python基本知識

Python

今回はpython基本知識を紹介します。

  1. Pythonのインストール
    1. zipファイルダウンロード
    2. インストール
  2. コメントの書き方
    1. 1行のみのコメント
    2. 複数行コメント
  3. 変数
    1. 変数定義
    2. データ型
  4. print()関数
    1. オプション引数(end)
    2. エスケープシーケンス
    3. format関数
      1. 複数の引数を与える
      2. リストやタプルを埋め込む
    4. f文字列
  5. input関数
  6. データ型変換
  7. 演算子
    1. 代数演算子
    2. ビット演算子
    3. 代入演算子
    4. 比較演算子
    5. ブール演算子
  8. 条件分岐
    1. if文
    2. while文
      1. while文のbreak
      2. while文のcontinue
      3. while文のelse
    3. for文
      1. for文のbreak
      2. for文のcontinue
      3. for文のelse
      4. 指定回数繰り返し
  9. 乱数生成
  10. 三項演算子
  11. 文字列
    1. 文字列演算
    2. 文字列検索
      1. findメソッド(rfind)
      2. indexメソッド(rindex)
      3. countメッソド
    3. 文字列置換
      1. replaceメッソド
      2. splitメッソド
      3. joinメッソド
      4. capitalizeメッソド
      5. titleメッソド
      6. upperメッソド
      7. lowerメッソド
      8. lstripメソッド
      9. rstripメソッド
      10. stripメソッド
      11. ljustメソッド(rjust,center)
      12. startswithメソッド
      13. endswithメソッド
      14. isalphaメソッド
      15. isdigitメソッド
      16. isalnumメソッド
      17. isspaceメソッド
  12. list型
    1. 検索
      1. indexメソッド
      2. countメソッド
      3. lenメソッド
      4. in
      5. not in
    2. 追加
      1. appendメソッド
      2. extendメソッド
      3. insertメソッド
    3. 削除
      1. del
        1. 変数を削除
        2. 位置を指定して削除
        3. 範囲を指定して削除
        4. すべての要素を削除
      2. pop
      3. remove
      4. clear
    4. 変更
      1. sortメソッド
      2. reverseメソッド
      3. copyメソッド
    5. ループ
      1. whileでループ
      2. forでループ
    6. 2次元リスト
  13. タプル
    1. タプルの初期化
    2. 検索
      1. indexメソッド
      2. countメソッド
      3. lenメソッド
  14. 辞書
    1. 辞書の初期化
    2. 空の辞書
    3. 検索
      1. keyで検索
      2. getメソッド
      3. keysメソッド
      4. valuesメソッド
      5. itemsメソッド
    4. 追加＆変更
    5. 削除
      1. delメソッド
      2. clearメソッド
    6. 辞書のループ
      1. keyのループ
      2. valueのループ
      3. itemのループ
  15. 集合
    1. 初期化
    2. 検索
      1. in
      2. not in
    3. 追加
      1. addメソッド
      2. updateメソッド
    4. 削除
      1. removeメソッド
      2. discardメソッド
      3. popメソッド
  16. 共通内容
    1. +演算子
      1. 文字列の結合
      2. リスト結合
      3. タプル結合
    2. ＊演算子
    3. in && not in
    4. 関数
      1. len
      2. del またはdel()
      3. max、min
      4. range(start,end,step)
      5. enumerate()
      6. tuple()
      7. list()
      8. set()
  17. 内包表記
    1. リスト内包表記
    2. 辞書内包表記
      1. 二つリストを結合し、辞書に変換
      2. 辞書から指定した条件のデータを取得
    3. 集合内包表記
  18. 関数
    1. 関数定義
    2. 関数に関数を実行
    3. 関数実行
    4. 変数のスコープ(globalキーワード)
    5. 引数
      1. 可変長引数
  19. アンパック
    1. タプルのアンパック
    2. 辞書のアンパック
  20. 二つ変数の値を交換
  21. 可変データ型
  22. lambda(無名関数)
    1. 引数無し
    2. 引数あり
    3. 引数デフォルト値
    4. 可変長引数
    5. 条件付き
    6. リストのソート
  23. 高階関数
    1.  map関数
    2. reduce関数
    3. filter

Pythonのインストール

pythonをインストールするのは環境により、違いますが、今回はwindowsでzip方式のインストールを紹介します。

zipファイルダウンロード

公式サイトよりWindows用Pythonのzipファイルをダウンロードする。

インストール

①好きな場所に解凍する。

②環境変数のPATHに展開したPythonの展開パスを追加する。

コメントの書き方

1行のみのコメント

Pythonで説明をコメントとして記述したり不要なコードをコメントアウトしたりする場合は#を使う。
「ctrl + /」でコメントアウトを追加する。

# first python code
print(“hello world”)

複数行コメント

シングルクォート’、ダブルクォート”を3つつなげたトリプルクォート（”’, “””）で囲むことで複数行の内容をコメントアウトする
”’
複数行のコメント
１行
２行
”’
“””
複数行のコメント
１行
２行
“””

変数

Python では変数は値を保管する場所ではなく、値が保管されている場所を指し示すものです。 その為、数値型の値を代入して定義した変数に、あとから別のデータ型の値を格納することもできます。

