Pythonまとめ（１．基本構文）

python code

>>> def method():
...     print(1)
...
>>> method()
1                    # 実行結果

varname = 値 # これにより変数varnameは値を参照するように初期化される

print(  varname ) # これは初期化されている変数をしようしているため問題なし
print( nonename ) # nonenameは初期化されていない変数のためエラーが発生する

varname:str = "value"

def 関数名(引数名1,引数名2,...):
    関数の処理
    return 戻り値

def 関数名(引数名1:引数名1の型, 引数名2:引数名2の型, ...) -> 戻り値の型:
    関数の処理
    return 戻り値

def printtest(arg1, *arg2, **arg3):
    print(f"  ARG1:{arg1}")
    print(f" *ARG2:{arg2}")
    print(f"**ARG3:{arg3}")

printtest( "引数1", "引数2", "引数3", "引数4", "引数5", Arg6="引数6", Arg7="引数7")

def methodtest1(arg1, arg2):
    return arg1+arg2

def methodtest2():
    pass

print( methodtest1(3,5) )
print( methodtest2() )

lambda arguments: expression

func = lambda x,y: x + y

print( func(1,3) )

print('print data')

print('print data')
print("data1", "data2", "data3")

print( *objects, sep=' ', end='\n', file=sys.stdout, flush=False)

input()
input(prompt)

s = input("Enter your ID:")
print(s)

if condition1:
    condition1がTrueの場合
elif condition2:
    condition1がFalseかつcondition2がTrueの場合
else:
    すべてのconditionがFalseの場合

while condition:
    条件を満たす間、繰り返す処理

for varname in iterable:
    各要素に対して順番に実行する処理

for varname in range(times): 
    times回実行する処理

for varname in range(start, end): 
    end-start回実行する処理

a = 0
while True:
    a += 1
    if a > 3:
        break
    print(a)
print("end")

a = 0
while a < 5:
    a += 1
    if a < 3:
        continue
    print(a)
print("end")

def find_negative(*numbers):
    for n in numbers:
        if n < 0:
            print(f"found:{n}")
            break
    else:
        print('not found')


find_negative(4,5,-3,5,-9) # 負数を含む場合
find_negative(2,6,5,6)     # 負数を含まない場合

match x:
    case 1:
        xが1のときの処理
    case 2:
        xが2のときの処理
    case _:
        xが1でも2でもないときの処理

match x:
    case 1|2|3:
        xが1か2か3のときの処理
    case _:
        それ以外のときの処理

match x:
    case 1 if y == True:
        xが1かつyがTrueのときの処理
    case 1|2:
        xが1または2のときの処理

match ['a', 200, 30]:
    case 'a'|'b', 100, 10|20:
        print( 'pattern 1' )
    case 'a', 100|200, 30:
        print( 'pattern 2' )
    case 'b', 100, _:
        print( 'pattern 3' )
    case 'b', 200, _:
        print( 'pattern 4' )

match [1,2,3,4]:
    case 1,2,_:         # 長さが違うのでマッチしない
        print("1,2,_")
    case 1,2,*_:        # これにはマッチする
        print("1,2,*_")

values = "drop table customer price".split(" ")
print(values)

match values:
    case "drop","table",*tablenames:
        print("==drop table==")
        for table in tablenames:
            print(table)

def matchtest(dict1):
    match dict1:
        case {"TYPE":0}:          # キーTYPEの値が0であること
            print("pattern 1")
        case {"ID":_, "NAME":_}:  # キーIDとNAMEが存在すること
            print("pattern 2")
        case {"ID":_}:            # キーIDが存在すること
            print("pattern 3")
        case _:
            print('error')

matchtest( {"TYPE":0, "ID":100} ) # Pattern 1
matchtest( {"TYPE":1, "ID":10, "NAME":"test"} )  # Pattern 2
matchtest( {"TYPE":2, "ID":20, "NOTE":"test"} )  # Pattern 3
matchtest( {"TYPE":2, "NAME":"test", "NOTE":"test"} ) # Pattern error

match [1, 1, 5]:
    case 1, 1, x: # これは3つ目の値は何でもよく、その値をxにキャプチャするという意味になる
        print( f'pattern 1 and {x=}' )
    case x:       # これはすべてのオブジェクトにマッチし、その値をxにキャプチャという意味になる
        print(x)

def matchtest(list1):
    match list1:
        case 1, 0, 1|2|3 as z:
            print( f'pattern 1. {z=}' )
        case 1, 0, z:
            print( f'pattern 2. {z=}' )
        case [0, *y] as z:
            print( f'pattern 3. {y=}, {z=}' )
        case z:
            print( f'pattern 4. {z=}' )

matchtest( [1, 0, 1] )  # Pattern 1
matchtest( [1, 0, 5] )  # Pattern 2
matchtest( [0, 9, 4] )  # Pattern 3
matchtest( [1,-3, 5] )  # Pattern 4

values = [1,2,3,4]

class Number():
    A:int = 1
    B:int = 2

for value in values:
    print(f"{value}:", end="")
    match value:
        case Number.A:
            print("A")
        case Number.B:
            print("B")
        case _:
            print("_")

from abc import ABC

class Point(ABC):
    pass

class Point1D(Point):
    def __init__(self, x=0):
        self.x = x

class Point2D(Point):
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

class Point3D(Point):
    def __init__(self, x=0, y=0, z=0):
        self.x = x
        self.y = y
        self.z = z

pointtable = [
    [Point1D(x= 1),           Point1D(x= 2),           Point1D(x= 3),          ],
    [Point2D(x= 1,y=-1),      Point2D(x= 2,y=-2),      Point2D(x= 3,y=-3),     ],
    [Point3D(x= 1,y=-1,z=10), Point3D(x= 2,y=-2,z=20), Point3D(x= 3,y=-3,z=30),],
]

for pointrow in pointtable:
    for point in pointrow:
        match point:
            case Point(x= 3, y=-3):
                print('pattern 1')
            case Point(x= _, z= _):
                print('pattern 2')
            case Point(y=_):
                print('pattern 3')
            case Point(x = 1, y =-1|-2):
                print('pattern 4')
            case Point(x = 1):
                print('pattern 5')
            case Point():
                print('pattern 6')
            case _:
                print('No Match' )

