#コメント（単一行） """ 複数行 「"」を参照 """ print（"任意の文字列"）

hensu = input('変数入力')

sample = 'hensu' print('変数の中身は = {}'.format()) #波かっこ「{}」の中身に出力されるはず

""" pythonで定数の宣言はできない 大文字_大文字という記述で記載されていたら定数と基本はみなす """ SAMPLE_TEISU = 'sample'

① hensu = 'sample' print(f'変数の内容は = {hensu }') # f'={hensu}' ② print(f'{=hensu }')# f'{=hensu}'

① is_hensu = True #論理型の任意の変数 ② suuti_int = 25 #数値型の任意の変数（int） hufou_float = 100.0 #数値型の任意の変数（float） ③ """ 上から足し算、引き算、掛け算、割り算 """ print (suuti_int + 1) print (suuti_int - 1) print (suuti_int * 1) print (suuti_int / 1) ④ print (suuti_int // 1) #割り算(余りが切り下げられる)

① hensu = 2 ② print(hensu ** 2) # 4が出力されう ③ print(type(hensu)) # Intが出力される

① hensu = 'moziretsu' #ダブルクォートでもOK print (hensu * 10) #変数 * nでn回表示 print (hensu + hensu) #+演算子で連結 ② hensu_kaigyo = """ mozi1 mozi2 """ #「"""」で改行を含んだ文字列を宣言できる ③ print(hensu[2]) #変数[n]でn番目の文字を示す（0番目から始まる） ④ byte_hensu = hensu.encode('utf-8') #文字列の変数.encode('文字コード')で宣言 hensu = hensu.decode('utf-8')#byte型の変数.decode('文字コード')で宣言

① hensu = 'moziretsu' ② print(hensu.count('mo')) #「1」と表示される。文字列の変数.count('カウント対象の文字')。存在しない文字列の場合は、0と表示される ③ print(hensu.startswith('mo')) #trueと表示される。文字列の変数.startswith('検索対象の文字列') print(hensu.endswith('mo')) #falseと表示される。文字列の変数.endswith('検索対象の文字列') ④ print(hensu .strip(’mo’)) #moが削除され出力される。文字列の変数.strip('削除対象の文字')。rstrip,lstripとするとそれぞれ右端及び左端から削除されるようになる ⑤ print(hensu.upper()) #大文字 print(hensu.lower()) #小文字。補足：hensu.swapcase()で大文字と小文字を入れ替える ⑥ print(hensu.replace('X','Y',-1)) #変数.repalce('置換文字列',’置き換え後の文字列')で文字変換で可能。-1を第三引数に入れないとすべて変換されない

① int_num = 12 print(str(int_num)) #str(数値型) ②③ msg = '12' print(int(msg)) #int(文字列型) msg = '20.5' print(float(msg)) #int(文字列型)

① list_a = [1,2,3,4] ② print(list_a [N]) #[N]でIndex番号を指定する

① list_a = [1,2,3,4,5] ② list_b = list_a[:N+1] #コロンN+1でリストの0番目～N番目までの要素を取り出す。この場合は、1,2,3が取り出される ③ list_a.append('apple') #append.('値')で新たに値が一つ追加される list_a.extend(['banana','orange']) #append.(リスト要素)でリスト形式での追加が可能 list_a.insert(1,'grape') #insert.(追加位置番号,'追加要素')で位置を指定可能 list_a.clear() #clearでリスト要素の中身をすべて削除

① list _ a = [0,1,1,2,2,3,3,3,4] ② list _ a.remove(3) #remove(削除したい値)で削除可能。ただし、左から数えて最初の要素の分しか削除されないので注意 ③ value = list_a.pop() #pop()で取得可能。変数valueにはリストの最後の要素が追加される ④ list _ a.count(0) #count(カウントしたい値)で値の数を指定してカウントする ⑤ list _ a.index(1) #index(取得したい位置番号)を指定する ⑥ list_b = list_a .copy() ⑦ list_a.sort() #sort() #昇順ソートされる list_b = sorted(list_a) #新たなリストlist_bにlist_aを昇順ソートした結果を格納 ⑧ list_a.reverse() #reverse()で降順ソート