変数定義

変数名はアルファベットの大文字と小文字は区別される。

変数名 = 値
name = ‘東京’
print(name)

データ型

Pythonでのデータ形で頻繁に利用されている種類は以下の7つです。関数typeで確認できます
type(“abc”)

  • 数値　（int型：整数、float型：小数点）
  • str型：文字列 （’hello world’） 
  • bool型：真偽値 (True,False)
  • list型：リスト（[1 , 2, 3, 5]）
  • tuple型：タプル（(1 , 2, 3, 5)）
  • set型：集合型 （{10, 20, 30}）
  • dict型：辞書 （{‘name’: ‘test’, ‘age’: 30}）

print()関数

print関数は、文字列を画面に出力する関数です。print関数の基本的な構文は以下のようになります。

print(‘出力したい文字列’)
name = ‘SaTo’
age = 30
weight = 108.5

print(‘今年は%d歳’ % age)
print(‘名前は%sです’ % name)
print(‘体重は%.2fです’ % weight)

no = 30;
print(‘番号は%07dです’ % no)  #学生番号は0000030です
print(‘名前は%s,年齢は%d’ % (name, age))  #名前はSaTo,年齢は30

オプション引数(end)

printで文字を出力するには、printの引数部分に出力したい文字列を置きます。printでは文字の末尾に改行が追加されるので、出力した文字列が自動的に改行されます。改行をしたくない場合はendオプションを用いて末尾に何も付加しないようにします。デフォルトはend=”\n”となっている

#文字列変数
text_a = ‘基本知識をべんきょうするか’
 
print(text_a)  #基本知識をべんきょうするか
print(text_a, end=”?”)  #基本知識をべんきょうするか?

エスケープシーケンス

文字列の中に改行を表す文字を入力したい場合、特殊な文字を表すのに使用するのがエスケープシーケンスです。

\ と文字の組み合わせでエスケープシーケンスを表します

エスケープシーケンス 意味
\newline 文字列を途中で改行する
\\ バックスラッシュ (\)
\’ 一重引用符 (‘)
\” 二重引用符 (“)
\n ASCII 行送り (LF)
\t ASCII 水平タブ (TAB)
使用例：
print(‘hello\nPython’)

format関数

Python2.6以上から使うことができる新しい方式が、format関数を使って文字列と変数を出力する方法です。format関数の書式は以下の通りです。