numbers = [ 1, 1.3, 3, 5.5, "A" ]

for number in numbers:
    print(f"{number:>3}: ", end="")
    match number:
        case int(1|2):
            print("1 or 2")
        case int(a): # これは int() as a と等しい
            print(f"integer {a}")
        case int() | float():
            print("number")
        case _:
            print("not number")

>>> sequence = "ABCDEFGHIJ"
>>> sequence[3]
'D'
>>> sequence[-5]
'F'

>>> a = 124
>>> b = 12.5
>>> type(a)
<class 'int'>
>>> type(b)
<class 'float'>

>>> 0.3-0.2-0.1
-2.7755575615628914e-17

>>> import decimal as d
>>> d.Decimal('0.3')-d.Decimal('0.2')-d.Decimal('0.1')
Decimal('0.0')

>>> True + True
2

# 完全一致
type( obj ) is (class1, class2, ...)     # 比較対象のクラスが1つだけであればタプルにしなくて良い

# 継承を含む
isinstance( obj, (class1, class2, ...) ) # 比較対象のクラスが1つだけであればタプルにしなくて良い

class A():
    pass

class B(A):
    pass

a = A()
b = B()

print( "type比較" )
print( type(a) is A )       # True
print( type(b) is A )       # False

print( "isinstance比較" )
print( isinstance(a, A) )   # True
print( isinstance(b, A) )   # True

isinstance( True, int ) # True

class Number(IntEnum):
    A = 1
    B = 2

isinstance( Number.A, int ) # True

'文字列'
'''文字列'''

"文字列"
"""文字列"""

sampletxt = """
"Sample"
'Text'
"""

print(repr(sampletxt))

import textwrap

sampletxt = """
            "Sample"
            'Text'
            """

print("--")
print(sampletxt)
print("--")
print(textwrap.dedent(sampletxt))
print("--")

>>> print('文字\n列')
文字
列
>>> print(r'文字\n列')
文字\n列

>>> a=1; b=5
>>> f"{a}+{b}={a+b}"
'1+5=6'

>>> a = 1; b = 0
>>> frm = f"{a}+{b}={a+b}" # この時点で文字列frmは 1+0=1 となる
>>> for i in range(3):
...     b = i # ここでbの値が変わってもfrmには影響を与えない
...     print( frm )
1+0=1
1+0=1
1+0=1

val=100

# {}の中で同じ引用符や\t、\nを使う、f文字列を入れる
print(f"{f"\t{val}"}")

# {}の中で改行
print(f"{
    val
         }")

# コメントをつける
print(f"{
    val # コメント
    }")

import datetime

now = datetime.datetime.now()

print(f"{now}")
print(f"{now = }")

import datetime

now = datetime.datetime.now()
print(f"{now = }")
print(f"{now = !s}")
print(f"{now = :%Y-%m-%d}")

>>> a="test"
>>> for char in a:
...     print(char)
t
e
s
t

>>> a="12345"
>>> print(a[1])
2
>>> print(a[1:-1])
234

>>> a = "abcde"
>>> a[1] = 'x'
Exception has occurred: TypeError
'str' object does not support item assignment

print( a + b ) # +が必要
print( "str" "ing" ) # 文字列リテラル同士なら+がなくてもOK
print( "str" f"{b}" ) # 文字列リテラル同士なら+がなくてもOK
print( a + b[0] + b[1] + b[2] )

>>> ','.join(["2012-03-08", "Hana Senou", "Female"])
'2012-03-08,Hana Senou,Female'

>>> from datetime import datetime,date,timezone
>>> # ローカル時刻で現在日時を取得
>>> datetime.now()
datetime.datetime(2023, 7, 17, 22, 23, 49, 145537)
>>> date.today()
datetime.date(2023, 7, 17)
>>> # UTCで現在日時を取得
>>> datetime.utcnow()
datetime.datetime(2023, 7, 17, 13, 26, 31, 339851)
>>> datetime.utcnow().date()
datetime.date(2023, 7, 17)

>>> from datetime import datetime,timezone,timedelta
>>> # タイムゾーンを明示的に指定して現在日時を取得
>>> jst = timezone(timedelta(hours=+9), 'JST')
>>> datetime.now(jst)
datetime.datetime(2023, 7, 17, 22, 43, 33, 180461, tzinfo=datetime.timezone(datetime.timedelta(seconds=32400), 'JST'))
>>> datetime.now(jst).date()
datetime.date(2023, 7, 17)

>>> from datetime import datetime,date
>>> datetime2 = datetime(2022,5,12,15,30,24,34567)
>>> datetime2
datetime.datetime(2022, 5, 12, 15, 30, 24, 34567)
>>> datetime2
datetime.datetime(2022, 5, 12, 15, 30, 24, 34567)
>>> date2 = date(2022,5,13)
>>> date2
datetime.date(2022, 5, 13)

>>> datetime1.year
2023
>>> datetime1.month
7
>>> datetime1.day
17
>>> datetime1.hour
22
>>> datetime1.minute
52
>>> datetime1.second
19
>>> datetime1.microsecond
535502
>>> datetime1.microsecond
535502
>>> date1.weekday() # 曜日は関数なので注意
0 # 月曜始まるで月曜が0、日曜は6
>>> date1.weekday() # 曜日は関数なので注意
1 # 月曜始まりで月曜が1、日曜は7

>>> dt1 = datetime(2023,7,17,20,00)
>>> dt1.replace(year=2500,month=8,day=5,hour=0,minute=0)
datetime.datetime(2500, 8, 5, 0, 0)

>>> dt1 = datetime(2023,7,17,20,00)
>>> dt1 + timedelta(days=1) # dayではなくdaysであることに注意
datetime.datetime(2023, 7, 18, 20, 0)

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

>>> import datetime
>>> dt = datetime.datetime.now()
>>> dt
datetime.datetime(2023, 7, 22, 17, 57, 57, 462458) # 今日は7月22日
>>> dt + datetime.timedelta(days=365)
datetime.datetime(2024, 7, 21, 17, 57, 57, 462458) # 365日後は7月21日。閏年のため1日ずれている。

