[Python] 기초2

본 과정은 제가 파이썬 수업을 들으면서 배운 내용을 복습하는 과정에서 적어본 것입니다.
틀린 부분이 있다면 댓글에 남겨주시면 고치도록 하겠습니다.
확실하지 않은 내용은 ‘(?)’을 함께 적었으니 그 내용을 아신다면 댓글에 남겨주시면 감사하겠습니다.

1) Tuple

• 할당에 투플이 큰 역할을 차지한다.

a=(1,2,3,) # 뒤에 , 를 찍어주는게 좋다.
a=(1,) # 뒤에 투플을 만들려면 ,를 찍어줘야한다. 
type(a) # tuple

a=1, # 괄호를 없애도 투플이다. 
type(a)

a=1,2,3, # 괄호 없애는게 편하다.
type(a) # tuple
a   # (1,2,3) 한개를 할당.

a,b=1,2,3 #하나하나씩 할당하는 것
type(b) #개수가 다르면 에러가 간다.

- * 는 다양하게 쓰인다. 여기서는 나머지를 할당 받겠다는 의미로 나타난다. 

# * 5가지 -> 여기서 별표는 나머지를 할당 받겠다는 의미 
a,*b =1,2,3
a
b
type(a)
######################
a,*b,c=1,2,3,4,5,6
a
b
c

Out:
1
[2, 3]
int
1
[2, 3, 4, 5]
6

*a=1,2,3,4,5,6 # 할당된 것이 없으니까 이 식은 에러가 난다. 

*a,=1,2,3,4,5,6 # a뒤에  ','를 붙이면 list로 바뀌게 된다. 투플인데 리스트로 변신시키고자 할 때 쓴다. 
a # [1, 2, 3, 4, 5, 6]

def x():
    return 1,2 # return 무조건 한개, (,)로 나눠지면 무조건 투플

• Swap 하는 방법

a=1
b=2

# (1) 
a,b=b,a # 스왑(swap)은 이렇게 하는것. b=1, a=2
a # 2
b # 1

# (2) (?)
import tempfile
# 따라서 쪼개려면 임시개체를 이용해서 한다.
temp = tempfile.NamedTemporaryFile()
a = 1
b = 2
a = temp
b = temp

• 피보나치
• 튜플로 피보나치를 만들 수 있다.
• 피보나치를 만다는 방법은 다양한데 기본적으로 10가지가 있다고 한다.

a=1
b=2
a,b = b, a+b # 교과서적인 테크닉 *** 중요
a # 2
b # 3

2) list

• list(mutable) & tuple(immutable) -> (heterogeneous & sequence - indexing & sclicing)
• list 안에 list도 넣을 수 있다.

list('경아') # ['경', '아'] 문자를 나눠줄 때 list를 쓴다. 

a=[1,] # list에 , 뒤에 넣어도 돌아간다. 
# mutable -> 자기자신이 변해도 메모리도 변한다. (첫번째 주소값만 안 변한다.) 
# 따라서 계속 추가가 되도 첫번째 주소도 바뀌지 않기에 주소값이 바뀌지 않는다. 
# python의 list는 링크드로 되어있다. (?)
a # [1]

• append & extend
• append: 맨 끝에 추가가된다.
• extend: 맨 끝에 추가가 된다.

a.append(2) # 안에 들어가는 원소 
a  # [1, 2]

a.extend([3]) # list 형태
a  # [1, 2, 3]

• 리턴값
• 리턴한다는 말은 값을 반환하며 메소드를 종료한다는 것

# mutable 조심해야할 3가지
# sequence heterogeneous

# 1) 리턴값이 없는 경우
a.index(1) # 0 -> 결과값이 나오지 않는다. 

# mutable일 때는 3가지를 조심해야한다. 
# 1) 실행했는데 결과값이 안나온다. 근데 값은 변하고 리턴은 없다. 
def append_():
    return None 