print(‘任意の文字列{0}任意の文字列’.format(変数)

複数の引数を与える

‘{0}, {1}, {2}…’.format(変数1, 変数2, 変数3….) #インデックス（添え字）で指定
‘{h1}, {h2},{h3}..’.format(h1=変数1, h2=変数2, h3=変数…) #キーワード引数で指定
‘{h1},{h2},{h3}…’.format(**{‘h1’:変数1, ‘h2’:変数2, ‘h3’:変数3….} ) #辞書で指定

リストやタプルを埋め込む

‘{0[添え字]}, {0[添え字]}, {1[添え字]}, {1[添え字]}…’.format(リスト1, リスト2….)

{0[添え字]}の左側の数字が{}に埋め込みたい変数（この場合リストやタプル）がformat関数の何番目の引数かを表していて、[添え字]がその変数の中で表示したい要素のインデックスになっています。

f文字列

Python3.6にf文字列フォーマットを追加されました。

name = ‘SaTo’
age = 30
print(f’名前は{name},年齢は{age}’)

input関数

input() 関数を使うと、キーボードを使って、文字列データを入力できます。
 
name = input(‘please input your name:’)
print(f’入力したname:{name}’)

データ型変換

型変換とは、その名のとおりデータ型を指定した型に変換することです。
変換関数 説明
int(x[,base]) xを整数に変換
float(x) xを小数に変換
str(x) xを文字列に変換
eval(str) pythonコードとして計算、オブジェクトを返す(本来のデータの)
tuple(s) sをタプルに変換
list(s) sをリストに変換
使用例：
age = input(‘please input your age:’)
int_age = int(age)
print(type(int_age))

演算子

代数演算子

+a       # 正数
-a        # 負数
a + b   # 加算
a – b    # 減算
a * b    # 乗算
a / b    # 除算
a % b   # a を b で割った余り
a ** b   # a の b 乗
a // b   # 切り捨て除算

ビット演算子

~a         # ビット反転
a & b     # AND:論理積(aもbも1のビットが1)
a | b      # OR:論理和(aまたはbが1のビットが1)
a ^ b      # XOR:排他的論理和(aまたはbが1のビットが1)
a << b   # b ビット左シフト
a >> b   # b ビット右シフト

代入演算子

a = b           # a に b を代入する
a = b = 10   # a=10,b=10に同じ
num1, float1, str1 = 10, 0.5, ‘hello’    # num1=10,float1=0.5,str1=’hello’ に同じ
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 = 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 と等しい
a != b         # a が b と異なる
a < b          # a が b よりも小さい
a > b          # a が b よりも大きい
a <= b        # a が b 以下である
a >= b        # a が b 以上である
a is b          # a が b と等しい
a is not b    # a が b と異なる
a in b          # a が b に含まれる (a, b は共に文字列、または、b はリストやタプル)
a not in b    # a が b に含まれない (a, b は共に文字列、または、b はリストやタプル)

ブール演算子

x and y    # x も y も真であれば真
x or y      # x または y が真であれば真
not x       # x が偽であれば真

条件分岐

if文

if 条件式1:
    条件式1がTrueのときに行う処理
    条件式1がTrueのときに行う処理
elif 条件式2:
    条件式1がFalseで条件式2がTrueのときに行う処理
elif 条件式3:
    条件式1, 2がFalseで条件式3がTrueのときに行う処理
…
else:
    すべての条件式がFalseのときに行う処理
使用例：
age = 9
if age < 20:
    print(“<20”)
elif 20 <= age < 60:
    print(“<60”)
else:
    print(“other”)

while文

while 条件式:
    条件式がTrueのときに行う処理
使用例：
x = 1
while x <= 10:
    print(x)
    x += 1

while文のbreak

pythonのwhile文にはbreak,continueが使えます。
break:繰り返し処理を強制終了させる

while文のcontinue

continue:その週の処理だけをスキップする

while文のelse

while count<5:
    if count ==1:
        break
    print(count)
    count+=1
else:
    print(‘breakで抜けた場合は実行されない’)

for文

for 繰り返し変数 in オブジェクトの集合:
    繰り返し処理内容
使用例：
list=[1,2,3,4,5]
for element in list:
    print(element)

for文のbreak

pythonのfor文にはbreak,continueが使えます。
break:繰り返し処理を強制終了させる

for文のcontinue

continue:その週の処理だけをスキップする

for文のelse

str = ‘test’
for i in str:
    if i == ‘s’:
        print(‘sが存在します’)
        break
    print(i)
else:
    print(‘breakで抜けた場合は実行されない’)
 

指定回数繰り返し

特定の回数分繰り返し処理を行いたい場合、range関数を使う方法がある。

for i in range(10):
     print(i)

乱数生成

Python標準ライブラリのrandomモジュールの関数random()やuniform(), randrange(), randint()などを使うと、乱数（ランダムな浮動小数点数floatや整数int）を生成できる。
random.random()（0.0以上1.0未満の浮動小数点数）
random.uniform()（任意の範囲の浮動小数点数）
random.randrange()（任意の範囲・ステップの整数）
random.randint()（任意の範囲の整数）
使用例：
import random

print(random.random()) # 0.10719278839344926
print(random.uniform(100, 500)) #496.6584713276877
print(random.randrange(10)) #6  
print(random.randrange(10, 20, 2))  #14
print(random.randint(10, 50)) #42

三項演算子

(変数) = (条件がTrueのときの値) if (条件) else (条件がFalseのときの値)

例：
x = “OK” if n == 10 else “NG”

文字列

文字列演算

a + b         # 文字列 a と 文字列 b を連結します
a * n         # 文字列 a を n 回繰り返します
a[n]          # 文字列 a の中の n 番目の文字を取り出します
a[n:m]      # 文字列 a の中の n 番目から m 番目までの文字列を取り出します
a[n:]         # 文字列 a の中の n 番目から最後までの文字列を取り出します
a[:m]        # 文字列 a の中の 0 番目から m 番目までの文字列を取り出します
a[n:m:s]   # 文字列 a の中の n 番目から m 番目までの文字列を s個とばしで取り出します
使用例：
str = ‘0123456789’
print(str[:7])      # 0123456
print(str[2:])     # 23456789
print(str[:])       # 0123456789
print(str[1:7])     # 123456
print(str[1:7:1])  # 123456
print(str[1:7:2])  # 135
 
print(str[::-1])      # 9876543210
print(str[-4:-1:])  # 678

文字列検索

findメソッド(rfind)

文字列の先頭から検索したい文字列を探し、最初に見つかった位置（０から始まるインデックス）を返す。
見つからなかった場合は−1を返す 

s.find(検索したい文字列,開始インデックス,終了インデックス)
使用例：
str = ‘This is a test string.’
#文字列先頭から末尾までで’test’を検索
print(str.find(‘test’))       # =>10

#文字列’This is’から’test’を検索
print(str.find(‘test’, 0, 6)) # =>-1

indexメソッド(rindex)

find()と同様の動作するが、見つからなかった場合「ValueError」という例外が発生する。
 
str.index(検索したい文字列,開始インデックス,終了インデックス)
str = ‘This is a test string.’
#文字列先頭から末尾までで’test’を検索
print(str.index(‘test’))       # =>10

#文字列’This is’から’new’を検索
print(str.index(‘new’)) # ValueError

countメッソド

文字列が何個含まれているか調べる。文字列が存在しない場合、０が出ます

str.count(検索したい文字列)
str = ‘This is a test string. test’
#文字列先頭から末尾までで’test’を検索
print(str.count(‘test’))       # 2

#文字列’This is’から’new’を検索
print(str.count(‘new’)) # 0

文字列置換

replaceメッソド

文字列の中で特定の文字列を置き換えるときはreplace(リプレース)メソッドを使います。

str.replace(‘文字列1’,‘文字列2’) #文字列1から文字列2へ置換します
str.replace(‘文字列1’,‘文字列2’,置換個数) #文字列1から文字列2へ置換します
str = ‘This is a test string. test’
#文字列先頭から末尾までで’test’を’newTest’に置換
print(str.replace(‘test’, ‘newTest’))       # This is a newTest string. newTest

splitメッソド

文字列を「区切り文字」で区切り、文字列のリストを作って返す。
区切り文字を指定しない場合、スペース・改行等の空白文字が区切り文字となる。
#文字列strを「区切り文字」で区切る。
str.split(区切り文字, 分割文字個数)
str = ‘This is a test string. test’

print(str.split(‘test’))       # [‘This is a ‘, ‘ string. ‘, ”]
print(str.split(‘test’,1))     # [‘This is a ‘, ‘ string. test’]

joinメッソド

シーケンス中の要素を連結した文字列を返す。
#シーケンスを文字列sで分割し連結した文字列を返す。
s.join(シーケンス)
mylist = [‘aa’, ‘bb’, ‘cc’]
new_str = ‘…’.join(mylist)
print(new_str)  #aa…bb…cc

capitalizeメッソド

先頭の文字だけ大文字にする
mystr = ‘this is a Test’
new_str = mystr.capitalize()
print(new_str) #This is a test

titleメッソド

単語の先頭文字だけ大文字に変換
mystr = ‘this is a Test’
new_str = mystr.title()
print(new_str) #This Is A Test

upperメッソド

文字列の英字小文字を英字大文字に変換し、その結果を返す。
mystr = ‘this is a Test’
new_str = mystr.upper()
print(new_str) #THIS IS A TEST

lowerメッソド

文字列の英字大文字を英字小文字に変換し、その結果を返す。
mystr = ‘this is a Test’
new_str = mystr.lower()
print(new_str) #this is a test

lstripメソッド

mystr = ‘    this is a Test    ‘
new_str = mystr.lstrip()
print(new_str) #’this is a Test    ‘

rstripメソッド

mystr = ‘    this is a Test    ‘
new_str = mystr.rstrip()
print(new_str) #’    this is a Test’

stripメソッド

mystr = ‘    this is a Test    ‘
new_str = mystr.strip()
print(new_str) #’this is a Test’

ljustメソッド(rjust,center)

文字列を幅を考慮して左寄せした結果を返す。文字列の幅が指定した値に満たない場合、指定した文字で埋める(埋め草文字)。埋め草文字を指定しない場合、スペースで埋める。
右寄せを行う場合はrjust(),中央寄せを行う場合はcenter()メソッドがある。
#文字列sの幅を考慮して左寄せする。
str.ljust(幅, 埋め草文字)
mystr = ‘Test’
new_str = mystr.ljust(8,’@’)
print(new_str) #Test@@@@

mystr = ‘Test’
new_str = mystr.center(8,’@’)
print(new_str) #@@Test@@

mystr = ‘Test’
new_str = mystr.rjust(8,’@’)
print(new_str) #@@@@Test

startswithメソッド

文字列が検索したい文字列で始まっている時Trueを返す。そうでない場合、Falthを返す。
開始インデックス/終了インデックスは、指定しなければ文字列の先頭/末尾になる。

#文字列sがある文字列で始まっているか調べる。
str.startswith(検索したい文字列,開始インデックス,終了インデックス)
mystr = ‘this is a test’
print(mystr.startswith(‘this’)) #True

endswithメソッド

文字列が検索したい文字列で終わっている時Trueを返す。そうでない場合、Falthを返す。
開始インデックス/終了インデックスは、指定しなければ文字列の先頭/末尾になる。

#文字列sがある文字列で終わっているか調べる。
str.endswith(検索したい文字列,開始インデックス,終了インデックス)
mystr = ‘this is a test’
print(mystr.endswith(‘test’)) #True

isalphaメソッド

文字列が英文字だけで構成されているか判定

print(‘hello’.isalpha()) #True
print(‘hello world’.isalpha()) #False
print(‘hello123’.isalpha()) #False

isdigitメソッド

文字列が数字だけから構成されているか判定

print(‘111’.isdigit()) #True
print(‘111.11’.isdigit()) #False
print(‘hello world’.isdigit()) #False
print(‘hello123’.isdigit()) #False
isdigit()
True: ユニコード文字・バイト文字・全角文字・ローマ数字
False: 漢数字
Error: なし
isdecimal()
True: ユニコード文字・全角文字
False: ローマ数字・漢数字
Error: バイト文字
isnumeric()
True: ユニコード文字・全角・ローマ数字・漢数字
False: なし
Error: バイト文字

isalnumメソッド

文字列が英文字か数字だけで構成されているか判定
print(‘hello123’.isalnum())  #True
print(‘hello123@’.isalnum()) #False
print(‘hello 123’.isalnum()) #False

isspaceメソッド

文字列がスペースかタブだけで構成されているか判定

print(‘ ‘.isspace()) #True

list型

書き方:
mylist = []
# または
mylist2 = list()

使い方：
name_list = [‘TOM’, ‘Lily’, ‘ROSE’]
print(name_list[0])

検索

indexメソッド

最初に現れる値のindexを調べる。存在しない場合、エラーとなる。

name_list = [‘TOM’, ‘Lily’, ‘ROSE’]
print(name_list.index(‘Lily’)) #1
print(name_list.index(‘Lilys’)) #ValueError

countメソッド

値が何個含まれているか。存在しない場合、０となる

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
print(name_list.count(‘Lily’)) #2
print(name_list.count(‘Lilys’)) #0

lenメソッド

リスト型を引数にすると、その要素の個数を取得できる。
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
print(len(name_list)) #4

in

指定した文字がリストに存在するかチェック
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
print(‘Lilys’ in name_list) #False
print(‘Lily’ in name_list) #True

not in

指定した文字がリストに存在しないかチェック

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
print(‘Lilys’ not in name_list) #True

追加

appendメソッド

リストのメソッドappend()で、末尾（最後）に要素を追加できる。

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
name_list.append(‘Test’)
print(name_list) #[‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’, ‘Test’]

extendメソッド

リストのメソッドextend()で、末尾（最後）に別のリストやタプルを結合できる。すべての要素が元のリストの末尾に追加される。

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
name_list.extend([‘Test’,’GO’])
print(name_list) #[‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’, ‘Test’, ‘GO’]

insertメソッド

リストのメソッドinsert()で、指定した位置に要素を追加（挿入）できる。

list.insert(index, data)
#第一引数に位置、第二引数に挿入する要素を指定する。先頭（最初）は0。負の値の場合、-1が末尾（最後）の一つ前となる。
#最後の２番目に追加
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
name_list.insert(-1, 123)
print(name_list) #[‘TOM’, ‘Lily’, ‘ROSE’, 123, ‘Lily’]
#先頭に追加
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
name_list.insert(0, 123)
print(name_list) #[123, ‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]

削除

Pythonでlist型のリスト（配列）の要素を削除するには、リストのメソッドclear(), pop(), remove()を使う。インデックスやスライスで位置・範囲を指定してdel文で削除する方法もある。

del

インデックス・スライスで位置・範囲を指定して削除する
スライスで範囲を指定すると、複数の要素を一括で削除できる。

変数を削除
# 変数を削除
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
del name_list
print(name_list) #NameError: name ‘name_list’ is not defined
位置を指定して削除
# 位置を指定して削除
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
del name_list[0]
print(name_list) #[‘Lily’, ‘ROSE’, ‘Lily’]
範囲を指定して削除
# 範囲を指定して削除
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
del name_list[0:2]
print(name_list) #[‘ROSE’, ‘Lily’]
すべての要素を削除
#すべての要素を削除
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
del name_list[:]
print(name_list) #[]

pop

指定した位置の要素を削除し、値を取得する
リストのメソッドpop()で、指定した位置の要素を削除し、その要素の値を取得できる。

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
print(name_list.pop(1)) # Lily
print(name_list) #[‘TOM’, ‘ROSE’, ‘Lily’]
負の値を使って末尾（最後）からの位置を指定することもできる。末尾（最後）は-1。
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Go’]
print(name_list.pop(-1)) # Go
print(name_list) #[‘TOM’, ‘Lily’, ‘ROSE’]