>>> import datetime
>>> from dateutil.relativedelta import relativedelta # relativedeltaをインポート
>>> dt = datetime.datetime.now()
>>> dt
datetime.datetime(2023, 7, 22, 17, 57, 57, 462458) # 今日は7月22日
>>> dt + relativedelta(years=+1)
datetime.datetime(2024, 7, 22, 17, 57, 57, 462458) # 1年後は7月22日。閏年が考慮されている。

>>> dt1 = datetime(2023,7,17,20,00)
>>> dt2 = datetime(2023,7,17,21,30)
>>> dt2-dt1
datetime.timedelta(seconds=5400)
>>> dt1-dt2
datetime.timedelta(days=-1, seconds=81000)

>>> # ISOフォーマット
>>> date1 = datetime.now(jst).date()
>>> datetime1 = datetime.now(jst)
>>> date1.isoformat()
'2023-07-17'
>>> datetime1.isoformat()
'2023-07-17T22:52:19.535502+09:00'
>>> date1.strftime('%Y-%m-%d %H-%M-%S.%f')
'2023-07-17 00-00-00.000000'
>>> datetime1.strftime('%Y-%m-%d %H-%M-%S.%f')
'2023-07-17 22-52-19.535502'
>>> datetime1.strftime('%Y-%m-%d(%a) %H-%M-%S.%f %Z')
'2023-07-17(Mon) 22-52-19.535502 JST'

>>> datetime.strptime("2023-07-17", "%Y-%m-%d") # 任意のフォーマット
datetime.datetime(2023, 7, 17, 0, 0)
>>> datetime.fromisoformat("2022-05-12T15:30:24") # ISOフォーマット
datetime.datetime(2022, 5, 12, 15, 30, 24)

sequence[ 取り出し開始位置(start) : 取り出し終了位置(stop) ]

char_sequence[2:5]
char_sequence[2:-5]
char_sequence[-8:-5]
char_sequence[-8:5]

>>> char_sequence = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
>>> char_sequence[5]
'F'
>>> char_sequence[2:5]
['C', 'D', 'E']

>>> char_sequence[3:]
['D', 'E', 'F', 'G', 'H', 'I', 'J']
>>> char_sequence[:-1]
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']

sequence[ 取り出し開始位置(start) : 取り出し終了位置(stop) : 取り出し間隔(step) ]

>>> num_sequence = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> num_sequence[0:10:2]
[0, 2, 4, 6, 8]
>>> num_sequence[1:6:2]
[1, 3, 5]

num_sequence = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 長さが10のシーケンス

num_sequence[ 5  :  2 : -1 ]  # これは[5, 4, 3]が得られる

num_sequence[    :  3 : -1 ]  # 開始位置が省略＝シーケンスの末尾なので[9, 8, 7, 6, 5, 4]が得られる
num_sequence[  9 :  3 : -1 ]  # 上と同じ結果になる指定

num_sequence[ -3 :    : -1 ]  # 終了位置が省略＝シーケンスの最初なので[7, 6, 5, 4, 3, 2, 1, 0]が得られる
num_sequence[ -3 :-11 : -1 ]  # 上と同じ結果になる指定
num_sequence[ -3 :  0 : -1 ]  # これは[7, 6, 5, 4, 3, 2, 1]となり0が含まれない

>>> a = [1, 2, 3, 4, 5]
>>> a[2:] = ["a", "b"]
>>> a
[1, 2, 'a', 'b']

>>> a = [1, 2, 3, 4, 5]
>>> a[:2] = ["a","b","c","d","e"]
>>> a
['a', 'b', 'c', 'd', 'e', 3, 4, 5]

>>> a = [1, 2, 3, 4, 5]
>>> a[2:4] = ["a","b","c","d","e"]
>>> a
[1, 2, 'a', 'b', 'c', 'd', 'e', 5]

>>> a = [ 1, 2, 3, 4, 5 ]
>>> a[::2]
[1, 3, 5] # 要素が連続しないスライス指定。要素数は3。
>>> a[::2] = ['a', 'b', 'c']
>>> a
['a', 2, 'b', 4, 'c']
>>> a[::2] = ['a', 'b', 'c', 'd', 'e'] # 要素数5を代入
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: attempt to assign sequence of size 5 to extended slice of size 3
# ValueError：サイズが3の拡張スライスにサイズが5のシーケンスを割り当てようとした

>>> a = [ 1, 2, 3, 4, 5 ]
>>> a[1:1]
[]
>>> a[1:1] = [ "a","b","c","d","e" ]
>>> a
[1, 'a', 'b', 'c', 'd', 'e', 2, 3, 4, 5]

>>> a = [ 1, 2, 3, 4, 5 ]
>>> a[100:200] # レンジ外のスライス指定も長さが0になるので
[]
>>> a[100:200] = ['a', 'b', 'c'] # こうすると末尾への挿入になる
>>> a
[1, 2, 3, 4, 5, 'a', 'b', 'c']

>>> "key" in dict
False

dicta = { "a":1, "b":2, "c":3 }

isinstance(dict.keys(), collections.abc.Set) # True

dicta.keys() >= {"a","b"}     # True
dicta.keys() >= {"a","b","d"} # False

dicta = { "a":1, "b":2, "c":3 }
set(dicta) # これは{'b', 'c', 'a'}のような順不問のキーの集合になる

>>> dict = {} # dictは空の辞書
>>> dict["key"] # 存在しないkeyにアクセス
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'key'
>>>
>>> dict.get("key", 0) # getを使用して存在しないkeyにアクセス
0

>>> from collections import defaultdict # defaultdictは標準型ではないためインポート必要
>>> defdict = defaultdict(lambda:0) # 引数で初期化する関数を指定、常に0を返すlambda関数を渡している。
>>> defdict["key"] # defaultdictで存在しないkeyにアクセス
0

>>> from collections import defaultdict
>>> defdict = defaultdict(list) # 引数で初期化する関数は空のリストを作成するlist()であり、初期値は[]になる。
>>> defdict["a"]
[]
>>> defdict["b"].append("bb")
>>> defdict["b"]
['bb']

