📂 python advanced (1)

---

📝 python

---

---

📌 method

---

* sorted(,key = lambda x:(x,y)) 받을 변수를 x 즉 첫번째 경우를 기준으로 정렬
  그 만약 정렬후 값이 같은게 있으면 두번째 y에 대해서 정렬 시킨다.
* replace() : 문자열을 교체하는 메서드, 대체자로 정수가 나오면 안됨 정수면 replace(a,str(b) 해야함
* replace() : 메서드는 원래 문자열을 수정하는 것이 아니라 새로운 문자열을 반환 하는 것임
* format() : 숫자를 다른 진수의 문자열로 바꿀시 사용
  - format(42, '#b') # '0b101010'
  - format(42, '#o') # '0o52'
  - format(42, '#x') # '0x2a'
  - format(42, '#X') # '0X2A'
* int(a,2) : 2진수인 문자열 a 를 십진수로 전환
  - int('0b101010',2) # 42
  - int('0o52', 8)    # 42
  - int('0x2a', 16)   # 42
* bin(a) : 십진수를 2진수로 전환 0b포함 그래서 [2:] 하면 이진수만 출력
  - bin(42) # '0b101010'
  - oct(42) # '0o52'
  - hex(42) # '0x2a'
  - bin(0b101010) # '0b101010'
  - oct(0b101010) # '0o52'
  - str(0b101010) # '42'
* s.find('123') : '123'이 있는 인덱스 번호 반환(문자열시작점)
* s.index('123') : 동일
* sum() : 숫자형 리스트,튜플 에서 값 반환 가능
* index() : 어떤 타입에서도 사용 가능 문자열,리스트,튜플,range,... 인덱스가 없으면 에러발생
  - array.index(x) : x 의 인덱스 반환
  - array.index(x,start) : start 부터 인덱스 반환
  - array.index(x,start,stop) : start 부터 stop x의 인덱스 반환 (stop-1)
* strip() : 양쪽 공백만 지워지고 사이공백은 안지워짐
* split() : 공백을 기준으로 나뉘는데 공백이 겹쳐도 같이 지워준다 . 
            (' ') 이렇게 사용해야 하나의 공백만 해서 나뉜다. 양쪽 공백도 제거됨
* ord(문자) : 해당 문자를 유니코드 정수로 반환
* chr(정수) : 0~1,114,111 정수를 해당 문자로 반환
* filter(조건, 순회 가능한 데이터) : 조건에 맞는 값만 반환 시키는 함수 
* map(적용할 함수,iterable) : 함수를 적용시켜서 반환 ,list(map()) 이런식으로 해야 값이 나옴
* sum() :list = [[1],[2,3]]
		 sum(list,[])
         return [1,2,3]
* pop() : 인덱스 지정 ,미지정시 마지막 삭제 , 객체로 반환!!
* remove() : 값지정해서 삭제 , 해당 값이 없으면 valueError
* __doc__ : 주석을 보는 함수
* 재귀함수 :
```
def factorial(n):
	if n == 1 : # n<2
    	return 1
    return n * factorial(n-1)
# n*n 이차원 배열만들기
def solution(n):
	answer=[[0]*n for _ in range(n)]
	for i in range(n): answer[i][i]=1
	return answer

* all() 함수 : 안에 조건이 모두 만족할 경우 참을 반환 
				def solution(arr):
   					return int(all(arr[i][j] == arr[j][i] for 
                    i,v in enumerate(arr) for j in range(len(v))))
* 2차원 배열에서의 sort() 함수
		
      * sort() 함수는 기본적으로 리스트의 첫번째 요소를 기준으로 정렬한다. 하지만
        key 함수를 사용하면 정렬기준을 변경 할 수 있다.
        key = lambda x : x[1] 은 열의 두번째 값을 기준으로 정렬하겠다. # 즉 기본적인 첫번째에서
        2번쨰 값을 기준으로 정렬하겠다 라고 하는것임
      * 딕셔너리의 경우 .items() 를 사용하여 사용가능 x[1] 은 딕셔너리의 벨류 의미
	sorted_data = sorted(data.items(), key = lambda x : x[1] 

---

📌 copy

---

• import copy

• 얕은 복사 (shallow copy) : [:] ,copy()
  • 새로운 객체를 생성
  • 원본 객체를 참조 (같은 메모리 주소)
  • 데이터 독립성 낮음 (내부 객체는 원본과 연결)
    • list타입에서 1차원 배열은 얕은 복사만으로 비교가 가능하지만 2차원이상의 배열에선
      1차원까지의 틀만 복사한 것이고 2차원 내부의 값들은 전체가 다같이 영향을 받아 비교하기 어려움
• 깊은 복사 (deep copy) : copy.deepcopy()
  • 새로운 객체를 생성
  • 독립적인 새로운 객체 생성
  • 독립성 높음 (모든 수준에서 독립)

---

📌 Sequence

---

• 순서가 있는, 재할당이 가능한, 수정이 가능한, 변경이 가능한, 삭제도 가능한
• 다양한 메소드나 자료 구조 형태의 레퍼런스

* 지능형 리스트 (Comprehending list) : [(,) if,for~~if~]
	- 매개변수 선언시 값 할당 가능 : code = [i for i in chars]
    
* Geneartor : ()
	- 게으른 계산 : 값을 한꺼번에 생성하지 않고 필요할 때만 계산하고 반환
    - 메모리 효율적
    - __iter__(),__next__() : 메서드 제공
	- 다음에 반활할 값만 가지고 있음
	- 한번에 한개의 항목을 생성 (메모리 유지 x)
    - yield 키워드를 사용하여 필요할 때마다 값을 생성하는 함수
	a = (ord(s) for s in chars)  # 반환 준비 상태
    print(next(a)) # 값을 한번씩 반환시킴 1,5,2,3 이 있으면 현재 1이 출력되는 상태
* dict : hash 값 존재
	- key 값 -> 해쉬주소 -> key 에 대한 value 참조
       + 가변형인 것은 고유의 해시값을 가지고 있지 않다.
       
  

---

📌 일급 함수

---

1. 런타임 초기화
2. 변수 할당 가능
3. 함수 인수 전달 가능
4. 함수 결과 반환 가능(return)

* callable : 호출 연산자 -> 메소드 형태로 호출이 가능한지 확인
  __call__ 이라는 인자가 있으면 함수를 호출 할 수 있음
  print(callable(str),callable(a)) -> True,True
* partial(함수,고정할 값) : 인수를 고정시키는 함수 ,from functools import partial
  - ex ) from operator import mul
  		 from operator import partial
         five = partial(mul,5) 
         six = parital(five,6) # 이렇게 2번 고정시키면 호출만 가능해진다 고정됨
         print(five(10) -> 10 * 5 = 50

---

📌 closure 함수

---

1. 외부에서 호출된 함수의 변수값,상태(레퍼런스)를 복사 후 저장 하는 역할 -> 저장후 접근(엑세스) 가능
2. 클로저는 공유하되 Immutable, 변경사항을 전달 할때도 사용
3. 불변자료구조 및 atom(원자성), STM -> 멀티스레드(coroutine) 프로그래밍에 장점
4. 자유영역에서 자유변수를 저장하고 있음, 해당영역의 상태를 기억!!

# 클래스로 클로져 구현
class Averager() :
	def __init__(self) :
    	self._series = []
    def __call__(self,v) : #클래스를 함수처럼 선언 할 수 있게 해주는 매직매소드
    	self._series.append(v)
        print(f'{self._series} / {len(self._series}')
        return sum(self._series) / lens(self._series)
 cls = Averager()
 print(cls(10)) # [10] / 1 , 10.0
 print(cls(30)) # [10,30] / 2 , 20.0
 print(cls(50)) # [10,30,50] / 3 , 30.0 
 # 자유영역에 있는 series 에 게속 저장 시킴

# 클로져 구현
def closure_1() :
	# Free variable : 자유 영역,클로저 영역
	series = []
   def averager(v) :
   	series.append(v)
       print(f'{series} / {len(series)})
       return sum(series) / len(series)
   return averager
cls = closure_1()
print(cls(10))
print(cls(30))
print(cls(50)) # 동일 결과

# 잘못된 클로저 사용
# 파이썬의 변수 범위 규칙에 따라 함수 내부에서 지역변수를 먼저 찾음 그래서 클로저 영역에 도달을 안함 + 에러표시
def closure_2() :
	# 자유영역
	cnt = 0 
    total = 0
    def averager (v) :
    	cnt += 1 # 이 줄에서 새로운 지역변수가 잡히기에 자유영역에서의 cnt가 영향을 못받음
        total += v
        return total / cnt
    return averager 
    # 오류 발생 

# nonlocal 사용
def closure_3():
	cnt = 0 
    total = 0
    def averager(v) :
    	nonlocal cnt,total # 지역변수 아니다 선언
        cnt += 1
        total += v
        return total / cnt
    return averager
cls3 = closure_3()
print(cls3(10)) # 10.0
print(cls3(30)) # 15.0
print(cls3(50)) # 20.0

---

📌 Decorator

---

• 장점
  1. 중복제거, 코드간결, 공통 함수 작성
  2. 로깅, 프레임워크, 유효성 체크 -> 공통기능
  3. 조합해서 사용 용이
• 단점
  1. 가독성이 떨어질 수 있음
  2. 특정 기능에 한정된 함수는 -> 단일 함수로 작성하는 것이 유리할 수 있음
  3. 디버깅 불편

import time

def perf_clock(func) : # fucn 함수를 자유변수로 사용
	def perf_clocked(*args)
    	# 함수 시작 시간
        st = time.perf_counter()
        # 실행
        result = func(*args)
        # 종료시간
        et = time.perf_counter() - st
        # 실행 함수명
        name = func.__name__
        # 함수 매개변수
     	arg_str = ', '.join(repr(arg) for arg in args)
        # 결과 출력
        print('[%0.5fs] %s(%s) -> %r' % (et,name,arg_str,result))
        return result
    return perf_clocked
    
# 데코레이터 미사용
def time_func(seconds) :
	time.sleep(seconds)
def sum_func(*numbers) :
	return sum(numbers)
 
no_deco1 = perf_clock(time_func)
no_deco2 = perf_clock(sum_func)
no_deco1(1.5) # [1.50131s] time_func(1.5) -> None
no_deco2(100,200,300,400,500) # [1.50169s] perf_clocked(1.5) -> None

# 데코레이터 사용
@perf_clock
def time_func(seconds) :
    time.sleep(seconds)
    
@perf_clock
def sum_func(*numbers) :
    return sum(numbers)
time_func(1.5) # 자동으로 데코레이터 된 함수가 같이 사용된다
sum_func(100,200,300,400,500)

---

✨ Tip

---

* for문 dict for key, value in mydict.items()
* sort 함수 기본 정렬은 key 이다 딕셔너리에서
* 딕셔너리에서 key 인자로 dict.values() 를 사용 할 순 없다. 그래서 
   - sorted(dict.items(), key =lambda x: x[1]) 이런식으로 해야한다.
* list comprehension : 기본적으로 리스트를 간결하고 효율적으로 생성하기 위한 문법
  - [표현식 for 항목 in 반복 가능한 객체 if 조건문] : 표현식 -> 리스트에 추가할 값이나 계산식
  
* 조건문에서 빈 공백열을 제거하고 싶을때 : i for i in a if i : if i 빈리스트면 false 니까 넘겨주지 않는다
* []*(음수) : 빈배열 로  
* *unpacking : 하나 푸는것
	- print(divmod(10,9),divemod(*(10,9)) -> (1,1)
      print(*divmod(10,9) -> 1,1
	- x, y, *rest = range(5) => x=0, y=,1 rest = [2,3,4]
    - x, y, *rest = range(2) => x=0, y=1, rest= []
* tuple = tuple * 2 ,list => list * 2 -> 둘다 id 값 변함
* tuple *= 2 , list *= 2  => 튜플은 불변이라 id 값이 변하고 list 는 가변이라 id 값이 변하지 않는다
  파이썬은 오른쪽 행을 먼저 계산하기에 위 식은 list 에 id 를 반환시키는 것이고 밑 식의 list 에는 새로운 
  id 를 할당 하지 않는다.
* 컴프리핸션을 사용하여 딕셔너리를 만들면 덮어쓰는 개념으로 된다. 한 키의 값에 여러개를 넣을때 사용 x
	dict1 = { k : v for k ,v in source}
	print(dict1) # {'k1': 'val2','k2':'val5'}
* 반복문 for 을 사용해서 리스트 안에 있는 요소를 제거 하는 경우 복사를 해서 사용해야한다
  그렇지 않으면 요소를 건너 뛰는 경우가 발생
  for i in list :
	remove(i) -> 건너뛰어진다
  for i in list[:] : —>> 이렇게 복사본을 사용해서 실행시키자!!
* list(Str) 하면 list 안에 문자열 하나하나가 넣어짐
* 문자열도 in 을 사용하여 따로 때내지않고 안에 있는 것을 찾을 수 있음
* 문자열도 슬라이싱 가능 :[:]
* 새로운 행을 추가할 떄 이미 행이 실행되서 그행이 잘못 계산되서 실행되는것 조심

for v in arr :
            v.extend([0] * (len(arr)-len(arr[0]))) # 이렇게 써버리면 그다음에 0이안드가고 빈배열이 드감 이미 추가되서 길이가 늘어났으니까
for v in arr :
            v.extend([0] * (len(arr)-len(v)))

* iter(호출가능한객체,반복을끝낼값) : 
  - iter_X = iter([1,2,3,4])
  - print(list(iter_x)) -> [1,2,3,4]
  - print(list(iter_x)) -> []
  - 주로 next 함수랑 같이씀 next 는 iterator 의 값을 순서대로 하나씩 꺼내주며 더이상 없을떄 stopiteration 에러를 발생
* 리스트 컴프리핸션 은 모든데이터를 한번에 로드
* 제너레이터는 데이터를 하나씩 생성하여 메모리 사용 최소화