① car = {"brando":"Toyota","model":"Prius","year":2015} #変数 = {"key":value,"key":value}の形で宣言 ② car['brando'] #変数['key']。取り出せなかったらエラー car.get('brando') #変数.get('key') 取り出せなかったらNoneが返却される car.get('XXX','not exist') #get('key','keyが取得不可の時の文言') ③ car.keys() car.values() car.items() ④ for key,value in car.items(): #for key,value in 辞書型の変数.teims: 「:」を忘れずに print("key= {} ",value = {}.format(key,value))

① car = {"brando":"Toyota","model":"Prius","year":2015} #変数 = {"key":value,"key":value}の形で宣言 ② car.update({'country':'japan'}) #変数.update({'key',value})。updateの引数に追加したいキーとバリューをしているする ③ car.popitem() #変数.popitem() ④ car.pop('country') #変数.pop('key') 。キーを削除する ⑤ car.clear() del car

① fruit= (''apple,'banana','orange') #タプルの宣言 ='("値1","値2","値3")のような形で宣言できる """ 1.タプルは値を変更することや追加することができない（値が変更されないことを保証できる） 2.配列側よりもアクセスすぴーとが速い """ ② fruit = fruit+ ('grape,') #このようにすれば追加自体は可能。+("",)とする。最後のカンマに注意 ③ list_a = ["banana","appke","grape"] #リストの場合は["値1","値2","値3"] fruit= tuple(list_a) #tuple関数内にリストを格納する ④ fruit[1] #変数[N]で取得 ⑤ fruit.count('apple') #値appleが何個あるか？ count('カウントしたい値')で指定可能 fruit.index('apple') #値appleが何番目にあるか？ index('何番目か確認をしたい値')で指定可能

① set_a = {'a','b','c','a'} #setを作成。'a'が2つあるが1つしか入っていない """ 同じ値を持つことができない（ユニーク） 順序が保持されていない（順番通り取得することが不可） ユニオンやインターセクションなどの集合処理を高速で行うことができる ② 'e' in set_a #set_aには'e'が入っていないのでfalseが返却される。'値' in リスト変数 'e' not in set_a #set_aには'e'が入っていないのでTrueが返却される。'値' not in リスト変数 len(set_a) #set_aの中の数を返却。この場合3が返却される len(リスト変数) ③ set_a.add('e') #set_aに値を追加。リスト変数.add('値') set_a.remove('e') #set_aから指定された値を削除。リスト変数.remove('値') 値がない場合はkeyErrorを返却 set_a.remove('e') #set_aに値を追加。リスト変数.discard('値') 値がない場合でもエラーは発生しない set_a.pop() #set_aから任意の要素を取り出して返して削除する。リスト変数.pop() set_a.clear() #set_aから削除する リスト変数.clear()

① s = {'a','b','c','d'} t = {'c','d','e','f'} ② s | t #sとtの和集合（ユニオン）。{'a','b','c','d','e','f'}を返却。sとtどちらにもある要素 s.union(t) ③ s & t #sとtの積集合{'c','d'}を返却。sとtどちらにもある要素 s.intersection(t) ④ s-t #sとtの差集合{'a','b'}を返却。sに含まれていてtにない値 s.difference(t) ⑤ s ^ t #sとtの片方に含まれる{'a','b','e','f'}を返却 s.symmetric_difference(t) ⑥ s.issubset(t) #集合sの要素が別の集合tにすべて含まれているか？この場合はtrue s.issuperset(t) #集合sがtの要素を含んでいるか？この場合はfalse。逆にしたらtrue u.isdisjoint(t) #集合uとtの中で1つでも重複要素があるとtrue。この場合はfalseを返却する