>>> list1 = [ 'h', 'e', 'l', 'l', 'o' ]
>>> list2 = [ 'h', 'e', 'm', 'l', 'o' ]
>>> list1 < list2
True

>>> list1 = [ 10, 20, 30]
>>> list2 = [ 10, 20, 20, 40]
>>>
>>> list1 < list2
False # 3番目の要素がlist2の方が小さい

>>> list1 = [ 10, 20, 30]
>>> list2 = [ 10, 20, 30, 40]
>>>
>>> list1 < list2
True # 3番目の要素までは同じだが、list1の方が要素数が少ない

>>> set1 = {1, 2, 3, 4, 5}
>>> set2 = {5, 4, 3, 2, 1}
>>> set3 = {1, 5, 3}
>>> set4 = {1, 2, 8}
>>>
>>> set1 >= set2
True
>>> set1 > set3
True
>>> set1 > set4
False

>>> # リストでの比較
>>> list1 = [10,20,30]
>>> list2 = [10,20,30]
>>> list3 = [30,20,10] # 中身は同じだが順序が異なる
>>> list1 == list2
True
>>> list1 == list3
False
>>> #辞書型は順序を持たないためキーバリューの組み合わせがすべて一致していれば良い。
>>> dict1 = { "key1":10, "key2":20 }
>>> dict2 = { "key2":20, "key1":10 } # 見た目上の順序は異なる
>>> dict1 == dict2
True

>>> list1 = [10,20,30]
>>> list2 = [30,20,10]
>>> set1 = set(list1)
>>> set2 = set(list2)
>>> set1 == set2
True

>>> list3 = [10,20,30,30,20,10]
>>> set3 = set(list3)
>>> set3
{10, 20, 30}
>>> set1 == set3
True

>>> list1 = [ 10, 20, 30]
>>> list2 = [ 30, 20, 10]
>>> list1 == list2
False
>>> sorted(list1) == sorted(list2)
True

for item in collection:
    print(item)

for key in dictionary:
    print(dictionary[key])

>>> len(dict1)
3

for (index,value) in enumerate(collection):
    print(f"collection[{index}]={value}") 

for index,value in enumerate(collection):

>>> dict = {"key1":100, "key2":200}
>>> for i,v in enumerate(dict):
...     print(f"{i=},{v=}")
i=0,v='key1' #　Python3.7からは常にkey1が0番目、key22が1番目である
i=1,v='key2'

>>> enumerate(list)
<enumerate object at 0x000001B828678A00>
>>> for i,v in enumerate(list):
...     print( f"{i=}, {v=}" )
i=0, v='h'
i=1, v='e'
i=2, v='l'
i=3, v='l'
i=4, v='o'

>>> for i,v in enumerate(list, 1):
...     print( f"{i=}, {v=}" )
i=1, v='h'
i=2, v='e'
i=3, v='l'
i=4, v='l'
i=5, v='o'

>>> for i,v in enumerate(list, 1):
...     print( f"{i=}, {v=}, {list[i]=}" )
i=1, v='h', list[i]='e'
i=2, v='e', list[i]='l'
i=3, v='l', list[i]='l'
i=4, v='l', list[i]='o'
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>;
IndexError: string index out of range
# list[5]へのアクセスが発生しインデックスエラーとなる

>>> enumerate(["a","b"],0)
<enumerate object at 0x0000020A85D79380>
>>> list(enumerate(["a","b"],0))
[(0, 'a'), (1, 'b')]

>>> list1 = [1,2,3]; list2 = [4,5,6]
>>> list1.append(list2)
>>> list1
[1, 2, 3, [4, 5, 6]]
>>> list1[3]
[4, 5, 6]

>>> list1 = [1,2,3]; list2 = [4,5,6]
>>> list1.extend(list2)
>>> list1
[1, 2, 3, 4, 5, 6]

>>> dict1 = {1:10,2:20}
>>> dict2 = {1:100,2:200}
>>> print( dict1 | dict2 )
{1: 100, 2: 200}
>>> print( dict2 | dict1 )
{1: 10, 2: 20}

# リスト
[ expression for variable_name in itarable ]
# ディクショナリ
{ key_expression:value_expression for variable_name in itarable }
# セット
{ expression for variable_name in itarable }

>>> datarange = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> { x:x**2 for x in datarange }
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

[ rule_expression for variable_name in itarable if condition_for_iterable ]

>>> datarange = list(range(1,21))
>>> datarange
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> [ x**2 for x in datarange if x%3==0 ]
[9, 36, 81, 144, 225, 324]

[ x**2 for x in (1,2,3,4,5,6,7,8,9,10) if x > 5 if x%2==0 ]

[ (x,y,z) for x in (1,2) for y in (1,2) for z in (1,2) if not (x == y and y == z) ]

array = []
for x in (1,2,3,4,5,6,7,8,9,10):
    if x > 5:
        if x%2 == 0:
            array.append(x**2)

>>> [ (x,y) for x in (1,2) for y in (3,4) ]
[(1, 3), (1, 4), (2, 3), (2, 4)]
>>> [ (x,y) for y in (3,4) for x in (1,2) ]
[(1, 3), (2, 3), (1, 4), (2, 4)]

>>> for x in (1,2):
...     for y in (3,4):
...         print(x, y)
...
1 3
1 4
2 3
2 4
>>> for y in (3,4):
...     for x in (1,2):
...         print(x, y)
...
1 3
2 3
1 4
2 4

min(iterable, key=None)          # iterableは空であってはいけない
min(iterable, default, key=None) # こちらはiterableが空でもOK。defaultはiterableが空だったときの値
min(arg1, arg2, *args, key=None) # これはiterableではなく引数で指定する

max(iterable, key=None)          # iterableは空であってはいけない
max(iterable, default, key=None) # こちらはiterableが空でもOK。defaultはiterableが空だったときの値
max(arg1, arg2, *args, key=None) # これはiterableではなく引数で指定する

datas = [ (10,20), (10,25), (40,10), (30,30) ]

print( min(datas) )
print( min(datas, key=lambda x:x[1]) )
print( max(datas, key=lambda x:x[0]+x[1]))

filter( function, iterable )

