5時間で学ぶPython言語
Python言語について
この言語は教育現場だけではなく
数多くの現場で用いられていますので
単なる学習や研究だけでなく
実務をこなすのにも大いに役立つため
初めて学ぶ言語には最適です。
プログラム言語の特性としては
・非常に簡単で分かりやすい文法であること
・ライブラリという、再利用可能なプログラムが豊富
・プログラム実装の事例が豊富
ということです。
プログラム言語の人気度では上位3位以内に入り
今最も注目を集めている言語になります。
特に統計解析や機械学習、AI関連の研究者は必ずと言って良いほど
Pythonを習得していますし国内でもその需要が増えてきています。
また一度Pythonを学習し終えたら
他の言語もすぐに覚えることができるようになります。
それくらいに初めて学ぶ言語には適していると思います。
おそらくこの講座を終える頃には、他の言語へも興味が湧き、
もっともっと学んでみたいという意欲が
高まってくるんではないかと、期待しています。
ぜひPythonを主軸にプログラミングを習得していきましょう。
ここではPythonの3.7versionに対応した文法を取り扱っています。
環境構築の仕方
Python言語のインストールを行いたい場合は
Anacondaというライブラリやツール類などが
セットになったパッケージを使ってインストールするのが
一番簡単です。
ダウンロードはこちら
インストーラーなどで簡単にインストール出来るでしょう。
インストールが面倒臭い方は
Google ColaboratoryというWEBサービスを使う事で
インストールせずにすぐにプログラミングを始めることもできます。
Google Colabの使い方
こちらの記事を参考にしてみてください
JupyterNotebookの使い方
Anacondaをインストールしていただいたら
JupyterNotebookが使えるようになっているはずです。
JupyterNotebookの起動の仕方
windows:
プログラムの中からAnaconda Promptを探して起動する。
macos:
アプリケーションの中からターミナルを探して起動する
以下のコマンドを打ち込んでエンターキーを押す
jupyter notebook
以下のような画面がブラウザーで立ち上がればOK
※ 表示されるフォルダなどは各自の構成により異なります。
jupyter notebook を起動した後は
http://localhost:8888/tree
でjupyter notebookの基本画面にアクセスできる。
基本画面での操作の仕方
基本画面での操作は以下のようになっています。
画面右上：
New をクリックして新規作成
・Text File (テキストファイル)
・Folder (フォルダ)
・Python(Python実行用のノートブック)
Upload をクリックして他ファイルの追加(読み込み)
画面左上：
フォルダやファイルの左側に表示される四角ボタンをクリックして選択
選択後、リネームや削除が実行できるようになる。
新規ノートブックの作成
画面右上：
New をクリックして
・Python
を選択してクリックすると新規のノートブックが作成できる。
※インストールしたバージョンによってはPython3 などの表記になることも有り。
ノートブックでの操作
画面左上：
新規作成後は以下のような画面が表示される。
画面上部のメニューからノートブックの操作が行える。
以下はよく使う操作。
プログラムの入力、実行方法
プログラムは「セル」と呼ばれる入力欄にコードを入力して実行する。
プログラムの実行は入力後に Shiftキー + エンターキー
もしくは画面上部の「Cell」 から「Run Cells」を選択で実行できる。
(Shiftキー + エンターキー が一番楽)
最下段の場合、実行後にセルが下に追加される。
それ以外の場合はセルの選択が下に移動する。
上からまとめて実行したい場合は
画面上部の「Cell」から「Run All」で全て実行できる。
セルの追加、移動、削除
画面上部の「プラスボタン」 もしくは
「Insert」から「Insert Cell」 などでセルを追加できる。
セルの移動は、まずはセルをクリックして選択し、
画面上部の上下矢印をクリックすることで移動できる。
セルを選択した状態で
画面上部の「ハサミ」マーク もしくは
「Edit」から「Cut Cells」 などでセルを削除できる。
ノートブックの保存、変換、リネーム
ノートブックを保存するには
画面左上の「フロッピーマーク」をクリックするか
「File」メニューから「Save and Checkpoint」をクリックする。
ノートブックを他の形式に変換する場合は
「File」メニューから「Download as」を選択して様々な形式に変換できる。
ノートブックの名称を変更するには
ノートブックのタイトルをクリックするか
「File」メニューから「Rename」をクリックして変更する。
ノートブックのリスタート(再起動)
プログラムを実行していて、おかしくなったりしたら
ノートブックを再起動する事で直す事ができる。
画面上部のメニュー「Kernel」から「Restart」
もしくは「リスタートマーク」を選択する事で再起動画面が表示され
「Restart」をクリックすると再起動する。
演算
プログラミングの基本は「演算」です。
演算とは様々な計算を行うことです。
プログラムの基本は
1.入力
2.演算
3.出力
この3つ
プログラムというのは基本的には文字と数値を組み合わせて入力し
何かしらの計算を行い、その結果を出す、という仕組みになっています。
演算は大きく分けると「文字」と「数値」の計算を取り扱います。
四則計算
加算(足し算)) +
減算(引き算) -
乗算(掛け算) *
除算(割り算) /
剰余(余り) %
べき乗 **
計算する際に使う数値や文字のことを「リテラル」
プラスなどの記号( + - など)は「演算子」と呼んでいます。
そのなかでも四則計算に使われるのは
「算術演算子」（または代数演算子）と読んでいます。
セルに以下を入力して結果をみてみましょう。
実行の仕方はShift + Enterキーです。
# 足し算(加算)
1+2
# 引き算(減算)
1-3
# かけ算(乗算)
2*3
# x は使えないのでエラーになる
2 x 3
# 割り算(除算)
10/3
# 割り算(余りなし、切り捨て除算)
10//3
# べき乗
2**3
# ルート
2**0.5
# 剰余(割った際の余り)
5%3
# 掛け算や引き算の優先順位は算数と一緒
2 * 3 + 4
計算する際に使う数値や文字のことを「リテラル」
プラスなどの記号( + - など)は「演算子」と呼んでいます。
そのなかでも四則計算に使われるのは
「算術演算子」（または代数演算子）と読んでいます。
そのほか
・ビット演算子
・代入演算子
・比較演算子
・ブール演算子
・条件演算子
など、演算子にはたくさん種類があります。
文字
文字列の取り扱いも演算になります。
プログラミングを簡単に表現すると
壮大な文字列操作を行うもの
と表現することができると思います。
Pythonで文字の取り扱い方
文字列として扱うには
'シングルクォートか"ダブルクォートで囲む
'最初の一歩'
"二歩目"
プログラムでは文字と数値は別もの
囲まないとエラーになる
三歩目
NameError Traceback (most recent call last)
in ()
----> 1 三歩目
NameError: name '三歩目' is not defined
画面への表示方法
プログラム上で文字を表示させたい場合は
print関数を使う。
関数では()カッコの中に入れるものを引数と呼ぶ
print('あの')
print('バランスの良い')
print('山本選手が！！')
あの
バランスの良い
山本選手が！！
シングルクォートとダブルクォートの使い分け
文字に'シングルクォートを用いたい場合は"ダブルクォートで囲みます
文字に"ダブルクォートを用いたい場合は'シングルクォートで囲みます
print("moco’s kitchen")
print('この " とはなんて読むんですか？')
moco’s kitchen
この " とはなんて読むんですか？
文字は+(足す)と*(かける)の演算子を用いることができます。
足した場合は 文字列の連結
かけた場合は 文字列の繰り返し
print('ダチョウ' + '倶楽部')
print('聞いてないよ' * 10)
ダチョウ倶楽部
聞いてないよ聞いてないよ聞いてないよ聞いてないよ聞いてないよ聞いてないよ聞いてないよ聞いてないよ聞いてないよ聞いてないよ
文字と数値をひとまとめに取り扱うことができません。
文法上間違いのためエラーが発生します。
print('M' + 1 + '知らんぷり')
TypeError Traceback (most recent call last)
in ()
----> 1 print('M' + 1 + '知らんぷり')
TypeError: Can't convert 'int' object to str implicitly
'シングルウォートなどで囲み、数字として扱えば
文法のエラーを回避することができます。
print('M' + '1' + '知らんぷり')
M1知らんぷり
print関数の仕組み
print関数は最後に改行コードが含まれる形になるので
改行コードを出したくなければ
end=を付け足して改行コードの代わりになるものを入力する。
end=''とした場合は空白が出力される
print("無駄", end="")
print("無駄")
print("無駄", end="")
コメント
Pythonでは# (シャープ記号) はコメントの機能を表す文字で
これを入力した以降のコードは無視される
これを利用してプログラム内にコメントを残すことができる。
コメントは英語で入力すると 多分カッコイイ www
### ここがコメント
print('上記のコメント行は実行時に影響しない') #こんな所にコメントしてもなにも起きない
# ここもコメント
上記のコメント行は実行時に影響しない
まとめてコメントしたいときは
macならコマンドキーを押しながらスラッシュキー
windowsはコントロールキーを押しながらスラッシュキー
インデックス
インデックスとはプログラム上で何番目というのを表す数字です。
インデックスを用いることでプログラムでは様々なことが行えます。
インデックスの表記
インデックス値は数値、[]四角カッコで囲む
[5]
文字のインデックスの例
print('はじめの一歩'[5])
歩
文字列は複数の文字からなるデータなので
インデックス番号の文字を取り出すことができる。
インデックスの数え方
インデックスは0から始まるので
文字列の最初の文字を取りたい場合インデックスは0
２番目を取りたい場合インデックスは1になる
n番目のインデックス値はn-1
1つズレるので注意
最後の文字を指定する場合は-1で指定でき
マイナスを付けると末尾から数えることができる。
# 最初
print('あいうえお'[0])
# 2番目
print('あいうえお'[1])
# 最後
print('あいうえお'[-1])
# 最後から数えて3番目
print('あいうえお'[-3])
あ
い
お
う
また
存在しないインデックス値を指定するとエラーになります。
print('あいうえお'[7])
IndexError Traceback (most recent call last)
in ()
----> 1 print('あいうえお'[7])
IndexError: string index out of range
IndexErrorはインデックス値が範囲外の場合に起こるエラーのことで
index out of rangeとは
インデックス値が存在しない値を参照している意味です。
インデックスは必ず存在する値を指定してあげないといけません。
スライス
Pythonではインデックスを使って
範囲指定でデータを取り出すことができる機能があり
スライスと呼んでいます。
スライスの書き方：
[n:m]n番目からm番目まで
[n:] n番目以降
[:n] n番目まで
[n:m:o] n番目からm番目までo個とばして
# 3番目から5番目
print('あいうえおかき'[2:5])
# 2番目以降
print('あいうえおかき'[1:])
# 3番目まで
print('あいうえおかき'[:3])
# 最初から最後の1つ手前まで
print('あいうえおかき'[0:-1])
# 最初から最後の1つ手前までで1つ飛ばして
print('あいうえおかき'[0:-1:2])
うえお
いうえおかき
あいう
あいうえおか
あうお
変数
プログラムでは入力されたデータを使い回す機能があります。
それが変数という概念です。
変数を用いることで入力したデータを再利用できるようになります。
変数の宣言と値の代入
変数名 = 値
= は代入を表す演算子（代入演算子）
= の左側に右側を代入する。
a = 12345
b = 23456
個数が合えば複数同時に宣言と代入が行える。
a,b,c = 4,5,6
d,e,f = '10','20','30'
変数名に使用できる文字
a - z のアルファベット(大文字と小文字)
0 - 9 までの数字
_ (アンダースコア)
変数名は自分で考えて付けるものなのでなんでも良いですが
中に格納するデータがどんなものかを考えて名称をつけるのが良いでしょう
この講義ではアンダーバーで
2つ以上の英単語を用いることを推奨します。
# 例：
magic_spell_name
attack_point
なお変数名は予約語や組み込み関数名に該当するものでなければ
なんでも付けることができます。
予約語などについては次項で
変数の使い方
宣言した後は、その変数を入力すれば使うことができます。
# 変数 a に 数値の12345 を代入する
a = 12345
# 変数 b に 数値の23456 を代入する
b = 23456
# 変数 a と b を足した結果を出力する
print(a + b)
35801
# 変数c にa + b の結果を代入する
c = a+b
# 結果
print(c)
35801
同じ変数名に値を代入すると上書きされます。
# 変数 a に数値の123を代入
a = 123
print(a)
# 変数 a に数値の234を代入
a = 234
print(a)
123
234
a,b = 12345,23456
print(a)
print(b)
# a + b の結果を再度 a に代入する(上書き)
a = a+b
print(a)
12345
23456
35801
プログラムではデータの形も重要です。
文字と数値は一緒に計算できません。
a = '文字'
b = 1
print(a + b)
TypeError Traceback (most recent call last)
in ()
1 a = '文字'
2 b = 1
----> 3 print(a + b)
TypeError: Can't convert 'int' object to str implicitly
TypeError:
変数 a と b のデータの形が違うので
計算できない(変換できない)という意味合いのエラーです。
数値の型と文字の型ではデータの形が違うため一緒にすることができません。
データの形の確認
type関数を使って変数のデータ型を確認する。
type(変数名)
# 変数aとcは数値、bは文字列を代入
a,b,c = 1 , '3' , 4
print(type(a))
print(type(b))
print(type(c))
<class 'int'>
<class 'str'>
<class 'int'>
int は整数の型
str は文字列の型を表す言葉です。
変数に格納したもののことをオブジェクトと呼んだりもします。
変数 = データの型 = オブジェクト
という関係性になるので、呼び方や概念を覚えておきましょう。
予約語
予約語というのはプログラム内であらかじめ使われてしまっている
言葉のことで、プログラムの中では特別な意味を持つ言葉になります。
予約語一覧
# 予約語の一覧を出す
__import__('keyword').kwlist
False
None
True
and
as
assert
break
class
continue
def
del
elif
else
except
finally
for
from
global
if
import
in
is
lambda
nonlocal
not
or
pass
raise
return
try
while
with
yield
Pythonの予約語はこれだけあります。
この予約語は変数名や関数名などに用いることはできません。
jupyter notebook上で予約語を使うと
緑色に表示が変わるので、気付けるかと思います。
組み込み関数一覧
# 組み込み関数を表示する
dir(__builtins__)
ArithmeticError
AssertionError
AttributeError
BaseException
BlockingIOError
BrokenPipeError
BufferError
BytesWarning
ChildProcessError
ConnectionAbortedError
ConnectionError
ConnectionRefusedError
ConnectionResetError
DeprecationWarning
EOFError
Ellipsis
EnvironmentError
Exception
False
FileExistsError
FileNotFoundError
FloatingPointError
FutureWarning
GeneratorExit
IOError
ImportError
ImportWarning
IndentationError
IndexError
InterruptedError
IsADirectoryError
KeyError
KeyboardInterrupt
LookupError
MemoryError
NameError
None
NotADirectoryError
NotImplemented
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
PermissionError
ProcessLookupError
RecursionError
ReferenceError
ResourceWarning
RuntimeError
RuntimeWarning
StopAsyncIteration
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TimeoutError
True
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError
__IPYTHON__
__build_class__
__debug__
__doc__
__import__
__loader__
__name__
__package__
__spec__
abs
all
any
ascii
bin
bool
bytearray
bytes
callable
chr
classmethod
compile
complex
copyright
credits
delattr
dict
dir
divmod
dreload
enumerate
eval
exec
filter
float
format
frozenset
get_ipython
getattr
globals
hasattr
hash
help
hex
id
input
int
isinstance
issubclass
iter
len
license
list
locals
map
max
memoryview
min
next
object
oct
open
ord
pow
print
property
range
repr
reversed
round
set
setattr
slice
sorted
staticmethod
str
sum
super
tuple
type
vars
zip
これを変数名に用いてしまうと、その関数の機能を
変数で上書きしてしまいその関数が使えなくなってしまいます。
間違えて使用してしまったらノートッブックを再起動しましょう。
変数名の宣言は英単語2個以上にすることで
こういった問題を回避することができたりするので推奨します。
# 例：
magic_spell_name
attack_point
データ型
プログラム言語で取り扱うデータにはデータの型があり
書き方などが決まっています。
変数などで取扱う際も、データの型に合わせて書く必要があります。
Pythonのデータ型を調べる方法
type関数を用いる
type(データ型)
整数型(int型)
整数値を取扱うための型で
int型とも言います(integer の略)
四則計算を行うことができるデータ型です。
# 2進法
num = 0b11000100
print(num)
# 8 進法
num = 0o777
print(num)
# 16進法
num = 0xffff
print(num)
196
511
65535
10進法は0から9まで数えて10までいくと１つ桁が繰り上がります。
2進法は0 , 1 で2つ数えて繰り上がり、
8進法は0から7まで行ったら繰り上がり
16進法は0から9までいったら次は英語のabcdefまでいくと
繰り上がるというものです。
小数型(float型)
整数型は小数点を取り扱えませんが
小数型は小数点も取扱うことができます。
浮動小数点型float型ともいいます。
num = 1.234
print(type(num))
<class 'float'>
指数表記も使えます。
指数表記は英文字のeをつけ数値でn乗を表します。
e3は10の3乗を表し-を付けると逆に-n乗になります。
# 1.2の10の3乗
num = 1.2e3
print(type(num))
print(num)
# 1.2の10の -3乗
num = 1.2e-3
print(num)
1200.0
0.0012
同じ数値でも、整数型と小数型では違う形なので注意が必要です。
小数型と整数型の計算結果は小数型になります。
# 整数割る整数
print(10/4)
# 整数割る整数(余りなし)
print(10//4)
# 整数割る小数
print(10//4.0)
# 小数割る小数
print(12.3/4.0)
2.5
2
2.0
3.075
論理型(bool型)
真偽値を取扱うための型で
booleanを略してbool型とも言います。
TrueかFalseどちらかの値が入る型です。
answer = True
print(answer)
print(type(answer))
True
<class 'bool'>
計算の判定結果はbool型になります。
==を用いると==の左側と右側が
等しいかどうかを判定できます。
1==2
False
等しいかどうかを判定した場合、正しければTrue
正しくなければFalseという結果になります。
文字列型(string型)
文字列を取扱うための型でstring型とも言います。
文字列(str)は"ダブルクォート
または'シングルクォートで囲む必要があります。
# 文字列型
print(type('12345'))
# こちらは数値
print(type(12345))
<class 'str'>
<class 'int'>
数字をそのまま書くと整数型、もしくは小数点型になるので
文字列として扱いたい場合は'などが必要です。
文字と数値の変換
文字列を整数型に直す場合は
int('数字')
整数型や小数型を文字列に直す場合は
str(数値)
# 文字列を整数型に
a = '12345'
# 文字を数値に変換したので計算できるようになる
print(int(a) + 12345)
24690
# 小数点を文字列に変換
b = 2.5
# 数値を文字列に変換したので文字列として加えられる
print('江頭' + str(b) + '分')
江頭2.5分
byte型
バイト列として扱いたい文字列の "..." や '...'
の前にbまたはBを記述して、バイト列(bytes)であることを示すと
byte型になります。
byte_st = b'0123456789abcdef'
print(byte_st)
print(type(byte_st))
b'0123456789abcdef'
<class 'bytes'>
bがついていたらbyte型で文字列型とは別物になります。
文字列
pythonのデータ型の中でも文字列型は一番よく使うデータ型です。
なので、文字列型の取り扱い方を詳しく見ていきましょう。
文字列型について
文字列型にする場合は
'シングルクォートや"ダブルクォートで囲みます。
変数に格納する際も同様です。
st = 'abcde'
print(st)
print(type(st))
abcde
<class 'str'>
シングルクォートやダブルクォートの使い分け
"..."の中では'を、'...'の中では"を使うことができます。
"..."の中で"を、'...'の中で'を使用するには、
\バックスラッシュ (Windows の環境では¥)
を用いて引用符をエスケープ(無効化)します。
# \ バックスラッシュを用いるとその後に続く引用符が無効になり、表示させることができる。
st = "We can use \" in the string."
print(st)
st = 'We can use \' in the string.'
print(st)
We can use " in the string.
We can use ' in the string.
エスケープ文字
特殊な文字列を打ち込む場合には、このエスケープ文字を使用します。
macは\バックスラッシュ
windowsは¥円マーク
\nとすると改行コード、\tと打ち込むとタブを表現できる。
# 改行コード
print('aaaa \n bbbb')
# タブ
print('cccc \t dddd')
aaaa
bbbb
cccc dddd
改行はエンターキーだが、打ち込むことはできないので
改行を含ませたい場合はエスケープ文字を使って表現できます。
このようにエスケープ文字を使って表現する特定の文字のことを
エスケープシーケンスと言います。
他にもいくつかエスケープシーケンスがありますが、
余り使わないかもしれません。
三重クォート
三重クォート """...""" や'''...'''は、
複数行にまたがった文字列を記述することができます。
三重クォートはしばしば、複数行のコメントとして利用されることがあります。
mail_text = '''
林様
お世話になっております。木森です
本日はウェルカムトゥーザジャングルをお届けいたします。
'''
print(mail_text)
林様
お世話になっております。木森です
本日はウェルカムトゥーザジャングルをお届けいたします。
メールの差し込み文章を作るときなどによく使われる手法です。
文章をあらかじめ変数に用意しておいて
その一部を取り替えると、いろいろな人向けの本文が作成できます。
文字列関数について
Pythonでは文字列を操作するいろいろな関数が備わっています。
その中からよく使うものをご紹介します。
replace : 文字列を置換する
置換対象文字列.replace('置換前文字列','置換後文字列')
aaa = 'abcdefg'
print(aaa)
# replaceでdef を zzzz に変換
print(aaa.replace('def','zzzz'))
abcdefg
abczzzzg
in , startswith , endswith
対象の文字列に対して検索文字列を含むかどうかの判定をして真偽値を返します。
検索文字列 in 対象の文字列 ：文字列を含むかどうかの判定する
対象の文字列.startswith(検索文字列)： 始まりの文字列かどうかを判定する
対象の文字列.endswith(検索文字列) ： 終端の文字列かどうかを判定する
apple = 'apple'
# apple に pp が含まれるかどうかを判定する
print('pp' in apple)
# apple がapp で始まるかどうかを判定する
print(apple.startswith('app'))
# apple が le で終わるかどうかを判定する
print(apple.endswith('le'))
True
True
True
split , rsplit , splitlines :
文字列をリストに変換
文字列.split(区切り文字) :
指定したセパレーターをもとに文字列を区切り, リストを返す
文字列.rsplit(区切り文字 , 区切り個数) :
区切りはじめる方向がsplit()と逆から引数指定分までを返す
文字列.splitlines() :
改行ごとに文字列を区切り, リストを返す
リスト型については詳細は次項で説明する。
# , 区切りでリスト型にする
print('aaaa,bbb,ccc'.split(','))
# 区切りはじめる方向がsplit()と逆から引数指定分までを返す
print('aaaa,bbb,ccc'.rsplit(',',1))
# 改行ごとに文字列を区切り, リストを返す
print('aaaa\nbb\ncc'.splitlines())
['aaaa', 'bbb', 'ccc']
['aaaa,bbb', 'ccc']
['aaaa', 'bb', 'cc']
join():
かっこの中のリスト型の文字列を連結する
'区切り文字'.join([文字,文字])
aaa = ','.join(['a','b','c'])
print(aaa)
a,b,c
count():
文字の個数をカウントする
検索対象文字列.count(カウントしたい文字列)
見つかれば個数、見つからない場合は0を返します。
aaa = '平平平平'.count('平')
print(aaa)
aaa = '平平平平'.count('米')
print(aaa)
4
0
ここから下は使う頻度は少ないものですが
文字列関数として備わっているものです。
find , rfind , index , rindex :
文字列の位置の判定を行う
対象の文字列.find(検索文字列) ：
検索文字列を探し, あった場合は, 最小のインデックスを返す
なければ-1を返す
対象の文字列.rfind(検索文字列))：
検索文字列を探し, あった場合は, 最大のインデックスを返す
なければ-1を返す
対象の文字列.index(検索文字列) ：
検索文字列を探し, あった場合は, 最小のインデックスを返す
なければエラーを返す
対象の文字列.rindex(検索文字列)：
検索文字列を探し, あった場合は, 最大のインデックスを返す
なければエラーを返す
# appleから p を探し, あった場合は, 最小のインデックスを返す. なければ-1を返す
print('apple'.find('p'))
# appleから p を探し, あった場合は, 最大のインデックスを返す. なければ-1を返す
print('apple'.rfind('p'))
# pen pine apple pen から e を探し, あった場合は, 最小のインデックスを返す
# なければエラーを返す
print('pen pine apple pen'.index('e'))
# pen pine apple pen からe を探し, あった場合は, 最大のインデックスを返す
# なければエラーを返す
print('pen pine apple pen'.rindex('e'))
1
2
1
16
isalnum , isalpha , isdigit , islower , isspace , istitle :
文字列の構成要素の判定
文字列.isalnum() :
文字がすべて英数文字かどうかの判定
文字列.isalpha() :
文字がすべて英字かどうかの判定
文字列.isdigit() :
文字がすべて数字かどうかの判定
文字列.islower() :
大小文字の区別がある文字がすべて小文字かどうかの判定
文字列.isspace() :
文字がすべて空白かどうかの判定
文字列.istitle() :
文字列がタイトルケース(先頭が大文字)かどうかの判定
# 文字列が英数字だけかどうかを判定する
print('az189898ssss'.encode('utf-8').isalnum())
# 文字列が全て英字だけかを判定する
print('aaaaAAAZZZzz'.encode('utf-8').isalpha())
# 文字列が数字だけかを判定する
print('123112399876'.encode('utf-8').isdigit())
# 小文字だけかどうかを判定する
print('abcdefghijkl'.encode('utf-8').islower())
# 文字が空白かどうかを判定する
print(' '.encode('utf-8').isspace())
# 文字列がタイトルケース(先頭が大文字)かどうかの判定
print('Apple Zedd '.encode('utf-8').istitle())
True
True
True
True
True
True
capitalize , swapcase,title,lower,upper:
大文字, 小文字の変換
文字列.capitalize() :
最初の文字のみを大文字にする
文字列.swapcase() :
大文字を小文字に, 小文字を大文字に変換する
文字列.title() :
文字列をタイトルケース(先頭が大文字)にする
文字列.lower() :
文字をすべて小文字に変換する
文字列.upper() :
文字をすべて大文字に変換する
# 最初の文字のみを大文字にする
print('az189898ssss'.capitalize())
# 大文字を小文字に, 小文字を大文字に変換する
print('az189898SSSS'.swapcase())
# 文字列をタイトルケース(先頭が大文字)にする
print('az189898ssss'.title())
# 文字をすべて小文字に変換する
print('Za189898SsSs'.lower())
# 文字をすべて大文字に変換する
print('az189898ssss'.upper())
Az189898ssss
AZ189898ssss
Az189898Ssss
za189898ssss
AZ189898SSSS
文字列のフォーマット
前の項では文字列の関数について取り扱いました。
その中でも文字列のフォーマットに関する部分は覚えることが多いので
詳しくやっていきたいと思います。
フォーマットとは文字列の出力を制御すること
文字列のフォーマットを行う方法としては3つ方法があります。
1つ目 文字列に特定のフォーマット文字をさしこんでフォーマットする。
2つ目 format関数を使う。
3つ目 文字列型のformat関数を使う。
2,3つ目はformat用の関数を使い、少しだけ書き方が違うだけで
ほぼほぼ一緒です。
format文字でフォーマットする方法
'文字列 %差し込みするデータがに対応する記号' % (変数)
%s : 文字列型
%d : 整数型
%f : 小数点型
%x : 16進法表記
%o : 8進法表記
%%%d : %を付けたい場合
errmsg = "Can't open file"
errcode = 19042
# 文字列に変数の結果を差し込む %s , %d
msg = "ERROR: %s (%d)" % (errmsg, errcode)
print(msg)
ERROR: Can't open file (19042)
上記の例だと通常のprint関数では
文字列型のデータと数値のデータを一緒には取り扱えませんが
フォーマット文字を使った差し込みであればデータの型が違っても扱うことができます。
%s の部分に文字列型
%d の部分に整数型のデータを差し込むことができる。
# 文字列型
print ("%s" % "ABC")
# 整数型
print ("%d" % 123)
# 小数点型
print ("%f" % 1.23)
# 16進法
print ("%x" % 255)
# 8進法
print ("%o" % 255)
# %を表示したい場合
print ("%%%d" % 80)
ABC
123
1.230000
ff
377
%80
フォーマットで便利な点としては%に続く数値で
文字幅や桁数を指定することができます。
#=> | ABC| : 右寄せ5文字分
print ("|%5s|" % 'ABC')
#=> |ABC | : 左寄せ5文字分
print ("|%-5s|" % 'ABC')
#=> | 123| : 右寄せ5桁
print ("|%5d|" % 123)
#=> |123 | : 左寄せ5桁
print ("|%-5d|" % 123)
#=> | +123| : ±符号付き
print ("|%+5d|" % 123)
#=> | 1.23| : 全体桁数.少数点以下の桁数
print ("|%5.2f|" % 1.23)
#=> |00123| : 0埋め
print ("|%05d|" % 123)
| ABC|
|ABC |
| 123|
|123 |
| +123|
| 1.23|
|00123|
format関数を使う方法
format(差し込むデータ , 差し込む先の文字列)
差し込む先の文字列.format(差し込むデータ)
個人的には文字列.format()の方が使いやすので
こちらをメインで説明します。
差し込む先の文字列には{}波カッコを付けて
その中に文字を差し込みします。
aaa = 'このあとに文字を差し込む {} 差し込んだ'.format('さしこ')
print(aaa)
このあとに文字を差し込む さしこ 差し込んだ
{}の部分に文字を差し込むことができます。
複数個の文字の差し込みに対応する場合はインデックスを用います。
{}波カッコ内のインデックス番号が、format関数に入れる順番に対応します。
# １番目は0、２番目は１に、3番目のデータが2のところに入る。
print('{0}-{1}-{2}'.format('100', '二百', 300))
100-二百-300
{0}には初めのデータ,{1}には2個目のデータが差し込まれます。
{}波カッコ内に任意の名前を指定し
キーワード引数として入力することも可能です。
# それぞれの名称に対応する文字が入る
print('{year}年{month}月{day}日'.format(year=2018, month=1, day=11))
2018年1月11日
{year}には引数で指定したyear=の値が差し込まれます。
左寄せ、中央寄せ、右寄せ
< ^ >で左寄せ、中央寄せ、右寄せができます。
全体の文字数を数値で指定し埋める文字を指定することもできます。
省略するとスペースになり、一文字であれば全角でもOKです。
{:寄せ記号 桁数}.format(数値など)
print('left : {:<10}'.format(100)) # 左寄せ
print('center: {:^10}'.format(100)) # センター寄せ
print('right : {:>10}'.format(100)) # 右寄せ
print('left : {:*<10}'.format(100)) # 左寄せ
print('center: {:a^10}'.format(100)) # センター寄せ
print('right : {:鬼>10}'.format(100)) # 右寄せ
left : 100
center: 100
right : 100
left : 100*******
center: aaa100aaaa
right : 鬼鬼鬼鬼鬼鬼鬼100
0埋め
ゼロ埋めして桁数を合わせたい場合は
埋める文字を0に指定して右寄せします。
{:0桁数}.format(数値)
# 5けたで0埋め
print('zero padding: {:05}'.format(123))
zero padding: 00123
桁区切り（カンマ、アンダースコア）
3ケタ毎に,カンマまたは_アンダースコアの区切りを入れられます。
{:,}.format(数値)
{:_}.format(数値)
なお、_アンダースコアはPython3.6で追加されたオプションなので
バージョンが古い場合は使えません。
# カンマで3ケタ区切り
print('{:,}'.format(100000000))
# _ で3ケタ区切り
#print('{:_}'.format(100000000))
100,000,000
小数点以下の桁数指定
全体の桁数を指定するには . のあとに桁数を書きます。
小数点以下の場合は固定小数点数を表すf を付けます。
{:.桁数}.format(数値)
{:.桁数f}.format(数値)
#2桁分まで表示
print('{:.2}'.format(1.234321))
#5桁分まで表示
print('{:.5}'.format(21.23432))
# 小数点5桁分
print('{:.5f}'.format(221.234543))
1.2
21.234
221.23454
算術演算子
プログラミング言語の中では各種の演算を表わす記号・シンボルが存在します。
それを演算子と言っています。
大きく四つに分けると
1.算術演算子(代数)
2.代入演算子
3.関係演算子(比較)
4.論理演算子
になります。
今回はその中で算術演算子についてとり扱っていきます。
算術演算子(または代数演算子)
算術演算子は四則計算をするのに使われる演算子です。
| 記号 | 意味 |
|---|---|
| + | 加算(足し算)) |
| - | 減算(引き算) |
| * | 乗算(掛け算) |
| / | 除算(割り算) |
| % | 剰余(余り) |
| ** | べき乗 |
+足すプラスと-引くマイナス は そのままですが
掛け算と割り算では使える記号が変わります。
掛け算は*アスタリスク
割り算は/スラッシュ
その他、珍しいものでは%剰余があります。
# 足し算(加算)
1+2
# 引き算(減算)
1-3
# かけ算(乗算)
2*3
# 割り算(除算)
10/3
3
2
6
3.3333333333333335
Python3では/スラッシュ１つの場合は結果は小数点まで出ます。
整数値だけにしたい場合は//スラッシュを二つ重ねます。
これで切り捨て除算になります。
# 割り算(余りなし、切り捨て除算)
10//3
# べき乗
2**3
べき乗の記号を用いてルート計算もできます。
# ルート
print(2**0.5)
print(9**0.5)
1.4142135623730951
3.0
特殊な演算方法として剰余といい
割った際の余りを求める方法があります。
余りを求める際には%の記号を使います。
# 剰余(割った際の余り)
print(5%3)
print(5%2)
print(5%5)
2
1
0
この余りという計算は、プログラム内では様々な条件分岐や
判定に応用できます。
計算には優先順序があり、演算子によって変わります。
基本的には数学、算数と同じルールです。
# 掛け算や引き算の優先順位は算数と一緒
2 * 3 + 4
10
足す、引くを優先したい場合は()カッコを用いる
a,b,c = 2,3,4
d = a * b + 4
e = a * (b + 4)
print(d)
print(e)
10
14
四則計算はプログラミングの基本になるので
しっかりと書き方を覚えておきましょう。
代入演算子
プログラミングではデータを格納することを
代入といっています。
その代入の仕方に関わる演算子が代入演算子です。
代入は = イコール記号となります。
文字を代入する場合は'シングルクォートや"ダブルクォートで囲み
数値を代入する場合はそのまま数字を入力します。
# 変数a に数値 121を代入
a = 121
print(a)
121
代入は=イコールの左側にある変数に
右側の計算結果を入れ込むような働きをします。
# 変数 a , b を用意
a , b = 2 , 3
print(a)
# a = a + b と同じ意味合い
a += b
print(a)
2
5
a に b を足した結果を 再度 aに代入する ということになります。
a = a + b と同じ意味合いになります。
結果は 最初にaに2 , bに3が入っているので2 + 3が
aの中に入ります。
この代入演算子を使った方法はプログラムでよく用いられます。
特に+=1でその変数の値を1ずつ足していく方法は
かなりの頻度で用いられます。
その他の代入演算子について
a = b # a に b を代入する
a += b # a = a + b に同じ
a -= b # a = a - b に同じ
a *= b # a = a * b に同じ
a /= b # a = a / b に同じ
a %= b # a = a % b に同じ
a **= b # a = a ** b に同じ
a //= b # a = a // b に同じ
左側の変数に、右側の変数を足したり引いたりした
結果を代入するというようなことが行えます。
# 変数 a , b を用意
a , b = 2 , 3
print(a)
# 何度か足してみる
a += 2
a += 5
print(a)
2
9
代入するたびに変数の値は変化します。
この1行で変数の中身が大きく変化していきますので
どこでどう値を変更しているのかといったことが
すぐに把握できるように、演算子の使い方は押さえておきましょう。
関係演算子
=イコール一つの場合は代入で値を格納することになりました。
==イコールを二つ用いると、今度は左側と右側を比較する動きになります。
比較のしかたが複数あり、演算子も複数存在します。
こういった比較をする演算子を、関係演算子や比較演算子と言っています。
数値の比較
まずは数値のデータを用意します。
変数aとbを用意して
a , b = 2 , 3
== : 演算子の左と右が等しいかどうかを判定する
等しい場合はTrue , 等しくない場合はFalseが返ってきます。
# a が b と等しいかどうかの判定
a == b
False
!= : 演算子の左と右が等しくないかどうかを判定する
等しくない場合はTrue , 等しい場合はFalseが返ってきます。
# a が b と異なるかどうかの判定
a != b
True
< : 演算子の左が右より小さいか比較する
演算子の左側が右側よりも小さい(未満)であったらTrue
違えばFalseが返ってきます。
# a が b よりも小さい(未満) 小なり
a < b
True
> : 演算子の左が右より大きいか比較する
演算子の左側が右側よりも大きければTrue
違えばFalseが返ってきます。
# a が b よりも大きい 大なり
a > b
False
大なり小なりに=イコールをつけると、以上と以下という意味になります。
<= : 演算子の左側が右側以下であればTrue , 違えば Falseが返ってきます。
# a が b 以下である 小なりイコール
a <= b
True
>=:演算子の左側が右側以上であればTrue , 違えばFalseが返ってきます。
# a が b 以上である 大なりイコール
a >= b
False
大小を比較する演算子は数値の計算にしか
正しく用いることができませんので
変数に格納するデータの形には注意して下さい。
文字列の比較
文字列の比較は
== (等しいかどうかの判定)
!= (異なるかどうかの判定)
not (否定)
in (含まれるかどうかの判定)
などを用います。
判定が正しければTrue , 正しくなければFalseを返します。
a , b = 'a' , 'b'
# a が b と等しいかどうかの判定
print(a == b)
# a が b と異なるかどうかの判定
print(a != b)
# a が b に含まれるかどうかの判定
print(a in b)
# a が b に含まれないかどうかの判定
print(a not in b)
False
True
False
True
特に文字が含まれるかどうか、という判定はよく用いられます。
文字の検索結果を利用したプログラムの制御は頻繁に出てきますので
in演算子 を使った比較の方法は押さえておきましょう。
このように文字や数値を比較すると
その結果はTrue or Falseのbool型で返ってきます。
比較した結果を用いてプログラムを制御する方法が
プログラムでは多用されるので書き方は覚えておきましょう。
論理演算子
論理演算子は比較の結果同士を加算した結果を返します。
幾つかの条件を組み合わせる場合には必ず用いる方法です。
論理演算子としては 3つしかありません。
and , or , not
and
andは条件と条件をつなげます。
日本語だと かつ という意味合いになります。
条件A and 条件B
条件が双方が True の場合にTrue
どちらか一方でもFalseなら結果がFalseになります。
andの左側と右側の両方の条件を満たしていないと
Trueにはなりません。
# 二つの条件がTrue
print(True and True)
# 片方の条件がFalse
print(True and False)
print(False and True)
# 両方の条件がFalse
print(False and False)
True
False
False
False
# 数値型での例
print(1==1 and 2==2)
print(1==1 and 2==1)
True
False
男性、20代の人のような複数の条件を満たす判定を
行いたいような時に使います。
a , b = 20 , '男性'
print(a==20 and b == '男性')
True
or
orの左側と右側、どちらかの条件がTrueであればTrueを返します。
日本語の意味だと もしくは という意味合いです。
条件A or 条件B
両方満たしていればTrue
どちらか一方でも合っていればTrueが返ってきます。
両方の条件を満たせない場合のみFalseが返ってきます。
# 二つの条件がTrue
print(True or True)
# 片方の条件がFalse
print(True or False)
print(False or True)
# 両方の条件がFalse
print(False or False)
True
True
True
False
# 両方の条件を満たす場合
a , b = 20 , '男性'
print(a==20 or b == '男性')
# どちらかの条件を満たす場合
a , b = 20 , '男性'
print(a==30 or b == '男性')
# 両方の条件を満たさない場合
a , b = 20 , '男性'
print(a==30 or b == '女性')
True
True
False
not
notは否定する意味合いになり、結果をひっくり返します。
TrueはFalseに 、 FalseはTrueにします。
# 含む場合
d = '男性'
print('男' in d)
True
# 含まれないとしたい場合
d = '男性'
print('男' not in d)
False
プログラムの中での制御は比較演算子と論理演算子を組み合わせて
どう処理を分岐させるか、続けさせるのかを組み上げていきますので
論理演算子の使い方も覚えておきましょう。
論理演算のまとめ
| 論理演算 | 結果 |
|---|---|
| True and True | True |
| True and False | False |
| False and True | False |
| False and False | False |
| True or True | True |
| True or False | True |
| False or True | True |
| False or False | False |
基礎演習1
さーてみなさん、ここまでの講義のおさらいをしてみましょう。
ここまででやったこととしては・・
演算の仕方、文字列の書き方、インデックスって何・・
変数とデータ型、いろいろな演算子
他のプログラム言語でも共通した考えになる部分をやりました。
今回の講義はそのおさらいとなります。
復習用の問題を用意しましたので、それを解いてみましょう。
もしわからなければ、今までの講義の動画や解説をもう一度見てみましょう。
基礎演習問題1:
文字列型の変数を宣言してみよう(値は任意で10文字以上)
基礎演習問題2:
5文字以上の文字列型の変数を作成し、4番目の文字を取り出そう。
基礎演習問題3:
文字列型の変数を作成し、改行、タブを含めた文章を代入する。
基礎演習問題4:
format関数を使い次の文章の入力部{}(波カッコ)に、
任意の名前を入れてを出力する :
私がナイツの{0}です、相方の名前はね、ちょっと汚い話になりますが・・・{1}です。
基礎演習問題5:
5桁の整数型の変数を作成し,
これを文字列に直し7ケタで0埋めして出力する。
基礎演習問題6:
2つの整数型の変数に整数値を入れて、その大小を比較する文を書く。
基礎演習問題7:
次の文章の中に、浦和という言葉がいくつあるか数える文を書く。
浦和、南浦和、北浦和、東浦和、西浦和、武蔵浦和、中浦和、浦和は7つの駅がある。
基礎演習問題8:
無駄を改行ありで10回表示させる文を書く。
基礎演習問題9:
9の9乗を計算する文を書く。
基礎演習問題10:
9の20乗と20の9乗 、どちらが大きいか、判定結果を出力する文を書く。
すぐに答えが出ない人は、動画を止めて考えてみましょう。
コツとしては何を入力したら、どう計算されて、どう出力されるのか
それを考えながら書いてみましょう。
答えはこの下に
回答
基礎演習問題1:回答
文字列型の変数を宣言してみよう(値は任意で10文字以上)
# データとして文字列にするにはシングルクォートかダブルクォートで囲むだけ
answer = '生麦生米なまたまご、字足らず'
print(answer)
生麦生米なまたまご、字足らず
基礎演習問題2:回答
5文字以上の文字列型の変数を作成し、4番目の文字を取り出そう。
# インデックスを用いてx番目のデータを取り出せる
# 4番目のインデックス値は 3
answer = '123456789'
print(answer[3])
基礎演習問題3:回答
文字列型の変数を作成し、改行、タブを含めた文章を代入する。
# まず文字列型の変数を用意
# 改行やタブはエスケープシーケンスを用いて表現する
answer = 'こんにちは 福山雅治です、\n私は\tおおきい\tです。'
print(answer)
こんにちは 福山雅治です、
私は おおきい です。
基礎演習問題4:回答
format関数を使い次の文章の入力部{}(波カッコ)に、
任意の名前を入れてを出力する :
私がナイツの{0}です、相方の名前はね、ちょっと汚い話になりますが・・・{1}です。
# まず文字列型の変数を用意
answer = '私がナイツの{0}です、相方の名前はね、ちょっと汚い話になりますが・・・{1}です。'
# format関数を使って値を差し込む
print(answer.format('塙','小峠'))
私がナイツの塙です、相方の名前はね、ちょっと汚い話になりますが・・・小峠です。
基礎演習問題5:回答
5桁の整数型の変数を作成し,
これを文字列に直し7ケタで0埋めして出力する。
# まずは5桁の整数型の変数を用意
answer = 12345
# これを文字列に直し7ケタで0埋めして出力する。
# フォーマット関数を使うと数値型のものを文字列の中に差し込みできる。
# 0埋めは、: コロン のあとに埋めたい文字 0を入れ桁数7を入力する
print({0:07}'.format(answer))
0012345
基礎演習問題6:回答
2つの整数型の変数に整数値を入れて、その大小を比較する文を書く。
# まずは二つの数値を用意
a , b = 20 , 30
# 大小の比較は 比較演算子(関係演算子)を用いる
print(a < b)
print(a > b)
True
False
基礎演習問題7:回答
次の文章の中に、浦和という言葉がいくつあるか数える文を書く。
浦和、南浦和、北浦和、東浦和、西浦和、武蔵浦和、中浦和、浦和は7つの駅がある。
# まずは文字列型の変数を用意
answer = '浦和、南浦和、北浦和、東浦和、西浦和、武蔵浦和、中浦和、浦和は7つの駅がある。'
# count関数で文字の個数を数えることができる。
print(answer.count('浦和'))
8
基礎演習問題8:回答
無駄を改行ありで10回表示させる文を書く。
# アスタリスク * を使うと、文字の繰り返しを表現できる。
# 改行は ¥n もしくは \n
print('無駄\n' * 10)
無駄
無駄
無駄
無駄
無駄
無駄
無駄
無駄
無駄
無駄
基礎演習問題9:回答
9の9乗を計算する文を書く、
# 掛け算はアスタリスク一個 , 累乗はアスタリスク２個
print(9 ** 9)
387420489
基礎演習問題10:
9の20乗と20の9乗、どちらが大きいか、判定結果を出力する文を書く。
# 9の20乗と20の9乗 を比較演算子で大小を比較する
print(20 ** 9 < 9**20)
True
リスト
プログラム言語の中では特殊なデータの形を取り扱うことができます。
それが辞書型やリスト型といったデータ構造のものです。
リスト型のデータを作るには[ ]四角カッコを用います。
四角カッコで括った中に、格納したいデータの形でデータを入力します。
リスト型の値は、要素を複数持つことができます。
リストの値に要素をたくさん入れ込むには,カンマでつなぎます。
リスト型の定義
[]
[要素,要素,・・・]
リストの例:
[1,2,3]
# リスト型
l1 = [1,2,3,4,5]
# 空のリスト(まだ要素を持っていない)
l2 = []
print(l1)
print(l2)
[1,2,3,4,5]
[]
リスト型というのは複数の要素を持ったデータ構造になっていて、
リスト型の中に入れられるデータの形については特に決まりはなく
どんなデータでも入れられます。
a = [1,2,3,'4']
print(a)
[1, 2, 3, '4']
リストの要素は違うデータ型を混在させることもできます。
[]を用いるのでインデックスと間違えやすいので気をつけましょう。
Python言語のリスト型はインデックスを用いて参照します。
リストの要素の参照
リスト型のデータ[インデックス値]
# リストの中にリストを定義
lis_lis = [[1,2,3],[4,5,6],[7,8,9]]
print(lis_lis)
# 取り出しもインデックスで
print(lis_lis[1][2])
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
6
リストの中にリストを格納できます。
その場合は多重リストになるので取り出す[]の指定も
その多重の分だけ書くことになります。
またインデックスにはスライスという機能があり
開始、終了などを指定すること出来るので
取り出される要素もスライスの仕方で変わります。
リスト型[インデックス値] : 1つだけ要素を取り出す。
リスト型[開始:終了] : 開始から終了までの複数の要素を取り出せる。
リスト型[開始:] : 開始から末尾までの複数の要素を取り出せる。
リスト型[:終了] : 最初から終了までの複数の要素を取り出せる。
リスト型[開始:終了:飛ばす数] : 開始から終了までn個飛ばしで複数の要素を取り出せる。
a = [1,2,3]
# 最初の要素を取り出す
print(a[0])
1
a = [1,2,3,4,5]
# 複数の要素を取り出す(3番目から4番目まで)
print(a[2:4])
[3, 4]
a = [1,2,3,4,5]
# 複数の要素を取り出す(２番目から最後まで)
print(a[1:])
# 複数の要素を取り出す(最初から3番目まで)
print(a[:3])
[2, 3, 4, 5]
[1, 2, 3]
リストでは要素の順番が重要になります。
スライスを使うと複数の要素に対応します。
リストの要素の追加
リストの要素の追加方法は多岐に渡ります。
値を一つだけ入れるのがappend
その他はリストをリストに追加する方法です。
変数.append(要素)
変数 += リスト
変数.extend(リスト)
リスト + リスト
a = [1,2,3]
# 要素の追加 append
a.append(4)
print(a)
[1, 2, 3, 4]
a = [1,2,3]
# 要素の追加 +=
a += a
print(a)
[1, 2, 3, 1, 2, 3]
a = [1,2,3]
# 要素の追加 extend
a.extend([4,5])
print(a)
[1, 2, 3, 4, 5]
a = [1,2,3]
# 要素の追加 リスト + リスト
a = a + a
print(a)
[1, 2, 3, 1, 2, 3]
リスト型の値は複数の要素をいれ込めるので
取り出し方も様々な取り出し方があります。
要素の変更
要素の変更方法はインデックスを用いて抽出をした所に
代入を行って変更を行います。
リスト型変数[インデックス値] = 変更後の値
リスト型変数[開始:終了] = [リスト]
リスト型変数[開始:] = [リスト]
リスト型変数[:終了] = [リスト]
a = [1,2,3,4,5]
print(a)
# ３番目の要素を 9 に変更
a[2] = 9
print(a)
[1, 2, 3, 4, 5]
[1, 2, 9, 4, 5]
a = [1,2,3,4,5]
# 複数の要素を変更(3番目から4番目まで
a[2:4] = [9,8]
print(a)
a = [1,2,3,4,5]
# 複数の要素を変更(２番目から最後まで)
a[1:] = [7,6]
print(a)
a = [1,2,3,4,5]
# 複数の要素を変更(最初から3番目まで)
a[:3] = [8,8,8,8]
print(a)
[1, 2, 9, 8, 5]
[1, 7, 6]
[8, 8, 8, 8, 4, 5]
インデックスの開始、終了を用いた場合は複数の要素が同時に置き換わるので
順番にも影響が出ます。注意しましょう。
要素の削除
リストから要素を削除する方法もいくつかあります。
del とインデックスを使う方法
del リスト[インデックス値]
del リスト[開始:終了]
l = ["A", "B", "C", "D", "E", "F", "G"]
print (l)
# 2番目を削除
del l[1]
print (l)
# さらに2番目,3番目を削除
del l[1:3]
print (l)
['A', 'B', 'C', 'D', 'E', 'F', 'G']
['A', 'C', 'D', 'E', 'F', 'G']
['A', 'E', 'F', 'G']
インデックス値1つだけの時は要素1つ
開始終了などで複数指定した場合は、複数の要素が削除されます。
pop関数を使って削除
リスト.pop(インデックス値)
pop関数を用いる場合、要素が無いとエラーになるので注意しましょう。
l = ["A", "B", "C", "D", "E", "F", "G"]
print (l)
# 4番目を削除
l.pop(3)
print (l)
['A', 'B', 'C', 'D', 'E', 'F', 'G']
['A', 'B', 'C', 'E', 'F', 'G']
l = ["A", "B", "C", "D", "E", "F", "G"]
# 要素がない場合はエラーになる
l.pop(8)
IndexError ：
インデックスの値が要素数を超えていたりする場合に発生するエラー
remove関数を使って削除
リスト.remove(指定の値)
remove関数も、指定の値が無いとエラーになります。
l = ["A", "B", "C", "D", "E", "F", "G"]
print(l)
# 要素の A を削除
l.remove('A')
print (l)
['A', 'B', 'C', 'D', 'E', 'F', 'G']
['B', 'C', 'D', 'E', 'F', 'G']
l = ["A", "B", "C", "D", "E", "F", "G"]
# 要素がない場合はエラーになる
l.remove('H')
ValueError :
リストに削除する値が含まれていないから発生したエラー
pop,removeで削除するには、有ったら削除するという工夫が必要です。
リストの要素の検索
リストの機能ではないですが
in演算子を用いてリストの要素の値の検索ができます。
値 in リスト型
in演算子を用いると
中身が検索できて、その結果がbool型で返ってきます。
l = ["A", "B", "C", "D", "E", "F", "G"]
print ('K' in l)
False
このbool型の結果を用いて有ったら削除するということができます。
リストの要素の並べ替え
並べ替えはsort関数を使って行います。
文字列の場合はABCなどの文字順、数値の場合は数値の大小の順番です。
昇順：リスト.sort()
降順：リスト.sort(reverse=True)
a = [1,4,3,5,6]
print(a)
# 昇順で並び替え
a.sort()
print(a)
[1, 4, 3, 5, 6]
[1, 3, 4, 5, 6]
a = [1,4,3,5,6]
print(a)
# 降順で並び替え
a.sort(reverse=True)
print(a)
[1, 4, 3, 5, 6]
[6, 5, 4, 3, 1]
要素を逆に並び替える
要素の大小ではなく、元の順番の逆に並び替える方法です。
リスト.reverse()
a = [1,4,3,5,6]
print(a)
# 格納した逆の順番で並び替え
a.reverse()
print(a)
[1, 4, 3, 5, 6]
[6, 5, 3, 4, 1]
リストは複数の値を確保できるので
様々な用途でプログラムでは用いられます。
使用頻度もTop3くらいにはなるかと思いますので
取り扱い方は押さえておきましょう。
タプル
リストと同じようなデータとしてタプル型というものがあります。
タプルは、一度定義したら追加、変更などができないデータ型です。
pythonでは()丸括弧 で定義することができます。
(要素)
リストとの大きな違いは値の追加や変更ができないという点です。
一度、変数を作ったらその変数の中の要素を変更したり付け足したり
削除したりすることができないリストだと思ってください。
なので、用途としては変わることのないものを格納しておく
というような使い方になります。
# ５つの要素をもったタプルを定義
a = (1,2,3,4,5)
print(a)
(1, 2, 3, 4, 5)
# 要素を持たないタプルも定義できるが意味がない
b=()
print(b)
()
要素の取り出しについてはリストと同じく
インデックスとスライス機能を使ったりすることができます。
# タプルの３番目の要素を取り出す
a = (1,2,3,4,5)
print(a[2])
3
# タプルの2-4番目の要素を取り出す
a = (1,2,3,4,5)
print(a[1:4])
(2, 3, 4)
要素の追加、削除、変更はできません。エラーが発生します。
# タプルの要素の追加
c = (1,3,5,7,9)
c.append(11)
AttributeError: 'tuple' object has no attribute 'append'
# タプルの削除
d = (1,3,5,7,9)
del d[2]
TypeError: 'tuple' object doesn't support item deletion
# タプルの要素の変更
e =(2,3,4,5,6)
e[3]=13
TypeError: 'tuple' object does not support item assignment
定義されたタプルの要素に手を加えようとするとエラーが発生します。
ただし、タプルとタプルを組み合わせて別のタプルを作り
要素の追加のようなことはできます。
t1 = (1,2,3,4,5)
t2 = (2,3,4,5,6)
t3 = t1 + t2
print(t3)
(1, 2, 3, 4, 5, 2, 3, 4, 5, 6)
このように
一度作ってしまえば要素は変わらないような使いみちであれば
間違って書き換える心配のないタプルが適しています。
タプルという形のデータもあるんだよ、ということを
押さえていただければと思います。
辞書型
リストと同じくpythonの中で最も使われるデータの形が
辞書型とよばれるデータ構造です。
辞書型はキーと値をペアにして
複数の要素を管理することができます。
キーは整数だけではなく、文字で設定可能です。
値は様々な型を用いることができます。
また、リストとは違って、順番は特に関係ありません
辞書型の作成
辞書型は{}波カッコで定義でき
キーと値を要素として格納できます。
{キー:値}
# キーが数値の辞書型の例
d1 = {1:10,2:20}
print(d1)
{1: 10, 2: 20}
# キーが文字列の辞書型の例
d2 = {'a':10,'b':20}
print(d2)
{'b': 20, 'a': 10}
辞書の要素の参照
変数名[キー]で値を返すことができます。
ただし、キーが無いとエラーになってしまいます。
# 5つの要素を登録
sample_dic_data = {'apple': 100, 'banana': 100,
'orange': 300, 'mango': 400, 'melon': 500}
# キーがmelonの要素を返す
print(sample_dic_data['melon'])
500
sample_dic_data = {'apple': 100, 'banana': 100,
'orange': 300, 'mango': 400, 'melon': 500}
# キーがgrapeの要素を返す
print(sample_dic_data['grape'])
KeyError: 'grape'
要素の中にそのキーが無い場合はKeyErrorが発生します。
辞書型の機能としては要素の追加、変更、削除もリストと同様にできます。
要素の追加
変数名[キー名] = 値
d3 = {1:2 , 3:4}
print(d3)
# 辞書の要素の追加
d3[5] = 8
print(d3)
{1: 2, 3: 4}
{1: 2, 3: 4, 5: 8}
すでに存在するキーを指定した場合は値を上書きして変更されます。
d4 = {1:2 , 3:4}
print(d4)
# 辞書の要素の変更
d4[1] = 18
print(d4)
{1: 2, 3: 4}
{1: 18, 3: 4}
キーの検索
リストと同じようにinを用いて
キー in 辞書
とすると、キーが存在している場合はTrueなければFalseが返ります。
d5 = {3:4 , 5:6 , 7:8}
# キー名で検索
print( 7 in d5)
print( 11 in d5)
True
False
mydict = {'pen':1 , 'pineapple':2 , 'apple':3}
print('apple' in mydict)
True
キーを文字列で設定した場合は探す時のキーも文字列で
整数値でキーを設定したら探す時も整数の値で探すことになるので
キーを検索する際のデータの形は注意しましょう。
辞書の要素の削除
全ての要素の削除
辞書変数名.clear()
要素を指定して削除
del 辞書変数名[キー]
辞書変数名.pop(キー)
delは消した値を返さ無いがpopは値を返します。
d6 = {'pen':1 , 'pineapple':2 , 'apple':3}
print(d6)
# キーで削除
del d6['pen']
print(d6)
# 要素の全削除
d6.clear()
print(d6)
{'apple': 3, 'pineapple': 2, 'pen': 1}
{'apple': 3, 'pineapple': 2}
{}
d7 = {'pen':1 , 'pineapple':2 , 'apple':3}
print(d7)
# pop関数でキーで削除
print(d7.pop('pen'))
print(d7)
{'apple': 3, 'pineapple': 2, 'pen': 1}
1
{'apple': 3, 'pineapple': 2}
popは消した値を用いて何かをする場合に使います。
d8 = {'pen':1 , 'pineapple':2 , 'apple':3}
print(d8)
# pop関数で存在しないキーで削除
print(d8.pop('penpen'))
KeyError: 'penpen'
値の参照と同じく、存在しないキーを削除するとエラーになります。
キーがない場合でも安全に消したい場合はpopに第二引数を追加します。
辞書変数名.pop(キー名 , 返す値)
d9 = {'pen':1 , 'pineapple':2 , 'apple':3}
print(d9)
# pop関数で存在しないキーで削除
print(d9.pop('penpen' , None))
{'apple': 3, 'pineapple': 2, 'pen': 1}
None
こうするとこのキーで要素があった場合はその値を
要素がなければ、第二引数の値を返すようにできます。
Noneを設定しておくと、何も起きないように見えるので
安全に消すことができます。
後の講義に出てくるIF文や検索の機能を使って
キーが有ったら、という工程を挟むことでも
うまく消すことができます。
この消した値を使って何かする場合は、少しだけ
テクニックが必要になるので注意しましょう。
全ての要素の参照
辞書型は複数のデータが格納されるので
全ての要素を参照する方法が用意されています。
辞書型の要素はキーと値で構成されているので次の３つの参照方法があります。
辞書型変数.keys() : キーのリストを返す。
辞書型変数.values() : 値のリストを返す。
辞書型変数.items() : キーと値のリストを返す。
# 辞書を定義
mydict = {"pen":1, "pineapple":2, "apple":3}
# キーのリストを返す。
print(mydict.keys())
# 値のリストを返す。
print(mydict.values())
# キーと値のリストを返す。
print(mydict.items())
dict_keys(['apple', 'pineapple', 'pen'])
dict_values([3, 2, 1])
dict_items([('apple', 3), ('pineapple', 2), ('pen', 1)])
少しややこしいのですが
辞書型からリスト型に変換されたデータを取得することができます。
キーと値のリストを返すitems()では
キーと値をタプル型にまとめたものが
リストの要素として格納されているものが返ってきています。
返ってきたリスト型の中身がタプル型の値になっているので
そこからキーと値を取り出す、ということをします。
この全てを参照する使い方については
繰り返しのfor文のところで詳しくやっていきたいと思いますので
まずは 辞書型の取り扱い方を覚えましょう。
辞書はpythonのなかでも最もよく使うデータ型になると思いますので
繰り返し試してみるのが良いと思います。
制御文
pythonでは条件分岐や繰り返しなど
プログラムを制御するための文法が存在します。
それを制御文と呼んでいます。
制御文はプログラミングを行う上で欠かせないもので
あらゆるところで出てきます。
書き方、使い方を押さえておきましょう。
if文
if文は条件分岐を行うための構文です。
if文の書き方
if 条件:
処理
if 条件:
処理
else:
処理
if 条件:
処理
elif 条件 :
処理
・・・
まずはIF単独の場合
条件を書いて:セミコロンを末尾に書きます。
# if文で条件に合致した場合printする
if 1<2:
print('1より２の方がおっきい')
1より２の方がおっきい
その条件に合致した場合にだけif文の中の処理が実行できます。
なお注意として制御文を使う場合、処理を書くブロックは
インデント(字下げ)といって空白４つ分ずらしてあげないといけません。
また空白４つはタブでも代用可能です。
if 1<2:
print('1より２の方がおっきい')
IndentationError: expected an indented block
インデントを行わないとエラーになります。
# 条件はTrue or False
hh = 8
if hh== 8:
print(hh)
8
if文では条件はbool型、真偽値になるものを採用できます。
次に条件に合致しなかった場合は
if文のあとにelse: と書いて
条件に合致しない場合の分岐処理も書くことができます。
hh = 7
if hh== 8:
print('{}時だよ、全員集合'.format(hh))
else:
# 条件に合致しなければこちらが実行される。
print('{}時だよ、全員解散'.format(hh))
7時だよ、全員解散
条件が複数ある場合
elif 条件: で条件を増やすことができます。
hh = 9
if hh== 8:
print('{}時だよ、全員集合'.format(hh))
elif hh==9:
# 条件に合致すれば実行される。
print('{}時だよ、全員遅刻'.format(hh))
else:
# 条件に合致しなければこちらが実行される。
print('{}時だよ、全員解散'.format(hh))
9時だよ、全員遅刻
if文では条件が合致したところだけ実行されます。
条件を分岐させたい時にだけelseやelifを使えば良いです。
条件が複数にまたがる場合
ネストと言って、if文の階層を作ることができます。
その場合、if文の階層の分だけインデントを行います。
aa = 2
bb = 50
if aa == 2:
if bb == 50:
print('江頭{0}時{1}分'.format(aa,bb))
else:
print('江頭{0}時'.format(aa))
else:
print('江頭')
江頭2時50分
インデントの位置で処理が変わってしまうので注意しましょう。
ネストを使うことでどんな条件でも
書き分けることができるようになります。
ただし、あまりネストを使いすぎると
わけわからなくなってきます。みるのも大変です。
あまり深い階層になってしまった場合は
そもそもの処理や条件などを見直した方が良いと思います。
またif文では何かしら処理を書かないとエラーになってしまいます。
if 1<2:
SyntaxError: unexpected EOF while parsing
特に処理を思いつかない場合はとりあえずpassというのを書きます。
if 1<2:
pass
passは何もしない処理を現します。
制御文だけを書いて、処理を書かずに実行すると
エラーになるので回避のために使えます。
pythonではインデントで処理するブロックが変わってきます。
なのでif文の中の処理なのか、その前の処理になるのかで
全体の処理が大きく変わってくることがありますので
どういう処理をさせるのかを考えてインデントをしてください。
for文
pythonで処理を繰り返し行う場合はforを使っていきます。
forの書き方
for 任意の変数名 in イテラブルオブジェクト:
処理
イテラブルオブジェクトとは？
イテラブルオブジェクトとは、繰り返しができるオジェクト
要は複数要素をもつオブジェクトの事のことです。
例えば変数に文字列を格納すると
aaaa = 'abcde12345'
print(aaaa)
abcde12345
これは文字列のオブジェクトになります。
オブジェクト指向ではデータをオブジェクトとして扱うので
データを格納した変数もまたオブジェクトと同じものだと言えます。
ではイテラブルオブジェクトってなんでしょうか？
これは繰り返しができるという意味で、
複数要素をもつオブジェクトのことになります。
要はリスト型や辞書型や文字列型のようなデータ構造のオブジェクトとなり
Python言語ではこのオブジェクトを用いて繰り返しを行います。
簡単なfor文の例
# 5回繰り返し処理を行う
for i in [1,2,3,4,5]:
print(i)
1
2
3
4
5
これが一番シンプルな繰り返しです。
for文の中の繰り返される処理の部分はインデント(字下げ)をしてください。
繰り返し行う回数というのがinのあとに書いた
イテラブルオブジェクトの要素数分だけ行われます。
ここでforの後に書いたiという変数は
繰り返しの中で使うことのできる変数になります。
変数名は任意で変更できます。
それぞれ1回目はこのリストの１つ目がこのiに代入される
2回目は2つ目・・・
という仕組みになっているので
このリストの要素数分だけ処理が実行されるという仕組みです。
リストは変数に代入しておいても同じように動きます。
# リスト型の変数に6つの要素を格納する
sample_list =[ 1,2,3,4,5,6]
# 6回繰り返し処理を行う
for i in sample_list:
print(i)
1
2
3
4
5
6
回数を指定したい場合
range関数で回数分の値を生成する。
forに使用する回数部分はイテラブルオブジェクトでなければならないため
代わりにrange関数でオブジェクトを生成して代用をします。
range関数では指定した個数のオブジェクトを作成できるので
for文の回数指定に代用できるという仕組みです。
range関数の書き方
range(整数値)
range(開始,終了)
range(開始,終了,間隔)
range関数は引数に指定した整数値の分だけ
数値を生成してくれます。
引数を追加すると開始、終了の数値、間隔を調整する事もできます。
# 10個の数値を持ったオブジェクトを生成
print(range(10))
range(0, 10)
range関数の結果はrange型になります。
ただしこれはリスト型ではないので分かりづらいです。
リスト型に変換してみましょう。
print(list(range(10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
これでリスト型になり中身がわかりやすくなります。
range関数では0から始まって引数分だけ整数値を生成しますが
注意点としては0から始まるので終わりは指定した値にならないので注意してください。
指定した値 -1になっています。
for i in range(3):
print(i)
0
1
2
# range関数で4回だけ実行する場合
for i in range(4):
print(i)
0
1
2
3
開始終了を指定する場合、第一引数から始まって、第二引数まで、となります。
この場合は５から10の１つ手前までの値を生成します。
# 5から9まで
for i in range(5,10):
print(i)
5
6
7
8
9
第三引数を指定すると、どれだけ加算するかを決められます。
マイナスの値を指定すると、引いていくこともできます。
# 2から10手前までの偶数
for i in range(2,10,2):
print(i)
2
4
6
8
# 20から10手前までの3個飛ばしで
for i in range(20,10,-3):
print(i)
20
17
14
11
文字列での繰り返し
繰り返しは基本、なんらかのオブジェクトを用いてその要素数だけ実行するか
range関数を使って指定した回数だけ実行するか
ということになります。
文字列を指定すると、その文字数分だけ実行されます。
# 文字列型の文字数だけ実行する場合
for i in 'apple':
print(i)
a
p
p
l
e
繰り返しの途中で抜ける場合(break)
for文の中で処理を抜けたい場合はbreakを用います。
breakが実行されるとfor文のブロックを抜けることになります。
li = ['Alice', 'in', 'Chains']
for name in li:
if name == 'in':
print('!!BREAK!!')
# ここで抜ける
break
# 2回目の処理は行われない
print(name)
Alice
!!BREAK!!
この場合は繰り返しの２回目でif文の条件に引っかかり、
その中のプリント文とbreakが実行されます。
そうなると途中で抜けた場合は、抜けた後以降の処理は行われません。
結果として２回目のプリントの前に抜けた、ということになります。
for文でもelseが使用できます。
elseの部分は一番最後に実行されます。
for i in ['Alice', 'in', 'Chains']:
print(i)
else:
# for文の後に実行される
print('処理終了')
Alice
in
Chains
処理終了
breakによって途中絵終了した場合には
elseの処理は実行されません。
li = ['Alice', 'in', 'Chains']
for name in li:
if name == 'in':
print('!!BREAK!!')
break
print(name)
else:
# break後は実行されない
print('!!FINISH!!')
Alice
!!BREAK!!
処理の途中で処理を飛ばす場合(continue)
breakは完全に処理を抜けてしまいますが
処理の一部だけを飛ばして、まだ処理を続けたい時は
continueを使います。
li = ['Alice', 'in', 'Chains']
for name in li:
if name == 'in':
print('!!continue!!')
# ここで処理を飛ばす
continue
# continue後は実行されない
print(name)
else:
# 最後に実行される
print('!!FINISH!!')
Alice
!!continue!!
Chains
!!FINISH!!
for文はプログラムの中でも高頻度で使われるもので
プログラムでは必須です。
どう処理を組み立てれば良いかを考えながら
for文を用いていきます。
特に2回以上行うような複雑な処理を2回以上書くよりは
for文1回で済ませてしまう方が楽になるので
使い方なども研究してみてください。
while文
制御文の最後はwhile文です。
for文では繰り返しの回数が決まっていましたが
whileでは条件を満たすまで繰り返し続けます。
whileの書き方
while 条件 :
処理
処理を書くところはインデント(字下げ)が必要になります。
while True:
しかしこう書いてしまうと、繰り返しがずっと行われてしまい
いつまでたっても終わりません。
jupyter notebook上で止めたい場合は
画面上部の四角ボタン(停止)を押して止めてください。
while文は条件を抜けるような処理を書いてあげないと
永久ループになってしまうので、注意が必要です。
while文の例：
sample_int =1
while sample_int <= 10:
print(sample_int)
sample_int = sample_int + 1
1
2
3
4
5
6
7
8
9
10
このようにして、変数などを条件に用いてwhile文の中で
変数を条件に合致しないように変更すると
whileの繰り返しを抜けることができます。
あらかじめカウント用の変数を用意したり、
フラグ値を用いたりすることでwhile文を抜けるのが
一般的な使い方になります。
forと同じようにcontinueやbreakも使えます。
i=0
while i<5:
if i ==2:
i+=1
continue
print(i)
i+=1
0
1
3
4
i=0
while i<5:
if i ==2:
break
print(i)
i+=1
0
1
continueは条件が満たされ続ける限りは
繰り返しが実行され続けるので注意しましょう。
組み込み関数について
pythonでは標準の機能として
組み込み関数というのが備わっています。
この講座のはじめから使っている
print関数なども組み込み関数です。
プログラムには欠かすことのできない機能であるため
組み込み関数の使い方を学んでいきましょう。
関数の使い方
関数名(引数,・・・)
関数名の後の()カッコに指定するものを引数と言い
引数は関数によっては複数存在することもあります。
その場合は,カンマで区切ることで、
何番目の引数に該当するかを指定できます。
関数を実行した結果は、何かしらの値が返ってくることがあります。
この返却される値のことを戻り値と言っています。
様々な組み込み関数
abs関数
数の絶対値を返す。
abs(数値)
print(abs(2.5))
print(abs(-12.2))
2.5
12.2
int関数
文字列や小数点を整数値に変える。
文字列の場合は数字のみで整数のみ、小数点はエラー
数値の場合、小数点以下は切り捨てとなる。
print(int(12.3))
print(int('13'))
print(int(0.9))
12
13
0
float関数
文字や整数値から浮動小数点の値に変える。
文字は数字でなくてはダメ。文字も小数点と数字だけ。
float(文字列)
float(整数値)
print(float(13))
print(float('15.5'))
13.0
15.5
oct関数
数値を8進法の値に変換
oct(数値)
print(oct(8))
print(oct(2))
0o10
0o2
hex関数
数値を16進法の文字列に直す
hex(数値)
print(hex(255))
print(hex(16))
0xff
0x10
0xが付くのは16進法の表記法
0から始まって16になると桁が繰り上がる。
16進数の先頭の0x付きや無しに変換したい場合は
format関数を用いて実現できます。
print(format(255 , 'x'))
print(format(255 , 'X'))
print(format(255 , '#x'))
ff
FF
0xff
input関数
入力欄が出てきて
プログラムに対して入力を行うことができる。
input('文字列')
s = input('--> ')
print(s)
--> 入力したよ
入力したよ
len関数
引数に指定したオブジェクトの長さを返す。
len(オブジェクト)
a = 'こんにちは、マット・デイモンです。'
# 文字数を返す
print(len(a))
17
b = [1,2,3,4,5]
# リストの要素数を返す
print(len(b))
5
list関数
引数に指定したオブジェクトをリスト型に変換
list(オブジェクト)
# 辞書型を定義
d1 = {1:2,3:4,5:6}
print(d1)
# キーをリストに変換
print(list(d1.keys()))
# 値をリストに変換
print(list(d1.values()))
# キーと値のタプル型の要素を持つリストに変換
print(list(d1.items()))
{1: 2, 3: 4, 5: 6}
[1, 3, 5]
[2, 4, 6]
[(1, 2), (3, 4), (5, 6)]
dict関数
キーと値の２つの組み合わせになっているものであれば辞書型に変換できる。
dict(オブジェクト)
# タプル型の要素を持つリストを辞書に変換
d2 = dict([('k1', 1), ('k2', 2), ('k3', 4)])
print(d2)
{'k1': 1, 'k2': 2, 'k3': 4}
max,min関数
max関数は複数指定したオブジェクトの中で、一番大きなものを返す。
min関数はその逆で、最小の値を返す。
max(オブジェクト)
min(オブジェクト)
sample_list = [1,2,3,4,5,6]
# 最大値を返す
print(max(sample_list))
# 最小値を返す
print(min(sample_list))
6
1
sample_st= 'apple'
# 最大値を返す
print(max(sample_st))
# 最小値を返す
print(min(sample_st))
p
a
open関数
ファイルを開いてファイルオブジェクトを作る関数。
こちらは紹介だけで、後の講義で詳細解説。
open(ファイルパス)
range関数
引数に指定した回数分のオブジェクトを生成する。
range(回数)
range(開始 , 終了)
range(開始 , 終了 , 間隔)
# 4つの整数を生成
print(list(range(4)))
[0, 1, 2, 3]
round関数
小数点を丸めて、一番近い整数を返す。
round(数値)
print(round(3.499))
print(round(3.5))
3
4
第二引数に桁を追加すると、その小数点の桁数で丸めを行う。
print(round(3.5187,3))
print(round(3.5187,1))
3.519
3.5
sorted関数
引数に指定したオブジェクトの要素の並び替えを行う。
sorted関数の詳しい使い方に関しては後のソートの講義で
sorted(オブジェクト)
str関数
引数に指定したものを文字列に変換
str(オブジェクト)
# 整数値を文字列に変換
print(str(12))
12
sum関数
リスト型の要素の合計値を返す。
要素が数値で無いとダメ
li =[1,2,3,4]
print(sum(li))
10
zip関数
enumerate関数
詳細は後の講義で。
関数は複数を組み合わせて使うことも可能
# 文字を小数点にしてから整数値に変換して絶対値にする。
print(abs(int(float('-3.14'))))
3
組み合わせた際は、カッコの最も内側に有るものの処理が先に行われます。
関数ではこのように複数を組み合わせて使って行くのが一般的になりますが
処理が複雑になり、追って行くのも大変になります。
まずは一番初めに処理が行われる部分を探して、その結果が正しいのか
ということを一つ一つ追って行くのが良いと思います。
enumerate関数
さてfor文で繰り返しの書き方をやりましたが、覚えていますか
for文の書き方のおさらいです。
for文ではrange関数などを使って繰り返しの回数を指定していました。
for i in range(5):
print(i)
0
1
2
3
4
このようにするとrange関数には0から4までの数値が生成され、
for文としては5回処理が繰り返されます。
enumerate関数はこのfor文の処理に
回数を数える変数を付け足すことができます。
# 5から9までの整数を生成して繰り返し処理する。
for i , j in enumerate(range(5,10)):
print(i , j)
0 5
1 6
2 7
3 8
4 9
どんな時に使うかというと処理が行われた回数を数えて、
回数で処理を抜けるような場合に用いる事が多いです。
count = 0
for i in range(5):
print(i)
if i>=3:
break
count+=1
0
1
2
3
for i , j in enumerate(range(5)):
print(i,j)
if i>=3:
break
0 0
1 1
2 2
3 3
無駄な変数への代入などを省いて、コードを簡略化でき
バグを少なくすることができるのがこの関数の利点です。
for文などで繰り返しの回数をカウントしたり、値として
用いたりするのに役立つ関数になっているので
繰り返しの処理を書く際には便利な関数です。
zip関数
zip関数はリスト型を２つ用いて繰り返しの中などで
同時に使うことをできるようにする関数です。
zip(オブジェクト,オブジェクト)
まずはリスト型の変数を二つ用意し
これをfor文で使っていきます。
a = [1,2,3,4,5]
b = [6,7,8,9,0]
for i , j in zip(a,b):
print(i,j)
1 6
2 7
3 8
4 9
5 0
変数i , jにはそれぞれ元のリスト型の変数の値が
格納されることになります。
もしzip関数を用いないで、２つのリストを使おうとすると
こんな感じになってしまいます。
a = [1,2,3,4,5]
b = [6,7,8,9,0]
count=0
for i in a:
print(i , b[count])
count+=1
1 6
2 7
3 8
4 9
5 0
当然バグの元にもなり得るので
処理としてまとめられるのであれば
zip関数を使ってしまった方が楽でコードもスッキリします。
またzip関数で使えるリスト型のデータについては
同じ要素数である必要があります。
ソート
ソートはデータを並べ替えを行います。
プログラムの中ではかなり多く用いられる処理です。
文字列型の並び替え(逆順にする)
インデックスを用いて文字列を逆さまにすることができます。
文字列[::-1]
a1 = 'abcdeアイウエオ123幹事!'
# [::-1]で逆さまにする
print(a1[::-1])
!事幹321オエウイアedcba
文字列内で使われている文字を並び替えるには
一旦リスト型に変換してから並び替えし、文字列に戻すことで
文字列の並び替えを実現できます。
sorted関数を使うと、文字列を分割して並び替えを行います。
第二引数のreverseにTrueを指定すれば降順
Falseを指定するか第二引数なしの場合は昇順となります。
a2 = 'abcdeアイウエオ123幹事!'
# sorted関数でリストに変換して昇順ソート
print(sorted(a2,reverse=False))
# sorted関数でリストに変換して降順ソート
print(sorted(a2,reverse=True))
['!', '1', '2', '3', 'a', 'b', 'c', 'd', 'e', 'ア', 'イ', 'ウ', 'エ', 'オ', '事', '幹']
['幹', '事', 'オ', 'エ', 'ウ', 'イ', 'ア', 'e', 'd', 'c', 'b', 'a', '3', '2', '1', '!']
join関数を用いるとリスト型のものを１つづつ連結して
文字列にすることができます。
'連結文字列'.join(リスト型)
a3 = 'abcdeアイウエオ123幹事!'
print(''.join(sorted(a3 , reverse=True)))
幹事オエウイアedcba321!
あまり文字列だけでの並び替えは
使う機会がないかもしれませんが、いざという時に役立つ手法です。
リスト型のソート
リスト型の関数であるsort関数を使う方法と
sorted関数を用いる方法があります。
sort関数
昇順：変数名.sort()
降順：変数名.sort(reverse=True)
sorted関数
昇順：sorted(変数名)
降順：sorted(変数名,reverse=True)
どちらも似ていますが
sort関数はリストの並び替えを行い、リスト型の並び順が変わります。
sorted関数は一時的な並び替えを行うので、元のリストの並び順に影響しません。
lis1= [3,1,2,4,5,7,6]
print(lis1)
# 昇順ソート
print(sorted(lis1))
# sorted関数の後に再度呼び出しても順番は変わら無い
print(lis1)
[3, 1, 2, 4, 5, 7, 6]
[1, 2, 3, 4, 5, 6, 7]
[3, 1, 2, 4, 5, 7, 6]
lis2= [3,1,2,4,5,7,6]
print(lis2)
# 降順にソート
lis2.sort(reverse=True)
# sort関数の後に呼び出すと順番は変わる
print(lis2)
[3, 1, 2, 4, 5, 7, 6]
[7, 6, 5, 4, 3, 2, 1]
順番がプログラムに大きな影響を与える場合は注意が必要です。
元の形を保持したままにするのか、並び替えてから使うのか
処理のさせ方を考えて使い分けをします。
辞書型のソート
辞書型の並び替えは
キーの昇順とキーの降順
値での昇順と値での降順
この4通りが存在します。
キー昇順：sorted(辞書型の変数.items())
値の昇順：sorted(辞書型の変数.items(), key=lambda x:x[1])
キー降順：sorted(辞書型の変数.items(), reverse=True)
値の降順：sorted(辞書型の変数.items(), key=lambda x:x[1],reverse=True)
# キー昇順
dct = { 2:3, 3:4, 1:2, 0:8, 4:2 }
for k, v in sorted(dct.items()):
print(k,':',v)
0 : 8
1 : 2
2 : 3
3 : 4
4 : 2
# キー降順
dct = { 2:3, 3:4, 1:2, 0:8, 4:2 }
for k, v in sorted(dct.items(), reverse=True):
print(k,':',v)
4 : 2
3 : 4
2 : 3
1 : 2
0 : 8
# Value昇順
dct = { 2:'3', 3:'4', 1:'2', 0:'8', 4:'2' }
for k, v in sorted(dct.items(), key=lambda x:x[1]):
print(k,':',v)
1 : 2
4 : 2
2 : 3
3 : 4
0 : 8
# Value降順
dct = { 2:'3', 3:'4', 1:'2', 0:'8', 4:'2' }
for k, v in sorted(dct.items(), key=lambda x:x[1],reverse=True):
print(k,':',v)
0 : 8
3 : 4
2 : 3
1 : 2
4 : 2
lambdaというのはラムダと読み、
pythonでは無名の関数を表す予約語になります。
ラムダについては後の講義で詳しくやって行きたいと思いますので、
ここでは割愛しますが、辞書の値で並び替えするには、
こういった書き方をしなくてはいけません。
辞書型そのものは並び順が大きな意味を持たないデータ型であるので
それを使うときにだけ並び替えを行うのが一般的です。
例えば、最終的に上位1番だけを出力する
といった時には降順で並び替えて出力する、ということを行います。
dct = { 2:'3', 3:'4', 1:'2', 0:'8', 4:'2' }
# まず辞書を値の降順ソートしてからenumrate関数に組み込む
for i , d in enumerate(sorted(dct.items(), key=lambda x:x[1],reverse=True)):
if i>=1:
# 2回目で処理を抜ける
break
print(i,d[0],d[1])
0 0 8
繰り返しの処理を行う際にまず、辞書を値の降順でソートしておきます。
enumerate関数から返されるカウント数をみて繰り返しの処理を抜けます。
そうすることでデータが大量にある際に、上位何番まで出力するといった
ことも実現できるようになります。
注意点としてはenumerate関数と辞書型のitemsを使うと
返ってくるデータ型は数値型とタプル型なので気をつけてください。
pythonではsorted関数を用いることで、
様々な形のデータの並び替えを行うことができます。
並びが重要なものを取り扱うプログラムを作るのに役立つと思います。
内包表記
内包表記はpython独特の書き方で
一定の処理を簡素に書くための手法となります。
内包表記の書き方
リスト：[値 for 変数 in イテラブルオブジェクト]
辞書 ：{キー:値 for 変数 in イテラブルオブジェクト}
セット：{値 for 変数 in イテラブルオブジェクト}
内包表記を使ってリストを作る
[値 for 変数 in イテラブルオブジェクト]
# 内包表記で変数にリスト型を格納する
lis1 = [i for i in range(10)]
print(lis1)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
内包表記を使わない場合は
lis2 = []
for i in range(10):
lis2.append(i)
print(lis2)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
内包表記は複数行にわたる処理を１行にまとめる事ができます。
内包表記を使って辞書を作る
{キー:値 for 変数 in イテラブルオブジェクト}
# 内包表記でキーをenumerate , 値をrangeの結果として辞書型を作成
num_dict = {k:v for k,v in enumerate(range(2,30,3))}
print(num_dict)
{0: 2, 1: 5, 2: 8, 3: 11, 4: 14, 5: 17, 6: 20, 7: 23, 8: 26, 9: 29}
keyとvalueに該当するものが有れば辞書型を作成可能です。
内包表記の中ではIF文を用いることもできます。
内包表記 ＋ IF文
リスト：[値 for 変数 in イテラブルオブジェクト if 条件]
辞書 ：{キー:値 if 条件 for 変数 in イテラブルオブジェクト}
内包表記 ＋ IF , else文
リスト：[値1 if 条件 else 値2 for 変数 in イテラブルオブジェクト ]
辞書：{キー1 if 条件 else キー2 : 値1 if 条件 else 値2 for 変数 in イテラブルオブジェクト}
# リスト内包表記 + IF文
num_list = [i for i in range(15) if i%2==0]
print(num_list)
[0, 2, 4, 6, 8, 10, 12, 14]
# リスト内包表記 + IF , else文
num_list = [i if i%2==0 else 0 for i in range(15) ]
print(num_list)
[0, 0, 2, 0, 4, 0, 6, 0, 8, 0, 10, 0, 12, 0, 14]
# 辞書内包表記 + IF文
num_dict = {k:v for k,v in enumerate(range(2,30,3)) if k%2==0}
print(num_dict)
{0: 2, 8: 26, 2: 8, 4: 14, 6: 20}
# 辞書内包表記 + IF , else文
num_dict = {k if k%2==0 else 0 : v if k%2==0 else 0
for k,v in enumerate(range(2,30,3)) }
print(num_dict)
{0: 0, 8: 26, 2: 8, 4: 14, 6: 20}
辞書型はenumerate関数を用いずにzip関数で
リスト２つを用いたりしても作る事ができます。
lis_a = [1,2,3,4,5]
lis_b = ['a','b','c','d','e']
d2 = {k:v for k,v in zip(lis_a,lis_b)}
print(d2)
{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}
リスト内包表記IFELSE文から辞書を作成する事もできます。
# リスト内包表記から辞書化
num_dict = dict((str(i),i) if i%2==0 else (i,str(i)) for i in range(10))
print(num_dict)
{9: '9', 1: '1', 3: '3', '8': 8, 5: '5', '0': 0, '2': 2, '4': 4, '6': 6, 7: '7'}
内包表記の中でfor文は複数書くことができます。
[値 for 変数1 in イテラブルオブジェクト for 変数2 in イテラブルオブジェクト]
# 2重の内包表記
print([i*j for i in range(1,5) for j in range(1,4) ])
[1, 2, 3, 2, 4, 6, 3, 6, 9, 4, 8, 12]
これを通常のfor文で書いて見ましょう。
a5 = []
for i in range(1,5):
for j in range(1,4):
a5.append(i * j)
print(a5)
[1, 2, 3, 2, 4, 6, 3, 6, 9, 4, 8, 12]
後に書いた方が内側のfor文に該当します。
このように複数行に渡るものも1行でスッキリ書くことができるのが
内包表記の良いところです。
まずは通常の処理を正しく書くことから始め、
それを簡略化できる部分があれば、内包表記に変えてゆく
といった風にすると、上手に覚えることができると思います。
基礎演習2
復習をしながら問題を解いてきましょう。！！
ここまででやったこととしては・・
制御文や内包表記、各種組み込み関数や
リストなどのデータ型についてです。
もしわからなければ、今までの講義の動画をもう一度見てみましょう。
基礎演習問題1:
リスト型の変数を宣言してみよう(要素は任意で3つ以上)
基礎演習問題2:
文字列型のキーと数値の値を持つ
辞書型の変数を作成してみよう(要素は任意で3つ以上)。
基礎演習問題3:
辞書型の変数を作成し、要素(キー：値)を追加してみよう
基礎演習問題4:
IF - ELSE文を用いた処理を作成しよう
条件は整数型の変数aの値が
偶数の場合 : 「偶数」とプリント
奇数の場合 : 「奇数」とプリント
基礎演習問題5:
for文で enumerate関数とrange関数を用いて
その２つの値を表示printさせよう。
range関数の引数は10とする。
基礎演習問題6:
リスト型の変数に3つの整数値を入れて、その最大値を出力する。
基礎演習問題7:
次の文章
「浦和、南浦和、北浦和、東浦和、西浦和、武蔵浦和、中浦和、浦和」
これを、で分割してキーとして辞書型の変数に格納したい。
値は空文字とする。
基礎演習問題8:
無駄を10個要素にもつリスト型を作成したい。
内包表記を使ってうまく書けないだろうか？
基礎演習問題9:
九九は１から９までの数字同士を掛け合わせた結果になる。
これをfor文を用いて表示してみよう。
なお、文字として表示させることとし、桁も揃えよう。
基礎演習問題10:
第９問、これを内包表記で１行でうまく書くことはできないだろうか？
色々な書き方があると思うので試してみよう。
すぐに答えが出ない人は、動画を止めて考えてみましょう。
コツとしては何を入力したら、どう計算されて、どう出力されるのか
それを考えながら書いてみましょう。
答えはこの下に
回答
基礎演習問題1:回答
リスト型の変数を宣言してみよう(要素は任意で3つ以上)
# リストは[]囲んで定義する
a = [1,2,3,4,5]
基礎演習問題2:回答
文字列型のキーと数値の値を持つ
辞書型の変数を作成してみよう(要素は任意で3つ以上)。
# 辞書型は{} 波カッコで定義する
d = {'a':1 , 'b':2 , 'c':3}
基礎演習問題3:回答
辞書型の変数を作成し、要素(キー：値)を追加してみよう
d = {'a':1 , 'b':2 , 'c':3}
# 辞書の要素の追加は変数名[キー] = 値
d['d'] = 4
print(d)
{'c': 3, 'd': 4, 'a': 1, 'b': 2}
基礎演習問題4:回答
IF - ELSE文を用いた処理を作成しよう
条件は整数型の変数aの値が
偶数の場合 : 「偶数」とプリント
奇数の場合 : 「奇数」とプリント
a = 10
if a%2==0:
print('偶数')
else:
print('奇数')
偶数
基礎演習問題5:回答
for文で enumerate関数とrange関数を用いて
その２つの値を表示printさせよう。
range関数の引数は10とする。
# enumerate の結果を１つの変数に格納する。
for i in enumerate(range(10)):
print(i)
(0, 0)
(1, 1)
(2, 2)
(3, 3)
(4, 4)
(5, 5)
(6, 6)
(7, 7)
(8, 8)
(9, 9)
# enumerate の結果を2つの変数に格納する。
for i,r in enumerate(range(10)):
print(i , r)
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
基礎演習問題6:回答
リスト型の変数に3つの整数値を入れて、その最大値を出力する。
a = [10,20,30]
print(max(a))
30
基礎演習問題7:回答
次の文章
「浦和、南浦和、北浦和、東浦和、西浦和、武蔵浦和、中浦和、浦和」
これを、で分割してキーとして辞書型の変数に格納したい。
値は空文字とする。
a = '浦和、南浦和、北浦和、東浦和、西浦和、武蔵浦和、中浦和、浦和'
# split関数で 、 で区切る。
b = a.split('、')
# 内包表記で辞書型にする
d = {k:'' for k in b}
print(d)
{'武蔵浦和': '', '中浦和': '', '東浦和': '', '浦和': '', '南浦和': '', '北浦和': '', '西浦和': ''}
a = '浦和、南浦和、北浦和、東浦和、西浦和、武蔵浦和、中浦和、浦和'
# split関数で 、 で区切る。
b = a.split('、')
# 内包表記を使わ無い場合
d = {}
for k in b:
d[k]=''
print(d)
{'武蔵浦和': '', '中浦和': '', '東浦和': '', '浦和': '', '南浦和': '', '北浦和': '', '西浦和': ''}
基礎演習問題8:回答
無駄を10個要素にもつリスト型を作成したい。
内包表記を使ってうまく書けないだろうか？
muda = ['無駄' for i in range(10)]
print(muda)
['無駄', '無駄', '無駄', '無駄', '無駄', '無駄', '無駄', '無駄', '無駄', '無駄']
基礎演習問題9:回答
九九は１から９までの数字同士を掛け合わせた結果になる。
これをfor文を用いて表示してみよう。
なお、文字として表示させることとし、桁も揃えよう。
for i in range(1,10):
for j in range(1,10):
# 2桁表記にフォーマットする , 改行コードをなくす
print('{:02}\t'.format(i*j), end='')
print() # 改行のみを行う
01 02 03 04 05 06 07 08 09
02 04 06 08 10 12 14 16 18
03 06 09 12 15 18 21 24 27
04 08 12 16 20 24 28 32 36
05 10 15 20 25 30 35 40 45
06 12 18 24 30 36 42 48 54
07 14 21 28 35 42 49 56 63
08 16 24 32 40 48 56 64 72
09 18 27 36 45 54 63 72 81
基礎演習問題10:回答
第９問、これを内包表記で１行でうまく書くことはできないだろうか？
色々な書き方があると思うので試してみよう。
# １段分の文字列を9つ持つリスト , 再度 join関数を使って リストを文字に、改行で連結
print('\n'.join([''.join(['{:02}\t'.format(i*j) for i in range(1,10) ])for j in range(1,10)]))
01 02 03 04 05 06 07 08 09
02 04 06 08 10 12 14 16 18
03 06 09 12 15 18 21 24 27
04 08 12 16 20 24 28 32 36
05 10 15 20 25 30 35 40 45
06 12 18 24 30 36 42 48 54
07 14 21 28 35 42 49 56 63
08 16 24 32 40 48 56 64 72
09 18 27 36 45 54 63 72 81
仕事などで九九を使うことはないと思いますが
プログラムを組み立ててゆくことを覚えるのには
最適な題材です。
上記で紹介した解法以外にも書き方はあると思いますので
色々な解き方を試して見てください。
分からなかった方は、文字列やフォーマットの回、繰り返しの回などを
参考にしていただいて、理解を深めていただければ
次第に解けるようになるかと思います。
関数
少し前に組み込み関数についてやっていますが今回は関数についてです。
組み込み関数はPython言語に初めから備わっている機能になりますが
関数は自分で定義することができます。
関数の定義の仕方
def 関数名(引数):
return 戻り値
関数に関係する用語ですが、まずは引数があります。
関数の()かっこの中に書くことができます。
引数は関数の中で使えるデータを受け渡す際に用います。
次に戻り値ですが、関数の中で計算された結果を
関数の外に戻す際に用います。
早速関数を定義して見ましょう。
# 関数の定義
def abc(aaa=0):
print(aaa)
return 1
# 関数の実行
print(abc())
print(abc(2))
0
1
2
1
引数の変数名の後に=イコールをつけて値を代入しておくと、
引数が指定されなかった場合に、初期値として使われる値になります。
戻り値は関数の実行結果なので
変数に格納したりする事もできます。
# 関数の実行結果が変数に格納される
a = abc(3)
print(a)
3
1
戻り値や引数は設定しなくても関数として定義できます
def defg():
print('dd')
defg()
dd
特に値を戻す必要がなければ
return無しで戻り値をなくしても大丈夫です。
関数の結果を用いて次に処理を行いたい場合は
returnを付けて値を戻すようにします。
引数は何個でもつけることができますが、
あまり多すぎると使うときに困ると思います。
なので5-6個くらいに納めた方が良いかと思います。
それ以上になるようであれば処理を改めたほうが良いでしょう。
関数を定義するときに引数を定義したら、
使うときもその引数の分だけ指定することが必要になりますが、
関数によっては引数で処理を変えたりしたいというニーズもあったりします。
そんな時は引数に**をつけると
引数をタプル型や辞書型で受け取ることができます。
def aaa1(**karg):
print(karg)
# 関数の引数に辞書型を渡す
aaa1(aws=[1,2])
{'aws': [1, 2]}
複数の引数にまとめてデータを渡せます。
def aaa2(arg1, arg2, arg3):
print(arg1)
print(arg2)
print(arg3)
lis = ['one', 'two', 'three']
# 関数の実行にリストをタプル型にして渡す。
aaa2(*lis)
one
two
three
ただしこの場合は引数の数と合わなければなりません。
個数が合わないとエラーが発生します。
lis2 = ['one', 'two', 'three','four']
# 引数の数と渡す数が合わ無いとエラーになる。
aaa2(*lis2)
TypeError: aaa2() takes 3 positional arguments but 4 were given
関数の使い方としては、複数行にまたがる処理が
2回以上行われる場合は、関数化していった方が
コードがスッキリして見やすく、メンテナンスもしやすくなります。
同じような処理を２度書くくらいであれば、全体を見直して
簡略化、省力化ができる部分を書き直してゆく、という感じで
関数を作っていくのが良いと思います。
特定の関数は別名でメソッドとも読んでいます。
プログラミングでは必須になる概念のため必ず覚えておいてください。
global変数とスコープ
関数などを使う際に必ず付いてくるのがスコープという概念です。
これは宣言した変数が使える範囲を示す概念のことです。
スコープにはグローバルとローカルの２種類があります。
ざっくり説明すると、一番外にあるものがグローバル
関数のブロックの中がローカルということになります。
ではその違いについて見て見ましょう。
まずはグローバルで使える変数を用意します。
global_var = 'global'
次に関数を定義して、その中で使える変数を用意します。
def local_def():
# ローカル用の変数
local_var = 'local'
return local_var
両方の変数を呼び出してみましょう。
グローバル変数の呼び出しは
print(global_var)
global
ローカル変数の呼び出しは
print(local_var)
NameError Traceback (most recent call last)
in ()
----> 1 print(local_var)
NameError: name 'local_var' is not defined
変数が定義されていないと、エラーが出てしまいます。
ローカルで定義したものは、
そのローカルのブロックの中でしか使えないからです。
なのでこのlocal変数が使えるのは、
定義した関数の中だけになります。
次に関数をいじって、グローバル変数を関数の中で読んでみましょう。
def local_def():
# グローバル変数の参照
print(global_var)
local_def()
global
グローバルで宣言した変数はどこでも使用することができます。
ローカルで宣言したものを
グローバルで使うにはどうすればいいでしょうか？
関数であれば戻り値として
グローバルの方に戻すことで使い回すことができます。
def local_def():
local_var = 'local'
# ローカルで定義した変数を戻す
return local_var
g2 = local_def()
print(g2)
local
for文の方も見て見ましょう。
global_var = 'g'
for i in range(5):
j = global_var*i
# ローカルの変数をそのままプリントする
print(i,j)```
4 gggg
結果は最終的に代入された結果のみが反映されることになります。
for文のブロックで使用していた変数などを
気づかずに再利用してしまうケースなどがありえると思いますが、
変数に格納した値によってはプログラムの結果に大きく影響が出てきます。
最後にグローバルとローカルで変数名がかぶってしまった場合どうなるでしょうか?
sp = 'global'
def local_def():
sp = 'local'
print(sp)
local_def()
print(sp)
local
global
一旦ローカルで同じ変数名で定義していますが
関数を呼び出した際はその関数で定義した変数名で
上書きされる形になるのでローカルで代入した値が表示されます。
その後グローバルの変数を呼び出す際には
元の値が表示されるという仕組みです。
globalという予約語を用いると、
このグローバル変数をローカル側で操作することできます。
sp = 'global'
def local_def():
# ローカルでグローバル変数として定義
global sp
sp= 'local'
print(sp)
local_def()
print(sp)
local
local
一旦ローカルで変数の前にglobalをつけて宣言し、
その後に変数に代入するとグローバルの変数の操作をすることができます。
グローバルとローカルで同じ変数を用いると、
不慮のバグの元になりやすいです。
なので慣れないうちは変数名はなるべく被らないような
名称にすることをお勧めします。
無名関数
さてこれまでは関数についての授業を行ってきましたが、
今回は無名関数というものについてのお話です。
ソートの回で少しだけ触れた
lambdaラムダというものについてです。
ラムダ式とも呼び、名前のない関数を作ることができます。
ラムダ式の書き方
lambda 引数 : 処理
普通の関数の書き方だと
def add (a,b):
return a+b
print(add(2,3))
5
このようになりますが
ラムダを使った無名関数だと
add = lambda a,b : a+b
print(add(2,3))
5
ラムダの後に書いた変数を受け取って:の後の処理が実行されます。
ラムダ式で変数addに関数を代入し
その変数を用いると関数が実行される仕組みです
通常の関数との違いはほとんどなく関数を定義したほうが無難です。
ラムダ式が効力を発揮するのはソートなどの時です。
辞書型の値でソートの際にこのラムダ式が出てきました。
dct ={ 3:7 , 5:6 ,1:3 }
# 辞書型を値で昇順ソートする。
print(sorted(dct.items(), key=lambda x:x[1]))
[(1, 3), (5, 6), (3, 7)]
key= 以降がラムダ式です。
sorted関数の引数keyが関数を受け取れます。
複雑なソートをする場合にラムダ式が役立ちます。
lis1 = [2,3,4,5,7]
# 要素を3で割った余りでソートするような場合
print(sorted(lis1 , key=lambda x:x%3))
[3, 4, 7, 2, 5]
辞書型の際はキーと値をタプル型で返してきます。
dct ={ 3:7 , 5:6 ,1:3 }
print(sorted(dct.items(), key=lambda x:x[1]))
[(1, 3), (5, 6), (3, 7)]
key=lambda x:x[1]のインデックス部分で
[0]がキー、[1]が値となります。
値でソートしたいのなら、
ラムダ式ではインデックスの二つ目すなわちインデックス値1となるので
key=lambda x:x[1]と指定することになるのです。
これは複合したデータの並び替えなどで役立つことになります。
# 多重のリストを定義
complex_list = [[1,2,3],[3,5,2],[2,6,8]]
print(complex_list)
[[1, 2, 3], [3, 5, 2], [2, 6, 8]]
# リストの最初の値で並び替え
print(sorted(complex_list,key=lambda x : x[0]))
# リストの２番目の値で並び替え
print(sorted(complex_list,key=lambda x : x[1]))
# リストの3番目の値で並び替え
print(sorted(complex_list,key=lambda x : x[2]))
[[1, 2, 3], [2, 6, 8], [3, 5, 2]]
[[1, 2, 3], [3, 5, 2], [2, 6, 8]]
[[3, 5, 2], [1, 2, 3], [2, 6, 8]]
大きなリストの要素として存在するリストの並べ替えのキーを
リストの各項目で定義することができます。
このようにすればどのようなデータの形でも対応できるようになるので
ラムダ式が大活躍します。
関数を定義するまでもないような小さな処理に向いていますので
関数やソートでの利用の仕方を覚えておきましょう。
オブジェクト指向の話
python言語はオブジェクト指向のプログラム言語となります。
それではオブジェクト指向とはなんなのでしょうか？
python言語では、取り扱うものは全部オブジェクトという概念となり
変数に格納するデータなども全てオブジェクトという扱いになります。
文字列オブジェクト
例えば変数aに文字列abcを代入すると、
この変数aは文字列型のオブジェクトになります。
# 文字列型のオブジェクト
a = 'abc'
print(a)
abc
関数とメソッド
次にリスト型の変数lと要素を宣言してみます。
そうするとこの変数lはリスト型のオブジェクトになり、
同時にリストオブジェクトが持つ関数(メソッド)が使えるようになります。
# リスト型を定義
lis1 = [1,2,3]
# リスト型のメソッド
lis1.append(4)
print(lis1)
[1, 2, 3, 4]
厳密には関数とメソッドは違うものですが
分かりやすくいうと、リスト型でデータを追加するappend
などはリストオブジェクトそのものに対する操作になるので
メソッドという取り扱いになります。
オブジェクト指向ではオブジェクトで定義された
関数と同じような書き方をしたものをメソッドと呼び
それ以外を関数と呼んでいます。
文字列型のオブジェクトを作れば、
そのオブジェクトが持つ関数はメソッドと言えることになります。
オブジェクト思考の概念
オブジェクト指向とは、何かしらの物オブジェクトで構成されたプログラム言語のことを言い、
オブジェクトとは変数、データ型、関数、そしてクラスといったものが挙げられます。
プログラム上で何かしらのモノを作ってそれを取り扱ってゆくという考えが
オブジェクト指向の基本的な考え方になっていきます。
ここら辺は概念的なものなので
今すぐわからなくても良いし、わからなくても簡単なプログラムであれば
なんとかなるものです。ゆくゆくは覚えていってください。
この次の回ではクラスについて詳しくやっていきたいと思います。
クラスについて
前回はオブジェクト指向についての概念を説明しました。
オブジェクト指向の概念を学んだら、次は実際にpythonで
そのオブジェクトとなるクラスを作って見ましょう。
クラスの作り方
class クラス名():
def __init__(self,):
処理
クラスの呼び出し方
変数名 = クラス名()
簡単なクラスを作ってみましょう。
class class_a():
def __init__(self,):
print('初期化')
self.ac = 'aaa'
これでクラスを作成する事ができました。
インスタンスとインスタンス化
インスタンスとは、クラスを実体化したものです。
クラスのデータやメソッドを使うためには
インスタンスと呼ばれるものを生成する必要があります。
クラスを呼び出して変数に格納します。
この事をインスタンス化
作った変数のことをインスタンスとも言います。
# インスタンス化
a = class_a()
初期化
ここでinitというメソッドの部分は
コンストラクタと呼ばれるインスタンスを生成する際に
一番初めに呼ばれる処理になります。
クラスを呼び出して変数に格納した際に
initが呼ばれてその中の処理が実行されます。
このinitの処理の中では引数にselfという変数名がありますが
selfという変数は自分自身を指すもので、クラスではこの引数は必須で
書かないとエラーになってしまいます。
initの処理の中ではself.acという変数に値として
aaaを代入しています。
これでこのクラスの中にacという変数を確保して値を代入したことになります。
クラスを生成した後に呼び出す部分でこの変数が使えるようになります。
クラス変数やメソッドの呼び出し方
クラス変数名.メソッド名
aa = class_a()
print(aa.ac)
初期化
aaa
クラスの変数を追加して見ましょう。
aa.b = 2
print(aa.b)
2
クラスの中に変数bが確保され、2という値が代入されました。
後にこの変数を使いまわすことができるようになります。
このクラスに定義した変数のことをアトリビュートと呼んでいます。
クラスではコンストラクタとは別に関数も定義でき、
このクラス内に定義した関数のことをメソッドと呼んでいます。
メソッドを追加して見ましょう。
# クラスの定義
class class_a():
def __init__(self,):
print('初期化')
self.ac = 'aaa'
# メソッドの定義
def anaa(self, ):
print(1)
# クラスを呼び出して変数に格納
aa = class_a()
# クラスのメソッドを呼び出す。
aa.anaa()
初期化
1
このようにクラスとは複数のメソッドやアトリビュートを持つ
オブジェクトということになります。
メソッドやアトリビュートは
そのクラスの中からしか呼び出すことができませんので
上記の例のクラスで定義したacという変数はそのままでは使用できません。
print(ac)
NameError Traceback (most recent call last)
in ()
----> 1 print(ac)
NameError: name 'ac' is not defined
必ずクラス変数とともに使う事が必要になります。
print(aa.ac)
aaa
クラスはどのような時に使うのでしょうか？
それはプログラムの中で大きな処理をひとまとめにしたり
別のプログラムで使いまわしたいときなどに役立ちます。
一旦一つのプログラムとしてクラス化しておいて
別のプログラムでそれを使いまわすという使い方が一般的です。
クラスの継承
クラスには継承という概念もあります。
まずは継承するものとされるものとして
親子のクラスを作り、その中にメソッドを作っておきます。
class oya():
def oyano_method(self):
print('oyano')
# 継承するクラスを引数に指定する
class ko(oya):
def kono_method(self):
print('kono')
子クラスの方は引数として親クラスを指定しておきます。
そうすることで子クラスを生成すると、
親クラスのメソッドが使えるようになります。
# 子クラスを呼び出す。
k = ko()
# 子クラスで継承した親クラスが呼べる
k.kono_method()
k.oyano_method()
kono
oyano
このように子クラスには無かった
親クラスのメソッドが呼び出せるようになります。
これは今までにあるクラスを派生させて、
新しいクラスを作りたい場合などに
用いることができる便利な機能です。
クラスの概念や、仕組みは覚えるまでは大変ですが、
覚えればプログラミングの幅が大きく広がるものとなりますので
ゆっくりと確実に覚えるようにしていってください
例外処理
今までの講義では何度かエラーの表示が出ていたかと思います。
例えば
# リスト型を定義
aqq = [1,2,3]
# インデックスで値を抽出
print(aqq[31])
IndexError Traceback (most recent call last)
in ()
2 aqq = [1,2,3]
3 # インデックスで値を抽出
----> 4 print(aqq[31])
IndexError: list index out of range
リスト型のインデックスの範囲外の値を指定すると
list index out of range
というエラーが発生します、リストの範囲外というエラー出力です。
こういったエラーが発生すると、そこでプログラムは終了してしまいます。
なのでエラーを発生させないようにするか、
エラーが発生した場合の対処をする必要があります。
エラーの発生を抑えるのは困難なので、
エラーを回避する記述をすることでプログラムを終了させないようにします。
それが例外処理になります。
pythonの例外処理の書き方
try:
処理
except:
例外時の処理
pythonでの例外処理は、エラーが発生しそうな箇所を
try - exceptという文言で囲みます。
exceptionというのは例外という意味の英語です。
ぜひ覚えておいてください。
try:
aqq = [1,2,3]
# ここでエラーが発生する
print(aqq[31])
except:
# エラー発生時にはこちらが呼ばれる
print('error')
error
エラーが発生した場合の処理をexceptのブロックに書きます。
エラーが発生しても何も処理をしない場合は
何も書かないと構文エラーになってしまうので
passと書いておきます。
try:
aqq = [1,2,3]
print(aqq[31])
except:
# 何も処理を書か無いとエラーになる
File "", line 5
何も処理を書か無いとエラーになる
^
SyntaxError: unexpected EOF while parsing
try:
aqq = [1,2,3]
print(aqq[31])
except:
# 処理が定まらない時はpassと書いておく
pass
上記ではエラーが発生したことは確認できますが
何が起こっているのかは分からないです。
なのであらかじめエラーが想定できる場合は
エラーが発生した場合の処理を複数書くことができます。
try:
処理
except エラー名:
例外時の処理
except エラー名:
例外時の処理
try:
aqq = [1,2,3]
# ここでIndexエラーが発生する
print(aqq[31])
except IndexError:
# ここでIndexエラーをキャッチする
print('index error')
except Exception:
print('exception')
index error
exceptの後にエラー名を書くことで、
該当するエラーが発生した場合の処理を書き分けることができます。
上記の例ではIndexエラーが発生すると
IndexErrorの部分の処理が実行されることになります。
Exceptionはすべてのエラーを拾います。
pythonのエラーの種類
ZeroDivisionError
数値を0で割ると発生
1/0
ZeroDivisionError Traceback (most recent call last)
in ()
----> 1 1/0
ZeroDivisionError: division by zero
NameError
存在しない変数やメソッドを参照しようとすると発生
print(asokokoks)
NameError Traceback (most recent call last)
in ()
----> 1 print(asokokoks)
NameError: name 'asokokoks' is not defined
そもそもこれは文法間違いであるので、
try-exceptではあまり用いられない使い方です。
KeyError
辞書型のキーがない場合などに発生
d ={1:2,3:4}
print(d[5])
KeyError Traceback (most recent call last)
in ()
1 d ={1:2,3:4}
----> 2 print(d[5])
KeyError: 5
他にもたくさんのエラーが存在します。
以下のコードはpythonの組み込みエラーを表示します。
[i for i in dir(__builtins__) if 'Error' in i]
['ArithmeticError',
'AssertionError',
'AttributeError',
'BlockingIOError',
'BrokenPipeError',
'BufferError',
'ChildProcessError',
'ConnectionAbortedError',
'ConnectionError',
'ConnectionRefusedError',
'ConnectionResetError',
'EOFError',
'EnvironmentError',
'FileExistsError',
'FileNotFoundError',
'FloatingPointError',
'IOError',
'ImportError',
'IndentationError',
'IndexError',
'InterruptedError',
'IsADirectoryError',
'KeyError',
'LookupError',
'MemoryError',
'NameError',
'NotADirectoryError',
'NotImplementedError',
'OSError',
'OverflowError',
'PermissionError',
'ProcessLookupError',
'RecursionError',
'ReferenceError',
'RuntimeError',
'SyntaxError',
'SystemError',
'TabError',
'TimeoutError',
'TypeError',
'UnboundLocalError',
'UnicodeDecodeError',
'UnicodeEncodeError',
'UnicodeError',
'UnicodeTranslateError',
'ValueError',
'ZeroDivisionError']
特に発生するエラーがわからない場合はとりあえずtry - exceptで囲んでおいて
のちにエラー内容に合わせて処理を追加してゆくというのが良いでしょう。
例外処理はプログラムでは必須になるテクニックなので必ず覚えておいてください。
ライブラリの利用
プログラム言語には、他の人が作ったプログラムを利用したり、
自分が作ったプログラムを利用できるようにする便利な機能が備わっています。
それがライブラリです。
pythonでは仕事や研究などですぐに使えるライブラリが
数多く備わっており、機械学習や統計分析なども
ライブラリを用いて簡単に行うことができるようになっています。
ライブラリの使い方はすごくシンプルです。
ライブラリの読み込み方
import ライブラリ名
from パッケージ名 import ライブラリ名
それではライブラリを使っていきましょう。
ランダム値を作り出すrandomライブラリを読み込みします。
import random
ランダムの整数を生成するrandint関数の呼び出し方
random.randint(最小値 , 最大値)
random.randint(1,10)
10
# ランダムのメソッドを10回呼び出す
for i in range(10):
print(random.randint(1,10))
9
5
3
8
2
9
2
1
4
7
ライブラリは特定の処理を関数化しているものが多いです。
なおライブラリのことを別の呼び方でモジュールとも言います。
モジュールを読み込む、とかの表現が有ったら、
他のプログラムを読み込んでいると思って大丈夫です。
pythonの主なライブラリ
os ライブラリ
PCのファイルやディレクトリなどの操作ができる
import os
# 自分のPCのディレクトリのファイルやフォルダをリスト化する
print(os.listdir('/'))
['.DocumentRevisions-V100', '.file', '.fseventsd', '.PKInstallSandboxManager', '.Spotlight-V100', '.Trashes', '.vol', 'anaconda', 'Applications', 'bin', 'cores', 'dev', 'etc', 'home', 'installer.failurerequests', 'Library', 'Live2D_Cache', 'net', 'Network', 'opt', 'private', 'sbin', 'System', 'tmp', 'Users', 'usr', 'var', 'Volumes']
os.listdir(ファイルやディレクトリなど)
listdirの引数にディレクトリを指定するとそのディレクトリ内の
ファイルやフォルダがリスト値で返されます。
自分のPCのファイルやディレクトリを探したり、
ファイルの一覧を使って、特定のファイルを読み込みしたり、
操作するようなプログラムを書くのに役立ちます。
time ライブラリ
プログラム内での時間に関わる操作を行うライブラリ
import time
# 2秒間プログラムを止める
time.sleep(2)
print(2)
time.sleep(1)
print(1)
2
1
自作のライブラリの使い方
pythonファイルを作成すれば、自作のライブラリの読み込みができます。
importできるライブラリの拡張子は.pyになります。
まずは簡単なpythonの実行ファイルを作りましょう。
このノートブックが置いてある
フォルダの中にpythonファイルを作っていきます。
テキストエディターなどで作成し拡張子を.pyで保存します。
sample.py
def hello(aa):
print(aa)
pythonファイルを作成したら
ライブラリとして読み込みでき、メソッドなどが使えるようになります。
# 自作ライブラリの読み込み
import sample
# メソッドの呼び出し
sample.hello('hello')
hello
ライブラリは無数にあり、anacondaでインストールした際には400種類くらいの
ライブラリが使えるようになっています。
そのライブラリの名称とかぶるとややこしいためインストール済みのライブラリをみてみます。
macの場合はノートブック上で
! pip list
これでコマンドが実行できて、表示できます。
windowsの場合はコマンドプロンプトなどで
!をとって実行してみてください。
! pip list
DEPRECATION: The default format will switch to columns in the future. You can use --format=(legacy|columns) (or define a format=(legacy|columns) in your pip.conf under the [list] section) to disable this warning.
adal (0.4.5)
alabaster (0.7.10)
alembic (0.9.6)
anaconda-client (1.6.3)
anaconda-navigator (1.6.2)
anaconda-project (0.6.0)
appnope (0.1.0)
appscript (1.0.1)
argcomplete (1.0.0)
asn1crypto (0.22.0)
astroid (1.4.9)
astropy (1.3.2)
azure (2.0.0rc6)
azure-batch (1.0.0)
azure-common (1.1.6)
azure-datalake-store (0.0.12)
azure-graphrbac (0.30.0)
azure-keyvault (0.3.5)
azure-mgmt (0.30.0rc6)
azure-mgmt-authorization (0.30.0)
azure-mgmt-batch (1.0.0)
azure-mgmt-cdn (0.30.3)
azure-mgmt-cognitiveservices (1.0.0)
azure-mgmt-compute (0.30.0rc6)
azure-mgmt-containerregistry (0.2.1)
azure-mgmt-datalake-analytics (0.1.6)
azure-mgmt-datalake-nspkg (2.0.0)
azure-mgmt-datalake-store (0.1.6)
azure-mgmt-devtestlabs (2.0.0)
azure-mgmt-dns (1.0.1)
azure-mgmt-documentdb (0.1.3)
azure-mgmt-iothub (0.2.2)
azure-mgmt-keyvault (0.30.0rc6)
azure-mgmt-logic (1.0.0)
azure-mgmt-monitor (0.2.1)
azure-mgmt-network (0.30.0rc6)
azure-mgmt-nspkg (2.0.0)
azure-mgmt-rdbms (0.1.0)
azure-mgmt-redis (1.0.0)
azure-mgmt-resource (0.30.0rc6)
azure-mgmt-scheduler (1.0.0)
azure-mgmt-sql (0.5.3)
azure-mgmt-storage (0.30.0rc6)
azure-mgmt-trafficmanager (0.30.0)
azure-mgmt-web (0.32.0)
azure-nspkg (2.0.0)
azure-servicebus (0.20.3)
azure-servicefabric (5.6.130)
azure-servicemanagement-legacy (0.20.4)
azure-storage (0.20.3)
Babel (2.4.0)
backports.shutil-get-terminal-size (1.0.0)
bcolz (0.12.1)
beautifulsoup4 (4.6.0)
bitarray (0.8.1)
blaze (0.10.1)
bleach (1.5.0)
bokeh (0.12.5)
boto (2.46.1)
Bottleneck (1.2.1)
bs4 (0.0.1)
certifi (2017.4.17)
cffi (1.10.0)
chardet (3.0.4)
charts (0.4.6)
chest (0.2.3)
click (6.7)
cloudpickle (0.2.2)
clyent (1.2.2)
colorama (0.3.9)
conda (4.5.11)
conda-build (3.0.19)
conda-verify (2.0.0)
configobj (5.0.6)
contextlib2 (0.5.5)
coverage (4.4.2)
cryptography (1.9)
cssselect (1.0.1)
cycler (0.10.0)
cyordereddict (1.0.0)
Cython (0.27.2)
cytoolz (0.8.2)
dask (0.14.3)
datashape (0.5.4)
decorator (4.0.11)
dill (0.2.6)
distributed (1.16.3)
Django (1.10.6)
django-bootstrap3 (8.2.2)
django-crispy-forms (1.6.1)
django-debug-toolbar (1.8)
django-pure-pagination (0.3.0)
django-registration-redux (1.5)
django-storages (1.6.3)
django-torina-blog (0.5)
docutils (0.13.1)
dynd (0.7.3.dev1)
empyrical (0.3.2)
entrypoints (0.2.2)
et-xmlfile (1.0.1)
fastcache (1.0.2)
fbprophet (0.2.1)
filelock (2.0.7)
Flask (0.12.2)
Flask-Cors (3.0.2)
future (0.16.0)
gevent (1.2.1)
glob2 (0.5)
greenlet (0.4.12)
h5py (2.7.0)
HeapDict (1.0.0)
html5lib (0.999999999)
idna (2.5)
imagesize (0.7.1)
intervaltree (2.1.0)
ipykernel (4.6.1)
ipython (5.3.0)
ipython-genutils (0.2.0)
ipywidgets (6.0.0)
isodate (0.5.4)
isort (4.2.5)
itsdangerous (0.24)
Janome (0.3.5)
jdcal (1.3)
jedi (0.10.2)
Jinja2 (2.9.6)
jsonschema (2.6.0)
jupyter (1.0.0)
jupyter-client (5.0.1)
jupyter-console (5.1.0)
jupyter-core (4.3.0)
keyring (10.4.0)
lazy-object-proxy (1.2.2)
line-bot-sdk (1.0.2)
llvmlite (0.18.0)
locket (0.2.0)
Logbook (1.1.0)
lru-dict (1.1.6)
lxml (3.7.3)
Mako (1.0.7)
MarkupSafe (0.23)
matplotlib (2.0.2)
mistune (0.7.4)
mpmath (0.19)
msgpack-python (0.4.8)
msrest (0.4.11)
msrestazure (0.4.11)
multipledispatch (0.4.9)
navigator-updater (0.1.0)
nb-anacondacloud (1.4.0)
nb-conda (2.2.0)
nb-conda-kernels (2.1.0)
nbconvert (5.1.1)
nbformat (4.4.0)
nbpresent (3.0.2)
networkx (1.11)
nltk (3.2.4)
nose (1.3.7)
notebook (5.0.0)
numba (0.33.0)
numexpr (2.6.4)
numpy (1.12.1)
numpydoc (0.6.0)
oauthlib (2.0.2)
odo (0.5.0)
olefile (0.44)
opencv-python (3.4.5.20)
openpyxl (2.4.7)
packaging (16.8)
pandas (0.20.1)
pandas-datareader (0.5.0)
pandas-highcharts (0.5.2)
pandocfilters (1.4.1)
partd (0.3.8)
pathlib2 (2.2.1)
patsy (0.4.1)
pep8 (1.7.0)
pexpect (4.2.1)
pickleshare (0.7.4)
Pillow (4.1.1)
pip (9.0.1)
pkginfo (1.4.1)
plotly (2.3.0)
ply (3.10)
prompt-toolkit (1.0.14)
psutil (5.2.2)
psycopg2 (2.7.1)
ptyprocess (0.5.1)
py (1.4.33)
py-d3 (0.2.7)
PyAlgoTrade (0.18)
pyasn1 (0.2.3)
pycosat (0.6.3)
pycparser (2.18)
pycrypto (2.6.1)
pycurl (7.43.0)
pyflakes (1.5.0)
Pygments (2.2.0)
PyJWT (1.5.2)
pylint (1.6.4)
pyodbc (4.0.16)
pyOpenSSL (17.0.0)
pyparsing (2.1.4)
pystan (2.17.0.0)
pytest (3.0.7)
python-dateutil (2.6.0)
python-editor (1.0.3)
python-highcharts (0.4.1)
pytz (2017.2)
PyWavelets (0.5.2)
PyYAML (3.12)
pyzmq (16.0.2)
QtAwesome (0.4.4)
qtconsole (4.3.0)
QtPy (1.2.1)
redis (2.10.5)
requests (2.18.1)
requests-file (1.4.2)
requests-ftp (0.3.1)
requests-oauthlib (0.8.0)
rope-py3k (0.9.4.post1)
scikit-image (0.13.0)
scikit-learn (0.18.1)
scipy (0.19.0)
seaborn (0.7.1)
selenium (3.0.2)
setuptools (27.2.0)
simplegeneric (0.8.1)
singledispatch (3.4.0.3)
six (1.10.0)
snowballstemmer (1.2.1)
sockjs-tornado (1.0.3)
sortedcollections (0.5.3)
sortedcontainers (1.5.7)
Sphinx (1.5.6)
sphinx-rtd-theme (0.2.4)
spyder (3.1.4)
SQLAlchemy (1.1.9)
sqlparse (0.2.3)
statsmodels (0.8.0)
sympy (1.0)
tables (3.4.2)
tblib (1.3.2)
terminado (0.6)
testpath (0.3)
toolz (0.8.2)
tornado (4.5.1)
traitlets (4.3.2)
unicodecsv (0.14.1)
urllib3 (1.21.1)
wcwidth (0.1.7)
webencodings (0.5)
Werkzeug (0.12.2)
wheel (0.29.0)
widgetsnbextension (2.0.0)
wrapt (1.10.10)
xlrd (1.0.0)
XlsxWriter (0.9.6)
xlwings (0.10.4)
xlwt (1.2.0)
zict (0.1.2)
zipline (1.1.1)
ライブラリの名称は、この名称と一緒でなければ大丈夫なので、
検索で引っかかったら、その名前は変えましょう。
自分の名前や、会社の名前とか、ニックネームとかを用いれば
ここら辺はカバーされるかと思います。
ライブラリの利用はプログラムでは当たり前のこととなっており、
自分でプログラムを書かずに、すでに使えるプログラムは
ライブラリから呼び出した方が賢明です。
どんなライブラリが使えるのか、
全てを紹介することはできませんので、基本編はここまでです。
基礎演習3
それではこれまでに学習した内容を踏まえて、演習を行っていきましょう。
少し難しめに作ってありますので、
動画を止めながらゆっくり考えて解いてみてください。
第一問：
整数1から100までの和を求めるプログラムを作成してみましょう。
第二問：
フィボナッチ数(0,1,1,2,3,5,8,13・・・)のように
最初の二項は0 , 1 で、以後どの項もその直前の2つの項の和
になるような数のフィボナッチ数と言います。
このフィボナッチ数を求める関数を作成しましょう。
3桁のフィボナッチ数までを表示させる関数にしましょう。
第三問：
前項で取り扱ったrandomライブラリの関数を使って
英小文字のaからzか、数字0から9までの文字だけを使った
32桁の文字列を作成するプログラムを作ろう。
random.randint(最小値、最大値)
でランダムな整数値が返せる。
第四問：
aabacdcda
この文字列の文字別で集計してみよう。
第五問：
景子の夫、千鳥、メンタリスト
この３つの文字列のうち、１つをランダムで返す関数を作って見ましょう。
すぐに答えが出ない人は、動画を止めて考えてみましょう。
コツとしては何を入力したら、どう計算されて、どう出力されるのか
それを考えながら書いてみましょう。
答えはこの下に
回答
第一問：回答
整数1から100までの和を求めるプログラムを作成してみましょう。
res = 0
# range(1,101)で1から100まで
for i in range(1,101):
# += で加算
res += i
print(res)
5050
# 上記を内包表記で書くと
print(sum([i for i in range(1,101)]))
5050
第二問：回答
フィボナッチ数(0,1,1,2,3,5,8,13・・・)のように
最初の二項は 0, 1 で、以後どの項もその直前の2つの項の和
になるような数のフィボナッチ数と言います。
このフィボナッチ数を求める関数を作成しましょう。
3桁のフィボナッチ数までを表示させる関数にしましょう。
def fib():
# まずはじめに変数を２つ用意する
a = b = 1
while True:
print(b)
# フィボナッチ数は直前の2つの項の和
a, b = b, a+b
# 3桁を超えたら抜ける
if b>999:
break
# 上記関数の実行
fib()
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
第三問：回答
前項で取り扱ったrandomライブラリの関数を使って
英小文字のaからzか、数字0から9までの文字だけを使った
32桁の文字列を作成するプログラムを作ろう。
random.randint(最小値、最大値)
でランダムな整数値が返せる。
import random
# 36個の英数字を用意する
words = 'abcdefghijklmnopqrstuvwxyz0123456789'
# 上記の中からランダムで返すのを32回繰り返して配列を作る
# その配列を join で連結して文字列に変換する
print(''.join([words[random.randint(0,35)] for i in range(32)]))
lfkj6bv913np7cq8fxzjjpfjv2u8qv0q
第四問：回答
aabacdcda
この文字列の文字別で集計してみよう。
辞書型とfor文で集計を行う事ができます。
# まずは集計対象の文字を用意
word = 'aabacdcda'
# 結果を格納するための辞書を用意
result_dict = {}
for w in word:
# 文字があれば +1 なければ1で辞書に格納する
if w in result_dict:
result_dict[w]+=1
else:
result_dict[w]=1
print(result_dict)
{'b': 1, 'c': 2, 'a': 4, 'd': 2}
第五問：回答
景子の夫、千鳥、メンタリスト
この３つの文字列のうち、１つをランダムで返す関数を作って見ましょう。
import random
# 配列を用意する
daigo = ['景子の夫','千鳥','メンタリスト']
# 関数を作る
def random_daigo(daigo):
# ランダムで整数値を返し、インデックスで上記配列の要素を返す。
return daigo[random.randint(0,2)]
# 関数の実行
print(random_daigo(daigo))
千鳥
randomライブラリには直接1つの要素をランダムで返す
choiceという関数があります。
random.choice(配列)
import random
daigo = ['景子の夫','千鳥','メンタリスト']
def random_daigo(daigo):
return random.choice(daigo)
print(random_daigo(daigo))
千鳥
さて、演習はいかがだったでしょうか？
あなたのwishは達成されましたか？
プログラミングができるようになると
そのwishを叶えることができるかもしれませんね。
プログラミングは
まずは真似してコードを書くこと写経が上達の鍵になります。
書いて書いて書きまくりましょう。
できなかったところは演習を復習してみてくださいね。
その先、仕事とか、研究にどう使えるの？
さて
プログラミングの基礎はいかがだったでしょうか？
文法を一通りやって、演習もやってもらえれば
それなりに理解できると思いますが
まだ、ここまでの段階だと
プログラミングでどんなことができるかとか
どんなことに役立つのかとか・・
イメージが湧かない方の方が多いのではないかと思います。
なので、実際に仕事で使っているコードも見ながら
プログラミングがどういうものなのかを
改めて体験していただき、その後どうすれば良いか
というところを深く掘り下げて行きたいと思います。
ファイルの読み込み
with open(ファイルパス) as 変数名:
処理
# 同じ階層に配置してあるファイルの中身を表示する。
with open('sample.py') as _r:
print(_r.read())
def hello(aa):
print(aa)
読み込みした際の変数名.read()で
ファイルの中身を全て読み込みします。
上記の例だとファイルのコードを全て読み込んでプリントしています。
CSVファイルの読み込み
ファイルの読み込み部分は一緒です。
CSVは,区切りフォーマットのファイルで
,で区切って読み込みを行う事ができます。
文字列.split(',')でカンマで区切りリスト型に変換を行う
# 結果を格納する変数を用意
res = []
# ファイルの読み込み
with open('sample.csv') as _r:
for row in _r:
# 改行を取り除き、カンマで区切って配列にする
rows = row.replace('\n','').split(',')
# 結果用の変数に追加
res.append(rows)
print(res)
[['aaa', 'bbb', 'ccc'], ['ddd', 'eee', 'fff'], ['hhh', 'iii', 'jjj'], ['kkk', 'lll', 'mmm']]
for row in res:
# タブ区切りで表示
print('\t'.join(row))
aaa bbb ccc
ddd eee fff
hhh iii jjj
kkk lll mmm
スクレイピング
スクレイピングはwebサイトへアクセスして情報取得する技術の事です。
Python言語には、スクレイピング用のライブラリが備わっているので
比較的簡単にWEBサイトから情報取得する事ができます。
requests.get(サイトURL)
WEBサイトへアクセスして情報を取得する。
import requests
# webサイトへアクセスしてデータを取得
html = requests.get('http://yahoo.co.jp')
# 取得したデータの最初の800文字を表示
print(html.content.decode('utf-8')[0:800])
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "・・・" class="autolink">http://www.w3.org/TR/html4/loose.dtd">・・・
機会学習系のライブラリの利用
データの可視化
データフレーム.plot()
でデータの可視化を行う(デフォルトは折れ線グラフ)
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
# データフレームの作成
df = pd.DataFrame([[3,4],[4,5],[6,9],[2,8]],columns=['a','b'])
# データフレームを描画
df.plot()
plt.scatter(データフレーム,データフレーム)
データフレームの２列を用いて散布図を表示する。
scikit learn
scikit learnは機械学習用のライブラリで各種モデル作成のためのプログラム群と
学習用のサンプルデータが揃っている。
datasets.load_iris()
学習用データの読み込み(iris:あやめのサンプルデータ)
import pandas as pd
# 必要なライブラリのインポート
from sklearn import datasets, model_selection, svm, metrics
# 有名なアヤメのデータの読み込み
iris = datasets.load_iris()
# アヤメのデータをデータフレームに変換する。
iris_data = pd.DataFrame(data=iris.data, columns=iris.feature_names)
# 5行だけ表示
iris_data.head()
# ラベルデータの読み込み
iris_label = pd.Series(data=iris.target)
# 5行だけ表示
iris_label.head()
0 0
1 0
2 0
3 0
4 0
dtype: int64
train_test_split(学習データ, 正解ラベル)
学習データを訓練用とテスト用に分ける。
# アヤメのデータを訓練データ、テストデータ、訓練ラベル、テストラベルに分ける。
train_data, test_data, train_label, test_label = model_selection.train_test_split(iris_data, iris_label)
# 訓練データ
train_data.head()
# 訓練ラベル
train_label.head()
70 1
125 2
77 1
25 0
51 1
dtype: int64
# 訓練データとテストデータの個数
print(len(train_data), '\t', len(test_data))
112 38
変数名 = 学習モデルの変数名.クラス()
学習モデルの変数名.fit(訓練データ,訓練ラベル)
訓練データで学習をおこなう。
# SVM学習器の定義
clf = svm.SVC()
# 訓練データで学習
clf.fit(train_data, train_label)
# テストデータで予測
pre = clf.predict(test_data)
print(type(pre))
print(pre)
[0 0 1 1 0 2 1 0 2 1 2 0 2 2 0 1 0 0 2 1 0
0 0 2 0 2 2 2 1 0 2 0 1 2 2 1 0 1]
accuracy_score(テストラベル, 予測値)
予測値の正答率を算出する
# 正答率
ac_score = metrics.accuracy_score(test_label, pre)
print(ac_score)
0.947368421053
サンプルデータだけでも10種類ほどは揃っているので
様々な機械学習モデルを試す事ができます。
その他
他にどんな事が出来るのか、コードを併記しませんが事例を挙げておきます。
定型作業の自動化
メールの受発信、一覧作成
SNSの投稿、書き込みの収集
エクセル、ワード文書などの作成(レポート作成)
PDFのテキスト抽出
GUI操作
データベース操作
データの加工、登録、追加、削除
大量データ加工
画像処理
画像収集
opencvなどを用いた画像加工
顔の抽出
物体検知
統計分析
基礎統計量の算出
分布の計算、可視化
回帰分析
区間推定
仮説検定
Webアプリケーション開発
FlaskやDjangoなどのフレームワークを用いたWEBサイト構築
ゲーム開発
PyGameやKivyなどのフレームワークを用いたゲーム開発
自然言語処理
テキストマイニング
形態素解析
係り受け
n-gram
woed2vec
AI開発
機械学習
DeepLearning
強化学習
GAN
これでプログラミングを一通り学んだ訳です。
文法についてはやってきているので、だいたい書けるようになっているはずです。
ここからは自分自身の作りたいプログラムを作ってみましょう。
よく使うコードについてはひとまとめにしておきました。
こちらにリンクを貼っておきますので、是非参考にしてみてください。
Pythonチートシート
作者の情報
乙pyのHP：
Youtube：
YouTubeのvideoIDが不正です
Twitter：
Discussion