이것저것 공부기록

zip()

- iterable의 같은 인덱스 원소를 묶어서 튜플로 변환

- 가장 짧은 iterable 기준으로 동작

- zip(iterable1, iterable2, ...)

- 시간복잡도 O(n), 공간복잡도 O(1)

- zip 객체는 1회성으로 z=zip(a,b)로 선언했다면 첫 list(z) 이후 list(z)는 빈 결과를 return

a = [1, 2, 3]
b=['a', 'b', 'c']

list(zip(a,b)) #[(1,'a'),(2,'b'),(3,'c')]

 

 

아래 3개중 뭐가 효과적일까?

- 시간복잡도는 O(n)으로 모두 같지만 solution1은 공간복잡도에서 O(n)으로 나머지 O(1)것에 비해 list를 생성함에 따라 비효율적임

- solution3은 count()가 시간복잡도가 O(n)으로 4번 반복해 상대적으로 오랜 시간이 요구

def solution1(n, control):
    key = dict(zip(['w','s','d','a'], [1,-1,10,-10]))
    return n + sum([key[c] for c in control])

def solution2(n, control):
    answer = n
    c = { 'w':1, 's':-1, 'd':10, 'a':-10}
    for i in control:
        answer += c[i]
    return answer

def solution3(n, control):
    answer = n + control.count('w') * 1 + control.count('s') * (-1) + control.count('d') * 10 + control.count('a') * (-10)
    return answer

 

P.S 최적화 측면에서는 아래와 같이 수정가능함

def solution_fast(n, control):
	c = {'w':1, 's':-1, 'd':10, 'a':-10}
    return n + sum(map(c.get, control)

-> map()

   - map(함수, iterable)형태로 사용하며 iterable의 각 원소에 함수를 적용함

-> get

   - dict.get(key, default)가 기본형태로 key가 없으면 키 없으면 None을 return

   - 만약에 c.get('x', 0)의 형태로 사용하면 키가 없으면 0을 반환

 

swapcase()

- str.swapcase()의 형태로 사용하며 문자열의 대문자는 소문자로, 소문자는 대문자로, 그 외 문자는 그대로 둠

- 동작원리는 if, elif, elif로 한 문자씩 upper인지 lower인지 확인해 시간복잡도 O(n), 공간복잡도 O(n)

- s.swapcase()한다고 변경되는게 아니라 s = s.swapcase()로 s에 할당해야 s가 변경됨

- 일부 유니코드에서 문자는 길이가 바뀔 수 있음

 

ord()

- ord(c)로 사용함

- 문자를 유니코드 정수 코드포인트로 바꿔주는 함수. 단, 문자열 길이는 반드시 1이어야함

- 시간복잡도와 공간복잠도 모두 O(1)임

 

문자열 my_string에서 index num1번째와 num2번쨰 문자 바꿀때 3번쨰 줄 역할은?

def solution(my_string, num1, num2):
    s = list(my_string) #문자열 -> 리스트
    s[num1],s[num2] = s[num2],s[num1] #두 문자 교환 / num1 위치의 문자와 num2 위치의 문자를 swap
    return ''.join(s) #리스트 -> 문자열

 

약수 구하기

def get_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5) + 1):
        if n % i == 0:          # i가 약수면
            divisors.append(i)
            if i != n // i:     # i와 n//i가 다르면 짝 약수도 추가
                divisors.append(n // i)
    return sorted(divisors)

 

join()

- 구분자.join(iterable) 형태로 사용하며 iterable을 구분자로 이어 붙여 하나의 문자열 생성

- 문자열 연결은 +보단 join()이 빠름

- 시간복잡도 공간복잡도 모두 O(n)

 

startswith()

- str.startswith(prefix[, start[,end]]) 형태로 사용하며 문자열이 특정 접두사로 시작하는지 확인해 True/False를 return

  ㄴ prefix(접두사) = 문자열의 앞부분

- 여러 접두사 체크도 가능 'file.txt'.startswith(("img", "file"))은 True를 return함

- 범위 지정도 가능해 "abcdef".startswith("cd", 2) 는 True를 return

- 시간 복잡도 O(k) #prefix 길이, 공간복잡도 O(1)

def solution(my_string, is_prefix):
    return int(my_string.startswith(is_prefix))

 

replace()

- str.replace(old, new[,count])형태로 사용하며, 문자열에서 old를 new로 치환

- "banana".replace("a", "o", 2)면 'bobona'로 치환됨

- 시간복잡도와 공간복잡도 모두 O(n)

 

int()랑 // 중에 뭐가 빠를까? //가 빠름

-> //는 한 번 연산 하지만 int()는 나눗셈과 함수 호출이 포함됨

 

lstrip()

- str.lstrip([char])의 형태로 사용하며 문자열 왼쪽에서 지정한 문자를 제거함

- 시간복잡도 O(n), 공간복잡도 O(n)

- rstrip, strip과 구분해 사용해야함

 

abs()

- abs(x)의 형태로 사용하며 숫자의 절댓값을 반환함
- abs(3+4j) 는 5를 return하는데 복소수

- O(1)의 시간복잡도와 공간복잡도

 

eval() -> 실무에서는 안쓰나?

-> 보안 위험으로 사용 안함. eval()은 임의 코드 실행이 가능해서 보안적 취약이 발생함

 

재귀로 각 자릿수 더하기

-> 재귀함수는 함수 호출 비용이 크고 재귀 깊이 제한, 스택 오버플로 위험으로 대부분의 경우에서 비효율

-> 실무에서는 반복문, DP(동적 계획법)을 사용하거나 재귀가 좋은 경우 "트리, DFS, 분할정복(깊이가 얕을 떄) 사용 권장

def sum_digit(number):
    '''number의 각 자릿수를 더해서 return하세요'''
    if number < 10:
        return number

    return number%10 + sum_digit(number//10)

 

iterable이란?

- for문으로 하나씩 꺼낼 수 있는 객체

- list, tuple, str, set, dict, range 같은게 있음