# return 이 None이면 결과값이 안나온다. 내부적으로는 return None도 없다. 

def xx():
    a=1

xx() is None # True  
# python 은 return을 생략하면 자연스럽게 None으로 바뀐다. -> mutable method 에서 많이쓴다. 
# 결과값이 안튀어나올 때

# 2) 리턴값이 있는 경우,  mutable인 애만 리턴값이 없는 경우가 있다. 

a= [1,]
b= 1,

# 3) 리턴값이 있는데 내 자신이 바뀐다. 
# ex1)
a=[1,2,3,'경아']

a.pop() # '경아' 맨 끝에 있는것 뽑아주는 것 
a # [1, 2, 3] 리턴값도 있고 자기자신도 변한다. 

# ex2)
def t(l):
    return l.append(3) # 3 더해주는 함수 , 리턴값이 바뀐다. -> 행동은 하지만 리턴은 None이다. 
b=[1,2,3]
t(b) # 행동안하는 것처럼 보이지만 행동한다. 하지만 리턴값이 안나온다. 
b # [1, 2, 3, 3]

# mutable은 또 있다. -> 함수의 매개변수로 쓰일 때 
def s(t,L=[]):
    L.append(t) # 리턴값을 굳이 안써도된다. default 가 heap 영역에 생긴다. -> 그래서 계속 유지한다. 

s(3) # 결과값 안나온다. 
b # [1, 2, 3, 3]
s(b)
b # [1, 2, 3, 3]
s(3,b)
b # [1, 2, 3, 3, 3]

• list 연산자

# list도 연산자가 있다. 
a=[1,2,3]
b=[3,4,5]
a+b # [1, 2, 3, 3, 4, 5] 추가된다. extend와 비슷하다. 
a*3 # [1, 2, 3, 1, 2, 3, 1, 2, 3] 한쪽이 숫자일 때는 곱하기가 된다. -> 숫자가 반복된다.
a='abc'
b='경아'
a+b # 'abc경아'
a*3 # abcabcabc' 반복
'abc''경아' # 'abc경아' 문자열만 더하기 안해도 붙여준다. 
# 하지만 숫자는 안됨 ex) [1,2,][2,3,]

# 리스트를 메소드로 쓰면 3가지 경우
# 1) 결과는 없지만 행동은 하는 애
# 2) 리턴값 나오는 애 
# 3) 리턴값도 나오고 자기자신도 나오는 애 

# 이런 함수는 안좋다. 
def s (t,L=[]):
    L.append(t) 
    return L # 계속 1씩 추가시키는 메소드. 결과값 안나온다.

s(1) # [1] 
s(1) # [1, 1] 실행할때마다 계속 추가되기 때문에 이런 함수는 안좋다. (계속 누적) 

3) set

• 순서가 없고 중복이 없다.
• mutable
• 내부적으로는 순서를 관리
• 사람은 순서를 관리할 수 없다.
• for 안에 set 쓸 수 있다. -> 내부적으로 순서를 관리하기 때문에
• set만의 연산자를 지원한다.

a={1,2,3,2,0}
a # {0, 1, 2, 3}

for i in a:
    print(i)
    
# 0
# 1
# 2
# 3

• 집합 연산자 제공
• 여집합은 제공 안함

a-{2} 
a&{2}
a|{2}
a^{2} # 대칭차집합 (대칭으로 나오는 것)
set() # 공집합

out:
{0, 1, 3}
{2}
{0, 1, 2, 3}
{0, 1, 3}
set() 

• 고유 메서드 확인 (dir)

# dir: 고유 메서드
t=set(dir(list())) & set(dir(tuple()))
t