① num = 10 ② print(type(num)) ③ num_str = str(num) #str（値）で文字列に変換 print(num_str) ④ num_list = [num_str,'20','30'] #リストの場合は[]括弧 print(num_list) ⑤ num_list.append('40') #リストに値を追加する場合はappend（値） print('num_list = {}'.format(num_litst)) ⑥ num_tuple = tuple(num_list) #タプルに変換する場合はtupel（変数） ⑦ val = input() num_tuple += num_tuple + val #タプルは+=という形でないと値を追加できない ⑧ num_set = {'40','50','60'} #セットの場合は{}を使う print('num_set = {}'.format(num_set)) ⑨ print(set(num_tupel) | | num_set) #set()で変換している ⑩ num_dict = {num_tuple:num_str} #辞書型の場合は{}括弧 ⑪ print(len(num_list)) ⑫ print(num_dict.get('MyKey','Does not exist')) ⑬ num_list.extend(['50','60']) ⑭ var = input() is_under = in(var) < 50 #標準入力に格納されるvarはstr型なのでintに変換する必要がある ⑮ print(f'format = {num_str}') ⑯ print(dir(num_dict))

① bool_var = True if bool_var: #:が付くことに注意 print('任意の文字')

① msg = 'bule' if msg == 'blue': print('中身は同じ') ② if msg == 'blue': print('中身はblue') elif msg == 'red' #elif 条件式となる print('中身はred') ③ if msg == 'blue': print('中身はblue') elif msg == 'red' #elif 条件式となる print('中身はred') else ; print('どれでもない') ④ #変数の宣言 gendar = 'man' age = 10 #andで条件を重ねる if gendar == 'man' and age = 10 #どちらかの条件はorでつなげる if gendar == 'man' or age = 10 #not 条件式 if not gendar == 'man'

① list_ronri = [true,true,true] if all(ronri): #if all(反復可能なオブジェクト)　反復可能なオブジェクトとはfor inで表現可能なオブジェクト。リストやタプル等 print('任意の文字') ② if any(ronri): print('任意の文字') #allはすべてtrue。anyは1つでもtrue

① for i in range(10): #for 変数 in range(数価）。数値はiに代入される。この場合0～9までに print(i) ② for _ in range(10): #アンダーバーを記載。アンダーバーを使う = 単にループするという意味 print('A') ③ for i in range(2,20,3) #range(a,b,c)でaは開始する数、bはここまで出力するという数、cは何個スキップするか？ print(i) ④ sample = ['john','Paul'] #リスト sample = ('john','Paul' ) #タプルの場合も使用可能 for menber in sample: print(member) ⑤ human = {'Name':'Taro','Age':20} for h in human: print(h,human.get(h))

① sample = ['a','b','c'] for index,value in enumerate(sample): #enumerate関数で配列の中の値とインデックをそれぞれ変数に格納 print(index) print(value) ② sample1 = ['a','b','c'] sample2 = ['d','e','f'] for a,b in zip(sample1,sample2) #zip関数の中で配列を指定してそれぞれのリストの中を個別に指定 ③ count = 0 for count < 10: #条件を満たす場合はループ print(count) count+=1

① for i in range(10): if i =3: continue #iが3の場合は処理がスキップされる print('任意の文字' + i) ② for i in range(10): if i =3: break#iが3の場合はforから抜ける print('任意の文字' + i)

① if(n := 10) >= 5: #nという変数の宣言をするのと同時にn>5の比較を実行している print('nは5より大きい') ② n = 0 #変数nの初期化 while(n := n+1) < 10: #本来ならwhile文の処理の最後に n +=1 と加算しなければならない。while文の中でnに加算している print(n)

for i in range(1,101): if i % 3 == 0 and i%5 == 0: print('Fizz Buzz') elif i%3 == 0: print('Fizz') elif i % 5 == 0: print('Buzz') else: print('数字のみ表示')

