アトリエ・エクレア

2DCG&3DCG, プログラミング, 日記などを掲載してます。

Vegas Pro

Vegas Pro

※Vegas Pro 13 Edit
旧バージョンなので注意。

覚書



<UI>

VegasPro13_UI_001.jpg



<メモ>

  • 編集作業中のデータは、[プロジェクト]と呼ぶ。
  • 編集中の状態は、[プロジェクトファイル] としてハードディスクに保存。
  • ビデオ、オーディオ、静止画像、テキスト、背景などは、[メディア] と呼ぶ。
  • タイムライン上に配置したメディアを、[イベント] と呼ぶ。※ビデオイベント、オーディオイベント、テキストイベント、背景イベントなど。
  • ビデオメディア(ビデオファイルと静止画像ファイル)は、ビデオトラック上に配置できる。※ビデオイベント
  • オーディオメディアは、オーディオトラック上に配置できる。※オーディオイベント
  • [エクスプローラ]ウィンドウで、フォルダ階層が表示されていない場合は、左端を右にドラッグして表示させる。
    ※(左上の)ウィンドウドッキングエリア
  • 音声の波形は、上:左チャンネル、下:右チャンネル
  • オーディオ ピークデータ ファイル (.sfk) に注意。
    ※ファイルを開いたときに、元のファイルと同じディレクトリに作成される。


