<jupyter_start><jupyter_text>배운다 예제로 나는 Tutorial Python - ver : 1.2 date : 19/09/10 작성 : 한경민  installation- pycharm- anaconda- debug  Importing Package- C에서의 include와 같은 여러가지 라이브러리(pakage)들을 import 해봅시다.<jupyter_code>import numpy as np
import torch
import math<jupyter_output><empty_output><jupyter_text>- as를 사용하여, numpy라는 라이브러리 명칭을 전부 사용할 필요 없이 np.~으로 numpy를 사용할 수 있습니다.- 예시에서는 나오지 않았지만, import tensorflow와 import tensorflow as tf에서, 각각 tensorflow.~ 그리고, tf.~라고 불러와야 하는 차이점이 있습니다.- import한 pakage을사용해 봅시다.<jupyter_code>print(np.random.randn(5,3))
print(torch.randn(5,4))
print(math.sqrt(2))
from numpy import random as nr
print(nr.randn(5,3))<jupyter_output>[[-0.28280536  1.07040095 -0.85927032]
 [ 0.36444261  0.78675443 -1.10288437]
 [-0.61791575  0.17841997  0.39080883]
 [-1.13811682  0.82265266 -1.49821237]
 [ 0.36216926  0.46093204 -0.27559024]]<jupyter_text>- from 패키지명 import 함수나 변수 를 활용하여, 패키지 안의 함수나 변수만을 가져올 수 있습니다.- 앞서 배웠던 as와 결합하여, numpy.random을 nr로 불러온 것에 성공한것을 볼 수 있습니다.  Data type : 자료형- python에는 다양한 data type이 존재합니다.- python에는 숫자형/ 문자열 자료형/ 리스트 자료형/ 튜플 자료형/ 딕셔너리 자료형/ 집합 자료형/ bool 자료형이 있습니다.  숫자형 데이터<jupyter_code>num1 = 123