remove

指定した値と同じ要素を検索し、最初の要素を削除する

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
name_list.remove(‘Lily’)
print(name_list) #[‘TOM’, ‘ROSE’, ‘Lily’]

clear

すべての要素を削除する

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
name_list.clear()
print(name_list) #[]

変更

# 指定した位置の値を変更する
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘Lily’]
name_list[0] = ‘new_data’
print(name_list) #[‘new_data’, ‘Lily’, ‘ROSE’, ‘Lily’]

sortメソッド

デフォルトは昇順。降順にソートしたい場合は引数reverseをTrueとする。
# 昇順
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘GO’]
name_list.sort()
print(name_list) #[‘GO’, ‘Lily’, ‘ROSE’, ‘TOM’]

# 降順
name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘GO’]
name_list.sort(reverse=True)
print(name_list) #[‘TOM’, ‘ROSE’, ‘Lily’, ‘GO’]

reverseメソッド

元のリストを逆順に並べ替え

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘GO’]
name_list.reverse()
print(name_list) #[‘GO’, ‘ROSE’, ‘Lily’, ‘TOM’]

copyメソッド

新しいリストを作成する

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘GO’]
new_list = name_list.copy()
new_list.pop()
print(new_list) #[‘TOM’, ‘Lily’, ‘ROSE’]
print(name_list) #[‘GO’, ‘Lily’, ‘ROSE’, ‘TOM’]