>>> list1 = [ 1, 6, 3, 10, 5, 9]
>>> filter(lambda x:x%2, list1)
<filter object at 0x000002AE3E2B6080>
>>> list(filter(lambda x: x%2, list1))
[1, 3, 5, 9]

>>> list2 = [x for x in list1 if x%2]
>>> list2
[1, 3, 5, 9]
>>> list_iter = (x for x in list1 if x%2)
>>> next(list_iter)
1
>>> next(list_iter)
3
>>> next(list_iter)
5
>>> next(list_iter)
9
>>> next(list_iter)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

map( callable, iterable)

>>> lista = [ -5, 10, 30]
>>> list( map( abs, lista))
[5, 10, 30]

>>> lista = [ -5, 10, 30]
>>> [abs(x) for x in lista]
[5, 10, 30]

>>> lista = [ -30, 10, 5]
>>> sorted( lista )
[-30, 5, 10]

>>> lista = [ -30, 10, 5]
>>> sorted(tuplea, key=lambda x:abs(x), reverse=True )
[-30, 10, 5]

>>> iterable1 = (1,2,3)
>>> iterable2 = ["M","F","M"]
>>> iterable3 = ["Augustine","Onslow","Basil"]

>>> list(zip(iterable1,iterable2,iterable3))
[(1, 'M', 'Augustine'), (2, 'F', 'Onslow'), (3, 'M', 'Basil')]

>>> iterable1 = (1,2,3)
>>> iterable2 = ("A")

>>> list(zip(iterable1, iterable2))
[(1, 'A')]

>>> list(zip(iterable1, iterable2, strict=True))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: zip() argument 2 is shorter than argument 1

def generator_function1():
    yield 1
    yield 2
    yield 3

gen_iter = generator_function1()
print(gen_iter)

for x in gen_iter:
    print(x)

>>> gen_iter = generator_function1()
>>> next(gen_iter)
1
>>> next(gen_iter)
2
>>> next(gen_iter)
3
>>> next(gen_iter)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

def generator_function2():
    a = 1
    while True:
        yield a
        a += 1


def generator_sample2():
    for i in generator_function2():
        print(i)
        if i >= 100: break # 無限に続くためループ側で終了するようにしておく


generator_sample2()

def generator_function3():
    sum = 0
    while True:
        sent = yield sum
        if isinstance(sent, int):
            sum += int(sent)
        else:
            try:
                intvalue = int(sent)
                sum += intvalue
            except ValueError:
                pass