out:
['count',
 '__gt__',
 '__lt__',
 '__format__',
 '__sizeof__',
 '__delattr__',
 '__iter__',
 '__doc__',
 '__ge__',
 '__new__',
 '__len__',
 '__hash__',
 'index',
 '__setattr__',
 '__le__',
 '__ne__',
 '__mul__',
 '__rmul__',
 '__dir__',
 '__init__',
 '__contains__',
 '__init_subclass__',
 '__repr__',
 '__getattribute__',
 '__subclasshook__',
 '__str__',
 '__add__',
 '__getitem__',
 '__eq__',
 '__reduce_ex__',
 '__reduce__',
 '__class__']

set(dir(tuple()))-t  # immutable
set(dir(list()))-t  # mutable 속성들 

out:
{'__getnewargs__'}
{'__delitem__',
 '__iadd__',
 '__imul__',
 '__reversed__',
 '__setitem__',
 'append',
 'clear',
 'copy',
 'extend',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort'}

4) dictionary

• mutable

{} # {}: dictionary -> 비어있는 공집합을 못만드는 이유는 집합(set)이 처음에는 파이썬에 없었다. 
# 딕셔너리가 먼저 만들어져 있었기에 딕셔너리가 됨.
# 내부 구성의 우선순위는 key
# value는 모든 타입 다 올 수 있다. (heterogeneous container)
set() # set() 공집합

{''} # key -> dictionary는 Hash구조로 이루어져있음

{1:1} # 숫자는 key로 올 수 있다. 문자 올 수 있다. 하지만 list는 올 수 없다. (변할 수 있으니까)

{(1,):1} # {(1,): 1}

{1,:1} # 투플도 되는데 연산자 우선순위라서 작동이 안된다.

{(1,[1]):1} # 안에 있는것 자체가 바뀔 수 있기 때문에 
# 딥카피, 스왈로 카피 할 때 한다. 

[참조]

• Hash Table: 키(Key)에 데이터(Value)를 저장하는 데이터 구조

Key를 통해 바로 데이터를 받아올 수 있으므로, 속도가 획기적으로 빨라짐 파이썬 딕셔너리(Dictionary) 타입이 해쉬 테이블의 예: Key를 가지고 바로 데이터(Value)를 꺼냄 보통 배열로 미리 Hash Table 사이즈만큼 생성 후에 사용 (공간과 탐색 시간을 맞바꾸는 기법) 단, 파이썬에서는 해쉬를 별도 구현할 이유가 없음 - 딕셔너리 타입을 사용하면 됨

• 깊은 복사(deep copy): 깊은 복사는 최상위 컨테이너를 복사하고 내부의 참조 역시 원본 컨테이너의 참조를 복사한다. 깊은 복사는 copy 모듈의 deepcopy() 함수를 사용하면 된다.

• 얕은 복사(swallow copy): 얕은 복사란 최상위 컨테이너는 복사하지만 카피한 컨테이너 내부의 참조는 기존 컨테이너와 동일한 참조로 채워져 있는 것을 얘기한다.