① try: var = 3 / 0 except Exception as e: #Exception = すべての例外 print(e,type(e)) #eはエラーの内容、typeで型を表示している pass ② try: var = 3 / 0 except Exception as e: #Exception = すべての例外 import traceback tracc.print_exc() #何行目にどんなエラーが発生したか等詳細がわかる pass

① try: var = 3 / 0 except Exception as e: print(e,type(e)) pass else: prin('任意の文字列1') #エラーない場合のみ実行　elseはあまり使われない finally: print('任意文字列2') #try終了後に実行

def devide(a,b): id(b == 0): raise ZeroDivisionError('bを0に設定しないでください') else: retrun a/b try: result = devide(10,0) #関数を呼び出した結果ZeroDivisionErrorが返ってくるはず except ZeroDivisionError as e: print(e,type(e)) #ZeroDivisionErrorが発生したためbを0に設定しないでくださいと表示されるはず

class MyException(Exception) #Exceptionクラスを継承 pass

① def print_hello(): #def 関数名(): 処理 print("Hello") print() ② dev print_hello(arg1,arg2) print(arg1) print(arg2) ③ dev print_hello(arg1 : str,arg2 : int) #別の型を与えても実行自体はできる。あくまでヒント print(arg1) print(arg2)

① dev function(arg1,arg2 = 100): #arg2に引数に指定しなければ設定しなければ100となる ② def spam(arg1,*arg2): #*が一つだと可変長のタプル print("arg1 = {},arg2 = {}".format(arg1,arg2)) spam(1,2,3,4,5) #1がarg1に格納されて、2,3,4,5がarg2に格納される ③ def spam_2(arg1,**arg2): #**が二つだと可変長の辞書型。可変長引数は基本的に1つしか宣言不可 print("arg1 = {},arg2 = {}".format(arg1,arg2)) spam_2(3,name = 'Taro',age=20) #nameとTaroは辞書として格納される ④ 可変長引数は関数内の引数の最後にする 同じ種類の可変長引数は複数並べることはできない ⑤def sample_2(): return 1,2 a,b = sample_2(): #a,bにそれぞれ1,2が入る

① def printAnimal(): global animal #gobal 変数で使うことができる animal = 'cat'

① def outer(): def innner(): print('A') inner() #関数外で呼び出すとエラー """ inner関数の用途 ・外の関数の外からアクセスできないような関数を作成 ・関数の中で同じ処理が何度も発生する場合に、一つにまとめる ・デコレータ関数を作成する """ ② def outer(): var = 'outer_sample' def innner(): nonlocal outer_sample #nonlocal + varで外側の変数を書き換えることができる outer_sample = 'inner_sample' print('A')

① dev generator(max): print('ジェネレータ作成') for n in range(max): yield n #●●の答え print('yield実行') gen = generator(10) #ジェネレータを作成、この時点では処理は実行されない n = next(gen) #ジェネレータ関数を実行（yield n の部分で実行が止まる）。print文は実行されない（yieldでとまるので） print('n={}'.format(n)) #n = 0となる n = next(gen)#ジェネレータ関数を再度実行。print文が実行される

① none #一回目のyield nには戻り値が入らない ② dev generator(max): print('ジェネレータ作成') for n in range(max): x = yield n print('x = {}'.format(x)) #xの中身を表示 print('yield実行') gen = generator(10) #ジェネレータを作成、この時点では処理は実行されない next(gen) #ジェネレータ関数を実行（yield n の部分で実行が止まる） gen.send(100) #100を送り込む ③ gen.throw(ValueError('Invalid Value')) ④ gen.close()

① 使用するメモリを節約することができる DBから大量のデータを取得するところで役に立つ ② import sys list_a = [i for i in range(100000)] def num(max): i = 0 while i < max yield i i += 1 gen = num(100000) ③ print(sys.getsizeof(list_a)) print(sys.getsizeof(gen)) #こちらの方が小さい