<操作>

  • 操作を忘れたら、ツールバーにある[操作手順チュートリアル]ボタンで確認する
  • 簡単なタイムラインの表示操作
    • 横移動:  タイムルーラーをドラッグ (手のカーソルになる)
    • 拡大縮小:  マウスホイール回転 (カーソル位置基準)
  • プロジェクトの全期間をクイック選択するには(全期間のループリージョン指定)
    タイムライン(マーカーバーなど)をダブルクリック。
  • Space : 再生の開始 / 再生を停止(停止して元の位置に戻る)
  • Enter : 再生 / 一時停止
  • Q : ループ再生
  • Shift + Space : 最初から再生
  • Ctrl + Home : プロジェクトの最初に移動
  • Ctrl + End : プロジェクトの最後に移動
  • Alt + ← / → : 1フレーム左 / 右に移動
  • Ctrl + ← / → : 前または次のマーカーに移動
  • Ctrl + Shift + ↑ / ↓ : 全てのトラック(またはバストラック)の高さを増減
  • ↑ / ↓ : 少しずつ(※Ctrl併用で大きく)水平方向にズームイン / ズームアウト ※イベント
  • Ctrl + ` : トラックの高さをデフォルトの高さに設定する
  • M : マーカーの挿入
  • Sイベントをカーソル位置で分割
  • Ctrl + G : カーソルの移動


<プロジェクト設定>

ビデオ形式、オーディオ形式、タイムライン ルーラー形式、プロジェクトの情報などのプロジェクトのプロパティ設定

  • ツールバーにある、[プロパティ]ボタンを押して、[プロジェクト プロパティ]ダイアログボックスを表示し、各種設定をする。
  • ※メニューバー[ファイル] → [プロパティ]でも同じ。


<メディアのインポート>

複数の方法がある。※一部

  • <方法1>※一番いいかも
    [プロジェクトメディア]ウィンドウ(の右ペイン)に、ドラッグ&ドロップ※(左上の)ウィンドウドッキングエリア
    ※タイムラインに、イベントとして自動配置されない。
  • <方法2>
    ツールバーにある、[開く] ボタンを押す。→ 選択して取り込む。
    ※タイムラインに、イベントとして自動配置される。
  • <方法3>
    [プロジェクトメディア]ウィンドウの上部メニューにある、[メディアのインポート] ボタンを押す。→ 選択して取り込む。
    ※タイムラインに、イベントとして自動配置されない。
  • <方法4>
    [エクスプローラ]ウィンドウで、取り込みたいメディアを、ダブルクリックする。 ※タイムラインに、イベントとして自動配置される。
    (or [プロジェクトメディア]ウィンドウに ドラッグ&ドロップ。 ※イベントとして自動配置されない。)
    (or タイムラインに ドラッグ&ドロップ。 ※イベントとして配置ということ。)


<赤目軽減>

※静止画像

  1. [プロジェクト メディア]ウィンドウ(またはタイムライン)の静止画像を右クリック。→ [赤目軽減]  ※(左上の)ウィンドウドッキングエリア
  2. [赤目軽減]ダイアログボックスが開くので、目の赤い部分の周囲を、ドラッグして選択する。
    ※選択ボックス内の画像が自動的に調整され赤目が除去(軽減)される。
  3. 完了したら、[閉じる]ボタンをクリック。※[ビデオ プレビュー]ウィンドウで結果が確認できる。


<メディアのトリミング>

※ビデオイベント、オーディオイベント共通

  1. [プロジェクトメディア]ウィンドウには、プロジェクト内の全てのメディアが表示されている。 ※(左上の)ウィンドウドッキングエリア
    トリミングしたいメディアを探す。
  2. トリミングしたいメディアを右クリック → [トリマーで開く]    ※(中上の)ウィンドウ
  3. [トリマー]ウィンドウのタイムラインにて、使用するクリップの先頭にカーソルを置く。 → [イン ポイントの設定]ボタンを押す。
  4. [トリマー]ウィンドウのタイムラインにて、使用するクリップの最後にカーソルを置く。 → [アウト ポイントの設定]ボタンを押す。
  5. タイムライン(※[トリマー]ウィンドウではない)にて、イベントを追加する位置をクリックしてカーソルを置く。
  6. いずれかの方法で、タイムラインに、トリミングしたメディアを追加できる。
    • [カーソルの後にメディアを追加]ボタンをクリック。
    • [カーソルの前にメディアを追加]ボタンをクリック。
    • トリミングしたメディアを、[トリマー]ウィンドウから、タイムラインに直接ドラッグする。

[トリマー]ウィンドウのタイムライン上をドラッグすることで、もっと簡単にトリミングできる。



<イベントの追加>

※ビデオイベント、オーディオイベント共通

  1. [プロジェクトメディア]ウィンドウには、プロジェクト内の全てのメディアが表示されている。 ※(左上の)ウィンドウドッキングエリア
    追加したいメディアを探す。
  2. タイムラインにドラッグする。
    ※ビデオメディアはビデオトラックへ、オーディオメディアはオーディオトラックへ配置できる。


<テキスト>

  1. [メディアジェネレーター]ウィンドウを開く。 ※(左上の)ウィンドウドッキングエリア
  2. 左側に表示されているプラグインを、クリックして選択。※タイトルおよびテキスト、(旧)テキストなど
  3. 右側で、使用するテキストプリセットを選択し、ビデオトラックにドラッグ。 ※テキストイベント

※[ビデオ メディアジェネレータ]ウィンドウ([生成されたメディア]ボタン) で、カスタマイズできる。※右下のフィルムのようなボタン



<背景>

  1. [メディア ジェネレータ]ウィンドウを開く。 ※(左上の)ウィンドウドッキングエリア
  2. 左側に表示されているプラグインを、クリックして選択。※単色、ノイズ テクスチャなど
  3. 右側で、使用するテキストプリセットを選択し、ビデオトラックにドラッグ。 ※背景イベント

※[ビデオ メディアジェネレータ]ウィンドウ([生成されたメディア]ボタン) で、カスタマイズできる。※右下のフィルムのようなボタン



<フェード>

<フェード イン>  ※ビデオイベント、オーディオイベント共通

  1. マウスカーソルを、イベントの左上隅に置く。※扇のようなカーソルに変わり、フェードハンドルをドラッグできるようになる。
  2. 右にドラッグし、フェードインポイントを調整する。

<フェード アウト>  ※ビデオイベント、オーディオイベント共通

  1. マウスカーソルを、イベントの右上隅に置く。※扇のようなカーソルに変わり、フェードハンドルをドラッグできるようになる。
  2. 左にドラッグし、フェードアウトポイントを調整する。

<クロスフェード>  ※ビデオイベント、オーディオイベント共通

  1. イベントをドラッグして、別のイベントにオーバーラップさせる。※クロスフェード リージョン (オーバーラップ リージョン) の作成
  2. ドラッグにより、クロスフェードの長さを調整する。※オーバーラップ リージョンは、クロスフェードの長さを表す。
  3. クロスフェードのカーブを変更するには、右クリック → [フェードの種類]

※クロスフェード リージョンをダブルクリックすると、再生リージョンが、クロスフェードエリアのみになる。

<不透明度の調整>  ※ビデオイベント

  1. マウスカーソルを、イベントの上部に置く。※手のカーソルに変わり、不透明度を上下にドラッグできるようになる。
  2. 上下にドラッグし、不透明度を調整する。

<オーディオレベルの調整>  ※オーディオイベント

  1. マウスカーソルを、イベントの上部に置く。※手のカーソルに変わり、フェードレベルを上下にドラッグできるようになる。
  2. 上下にドラッグし、ボリュームを調整する。


<トランジション>

※ビデオイベント

  1. フェードエリア (クロスフェード、フェードイン/アウト) を作成する。※フェードの項参照
  2. [トランジション]ウィンドウの左側で、カテゴリを選択する。 ※(左上の)ウィンドウドッキングエリア
  3. [トランジション]ウィンドウの右側で、プリセットを選び、フェードエリアにドラッグ
  4. このとき表示される、[ビデオ イベント FX]ダイアログボックスで、トランジションのプロパティを調整できる。
    ※[トランジションのプロパティ]ボタン


<エフェクト>

<エフェクト>

・ビデオ エフェクト

  1. [ビデオ FX]ウィンドウの左側で、ビデオ エフェクト カテゴリをクリック。※(左上の)ウィンドウドッキングエリア
  2. 右側のプリセットを選択し、タイムラインにドラッグ
  3. このとき表示される、[ビデオ イベント FX]ダイアログボックスで、エフェクトを調整できる。※右下の、[イベントFX]ボタン
    最上部にあるボタンは、エフェクトチェーンを表す。
    チェックボックスのONでトラックに適用、OFFでバイパス。
    ボタンをクリックして、プラグインの設定を表示。
    プラグインのコントロールを調整して、必要な外観を得る。
  4. アニメーションボタンをクリックして、キーフレームアニメーション可能。

・オーディオ エフェクト

  1. トラックヘッダーの、[トラック FX]ボタンをクリックして、[オーディオ トラック FX]ウィンドウを開く。
  2. 最上部にあるボタンは、エフェクトチェーンを表す。
    チェックボックスのONでトラックに適用、OFFでバイパス。
    ボタンをクリックして、プラグインの設定を表示。
    プラグインのコントロールを調整して、必要なサウンドを得る。
  3. さらにエフェクトを追加するには、[プラグイン チェーン]ボタンをクリック。

<プロジェクト全体のエフェクト>

・プロジェクト全体の、ビデオ エフェクト

  1. [ビデオ FX]ウィンドウの左側で、ビデオ エフェクト カテゴリをクリック。※(左上の)ウィンドウドッキングエリア
  2. 右側のプリセットを選択し、[ビデオ プレビュー]ウィンドウ にドラッグ※右上
  3. このとき表示される、[ビデオ出力 FX]ダイアログボックスで、エフェクトを調整できる。※上の、[ビデオ出力 FX]ボタン
    最上部にあるボタンは、エフェクトチェーンを表す。
    チェックボックスのONでトラックに適用、OFFでバイパス。
    ボタンをクリックして、プラグインの設定を表示。
    プラグインのコントロールを調整して、必要な外観を得る。
  4. アニメーションボタンをクリックして、キーフレームアニメーション可能。

・プロジェクト全体の、オーディオ エフェクト

  1. [マスタ バス]ウィンドウの、[マスタ FX]ボタンをクリックして、[マスタ FX]ウィンドウを開く。※右上
  2. マスタ FX チェーンにプラグインがない場合は、[プラグイン チューザー]ダイアログボックスが表示されるので、プラグインを追加する。
  3. 最上部にあるボタンは、エフェクトチェーンを表す。
    チェックボックスのONでトラックに適用、OFFでバイパス。
    ボタンをクリックして、プラグインの設定を表示。
    プラグインのコントロールを調整して、必要なサウンドを得る。
  4. さらにエフェクトを追加するには、[プラグイン チェーン]ボタンをクリック。


<ビデオをプレビュー (エフェクト有/無)>

※ビデオ

エフェクト無しと、エフェクト有りのビデオを、同時に参照する方法。

  1. [ビデオ プレビュー]ウィンドウにて、いずれかの方法で、エフェクト無しの範囲を作成する。 ※右上
    • [分割画面ビュー]ドロップダウンメニューで、プリセットを選択。
    • [分割画面ビュー]ボタンをクリックしてから(カーソルが十字に変わる)、プレビューエリア内をドラッグ。
  2. [分割画面ビュー]ボタンをクリックすることで、ON / OFF できる。


<VST エフェクト>

※オーディオ

  1. メニューバーにある[オプション]メニュー → [ユーザー設定]     ※[ユーザー設定]ダイアログボックスが開く。
  2. [VST エフェクト]タブ → VSTプラグインのインストール先の指定、使用するプラグインの選択をする。


<オーディオの録音>

※オーディオ

  1. Windowsタスクバーにあるスピーカーアイコンを右クリック → [録音デバイス] → 録音デバイスを設定する。    ※Windows10
    ※Vegas起動後に設定した場合、録音アームが有効にならない場合があるので、その場合はVegasを再起動する。
  2. トラックヘッダーエリアを右クリック → [オーディオトラックの挿入]
  3. 録音の開始時間を設定するため、タイムラインをクリックしてカーソル位置を設定する。[
  4. トラックヘッダーの[録音アーム]ボタンをクリックして、トラックへの録音を有効にする。
  5. [プロジェクト録音ファイル フォルダ]ダイアログボックスが開くので、保存場所を指定する。
    ※プロジェクトプロパティのオーディオタブ内でも指定可能。
  6. タイムラインツールバー内、トランスポートコントロールの、[録音]ボタンをクリックで、録音開始。
  7. 再度 [録音]ボタン、または、[停止]ボタン をクリックで、録音終了。
  8. [録音アーム]ボタンをクリックして、録音を無効にする。終了。


<ビデオの、クロップ(切り抜き)、拡大縮小、回転、パン>

※ビデオ

<ビデオ イベントの、クロップ(切り抜き)、拡大縮小、回転、パン>

  1. ビデオイベント右下の、[イベント パン/クロップ]ボタンをクリックする。※ビデオイベント右下のボタン
    [ビデオ イベントFX]ウィンドウが表示される。
  2. イベントの現在のビューを表す、(Fと書かれた)点線の長方形が表示されている。
    この長方形を編集することで、ビデオの表示を変更できる。
    ※アニメーション設定が可能。

<トラック モーション>

  • トラックをモーションさせるには、トラックヘッダーにある [トラック モーション]ボタンを使用する。

※トラックモーションや、トラックモーションとビデオ イベントFX(イベントのクロップ、拡大縮小、回転、パン)の組み合わせ により、
ピクチャー・イン・ピクチャー エフェクト を作成できる。



<スローモーション / ファストモーション>

※ビデオとオーディオ

複数の方法がある。
以下は、その中の2つの方法だが、それぞれ特徴が異なるので、使い分けることになる。

<方法1> ベロシティ エンベローブ ※ビデオイベント
※イベントの長さが変わらないので、自分で調整する必要がある。細かい調整が可能。

  1. ビデオイベントを選択し、右クリック → [エンベローブの挿入/削除][ベロシティ]を選択。
  2. ベロシティ エンベローブが表示されるので、上下にドラッグして、速度を調整する。
    ※リセットする場合は、右クリック → [すべてリセット]

<方法2> タイムストレッチ ※ビデオイベントとオーディオイベント
※イベントの長さを変えるので、直観的だが、細かい調整に向かない。

  1. マウスカーソルを、Ctrlキーを押しながら、イベントの左右のエッジに置く。※波線付き左右矢印のカーソルに変わる。
  2. そのまま、エッジを左右にドラッグする。※ストレッチされたことを示す、ジグザグの線が表示される。

※オーディオイベントについて:

  • 処理品質は、[プロジェクト プロパティ]ダイアログボックス→ オーディオタブ → [リサンプリングとストレッチの品質] で設定。
  • ピッチを保持するかどうかは、[イベント プロパティ]ダイアログボックス(イベント右クリック)→ [タイムストレッチ / ピッチシフト] で設定。


<リバース>

※ビデオイベント、オーディオイベント共通

  • イベントを右クリック → [逆方向]  ※リバースされると、左端に矢印アイコンが表示される。


<イベントのトリミング>

※ビデオイベント、オーディオイベント共通

<イベントの右端をトリミング>
[アウト]ポイントの設定

  1. マウスカーソルをイベントの右端に置く。 ※左右の矢印のようなカーソルになる。
  2. そのまま左右にドラッグし、[アウト]ポイントを変更する。 ※長くすると(終了位置よりも後ろ)、ループになる。

<イベントの左端をトリミング>
[イン]ポイントの設定

  1. マウスカーソルをイベントの左端に置く。 ※左右の矢印のようなカーソルになる。
  2. そのまま左右にドラッグし、[イン]ポイントを変更する。 ※長くすると(開始位置よりも前)、ループになる。

<イベントのタイムストレッチ>
  1. マウスカーソルを、Ctrlキーを押しながら、イベントの左右のエッジに置く。※波線付き左右矢印のカーソルに変わる。
  2. そのまま、エッジを左右にドラッグする。※ストレッチされたことを示す、ジグザグの線が表示される。

※オーディオイベントについて:

  • 処理品質は、[プロジェクト プロパティ]ダイアログボックス→ オーディオタブ → [リサンプリングとストレッチの品質] で設定。
  • ピッチを保持するかどうかは、[イベント プロパティ]ダイアログボックス(イベント右クリック)→ [タイムストレッチ / ピッチシフト] で設定。

<イベントの分割>
  1. イベント内をクリックして、カーソルをイベント内に置く。
  2. [S]キーを押して、イベントを分割。
  3. 分割されたイベントで、不要なものは、[Delete]キーで削除。

<イベントのトリミング>

キーの組み合わせ 左トリム機能 イベントの中央 右トリム機能
なし [イン]ポイントを変更 (トリム) イベントの移動 [アウト]ポイントを変更 (トリム)
Ctrl イベントをタイムストレッチ イベントのコピーを作成 イベントをタイムストレッチ
Alt [イン]ポイントを固定 (スリップ トリム) イベントを移動せずに内容を移動 (スリップ) [アウト]ポイントを固定 (スリップ トリム)
Ctrl + Alt 2つのイベント間の編集ポイントをトリミング
(隣接トリム)
内容を移動せずにイベントを移動 (スライド) 2つのイベント間の編集ポイントをトリミング
(隣接トリム)

・分割 [S]キー



<ポスト編集リップル>

波及効果 / 連鎖反応 みたいなことを行う。
(例えば、イベントを削除したら後ろのイベントを自動で詰めたり、複数のトラックのイベントを一緒に移動させたりできる。)
やり方は複数あるが、簡単なのは、"ポスト編集リップルの自動適用" を行う方法。

  1. タイムラインツールバーにある、[自動リップル]ボタンを選択する(またはCtrl + L)。
  2. 自動リップルボタンの横にある下矢印をクリックし、リップルの種類を選択する。
  3. 以下のいずれかの編集を行う。
    ※タイムラインの上部に表示される矢印は、ポスト編集リップルの発生場所と、影響のあるイベントの移動方向を表す。
    • トリミング、スリップトリミング、スライド、"タイムストレッチによるイベントの長さの調整"
    • イベントの移動
    • イベントの切り取り
    • イベントの貼り付け
    • イベントの削除
  4. 選択したオプションに従って、編集後にタイムラインの内容がリップルされる。


<イベントのシャッフル>

リップル編集と同様に、1回の操作でイベントの順序を変更できる。

  1. イベントを右ドラッグ(※左ではない)で、別のイベントに重ねる。
  2. マウスカーソルが別イベント内の時に、ドラッグを終了すると、ショートカットメニューが表示される。
    ショートカットメニュー → [イベントのシャッフル] を選択する。


<マーカーの挿入>

マーカーとリージョンは、タイムライン上の参照ポイントとして機能し、タイムライン上のイベントを整列するのに役立つ。
また、DVD Architect Proは、それらのマーカーを、チャプターマーカーとして読み取ることができる。

  1. マーカーを挿入する位置に、カーソルを置く
  2. [M]キーで、カーソルの位置に、マーカー(マーカータグ)が挿入され、編集ボックスが表示される。  ※タイムラインツール バー
  3. マーカーの名前を入力し、[Enter]キーで確定する。


<リージョンの挿入>

マーカーとリージョンは、タイムライン上の参照ポイントとして機能し、タイムライン上のイベントを整列するのに役立つ。
また、DVD Architect Proは、それらのマーカーを、チャプターマーカーとして読み取ることができる。

  1. タイムラインをドラッグして、時間範囲を選択する。
  2. [R]キーで、選択範囲の先頭と最後に、リージョン(リージョンタグ)が挿入され、編集ボックスが表示される。  ※タイムラインツール バー
  3. リージョンの名前を入力し、[Enter]キーで確定する。


<レンダリング>

プロジェクトのレンダリング (名前をつけてレンダリング)をする方法。

Movie Studioの場合、[ムービーの書き出し]ボタンがあって、レンダリング後にDVD Architectに送信するか選択できるのだが、
Vegas Proにはその機能はない。
とりあえず、DVDやBlu-rayに書き出むかどうかに限らず、名前をつけてレンダリングを行う。

  1. タイムラインにて、始めと終わりの範囲指定(ループリージョン)をする。※ブランクスペースをダブルクリックが楽。
  2. いずれかの方法で、[名前をつけてレンダリング]ダイアログボックスを表示させる。
    • ツールバーの、[名前をつけてレンダリング]ボタン
    • メニューバーの[ファイル]メニュー → [名前をつけてレンダリング]
  3. 各項目を設定する。
    • 出力ファイル: ファイルの保存場所と、名前を指定する。
    • 出力形式: 作成するファイル形式を選択する。
    • レンダリング オプション:  [ループ リージョンのみレンダリング] にチェック。
    • メタデータ オプション:  後でDVDやBlu-rayに書き出して、チャプターメニュー用のチャプターマーカーとして使用する場合、
      [レンダリングされたメディア ファイルにプロジェクト マーカーを保存] にチェック。
  4. [レンダリング]ボタンをクリックして、レンダリングする。





Python

Python

<免責事項>
この記事は、管理人の個人的な覚書きのためのものです。
内容に間違いがあっても責任は負いません。

<環境>

Python 3.6.2
Visual Studio Code Version 1.16.0

Windows10 環境変数確認方法:
Windowsアイコンを右クリック → システム
→ 関連設定:システム情報(右にある) → システムの詳細設定(左にある) → 詳細設定タブ内の環境変数ボタン



<参考>



<Visual Studio Code エンコーディング>

  • ファイル → 基本設定 → 設定 → エンコーディングがutf8か確認(違うなら変更) → ユーザー設定を保存
"files.encoding": "utf8"


<Visual Studio Code 統合ターミナル>

<統合ターミナルの表示>

  • 表示(上部メニュー) → 統合ターミナル

<統合ターミナルでのコマンド実行>

PS C:\Users\ユーザー名\Desktop\SampleFolder> Python sample.py

※この例では、sample.pyファイルが、デスクトップの、SampleFolderフォルダーに入っている。
※実行したコマンドは、キーボードの↑(上矢印)キーで、再度呼び出し可能。



<ソースファイルの拡張子>

  • sample.py のように、「 .py 」を使う。


<基本>

  • インタプリタ言語。コンパイルやリンクが必要ない。
  • ソースコードは、デフォルトでは、UTF-8でエンコードされているものとして扱われる。
  • 大文字と小文字は別のものとして扱われる。
  • 改行が、文の区切り
  • 文字列リテラルは、ダブルクォーテーション( " ) または、シングルクォーテーション( ' ) で囲む。
    途中で改行する場合は、バックスラッシュ(\)を使用する。
    ※バックスラッシュ(\)の記述無しの、複数行にわたる文字列リテラルは、三重クォート(""" または''')で囲む。
  • Pythonにおいて、インデントは、実行文をグループにまとめる方法。※ブロック
  • Javaなどに存在する、インクリメント演算子(++)、デクリメント演算子(--)が無い。
  • 関数内で、グローバル変数への代入をする場合、global文が必要。
    ※global文が無いと、ローカル変数の定義になってしまう。
    ※自由変数がグローバル変数を参照するだけの場合、global文は必要ない。
    ※リスト, 辞書の要素への代入は、変数の定義に非ず、global文なしで可能。※タプルはそもそも代入不可。


<改行>

  • 改行が文の区切り。
  • ,(コンマ)の後に改行した場合は、一文として扱われる。
  • 文の途中で折り返す場合は、\ (バックスラッシュ) を使用する。
  • 文字列リテラルにおける、改行のエスケープシーケンスは、\n


<コメント>

  • 一行コメント(改行まで)は、#(ハッシュ文字)を使用する。
    ※#による一行コメントは、インデント無しでも使用できる。
  • コメントは基本的に、#によるコメント(一行コメント)を使用する。
  • コメントは、文字列リテラルの内部に置くことはできない。
    文字列リテラル中のハッシュ文字は、ただのハッシュ文字となる。
  • 複数行のコメントは、#による一行コメントを複数使うか、或いは、文字列リテラルで代用する。
  • 複数行のコメントを、文字列リテラルで代用する場合、
    """(ダブルクォーテーション3つ)、または '''(シングルクォーテーション3つ)で囲む。

    三重クォートの文字列リテラルは、バックスラッシュ(\)なしで、途中で改行ができる。
    → 改行やホワイトスペースなどが書いた通りに適用されるヒアドキュメントとなる。
    ※通常の文字列リテラルの場合、途中の改行には、一文とみなす為のバックスラッシュ(\)が必要。
    ※文字列リテラルによる代用なので、構文に沿ったインデントが必要。
# 一行コメント(改行まで)

""" 
複数行のコメント ※ヒアドキュメント
(文字列リテラルによる代用なので、構文に沿ったインデントが必要)
"""


<演算子>

※一部

<代入演算子>

  • = : 代入演算子 ※変数に値を代入

<算術演算子>

  • + : 加算、または、文字列の連結
  • - : 減算
  • * : 乗算、または、文字列の反復
  • / : 除算 ※常に浮動小数点数を返す。例)15/3なら5.0を返す
  • // : 一番近い小さい整数に丸める数学除算
    ※floor division 演算子。floor division を行い、(小数部を切り捨てて) 整数を返す。
    ※浮動小数点数について、小数点以下を切り捨てて0 にするには、int()関数が利用できる。
    丸めなし(特に負の値)で完全に切り捨てるところが、floor divisionと異なる。
  • ** : 冪演算(べきえんざん)。冪乗を計算。

<論理演算子>

  • and : 論理積 ※A and B は、AとBが共に真の場合に真となる。
  • or   : 論理和 ※A or B は、AかBのいずれかが真の場合に真となる。
  • not : 論理否定 ※not A は、aが真なら偽、偽なら真となる。


<数値と文字列の連結>

  • 数値と文字列は、単純に、+演算子で連結することができない。※Java等と違うので注意。
  • 最終的に文字列にする場合、数値を文字列に変換してから、文字列と結合する必要がある。
    ※数値を文字列に型変換するには、str()関数が使用できる。
  • 最終的に数値にする場合、文字列を数値に変換してから、数値と結合する必要がある。
    ※文字列を数値に型変換するには、int()関数やfloat()関数などが使用できる。
print("15" + str(32))  # str()を利用 ※結果(文字列):1532
print(int("15") + 32)  # int()を利用 ※結果(数値):47


<変数>

  • 半角アルファベットや数字、アンダースコア( _ )が使用可能。
  • 先頭が数字は不可。
  • 予約語は使用不可。
  • 変数は型を持たないので、型定義はしない。※データ自体が型を持つ。
  • 変数の定義と、初期値の代入を、同時に行う必要がある。
    ※初期値の代入は、組み込み定数 None の代入でも可能。
speed = 15                                     # 変数の定義
print("速さは、" + str(speed) + " m/sです。")  # 結果: 速さは、15 m/sです。


<入力と出力>

  • 画面に文字を出力するには、print()関数(組み込み関数の1つ)が使用できる。
  • print()関数は、キーワード引数 end を使うと、出力の末尾に改行文字を出力しないようにしたり、
    別の文字列を末尾に出力したりできる。
  • キーボードから入力を受け取るには、input()関数(組み込み関数の1つ)が使用できる。
    ※戻り値は、str型なので注意。
# print()で出力
speed = 15
print("速さは、" + str(speed) + " m/sです。")  # 結果: 速さは、15 m/sです。
# print()で出力  ※キーワード引数endを使用
for i in range(10):   # range()は、引数が1つの場合、0 ~ 引数-1 までの値を返す
    # キーワード引数end : 文字列の最後に、自動的に挿入される改行を、任意の文字に変更
    print(i, end = " ") # 結果: 0 1 2 3 4 5 6 7 8 9
# input()で入力  ※戻り値は、str型なので注意。
speed = input("速さを入力してください。")  # 引数で、表示文字列を指定できる。
print("速さは、" + speed + " m/sです。")  # 結果: 速さは、15 m/sです。  ※15を入力した。


<組み込み定数>

組み込み定数の例   ※他にもある

  • True : bool型の真値。
    Trueへの代入は不正で、SyntaxErrorを送出する。
  • False : bool型の偽値。
    Falseへの代入は不正で、SyntaxErrorを送出する。
  • None : 型 NoneType の唯一の値。
    Noneは、関数にデフォルト引数が渡されなかったときなどに、値の非存在を表すのに頻繁に用いられる。
    Noneへの代入は不正で、SyntaxErrorを送出する。


<条件分岐>

<if文>

num = int(input("整数を入力してください。"))

if num < 5:                # 条件式
    print('5未満です。')
elif num == 5:             # "elif" は、"else if" を短くしたもの
    print('5です。')
elif num < 10:
    print('5より大きく、10未満です。')
else:
    print('10以上です。')


<反復処理(ループ)>

<range()関数>

  • 組み込み関数 range() は、算術型の数列を生成する。
  • 指定した終端値は生成されるシーケンスには入らない。
  • range() が返すオブジェクトは、リストであるかのように振る舞うが、リストでは無い。
    これは、イテレートした時に望んだ数列の連続した要素を返すオブジェクトである。
    しかし実際にリストを作るわけではないので、スペースの節約になる。
    このようなオブジェクトは イテラブル (iterable) と呼ばれる。
  • list()関数は、イテラブルからリストを生成する。
print(list(range(7)))   # 結果: [0, 1, 2, 3, 4, 5, 6]

<for文>

<リストの利用>

dogs = ["ポチ", "ハチ", "ゴン太"]  # リストを作成
for dog in dogs:                  # for文で、リストを利用
    print(dog, end = " ")         # 結果: ポチ ハチ ゴン太

<組み込み関数range()の利用>

  • range()は、引数が1つの場合、0(start)≦値<引数(stop) (0 ~ 引数-1)  の整数のイテレータを返す。
    値はループごとに1ずつ増加。
    ※引数が1つの場合、startの値は0となり(デフォルト)、step(増減量)の値は1となる(デフォルト)。
    → 結果的に、引数の値は、生成される値の個数と等しくなる。引数が0以下の場合、中の処理は実行されない
for i in range(10):   # range()は、引数が1つの場合、0 ~ 引数-1 までの値を返す
    # キーワード引数end : 文字列の最後に、自動的に挿入される改行を、任意の文字に変更
    print(i, end = " ") # 結果: 0 1 2 3 4 5 6 7 8 9
  • range()は、引数が2つの場合、第一引数(start)≦値<第二引数(stop)   (第一引数 ~ 第二引数-1) の整数のイテレータを返す。
    値はループごとに1ずつ増加。
    ※第二引数から1を引いた数までなので注意。
for i in range(3, 10):   # range()は、引数が2つの場合、第一引数(ループ開始値) ~ 第二引数-1(ループ終了値) までの値を返す
    print(i, end = " ")    # 結果: 3 4 5 6 7 8 9  ※10は入らないので注意
  • range()は、引数が3つの場合、第三引数は、正だけでなく、負の整数も指定できる。
    • <第三引数が正の場合>
      第三引数(step)の増減量で、第一引数(start)≦値<第二引数(stop) (第一引数 ~ 第二引数-1) の整数のイテレータを返す。
      第二引数-1までとなる。
    • <第三引数が負の場合>
      第三引数(step)
      の増減量で、第一引数(start)≧値>第二引数(stop) (第一引数 ~ 第二引数+1) の整数のイテレータを返す。
      第二引数+1までとなる。
for i in range(3, 10, 2):   # range()は、引数が3つの場合、第三引数(増減量)の増減量で、
                            # 第一引数(ループ開始値) ~ 第二引数-1(ループ終了値) までの値を返す。
    print(i, end = " ")       # 結果: 3 5 7 9

<while文>

  • 条件式が真なら、処理を繰り返す。
num = 0
while num < 10:            # 条件式
    print(num, end = " ")    # 結果: 0 1 2 3 4 5 6 7 8 9
    num += 1

<break文>

  • 最も内側のfor、または、whileループを中断する。
for i in range(3, 10):
    if i > 7:
        break           # 最も内側のfor文を抜ける
    print(i, end = " ")   # 結果: 3 4 5 6 7

<continue文>

  • ループにおける、次のイテレーション(反復)を実行する。
    → 現在のループを中断し、次のループへ移る。
for i in range(3, 10):
    if i == 7:
        continue        # 現在のループを中断し、次のループへ移る
    print(i, end = " ")   # 結果: 3 4 5 6 8 9  ※7は出力されない

<ループの、else節>

  • ループ文は、else節を持つことができる。
  • for文では、反復処理対象のリストを使い切ってループが終了したとき実行される。
    但し、break文でループが終了したときは実行されない。
  • while文では、条件が偽になったときに実行される。
    但し、break文でループが終了したときは実行されない。
for i in range(3, 10):
    if i == 10:
        break
    print(i, end = " ")
else:
    print("\n", end = "")
    print(i)
    print("ループが中断されずに、最後まで実行されました。")

# 結果:
# 3 4 5 6 7 8 9
# 9
# ループが中断されずに、最後まで実行されました。


<イミュータブル と ミュータブル>

イミュータブル(immutable)型 (:不変型)

  • イミュータブルなオブジェクトとは、作成後にその状態を変えることのできないオブジェクトのこと。
  • 固定の値を持ったオブジェクト。
  • イミュータブルなオブジェクトには、数値、文字列、およびタプルなどがある。
    これらのオブジェクトは値を変えられない。
  • 別の値を記憶させる際には、新たなオブジェクトを作成しなければならない。
  • 固定のハッシュ値が必要となる状況で重要な役割を果たす。※辞書のキーなど
  • int, float, str, tuple など

ミュータブル(mutable)型 (:可変型)

  • ミュータブルなオブジェクトとは、作成後も状態を変えることができるオブジェクトのこと。
  • ミュータブルなオブジェクトは、 識別値を変えることなく、値を変更できる。
    ※識別値を調べるには、id()関数が使える。id(object) : オブジェクトの“識別値”を返す。
  • list, dictionary, set など


<文字列型 (string)>

  • 文字列は単引用符(')、または、二重引用符(")で囲み、結果はどちらも同じ文字列になる。
    引用符をエスケープするには、\ を使う。
  • 文字列リテラルは複数行にまたがって書ける。
    1つの方法は三連引用符("""や''')を使うこと(三重クォート文字列)。
    行末は自動的に文字列に含まれるが、行末に \ を付けることで含めないようにすることもできる。
  • 文字列は、+演算子で連結させることができ、*演算子で反復させることができる。
  • 連続して並んでいる複数の文字列リテラルは自動的に連結される。
    リテラルどうしに対してのみ働き、変数や式には働かない。
    変数どうしや変数とリテラルを連結したい場合は、+演算子を使う。
  • 文字列は インデクス表記(添字表記)することができ、最初の文字のインデクスは 0 になる。
    文字列型と区別された文字型は無い。文字というのは単なる長さが 1 の文字列。
  • Python の文字列は変更できない。つまり不変(immutable)。
    従って、文字列のインデクスで指定したある場所に代入を行うとエラーが発生する。
    元の文字列と別の文字列が必要な場合は、新しく文字列を作成する。
  • 組込み関数len()は文字列の長さを返す。
# 文字列は単引用符(')、もしくは二重引用符(")で囲む
word = "Hello"
print(word)      # 結果: Hello

# 文字列は インデクス表記(添字表記)が可能  ※0が最初の文字
print(word[0])      # 結果: H

# インデクスに負の数を指定した場合は右から数える  ※-1が最後の文字
# -0 は 0 と等しいので、負のインデクスは -1 から始まる
print(word[-1])     # 結果: o

# 文字列は変更できない(不変:immutable)
# word[3] = "a"     # インデクスで指定した場所に代入は、エラー

# スライスで、部分文字列を取得することができる
# スライスのインデクスにはデフォルト値がある;
#   最初のインデクスを省略すると、0とみなされる。
#   第2のインデクスを省略すると、文字列のサイズとみなされる。
word = word[0:2]    # 位置 0(included) から 2(excluded)までの文字列
print(word)         # 結果: He

# 文字列は + 演算子で連結、* 演算子で反復できる
word += "l" * 2 + "o, World!"
print(word)         # 結果: Hello, World!

# 組込み関数 len() は文字列の長さを返す
val = len(word)
print(val)          # 結果: 13

<文字列メソッド>

文字列は 共通のシーケンス演算全てに加え、以下のメソッドを実装する。※一部

  • str.find(sub[, start[, end]])
    文字列のスライス s[start:end] に部分文字列subが含まれる場合、その最小のインデックスを返す。
    オプション引数 start および end はスライス表記と同様に解釈される。
    subが見つからなかった場合 -1 を返す。
    ※find()メソッドは、subの位置を知りたいときにのみ使う。
    subが部分文字列であるかどうかのみを調べるには、in演算子を使う:
print("World" in "Hello, World!") # 結果:  True
  • str.index(sub[, start[, end]])
    find()と同様だが、部分文字列が見つからなかったとき、ValueErrorを送出する。
  • str.replace(old, new[, count])
    文字列をコピーし、現れる部分文字列old全てをnewに置換して返す。
    オプション引数countが与えられている場合、先頭からcount個のoldだけを置換する。
  • str.split(sep=None, maxsplit=-1)
    文字列を、sepをデリミタ文字列として区切った単語のリストを返す。
    maxsplitが与えられていれば、最大でmaxsplit回分割される(つまり、リストは最大 maxsplit+1 要素になる)。
    maxsplitが与えられないか-1なら、分割の回数に制限はない(可能なだけ分割される)。
    sepが与えられた場合、連続した区切り文字はまとめられず、空の文字列を区切っていると判断される(例えば '1,,2'.split(',') は ['1', '', '2'] を返す)。
    引数sepは複数の文字にもできる(例えば '1<>2<>3'.split('<>') は ['1', '2', '3'] を返す)。
    区切り文字を指定して空の文字列を分割すると、['']を返す。
    sepが指定されていないかNoneの場合、異なる分割アルゴリズムが適用される。
    連続する空白文字はひとつのデリミタとみなされる。
    また、文字列の先頭や末尾に空白があっても、結果の最初や最後に空文字列は含まれない。
    よって、空文字列や空白だけの文字列をNoneデリミタで分割すると、[]が返される。
val = "Hello, World!\n".split("\n")
print(val)      # 結果: ['Hello, World!', '']
  • str.splitlines([keepends])
    文字列を改行部分で分解し、各行からなるリストを返す。
    keependsに真が与えらない限り、返されるリストに改行は含まれない。
    split()とは違って、デリミタ文字列sepが与えられたとき、このメソッドは空文字列に空リストを返し、終末の改行は結果に行を追加しない。
val = "Hello, World!\n".splitlines()
print(val)      # 結果: ['Hello, World!']
  • str.startswith(prefix[, start[, end]])
    文字列が指定されたprefixで始まるならTrueを、そうでなければFalseを返す。
    prefixは見つけたい複数の接頭語のタプルでも構わない。
    オプションのstartがあれば、その位置から判定を始める。
    オプションのendがあれば、その位置で比較を止める。
  • str.strip([chars])
    文字列の先頭および末尾部分を除去したコピーを返す。
    引数charsは除去される文字集合を指定する文字列。
    charsが省略されるかNoneの場合、空白文字が除去される。
    chars文字列は接頭語でも接尾語でもなく、そこに含まれる文字の組み合わせ全てがはぎ取られる。
    文字列の最も外側の先頭および末尾から、引数 chars 値がはぎ取られる。
    文字列の先頭からcharsの文字集合に含まれない文字に達するまで、文字が削除される。
    文字列の末尾に対しても同様の操作が行われる。
val = "www.example.com".strip("cmowz.")
print(val)      # 結果: "example"
  • str.zfill(width)
    長さが width になるよう ASCII '0' で左詰めした文字列のコピーを返す。
    先頭が符号接頭辞 ('+'/'-') だった場合、'0' は符号の前ではなく、後に挿入される。
    widthが、len(s)以下の場合元の文字列を返す。


<リスト型 (list)>

  • リストは変更可能 (mutable) で、要素はたいてい同じ型のオブジェクトであり、たいていイテレートによってアクセスする
  • リストはミュータブルなシーケンスで、一般的に同種の項目の集まりを格納するために使われる。
  • 異なる型の要素を含むこともあるが、通常は全ての要素は同じ型を持つ。
  • 他の言語で言う配列(array)と似たようなもの。
    ※Javaにおける配列とListを一緒にしたような感じ・・・。
  • 角括弧の対を使い、空のリストを表す: []
  • 角括弧を使い、項目をカンマで区切る: [a]、[a, b, c]
  • リスト内包表記を使う: [x for x in iterable]
  • 型コンストラクタを使う: list() または list(iterable)
  • リストを作る方法は、他にも組み込み関数 sorted() などいろいろある。
numbers = [1, 4, 9, 16, 25]         # リスト(オブジェクト)を作成
for i in range(len(numbers)):       # len()は、リストの長さ(要素数)を返す
    print(numbers[i], end = " ")    # 結果: 1 4 9 16 25
numbers = [1, 4, 9, 16, 25]     # リストを作成
for i in numbers:               # カウンタ変数iには、リストの要素が入る
    print(i, end = " ")         # 結果: 1 4 9 16 25

<リストオブジェクトのメソッド>

  • list.append(x) : リストの末尾に要素を一つ追加する。a[len(a):] = [x] と等価。
  • list.extend(iterable) : iterableの全ての要素を対象のリストに追加し、リストを拡張する。a[len(a):] = iterable と等価。
  • list.insert(i, x) : 指定した位置に要素を挿入する。
    第一引数は、リストのindexで、そのindexを持つ要素の直前に挿入される。
    a.insert(0, x) はリストの先頭に挿入を行う。
    a.insert(len(a), x) は a.append(x) と等価。
  • list.remove(x) : リスト中で、値xを持つ最初の要素を削除する。該当する項目がなければエラーとなる。
  • list.pop([i]) : リスト中の指定された位置にある要素をリストから削除して、その要素を返す。
    indexが指定されなければ、 a.pop() はリストの末尾の要素を削除して返す。
    この場合も要素は削除される。
  • list.clear() : リスト中の全ての要素を削除する。del a[:] と等価。
  • list.index(x[, start[, end]]) : リスト中で、値xを持つ最初の要素の位置をゼロから始まる添字で返す。
    該当する要素がなければ、ValueError を送出する。
    任意の引数である startとendはスライス記法として解釈され、リストの探索範囲を指定できる。
    返される添字は、start引数からの相対位置ではなく、リスト全体の先頭からの位置になる。
  • list.count(x) : リストでの、xの出現回数を返す。
  • list.sort(key=None, reverse=False) : リストの項目を、インプレース演算 (in place、元のデータを演算結果で置き換えるやりかた) でソートする。
    引数はソート方法のカスタマイズに使える。
  • list.reverse() : リストの要素を、インプレース演算で逆順にする。
  • list.copy() : リストの浅い(shallow)コピーを返す。a[:] と等価。

<多次元リスト>

# 多次元リスト ※例) 二次元リスト
list2D = [[ 1, 2, 3, 4, 5],
          [ 6, 7, 8, 9,10],
          [11,12,13,14,15]]

x = 3
y = 2

# 変数の複数同時の代入:
# タプルのパック(右辺が1つのタプルになる)と、
# シーケンスのアンパック(左辺にアンパックされる)を組み合わせたもの
# x, y = 3, 2         # 右辺:リストやタプルなど、全てのシーケンス型を使うことができる

val = list2D[y][x]  # 要素の値を取り出す。※添え字の指定順に気を付ける。
print(val)          # 結果: 14


<タプル型 (tuple)>

  • タプルは不変型 (immutable) で、複数の型の要素からなることもあり、
    要素はアンパック操作やインデックス (あるいは namedtuples の場合は属性)でアクセスすることが多い。
  • タプルはイミュータブルなシーケンスで、一般的に異種のデータの集まりを格納するために使われる。
  • タプルはまた、同種のデータのイミュータブルなシーケンスが必要な場合
    (set インスタンスや dict インスタンスに保存できるようにするためなど) にも使われる。
  • タプルを作るのはカンマであり、丸括弧ではない。
    丸括弧は省略可能だが、空のタプルの場合や構文上の曖昧さを避けるのに必要な時は例外。
  • 丸括弧の対を使い、空のタプルを表す: ()
  • カンマを使い、単要素のタプルを表す: a, または (a,)
  • 項目をカンマで区切る: a, b, c または (a, b, c)
  • 組み込みの tuple() を使う: tuple() または tuple(iterable)
numbers = (1, 4, 9, 16, 25)         # タプル(オブジェクト)を作成
for i in range(len(numbers)):       # len()は、タプルの長さ(要素数)を返す
    # numbers[i] = 30               # リストと異なり、タプルでは、要素の値の変更は不可
    print(numbers[i], end = " ")    # 結果: 1 4 9 16 25
numbers = (1, 4, 9, 16, 25)     # タプルを作成
for i in numbers:               # カウンタ変数iには、タプルの要素が入る
    print(i, end = " ")         # 結果: 1 4 9 16 25


<辞書型 (dictionary)>

  • 任意のキーを、値に対応付ける連想配列。
  • ある範囲の数でインデクス化されているシーケンスと異なり、辞書は キー (key) でインデクス化されている。
    ※キーは何らかの変更不能な型。
  • 文字列、数値は常にキーにすることができる。
  • タプルは、文字列、数値、その他のタプルのみを含む場合はキーにすることができる。
    直接、あるいは間接的に変更可能なオブジェクトを含むタプルはキーにできない。
  • 辞書は、順序付けのされていない キー(key): 値(value) のペアの集合であり、キーが (辞書の中で)一意でければならない
  • 辞書での主な操作は、ある値を何らかのキーを付けて記憶することと、キーを指定して値を取り出すこと。
  • 波括弧 (brace) のペア: {} は空の辞書を生成。
  • カンマで区切られた key: value のペアを波括弧ペアの間に入れると、辞書の初期値となる key: value が追加される。
  • del で key: value のペアを削除できる。
  • すでに使われているキーを使って値を記憶すると、以前そのキーに関連づけられていた値は失われる。
  • 存在しないキーを使って値を取り出そうとするとエラーになる。
  • 辞書オブジェクトに list(d.keys()) を実行すると、辞書で使われている全てのキーからなるリストを適当な順番で返す。
    ソートされたリストが欲しい場合は、代わりに sorted(d.keys()) を使う。
  • ある単一のキーが辞書にあるかどうか調べるには、 in キーワードを使う。
petName = {"dog": "ポチ", "cat": "タマ"}    # 辞書(オブジェクト)の作成

# キーを指定して、値を取り出す
val = petName["dog"]
print(val)                  # 結果: ポチ
val = petName["cat"]
print(val)                  # 結果: タマ

# キーを指定して、値を書き換え
petName["dog"] = "ハチ"
val = petName["dog"]
print(val)                  # 結果: ハチ
  • ループで利用する場合
petName = {'dog': 'ポチ', 'cat': 'タマ'}    # 辞書オブジェクトの作成

# ループ
for k, v in petName.items():    # items()メソッドで、キーと値を、同時に取り出せる
    print(k, v)

# 結果:
# dog ポチ
# cat タマ


<ユーザー定義関数>

  • def キーワードで、関数を定義する。
  • def の後に、関数名と仮引数を丸括弧で囲んだリストを続ける。
    ※仮引数が無い場合は、丸括弧のみを記述。
  • 関数の実体を構成する実行文は、次の行から始め、インデントが必要。
  • 関数の定義は、呼び出し処理の前(※実行順の意)に行う必要がある。
  • 戻り値がある場合は、return文を使用
  • 関数の中で変数を定義すると、ローカル変数となる。
    ※ローカル変数のスコープは、その定義された関数内(定義した場所から)。
  • グローバル変数と同じ名前のローカル変数を定義可能。別の変数として扱われる。
  • 関数内で、グローバル変数への代入をする場合、global文が必要。
    ※global文が無いと、ローカル変数の定義になってしまう。
    ※自由変数がグローバル変数を参照するだけの場合、global文は必要ない。
    ※リスト, 辞書の要素への代入は、変数の定義に非ず、global文なしで可能。※タプルはそもそも代入不可。

<ローカル変数, グローバル変数, 自由変数>

  • ローカル変数 (local variable) :  ある名前(識別子)が、ブロック内で束縛されているなら、
    nonlocal や global として宣言されていない限り、それはそのブロックのローカル変数
  • グローバル変数 (global variable) :  ある名前(識別子)が、モジュールレベルで束縛されているなら、その名前はグローバル変数
  • 自由変数 (free variable) :  ある変数が、あるコードブロック内で使われていて、そのブロックで定義はされていないなら、それは自由変数

<ユーザー定義関数> 戻り値なし

# 関数の定義
def myfunc(name):
    print("Hello, " + name + "!")

# 関数の呼び出し
myfunc("World")   # 結果: Hello, World!

<ユーザー定義関数> 戻り値あり

# 関数の定義
def myfunc():
    name = "World"
    return name     # 戻り値がある場合は、return文を使用
    
# 関数の呼び出し
print("Hello, " + myfunc() + "!")   # 結果: Hello, World!

<global文>

  • global文は、現在のコードブロック全体で維持される宣言文。
  • 列挙した識別子をグローバル変数として解釈するよう指定する。※複数の場合、コンマで区切って列挙する。
  • globalを使わずにグローバル変数に代入を行うことは不可能だが(ローカル変数の定義になってしまうため)、
    自由変数を使えば、その変数をグローバルであると宣言せずにグローバル変数を参照することができる。
  • リスト, 辞書の要素への代入は、変数の定義に非ず、global文なしで可能。※タプルはそもそも代入不可。
# グローバル変数
x = 20
y = 30

# 関数の定義
def myAdd(Z):   # 仮引数zはローカル変数
    global x    # 変数xをグローバル変数として解釈するよう宣言
    x = 75      # グローバル変数xへの代入 ※global文を使用しないと、ローカル変数の定義になってしまう
    return x + Z
    
# 関数の呼び出し
print(myAdd(y))     # 結果: 105

# グローバル変数xを出力
print(x)            # 結果: 75
# グローバル変数
x = 20
y = 30

# 関数の定義
def myAdd(Z):   # 仮引数zはローカル変数
    x = 75      # ローカル変数xの定義 ※グローバル変数xとは、別の変数となる
    return x + Z
    
# 関数の呼び出し
print(myAdd(y))     # 結果: 105

# グローバル変数xを出力
print(x)            # 結果: 20
# グローバル変数
x = 20
y = 30

# 関数の定義
def myAdd(Z):       # 仮引数zはローカル変数
    return x + Z    # x: 自由変数が、グローバル変数を参照するだけなら、global文は必須ではない
    
# 関数の呼び出し
print(myAdd(y))     # 結果: 50

# グローバル変数xを出力
print(x)            # 結果: 20


<関数における、引数のデフォルト値>

  • 関数の定義時に、引数(仮引数)に、デフォルト値を設定できる。※デフォルト引数
  • 仮引数にデフォルト値が指定されている場合、関数呼び出しでの実引数の指定が省略できる。
  • デフォルト引数(default argument)は、非デフォルト引数(non-default argument)の後に指定しなければならない。
def calcTriangleArea(base, height = 10):    # 引数heightにデフォルト値を指定(デフォルト引数)
    area = base * height / 2
    return area

# 引数ひとつだけで関数呼び出し ※仮引数baseに代入される
print(calcTriangleArea(20))         # 結果: 100.0

# 引数ふたつで関数呼び出し ※指定した実引数が、仮引数のデフォルト値よりも優先される
print(calcTriangleArea(20, 50))     # 結果: 500.0


<関数呼び出しにおける、キーワード引数>

  • 関数呼び出し時にキーワード引数を用いると、関数の仮引数から指定したキーワードを探し、値を割り当てることができる。
  • 名前付き引数を使用する。
  • 引数の指定は、順不同で良くなる。
  • 必要な引数にのみ値を渡す。
def calcTriangleArea(base, height):
    area = base * height / 2
    return area

# 通常(キーワード引数なし)の関数呼び出し ※基本的に左から順番に、実引数が仮引数に代入されていく
print(calcTriangleArea(10, 20))                     # 結果: 100.0

# キーワード引数を利用した関数呼び出し   ※実引数の指定が、順不同となる
print(calcTriangleArea(height = 40, base = 70))     # 結果: 1400.0

# キーワード引数を利用した関数呼び出し   ※位置引数(positional argument、固定引数)と、キーワード引数(keyword argument)の混在
print(calcTriangleArea(30, height = 50))            # 結果: 750.0

# ※※※これはエラーとなる※※※
# キーワード引数を利用した関数呼び出し   ※位置引数は、キーワード引数の前に指定する必要がある
#print(calcTriangleArea(height = 80, 60))           # 結果: SyntaxError: positional argument follows keyword argument


<ラムダ式 (lambda)>

  • 無名のインライン関数で、関数が呼び出されたときに評価される1つの式(expression)を含む。
  • ラムダ関数を作る構文は lambda [arguments]: expression である。
    ※expressionには、関数の指定も可能。
  • キーワード lambda を使うと、名前のない小さな関数を生成できる。
  • ラムダ式の関数は、関数オブジェクトが要求されている場所にならどこでも使うことができる。
  • ラムダ式は、構文上単一の式に制限されている。
  • 意味付け的には、ラムダ形式は単に通常の関数定義に構文的な糖衣をかぶせたものに過ぎない。
  • 入れ子構造になった関数定義と同様、ラムダ式もそれを取り囲むスコープから変数を参照することができる。
  • (ラムダ式自体は、関数名みたいな感じで使用できる、と覚えておくと良いかもしれない。)
# ラムダ式の部分(lambda x, y: x + y)が関数(関数名)で、(7, 9)の部分が引数の指定と関数呼び出しの形式。
result = (lambda x, y: x + y)(7, 9) # ラムダ式の引数xに7、ラムダ式の引数yに9が代入される
print(result)              # 結果: 16

# 以下のやり方でも、出力結果は同じ
f = lambda x, y: x + y     # ラムダ式を変数に代入 ※標準の関数でも、変数への代入は可能
result = f(7, 9)           # 関数呼び出し ※ラムダ式が呼び出される。
print(result)              # 結果: 16
def add(a, b):
    return a + b

# (lambda x, y: add(x, y))の部分が関数(ラムダ式)で、(7, 9)の部分が引数の指定と関数呼び出しに相当。
result = (lambda x, y: add(x, y))(7, 9) # ラムダ式に、関数を設定 ※ラムダ式の引数xに7、ラムダ式の引数yに9が代入される
print(result)              # 結果: 16

# 以下のやり方でも、出力結果は同じ
f = lambda x, y: add(x, y) # ラムダ式を変数に代入 ※標準の関数でも、変数への代入は可能
result = f(7, 9)           # 関数呼び出し ※ラムダ式が呼び出され、その中でさらにadd()関数が呼び出される。
print(result)              # 結果: 16


<クラス>

  • クラス(class)は、ユーザー定義オブジェクトを作成するためのテンプレート。
    クラス定義は普通、そのクラスのインスタンス上の操作をするメソッドの定義を含む。
  • クラスが __init__() メソッドを定義している場合、クラスのインスタンスを生成すると、
    新しく生成されたクラスインスタンスに対して自動的に __init__() を呼び出す。※コンストラクタ
  • 属性の名前には二種類(データ属性およびメソッド)ある。
    • データ属性 (data attribute): Smalltalkの“インスタンス変数”や C++の“データメンバ” に相当。
    • メソッド (method): クラス本体の中で定義された関数。
      そのクラスのインスタンスの属性として呼び出された場合、
      メソッドはインスタンスオブジェクトを第一引数 (argument) として受け取る (この第一引数は通常 self と呼ばれる)。
      (Pythonでは、メソッドという用語はクラスインスタンスだけのものではなく、
      オブジェクト型にもメソッドを持つことができる。※リストオブジェクトなど。)
  • メソッドの最初の引数を self と呼ぶが、この名前付けは単なる慣習でしかない。
    self という名前は、Pythonでは何ら特殊な意味を持たないが、
    この慣行に従わないと、コードは他の Pythonプログラマにとってやや読みにくいものとなる。
  • クラス変数は、全てのインスタンスで共有される。
  • インスタンス変数は、それぞれのインスタンス毎にユニーク。
# クラス定義
class MyPet:
    kind = "猫"                       # クラス変数(class variable)は、全てのインスタンスで共有される

    # 初期化   ※クラスのインスタンスを生成すると、新しく生成されたクラスインスタンスに対して自動的に __init__() を呼び出す
    def __init__(self, name):         # インスタンスオブジェクトを第一引数として受け取る
        self.name = name              # インスタンス変数(instance variable)は、それぞれのインスタンス毎にユニーク

    # メソッド
    def favourite_food(self):
        food = ""                     # foodは、このメソッドのローカル変数であり、別のメソッドから利用できない
        if self.name == "タマ":       # インスタンス変数を利用
            food = "生クリーム"
        elif self.name == "トム":
            food = "アイスクリーム"
        mystr = self.name + "の好物は、" + food  # mystrは、このメソッドのローカル変数であり、別のメソッドから利用できない
        return mystr

# クラスのインスタンス化(instantiation) ※関数のような表記法を使う。
# クラスの新しいインスタンス(instance)を生成し、そのオブジェクトを変数へ代入
pet1 = MyPet("タマ")
pet2 = MyPet("トム")

# 属性参照 =======================================================
# クラス変数は、全てのインスタンスで共有される
print(pet1.kind)                # 結果: 猫
print(pet2.kind)                # 結果: 猫

# インスタンス変数は、それぞれのインスタンス毎にユニーク
print(pet1.name)                # 結果: タマ
print(pet2.name)                # 結果: トム

# メソッド呼び出し
print(pet1.favourite_food())    # 結果: タマの好物は、生クリーム
print(pet2.favourite_food())    # 結果: トムの好物は、アイスクリーム


<派生クラス>

  • 基底クラス(base class)を派生(拡張)して、派生クラス(derived class)をつくることができる。
    このとき、既存のクラスの属性を新規に作成したクラスに引き継がせることができる。これを継承とよぶ。
  • 派生クラスは基底クラスのメソッドを上書き(override)することができる。
  • 派生クラス名.メソッド名()の呼び出しでは、基底クラスの同名のメソッド(コンストラクタを含む)は呼び出されない。
    クラスの中でオーバーライドされた継承メソッドにアクセスするには、親クラス(基底クラス)を参照可能なsuper()関数が利用できる。
    ※または次の方法もある。
  • 基底クラスのメソッドを直接呼び出す方法: BaseClassName.methodname(self, arguments)
# 基底クラス (base class) の定義
class Base:
    def __init__(self):
        self.x = 20         # インスタンス変数(データ属性)
        print("Base")
    def baseMethod(self):
        return "基底クラス"

# 派生クラス (derived class) の定義
class Sub(Base):
    def __init__(self):
        super().__init__()   # クラス内で、基底クラスの(派生クラスと名前が重複する)メソッドを呼び出すには、super()を利用
        #Base.__init__(self) # これでも可能
        print("Sub")
        print(self.x)        # super()を使って基底クラスを初期化しておかないと、エラー
    def subMethod1(self):
        return "派生クラス"
    def subMethod2(self):
        baseStr_UseSuper = super().baseMethod() # 基底クラスのメソッド呼び出し ※super()を利用する場合
        baseStr_NonuseSuper = self.baseMethod() # 同クラス内(基底クラスから継承)のメソッド呼び出し ※super()を利用しない場合
        subStr = self.subMethod1()      # 同クラス内(派生クラス)のメソッド呼び出し
        print(baseStr_UseSuper + ", " + baseStr_NonuseSuper + ", " + subStr)
        
# ===============================================================================================
sub = Sub() # 結果:
            # Base
            # Sub
            # 20
val = sub.baseMethod()
print(val)              # 結果: 基底クラス
val = sub.subMethod1()
print(val)              # 結果: 派生クラス

sub.subMethod2()        # 結果: 基底クラス, 基底クラス, 派生クラス


<モジュールのインポート>

  • インポート方法は複数ある。
import tkinter         # tkinterモジュールをインポート
import tkinter as tk   # tkinterモジュールをインポート ※tkとして扱える
  • 以下は、アンダースコア (_) で始まるものを除いてすべての名前をインポートする。
  • 未知の名前がインタープリターに読み込まれ、定義済みの名前を上書きしてしまう可能性があるのであまりよくない。
from tkinter import *  # tkinterモジュールから全ての名前をインポート


<乱数>

  • 擬似乱数を生成するには、randomモジュールをインポートする。
import random

# 整数用の関数 =================================================================
# random.randrange(stop)  ※0 <= 整数値 < stop
rdm1 = random.randrange(10)
print(rdm1)     # 0  整数値 < 10  ※0から9(含む)までのいずれかの整数

# random.randrange(start, stop[, step])  ※start <= (stepによる)整数値 < stop  逆転もあるので注意
rdm2 = random.randrange(2, 10, 2)
print(rdm2)     # 2 ≦ 整数値(ステップ2) < 10   ※2,4,6,8のいずれかの整数

# random.randint(a, b)  ※a <= 整数値 <= b  ※randrange(a, b+1) のエイリアス
rdm3 = random.randint(2, 10)    # a > b だとエラー
print(rdm3)     # 2 ≦ 整数値 ≦ 10  ※2から10(含む)までのいずれかの整数

# 実数分布 ====================================================================
# random.random() ※ランダムな浮動小数点数)を返す。範囲: 0.0(含む) ~ 1.0(含まない)
rdm4 = random.random()
print(rdm4)     # 0.0 <= 実数値 < 1.0  ※0.0から1.0(含まない)までのいずれかの実数

# random.uniform(a, b) ※a <= b なら a <= 実数値 <= b , b < a なら b <= 実数値 <= a
# 端点の値 b が範囲に含まれるかどうかは、等式 a + (b-a) * random() における浮動小数点の丸めに依存
rdm5 = uniform(1.5, 5.0)
print(rdm5)     # 1.5 <= 実数値 <= 5.0  ※1.5から5.0(含む)までのいずれかの実数


<ファイルの入出力>

  • file object(ファイルオブジェクト)は開かれたファイルを表す。※別名は、I/O オブジェクト
  • ファイルオブジェクト: 下位のリソースへのファイル志向 API (read() や write() メソッドを持つもの) を公開しているオブジェクト。
  • ファイルオブジェクトは、作成された手段によって、実際のディスク上のファイルや、
    その他のタイプのストレージや通信デバイス(例えば、標準入出力、インメモリバッファ、ソケット、パイプ、等)へのアクセスを媒介できる。
  • ファイルオブジェクトは file-like objects や streams とも呼ばれる。
  • ファイルオブジェクトは、3種類ある。: 生のバイナリーファイル、バッファされたバイナリーファイル、そしてテキストファイル。
  • インターフェイスは io モジュールで定義されている。
  • ファイルオブジェクトを作る標準的な方法は、open()関数を使うこと。
  • open()関数は、ファイルを開き、対応するファイルオブジェクトを返す。ファイルを開くことができなければ、OSErrorが送出される。
    ※ファイルオブジェクトのclose()メソッドで、ファイルを閉じる。
  • ファイルオブジェクトのreadline()メソッドは、ファイルから1行だけを読み取る。
    改行文字(\n)は、読み出された文字列の終端に残る。
    改行が省略されるのは、ファイルが改行で終わっていない場合の最終行のみ。ファイルの終端(EOF)に達したら、空文字列('')を返す。
    ※テキストファイルに直接 \ と文字で記述されたものは、 \\ (バックスラッシュのエスケープシーケンス)として読み込まれる(表示上はそのまま \ )。
    例えば、直接 \n と文字で記述されたものは、\\n として読み込まれる(表示上はそのまま \n )。
    このため、実際に改行をさせたい場合は、\\n を \n に変換する処理が必要。
    ※文字列メソッド str.replace(old, new [,count])が利用できる。
# ファイル読み込み ========================================================================================
# open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
# file を開き、対応するファイルオブジェクトを返す。ファイルを開くことができなければ、OSErrorが送出される。
#
# file: 開くファイルのパス名を与えるものか、または、ラップするファイルの整数のファイルディスクリプタ
# mode: オプションの文字列で、ファイルが開かれるモードを指定する。デフォルトは 'r' で、読み込み用にテキストモードで開く。
#       他に、書き込み用の 'w'、排他的な生成用の 'x'、追記用の 'a' などがある。
# buffering: オプションの整数で、バッファリングの方針を設定する。バッファリングを無効にする(バイナリモードでのみ有効)には0、
#            行単位バッファリング(テキストモードでのみ有効)には1、固定値のチャンクバッファの大きさをバイト単位で指定するには1以上の整数
# encoding: ファイルのエンコードやデコードに使われる text encoding の名前。テキストモードでのみ使用。
#           エンコーディングが指定されなければ、デフォルトはプラットフォーム依存

f = open("samplefolder/sample.txt", "r", encoding = "utf-8") # ファイルオブジェクトを返す
while True:
    line = f.readline() # 1行ずつ読み込む
    print(line, end='')
    if not line:        # ファイルの終端(EOF)に達したら、空文字列('')を返す
        f.close()       # ファイルを閉じる
        break
  • ファイルから複数行を読み取るには、ファイルオブジェクトに対してループを書く方法がある。
f = open("samplefolder/sample.txt", "r", encoding = "utf-8") # ファイルオブジェクトを返す

for line in f:          # 1行ずつ読み込むのを繰り返す。ファイル終端の、空の文字列で終了
    print(line, end='')

f.close()               # ファイルを閉じる


<GUIプログラム>

  • Tkinterモジュールをimportすることで、GUIプログラミングが可能。※import時、先頭は小文字のt
  • Tkinterは、Python からGUIを構築・操作するための標準ライブラリ(ウィジェット・ツールキット)。
    Tcl/Tk(ティクル・ティーケー:スクリプト言語"Tcl"と、そのGUIツールキット"Tk"からなる、GUIスクリプティング環境)のTk部分を、
    Pythonで利用できるようにしたもので、簡単にGUI画面をもったアプリケーションを作ることが可能。
  • Tkクラスのmainloop()メソッドで、ディスプレイ表示や、表示の更新が行われる。
  • 各ウィジェットを変更した場合(表示/非表示や有効/無効など)に、mainloop()メソッドの到達前に、強制的に表示更新させるには、
    Tkクラスや各ウィジェットのupdate()メソッド(※Miscクラスから継承)が利用できる。
  • ウィンドウ上のウィジェットを削除するには、各ウィジェットのdestroy()メソッドが利用できる。
  • Canvas上のオブジェクトを削除するには、Canvasクラスのdelete()メソッドが利用できる。
  • ウィジェットの表示・非表示は、配置・非配置で可能。  ※いずれでも可能。
    • place()で表示(配置)、place_forget()で非表示(非配置)。
    • pack()で表示(配置)、pack_forget()で非表示(非配置)。

<ウィンドウ>

  • ウィンドウ作成には、tkinterが利用できる。
# 最低限の、GUIウィンドウ作成

import tkinter          # tkinter をインポート
#from tkinter import *  #このインポートのほうが効率がいいが、構造理解のため、敢えて使わない

# Tkクラスを(引数なしで)インスタンス化することで、Tkのトップレベルウィジェット(アプリケーションのメインウィンドウ)を生成
tk = tkinter.Tk()       # 生成したオブジェクトを、変数に代入
tk.mainloop()           # Tkのメインループをコール
import tkinter

tk = tkinter.Tk()

tk.title("タイトル")    # ウィンドウタイトル
tk.minsize(640, 480)    # 最小ウィンドウサイズ

tk.mainloop()

<フレーム・ウィジェット>

  • フレームは、複数のウィジェットを纏めることができる。
  • 削除するには、オブジェクトの、destroy()メソッドを使用。
  • Canvasとは独立している。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("キーボード操作")
tk.minsize(640, 480)

# フレーム
frame = tkinter.Frame(tk, width = 640, height = 480, bg = "green")
frame.place(x = 0, y = 0)

# ラベル  ※作成したフレームの子にする
lbl = tkinter.Label(frame, text = "フレーム内ラベル", bg = "white", font = ("MS Pゴシック", 22)) # frameをparentに指定
lbl.place(x = 100, y = 50)

# ボタン  ※作成したフレームの子にする
btn = tkinter.Button(frame, text = "フレーム内ボタン", width = 20, bg = "white")    # frameをparentに指定
btn.place(x = 100, y = 100)

# フレームの非表示 ※フレーム内のWidgetを纏めて操作できる
frame.place_forget()

# メインループ
tk.mainloop()

<ラベル・ウィジェット>

  • 削除するには、オブジェクトの、destroy()メソッドを使用。
  • Canvasとは独立している。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# ラベル ※bgを指定しない場合、背景は薄いグレー(デフォルト)
# フォントは、リストかタプルで指定
lbl = tkinter.Label(tk, text = "表示するテキストをここに書く", bg = "white", font = ("MS Pゴシック", 22))
lbl.place(x = 100, y = 40)

# メインループ
tk.mainloop()
  • ラベルのテキストを変更する。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# ラベル
lbl = tkinter.Label(tk, text = "表示するテキストをここに書く", fg = "blue", bg = "white", font = ("MS Pゴシック", 22))
lbl.place(x = 100, y = 40)

# ラベルのテキスト変更 ※いずれの方法でも可能
lbl["text"] = "変更するテキストをここに書く"      # オブジェクト生成後、オプション名を辞書インデックスのように扱う
#lbl.config(text = "変更するテキストをここに書く") # または、オブジェクト生成後に、config()メソッドを使って属性を更新

# メインループ
tk.mainloop()
  • ラベルを無効にするには、stateオプションに、"disabled"を指定する。
    ※完全に見えなくなるわけではなく、テキストがグレー表示になる。
    ※有効にする場合は、"normal"
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# ラベル
lbl = tkinter.Label(tk, text = "表示するテキストをここに書く", fg = "blue", bg = "white", font = ("MS Pゴシック", 22))
lbl.place(x = 100, y = 40)

# ラベルのテキスト変更 ※いずれの方法でも可能
lbl["text"] = "変更するテキストをここに書く"      # オブジェクト生成後、オプション名を辞書インデックスのように扱う
#lbl.config(text = "変更するテキストをここに書く") # または、オブジェクト生成後に、config()メソッドを使って属性を更新

# ラベルを無効にする
lbl["state"] = "disabled"
#lbl.config(state = "disabled")   # これでも可能

# メインループ
tk.mainloop()
  • ラベルを削除する。
    ※ラベルなどのGUIオブジェクトを削除するには、そのオブジェクトの、destroy()メソッドを使用。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# ラベル
lbl = tkinter.Label(tk, text = "表示するテキストをここに書く", fg = "blue", bg = "white", font = ("MS Pゴシック", 22))
lbl.place(x = 100, y = 40)

# ラベルのテキスト変更 ※いずれの方法でも可能
lbl["text"] = "変更するテキストをここに書く"      # オブジェクト生成後、オプション名を辞書インデックスのように扱う
#lbl.config(text = "変更するテキストをここに書く") # または、オブジェクト生成後に、config()メソッドを使って属性を更新

# ラベルを削除する
lbl.destroy()

# メインループ
tk.mainloop()
  • 複数行のラベル
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# ラベル
lbl = tkinter.Label(tk, width = 22, height = 5, bg = "white",
        anchor = tkinter.NW, wraplength = 85, justify = "left", text = "abcdefghijklmnopqrstuvwxyz")
lbl.place(x = 10, y = 20)

# メインループ
tk.mainloop()

<オプション>

  • オプションを利用することで、共通項目を設定できる。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# オプション =========================================================================
# 全てのラベルのフォントを設定  ※フォントは、リストかタプルで指定
tk.option_add("*Label.Font", ("MS Pゴシック", 10))  # 全てのウィジェットのフォントを設定する場合は、*font
# 全てのラベルの背景色を設定
tk.option_add("*Label.Background", "white")         # 全てのウィジェットの背景を設定する場合は、*Background

# ラベル
lbl1 = tkinter.Label(tk, text = "ラベル1")
lbl1.place(x = 100, y = 50)

lbl2 = tkinter.Label(tk, text = "ラベル2")
lbl2.place(x = 100, y = 100)

lbl3 = tkinter.Label(tk, text = "ラベル3")
lbl3.place(x = 100, y = 150)

# メインループ
tk.mainloop()

<ボタン・ウィジェット>

  • 削除するには、オブジェクトの、destroy()メソッドを使用。
  • Canvasとは独立している。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# ボタン
btn = tkinter.Button(tk, text = "ボタンのテキスト", width = 20, bg = "white")
btn.place(x = 100, y = 50)

# メインループ
tk.mainloop()
  • ボタンにイベントを設定する。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# ユーザー定義関数
def btn_click():
    print("ボタンがクリックされました。")

# ボタン
btn = tkinter.Button(tk, text = "ボタンのテキスト", width = 20, bg = "white")
#btn = tkinter.Button(command = btn_click, text = "ボタンのテキスト", width = 20, bg = "white") # イベント設定1
btn.place(x = 100, y = 50)

# イベント設定 ※イベント設定1,2,3いずれの方法でも可能
btn["command"] = btn_click       # イベント設定2
#btn.config(command = btn_click) # イベント設定3

# メインループ
tk.mainloop()
  • ボタンを無効にするには、stateオプションに、"disabled"を指定する。
    ※有効にする場合は、"normal"
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# ユーザー定義関数
def btn_click():
    print("ボタンがクリックされました。")

# ボタン
btn = tkinter.Button(tk, text = "ボタンのテキスト", width = 20, bg = "white")
#btn = tkinter.Button(command = btn_click, text = "ボタンのテキスト", width = 20, bg = "white") # イベント設定1
btn.place(x = 100, y = 50)

# イベント設定 ※イベント設定1,2,3いずれの方法でも可能
btn["command"] = btn_click       # イベント設定2
#btn.config(command = btn_click) # イベント設定3

# ボタンを無効にする
btn["state"] = "disabled"
#btn.config(state = "disabled")   # これでも可能

# メインループ
tk.mainloop()

<エントリー・ウィジェット>

  • 削除するには、オブジェクトの、destroy()メソッドを使用。
  • Canvasとは独立している。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# エントリー
entry = tkinter.Entry(tk, width = 50, bd = 5, bg = "white")
entry.place(x = 100, y = 50)

# メインループ
tk.mainloop()
  • エントリーに入力されたテキストを取得する。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# エントリー
entry = tkinter.Entry(tk, width = 50, bd = 5, bg = "white")
entry.place(x = 100, y = 50)

# ユーザー定義関数
def btn_click():
    entryText = entry.get()  # エントリーに入力されたテキストを取得
    print(entryText)

# ボタン
btn = tkinter.Button(tk, command = btn_click, text = "ボタンのテキスト", width = 20, bg = "white")
btn.place(x = 100, y = 100)

# メインループ
tk.mainloop()
  • エントリーを無効にするには、stateオプションに、"disabled"を指定する。
    ※有効にする場合は、"normal"
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# エントリー
entry = tkinter.Entry(tk, width = 50, bd = 5, bg = "white")
entry.place(x = 100, y = 50)

# エントリーを無効にする
entry["state"] = "disabled"
#entry.config(state = "disabled")   # これでも可能

# ユーザー定義関数
def btn_click():
    entryText = entry.get()  # エントリーに入力されたテキストを取得
    print(entryText)

# ボタン
btn = tkinter.Button(tk, command = btn_click, text = "ボタンのテキスト", width = 20, bg = "white")
btn.place(x = 100, y = 100)

# メインループ
tk.mainloop()

<キャンバス・ウィジェット (Canvas widget)>

  • ウィンドウにグラフィックスを描画するには、土台となるCanvasが必要。
  • グラフィックスを作成する場合、Canvasクラスのcreate_が先頭にあるメソッドで作成。※この時、識別番号(object ID)が返る。
  • キャンバス上のオブジェクトを削除する場合、Canvasクラスのdelete()メソッドで削除
    ※引数には、識別番号(object ID)、またはタグを指定する。object ID指定の場合、個別に削除できる。
    タグ指定の場合、同じタグを指定したもの全てを削除できる。
    ※キャンバス上の"全て"のオブジェクトを削除する場合、delete("all") とする。
  • グラフィックスの属性を変更する場合、Canvasクラスのitemconfig()メソッド(またはitemconfigure()メソッド)で変更できる。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, bg = "white", width = 640, height = 480)   # bgなど、キーワード引数は任意
canvas.place(x = 0, y = 0)   # canvas.pack()でも配置できる(※ウィンドウサイズが変わると、位置が動く)。

# メインループ
tk.mainloop()

<画像>

  • 画像は、Canvasに描画。
  • Canvasクラスのcreate_image()メソッドで作成。※この時、識別番号(object ID)が返る。
  • Canvasクラスのdelete()メソッドで削除。
    ※引数には、識別番号(object ID)、またはタグを指定する。object ID指定の場合、個別に削除できる。
    タグ指定の場合、同じタグを指定したもの全てを削除できる。
  • 属性を変更する場合、Canvasクラスのitemconfig()メソッド(またはitemconfigure()メソッド)で変更できる。
  • Canvasクラスの、create_image()メソッドの引数imageについて:
    • 画像の更新は、基本的に、Tkクラスのmainloop()メソッドやupdate()メソッドで行われる。
      それまでイメージオブジェクトへの参照を保持する必要がある。
    • 引数imageには、戻り値を直接代入するような、(すぐ消滅する)関数の指定はできない。
      → 変数(グローバル変数)を用意しておき、一度参照を代入してから、imageに代入するのが無難。
      ※文法的には可能だが、すぐに参照が消滅するため、mainloop()やupdate()による更新で画像が消える。
    • クラス内でcreate_image()メソッドを使用する場合、
      イメージオブジェクトへの参照を、メソッド内のローカル変数に代入したものを指定すると画像が消える。
      → インスタンス変数(例 self.imgなど)、または、グローバル変数を指定する。
      ※文法的には可能で、メソッド内でupdate()で更新すれば画像は表示できる。
      しかし、メソッドを抜けた時点で参照が消失し、mainloop()やupdate()による更新で画像が消えるため、
      インスタンス変数(例 self.imgなど)、または、グローバル変数を指定しておくのが無難。
    • 関数内でcreate_image()メソッドを使用する場合、イメージオブジェクトへの参照を、ローカル変数に代入したものを指定すると画像が消える。
      → グローバル変数を指定する。※global文を忘れずに。
      ※文法的には可能で、関数内でupdate()で更新すれば画像は表示できる。
      しかし、関数を抜けた時点で参照が消失し、mainloop()やupdate()による更新で画像が消えるため、
      グローバル変数を指定しておくのが無難。
    以上を踏まえると、
    イメージオブジェクトへの参照は、グローバル変数(または、クラスのインスタンス変数)に保持させるのが無難
    ※関数内ではglobal文を忘れずに。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, bg = "white", width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 画像
img = tkinter.PhotoImage(file = "img/myImage.png")  # この例では、.pyファイルと同じ階層のimgフォルダ内の、myImage.png画像を読み込む
canvas.create_image(0, 0, anchor = tkinter.NW, image = img, tag = "myImageTag") # anchor指定無しの場合、中心が基準 ※NW:NorthWest

# メインループ
tk.mainloop()
  • 画像の削除。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, bg = "white", width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 画像
img = tkinter.PhotoImage(file = "img/myImage.png")
image_ID = canvas.create_image(0, 0, anchor = tkinter.NW, image = img, tag = "image_Tag")

# 画像を削除
canvas.delete("image_Tag")    # 同じタグのものが全て削除される
#canvas.delete(image_ID)      # 個別に削除するには、識別番号(object ID)を指定する

# メインループ
tk.mainloop()
  • 画像の属性の変更。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, bg = "white", width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 画像
img1 = tkinter.PhotoImage(file = "img/myImage1.png")
img2 = tkinter.PhotoImage(file = "img/myImage2.png")
image_ID = canvas.create_image(0, 0, anchor = tkinter.NW, image = img1, tag = "image_Tag")

# 画像の属性を変更
canvas.itemconfig(image_ID, image = img2)
#canvas.itemconfigure(image_ID, image = img2)   # itemconfigure()でも可能

# メインループ
tk.mainloop()

<矩形>

  • 矩形は、Canvasに描画。
  • Canvasクラスのcreate_rectangle()メソッドで作成。※この時、識別番号(object ID)が返る。
  • Canvasクラスのdelete()メソッドで削除。
    ※引数には、識別番号(object ID)、またはタグを指定する。object ID指定の場合、個別に削除できる。
    タグ指定の場合、同じタグを指定したもの全てを削除できる。
  • 属性を変更する場合、Canvasクラスのitemconfig()メソッド(またはitemconfigure()メソッド)で変更できる。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("矩形を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 矩形を描く
# 左上x座標, 左上y座標, 右下x座標, 右下y座標, オプション
canvas.create_rectangle(50, 50, 590, 430, fill = "blue") # fillで塗りつぶし ※色は16進数でも指定可能(例: #0000ff)

# メインループ
tk.mainloop()
  • 矩形の削除。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("矩形を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 矩形を描く
# 左上x座標, 左上y座標, 右下x座標, 右下y座標, オプション
# 色は16進数でも指定可能(例: #0000ff)
rect_ID = canvas.create_rectangle(50, 50, 590, 430, outline = "red", fill = "blue", tag = "rect_Tag")

# 矩形を削除
canvas.delete("rect_Tag")    # 同じタグのものが全て削除される
#canvas.delete(rect_ID)      # 個別に削除するには、識別番号(object ID)を指定する

# メインループ
tk.mainloop()
  • 矩形の属性の変更。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("矩形を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 矩形を描く
# 左上x座標, 左上y座標, 右下x座標, 右下y座標, オプション
# 色は16進数でも指定可能(例: #0000ff)
rect_ID = canvas.create_rectangle(50, 50, 590, 430, outline = "red", fill = "blue", tag = "rect_Tag")

# 矩形の属性を変更
canvas.itemconfig(rect_ID, fill = "yellow")
#canvas.itemconfigure(rect_ID, fill = "yellow")   # itemconfigure()でも可能

# メインループ
tk.mainloop()

<テキスト (文字)>

  • テキスト(文字)は、Canvasに書く(描画する)。
  • Canvasクラスのcreate_text()メソッドで作成。※この時、識別番号(object ID)が返る。
  • Canvasクラスのdelete()メソッドで削除。
    ※引数には、識別番号(object ID)、またはタグを指定する。object ID指定の場合、個別に削除できる。
    タグ指定の場合、同じタグを指定したもの全てを削除できる。
  • 属性を変更する場合、Canvasクラスのitemconfig()メソッド(またはitemconfigure()メソッド)で変更できる。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("テキストを書く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# テキストを書く  ※デフォルトでは、テキスト領域の中心が基準
# フォントは、リストかタプルで指定
canvas.create_text(100, 50, text = "Hello, World!", font = ("メイリオ", 15), fill = "blue", tag = "text_Tag")

# メインループ
tk.mainloop()
  • テキストの削除。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("テキストを書く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# テキストを書く  ※デフォルトでは、テキスト領域の中心が基準
# フォントは、リストかタプルで指定
text_ID = canvas.create_text(100, 50, text = "Hello, World!", font = ("メイリオ", 15), fill = "blue", tag = "text_Tag")

# テキストを削除
canvas.delete("text_Tag")    # 同じタグのものが全て削除される
#canvas.delete(text_ID)      # 個別に削除するには、識別番号(object ID)を指定する

# メインループ
tk.mainloop()
  • テキストの属性の変更。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("テキストを書く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# テキストを書く  ※デフォルトでは、テキスト領域の中心が基準
# フォントは、リストかタプルで指定
text_ID = canvas.create_text(100, 50, text = "Hello, World!", font = ("メイリオ", 15), fill = "blue", tag = "text_Tag")

# テキストの属性を変更
canvas.itemconfig(text_ID, fill = "yellow")
#canvas.itemconfigure(text_ID, fill = "yellow")   # itemconfigure()でも可能

# メインループ
tk.mainloop()

<線>

  • 線は、Canvasに描画。※波線も描画できる。
  • Canvasクラスのcreate_line()メソッドで作成。※この時、識別番号(object ID)が返る。
  • Canvasクラスのdelete()メソッドで削除。
    ※引数には、識別番号(object ID)、またはタグを指定する。object ID指定の場合、個別に削除できる。
    タグ指定の場合、同じタグを指定したもの全てを削除できる。
  • 属性を変更する場合、Canvasクラスのitemconfig()メソッド(またはitemconfigure()メソッド)で変更できる。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("線を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 線を描く
# 座標(10, 20)と座標(250, 50)を結ぶ、線を描く
canvas.create_line(10, 20, 250, 50, width = 3, fill = "blue", tag = "line_Tag")

# メインループ
tk.mainloop()
  • 線の削除。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("線を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 線を描く
# 座標(10, 20)と座標(250, 50)を結ぶ、線を描く
line_ID = canvas.create_line(10, 20, 250, 50, width = 3, fill = "blue", tag = "line_Tag")

# 線を削除
canvas.delete("line_Tag")    # 同じタグのものが全て削除される
#canvas.delete(line_ID)      # 個別に削除するには、識別番号(object ID)を指定する

# メインループ
tk.mainloop()
  • 線の属性の変更。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("線を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 線を描く
# 座標(10, 20)と座標(250, 50)を結ぶ、線を描く
line_ID = canvas.create_line(10, 20, 250, 50, width = 3, fill = "blue", tag = "line_Tag")

# 線の属性を変更
canvas.itemconfig(line_ID, fill = "red")
#canvas.itemconfigure(line_ID, fill = "red")   # itemconfigure()でも可能

# メインループ
tk.mainloop()

<弧(円弧)>

  • 弧(円弧)は、Canvasに描画。
  • Canvasクラスのcreate_arc()メソッドで作成。※この時、識別番号(object ID)が返る。
  • Canvasクラスのdelete()メソッドで削除。
    ※引数には、識別番号(object ID)、またはタグを指定する。object ID指定の場合、個別に削除できる。
    タグ指定の場合、同じタグを指定したもの全てを削除できる。
  • 属性を変更する場合、Canvasクラスのitemconfig()メソッド(またはitemconfigure()メソッド)で変更できる。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("弧を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 弧を描く
# バウンディングボックスの左上座標(10, 20)と右下座標(250, 200)、反時計回り120度の弧
canvas.create_arc(10, 20, 250, 200, extent = 120, style = tkinter.ARC, tag = "arc_Tag")

# メインループ
tk.mainloop()
  • 弧の削除。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("弧を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 弧を描く
# バウンディングボックスの左上座標(10, 20)と右下座標(250, 200)、反時計回り120度の弧
arc_ID = canvas.create_arc(10, 20, 250, 200, extent = 120, style = tkinter.ARC, tag = "arc_Tag")

# 孤を削除
canvas.delete("arc_Tag")    # 同じタグのものが全て削除される
#canvas.delete(arc_ID)      # 個別に削除するには、識別番号(object ID)を指定する

# メインループ
tk.mainloop()
  • 弧の属性の変更。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("弧を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 弧を描く
# バウンディングボックスの左上座標(10, 20)と右下座標(250, 200)、反時計回り120度の弧
arc_ID = canvas.create_arc(10, 20, 250, 200, extent = 120, style = tkinter.ARC, tag = "arc_Tag")

# 弧の属性を変更
canvas.itemconfig(arc_ID, extent = 240)
#canvas.itemconfigure(arc_ID, extent = 240)   # itemconfigure()でも可能

# メインループ
tk.mainloop()

<楕円>

  • 楕円は、Canvasに描画。
  • Canvasクラスのcreate_oval()メソッドで作成。※この時、識別番号(object ID)が返る。
  • Canvasクラスのdelete()メソッドで削除。
    ※引数には、識別番号(object ID)、またはタグを指定する。object ID指定の場合、個別に削除できる。
    タグ指定の場合、同じタグを指定したもの全てを削除できる。
  • 属性を変更する場合、Canvasクラスのitemconfig()メソッド(またはitemconfigure()メソッド)で変更できる。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("楕円を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 楕円を描く
# バウンディングボックスの左上座標(10, 20)と右下座標(250, 200)の、楕円
canvas.create_oval(10, 20, 250, 200, fill = "blue", tag = "oval_Tag")

# メインループ
tk.mainloop()
  • 楕円の削除。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("楕円を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 楕円を描く
# バウンディングボックスの左上座標(10, 20)と右下座標(250, 200)の、楕円
oval_ID = canvas.create_oval(10, 20, 250, 200, fill = "blue", tag = "oval_Tag")

# 楕円を削除
canvas.delete("oval_Tag")    # 同じタグのものが全て削除される
#canvas.delete(oval_ID)         # 個別に削除するには、識別番号(object ID)を指定する

# メインループ
tk.mainloop()
  • 楕円の属性の変更。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("楕円を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 楕円を描く
# バウンディングボックスの左上座標(10, 20)と右下座標(250, 200)の、楕円
oval_ID = canvas.create_oval(10, 20, 250, 200, fill = "blue", tag = "oval_Tag")

# 楕円の属性を変更
canvas.itemconfig(oval_ID, fill = "red")
#canvas.itemconfigure(oval_ID, fill = "red")   # itemconfigure()でも可能

# メインループ
tk.mainloop()

<多角形>

  • 多角形は、Canvasに描画。
  • Canvasクラスのcreate_polygon()メソッドで作成。※この時、識別番号(object ID)が返る。
  • Canvasクラスのdelete()メソッドで削除。
    ※引数には、識別番号(object ID)、またはタグを指定する。object ID指定の場合、個別に削除できる。
    タグ指定の場合、同じタグを指定したもの全てを削除できる。
  • 属性を変更する場合、Canvasクラスのitemconfig()メソッド(またはitemconfigure()メソッド)で変更できる。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("多角形を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 多角形を描く
# 座標(10, 20)と座標(250, 50)と座標(100, 200)を結ぶ、多角形を描く
canvas.create_polygon(10, 20, 250, 50, 100, 200, fill = "blue", tag = "polygon_Tag")

# メインループ
tk.mainloop()
  • 多角形の削除。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("多角形を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 多角形を描く
# 座標(10, 20)と座標(250, 50)と座標(100, 200)を結ぶ、多角形を描く
polygon_ID = canvas.create_polygon(10, 20, 250, 50, 100, 200, fill = "blue", tag = "polygon_Tag")

# 多角形を削除
canvas.delete("polygon_Tag")    # 同じタグのものが全て削除される
#canvas.delete(polygon_ID)      # 個別に削除するには、識別番号(object ID)を指定する

# メインループ
tk.mainloop()
  • 多角形の属性の変更。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("多角形を描く")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 多角形を描く
# 座標(10, 20)と座標(250, 50)と座標(100, 200)を結ぶ、多角形を描く
polygon_ID = canvas.create_polygon(10, 20, 250, 50, 100, 200, fill = "blue", tag = "polygon_Tag")

# 多角形の属性を変更
canvas.itemconfig(polygon_ID, fill = "red")
#canvas.itemconfigure(polygon_ID, fill = "red")   # itemconfigure()でも可能

# メインループ
tk.mainloop()

<アニメーション>

  • 各ウィジェットの表示内容を変更した場合に、メインループ到達前に、強制的に表示更新させるには、
    Tkクラスや各ウィジェットのupdate()メソッド(※Miscクラスから継承)が利用できる。
  • 時間を停止させるには、timeモジュールのsleep()関数が利用できる。
    ※timeモジュールをインポートする必要がある。
  • Widget(ウィジェット)を移動させるには、Canvasクラスのmove()メソッドか、coords()メソッドが利用できる。
    • move()メソッドは相対座標を指定する。
    • coords()メソッドは絶対座標を指定する。
import tkinter
import time     # sleep関数利用のためインポート

# ウィンドウ
tk = tkinter.Tk()
tk.title("アニメーション")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 矩形を描く
rect_ID = canvas.create_rectangle(50, 50, 200, 200, outline = "red", fill = "blue", tag = "rect_Tag")

# 画面を描画
tk.update()     # 強制的に画面を描画

# 時間を停止
time.sleep(5)   # 引数に、停止する時間(秒)を指定

# アニメーション処理
for i in range(0, 10):
    canvas.move(rect_ID, 20, 10)    # x座標:+20, y座標:+10 動く
    tk.update()                     # 画面を描画
    time.sleep(0.5)                 # 時間を停止

# メインループ
tk.mainloop()

<イベント設定 (バインドとイベント)>

  • ウィジェットコマンドからのbind()メソッドによって、
    あるイベントを待つことと、そのイベント型が起きたときにコールバック関数を呼び出すことができる。
    ※解除はunbind()メソッド
  • bind()メソッドの形式 :
    def bind(self, sequence, func, add='')
    sequence:
    対象とするイベントの型を示す文字列。
    func:
    一引数を取り、イベントが起きるときに呼び出されるPython関数。
    イベント・インスタンスが引数として渡される。
    (このように実施される関数は、一般に callbacks として知られている。)
    add:
    オプションで、'' か '+' のどちらか。
    空文字列を渡すことは、このイベントが関係する他のどんなバインドをもこのバインドが置き換えることを意味する。
    '+' を使う仕方は、この関数がこのイベント型にバインドされる関数のリストに追加されることを意味する。
  • キーボードによるイベントを受け取るには、ウィジェットにフォーカスが必要。
    ※フォーカスを合わせるには、キーボードのTabキー、またはスクリプトから合わせる方法がある。
    ※各ウィジェットのforcus_set()メソッド(Miscクラスから継承)でフォーカスを指定できる。
  • ボタンウィジェットのクリックイベントについては、引数commandにユーザー定義関数を指定することで、イベント設定が可能。

ボタンウィジェットのクリックイベント

import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# 引数無しのユーザー定義関数
def btn_click():
    print("ボタンがクリックされました。")

# ボタン
btn = tkinter.Button(tk, text = "ボタンのテキスト", width = 20, bg = "white")
#btn = tkinter.Button(command = btn_click, text = "ボタンのテキスト", width = 20, bg = "white") # イベント設定1
btn.place(x = 100, y = 50)

# イベント設定 ※イベント設定1,2,3いずれの方法でも可能
btn["command"] = btn_click       # イベント設定2
#btn.config(command = btn_click) # イベント設定3

# メインループ
tk.mainloop()

ボタンウィジェットのクリックイベントで、引数を使う場合1
"expressionに、引数ありのユーザー定義関数を指定した、引数無しのラムダ式" が利用できる。

import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# 引数ありのユーザー定義関数
def btn_click(btn_name):
    print(btn_name + "が押されました")
    
# イベント設定
# ユーザー定義関数に引数を渡したいときは、
# "expressionに、引数ありのユーザー定義関数を指定した、引数無しのラムダ式" が利用できる。
# (ラムダ式を使うのであれば、ラムダ式自体には引数を記述可能(キーワード引数を記述可能)だが、
# そのラムダ式の引数に対して、値を渡せないので意味がない)
btn_name = "起動ボタン"
btn = tkinter.Button(tk, text = btn_name, command = lambda : btn_click(btn_name))
btn.place(x = 10, y = 20)

# メインループ
tk.mainloop()

ボタンウィジェットのクリックイベントで、引数を使う場合2
引数ありのユーザー定義関数内で、イベント用の関数を定義し、それを戻り値にして、引数commandに指定することで可能。

import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# 引数ありのユーザー定義関数
def myCallback(btn_name):
    def btn_click():            # ユーザー定義関数内で、イベント用の関数を定義 ※引数は指定しない
        print(btn_name + "が押されました")
    return btn_click            # イベント用の関数名を返す
    
# イベント設定
# ユーザー定義関数に引数を渡したいときは、
# 引数ありのユーザー定義関数内で、イベント用の関数を定義し、それを戻り値にして、引数commandに指定することで可能
btn_name = "起動ボタン"
btn = tkinter.Button(tk, text = btn_name, command = myCallback(btn_name)) # 引数commandには、戻り値の関数名を指定
btn.place(x = 10, y = 20)

# メインループ
tk.mainloop()

イベント設定※ボタンウィジェットのクリックイベント以外の、イベント設定

import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# ラベル
lbl = tkinter.Label(tk, width = 50, height = 10, bg = "white",
        anchor = "nw", wraplength = 85, justify = "left", text = "abcdefghijklmnopqrstuvwxyz")
lbl.place(x = 10, y = 20)

# イベントハンドラ
def press_label(event):     # Event object を引数にとる、コールバック関数
    print(event.keysym + "が押された")

# フォーカスの設定
lbl.focus_set()     # キーボード操作のイベントを受け取るには、フォーカスが必要

# イベント設定
lbl.bind("<KeyPress-space>", press_label)
# イベント解除: lbl.unbind("<KeyPress-space>")

# メインループ
tk.mainloop()

イベント設定で、引数を使う場合 ※ボタンウィジェットのクリックイベント以外の、イベント設定
"expressionに、引数ありのユーザー定義関数を指定した、引数あり(Event object用)のラムダ式" が利用できる。

import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("タイトル")
tk.minsize(640, 480)

# ラベル
lbl = tkinter.Label(tk, width = 50, height = 10, bg = "white",
        anchor = "nw", wraplength = 85, justify = "left", text = "abcdefghijklmnopqrstuvwxyz")
lbl.place(x = 10, y = 20)

# 引数ありのユーザー定義関数
def press_label(event, lbl_name):     # Event object を引数にとる、コールバック関数
    print(lbl_name + "で、" + event.keysym + "が押された")

# フォーカスの設定
lbl.focus_set()     # キーボード操作のイベントを受け取るには、フォーカスが必要

# イベント設定
# ユーザー定義関数に引数を渡したいときは、
# "expressionに、引数ありのユーザー定義関数を指定した、引数あり(Event object用)のラムダ式" が利用できる
lbl_name = "ラベル"
lbl.bind("<KeyPress-space>", lambda event: press_label(event, lbl_name))

# メインループ
tk.mainloop()

イベントタイプ ※一部

  • Button: マウスボタンのひとつが押された。
    例) <Button-1> など  ※1:左マウスボタン、2:中マウスボタン、3:右マウスボタン に対応。
  • ButtonRelease: マウスボタンが離された。
    例) <ButtonRelease-1> など  ※1:左マウスボタン、2:中マウスボタン、3:右マウスボタン に対応。
  • Double-Button: マウスボタンのひとつがダブルクリックされた。
    例) <Double-Button-1> など  ※1:左マウスボタン、2:中マウスボタン、3:右マウスボタン に対応。
  • Motion: ウィジェット内で、押した状態で、マウスポインターが動いた。
    例) <B1-Motion> など  ※B1:左マウスボタン、B2:中マウスボタン、B3:右マウスボタン に対応。
  • Enter: ウィジェットの可視領域に、マウスポインターが入った。
    例) <Enter>
  • Leave: ウィジェットの外に、マウスポインターが外れた。
    例) <Leave>
  • KeyPress: キーボードのキーが押された。※押されている間ずっと
    例) <KeyPress-Return> など  ※Returnキー(Enterキー)
  • KeyRelease: キーボードのキーが離された。
    例) <KeyRelease-space> など  ※spaceキー(Sは小文字なので注意)
  • Shift: Shiftキーと併用のキーが押された。※押されている間ずっと
    例) <Shift-Tab> など  ※Shiftキーを押しながらTabキー
  • Key: キーボードのいずれかのキーが押された。※押されている間ずっと
    例) <Key>

イベントモディファイア ※一部

  • Alt, Any, Control, Double, Lock, Shift, Triple などがある。
    例) <any-keypress> , <double-button-1>
  • '<1>' は '<button-1>' と同じ。
  • 'x' は '<keypress-x>' と同じ。

<キーボード操作>

  • キーボード操作をするには、ウィジェットとイベント処理を関連付ける必要がある。※イベントバインディング
  • イベントバインディングを行うには、各ウィジェットのbind()メソッド、またはbind_all()メソッドを使う。※Universal widget methods
  • ボタンウィジェットのクリックイベントは、command属性に、イベント関数を指定することで可能。
    それ以外のボタン、及び、ボタン以外のウィジェットのイベントは、各ウィジェットのbind()メソッドによるイベントバインディングを行う。
    ※解除はunbind()メソッド
  • キーボードによるイベントを受け取るには、ウィジェットにフォーカスが必要。
    ※フォーカスを合わせるには、キーボードのTabキー、またはスクリプトから合わせる方法がある。
    ※各ウィジェットのforcus_set()メソッド(Miscクラスから継承)でフォーカスを指定できる。
  • 関連づけられた関数の引数にはイベントのオブジェクトが渡される。オブジェクトのkeysym(:key symbol)変数には押されたキーの文字列が入る。
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("キーボード操作")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 矩形を描く
rect_ID = canvas.create_rectangle(50, 50, 200, 200, outline = "red", fill = "blue", tag = "rect_Tag")

# 矩形を移動する
def moveRect(event):
    canvas.move(rect_ID, 20, 10)    # x座標:+20, y座標:+10 動く
    tk.update()                     # 画面を描画

# フォーカスを合わせる ※Tabキーを押さなくてもフォーカスを合わせておく
canvas.focus_set()

# イベントバインディング
canvas.bind("<KeyPress-Return>", moveRect)

# メインループ
tk.mainloop()
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("キーボード操作")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 矩形を描く
rect_ID = canvas.create_rectangle(50, 50, 200, 200, outline = "red", fill = "blue", tag = "rect_Tag")

# 矩形を移動する
def moveRect(event):
    canvas.move(rect_ID, 20, 10)    # x座標:+20, y座標:+10 動く
    tk.update()                     # 画面を描画

# イベントバインディング
canvas.bind_all("<KeyPress-Return>", moveRect)

# メインループ
tk.mainloop()
import tkinter

# ウィンドウ
tk = tkinter.Tk()
tk.title("キーボード操作")
tk.minsize(640, 480)

# キャンバス
canvas = tkinter.Canvas(tk, width = 640, height = 480)
canvas.place(x = 0, y = 0)

# 矩形を描く
rect_ID = canvas.create_rectangle(50, 50, 200, 200, outline = "red", fill = "blue", tag = "rect_Tag")

# 矩形を移動する
def moveRect(event):
    if event.keysym == "Up":
        canvas.move(rect_ID, 0, -10)    # x座標:0, y座標:-10 動く
    elif event.keysym == "Down":
        canvas.move(rect_ID, 0, 10)     # x座標:0, y座標:+10 動く
    elif event.keysym == "Left":
        canvas.move(rect_ID, -10, 0)    # x座標:-10, y座標:0 動く
    elif event.keysym == "Right":
        canvas.move(rect_ID, 10, 0)     # x座標:+10, y座標:0 動く
    #tk.update()                         # 画面を描画

# イベントバインディング
canvas.bind_all("<KeyPress-Up>", moveRect)
canvas.bind_all("<KeyPress-Down>", moveRect)
canvas.bind_all("<KeyPress-Left>", moveRect)
canvas.bind_all("<KeyPress-Right>", moveRect)

# メインループ
tk.mainloop()




Visual Studio Code インデント

Visual Studio Code インデント

※Version 1.16.0

<インデント>

インデント操作

  • インデントを行う方法 :Tab
  • インデントを戻す方法 :Shift + Tab



マイブログへようこそ♪
PLEASANT_DRAGON

2DCG&3DCG,プログラミング,
日記などを掲載中☆

(*´▽`*)コメント大歓迎です☆

最新記事
記事一覧

全ての記事を表示する

カテゴリ
SAI (0)
mi (2)
C (1)
C++ (1)
C# (0)
VBA (0)
月別アーカイブ
最新コメント
RSSリンクの表示
リンク
FC2ブログランキング

FC2Blog Ranking

ピックアップ商品1♪










カレンダー
09 | 2017/10 | 11
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 - - - -
ブログ内検索フォーム
プロフィール

エクレア

Author:エクレア


  • 2DCG&3DCGの創作活動をしています。

  • SF系のメカが大好物。

アクセスカウンター
Twitter
ピックアップ商品2♪