• key & value
• [용어집][https://docs.python.org/ko/3/glossary.html] 참조

{3,2,1}
{'c':2,'a':1,'b':2} # 버전이 바뀌어서 (set) 정렬을 안해준다. 

# 정렬유지하는 dictionary: orderedict -> 'key: value'
from collections import OrderedDict 

# dictionary view 3가지 
{'c':2,'a':1,'b':2}.keys() # [] 있다고 list가 아니다. -> for 뒤에 쓸 수 있다. 
{'c':2,'a':1,'b':2}.values()
{'c':2,'a':1,'b':2}.items()

out:
{1, 2, 3}
{'c': 2, 'a': 1, 'b': 2}
dict_keys(['c', 'a', 'b'])
dict_values([2, 1, 2])
dict_items([('c', 2), ('a', 1), ('b', 2)])

• in 이용

for i in {'c':2,'a':1,'b':2}.items(): # dictionary는 for 뒤에 쓸 수 있다. 
    print(i)

out:
('c', 2)
('a', 1)
('b', 2)

for i in {'c':2,'a':1,'b':2}.keys(): 
    print(i)
    
for i in {'c':2,'a':1,'b':2}:
    print(i)
    
out:
c
a
b
c
a
b

3 in {1,2,3}
3 not in {1,2,3}
2 in {'c':2,'a':1,'b':2} # Flase-> key만 체크하기 때문에

x={'a':1,'b':2}
x['c'] # keyError -> key가 없기때문에 에러

out:
True
False
False

1 in [1,2,3]
'1' in [1,2,3]
'1' in ['12345']
'1' in '123456'
1 in '123' # type error (homogeneous- 문자형 1로 인식)

out:
True
False
False
True

<복습> - 지금까지 배운 에러: NameError, indexError(범위 없는 애 지목), TypeError(같은 타입 메소드 아닐 때 쓸 때), KeyError(키가 없을 때) - debugging 할 때 알아두면 좋다.

# defualt 값을 지정해준는 식 2가지
from collections import defaultdict # 참조할때 get으로 써도된다.

dir(x) # dictionary 는 mutable - clear, pop

x.get('a') # 1 -> default 반환값을 반환해준다. 
x.get('x',3) # 3

• 할당 기법

# <복습> 할당기법
# (1)
a=1

# (2)
a,b=1,2 # 동시할당 # 피보나치 기법도 알아야한다

# (3)
a=b=1 # mutable일 때 같이 바뀌므로 조심

# (4)
a,*b=1,2,3,4 # 별표 쓰는 것

# (5) -> 증감할당
a+=1 
# issue: ++는 부호 취급
++a # C, java 배운사람은 이게 2가 되어야하는데, 파이썬은 ++를 그냥 부호로 인식한다.
--a
# a++ # 에러가난다. -> SyntaxError : 문법에 맞지 않는다. 

# (6) -> 선언 
int a; a = 1 # 선언과 할당을 분리할 수 있는데, 타입이 없어지고 숫자를 선언하는 방식을 안만들어 놓음. 
# global, nonlocal 선언과 비슷하다. 

# mutable 문제점
a=b=[1,2,3,] # mutable로 할당할때 주의 
a
b
b.append(4) 
a  # a도 같이 바뀐다.

out:
[1, 2, 3]
[1, 2, 3]
[1, 2, 3, 4]

--------------------------------

b=[1,2,3,4,5,6]
a # 재할당하면 주소가 바뀐다. 

out: 
[1, 2, 3, 4]

5) if문

• True or False

{} # 객체 값이 있냐 없냐에 따라 T,F 체크 (존재론적 유무)

if 0: 
    print('T')
else:
    print('F') # -> F : 없는 애는 다 F - 존재론 적 관점 
    
if 2: 
    print('T')
else:
    print('F') # -> T
    
if 0.0: 
    print('T')
else:
    print('F') # -> F
    
if []: 
    print('T') # -> F
else:
    print('F')  # -> F : list 입장에서는 없으니까 F
    
if None: 
    print('T')
else:
    print('F') # -> F : None은 없으니까 F 
    
None == False # False : 파이썬에서 F=0, None은 값이 없다.

if '': 
    print('T')
else:
    print('F') # -> F
    
if "": 
    print('T')
else:
    print('F') # -> F
    
if '''''': 
    print('T')
else:
    print('F') # -> F
    
if a is not None: 
    print('T')
else:
    print('F') # -> T

• and , or

0 and 3 # 1 은 true -> 앞에 true인지 false인에 따라 true 일 때만 뒤에 값이 나온다. 
1 and 3
'''''' and 3
[1,2,3] and 3
1 or 3 # 1 이 true -> 뒤에거 안본다. (뭐가나오든 체크를 하지 않는다.)
3 or 1/0 
# and, or 은 뒤에 복잡하게 만들 수 있다. 

out:
0
3
''
3
1
3

6) for문

• python은 반복문 2가지 : 브레이크, 컨틴뉴 기법