① #subジェネレータから呼び出されるジェネレータ dev sub_sub_generator(): yield "sub subのyield" return "sub subのreturn" #ジェネレータから呼び出されるジェネレータ dev sub_generator(): yield "subのyield" res = yield from sub_sub_generator() # yield fromでサブジェネレータの呼び出し print("sub res = {}".format(res)) retrun "subのretrun" #ジェネレータ dev generator(): yield "generatorのyield" res = yield from★★ sub_generator() print("sub res = {}".format(res)) retrun "generatorのretrun" gen = generator() print(next(gen)): #ジェネレータのyieldまで処理が進む print(next(gen)): #yield from sub_generator() が呼び出されて、sub_generatorのyieldまで処理が進む print(next(gen)): #yield from sub_sub_generator()が呼び出されて、sub_sub_generatorのyieldまで処理が進む print(next(gen)): #sub_sub_generator()のreturnが呼び出し元（sub_generator()）※直接の呼び出し元に返される。sub_generator()のresに格納される。さらに下のprint文も実行される。これがメインのジェネレータまで実行される。 print(next(gen)): #ジェネレータは処理が完了しているのでエラーとなる

def generate_enemy_hand(): while True: yield '1' yield '2' yield '3' def is_win(my_hand,enemy_hand): if my_hand == '1' and enemy_hand == '2': return True elif my_hand == '2' and enemy_hand == '3': return True elif my_hand == '3' and enemy_hand == '1': return True else return false hands_dict = { '1':'グー' '2':'チョキ' '3':パー } lose_count = 0 enemy_hands generate_enemy_hand() while True: my_hand = input('何を出しますか？ 1:グー、2:チョキ、3:パー' ) if my_hand not in ('1','2','3'): print('間違った入力です') continue enemy_hand = next(enemy_hands) print('あなたの出した手は:{},相手の出した手は:{}'.format(hands_dict.get(my_hand),hands_dict.get(enemy_hand)) if my_hand == enemy_hand: print('あいこ') elif is_win(my_hand,enemy_hand): print('あなたは勝ちました') break else lose_count += 1 if lose_count == 3: print('あなたは負けました') break else: print('あなたは負けました。再チャレンジ')

① def print_hello(): print('hello') def print_goodbye(): print('goodbye') var = ['A','B',print_hello,print_goodbye] #関数を変数化する場合は()を付けない var[2]() #:もつけない """ Pythonでは関数もオブジェクトの一つに過ぎないので変数として扱うことができる また関数を他の関数の引数として渡したり返り値として扱うこともできます 関数を引数にしたり帰り値にする関数を高階関数といいます """ ② hello world こんにちは と表示される まず、print_hello関数に引数print_worldを渡している 20行目のfuncは、print_worldなので、ここでhello、さらにprint_world関数はworldをくっつける関数なのでworldもプラスされる さらに21行目でprint_konnnichiwa関数が返却されるのでこんにちはと出力される

① x = 0 y < 10 else 1 ② lambda_a = lambda x:x*x # lambda 引数: 返り値が構文 ③ lambda_b = lambda x,y,z=5: x*y*z ④ c = lambda x,y : y if x < y else x #x<yの場合はyを返し、それ以外はxを返す

① 関数から自分の関数を呼び出すこと ② dev fin(n): if n < 3: return 1 else: return fib(n-1) + fib(n-2)

① new_list = [x for x in list_a] #変数名 = [式 for 変数 in リスト] ② new_list = [x for x in list_a if type(x) == int] #変数名 = [式 for 変数 in リスト(if条件式)] ③ list = [x for x in range(10000)] #リスト tup= tuple(x for x in range(10000)])#タプル（タプルの場合は丸括弧にしたものをtuple関数で変換） gen = (x for x in range(10000)) #ジェネレータ（ジェネレータの場合は丸括弧） set = {x for x in range(10000)}#セット（セットの場合は波かっこ）

① @関数名と関数の前につけることでデコレータ関数を利用可能 デコレータは関数オブジェクトを引数にとって引数にとった関数に実行時に変更を加えます デコレートは関数間である処理を共通に利用したい場合によく用いられる ② dev my_decorator(func) #関数を引数にとる def_wrapper(*arg,**kwargs): #呼び出し側の関数を引数にとる print('*' * 100) func(*args,**kwargs) print('*' * 100) return 1 return wrapper ③キャプチャ通り

① list a = [1,2,3] map_a = map(multiple_2,list_a) #2,4,6となる """ map(第1引数に関数、第2引数にリストとる) """ map_a = map(lambda x * x:2,list_a) ② map_man = map(lambda x : x + ',' + man.get(x),man) #第2引数のmanがループされ「キー + "," + 値（man.get(x)）」と してリストに格納される """ #map_manには name,ichiro age,18 country,japan がはいる """

① class car: """車クラス""" country = 'Japan' year = 2019 name = 'Prius' def print_name(self): #selfはインスタンス自身を示す print(self.name) ② my_car = Car() print(mycar.print_name()) #selfはインスタンス自身を示すので引数なしでもOK

① class sample_class: def __init__(self,msg): print("コンストラクタ呼び出し" + msg) """ 構文は、__init__ #アンダースコア2個 + init + アンダースコア2個 コンストラクタは必ずselfを第一引数にとる """ class_A = sample_class("任意の文字")

① 任意のインスタンスメソッドを持つクラスを作成し、関数を呼び出しなさい インスタンスメソッドは必ず引数selfをとる。selfとはインスタンス化した自分自身 class MyClass: def __init__(self,name): self.name = name def print_hello(self): #インスタンスメソッド。引数に必ずselfをとる。selfとはインスタンス化した自分自身を示す print('Hello' + self.name) AClass = MyClass('world') #インスタンス化 AClass.print_hello() #インスタンスメソッド呼び出し ② 任意のクラスメソッドを持つクラスを作成し、関数を呼び出しなさい クラスメソッドは必ず引数clsをとる。clsとはインスタンス化した自分自身 class MyClass: def __init__(self,name): self.name = name @classmethod #@classmethodを作成する def print_hello(cls): print('Hello' + cls.class_name) #引数には必ずclsをとる。clsとは自分のクラスを示す MyClass.print_hello() #クラスメソッドの呼び出し。インスタンス化は不要 ③ 任意のスタティックメソッドを持つクラスを作成し、関数を呼び出しなさい クラスメソッドはクラス変数へもインスタンス変数へもアクセスできない class MyClass: def __init__(self,name): self.name = name @staticsmethod #@staticmethodを作成する def print_hello(): print('Hello') MyClass.print_hello()

① class Human: def __init__(self, name ,age, phone_number): self.name = name self.age = age self.phone_number = phone_number def__str__(self); return 'Human' def__bool__(self,other): #bool関数の中で一致される条件を書く return (self.name = other.name) and (self.phone_number = other.phone_number) man = Human('Taro',20,'08011111111') print(man) #内部的には__str__が呼ばれる man2 = Human('Taro',20,'08011111111') print(man == man2) #Trueとなる

def __hash__(self): return hash(self.name +self.phone_number #どんな形態でハッシュ値を返却するか定義する def __bool__(self): return true if self.age >= 20 else false #条件式を定義する def __len__(self): return len(self.name) #lenで何を返却するか定義する man = Human('Taro',20,'081111111') #インスタンス化 #__hash__呼び出し print(hash('Taro')) #hash('プロパティ名')となる。setや辞書型のキーとして使用することが多い #__bool__呼び出し if man: #呼び出し時はこれがそのままboolで呼ばれる print('manはTrue') #__len__呼び出し print(len(man))

①② class Person: def __init__(self,name,age): self.name = name sell.age = age def greeting(self): print('hello {}'.format(self.name)) def say_age(self) print('{} years'.format(self.age)) class Employee(persion): def __init__(self,name,age,number) super().__init__(name,age)#super()とすることで親クラスを呼び出して、__init__で初期化します self.number = number def greeting(self): super().greeting()

① class ClassC(ClassA,ClassB) ClassA.__init__ ClassB.__init__

① クラスの再定義をするクラス（メタクラスはクラスとそのインスタンスの振る舞いを定義する機能を持ちます。） メタクラスは主にその定義でよいのかクラスを検証する際に用いられる 例えばメタクラスを継承したクラスA ② class ClassA(metaclass=ClassB) ③ print文が実行される __new__はインスタンスを作成される前に実行されるものがだから metacls：クラスのモデルが入っている name:クラスの名前 bases:継承しているクラス class_dict:クラスの持っている値、関数 __new__の中身にチェック処理を実行することでクラスの値を検証したりすることもできる

① Class ClassA(metaclass = ClassB) @abstractmethod #@abstractmethodを使用すると抽象クラスという意味 def func(self) pass #passでやる

① class ClassA: __msg = "Hello" #__（アンダースコア2つでプライベート変数にアクセス） ② taro = ClassA() print(taro._ClassA__name) #インスタンス変数._クラス名.プライベート変数でアクセスできてしまう

① Class Human: def __init__(self, name ,age): self.__name = name #__二つでプライベート変数 self.__age = age @property def name(self): #getter print('getter nameが呼ばれました') return self.__name @property def age(self): #getter print('getter ageが呼ばれました') return self.__age @name.setter def name(self,name): #setter print('setter nameが呼ばれました') return self.__name @age.setter def age(self,age): #setter print('setter ageが呼ばれました') return self.__age Human = Human('Kouichi',22) Human.name = 'Makoto' #setterが呼ばれる print(Human.name) #getterが呼び出される

① file_path = 'resource\input.csv' f = open(file_path,mode ='r' ,encoding = 'utf-8') #open(ファイルパス、モード、文字コード) line = f.read() #read()で全行読み込み print(line) ② lines = f.readlines() #1行単位で配列で読み込み print(lines) ③ line = f.readline() while line: print(line.rstrip('\n')) #改行コードを消す line = f.readline() ④ while (line := f.readline()): print(line.rstrip('\n')) ⑤ f.close() #閉じないとメモリを食う ⑥ with open(file_path,mode ='r' ,encoding = 'utf-8') as f: lines = f.readlines() #1行単位で配列で読み込み print(lines)

① file_path = 'resource\input.csv' f = open(file_path, mode ='w' ,encoding = 'utf-8' , newLine = '\n') #open(ファイルパス、モード、文字コード、改行コード) f.write('あああ\いいい') ② with open(file_path,mode ='w' ,encoding = 'utf-8',newLine = '\n') as f: f.write('あああ\いいい') #自動でクローズ ③ with open(file_path,mode ='a' ,encoding = 'utf-8',newLine = '\n') as f: #モードaで出力モード f.write('あああ\いいい') #自動でクローズ

① class WithClass(self): def__init__(self): print("init呼び出し") def_enter__(self): print("enter呼び出し") def __exit__(self,exc_type,exc_val,exc_tb): print("exit呼び出し") """ withの中の処理を実行する前にクラスの__init__と__enter__がそれぞれ呼ばれ、処理終了後にクラスの__exit__メソッド が呼ばれます withがどのような場面で必要かいうと、処理が連続していてすべての処理が必要な場合。以下となる ・ファイルへの書き込み処理（DBへコネクションを張る⇒書き込む⇒コネクションを閉じる） """ ② with WithClass() as t: print("with実行") """ __init__と__enter__が実行された後、with実行が出力され最終的に__exit__が実行される """

① # |で区切ると連結させる z = x | y z = {**x , **y} #python3.8以前 ② msg.removeprefix('Hello') >>'World' msg.removesuffix('World') >>'Hello' ③ math.gcd(12,15,24) #最大公約数（math.gcd） >>3 math.lcm(12,15,24) #最大公倍数（math.lcm） >> 120 ④ def func(arg:list[str]) -> None:

① match status: case 400: #400だったら return "Bad request" case 404: return "Not found" case 405 | 406 return "Not allowed" case _:Statusが上記処理を満たさない場合 return "Someting wrong" ② def my_function(x :int | float) -> int | float: return x**2 ③ print(isinstance(num,int | float)) #isinstance(変数,チェックしたい型 | チェックしたい型)

① raise ExceptionGroup('problems',[ #ExceptionGroupを使う。第一引数は文字列、第二引数はExceptionのリストにする VlaueError('illegal number') NmaeError('bad name') TypeError('no such type') ]) try: do_someting() except ExceptionGroup as e #ExceptionGroupをキャッチする pass ② try: do_someting() except *Valur Error as v: #*（アスタリスク） as 変数:で個別に取り出すことができる print('value error') #以下同文 ③ from typeing import Self #Selfをimport class User: #Selfを指定すると、引数と戻り値の型がUserクラスのインスタンスになる。実行時にインスタンスを指定しないとコンパイルエラーになる def copy(self:Self) -> Self: ④ from typing import LiteralString def print_msg(msg: LiteralString): print(msg)

① 全てのクラスとモジュールは1つの役割を提供して責任を持つべきとする原則 ・役割が複数ある場合何なのか複雑してしまう ・1つの役割に別の役割が複雑に依存してしまい。保守性の展開を招く

② 開放閉鎖の原則 クラス、モジュール、関数などのソフトウェア部品は拡張に対しては開いており、修正に対しては 閉じていなければならない ・アプリケーションに変更があった場合、コードを追加して修正し、容易に対応できる ・モジュールの動作を変更する場合には、ソースコードを直接修正するようなことはないようにする 【メリット】 ・機能拡張が容易になり、ソフトウェアの保守性が向上する ・機能拡張時にテストをする際に、拡張機能だけを実施すればよく、元のソースコードはテストしなくてもよいため、保守性も 向上する

③ リスコフの置換原則 サブクラスは、そのスーパークラスの代用ができなればならない func(x)という関数に対して、Tクラスのインスタンスxで実行できるなら、 TクラスのサブクラスのSのインスタンスyでも実行できなければならない 【なぜか？】 ・スーパークラスの仕様を理解すれば、それを継承したサブクラスの中身をすべて確認せずに利用 できる、拡張性、保守性が向上 ・サブクラス、スーパークラス間で実行できるものとできないものがあるとサブクラウスの コードをすべて理解する必要性が生じる

④ インターフェース※分離の原則 インターフェース上に必要のないメソッドを追加して、継承先が無駄なコードを作成することがないようにする代わりに、新しい インターフェースを作成して、クラスは必要なインターフェースを継承できるようにする ・継承するインターフェースの持つメソッドは必要最小限のものにする ・インターフェースの持つメソッドを増やしすぎることで、継承先のクラスに無駄なコードが増えてしまい、コードが複雑になり利用者が混乱する ・インターフェースの継承先が増えるため、インターフェースの修正による、継承先のクラスの修正量が多くなり、保守性が低下する ※インターフェースとはメソッドの中身を記載していない継承して利用するためのクラスのこと

⑤ 依存性逆転の原則 ソフトウェアモジュール間の依存関係を切り離すための方法 ・高水準なモジュールは低水準のモジュールに依存してはいけない。両者は抽象化に依存すべき ・抽象化は詳細に依存するべきではなく、詳細は抽象化に依存すべき

クラス、モジュール、関数などのソフトウェア部品は拡張に対しては開いており、修正に対しては 閉じていなければならない ・アプリケーションに変更があった場合、コードを追加して●●し、容易に対応できる ・モジュールの動作を変更する場合には、ソースコードを直接修正するようなことはないようにする 【メリット】 ・機能●●が容易になり、ソフトウェアの●●性が向上する ・機能●●時にテストをする際に、●●機能だけを実施すればよく、元のソースコードはテストしなくてもよいため、保守性も 向上する