ループ

whileでループ

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘GO’]
i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

forでループ

name_list = [‘TOM’, ‘Lily’, ‘ROSE’, ‘GO’]

for name in name_list:
    print(name)

2次元リスト

[
[要素1, 要素2, 要素3],
[要素4, 要素5, 要素6],
…,
]
name_list = [[‘TOM’, ‘Lily’], [‘ROSE’, ‘GO’]]
print(name_list[0][0])

タプル

リストはデータを変更できますが、タプルはデータを変更できない。

タプルの初期化

タプル型は ( から ) までの間に複数の要素をカンマ(,)で区切って定義します。書式は次のとおりです。
(要素1, 要素2, …)

tuple = (1, 2, 3, 4)
print(tuple)

要素が 1 つだけの場合はカンマを付けてください。

(要素1,)

tuple = (1,)
print(tuple)

検索

indexメソッド

最初に現れる値のindexを調べる。存在しない場合、エラーとなる。

tuple = (‘aa’, ‘bb’, ‘cc’, ‘dd’)
print(tuple[0])  #aa

print(tuple.index(‘bb’)) #1
print(tuple.index(‘ee’)) #ValueError

countメソッド

値が何個含まれているか。存在しない場合、０となる

tuple = (‘aa’, ‘bb’, ‘cc’, ‘dd’, ‘cc’)