%%timeit # 몇초동안 몇개 실행되는가 체크
temp = []
for i in range(100):
    temp.append(i)

• for i in # for in 다음 올 수 있는 것은 iterable!

• iterable (이터러블) -> 순회 가능 한 것 (container는 기본적으로 다 이터러블 , sequence (6가지) <- iterable (bytes, str, bytearray, range, list, tuple) 멤버들을 한 번에 하나씩 돌려줄 수 있는 객체. 이터러블의 예로는 모든 (list, str, tuple 같은) 시퀀스 형들, dict 같은 몇몇 비시퀀스 형들, 파일 객체들, iter() 나 시퀀스 개념을 구현하는 getitem() 메서드를 써서 정의한 모든 클래스의 객체들이 있습니다. set, frozenset, range

• iterater: 1개의 속성을 뽑아낼 수 있는 것
• iterable 만드는 2 가지 방식
  • iterable 상속
  • duck-typing 방식으로 literable
    
    • duck-typing (덕 타이핑): 올바른 인터페이스를 가졌는지 판단하는데 객체의 형을 보지 않는 프로그래밍 스타일

def x ():
    for i in range(100):
        temp.append(i)
        
dir([x]) #__getitem__ -> iterable

for i in range(10):
    print(i)

out:
0
1
2
3
4
5
6
7
8
9

---------------------------
for i in '경아':
    print(i)
    
for i in 1,2,3,'경아',4: # tuple로 인식 
    print(i)
    
for i in {1,2,3}:
    print(i)
    
out:
경
아

1
2
3
경아
4

1
2
3

• for문에 dictionary

# dictionary - 3가지:
{'c':2,'a':1,'b':2}.keys() # [] 있다고 list가 아니다. -> for 뒤에 쓸 수 있다. 
{'c':2,'a':1,'b':2}.values()
{'c':2,'a':1,'b':2}.items()

for i in {'a':1,'b':2}.items():
    print(i) # 결과값이 tuple로 나왔다. 
# ('a', 1)
# ('b', 2)

• unpacking

a= 1,2,3 # tuple 
type(a)

a,b,c=(1,2,3) # tuple ()씌워도 안씌워도 둘다 튜플 따라서 위에 예시랑 같다. 
a

a,b,c = 1,2,3 
type(a)
# integer로 바뀐다. 

for i,j in {'a':1,'b':2}.items():
    print(i,j) # 각각 쪼개서 나눌수 있다. : unpacking 

out:
tuple

1

int

a 1
b 2

• else

for i in range(10000):
    if i==10:
        break
    else:
        print(i)
else:
    print('경아') # telegram 으로 쓸 때 많이 쓴다. -> 완벽하게 다 돌아가면 나타나게하는 것

out:
경아

• else 3가지 쓰이는 방법
• for에 쓰는 else는 반복문이 완전하게 실행되면 else가 출력
• if에 쓰는 else: 안 맞는다는 의미
• while에 쓰는 else: 0 이상 돌았을 때 else 값 출력

for i,j in {'a':1,'b':2}.items():
    print(i,j) 
else:
    print('경아') 

print('######')

a=10
while a>10:
    a-=1
else:
    print('경아') # 0번 돌알았다고 생각해서 else로 찍힌다. 
    
while a>0:
    a-=1
else:
    print('경아')
    
print('#######')

while a>0:
    a-=1
    if a==5:
        break
    print(a)
else:
    print('경아') 

print('########')
    
while a>0:
    a-=1
    if a==5:
        raise
    print(a)
else:
    print('경아') 

out: 
a 1
b 2
경아
######
경아
경아
#######
경아
########
경아

• continue

for i in range(10):
    if i==20:
        continue
    else:
        print(i)
else:
    print('경아') # continue: break하고 에러가 안나면 쓴다. -> while에서는 많이 쓴다.
    
# for 하고 while 에서 차이점 
# for 에서는 쓰기가 어려운 무한 루프  
# while 에서는 무한 루프를 쓰기가 쉽다. 

out:
0
1
2
3
4
5
6
7
8
9
경아

• 무한루프 (for vs. while)
• for 에서는 쓰기가 어려운 무한루프
• while 에서는 무한 루프를 쓰기가 쉽다.

a= input( ) # 사용자 입력받는 것  -> 모든게 str로 바뀐다. 
type(a) # str

# 입력받아서 10을 더해서 출력
a= input()
int(a)+10 # type을 바꿔주는 방법이 python에는 없고, 새로 인스턴스화하는 방식을 써야한다. 

# 무한루프
a=input()
try:
    a =int(a)
except:
    a=input() # 이처럼 실수를 할 수 있을 때 무한루프를 돌린다.
    
while True:  # 무한루프
    try:
        a= int(input())
    except:
        continue  
    else:
        break
        
while [123,12,3,2,'as']: # <- 이 while문도 가능하다. cuz 존재론적 유무 -> True
    try:
        a= int(input())
    except:
        continue  
    else:
        break

<참조>
# python 안에 기본 내장 함수 
import builtins

a= input() 
a=eval(a) # 아라서 type을 바꿔준다. 좋긴한데 엄청 좋진 않다. 
type(a) # 에를 들어 python 기본 문법(in, + etc)이나 식이 좀 더 길다면 에러가 뜬다. 

'eval' in dir( builtins) # True 있는지 없는지 체크 

# eval 보다 조금 더 우아한 애
import ast

ast.literal_eval('1.2') # 1.2 -> '고급 강의6'에서 더 깊게 배울 예정 

python 형변환 2가지 (type conversion)

• 함수를 변화
• 객체 방식으로 타입을 변화

<복습> * else 3 가지 방법 - if - for - while - try else -> 에러가 안날 때 else * 할당은 6가지 * 반복문 2가지 : 브레이크, 컨틴뉴 기법

7) 선언(Declaration) - 함수