def generator_sample3():
    gen_iterator = generator_function3()
    sendvalue = None
    try:
        while True:
            x = gen_iterator.send(sendvalue)
            print(x)
            sendvalue = input("number:")
    except StopIteration:
        pass
    except EOFError:
        pass
    finally:
        gen_iterator.close(


generator_sample3()

        sent = yield sum

            x = gen_iterator.send(sendvalue)

>>> gen = (x for x in range(1, 4))
>>> type(gen)
<class 'generator'>
>>> for i in gen:
...     print(i)
...
1
2
3

>>> gen_iter = ( (x,y) for x in (1,2) for y in (3,4) )
>>> next(gen_iter)
(1, 3)
>>> next(gen_iter)
(1, 4)
>>> next(gen_iter)
(2, 3)
>>> next(gen_iter)
(2, 4)
>>> next(gen_iter)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

from enum import Enum

# クラス方式
class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

# ファンクション方式
Color = Enum('Color', ['RED', 'GREEN', 'BLUE'])

>>> Color = Enum('Color', ['RED', 'GREEN', 'BLUE'])
>>>
>>> Color.RED
<Color.RED: 1>
>>> Color(1)
<Color.RED: 1>
>>> member = Color.RED
>>> member.name
'RED'
>>> member.value
1
>>> Color(2).name
'GREEN'

>>> class Color(Enum):
...     RED = 1
...     KURENAI = 1
...     BLUE = 2
...
>>> Color(1)
<Color.RED: 1>
>>> Color.KURENAI
<Color.RED: 1>

>>> for c in Color:
...     print(c)
...
Color.RED
Color.BLUE

>>> for c in Color.__members__.items():
...     print(c)
...
('RED', <Color.RED: 1>)
('KURENAI', <Color.RED: 1>)
('BLUE', <Color.BLUE: 2>)

from enum import Enum, unique

@unique
class Color(Enum):
    RED = 1
    KURENAI = 1
    BLUE = 2

from enum import Enum, auto

class Color(Enum):
    RED = auto()
    BLUE = auto()
    GREEN = auto()

>>> Color.RED is Color.KURENAI
True
>>> Color.RED is not Color.BLUE
True
>>> Color.RED == Color.KURENAI
True
>>> Color.RED == 1
False
>>> Color.RED > Color.BLUE
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'Color' and 'Color'

from enum import Enum

class Color(Enum):
    RED = 0
    BLUE = 1
    GREEN = 2

import ColorEnum
from importlib import reload

redcolor1 = ColorEnum.Color.RED

reload(Enum1)

redcolor2 = ColorEnum.Color.RED

print(redcolor1 is redcolor2)
print(redcolor1 == redcolor2)

>>> class UNIXPermission(IntFlag):
...     R = 4
...     W = 2
...     X = 1
...     RWX = 7 # これはR|W|Xの値と等しいのでエイリアス扱いとなる
...
>>> UNIXPermission.R | UNIXPermission.W
<UNIXPermission.R|W: 6>
>>> UNIXPermission.RWX
<UNIXPermission.RWX: 7>
>>> UNIXPermission.R + UNIXPermission.W
6

from dataclasses import dataclass

@dataclass
class Human:
    name: str
    age: int

from dataclasses import dataclass

@dataclass
class Human:
    name: str
    age: int

h1 = Human("Eve", 0)

@dataclass
class Human:
    name: str
    age: int = 20

h1 = Human("test")

@dataclass
class Human:
    name: str
    age: int = 20
    sex: str

@dataclass
class Human:
    name: str
    birth: date
    age: int = field(init=False) # 初期化しないフィールド

    def __post_init__(self):
        pass # ここでbirthからageを計算する処理を実行

@dataclass(init=True,          # __init__
           repr=True,          # __repr__
           eq=True,            # __eq__
           order=False,        # __lt__, __le__, __gt__, __ge__
           unsafe_hash=False,  # __hash__
           frozen=False,       # イミュータブル化
           match_args=True,    # __match_args__
           kw_only=False,      # すべての引数がキーワード専用引数になる
           slots=False)        # __slots__

@dataclass
class Human:
    name: str
    age: int = 0
#   address: list[str] = []  これはエラーになる

dataclasses.field(*, default=MISSING, default_factory=MISSING, init=True, repr=True, hash=None, compare=True, metadata=None, kw_only=MISSING)

from dataclasses import dataclass, field

@dataclass
class Human:
    name: str
    age: int
    title: list[str] = field(default_factory=list)

from dataclasses import dataclass, field

@dataclass
class Human1:
    name: str
    age: int = field(default=0, compare=False, repr=False)

@dataclass
class Human2:
    name: str
    age: int = 0

h11 = Human1("Eve", 5); h12 = Human1("Eve", 10)
h21 = Human2("Eve", 5); h22 = Human2("Eve", 10)

print( F"{h11=}, {h12=}, {h21=}, {h22=}")
print( F"{h11==h12 = }" )
print( F"{h21==h22 = }")

py -m pip install dataclass-wizard

from dataclasses import dataclass, field
import dataclass_wizard as dw

@dataclass
class Human1(dw.YAMLWizard):
    name: str
    age: int = field(default=0, compare=False, repr=False)

yaml = h.to_yaml()
print( "==YAML==" )
print( yaml )

h_load = Human1.from_yaml( yaml )
print( "==Loaded==" )
print( h_load )

from dataclasses import dataclass, field
import dataclass_wizard as dw

@dataclass
class Human1(dw.YAMLWizard):
    name: str
    age: int = field(default=0, compare=False, repr=False)

h = Human1("Eve", 30)

yaml = h.to_yaml(sort_keys=False)
print( "==YAML==" )
print( yaml )

class CounterClass(superclass): # スーパクラスがない場合(objの場合)は()ごと省略可能
    total = 0                   # クラス変数（すべてのインスタンスで共通の変数）

    def __init__(self, name):   # コンストラクタ
        self.name = name        # インスタンス変数

    def getName(self):          # インスタンスメソッド
        return self.name

    @classmethod
    def getCount(cls):          # クラスメソッド
        return cls.total

    @staticmethod
    def convertFrom():          # スタティックメソッド
        pass # 何らかの処理

    def __init__(self, name):   # コンストラクタ
        super().__init__(name)

>>> class Human:
...     _name = "example"
...
>>> Human._name # アクセスできるが、お作法上よろしくない
'example'

>>> class Human:
...     __name = "example"
...
>>> Human.__name # 普通にはアクセスできない
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'Human' has no attribute '__name'
>>> Human._Human__name
'example'

class Reader:
    def _readdata(self):
        print("Reader->readdata")

    def read(self):
        self._readdata()


class CSVReader(Reader):
    def _readdata(self):
        print("CSVReader->readdata")
        super().read()
    
    def read(self):
        self._readdata()

csvreader = CSVReader()
csvreader.read()

class Reader:
    def __readdata(self): # _Reader__readdataに置換される
        print("Reader->readdata")

    def read(self):
        self.__readdata() # _Reader__readdataに置換される


class CSVReader(Reader):
    def __readdata(self): # _CSVReader__readdataに置換される
        print("CSVReader->readdata")
        super().read()
    
    def read(self):
        self.__readdata() # _CSVReader__readdataに置換される

class PropertyTest:
    def __init__(self) -> None:
        self._balance = 0

    @property
    def balance(self):
        return self._balance
    
    @balance.setter
    def balance(self,value):
        if value<0: raise ValueError()
        self._balance = value

proptest = PropertyTest()
print( proptest.balance )
proptest.balance = 10
print( proptest.balance )
proptest.balance = -1
print( proptest.balance )

class PropertyTest2:
    def __init__(self) -> None:
        self._balance = 0

    def getbalance(self):
        return self._balance

    def setbalance(self, value):
        if value<0: raise ValueError()
        self._balance = value

    # 引数は順にgetter, setter, deleter, docstring
    balance = property(getbalance, setbalance, None, None)

class PropertyNameTest:
    def __init__(self, firstname, familyname) -> None:
        self.firstname = firstname
        self.familyname = familyname

    @property
    def fullname(self):
        return f"{self.firstname} {self.familyname}"
    

proptest = PropertyNameTest("Ned", "Peyton")
print( proptest.fullname )

class Sample1():
    def __new__(cls):
        print("new")
        return [1, 2, 3]

    def __init__(self): # この__init__は呼び出されない
        print("init")

class Sample2():
    def __new__(cls):
        print("new")
        return super().__new__(cls)

    def __init__(self):
        print("init")

print("Sample1")
Sample1()

print("\nSample2")
Sample2()

import datetime
now = datetime.datetime.now()

print( f"{repr(now) = }" )
print( f"{str(now)  = }" )

# 文字列をPythonコードとして実行するeval関数にreprの結果を渡す
then = eval( repr(now) )
print( f"{str(then) = }" )

class Item(object):
    def __init__(self) -> None:
        self.stock = 0
    
    def __setattr__(self, __name: str, __value: Any) -> None:
        print(f"__setattr__ called:{__name},{__value}")
        super().__setattr__(__name,__value)
    
    def __getattribute__(self, __name: str) -> None:
        print(f"__getattribute__ called:{__name}")
        return super().__getattribute__(__name)
    
    def __delattr__(self, __name: str) -> None:
        print(f"__delattr__ called:{__name}")
        super().__delattr__(__name)


i = Item()
print("--------------------------------")
i.stock = 100
print("--------------------------------")
print(i.stock)
print("--------------------------------")
del i.stock
print("--------------------------------")
i.name = "ItemName"

i = Item()
print("--------------------------------")
print(i.name)

class Item(object):
    def __init__(self) -> None:
        self.stock = 0

    def __setattr__(self, __name: str, __value: Any) -> None:
        print(f"__setattr__ called:{__name},{__value}")
        super().__setattr__(__name,__value)

    def __getattribute__(self, __name: str) -> None:
        print(f"__getattribute__ called:{__name}")
        return super().__getattribute__(__name)
    
    def __delattr__(self, __name: str) -> None:
        print(f"__delattr__ called:{__name}")
        super().__delattr__(__name)

    def __getattr__(self, __name: str):
        print(f"__getattr__ called:{__name}")
        match __name:
            case "stock":
                self.stock = 0
                return self.stock
            case "name":
                self.name = "Void"
                return self.name
            case _:
                raise AttributeError(f"Unsupported attribute:{__name}")


i = Item()
print("--------------------------------")
print(i.stock)
print("--------------------------------")
print(i.name)

i = Item()
print("--------------------------------")
setattr(i, "stock", "100")
print("--------------------------------")
print( getattr(i, "name", "DEFAULTNAME") )  # 呼び出し時点では存在しないが__getattr__がサポートしている属性
print("--------------------------------")
print( getattr(i, "price", 10000) )         # 存在しない、__getattr__もサポートしていない属性で、デフォルト値の指定あり
print("--------------------------------")
print( getattr(i, "id") )                   # 存在しない、__getattr__もサポートしていない属性で、デフォルト値の指定なし

class Item(object):
    def __init__(self) -> None:
        time.sleep(1) # nameの計算に時間がかかる
        self.name = "default name"


item = Item() # この処理に時間がかかる

class Item_Delayed(object):
    def __init__(self) -> None:
        pass
    
    def __getattr__(self, __name: str):
        match __name:
            case "name":
                time.sleep(1) # nameの計算に時間がかかる
                setattr(self, "name", "Void")
                return "Void"
            case _:
                raise AttributeError(f"Unsupported attribute:{__name}")


itemdelay = Item_Delayed()
print(itemdelay.name) # name属性の初回アクセスで時間がかかる
print(itemdelay.name) # name属性の二回目アクセスで__getattr__は呼び出されないため時間がかからない

from memory_profiler import profile

class Item:
    def __init__(self) -> None:
        self.codes = [x for x in range(0,100000)]


class ItemDelayed:
    def __getattr__(self, __name: str):
        if  __name == (codes := "codes"):
            value = [x for x in range(0,100000)]
            setattr(self, codes, value)
            return value
        else:
            raise AttributeError(f"Unsupported attribute:{__name}")


@profile
def main():
    item = Item()
    itemDelayed = ItemDelayed()
    itemDelayed.codes


main()

def add_number(int1,int2):
    return int1+int2

def add_number_debug(int1,int2):
    print("add_number start")
    v = add_number(int1,int2)
    print("add_number end")
    return v

def add_number(int1,int2):
    return int1+int2

def modifier(target):
    def wrapper_function(int1,int2):
        print( "add_number start")
        v = target(int1,int2)
        print( "add_number end")
        return v
    
    return wrapper_function


add_number_debug = modifier(add_number)

print( add_number_debug(1,3) )

def printmethod(target:Callable):
    def wrapper_function(*positionalargs, **keywordargs):
        print(f"{getattr(target, '__name__', 'Function')} start")
        v = target(*positionalargs, **keywordargs)
        print(f"{getattr(target, '__name__', 'Function')} end")
        return v
    
    return wrapper_function

@printmethod
def add_number(int1,int2):
    return int1+int2

@printmethod
def mult_number(int1,int2):
    return int1*int2

mult_number(3,4)

def recordtime(tzinfo:datetime.tzinfo):
    def wrapper_function(target:Callable):
        def inner_function(*positionalargs, **keywordargs):
            print( f"{datetime.datetime.now(tzinfo)} start")
            v = target(*positionalargs, **keywordargs)
            time.sleep(2.5)
            print( f"{datetime.datetime.now(tzinfo)} end")
            return v
        return inner_function
    return wrapper_function


@recordtime(datetime.timezone.utc)
def add_number(int1,int2):
    return int1+int2

def wrapper_function(target:Callable):
    def inner_function(*positionalargs, **keywordargs):
        tzinfo = datetime.timezone.utc # パラメータは設定済み
        print( f"{datetime.datetime.now(tzinfo)} start")
        v = target(*positionalargs, **keywordargs)
        time.sleep(2.5)
        print( f"{datetime.datetime.now(tzinfo)} end")
        return v
    return inner_function

@recordtime(datetime.timezone(datetime.timedelta(hours=9)))
def add_number(int1,int2):
    return int1+int2


@recordtime(datetime.timezone.utc)
def mult_number(int1,int2):
    return int1*int2


print( add_number(3, 5) )
print( mult_number(3, 5) )

try:
    # 例外が発生しうる処理
except SomeError as e:
    # ある例外が発生したときの処理
except (CertinError, AnotherError) as e:
    # ある例外が発生したときの処理
else:
    # 例外が発生しなかったときの処理
finally:
    # 例外の発生如何に関わらず最後にかならず実行する処理

raise ValueError("エラーメッセージ")

raise newexception from originalexception

import traceback

try:
    # 例外が発生しうる処理
except:
    traceback.print_exc()

class OriginalException(Exception):
    def __init__(self, message):
        super().__init__(message)

# 変数の宣言
i:str = "文字列"

# 関数の引数と戻り値
def methodname(arg1:str, arg2:int) -> str:
    pass

assert condition[, message]

# 間違った例
assert(False, "Error")

number = 5
assert isinstance(number, int|float) and number > 0, \
       f"NUMBER should be a positive number, but {number} was given."

age_str = input("enter your age:")
if not re.match("\d+$",age_str,re.ASCII) or (age := int(age_str)) <= 0:
    print("不正な値が入力されました。")

def factorlist():
    # 試し割りする値のジェネレータ
    yield from (2,3,5)
    value = 7
    while True:
        for d in (2,2,2,4):
            yield value
            value += d

def pf(number:int):
    # 試し割りで素因数分解する
    primelist = []
    for v in factorlist():
        if number <= v: break
        while number%v == 0:
            number /= v
            primelist.append(v)
    return primelist

>>> pf(100)
[2, 2, 5, 5]
>>> pf(987945)
[3, 5, 7, 97, 97]

def pf_with_inputcheck(number:int):
    if not (isinstance(number, int) and number >= 1):
        raise ValueError(f"Number must be a integer larger than 1, but was {number!r}.")

    primelist = []
    for v in factorlist():
        if number <= v: break
        while number%v == 0:
            number /= v
            primelist.append(v)
    return primelist

def pf_with_inputassert(number:int):
    assert isinstance(number, int) and number >= 1, \
           f"Number must be a integer larger than 1, but was {number!r}."

    primelist = []
    currentvalue = number
    while currentvalue > 1:
        for i in range(2,currentvalue):
            if currentvalue%i == 0:
                currentvalue //= i
                primelist.append(i)
                break
 
    return primelist

>>> pf(20)
[2, 2]

def pf_with_outputassert(number:int):
    # 試し割りで素因数分解する  
    originalnumber = number 
    primelist = []
    for v in factorlist():
        if number <= v: break
        while number%v == 0:
            number /= v
            primelist.append(v)
    
    assert (result := reduce(lambda x,y: x*y, primelist))==originalnumber, \
        f"Prime factorization error. {originalnumber} != {"*".join(map(str,primelist))} = {result}."
    return primelist

def pf_fixed(number:int):
    # 試し割りで素因数分解する  
    originalnumber = number 
    primelist = []
    for v in factorlist():
        if number == 1: break
        while number%v == 0:
            number /= v
            primelist.append(v)
    
    return primelist

def factorlist_bug():
    yield 2
    yield 3
    value = 5
    while value < 10000:
        yield value
        value += 2

def pf_bug(number:int):
    if not( isinstance(number,int) and 1 < number < 100000 ):
        raise ValueError(f"Number must be integer and from 2 to 99999. Got {number}({type(number)}).")    
    # 試し割りで素因数分解する  
    originalnumber = number 
    primelist = []
    for v in factorlist_bug():
        if number == 1: break
        while number%v == 0:
            number /= v
            primelist.append(v)
    else:
        assert False, "You should not encounter this message. " \
            f"{originalnumber=}, {number=}, {v=}, {primelist=}"

    return primelist

>>> pf_bug(67432)
[2, 2, 2, 8429]
>>> pf_bug(67434)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 13, in pf_bug
AssertionError: You should not encounter this message. originalnumber=67434, number=11239.0, v=9999, primelist=[2, 3]

x = 5

del x

print(x) #　NameErrorとなる

>>> data = [0,1,2,3]
>>> del data[2]
>>> data
[0, 1, 3]

x = 5 # グローバル変数


def method1(): # ローカルで定義していない変数xを参照
    print(f"  1:{x}") 


def method2(): # グローバルと重複している変数xに代入
    x = 7
    print(f"  2:{x}")


def method3(): # global宣言の上で、変数xに代入
    global x

    x = 7
    print(f"  3:{x}")


print("method1")
method1()
print(f"  1:{x}")

print("\nmethod2")
method2()
print(f"  2:{x}")

print("\nmethod3")
method3()
print(f"  3:{x}")

exec(object, globals=None, locals=None, /, *, closure=None) 
# execはコードを指定できる closure引数は3.11から追加

eval(expression, globals=None, locals=None)
# evalは式のみ

>>> eval('4+5')
9
>>> exec('4+5')
>>>

with open('log.ini', mode='r') as f:
    print( "with内部" )
    print( f.readline() )

print( "with外部" )
print( f.readline() )     # ValueError: I/O operation on closed file.

class Test():
    def __enter__(self):
        print("enter")
        return self

    def __exit__(self, exc_type, exc_value, traceback): # with内部で発生した例外を受け取る引数がある
        print("exit")

with Test() as e:
    print('with')

from contextlib import contextmanager

class A:
    def print(self):
        print("A")

@contextmanager
def useA():
    print("enter")
    a = A()
    try:
        yield a # yieldの前までがenterに相当する部分、yieldの後がexitに相当する部分
    finally:
        # Code to release resource, e.g.:
        print("exit")
        del a

with useA() as a:
    a.print()

# 順番で指定する方法。引数の先頭から0,1,2,...となる
"{1}-{0}-{0}".format(10,"abc")

# キーワードで指定する方法
"{number}-{name}-{number}".format(number=10,name="abc")

"{0}-{1}-{2}".format(10,"abc","ABC")
"{}-{}-{}".format(10,"abc","ABC")

# 次はすべての順番指定が省略されていて、1対1対応しているのでOK。キーワード指定の{name}と{number}は省略には影響しない。
"{}-{name}-{number}-{}".format(100,200,number=10,name="abc") 
# 次は順番指定が省略されているものといないものが混在しているのでエラー
"{}-{1}".format(100,200,number=10,name="abc")

value=datetime.datetime.now()

print(   "{0}".format(value) ) # 変換フラグなし
print( "{0!s}".format(value) )
print( "{0!r}".format(value) )
print( "{0!a}".format(value) )

:[[fill]align][sign][#][0][minimumwidth][grouping_option][.precision][type]

valueint  =1000000
valuefloat=1.11111

locales = (
    "pt_PT.UTF-8", # ポルトガル語-ポルトガル
    "de_DE.UTF-8", # ドイツ語-ドイツ
    "ja_JP.UTF-8", # 日本語-日本
)

for _locale in locales:
    locale.setlocale(locale.LC_NUMERIC, _locale) # ロケールを切り替え
    print( f"=={_locale[:5]}==")
    print( "  {0} -> {0:n}".format(valueint) )
    print( "  {0} -> {0:n}".format(valuefloat) )

"{:%Y-%m-%d}".format( datetime.datetime.now() )

import datetime

class FormatTest:
    def __init__(self) -> None:
        self.datetime =datetime.datetime.now()
    
    def __format__(self, __format_spec: str) -> str:
        return self.datetime.strftime(__format_spec)


formattest=FormatTest()
value ="{:%Y%m%d}".format(formattest)

print(value)

def test(arg:Any, method:Callable):
    """_summary_

    Args:
        arg (Any): _description_
        method (Callable): _description_
    """

# PEP8基準で正しい
if x == 4: print(x, y); x, y = y, x
# PEP8基準で間違い
if x == 4 : print(x , y) ; x , y = y , x