print(tuple.count(‘bb’)) #1
print(tuple.count(‘cc’)) #2
print(tuple.count(‘ff’)) #0

lenメソッド

要素の個数を取得できる。

tuple = (‘aa’, ‘bb’, ‘cc’, ‘dd’, ‘cc’)
print(len(tuple)) #5

辞書

辞書型は { から } までの間に複数の要素をカンマ(,)で区切って定義します。要素はキーと対応する値の組み合わせを キー:値 の形式で記述します。書式は次のとおりです。
{キー1:値1, キー2:値2, …}
リストやタプルのようなシーケンス型とは異なり辞書はマッピング型なので要素には順序はありません。(ただし Python3.7 からは辞書の順序は要素が挿入された順序であることが保証されるようになりました)。

辞書の初期化

dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}
print(dict)

空の辞書

dict = {}
または
dict = dict()

検索

keyで検索

dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}

print(dict[‘name’]) #Tom
print(dict[‘names’]) #KeyError

getメソッド

dict.get(‘key’,デフォルト値)
dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}

print(dict.get(‘name’, ‘defalut’))    #Tom
print(dict.get(‘names’, ‘defalut’)) #defalut
print(dict.get(‘names’))                #None

keysメソッド

dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}
print(dict.keys())  #dict_keys([‘name’, ‘age’, ‘gender’])

valuesメソッド

dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}
print(dict.values())   #dict_values([‘Tom’, 30, ‘1’])

itemsメソッド

dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}
print(dict.items())   #dict_items([(‘name’, ‘Tom’), (‘age’, 30), (‘gender’, ‘1’)])

追加＆変更

辞書[‘key’]=value
# keyが存在しない場合、追加する。
# keyが存在する場合、変更する。
dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}

dict[‘id’] = 11110
print(dict) #{‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’, ‘id’: 11110}
dict[‘name’] = ‘Rose’
print(dict) #{‘name’: ‘Rose’, ‘age’: 30, ‘gender’: ‘1’, ‘id’: 11110}

削除

delメソッド

dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}

del dict[‘name’]
print(dict) #{‘age’: 30, ‘gender’: ‘1’}
del dict[‘ages’] #KeyError

clearメソッド

dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}

dict.clear()
print(dict) #{}

辞書のループ

keyのループ

dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}
for key in dict.keys():
    print(key)

valueのループ

dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}
for val in dict.values():
    print(val)

itemのループ

dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}
for item in dict.items():
    print(item)