• 쓰겠다고 미리 선언하는 것

• 다른 변수는 선언하는게 없다.

• 크게 2가지 1) 함수 (function) 2) 클래스 -> nonlocal,global 포함될 수도 있고 애매

def one_two(a,b):
    return [a+b,a-b] # list 

a=1
b=2
x,y=one_two(a,b)
x # 3
y # -1


def cho_beauty(): # 뒤에 함수에 이름을 쓴다. 함수는 PEP8 -> snake _'바'쓰는것으로 쓴다. 
    a = 1   # () 비어있으면 파라미터가 없다. 결과값은 1개 ; 파이썬은 return 을 안쓰면 자동적으로 return nan을 붙여준다. 
    
# 앞단어 동사, 뒷단어를 명사 (용어집)[https://www.python.org/dev/peps/pep-0008/]

# 선언할 때는 매개변수(parameter), 사용할 때는 인자(argument) (역할하고 행위가 다르다.)

• coding style

• EAFP: 허락보다는 용서를 구하기가 쉽다 (Easier to ask for forgiveness than permission). ex) try, except

• LBYL: 뛰기 전에 보라 (Look before you leap). ex) java, C

• 호출 (call)

def cho_beauty():  # Call 호출 
    return 

def cho_beauty(): 
    ''' 설명을 적는다. '''
    a = 1 

callable(moon_beauty) # True : 식 (함수, 개체)를 부를 수 있느냐? -> callable 

jupyter notebook HELP

• shift + tap -> 설명 보는 방법 2,4,8
• ?Name # 물음표를 앞 or 뒤
• Name?? # 물음표 2번 붙이면 설명도 보여준다.

• help(‘for’) # help 쳐도 보여준다

• command pallete: control + shift + p
• alt -> 동시에 여러개 선택할 수 있도록 해주는 것

8) 파라미터