print(num1)
print(type(num1))
num2 = -1.23
print(num2)
print(type(num2))
num3 = 1.23e4
print(num3)
print(type(num3))
num4 = float(num1)
print(num4)
print(type(num4))<jupyter_output>123
<class 'int'>
-1.23
<class 'float'>
12300.0
<class 'float'>
123.0
<class 'float'><jupyter_text>- 숫자형에는 크게 두 가지 타입이 존재합니다.- int는 정수를 다루는 타입이고, float는 유리수를 다루는 타입입니다.- 1.23e4와 같은 문법이 허용되어있으며, "eNum"은 *10^(Num)을 의미하므로, 1.23e4는 1.23*10^4 즉, 1230을 의미합니다.- int(), float()등을 통해 type casting(타입을 변환)이 가능합니다.- 위의 예시에선 123(int)를 float형으로 type casting한 것을 확인할 수 있습니다.  숫자형 데이터의 사칙연산- 숫자형 데이터는 사칙연산을 지원합니다.- 기본적으로, "+, -, *, /" 등을 지원하며, python에서는 제곱연산 "**"과 나머지를 반환하는 "%" 연산, 몫을 반환하는 "//"를 지원합니다.<jupyter_code>a = 123
b = 456
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a ** 2)
print(b % a)
print(b // a)<jupyter_output>579
-333
56088
0.26973684210526316
15129
87
3<jupyter_text>문자열 - 문자열을 사용할때는, ('\~'), ("\~"), ('''\~'''), ("""\~""") 총 4가지를 사용하여, 문자열을 생성 할 수 있습니다. - 문자열을 줄 바꿈 사용하고자 한다면, "\n"을 사용하면, 원하는 위치에서 줄 바꿈을 수행하는 문자열을 생성할 수 있습니다.<jupyter_code>string1 = 'hellow world'
print(string1)
string2 = "hellow world2"
print(string2)
string3 = '''hellow world3 hellow world3 hellow world3 hellow world3 hellow world3
hellow world3 hellow world3 hellow world3 hellow world3 hellow world3 hellow world3 hellow world3 hellow world3 '''
print(string3)
string4 = """hellow world4 hellow world4 hellow world4 hellow world4 hellow world4 
hellow world4 hellow world4 hellow world4 hellow world4 hellow world4 hellow world4 hellow world4 hellow world4 """
print(string4)
string5 = """hellow \nworld5"""
print(string5)<jupyter_output>hellow world
hellow world2
hellow world3 hellow world3 hellow world3 hellow world3 hellow world3
hellow world3 hellow world3 hellow world3 hellow world3 hellow world3 hellow world3 hellow world3 hellow world3 
hellow world4 hellow world4 hellow world4 hellow world4 hellow world4 
hellow world4 hellow world4 hellow world4 hellow world4 hellow world4 hellow world4 hellow world4 hellow world4 
hellow 
world5<jupyter_text>LIST : 리스트 자료형- 앞서, 숫자나 문자열 자료형에 대해 공부하는 시간을 가졌습니다.- 이번에는 숫자나 문자열의 여러개의 모음으로 표현되는 리스트 자료형에 대하여 배워볼 것입니다.<jupyter_code>a = []
b = [1,2,3]
c = ['a','b','c']
d = [1,2,3,'a','b']
e = [1,2,['a',c]]
print(a)
print(b)
print(c)
print(d)
print(e)<jupyter_output>[]
[1, 2, 3]
['a', 'b', 'c']
[1, 2, 3, 'a', 'b']
[1, 2, ['a', ['a', 'b', 'c']]]<jupyter_text>- List는 "[]"로 생성할 수 있으며, 순서를 고려하는 자료형입니다.- List의 원소(element)로 올 수 있는것은 숫자형 자료형, 문자열등이 있으며, 리스트 자체로 한 리스트의 element로 들어올 수 있습니다.<jupyter_code>a = [1,2,3,['a','b']]
print(a[0])
print(a[1])
print(a[2])
print(a[3])
print(a[3][0])
print(a[3][1])
print(a[-1][0])
print(a[-1][-1])<jupyter_output>1
2
3
['a', 'b']
a
b
a
b<jupyter_text>- 보기와 같이 List는 indexing을 지원하며, 첫 element는 "0" 부터 시작합니다.- List의 마지막 element는 -1, 마지막에서 두번째 element는 -2로 대치할 수 있습니다.- List속에 List가 있다면, [?][?]으로 값에 접근할 수 있습니다.<jupyter_code>a = [1,2,3,4,5,6,7]
print(a[2:5])
print(a[:5])
print(a[2:])
print(a[:-1])
print(a[-1:])
b = "1234567"
print(b[2:5])<jupyter_output>[3, 4, 5]
[1, 2, 3, 4, 5]
[3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6]
[7]
345<jupyter_text>- List는 slicing을 지원합니다.- 2번째 element부터 5번째 element가 되기 전까지를 가져오고 싶을때가 있을텐데 그런때에 유용한것이 slicing입니다.- 기본적으로 [start_point:end_point]이 지원되며, [start_point:],[:end_point]는 각각 시작지점 ~ 리스트의 끝, 리스트의 시작 ~ 끝지점이 추출됩니다.<jupyter_code>a = [1,2,3]
b = ['4','5','6']
print(a + b)
print(a*3)
print(len(a+b))
print(len(a*3))<jupyter_output>[1, 2, 3, '4', '5', '6']
[1, 2, 3, 1, 2, 3, 1, 2, 3]
6
9<jupyter_text>- 리스트에는 더하기 곱하기 연산이 정의되어있습니다.- 더하기 연산은 두 리스트를 이어주는 연산이 수행되고,- 곱하기 연산은, 리스트를 곱한 숫자만큼 반복해서 이어붙히는 연산을 수행합니다.- len() 함수는 리스트의 element수를 반환합니다.<jupyter_code>a = [1,2,3]
a[1] = 7
print(a)
del a[1]
print(a)
a = [1,2,3,4,5]
del a[3:]
print(a)<jupyter_output>[1, 7, 3]
[1, 3]
[1, 2, 3]<jupyter_text>- 위와같이 리스트의 값 일부를 접근하여 수정할 수 있습니다.- del을 이용하여, 리스트의 한 element를 제거할 수 있습니다.- 마찬가지로, del을 이용해 여러 element를 제거할 수도 있습니다.<jupyter_code>a = []
a.append(1)
a.append(3)
a.append(2)
print(a)
a.reverse()
print(a)
a.sort()
print(a)<jupyter_output>[1, 3, 2]
[2, 3, 1]
[1, 2, 3]<jupyter_text>- 비어있는 list는 []으로 생성할 수 있습니다.- append() 매소드를 활용해, 현재 리스트에 element를 추가할 수 있습니다.- reverse() 매소드를 활용해, 현재 리스트의 값들을 반전시킬 수도 있습니다.- sort() 매소드를 활용해, 값들을 sort할 수 있습니다.<jupyter_code>a = [1,2,3,4,5,3,6,7,8,9,10]
a.insert(2,11)
print(a)
a.remove(3)
print(a)
a.remove(3)
print(a)
print(a.pop())
print(a)
print(a.count(3))
print(a.count(5))<jupyter_output>[1, 2, 11, 3, 4, 5, 3, 6, 7, 8, 9, 10]
[1, 2, 11, 4, 5, 3, 6, 7, 8, 9, 10]
[1, 2, 11, 4, 5, 6, 7, 8, 9, 10]
10
[1, 2, 11, 4, 5, 6, 7, 8, 9]
0
1<jupyter_text>- insert(insert_point, val) 매서드를 활용하여, 원하는 위치에 값을 삽입할 수 있습니다.- remove(val)를 활용하여, 첫 element부터 val에 해당하는 값을 찾아 제거할 수 있습니다.- pop()을 활용하여, 마지막 element부터 추출 및 제거할 수 있습니다.- count(val)를 활용하여, list속 val의 갯수를 샐 수 있습니다.  Tuple : 튜플 자료형- tuple형 데이터는 기본적으로 리스트형 데이터와 거의 비슷하지만, 몇 가지 다른점이 있습니다.- 리스트는 []으로 생성됬지만, 튜플은 ()으로 생성됩니다.- 리스트는 개별 값들에 접근해 생성 및 수정, 삭제 모두 가능하지만, 튜플은 생성된 뒤 아무값도 바꿀 수 없습니다..<jupyter_code>t1 = ()
t2 = (1,)
t3 = (1,2,3)
t4 = 1,2,3
t5 = ('a',1,('123','abc'))
print(t1)
print(t2)
print(t3)
print(t4)
print(t5)<jupyter_output>()
(1,)
(1, 2, 3)
(1, 2, 3)
('a', 1, ('123', 'abc'))<jupyter_text>- t2에서 한 개의 element만 사용하는 tuple에서는 반드시, ","를 사용하여야한다.- "()"를 사용하지 않더라도 tuple을 생성할 수 있다는 점이 있다.- 그 외의 인덱싱, 더하기, 곱하기등은 list에서의 것과 모두 같다.  Dictionary : 딕셔너리 자료형- 딕셔너리는 key와 value를 한쌍으로 하는 자료형입니다.- {'name' : 홍길동, 'year' : 1990, 'height' : 178, 'weight' : 63 }- key는 tuple에서 처럼 수정할 수 없는 값을 사용하고, value에서는 변하는 값, 변하지 않는 값 모두 사용할 수 있습니다.<jupyter_code>a = {'a' : 1, 'b' : 2, 3 : 'abc', 4 : [5,6,7]}
print(a['a'])
print(a['b'])
print(a[3])
print(a[4])<jupyter_output>1
2
abc
[5, 6, 7]<jupyter_text>- 기본적으로 "{}"을 통해 생성할 수 있습니다. ** set과 혼동 할 수 있지만, set에는 key가 없습니다. **- 순서가 없는 자료형이므로, 리스트나 튜플의 indexing방법을 지원하지 않으며, key를 통해 값을 불러와야 합니다.<jupyter_code>a = {}
a[2] = 'abc'
a['a'] = 'abcd'
a[0] = [1,2,3,4]
print(a)
print(2 in a)
print(3 in a)
del a[2]
print(a)
print(a[0])
print(a.get(0))
print(a['a'])
print(a.get('a'))
print(a.get(2))
#print(a[2]) #make err<jupyter_output>{2: 'abc', 'a': 'abcd', 0: [1, 2, 3, 4]}
True
False
{'a': 'abcd', 0: [1, 2, 3, 4]}
[1, 2, 3, 4]
[1, 2, 3, 4]
abcd
abcd
None<jupyter_text>- 위와같이 비어있는 dictionary에 "dicname[key] = val" 과 같은 방식으로 element를 추가할 수 있습니다.- key가 list에 있는지 여부를 "key in dicname" 으로 알 수 있습니다.- list와 마찬가지로 del을 사용해 key와 val쌍을 제거할 수 있습니다.- dicname[key]로 값을 불러올 수 있지만, dicname.get(key)를 통해 값을 불러올 수도 있습니다.- get method를 사용하면, key가 존재하지 않는 경우에 None을 배출하지만, dicname[key]는 오류를 발생시킵니다.<jupyter_code>a = {'key1' : 'val1', 'key2' : 'val2', 'key3' : 'val3'}
print(a.keys())
for item in a.keys():
    print(item)
print(a.values())
for item in a.values():
    print(item)
print(a.items())
a.clear()
print(a)<jupyter_output>dict_keys(['key1', 'key2', 'key3'])
key1
key2
key3
dict_values(['val1', 'val2', 'val3'])
val1
val2
val3
dict_items([('key1', 'val1'), ('key2', 'val2'), ('key3', 'val3')])
{}<jupyter_text>- keys() 매소드를 통해, key들만 추출할 수도 있습니다.- 마찬가지로, values() 매소드를 통해 value들만 추출할 수도 있습니다.- clear를 통해, dictionary의 내용을 모두 지울수도 있습니다.<jupyter_code>a = {'a' : 1, 'a' : 2}
print(a)<jupyter_output>{'a': 2}<jupyter_text>- 같은 key를 갖는 쌍이 한 dictionary안에 있을 경우, 마지막으로 입력된 key와 value쌍만 인정받을 수 있습니다.  Set : 집합 자료형- 집합 자료형 역시 list 자료형과 비슷한 형태의 자료형입니다.- List와 Set의 가장 두드러지는 차이점은 1. 중복을 허용하지 않는다, 2. 순서가 없다. 라는 2가지 특징이 될것입니다.- Set형 자료형은 set()으로 생성하며, 순서가 없기 때문에 인덱싱을 지원하지 않는다는 점이 또 하나의 큰 특징이라고 볼 수 있을것입니다.<jupyter_code>set1 = set([1,2,3,4,5])
print(set1)
set2 = set([1,3,5,7,9])
print(set2)
set3 = set1 & set2
print(set3)
set4 = set1.intersection(set2)
print(set4)
set5 = set1 | set2
print(set5)
set6 = set1.union(set2)
print(set6)
set7 = set1 - set2
print(set7)
set8 = set1.difference(set2)
print(set8)
set1.add(6)
print(set1)
set1.update([6,7,8,9,10])
print(set1)
set1.remove(6)
print(set1)<jupyter_output>{1, 2, 3, 4, 5}
{1, 3, 5, 7, 9}
{1, 3, 5}
{1, 3, 5}
{1, 2, 3, 4, 5, 7, 9}
{1, 2, 3, 4, 5, 7, 9}
{2, 4}
{2, 4}
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
{1, 2, 3, 4, 5, 7, 8, 9, 10}<jupyter_text>- set형은 리스트를 set()을 통해 형변환을 통해 얻을 수도 있지만, 기본적으로 "{}"을 통해 생성할 수 있습니다.- set은 집합으로써, & | - 연산을 지원하며 각각 교집합, 합집합, 차집합을 의미합니다.- intersection, union, difference가 각각 상기 언급된 집합연산을 대체할 수도 있습니다.- add(val)를 통해 집합에 element를 추가할 수 있습니다.- update(list)를 통해 집합에 element들을 추가할 수도 있습니다.- remove(val)을 통해, 집합에서 해당하는 val element를 제거할 수 있습니다.  bool 자료형- 참과 거짓을 나타내기 위한 자료형입니다.- True와 False 두 값만을 가질 수 있으며, and 나 or 등의 연산자를 활용할 수 있습니다.<jupyter_code>T = True
print(T)
F = False
print(F)
T = 5>3
print('5>3: ' + str(T))
F = 5<=3
print('5<=3: ' + str(F))
bool1 = 5>3 and 5<=3
print('5>3 and 5<=3: ' + str(bool1))
bool2 = 5>3 or 5<=3
print('5>3 or 5<=3: ' + str(bool2))
if 5<3:
    print('5<3: True')
else:
    print('5<3: False')
if []:
    print('[]: True')
else:
    print('[]: False')
if [1,2,3,'a','b']:
    print("[1,2,3,'a','b']: True")
else:
    print("[1,2,3,'a','b']: False")
if 1:
    print('1: True')
else:
    print('1: False')
if 0:
    print('0: True')
else:
    print('0: False')
while 5<3:
    print("impossible")<jupyter_output>True
False
5>3: True
5<=3: False
5>3 and 5<=3: False
5>3 or 5<=3: True
5<3: False
[]: False
[1,2,3,'a','b']: True
1: True
0: False<jupyter_text>For / While : 반복문- for문과 while문을 반복하여 단순 반복작업을 쉽게 수행해봅시다.<jupyter_code>print(math.pow(0,0))
print(math.pow(1,1))
print(math.pow(2,2))
print(math.pow(3,3))
print(math.pow(4,4))<jupyter_output>1.0
1.0
4.0
27.0
256.0<jupyter_text>- 이렇게 귀찮게 작성되어야 할 코드가...<jupyter_code>for i in range(0,5):
    print(math.pow(i,i))<jupyter_output>1.0
1.0
4.0
27.0
256.0<jupyter_text>- 이렇게 간단히 수행할 수 있습니다.- i는 for문을 돌며 range(0,5)가 뱉는 {0,1,2,3,4}를 하나하나 꺼내 사용하며, for안의 문장을 반복합니다.- 위에서 작성된 for문은 다음과같이 똑같은 일을 수행하는 While문으로 작성할 수 있습니다.<jupyter_code>i = 0
while(i < 5):
    print(math.pow(i,i))
    i = i+1<jupyter_output>1.0
1.0
4.0
27.0
256.0<jupyter_text>- i = 0 으로 값을 초기화 하고, - 매 iteration을 i < 5 를 더 이상 만족하지 않을때까지 반복합니다.<jupyter_code>i = 0
while(True):
    print(math.pow(i,i))
    i = i+1
    if i == 5:
        break<jupyter_output>1.0
1.0
4.0
27.0
256.0<jupyter_text>- 다음과 같이 while문을 항상 가동하되, break을 통해, while문을 특정 조건을 만족하면 탈출 할 수 있게 작성할 수 있습니다.- 위와 같은 방식으로, break을 활용하여 위와 같은 수행을 하는 while문을 만들 수 있습니다.  IF/else : 조건문- while문에서 잠시 소개되었던, if문에 대해 알아봅시다!- if문은 if문 오른쪽 문장이 참(True)인치, 거짓(False)인지에 따라서, 종속 문장을 수행합니다.- 여기서 종속문장은 들여쓰기를 기준으로 하며, 이는 C언어의 "{}"와 유사합니다.- 종속문장의 상위문장에는 항상 ":"이 따라오게 되어있습니다.- if/elif/else를 활용하여, 조건1을 만족하는지 아닌지/ 조건1이 만족되지 않았다면, 조건2는 만족하는지 하지않는지, 모두 만족하지 않는 그 외에 해당하는지를 확인합니다.<jupyter_code>test_value = 26
if test_value>50 or test_value<10:
    print('case1')
elif test_value>35 or test_value<25:
    print('case2')
elif test_value>29 or test_value<27:
    print('case3')
else:
    print('o,w')<jupyter_output>case3<jupyter_text>- test_value는 26의 값으로 초기화 되었으며,첫 조건문(10미만, 50초과)을 만족하지 못했으므로, 두번째 조건문(25미만, 35초과)을 확인하게되고, 두번째 조건문 역시 만족하지 못했으므로, 3번째 조건문(27미만, 29초과)에서, 26은 27미만에 해당하므로, 세번째 조건문에서 참이되어 case3를 print하게 됩니다. 만일 test_value가 27~29사잇값이였다면, o.w가 출력되었을 것입니다.  Function : 함수- 인풋과 아웃풋으로 정의되는 함수를 구성합니다.- 중,고등학교에서 배웠던 함수의 flow는 다음과 같았을 것입니다.- 위 그림의 함수의 입력(input)으로 x1,x2 라는 것이 사용되었고, 이를 전달인자(argument)라고 부릅니다.- 혹은 매개변수(parameter)이라고도 부릅니다.- 이 둘은 함수의 정의 부분에 나열된 변수인가(parameter) 혹은, 함수를 호출할 때 전달되는 실제 값(argument)인지에 따라 명칭이 다르지만, 보통 혼용되어 사용되는것 같습니다.<jupyter_code>import matplotlib.pyplot as plt

def quadratic_formula_plot(from_,to_,a,b,c):
    x = np.arange(from_,to_,0.1)
    y = []
    for tempx in x:
        tempy = a*pow(tempx,2) + b*tempx + c
        y.append(tempy)
    plt.plot(x,y)
    plt.show()
    
quadratic_formula_plot(-1,1,3,2,2)<jupyter_output><empty_output><jupyter_text>- 함수의 출력을 위해 import matplotlib.pyplot as plt을 import합니다.- 위의 예시에서는 2차 함수의 계수(constant)와 plot할 x축의 시작과 끝까지의 결과를 보여주는 함수를 확인 할 수 있습니다.- 정의된 함수의 argument로 -1,1,3,2,2가 들어간것을 볼 수 있는데, 이는 각각 x축 시작점, x축 끝점, ax^2+bx+c에서 a,b,c를 의미합니다.- - 함수의 parameter로 from_, to_, a, b, c가 있는데, 별도의 기입이 없다면, 함수 밖에서 입력되는 argument는 저 순서대로 인식이 됩니다.- 먼저 np.arange(from_,to_,0.1)에서 -1(from_)에서 부터 0.1씩 늘려가며, 1이 될 때까지의 값들을 x에 저장합니다.- y=[] 에서는 for문을 반복하며, 계산된 tempy들을 저장해주기 위한 공간을 준비합니다.- for 문 안에서는, x값을 하나씩 꺼내 tempy를 계산하고, 그 값을 y.append(tempy)를 통해 저장합니다.- 저장된 y와 x를 plt.plot(x,y) plt.show()를 통해 출력합니다.- 함수의 정의 밖에서, quadratic_formula_plot(-1,1,3,2,2)을 통해 예시와 같이 미리 정의된 함수를 수행할 수 있습니다.  Class : 클래스- 클래스는 프로그래밍의 객체지향을 구현하기위한 핵심적인 부분이라고 볼 수 있습니다.- 클래스는 무엇이며, 어떻게 사용될까요?- 예시로 사람에 대한 정보를 저장하고, 다루는 프로그램을 구현한다고 생각해보겠습니다.<jupyter_code>#human1:
human1_name = '<NAME>'
human1_height = 177
human1_age = 25
human1_gender = "Male"

#human2:
human2_name = '<NAME>'
human2_height = 164
human2_age = 25
human2_gender = "Female"

#human3:
human3_name = '<NAME>'
human3_height = 176
human3_age = 27
human3_gender = "Male"

#human4:
human3_name = '<NAME>'
human3_height = 173
human3_age = 24
human3_gender = "Male"<jupyter_output><empty_output><jupyter_text>- 이런식으로 사람을 하나하나 작성하다보면 코드가 굉장히 지저분해지고, 변수를 매번 직접 만들어야하는 어려움이 있습니다.- 여기서 주목할 점은, 여기서 다루는 사람에 대한 정보는 모두 이름, 키, 나이, 성별로 고정되어 있다는 점입니다.- 이런 수행을 반복적으로 수행할 때 빛나는 것이 바로, 클래스입니다.<jupyter_code>class human:
    class_value = 'student'
    def __init__(self,name_,height_,age_,gender_):
        self.name = name_
        self.height = height_
        self.age = age_
        self.gender = gender_
    def print(self):
        print('name is: '+ self.name)
        print('height is: '+ str(self.height)+ 'cm')
        print('age is: '+ str(self.age))
        print('gender is: '+ self.gender)
        print('and he/she is '+ self.class_value)
        print('------------------')

human1 = human('<NAME>',177,25,'Male')
human2 = human('<NAME>',164,25,'Female')
human3 = human('<NAME>',176,27,'Male')
human4 = human('<NAME>',173,25,'Male')

human1.print()
human2.print()
human3.print()
human4.print()

print(human1.name)
print(human1.class_value)
print(human2.name)
print(human2.class_value)<jupyter_output>name is: <NAME>
height is: 177cm
age is: 25
gender is: Male
and he/she is student
------------------
name is: <NAME>
height is: 164cm
age is: 25
gender is: Female
and he/she is student
------------------
name is: <NAME>
height is: 176cm
age is: 27
gender is: Male
and he/she is student
------------------
name is: <NAME>
height is: 173cm
age is: 25
gender is: Male
and he/she is student
------------------
<NAME>
student
<NAME>
student<jupyter_text>- __init__(self,name_,height_,age_,gender_):- "생성자(constructor)"는 객체(하나의 사람 같은)가 생성될 때 최초로 실행됩니다.- 우리는 예시에서, human1 = human('<NAME>',177,25,'Male')에서 human이란 class로 human1 object(객체)를 생성하였고,- 객체 human1의 정보를 argument값을 전달하여, human1의 초기값으로써 저장하였습니다.- 매번 객체를 생성할때마다 argument를 통해 초기화 시킬 정보들을 전달하여, 생성자에서 그 값들로 초기화를 수행합니다.- self.name 등은, 각 객체마다 독립적으로 가질 수 있는 변수로, "객체변수"라 불리며, 생성된 객체마다 다른 값을 가질 수 있습니다.- def print(self):- 모든 사람이면 공통적으로 하는 일이 있을 수 있습니다. 예컨데, 밥을 먹는다던가, 숨을 쉬기 등의 동작을 수행할 수 있을텐데요,- 위의 예시에서는 사람의 정보를 다루는것이 목표이므로, 개인정보를 출력하는 동작을 만들었습니다.- 각 객체가 자기자신이 갖고 있던, 객체변수를 출력하는 함수를 class안에 만들었고, 이는 모든 human class가 동일하게 동작 할 수 있습니다.- class안에 어떤 동작을 수행하는 함수를 "매서드"라고 부르며, 이를 통해 같은 human이라는 class를 갖는 객체들은 동일한 동작을 독립적인 변수(객체변수)등을 활용하여 일관적으로 수행할 수 있습니다.- class_value = 'student'- self로 선언되지 않은 변수인 class_value는 모든 human_class가 공유하는 변수로, 각각의 객체에서 항상 같은값을 반환합니다. 이를 클래스 변수라 부릅니다.- C++에서와 달리 객체변수, 클래스 변수 모두 클래스 밖에서 접근 가능합니다.- 마지막 4줄에서 확인할 수 있듯이, 클래스 변수의 출력은 오브젝트와 무관하게 같은 값을 뱉고, 객체 변수는 오브젝트에 종속된 값을 출력하는것을 볼 수 있습니다.   Iterator- List, tuple, Set, Dictionary 같은 자료형이나, 문자열과 같은 문제 시퀸스는 for문을 통해 하나하나 원소를 꺼내올 수 있는데, 이런 자료형이나, 시퀸스들을 Iterable 객체(Iterable object)라 부릅니다.- iterable object의 내장함수 iter()은 "iter(iterable_object_name)" 과 같이 사용하여, iterable object의 iterator를 반환합니다.- iterable object에서 실제로 iteration을 수행하는 것은 iterator이며, iterator은 next라는 매서드 함수를 사용하여, 다음 원소를 꺼내옵니다.- 더이상 반환할 next 원소가 부재할시에는, "stopiteration 예외상황"을 반환시켜 정지합니다.<jupyter_code>list_iterobj = [1,3,5,7,9]
list_iterator = iter(list_iterobj)
print(list_iterator.__next__())#in python2 list_iterator.next()
print(list_iterator.__next__())
print(list_iterator.__next__())
print(next(list_iterator))
print(next(list_iterator))
#print(list_iterator.__next__())#stopiteration exception err occur<jupyter_output>1
3
5
7
9<jupyter_text>- iterable한 클래스를 만들고자 한다면, iterator를 반환하는 __iter__() 매서드를 작성해야만 합니다.- iterator는 1.동일한 클래스 객체가 될 수도 있고, 2.별도로 작성된 iterator 클래스의 객체가 될 수도 있습니다.- iterator가 되는 클래스는 반드시 __next__() 매서드를 가지고 있어야 합니다.- 요약하면, iterable class(object) -> has iterator -> has __next__() method. 가 될것입니다.<jupyter_code>class iterator_class:
    def __init__(self,capacity_,list_):
        self.cap = capacity_
        self.index = 0
        if not list_:
            self.data = list(range(self.cap))
            print(self.data)
        else:
            self.data = list_
            print(self.data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index >= self.cap:
            raise StopIteration
        out = self.data[self.index]
        self.index += 1
        return out
test = iterator_class(10,[])
for x in test:
    print(x)
######################################################
class iterable_class:
    def __init__(self,capacity_,list_):
        self.cap = capacity_
        self.list = list_
    def __iter__(self):
        self.index = 0
        return iterator_class(self.cap,self.list)
test = iterable_class(5,[1,3,5,7,9])
for x in test:
    print(x)<jupyter_output>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0
1
2
3
4
5
6
7
8
9
[1, 3, 5, 7, 9]
1
3
5
7
9<jupyter_text>- 위의 예시에서 iterator_class는 __iter__() 매서드를 갖고 있고, 자기자신을 iterator 반환하고 있습니다.- 또, __next__() 매서드를 갖고 있으므로, iterator_class는 이터레이터로서 동작할 수 있습니다.- 따라서, iterator_class는 iterable하며, iterator이기도 합니다.- 아래의 iterable_class는 __iter__() 매서드를 갖고 있으며, iterator_class를 iterator로써 반환하고 있습니다.- iterator_class와는 반대로 __next__()가 없으나, iterable하며, 이는 __iter()__ 에서 __next__() 매서드를 갖고있는, iterator를 반환하고 있기에, iterable한 class가 될 것입니다.- 따라서, iterable_class는 iterator가 아니지만, iterable합니다.  generator- generator는 iterator의 특수한 형태중 하나입니다.- generator 함수는 함수안에 yeild가 하나하나 사용되어 데이터를 하나씩 리턴하는 방식으로 동작합니다.- generator를 생성한 뒤 next를 통해 호출 될 때마다, 마지막 yield 이후부터 다음 yield까지의 동작을 수행합니다.- iteratable object와 마찬가지로, for문에서 사용될 수 있습니다.<jupyter_code>def generator_func():
    print('0-1')
    yield 1
    print('1-2')
    yield 2
    print('2-3')
    yield 3
    print('3-4')

g1 = generator_func()
print(type(g1))
print(next(g1))
print(next(g1))
print(next(g1))
print('--------------------')
g2 = generator_func()
for item in g2:
    print(item)
def infgen():
    cnt = 0
    while True:
        yield cnt
        cnt = cnt + 1
        
g = infgen()
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))<jupyter_output>0
1
2
3
4
5<jupyter_text>- generator은 키워드 "yeild"를 통해 iterator를 생성하므로, 다음과 같이 무한한 순서가 있는 객체를 만드는 것이 가능합니다.- 이렇게 무한한 숫자를 반환할 수 있는 이유는 generator를 실행할때(next) 마다, yield까지 수행되고 내부의 변수가 유지되는 독특한 방식을 채택하고 있기 때문입니다. - 사실, List, set Dictionary의 표현식의 내부도 generator입니다.- 표현식에 대해서는 다음 자료를 확인!<jupyter_code>print(type(x^3 for x in [1,3,5]))
print(type(x^3 for x in (1,3,5)))
print(type(x^3 for x in {1,3,5}))<jupyter_output><class 'generator'>
<class 'generator'>
<class 'generator'>
{'fraction_non_alphanumeric': 0.15807577268195414, 'fraction_numerical': 0.05897308075772682, 'mean_word_length': 3.9496669133974835, 'pattern_counts': {'":': 1, '<': 138, '<?xml version=': 0, '>': 134, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '31', 'dir': 'jupyter-structured-clean-dedup', 'id': '431571', 'license': 'MIT', 'n_tokens_mistral': 12618, 'n_tokens_neox': 14312, 'n_words': 2709, 'path': 'python_tut.ipynb', 'repo_name': 'TaehoLi/Intern-Study', 'size': '20139'}