dict = {‘name’: ‘Tom’, ‘age’: 30, ‘gender’: ‘1’}
for key, value in dict.items():
    print(f'{key}={value}’)

集合

集合は、重複しない要素を順不同で集めたものです。
主に存在判定や重複エントリの排除などで使われます。

初期化

s1 = {10, 20, 30}  # 値がある
s2 = set(‘sfsdf’)   
s3 = set()  　　　#空

検索

in

s1 = {10, 20, 30, 40}
print(10 in s1) #True

not in

s1 = {10, 20, 30, 40}
print(10 not in s1) #False

追加

addメソッド

setの値に引数が追加されます。

s1 = {10, 20}
s1.add(30)
print(s1) #{10, 20, 30}

updateメソッド

setの値にリストが追加されます。
s1 = {10, 20}
s1.update([30, 20, 40])
print(s1) #{40, 10, 20, 30}

削除

removeメソッド

指定した値を削除する。存在しない場合、エラーとなる

s1 = {10, 20, 30, 40}
s1.remove(10)
print(s1) #{40, 20, 30}
s1.remove(10) #KeyError

discardメソッド

指定した値を削除する。存在しない場合、エラーにならない。

s1 = {10, 20, 30, 40}
s1.discard(10)
print(s1) #{40, 20, 30}
s1.discard(10) 

popメソッド

一つ値を削除し、削除された値を返す。

s1 = {10, 20, 30, 40}
v1 = s1.pop()
print(s1) #{10, 20, 30}
print(v1) #40

共通内容

+演算子

二つ変数の値を結合する。文字列、リスト、タプルは使えます、辞書は使えない。

文字列の結合

str1 = ‘abc’
str2 = ‘def’

print(str1 + str2)  #abcdef

リスト結合

list1 = [1, 10]
list2 = [2, 20]

print(list1 + list2)  #[1, 10, 2, 20]

タプル結合

t1 = (1, 10)
t2 = (2, 20)

print(t1 + t2)  #(1, 10, 2, 20)

＊演算子

指定した値は複数を作成する。文字列、リスト、タプルは使えます、辞書は使えない。

str1 = “-“
list1 = [10]
t1 = (‘test’,)

print(str1 * 10)  #———-
print(list1 * 10)  #[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
print(t1 * 10)  #(‘test’, ‘test’, ‘test’, ‘test’, ‘test’, ‘test’, ‘test’, ‘test’, ‘test’, ‘test’)

in && not in

inは要素が存在するかチェックする。文字列、リスト、タプル、辞書は使えます。
not in は要素が存在しないかチェックする。文字列、リスト、タプル、辞書は使えます。
str1 = “abcde”
list1 = [10, 20, 30]
t1 = (‘test’,’hello’, ‘tom’)
dict1 = {‘name’:’tome’, ‘age’:30, ‘address’:’tokyo’}

print(‘a’ in str1)      #True
print(‘a’ not in str1)  #False

print(20 in list1)      #True
print(20 not in list1)  #False

print(‘tom’ in t1)      #True
print(‘tom’ not in t1)  #False

print(‘age’ in dict1)      #True
print(‘age’ not in dict1)  #False

関数

len

要素の個数を取得する。文字列、リスト、タプル、集合、辞書が使えます。

str1 = “abcde”
list1 = [10, 20, 30]
t1 = (‘test’,’hello’, ‘tom’)
s1 = {10, 20, 23, 4}
dict1 = {‘name’:’tome’, ‘age’:30, ‘address’:’tokyo’}

print(len(str1))      #5
print(len(list1))     #3
print(len(t1))        #3
print(len(s1))        #4
print(len(dict1))     #3

del またはdel()

要素を削除する。文字列、リスト、タプル、集合、辞書が使えます。

str1 = “abcde”
list1 = [10, 20, 30]
t1 = (‘test’,’hello’, ‘tom’)
s1 = {10, 20, 23, 4}
dict1 = {‘name’:’tome’, ‘age’:30, ‘address’:’tokyo’}

del str1
print(str1) #NameError

del(list1)
print(list1) #NameError

del(list1[2])
print(list1) #[10, 20]

max、min

maxは最大の要素を取得する。
minは最小の要素を取得する。
str1 = “abcde”
list1 = [10, 20, 30]
t1 = (‘test’,’hello’, ‘tom’)
s1 = {10, 20, 23, 4}
dict1 = {‘name’:’tome’, ‘age’:30, ‘address’:’tokyo’}
 
print(max(str1)) #e
print(max(list1)) #30

print(min(str1)) #a
print(min(list1)) #10

print(max(t1)) #tom
print(min(t1)) #hello

range(start,end,step)

startからendまでの数値を生成する。endを含まない。
start,stepを省略できる。
例： range(10)  1～9の値を生成する

for i in range(1, 10, 1):
    print(i)
1
2
3
4
5
6
7
8
9

enumerate()

Pythonのenumerate()関数を使うと、forループの中でリストやタプルなどのイテラブルオブジェクトの要素と同時にインデックス番号（カウント、順番）を取得できる。

enumerate(対象,start=0)
list1 = [10, 20, 30]
for index, value in enumerate(list1):
    print(f'{index}={value}’)

結果：
0=10
1=20
2=30
list1 = [10, 20, 30]
for index, value in enumerate(list1,start=2):
    print(f'{index}={value}’)

結果：
2=10
3=20
4=30

tuple()

リスト、集合からタプルに変換する

list1 = [10, 20, 30]
s1 = {100, 200, 300}
t1 = (‘a’,’b’,’c’)

print(tuple(list1)) #(10, 20, 30)
print(tuple(s1))    #(200, 100, 300)

list()

タプル、集合からリストに変換する。
list1 = [10, 20, 30]
s1 = {100, 200, 300}
t1 = (‘a’,’b’,’c’)

print(list(s1))    #[200, 100, 300]
print(list(t1))    #[‘a’, ‘b’, ‘c’]

set()

リスト、タプルから集合に変換する
list1 = [10, 20, 30]
s1 = {100, 200, 300}
t1 = (‘a’,’b’,’c’)

print(set(list1))    #{10, 20, 30}
print(set(t1))       #{‘a’, ‘b’, ‘c’}

内包表記

リスト内包表記

リスト内包表記では新たなリストが生成される。

list1 = [i for i in range(10)]
print(list1) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
条件を満たす要素を削除する、という処理は、条件を満たさない要素を残す（抽出する）、という処理に等しい。このような処理にはリスト内包表記を利用する。
list1 = [i for i in range(10) if i %2 == 0]
print(list1) #[0, 2, 4, 6, 8]
list1 = [ (i,j) for i in range(3) for j in range(3)]
print(list1) #(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

辞書内包表記

dict1 = {i: i**2 for i in range(1,5)}
print(dict1) #{1: 1, 2: 4, 3: 9, 4: 16}

二つリストを結合し、辞書に変換

list1 = [‘name’, ‘age’]
list2 = [‘tom’, 29]

dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1) #{‘name’: ‘tom’, ‘age’: 29}

辞書から指定した条件のデータを取得

fruits = {‘apple’: 120, ‘Strawberry’: 300, ‘avocado’: 200, ‘orange’: 500}
dict1 = {key: value for key, value in fruits.items() if value >= 300}
print(dict1) #{‘Strawberry’: 300, ‘orange’: 500}

集合内包表記

list1 = [2, 8, 10]
set1 = {i**2 for i in list1}
print(set1) #{64, 100, 4}

関数

関数定義

ユーザーが定義する関数は、次のように定義します。
def 関数名(引数1, 引数2, …):
    “””
    関数の説明
    :param 引数1: 説明１
    :param 引数2: 説明2
    :return: 戻り値
    “””
    関数内で実行する処理
    return 戻り値
引数が 0 個の場合
def 関数名():
    関数内で実行する処理
    return 戻り値

関数に関数を実行

def 関数名():
    関数内で実行する処理
    関数名2()
    return 戻り値

関数実行

関数名(引数)

変数のスコープ(globalキーワード)

a = 100

def test():
    print(a)

def testB():
    a = 200
    print(a)

test()   #100
testB()  #200
print(a) #100　　aの値を変更されない
a = 100
def test():
    print(a)

def testB():
    global a
    a = 200
    print(a)

test()   #100
testB()  #200
print(a) #200 global キーワードを使ったら、変更されます。

引数

def user_info(name, age, address=”jp”):
    print(f’名前：{name},年齢：{age},住所：{address}’)

user_info(‘Tom’, 39, ‘tokyo’)  #名前：Tom,年齢：39,住所：tokyo

user_info(‘Rose’, address=‘CHIBA’, age=20) #名前：Rose,年齢：20,住所：CHIBA

user_info(‘Rose’, age=20) #名前：Rose,年齢：20,住所：jp

可変長引数

def user_info(*args):
    print(args)

user_info() #()
user_info(‘Tom’, 39)  #(‘Tom’, 39)
user_info(‘Rose’) #(‘Rose’,)
キーワード付きの引数を受け取るように関数を定義することもできます。
def user_info(**kwargs):
    print(kwargs)

user_info() #{}
user_info(name = ‘Tom’, age =39)  #{‘name’: ‘Tom’, ‘age’: 39}

アンパック

タプルのアンパック

def get_num():
    return 100, 200

num1, num2 = get_num()
print(num1,num2) #100 200

辞書のアンパック

dict1 = {‘name’: ‘Tom’, ‘age’: 20}
a, b = dict1
print(a) #name
print(b) #age

print(dict1[a]) #Tom
print(dict1[b]) #20

二つ変数の値を交換

a, b = 1, 2
a, b = b, a

print(a) #2
print(b) #1

可変データ型

リスト、辞書、集合は元のデータを変更できる。
整数、小数、文字列、タプルは元のデータを変更できない。

lambda(無名関数)

def文で関数を定義するが、lambda（ラムダ式）で名前を持たない無名関数を作成することもできる。
名前 = lambda 引数, 引数, ...: 式

引数無し

fn2 = lambda:100
print(fn2)  #<function <lambda>print(fn2()) #100

引数あり

fn1 = lambda a,b : a+b
print(fn1(10,20)) #30

引数デフォルト値

fn1 = lambda a,b,c=10 : a+b+c
print(fn1(10,20)) #40

可変長引数

fn1 = lambda *args : args
print(fn1(10,20,29)) #(10, 20, 29)
fn1 = lambda **kwargs : kwargs
print(fn1(name=’Tome’,age = 20)) #{‘name’: ‘Tome’, ‘age’: 20}

条件付き

fn1 = lambda a, b : a if a > b else b
print(fn1(10,20)) #20

リストのソート

students = [
    {‘name’:’tom’, ‘age’: 20},
    {‘name’:’rose’, ‘age’: 19},
    {‘name’:’jack’, ‘age’: 22},
]

students.sort(key=lambda x:x[‘age’])

print(students) #[{‘name’: ‘rose’, ‘age’: 19}, {‘name’: ‘tom’, ‘age’: 20}, {‘name’: ‘jack’, ‘age’: 22}]

高階関数

 map関数

map関数はリストのような複数の要素をもったオブジェクト（これをシーケンスと呼びましたね）と関数を引数として受け取ります。そしてシーケンスの各要素を、受け取った関数に渡して実行してくれます。このように関数を受け取る関数や関数を返す関数を高階関数と呼びます。
map(function, sequence_object)
list1 = [1, 2, 3, 4, 5]
def func(x):
    return x * 2 
result = map(func, list1)

print(result)
print(list(result)) #[2, 4, 6, 8, 10]

reduce関数

シーケンスのすべての要素をまとめて1つの値に集約します。集約する方法は、引数を2つ受け取る関数を用意します。
関数は最初1番目、2番目の要素を受け取りその集約結果を返します。次にその集約結果を引数1に、3番目の要素を引数2に受け取ります。この繰り返しですべての要素を処理します。
import functools
list1 = [1, 2, 3]

def func(x, y):
    return x + y

result = functools.reduce(func, list1)
print(result) # 6  # func(func(1, 2), 3)

filter

シーケンスのすべての要素を関数の引数として実行し、Trueを返却した要素のみから新しいlistを作成する。
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def func(x):
    return x % 2 == 0

result = filter(func, list1)
print(list(result)) # [2, 4, 6, 8]
タイトルとURLをコピーしました