Python
파이썬 기초와 Ipython, jupyter notebook
haventmetyou
2023. 10. 31. 17:42
C:\Users\Desktop\project\basic>python hello.py
hello.py
__main__
C:\Users\Desktop\project\basic>ipython
In [1]: %run hello.py
hello.py
__main__
In [2]: an_apple = 27
In [3]: an_example = 42an 입력하고 tap 키 누르면 자동 완성 기능 제공
자기관찰(인트로스펙션 introspection)
In [3]: b = [1, 2, 3]
In [4]: b?
Type: list
String form: [1, 2, 3]
Length: 3
Docstring:
Built-in mutable sequence.
If no argument is given, the constructor creates a new empty list.
The argument must be an iterable if specified.
In [5]: print?
Signature: print(*args, sep=' ', end='\n', file=None, flush=False)
Docstring:
Prints the values to a stream, or to sys.stdout by default.
sep
string inserted between values, default a space.
end
string appended after the last value, default a newline.
file
a file-like object (stream); defaults to the current sys.stdout.
flush
whether to forcibly flush the stream.
Type: builtin_function_or_method변수 이름 앞이나 뒤에 물음표를 붙이면 그 객체에 대한 일반 정보 출력
In [7]: def add_numbers(a, b):
...: """
...: Add two numbers together
...: Returns
...: ------
...: the sumL type of arguments
...: """
...: return a + b
...:
In [8]: add_numbers?
Signature: add_numbers(a, b)
Docstring:
Add two numbers together
Returns
------
the sumL type of arguments
File: c:\users\desktop\project\basic\<ipython-input-7-004085b61198>
Type: function
별표(*)로 문자열을 둘러싸게 되면 해당 문자열이 포함된 모든 이름을 보여 줌
In [9]: import numpy as np
In [10]: np.*load*?
np.__loader__
np.load
np.loadtxt
In [11]: a = b
In [12]: a.append(4)
In [13]: a
Out[13]: [1, 2, 3, 4]
In [14]: b
Out[14]: [1, 2, 3, 4]변수에 값을 할당하는 것은 한 이름이 하나의 객체로 연결되므로 바인딩이라고 부름
값이 할당된 변수 이름은 때때로 종속 변수라고 부르기도 함
In [15]: def append_element(some_list, element):
...: some_list.append(element)
...:
In [16]: data = [1, 2, 3]
In [17]: append_element(data, 4)
In [18]: data
Out[18]: [1, 2, 3, 4]
In [23]: a = 4.5
In [24]: b = 2
In [25]: # 문자열 출력 형식을 지정한다. 나중에 자세히 살펴본다
In [26]: print('a is {}, b is {}'.format(type(a), type(b)))
a is <class 'float'>, b is <class 'int'>
모듈 import
C:\Users\Desktop\project\basic>copy con some_module.py
# some_module.py
PI = 3.14159
def f(x):
return x + 2
def g(a, b):
return a + b
^Z # 코드 입력 후 ctrl + Z
1개 파일이 복사되었습니다.In [2]: import some_module
In [3]: result = some_module.f(5)
In [4]:
In [4]: pi = some_module.PI
In [5]: pi
Out[5]: 3.14159
In [6]: # 또는
In [7]: from some_module import g, PI
In [8]: result = g(5, PI)
In [9]: result
Out[9]: 8.14159
문자열
In [33]: animals = '''
...: cat
...: dog
...: fish
...: '''
In [34]: animals
Out[34]: '\ncat\ndog\nfish\n'
In [35]: animals.count('\n')
Out[35]: 4
In [36]: a = 'this is a string'
In [37]: a[10] = 'f'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[37], line 1
----> 1 a[10] = 'f'
TypeError: 'str' object does not support item assignment파이썬의 문자열은 변경이 불가능
> replace 같은 메서드를 사용해 변경된 새로운 문자열을 생성해야 함
In [38]: b = a.replace('string', 'longer string')
In [39]: b
Out[39]: 'this is a longer string'
In [40]: a
Out[40]: 'this is a string'작업 이후 변수 a는 변경되지 않음
역슬래시(\)는 이스케이프 문자로 개행 문자 \n이나 유니코드 문자 같은 특수한 목적의 문자를 나타내기 위해 사용
역슬래시를 나타내려면 역슬래시 자체를 이스케이프해야 함
In [54]: s = '12\34'
In [55]: s
Out[55]: '12\x1c'
In [56]: s = '12\\34'
In [57]: s
Out[57]: '12\\34'
특수 문자 없이 역슬래시가 많이 포함된 문자열 나타낼 때, 혹은 특수문자를 그대로 나타내도록 할 때
In [52]: s = r'this\has\no\special\characters'
In [53]: s
Out[53]: 'this\\has\\no\\special\\characters'코드 앞에 r을 붙임
In [58]: template = '{0:.2f} {1:s} are worth US${2:d}'{0:.2f}는 첫 번째 인수를 소수점 아래 두 자리까지만 표시하는 부동소수점 형태로 출력하라는 의미
{1:s}는 두 번째 인수를 문자열로 포맷하라는 의미
{2:d}는 세 번째 인수를 정수로 포맷하라는 의미
In [59]: template.format(88.46, 'Argentine Pesos', 1)
Out[59]: '88.46 Argentine Pesos are worth US$1'포맷 매개변수를 통해 대치하고 싶은 인수를 format 메서드에 전달
파이썬 3.6부터 문자열 포맷을 편리하게 지정할 수 있는 f-string 기능 추가됨
f-string을 만들려면 문자열을 감싸는 따옴표 앞에 f를 붙이면 됨
In [60]: amount = 10
In [61]: rate = 88.46
In [62]: currency = 'Pesos'
In [63]: result = f'{amount} {currency} is worth US${amount / rate}'
In [64]: f'{amount} {currency} is worth US${amount / rate:.2f}'
Out[64]: '10 Pesos is worth US$0.11'
위 문자열 템플릿과 같은 방법으로 각 표현식 뒤에 포맷 지정 가능
정렬
In [34]: a = [7, 2, 5, 1, 3]
In [35]: a.sort()
In [36]: a
Out[36]: [1, 2, 3, 5, 7]
In [37]: b = ['saw', 'small', 'He', 'foxes', 'six']
In [38]: b.sort(key=len)
In [39]: b
Out[39]: ['He', 'saw', 'six', 'small', 'foxes']sort는 몇 가지 옵션을 제공하는데 그중 하나는 사용할 값을 반환하는 함수
슬라이싱
# 원하는 크기만큼 자르기
In [40]: seq = [7, 2, 3, 7, 5, 6, 0, 1]
In [41]: seq[1:5]
Out[41]: [2, 3, 7, 5]
# 다른 순차 자료형을 대입할 수 O
In [42]: seq[3:5] = [6, 3]
In [43]: seq
Out[43]: [7, 2, 3, 6, 3, 6, 0, 1]색인의 시작(start) 위치에 있는 값은 포함, 끝(stop)은 포함 x
슬라이싱 결과의 개수는 stop - start
In [44]: seq[-4:]
Out[44]: [3, 6, 0, 1]
In [45]: seq[-6:-2]
Out[45]: [3, 6, 3, 6]음수 색인은 순차 자료형의 끝에서부터 위치를 나타냄
In [46]: seq[::2]
Out[46]: [7, 3, 3, 0]
In [47]: seq[::-1]
Out[47]: [1, 0, 6, 3, 6, 3, 2, 7]두 번째 콜론 다음에 간격(step) 지정할 수 있음
값으로 -1을 사용하면 리스트나 튜플을 역순으로 반환
딕셔너리
In [49]: empty_dict = {}
In [50]: d1 = {'a': 'some value', 'b': [1, 2, 3, 4]}
In [51]: d1
Out[51]: {'a': 'some value', 'b': [1, 2, 3, 4]}
In [52]: d1[7] = 'an integer'
In [53]: d1
Out[53]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}
In [54]: d1['b']
Out[54]: [1, 2, 3, 4]
In [55]: 'b' in d1
Out[55]: True
In [56]: d1[[10, 20]] = [100, 200]
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[56], line 1
----> 1 d1[[10, 20]] = [100, 200]
TypeError: unhashable type: 'list'다른 프로그래밍 언어에서는 해시 맵 또는 연관 배열(associative array)로 알려져 있음 키-값 쌍을 저장
리스트는 키로 사용할 수 없음
del 예약어나 pop 메서드(값을 반환함과 동시에 해당 키 삭제)를 통해 딕셔너리 값을 삭제할 수 있
In [57]: d1[5] = 'some value'
In [58]: d1
Out[58]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer', 5: 'some value'}
In [59]: d1['dummy'] = 'another value'
In [60]: d1
Out[60]:
{'a': 'some value',
'b': [1, 2, 3, 4],
7: 'an integer',
5: 'some value',
'dummy': 'another value'}
In [61]: del d1[5]
In [62]: d1
Out[62]:
{'a': 'some value',
'b': [1, 2, 3, 4],
7: 'an integer',
'dummy': 'another value'}
In [63]: ret = d1.pop('dummy')
In [64]: ret
Out[64]: 'another value'
In [65]: d1
Out[65]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}
keys와 values 메서드는 각각 키와 값이 담긴 이터레이터 반환, 키의 순서는 삽입 순서에 따라 다름
이러한 함수는 키와 값을 각각 동일한 순서로 출력
In [66]: list(d1.keys())
Out[66]: ['a', 'b', 7]
In [67]: list(d1.values())
Out[67]: ['some value', [1, 2, 3, 4], 'an integer']
키와 값에 대해 반복 작업을 해야 하는 경우 items 메서드를 사용하면 키-값 쌍을 갖는 튜플로 사용할 수 있음
In [68]: list(d1.items())
Out[68]: [('a', 'some value'), ('b', [1, 2, 3, 4]), (7, 'an integer')]
update 메서드를 사용하면 하나의 딕셔너리를 다른 딕셔너리와 합칠 수 있음
In [69]: d1.update({'b': 'foo', 'c': 12})
In [70]: d1
Out[70]: {'a': 'some value', 'b': 'foo', 7: 'an integer', 'c': 12}이미 존재하는 키에 대해 update를 호출하면 이전 값은 사라짐
순차 자료형에서 딕셔너리 생성
In [71]: tuples = zip(range(5), reversed(range(5)))
In [72]: tuples
Out[72]: <zip at 0x2287a0e2780>
In [73]: mapping = dict(tuples)
In [74]: mapping
Out[74]: {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}본질적으로 딕셔너리는 두 개짜리 튜플로 구성됨
dict 함수가 두 개짜리 튜플의 리스트를 인수로 받아 딕셔너리를 생성
(딕셔너리가 만들어지는 과정)
기본값
In [75]: words = ['apple', 'bat', 'bar', 'atom', 'book']
In [76]: by_letter = {}
In [77]: for word in words:
...: letter = word[0]
...: if letter not in by_letter:
...: by_letter[letter] = [word]
...: else:
...: by_letter[letter].append(word)
...:
In [78]: by_letter
Out[78]: {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}setdefault 메서드 사용 목적
In [79]: by_letter = {}
In [80]: for word in words:
...: letter = word[0]
...: by_letter.setdefault(letter, []).append(word)
...:
In [81]: by_letter
Out[81]: {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}내장 collections 모듈에는 위 과정을 좀 더 쉽게 만드는 defaultdict 클래스가 있음
자료형 혹은 딕셔너리의 각 슬롯에 담길 기본값을 생성하는 함수를 넘겨 딕셔너리 생성
In [85]: from collections import defaultdict
In [86]: for word in words:
...: by_letter[word[0]].append(word)
...:
In [87]: by_letter
Out[87]: defaultdict(list, {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']})In [91]: keys = ['a', 'b', 'c', 'd']
In [92]: x = dict.fromkeys(keys, 0)
In [93]: x
Out[93]: {'a': 0, 'b': 0, 'c': 0, 'd': 0}
In [94]: x['z']
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
Cell In[94], line 1
----> 1 x['z']
KeyError: 'z'
In [95]: from collections import defaultdict
In [96]: y = defaultdict(int)
In [97]: y['z']
Out[97]: 0
In [98]: int()
Out[98]: 0
In [99]: z = defaultdict(lambda: 'python')
In [100]: z['a']
Out[100]: 'python'
In [101]: z[0]
Out[101]: 'python'
유효한 딕셔너리 키
딕셔너리의 값으로는 어떤 파이썬 객체든 가능하지만 키는 스칼라 자료형(정수, 실수, 문자열)이나 튜플(튜플에 저장된 값 또한 바뀌지 않는 객체여야 함)처럼 값이 바뀌지 않는 객체만 가능
기술적으로는 해시가 가능(hashability)해야 함, 어떤 객체가 해시가 가능한지는(딕셔너리의 키로 사용할 수 있는지) hash 함수를 사용해 검사할 수 있음
In [103]: hash('string')
Out[103]: -3594434936365532107
In [104]: hash((1, 2, (2, 3)))
Out[104]: -9209053662355515447
In [105]: hash((1, 2, [2, 3]))
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[105], line 1
----> 1 hash((1, 2, [2, 3]))
TypeError: unhashable type: 'list'비가역으로 해시 > 원래 넣었던 객체는 불가능, 길이는 모두 같음
집합
# 집합
In [106]: set([2, 2, 2, 1, 3, 3])
Out[106]: {1, 2, 3}
In [107]: a = {1, 2, 3, 4, 5}
In [108]: b = {3, 4, 5, 6, 7, 8}
# 합집합
In [109]: a.union(b)
Out[109]: {1, 2, 3, 4, 5, 6, 7, 8}
In [110]: a|b
Out[110]: {1, 2, 3, 4, 5, 6, 7, 8}
# 교집합
In [111]: a.intersection(b)
Out[111]: {3, 4, 5}
In [112]: a & b
Out[112]: {3, 4, 5}
# 부분집합, 상위집합
In [113]: a_set = {1, 2, 3, 4, 5}
In [114]: {1, 2, 3}.issubset(a_set)
Out[114]: True
In [115]: a_set.issuperset({1, 2, 3})
Out[115]: True
# 집합의 내용이 같다면 두 집합은 동일(순서가 없기 때문)
# 리스트나 튜플은 False
In [116]: {1, 2, 3} == {3, 2, 1}
Out[116]: True딕셔너리도 순서가 없기 때문에 셸 창에 {1: 'cat', 2: 'dog'} == {2: 'dog', 1: 'cat'} 입력했을 때 True 출력
내장 순차 자료형 함수
1. enumerate
순차 자료형에서 현재 아이템의 index를 함께 추적할 때 사용
In [117]: a = [38, 21, 53, 62, 19]
In [118]: for i, v in enumerate(a):
...: print(i, v)
...:
0 38
1 21
2 53
3 62
4 19
2. sorted
정렬된 새로운 순차 자료형 반환
In [119]: sorted([7, 1, 2, 6, 0, 3, 2])
Out[119]: [0, 1, 2, 2, 3, 6, 7]
In [120]: sorted('horse race')
Out[120]: [' ', 'a', 'c', 'e', 'e', 'h', 'o', 'r', 'r', 's']
In [194]: a = [7, 1, 2, 6, 0, 3, 2]
In [195]: sorted(a)
Out[195]: [0, 1, 2, 2, 3, 6, 7]
In [196]: a
Out[196]: [7, 1, 2, 6, 0, 3, 2]
In [197]: a.sort()
In [198]: a
Out[198]: [0, 1, 2, 2, 3, 6, 7]
3. zip
여러 개의 리스트나 튜플 또는 다른 순차 자료형을 서로 짝지어 튜플 리스트 생성
In [126]: seq1 = ['foo', 'bar', 'baz']
In [127]: seq2 = ['one', 'two', 'three']
In [128]: zipped = zip(seq1, seq2)
In [129]: list(zipped)
Out[129]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]
In [130]: seq3 = [False, True]
In [131]: list(zip(seq1, seq2, seq3))
Out[131]: [('foo', 'one', False), ('bar', 'two', True)]
In [132]: for index, (a, b) in enumerate(zip(seq1, seq2)):
...: print(f'{index}: {a}, {b}')
...:
0: foo, one
1: bar, two
2: baz, three
In [133]: a
Out[133]: 'baz'
In [134]: b
Out[134]: 'three'
리스트, 집합, 딕셔너리 표기
리스트 표기법
In [135]: strings = ['a', 'as', 'bat', 'car', 'dove', 'python']
In [136]: [x.upper() for x in strings if len(x) > 2]
Out[136]: ['BAT', 'CAR', 'DOVE', 'PYTHON']필터 조건 생략 가능, 문자열 리스트가 있다면 위 코드처럼 문자열의 길이가 2 이하인 문자열은 제외하고 나머지를 대문자로 변환 가능
집합과 딕셔너리도 동일한 방식 적용 가능
리스트 내 문자열들의 길이를 담고 있는 집합을 생성하려면 집합 표기법을 이용해 다음과 같이 처리
In [141]: unique_lengths = {len(x) for x in strings}
In [142]: unique_lengths
Out[142]: {1, 2, 3, 4, 6}
map 함수를 이용해 함수적으로도 표현 가능
In [143]: set(map(len, strings))
Out[143]: {1, 2, 3, 4, 6}
딕셔너리 표기법 예제: 리스트에서 문자열의 위치를 담고 있는 딕셔너리 생성
In [144]: loc_mapping = {value: index for index, value in enumerate(strings)}
In [145]: loc_mapping
Out[145]: {'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5}
중첩된 리스트 표기법
각 이름에서 알파벳 a가 두 개 이상 포함된 이름의 리스트 구한다고 했을 때 다음과 같은 반복문으로 리스트를 구할 수 있음
In [146]: all_data = [['John', 'Emily', 'Michael', 'Mary', 'Stevev'], ['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]
In [147]: names_of_interest = []
In [148]: for names in all_data:
...: enough_as = [name for name in names if name.count('a') >= 2]
...: names_of_interest.extend(enough_as)
...:
In [149]: names_of_interest
Out[149]: ['Maria', 'Natalia']
위 코드 전체를 중첩된 리스트 표기법을 이용해 한 번에 구현할 수 있음
In [151]: result = [name for names in all_data for name in names
...: if name.count('a') >= 2]
In [152]:
In [152]: result
Out[152]: ['Maria', 'Natalia']
리스트 표기법에서 for 부분은 중첩의 순서에 따라 나열되며 필터 조건은 끝에 위치함
숫자 튜플이 담긴 리스트를 단순한 리스트로 변환하는 예제
In [153]: some_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
In [154]: flattened = [x for tup in some_tuples for x in tup]
In [155]: flattened
Out[155]: [1, 2, 3, 4, 5, 6, 7, 8, 9]
함수
In [157]: def my_function(x, y):
...: return x + y
...:
In [158]: my_function(1, 2)
Out[158]: 3
In [159]: result = my_function(1, 2)
In [160]: result
Out[160]: 3
함수 블록이 끝날 때까지 return 문이 없다면 자동으로 None이 반환됨
In [161]: def function_without_return(x):
...: print(x)
...:
In [162]: result = function_without_return('hello!')
hello!
In [163]: print(result)
None각 함수는 여러 개의 위치 인수와 키워드 인수를 받을 수 있음
키워드 인수는 기본값이나 선택적인 인수로 흔히 사용됨
In [164]: def my_function2(x, y, z=1.5):
...: if z > 1:
...: return z * (x + y)
...: else:
...: return z / (x + y)
...:
In [165]: my_function2(5, 6, z=0.7)
Out[165]: 0.06363636363636363
In [166]: my_function2(3.14, 7, z=3.5)
Out[166]: 35.49
In [167]: my_function2(10, 20)
Out[167]: 45.0키워드 인수는 선택 사항이지만 함수를 호출할 때 위치 인수는 반드시 지정해야 함
함수의 키워드 인수는 항상 위치 인수 다음에 와야 한다는 규칙이 있음
네임스페이스, 스코프, 지역함수
함수는 전역(global)과 지역(local), 두 가지 스코프(scope)에서 변수를 참조
변수의 스코프를 설명하는 다른 용어로 네임스페이스가 있음, 함수에서 선언된 변수는 기본적으로 모두 지역 네임스페이스에 속함
In [168]: def func():
...: a = []
...: for i in range(5):
...: a.append(i)
...:
In [169]: def func():
...: a = []
...: for i in range(5):
...: a.append(i)
...: print(a)
...:
In [170]: func()
[0, 1, 2, 3, 4]
In [171]: print(a)
baz
In [172]: a = []
In [173]: def func():
...: for i in range(5):
...: a.append(i)
...:
In [174]: func()
In [175]: a
Out[175]: [0, 1, 2, 3, 4]
In [176]: func()
In [177]: a
Out[177]: [0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
In [178]: a = None
In [179]: def bind_a_variable():
...: global a
...: a = []
...: bind_a_variable()
In [180]:
In [180]: print(a)
[]
In [181]: print(a.append('apple'))
None
In [182]: a
Out[182]: ['apple']global 예약어의 사용은 권장되지 않음
여러 값 반환
In [183]: def f():
...: a = 5
...: b = 6
...: c = 7
...: return a, b, c
...:
In [184]: a, b, c = f()
In [185]: f()
Out[185]: (5, 6, 7)
In [187]: x
Out[187]: {'a': 0, 'b': 0, 'c': 0, 'd': 0}
In [188]: x, y, z = (5, 6, 7)
In [189]: x
Out[189]: 5
In [190]: def f():
...: a = 5
...: b = 6
...: c = 7
...: return {'a': a, 'b': b, 'c': c}
...:
In [191]: result = f()
In [192]: result
Out[192]: {'a': 5, 'b': 6, 'c': 7}경우에 따라 딕셔너리를 반환하는 방식이 더 유용할 수 있음