• 파라미터 6가지 (암기) 1) 포지셔널 2) 키워드 3) 포지셔널 온리 4) 키워드 온리 5) 가변 포지셔널 6) 가변 키워드

def moon_beauty(a): 
    a = 1 
    
moon_beauty # function: __a__ 현재 작업하고 있는 타일에서 정의된 아이(?) 

def moon_beauty(a,b): # 인자 두개 넣어도 에러가 안난다. 다만 argument 도 2개로 바꿔야한다. 
    a = 1 

# 1) 포지셔널 방식 
moon_beauty(3,4) # 3 4

# 2) keyword 방식 : 매개변수 이름이 들어가는 것 
# 순서 바꿔써도 상관 없다. 
moon_beauty(b=3,a=4) # 4 3
    
def moon_beauty(a,b,c): 
    print(a,b,c)
    
moon_beauty(3,c=3,b=2) # 3 2 3 
moon_beauty(3,c=3,2) # 한번 키워드 쓰면 그 다음부터는 계속 keyword 방식으로 써야한다.
moon_beauty(3,c=3,a=4) # 키워드 방식 쓸 때 c가 없어서 개수가 안맞아서 에러가 난다.

# 파라미터에는 디폴트값을 둘 수 있다. 하지만 조심해야한다. - 디폴트 방식
def moon_beauty(a,b=0,c=3): 
    print(a,b,c)
    
def moon_beauty(a,b=0, 3):  # 디폴트 값은 뒤에서부터 차례대로 채워져야한다. 따라서 이거는 에러 
    print(a,b,c)    
    
def moon_beauty(a,b,c=0): # 아무것도 안쓰면 디폴트값이 들어간다. 따라서 키워드 값이 더 편하다. 왜냐하면 디폴트 값이 있기 때문이다. 
    print(a,b,c)

import pandas as pd

# 3) 키워드 온리 방식만 쓸 수 있도록 만들 수도 있다. 
def moon_beauty(*, a=0, b=0,c=0): # *: 다음부터는 positional 방식으로는 절대 집어넣을 수 없다. 
    print(a,b,c)
moon_beauty(a=3) # 3 0 0 : 키워드 방식으로 집어 넣어야한다. 

def moon_beauty(x=0,*, a=0, b=0,c=0): # *: 다음부터는 positional 방식으로는 절대 집어넣을 수 없다. 
    print(x,a,b,c)
moon_beauty(3) # 3 0 0 0    
    
# 4) POSITIONAL 온리 방법은 만들기가 좀 어렵다.
all # iterable , /: positional only 방식     

a=[1,2,'']
all(a) # False
all(iterable=a) # typeError -> no keyword arguments 

# 5) 가변 포지셔널 방식 (가변: 개수와 상관 없는 것)
def moon_beauty(*a): # * + 문자 
    print(a)
moon_beauty(1,2,3,) # (1, 2, 3) 인자 없이, 개수 상관 없이 넣는 방법이 가변 포지서녈 기법

# 평균 구할 때 개수마다 함수로 만들어야 한다. 하지만 이 방식을 쓰면 개수에 상관없이 받아서 쓰면 되니깐 좋다. 

def moon_beauty(*a): # * + 문자 
    print(sum(a))

sum # iterable, / : positional only 

moon_beauty(3,2,1,4,4,2) # 16


# 6) 가변 키워드 (가변: 개수와 상관 없는 것)
def moon_beauty(**a):
    print(a)
    
moon_beauty(a=3,b=2,c=4) # {'a': 3, 'b': 2, 'c': 4} 
# 엄청 많이 나온다. dictionary 형으로 나온다. 
# ex) import matplotlib.pyplot as plt

9) Argument (인자)

• *a # keywords가 포지셔널 방식으로 들어간다.
• **a # values가 keyword 방식으로 들어간다.

def moon_beauty(a,b,c):
    print(a,b,c)
a=[1,2,3]

moon_beauty(a[0],a[1],a[2]) # 1 2 3

