-
[python]0. Pythonic code인공지능/부스트캠프 Ai Tech 2022. 1. 21. 18:31728x90
[python]0. Pythonic code In [1]:from IPython.core.display import display, HTML display(HTML("<style>.container { width:90% !important; }</style>")) #창 맞추기위함
예시 : 여러 단어들을 하나로 붙일 때
In [1]:colors = ['red', 'blue', 'green', 'yellow'] result = '' for s in colors: result += s
In [2]:result
Out[2]:'redbluegreenyellow'
Pythonic¶
In [1]:colors = ['red', 'blue', 'green', 'yellow'] result = ''.join(colors) result
Out[1]:'redbluegreenyellow'
왜 Pythonic?¶
- 남들이 많이 쓴다
- 효율적이다 : 단순 for loop append보다 빠르다.
- 멋지다.
- split & join
- list comprehension
- enumerate & zip
- lambda & map & reduce
- generator
- asterisk
split¶
string type의 값을 "기준값"으로 나눠서 List 형태로 변환
In [4]:items = 'zero one two three'.split() # 빈칸을 기준으로 문자열 나누기 print(items)
['zero', 'one', 'two', 'three']
In [1]:example = 'python, java, javascript' example.split(",")
Out[1]:['python', ' java', ' javascript']
In [7]:for content in example.split(","): print(content.strip())
python java javascript
In [2]:a,b,c = example.split(",") # 리스트에 있는 각 값을 a,b,c 변수로 unpacking
In [3]:a,b,c
Out[3]:('python', ' java', ' javascript')
JOIN¶
In [4]:colors = ['red', 'blue', 'green', 'yellow'] "-".join(colors)
Out[4]:'red-blue-green-yellow'
In [7]:" ".join(colors)
Out[7]:'red blue green yellow'
In [10]:result = [] for i in range(10): result.append(i) result
Out[10]:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Pythonic¶
In [1]:num=2 "Even" if num%2 == 0 else "Odd"
Out[1]:'Even'
In [12]:result = [i for i in range(10)] result
Out[12]:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [13]:result = [i for i in range(10) if i % 2 == 0] # for + if result
Out[13]:[0, 2, 4, 6, 8]
In [23]:["Even" if i % 2 == 0 else "Odd" for i in range(10)] # if else 문은 맨앞에
Out[23]:['Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd']
In [1]:# mxn 행렬 만들기 m = 4 n = 3 ary = [[0] * m for _ in range(n)] ary
Out[1]:[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
In [ ]:# 20x50 행렬 만들기 ary = [[0]* 20 for _ in range(50)] ary
Nested For loop¶
In [16]:word_1 = "Hello" word_2 = "World" ''' for i in word_1: for j in word_2: result.append(i+j) ''' result = [i+j for i in word_1 for j in word_2] result
Out[16]:['HW', 'Ho', 'Hr', 'Hl', 'Hd', 'eW', 'eo', 'er', 'el', 'ed', 'lW', 'lo', 'lr', 'll', 'ld', 'lW', 'lo', 'lr', 'll', 'ld', 'oW', 'oo', 'or', 'ol', 'od']
In [4]:# 리스트에서 특정 값을 가지는 원소를 모두 제거하기 a = [1, 2, 3, 4, 5, 5, 5] remove_set = {3, 5} # 집합, 존재유무만 체크할때 유용함 # remove_list에 포함되지 않은 값만을 저장 result = [i for i in a if i not in remove_set] print(result)
[1, 2, 4]
In [3]:a = [1, 2, 3, 4, 5, 5, 5] {key:value for key,value in enumerate(a)}
Out[3]:{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 5, 6: 5}
In [5]:a.count(5)
Out[5]:3
Filter¶
i와 j가 같다면 List에 추가하지 않음
In [19]:case_1 = ["A", "B", "C"] case_2 = ["D", "E", "A"] result = [i+j for i in case_1 for j in case_2] result
Out[19]:['AD', 'AE', 'AA', 'BD', 'BE', 'BA', 'CD', 'CE', 'CA']
In [20]:result = [i+j for i in case_1 for j in case_2 if not(i==j)] # if으로, i와 j가 같으면 List에 추가하지 않음 # [i+j if not(i==j) else "BEE" i for i in case_1 for j in case_2] result
Out[20]:['AD', 'AE', 'BD', 'BE', 'BA', 'CD', 'CE', 'CA']
In [21]:result.sort() result
Out[21]:['AD', 'AE', 'BA', 'BD', 'BE', 'CA', 'CD', 'CE']
Two Dimentional List¶
In [22]:words = 'The quick brown fox jumps over the lazy dog'.split()
In [24]:print(words)
['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']
In [26]:stuff = [[w.upper(), w.lower(), len(w)] for w in words] stuff
Out[26]:[['THE', 'the', 3], ['QUICK', 'quick', 5], ['BROWN', 'brown', 5], ['FOX', 'fox', 3], ['JUMPS', 'jumps', 5], ['OVER', 'over', 4], ['THE', 'the', 3], ['LAZY', 'lazy', 4], ['DOG', 'dog', 3]]
In [27]:for i in stuff: print(i)
['THE', 'the', 3] ['QUICK', 'quick', 5] ['BROWN', 'brown', 5] ['FOX', 'fox', 3] ['JUMPS', 'jumps', 5] ['OVER', 'over', 4] ['THE', 'the', 3] ['LAZY', 'lazy', 4] ['DOG', 'dog', 3]
In [28]:print(stuff)
[['THE', 'the', 3], ['QUICK', 'quick', 5], ['BROWN', 'brown', 5], ['FOX', 'fox', 3], ['JUMPS', 'jumps', 5], ['OVER', 'over', 4], ['THE', 'the', 3], ['LAZY', 'lazy', 4], ['DOG', 'dog', 3]]
In [31]:import pprint # print보다 깔끔하게 출력됨 pprint.pprint(stuff)
[['THE', 'the', 3], ['QUICK', 'quick', 5], ['BROWN', 'brown', 5], ['FOX', 'fox', 3], ['JUMPS', 'jumps', 5], ['OVER', 'over', 4], ['THE', 'the', 3], ['LAZY', 'lazy', 4], ['DOG', 'dog', 3]]
Two dimensional vs One dimensional¶
In [24]:case_1 = ["A", "B", "C"] case_2 = ["D", "E", "A"] ''' for i in case_1: for j in case_2: i+j ''' result = [i+j for i in case_1 for j in case_2] result
Out[24]:['AD', 'AE', 'AA', 'BD', 'BE', 'BA', 'CD', 'CE', 'CA']
In [25]:''' 여기서는 for j in case_2가 먼저 작동하여 for j in case_2: line = [] for i+j for i in case_1: line.append(i+j) 가 된다.''' result = [[i+j for i in case_1]for j in case_2]
In [26]:result # 2차원
Out[26]:[['AD', 'BD', 'CD'], ['AE', 'BE', 'CE'], ['AA', 'BA', 'CA']]
In [10]:[[j + i for i in case_1 if j != "C"]for j in case_2]
Out[10]:[[], ['EA', 'EB', 'EC'], ['AA', 'AB', 'AC']]
Enumerate vs zip¶
Enumerate¶
list의 element를 추출할 때 번호를 붙여서 추출
In [11]:for i,v in enumerate(['tic', 'tac', 'toe']): print(i, v)
0 tic 1 tac 2 toe
In [12]:for i,v in enumerate("ABC"): print("{0} \t {1}".format(i, v))
0 A 1 B 2 C
In [13]:my_str = "ABCD" {v : i for i , v, in enumerate(my_str)}
Out[13]:{'A': 0, 'B': 1, 'C': 2, 'D': 3}
In [14]:text = "Samsung Group is a South Korea."
In [16]:set_text = list(set(text.split()))
In [17]:{i : v.lower() for i, v in enumerate(text.split())}
Out[17]:{0: 'samsung', 1: 'group', 2: 'is', 3: 'a', 4: 'south', 5: 'korea.'}
In [18]:{i : v.lower() for i, v in enumerate(set_text)}
Out[18]:{0: 'a', 1: 'samsung', 2: 'south', 3: 'korea.', 4: 'is', 5: 'group'}
In [19]:{v.lower() : i for i, v in enumerate(set_text)}
Out[19]:{'a': 0, 'samsung': 1, 'south': 2, 'korea.': 3, 'is': 4, 'group': 5}
zip¶
두개의 list의 값을 병렬적으로 추출함
In [20]:alist = ['a1', 'a2', 'a3'] blist = ['b1', 'b2', 'b3'] for a, b in zip(alist, blist): # 병렬적으로 값을 추출 print(a,b)
a1 b1 a2 b2 a3 b3
In [23]:a,b,c = zip((1,2,3), (10,20,30), (100,200,300)) # 각 tuple의 같은 index 끼리 묶음 print("a : ", a) print("b : ", b) print("c : ", c)
a : (1, 10, 100) b : (2, 20, 200) c : (3, 30, 300)
In [24]:[sum(x) for x in zip((1,2,3),(10,20,30), (100,200,300))]
Out[24]:[111, 222, 333]
enumerate & zip¶
In [1]:alist = ["a1", "a2", "a3"] blist = ["b1", "b2", "b3"] for i, values in enumerate(zip(alist,blist)): print(i, values) # 번호와 zip tuple
0 ('a1', 'b1') 1 ('a2', 'b2') 2 ('a3', 'b3')
In [5]:list(enumerate(zip(alist,blist)))
Out[5]:[(0, ('a1', 'b1')), (1, ('a2', 'b2')), (2, ('a3', 'b3'))]
lambda & map & reduce¶
lambda¶
함수 이름 없이, 함수처럼 쓸 수 있는 익명 함수
- 테스트가 어렵다, 코드 해석도 어렵다.. 하지만 많이쓴다.
In [6]:#Gemeral function def f(x, y): return x + y print(f(1, 4))
5
In [7]:#Lambda function = lambda 매개변수 : return이 되는 값 f = lambda x, y: x + y print(f(1,4))
5
In [10]:(lambda x, y: x + y)(10, 50) # 바로 뒤에 붙여주면 삽입됨
Out[10]:60
In [8]:up_low = lambda x : x.upper() + x.lower()
In [9]:up_low("My Happy")
Out[9]:'MY HAPPYmy happy'
In [11]:join_split = lambda x : "-".join(x.split())
In [12]:join_split("My Happy")
Out[12]:'My-Happy'
In [16]:array = [('홍길동', 50),('이순신', 32), ('아무개', 74)] def my_key(x): return x[1] print(sorted(array, key=my_key)) print(sorted(array, key=lambda x: x[1]))
[('이순신', 32), ('홍길동', 50), ('아무개', 74)] [('이순신', 32), ('홍길동', 50), ('아무개', 74)]
In [17]:list1 = [1,2,3,4,5] list2 = [6,7,8,9,10] result = map(lambda a, b: a+b, list1, list2) print(list(result))
[7, 9, 11, 13, 15]
Map¶
두개 이상의 list에도 적용 가능함, if도 사용가능
python3는 iteration을 생성 -> list를 붙여줘야 list 사용가능!!
실행시점의 값을 생성, 메모리관리 효율적
In [16]:def f(X): return X + 5 list(map(f,ex))
Out[16]:[6, 7, 8, 9, 10]
In [21]:[value + 5 for value in ex]
Out[21]:[6, 7, 8, 9, 10]
In [19]:map(f,ex) # list를 붙여줘야 가능
Out[19]:<map at 0x24522d43bc8>
In [23]:ex = [1,2,3,4,5] f = lambda x: x**2 list(map(f, ex))
Out[23]:[1, 4, 9, 16, 25]
In [25]:[f(value) for value in ex] # 그러나 map보다 이게 더 간단하다.
Out[25]:[1, 4, 9, 16, 25]
In [17]:a,b = map(int, input().split())
54 3
In [18]:f = lambda x, y : x + y list(map(f, ex, ex)) # 두개 이상의 list도 가능
Out[18]:[2, 4, 6, 8, 10]
In [26]:[value**2 if value%2 ==0 else value for value in ex]
Out[26]:[1, 4, 3, 16, 5]
In [28]:from functools import reduce ''' [1,2,3,4,5] 리스트를 순차적으로 돌면서 함수를 적용 ''' print(reduce(lambda x, y: x+y, [1,2,3,4,5]))
15
In [29]:for city in ["Seoul", "Busan", "Pohang"]: print(city, end="\t")
Seoul Busan Pohang
In [31]:# 내부적 구현으로 __iter__와 __next__ 가 사용됨 # iter()와 next() 함수로 iterable 객체를 iterator objet로 사용 cities = ["Seoul", "Busan", "Jeju"] iter_obj = iter(cities) print(next(iter_obj)) print(next(iter_obj)) print(next(iter_obj)) next(iter_obj)
Seoul Busan Jeju
--------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-31-90b0843a2ec2> in <module> 8 print(next(iter_obj)) 9 print(next(iter_obj)) ---> 10 next(iter_obj) StopIteration:
In [32]:iter(cities) # 메모리 위치들에 대한 다음 정보를 가지고 있음 # linked-list와 유사
Out[32]:<list_iterator at 0x245222e6fc8>
In [34]:memory_address_cities = iter(cities) memory_address_cities
Out[34]:<list_iterator at 0x245212e1cc8>
In [35]:next(memory_address_cities) # 메모리 주소를 next로 내용물을 꺼냄
Out[35]:'Seoul'
In [36]:next(memory_address_cities)
Out[36]:'Busan'
In [37]:next(memory_address_cities)
Out[37]:'Jeju'
generator¶
iterable object를 특수한 형태로 사용해주는 함수
- element가 사용되는 시점에 값을 메모리에 반환
- yield를 사용해 한번에 하나의 element만 반환함, 메모리 공간 절약
In [38]:def general_list(value): result = [] for i in range(value): result.append(i) return result
In [41]:general_list(10)
Out[41]:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [42]:import sys result = general_list(50) sys.getsizeof(result)
Out[42]:528
In [39]:def genrator_list(value): result = [] for i in range(value): yield i # 메모리의 주소값만 가지고 있다가 사용될때 출력
In [43]:genrator_list(50) # genrator_list의 형태, 메모리의 주소 값만 가진 상태
Out[43]:<generator object genrator_list at 0x000002452278B148>
In [ ]:for a in genrator_list(50): # 이제 출력 해주세요~ 할때 불러온다. print(a)
In [45]:result = genrator_list(50) sys.getsizeof(result) # 일반적인 메소드와 비교해서 메모리를 적게 차지함
Out[45]:120
In [ ]:list(genrator_list(50))
In [46]:sys.getsizeof(list(genrator_list(50))) # list로 바로 불러와도 메모리를 적게먹음
Out[46]:472
genrator comprehension¶
genrator 형태의 list를 생성, list_comprehension과 유사
- generator expression 이라는 이름으로도 부름
- [] 대신 () 를 사용하여 표현
In [50]:gex_ex = (n*n for n in range(500)) # list의 [] 대신 () print(type(gex_ex))
<class 'generator'>
In [53]:for x in gex_ex: # genrator 사용 print(x)
In [ ]:list(gex_ex)
왜? 언제? generators를 쓸까.¶
메모리 용량을 아껴야 할때!
When generator¶
- list 타입의 데이터를 반환해주는 함수는 generator로 만들어라!
- 읽기 쉬운 장점, 중간 과정에서 loop 가 중단될 수 있을때!
- 큰 데이터를 처리할 때는 generator expression을 고려하라!
- 데이터가 커도 처리의 어려움이 없다.
- 파일 데이터를 처리할 때도 generator를 쓰자.
function passing arguments¶
함수에 입력되는 arguments의 다양한 형태
1) Keyword arguments
2) Default arguments
3) Variable-length arguments(가변인자)
Keyword arguments¶
함수에 입력되는 parameter의 변수명을 사용, arguments를 넘김
In [54]:def print_somthing(my_name, your_name): print("Hello {0}, My name is {1}".format(your_name, my_name)) print_somthing("Lee", "C")
Hello C, My name is Lee
In [56]:print_somthing(your_name = "Lee", my_name = "C") # Keyword
Hello Lee, My name is C
default arguments¶
parameter에 기본값을 미리 입력해서 입력안해도 사용가능
In [58]:def print_somthing_2(my_name, your_name="C"): print("Hello {0}, My name is {1}".format(your_name, my_name)) print_somthing_2("lee")
Hello C, My name is lee
variable-length¶
함수의 parameter 수가 정해져 있지 않을때 variable-length(가변인자)를 사용한다.
- Asterisk(*) 기호를 사용하여 함수의 parameter를 표시
- 입력된 값은 tuple type으로 사용할 수 있음
- 가변인자는 일반적으로 *args를 변수명으로 사용
- 기존 parameter 이후에 나오는 값을 tuple로 저장함
In [1]:def asterisk_test(a, b, *args): print("args : ", list(args)) print("type of args : ", type(args)) return a+b+sum(args) print(asterisk_test(1,2,3,4,5))
args : [3, 4, 5] type of args : <class 'tuple'> 15
Keyword variable-length¶
parameter 이름을 따로 지정하지 않고 입력하는 방법
- asterisk(*) 두개를 사용하여 함수의 parameter를 표시함
- 입력된 값은 dict type으로 사용할 수 있음
- 가변인자는 오직 한개만 기존 가변인자 다음에 사용
In [62]:def kwargs_test_1(**kwargs): print(kwargs) kwargs_test_1(first=3, second=4, third=5)
{'first': 3, 'second': 4, 'third': 5}
In [65]:def kwargs_test_2(**kwrags): print(kwrags) print("First value is {first}".format(**kwrags)) print("Second value is {second}".format(**kwrags)) print("Third value is {third}".format(**kwrags)) kwargs_test_2(first=3, second=4, third=5)
{'first': 3, 'second': 4, 'third': 5} First value is 3 Second value is 4 Third value is 5
In [67]:# 키워드 가변인자 예제 def kwargs_test_3(one, two, *args, **kwargs): print(one+two+sum(args)) print(args) print(kwargs) kwargs_test_3(3,4,5,6,7,8,9, first=3, second=4, third=5)
42 (5, 6, 7, 8, 9) {'first': 3, 'second': 4, 'third': 5}
In [68]:def asterisk_test(a, *args): print(a, args) print(type(args)) asterisk_test(1, *(2,3,4,5,6))
1 (2, 3, 4, 5, 6) <class 'tuple'>
In [69]:def asterisk_test(a, *args): print(a, args) print(type(args)) asterisk_test(1, (2,3,4,5,6))
1 ((2, 3, 4, 5, 6),) <class 'tuple'>
In [70]:print("1", "2", "3", "4") print(["1", "2", "3", "4"]) # list 한개가 들어감 print(*["1", "2", "3", "4"])
1 2 3 4 ['1', '2', '3', '4'] 1 2 3 4
In [75]:a,b,c = ([1,2], [3,4], [5,6]) print(a,b,c) data = ([1,2], [3,4], [5,6]) print(data) print(*data)
[1, 2] [3, 4] [5, 6] ([1, 2], [3, 4], [5, 6]) [1, 2] [3, 4] [5, 6]
In [77]:def asterisk_test(a, b, c, d): print(a, b, c, d) data = {"b":1, "c":2, "d":3} asterisk_test(10, **data) # dict 형을 풀어줌
10 1 2 3
with zip¶
In [3]:ex = ([1,2], [3,4], [5,6], [5,6], [5,6]) ex # tuple로 묶여있어 한개의 값만 갖는다.
Out[3]:([1, 2], [3, 4], [5, 6], [5, 6], [5, 6])
In [4]:for value in zip(ex): print(value)
([1, 2],) ([3, 4],) ([5, 6],) ([5, 6],) ([5, 6],)
In [5]:for value in zip(*ex): print(value)
(1, 3, 5, 5, 5) (2, 4, 6, 6, 6)
In [82]:for value in zip(*ex): print(sum(value))
19 24
In [85]:ex = ([1,2], [3,4], [5,6]) a,b,c = ex for value in zip(a,b,c): print(value) for value in zip(*ex): print("unpacking : " ,value)
(1, 3, 5) (2, 4, 6) unpacking : (1, 3, 5) unpacking : (2, 4, 6)
In [9]:a = [1,2,6,4,2] a.reverse()
In [11]:a.sort(reverse=True)
In [13]:print(a)
[6, 4, 2, 2, 1]
빠르게 입력 받기¶
input() 함수보다 더 빠르게 입력받는 방법
- 파이썬은 sys.stdin.readline() 메서드를 사용
- 단, 입력 후 엔터가 줄 바꿈 기호로 입력되어 rstrip() 메서드와 함께 사용
In [14]:import sys data = sys.stdin.readline().rstrip() print(data)
In [15]:answer = 7 print(f"정답은 {answer}입니다.")
정답은 7입니다.
내장함수¶
In [19]:# eval() : 사람의 입장에서 정의된 수식을 계산해서 보여줌 result = eval("(3+5)*7") print(result)
56
In [20]:# sorted() result = sorted([9, 1, 8, 5, 4]) reverse_result = sorted([9, 1, 8, 5, 4], reverse=True) print(result) print(reverse_result)
[1, 4, 5, 8, 9] [9, 8, 5, 4, 1]
In [22]:# sorted() with key : key 속성으로 정렬 기준을 정할 수 있다. array = [('홍길동', 50),('이순신', 32), ('아무개', 74)] print(sorted(array, key=lambda x: x[1], reverse=True)) # 두번째 값인 숫자를 통해서 정렬
[('아무개', 74), ('홍길동', 50), ('이순신', 32)]
순열과 조합¶
In [23]:from itertools import permutations data = ['A', 'B', 'C'] # 데이터 준비 result = list(permutations(data, 3)) # 모든 순열 구하기 print(result)
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]
In [24]:from itertools import combinations data = ['A', 'B', 'C'] # 데이터 준비 result = list(combinations(data, 2)) # 2개를 뽑는 조합 구하기 print(result)
[('A', 'B'), ('A', 'C'), ('B', 'C')]
In [25]:from itertools import product data = ['A', 'B', 'C'] # 데이터 준비 result = list(product(data, repeat=2)) # 2개를 뽑는 모든 순열 구하기(중복 허용) print(result)
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
In [26]:from itertools import combinations_with_replacement data = ['A', 'B', 'C'] # 데이터 준비 result = list(combinations_with_replacement(data, 2)) # 2개를 뽑는 모든 조합 구하기(중복 허용) print(result)
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]
Counter¶
파이썬 collections 라이브러리의 Counter는 등장 횟수를 세는 기능을 제공
- 리스트와 같은 반복가능한 객체가 주어졌을 때 내부의 원소가 몇 번씩 등장했는지를 알려준다.
In [27]:from collections import Counter counter = Counter(['red', 'blue', 'red', 'green', ' blue', 'blue']) print(counter['blue']) # 'blue' 가 등장한 횟수 출력 print(counter['green']) print(dict(counter)) # 사전 자료형으로 반환
2 1 {'red': 2, 'blue': 2, 'green': 1, ' blue': 1}
In [29]:# Dict 형끼리는 사칙연산이 가능하다. participants = ["mislav", "stanko", "mislav", "ana"] completions = ["stanko", "ana", "mislav"] participants = Counter(participants) completions = Counter(completions) list(participants - completions)
Out[29]:['mislav']
최대 공약수와 최소 공배수¶
최대 공약수를 구할때는 math의 gcd() 함수를 이용
In [28]:import math # 최소 공배수(LCM)를 구하는 함수 def lcm(a, b): return a * b // math.gcd(a, b) a = 21 b = 14 print(math.gcd(21, 14)) # 최대 공약수(GCD) 계산 print(lcm(21,14)) # 최소 공배수 계산
7 42
In [ ]:from math import sqrt
In [ ]:'인공지능 > 부스트캠프 Ai Tech' 카테고리의 다른 글
[python]5. Numpy (0) 2022.01.21 [python]4. Python Data Handling (0) 2022.01.21 [python]3. Exception_File_LogHandling (0) 2022.01.21 [python]2. Module and Project (0) 2022.01.21 [python]1. Objects_in_Python (0) 2022.01.21