# unpacking
moon_beauty(*a) # argument * 가 쪼개준다. 따라서 개수가 맞아야한다. : unpacking

a={'a':1,'b':2,'c':3}
moon_beauty(*a) # a b c : keywords가 포지셔널 방식으로 들어간다.
moon_beauty(**a) # 1 2 3 : values가 keyword 방식으로 들어간다.

a={'a':1,'c':3,'b':2}
moon_beauty(*a) # a c b
moon_beauty(**a) # 1 2 3

from star import * # * 3가지 비밀 (?) 
# %whos -> import sys, moon - module 파일이름으로 부른다. 
# __all__=['a'] # * 를 쳤을 때 import 되는 애를 지정할 수 있다. 문자열만 들어올 수 있다.
# _b 는 안나온다. 
# _b 는 private 처럼 쓸 수 있다.

오늘 ‘*’ 배운거 7…번 나옴
1) 할당 2) 키워드 온리방식 3) 가변 포지셔널 방식 4) 가변 키워드 방식 - dictionary 로 나온다. 5) argument : * 쪼개준다.(unpacking) - 키워드가 포지셔널 방식으로 들어감 6) argument : ** values가 keyword 방식으로 들어간다. 7) all=[‘a’] # * 를 쳤을 때 import 되는 애를 지정할 수 있다. 문자열만 들어올 수 있다.

• %whos # import sys, moon - module 파일이름으로 부른다.
• from moon import a
• moon.a

• ‘_b’ 는 private으로 %whos에 안뜬다. 8) [[1,2,3],[4,5]] # unpacking - for문, argument

• _b 하면 import name 하면 private으로 안나온다.

• unpacking 기법

[*[1,2,3],*[4,5]] # [1, 2, 3, 4, 5] list
{*[1,2,3],*[4,5]} # {1, 2, 3, 4, 5} set 
{*(1,2,3),*(4,5)} # {1, 2, 3, 4, 5} tuple
{*{1,2,3},*{4,5}} # {1, 2, 3, 4, 5} set 
{*{'a':1,'b':2}} # {'a', 'b'} dictionary 
{**{'a':1,'b':2}} # {'a': 1, 'b': 2} dictionary  <- backend 에서 쓴다. 
{**{'a':1,'b':2}, **{'a':3,'b':2}} # 뒤에 있는게 덮어버린다.  # dictionary, set, ->  {} 중복 안된다.
# {'a': 3, 'b': 2, 'd': 2}

10) lambda

• 선언을 하면 메모리가 올라간다.
• 메모리 소모 없이 일시적으로 쓸 수 있다.
• 함수이면서 식이다. (식: 하나의 값으로 표현할 수 있다)
• 따라서 할당할 수 있다.

(lambda : 1)() # 1 : colon 뒤에 있는 값은 리턴값 

def x():
    return 1
    
x = lambda :1    

a=3
4 if a>2 else 1 # 4 : 하나의 값으로 축약할 수 있다 -> 식이다.

b= 4 if a>2 else 1 # 할당할 수 있다. 
b # 4

• Argument에도 식을 넣을 수 있다.

def x(a):
    print(a)

x(3)
x(4 if a>2 else 1) 
x('' or 4) # or 쓰면 값이 하나 -> 따라서 식으로 넣을 수 있다.
x(lambda : 3) 
    
out:
3
4
4
<function <lambda> at 0x00000258A6B3B268>

-------------------------------
x(lambda :3 or 4)
x((lambda :3) or 4)
x(lambda : 3 if a>3 else 4)() # function 있으면 괄호를 써야한다.\

out:
<function <lambda> at 0x00000258A6C9CE18>
<function <lambda> at 0x00000258A6C9CE18>
<function <lambda> at 0x00000258A6C9CE18>

---

다음 강의 예고: 함수안에 함수를 넣는 것을 배운다

---

무단 배포 금지