먹고 기도하고 코딩하라

파이썬 문자열 / 리스트 / 딕셔너리 메소드 본문

Python

파이썬 문자열 / 리스트 / 딕셔너리 메소드

사과먹는사람 2021. 6. 23. 23:05
728x90
728x90

 

어느 언어를 배우든 문자열, 리스트, 객체(딕셔너리) 내장 메소드를 익히는 건 기본이라고 생각한다. 제일 많이 쓰기 때문에 잘 알아두면 필요할 때 검색하지 않고 바로바로 사용할 수 있기 때문에 외워도 좋겠다.

 

 

1. 문자열

  • str.count(target) -> Int : str 내 target이 등장하는 빈도, 즉 str에서 target의 개수를 세서 반환한다.
  • str.find(target) -> Int : str 내 target이 처음으로 등장하는 위치의 인덱스를 반환한다. target이 str 내에 존재하지 않을 경우 -1을 반환한다.
  • str.index(target) -> Int : str 내 target이 처음으로 등장하는 위치의 인덱스를 반환한다. find와 기본적인 기능은 똑같지만, index의 경우 target이 str 내에 존재하지 않을 때 ValueError를 발생시켜 프로그램을 중단시킨다.
  • str.upper(), str.lower() -> None : str 내 모든 문자를 대문자로 바꾸거나 소문자로 바꾸는 메소드이다.
  • str.replace(dest, target) -> None : str 내 모든 dest를 target으로 전부 바꾼다.
  • str.split() -> list : str을 공백 단위로 나눠 리스트로 내보낸다. 즉, split(' ') 할 필요 없이 그냥 split() 하면 된다. 만약 split 안에 문자가 있을 경우에는 해당 문자를 기준으로 앞뒤로 문자열을 나눠 리스트에 담는다. 만약, 줄 바꿈 문자 '\n'을 기준으로 split 하고 싶다면 str.splitlines()을 이용하라.
  • str.swapcase() -> str : str에서 대소문자를 반전한 문자열 복사본을 반환한다. 
  • (팁) str[::-1]을 쓰면 문자열을 거꾸로 뒤집을 수 있다.
  • str.ljust(width, char) -> str : 문자열 str의 맨 처음부터 문자열을 포함한 길이 width만큼 char로 채운다. 쉽게 말해, str을 먼저 쓰고 난 다음 width-len(str)만큼 char로 채우는 것이다. rjust는 이와 반대로 동작한다. (문자열 맨 끝부터) 
name = 'Jane';
print(name.ljust(10, '+'))
# Jane++++++
print(name.rjust(10, '+'))
# ++++++Jane

 

 

2. 리스트

  • list.sort() -> None : 리스트 요소를 순서대로 정렬한다. 이 때 sort 함수 인자 key로 정렬 함수를 줄 수 있는데, 정렬 함수가 없는 경우에는 숫자 오름차순, 알파벳 오름차순으로 정렬한다. 원본 리스트를 변경한다. 자매품으로 sorted()가 있는데, sorted는 파이썬 내장 함수로, 원본을 변경하지 않되 정렬한 결과를 return한다. list.sort()의 경우 return값은 None이다. 옵션으로 reverse를 줄 수 있는데, reverse=True로 하면 정렬을 하되 역순, 즉 내림차순으로 정렬한다. 기본값은 reverse=False 이다. 시간복잡도 O(nlogn). 파이썬의 sort 메소드는 내부적으로 팀소트(Tim sort)라는 효율적인 알고리즘을 사용하고 있다.
    • 추가적인 옵션으로 key=len(문자열 길이 기준 정렬), key=str.lower(대소문자 구분 없이 정렬) 등이 있다.
  • list.reverse() -> None : 리스트 요소를 역순으로 배열한다. 이 때 주의할 점은 정렬하는 것이 아니라 주어진 리스트를 단순히 뒤집는 것이다. list.sort()와 같이 자매품으로 reversed()가 있는데 reversed 역시 파이썬 내장 함수다. 원본을 변경하지 않고 뒤집은 결과를 ReverseIterator로 return한다. reversed()의 경우 return값은 None이다. 시간복잡도 O(n)
  • list.index(x) -> Int : 리스트에 x가 등장하는 첫 위치를 반환한다. 리스트에 x가 없을 경우 ValueError가 발생돼 프로그램이 중단된다.
  • list.insert(i, x) -> None : 리스트의 i번째 위치에 x를 삽입하는 함수이다. 리스트 중간에 값을 삽입하고 싶을 때 아주 좋은 함수이다. 시간복잡도 O(n)
  • list.remove(x) -> None : 리스트에서 첫 번째로 나오는 x를 찾아 삭제하는 함수이다.
  • list.pop() -> Object : 리스트의 마지막 요소를 삭제해 그 값을 return하는 함수이다. 시간복잡도 O(1)
  • list.pop(x) -> Object : 리스트의 x번째 위치의 요소를 삭제해 그 값을 return하는 함수이다. 시간복잡도 O(n)
  • list.count(x) -> Int : 리스트 내 x의 개수를 파악해 몇 개가 있는지 return하는 함수이다.
  • list.extend(list) -> None : 원래의 list에 인자로 전해진 list를 더하는 함수이다. list 원본을 변경한다. 
  • list[:] -> List : 메소드는 아니지만 리스트의 깊은 복사를 하고 싶을 때 이렇게 쓸 수 있다. 파이썬의 모든 변수는 레퍼런스이므로, 가변 객체인 리스트나 바이트를 복사할 때에는 깊은 복사를 해야 한다.

이건 참고용인데 리스트에서 조합을 구해야 할 때가 있다. 예를 들어 [1, 2, 3, 4, 5]가 있는데 3개씩 묶은 조합인 (1, 2, 3), (1, 2, 4), (1, 2, 5), ... (3, 4, 5) 이런 식으로 조합들이 필요하다면 쓸 수 있는 모듈로 permutations와 combinations가 있다.

itertools 라이브러리에 들어 있다.

lst = ['a', 'b', 'c', 'd', 'e']
from itertools import permutations
print(list(permutations(items, 3)))
# [('a', 'b', 'c'), ('a', 'b', 'd'), ('a', 'b', 'e'), ('a', 'c', 'b'), ('a', 'c', 'd'), ('a', 'c', 'e'), ('a', 'd', 'b'), ('a', 'd', 'c'), ('a', 'd', 'e'), ('a', 'e', 'b'), ('a', 'e', 'c'), ('a', 'e', 'd'), ('b', 'a', 'c'), ('b', 'a', 'd'), ('b', 'a', 'e'), ('b', 'c', 'a'), ('b', 'c', 'd'), ('b', 'c', 'e'), ('b', 'd', 'a'), ('b', 'd', 'c'), ('b', 'd', 'e'), ('b', 'e', 'a'), ('b', 'e', 'c'), 
('b', 'e', 'd'), ('c', 'a', 'b'), ('c', 'a', 'd'), ('c', 'a', 'e'), ('c', 'b', 'a'), ('c', 'b', 'd'), ('c', 'b', 'e'), ('c', 'd', 'a'), ('c', 'd', 'b'), ('c', 'd', 'e'), ('c', 'e', 'a'), ('c', 'e', 'b'), ('c', 'e', 'd'), ('d', 'a', 'b'), ('d', 'a', 'c'), ('d', 'a', 'e'), ('d', 'b', 'a'), ('d', 'b', 'c'), ('d', 'b', 'e'), ('d', 'c', 'a'), ('d', 'c', 'b'), ('d', 'c', 'e'), ('d', 'e', 'a'), ('d', 'e', 'b'), ('d', 'e', 'c'), ('e', 'a', 'b'), ('e', 
'a', 'c'), ('e', 'a', 'd'), ('e', 'b', 'a'), ('e', 'b', 
'c'), ('e', 'b', 'd'), ('e', 'c', 'a'), ('e', 'c', 'b'), ('e', 'c', 'd'), ('e', 'd', 'a'), ('e', 'd', 'b'), ('e', 'd', 'c')]

from itertools import combinations
print(list(combinations(items, 3)))
# [('a', 'b', 'c'), ('a', 'b', 'd'), ('a', 'b', 'e'), ('a', 'c', 'd'), ('a', 'c', 'e'), ('a', 'd', 'e'), ('b', 'c', 'd'), ('b', 'c', 'e'), ('b', 'd', 'e'), ('c', 'd', 'e')]

보다시피 차이가 있는데 combinations의 경우에는 같은 조합이지만 순서가 뒤집힌 것은 중복으로 처리해 반환하지 않는다는 것이다. permutations의 경우에는 ('a', 'b', 'c')와 ('c', 'a', 'b')를 따로 출력했지만 combinations는 ('a', 'b', 'c')가 있으면 ('b', 'a', 'c')나 ('c', 'b', 'a') 같은 건 없는 거다.

 

 

3. 딕셔너리

* 변하지 않는 불변값만 딕셔너리 키가 될 수 있다. 그렇기 때문에 리스트는 딕셔너리 키가 될 수 없다.

  • dict.keys() : dict의 key들만 모아서 dict_keys 객체로 돌려준다. dict.values() 역시 마찬가지이다.
  • dict.values() : dict의 value들만 모아서 dict_values 객체로 돌려준다.
  • dict.items() : dict의 key, value 쌍들을 튜플로 묶은 값을 dict_items 객체로 돌려준다. for 루프를 돌릴 때 쓰기 좋다.
dict1 = {'Oasis': 'UK', 'Green Day': 'US', 'Daft Punk': 'FR'}
for name, country in dict1.items():
  print('{} from {}'.format(name, country))
  
# Oasis from UK
# Green Day from US
# Daft Punk from FR
  • dict.clear() -> None : dict 안의 모든 key, value 쌍들을 삭제한다.
  • dict.get(key, default) -> Object : dict에서 key를 찾아 그 value 값을 반환한다. dict[key]라는 접근법도 물론 있지만, dict[key]를 썼을 때 key값이 없다면 에러가 나서 프로그램이 중단되는 반면 dict.get(key)를 쓰면 None을 반환하며 프로그램이 계속 이어진다. default 값을 넣어줄지 말지는 선택인데, 만약 해당 key가 dict에 없다면 돌려줄 기본값을 설정하는 옵션이다.
  • dict.copy() : 딕셔너리의 깊은 복사 방법이다.
  • dict.setdefault(key, default) -> Object : 딕셔너리 안에 어떤 키가 있는지 모를 때 사용하기 좋다. 만약 딕셔너리에 key가 있다면 키에 해당하는 값을 얻을 수 있고, 그렇지 않다면 새 키와 기본값 default가 딕셔너리에 저장된다.
# setdefault 사용 X
data = (('A', '4.0'), ('B', '3.0'), ('C', '2.0'))
dic1 = {}
for k, v in data:
  if k in dic1:
    dic1[k].append(v)
  else:
    dic1[k] = [v]

# setdefault 사용 O
dic2 = {}
for k, v in data:
  dic2.setdefault(k, []).append(v)

 

한편 collections 모듈에서 좀 더 다양한 딕셔너리 타입을 제공한다.

(1) default dictionary : dict와 여러 모로 비슷한데, default dictionary를 새로 생성할 때 인자로 타입을 줄 수 있다. 예를 들면 defaultdict(int) 이런 식으로 쓰면 값을 설정하지 않은 모든 key들에 대해 기본값인 0을 주게 된다. defaultdict(int)라고 int 타입만 value가 될 수 있는 건 아니고, 그냥 모든 key들에 대해 기본값이 int값이라는 의미이다. list, set, str 이런 식으로 자유롭게 타입을 줄 수 있어 사용하기 좋다. 

from collections import defaultdict
data = (('A', '4.0'), ('B', '3.0'), ('C', '2.0'))
dic1 = {}
for k, v in data:
  if k in dic1:
    dic1[k].append(v)
  else:
    dic1[k] = [v]

dic2 = defaultdict(list)	# 이 경우, 존재하지 않는 key에 접근했을 경우 [] 반환
for k, v in data:
  dic2[k].append(v)

 

(2) Ordered dictionary : 삽입 순서대로 항목을 저장하는 딕셔너리이다. 그런데 파이썬 3.7 이후부터는 기본 딕셔너리도 삽입 순서대로 항목을 저장하고 꺼내오는 것이 보장되기 때문에 이 용도 하나라면 굳이 쓸 필요는 없어 보인다.

from collections import OrderedDict
data = (('A', '4.0'), ('B', '3.0'), ('C', '2.0'))
dic1 = {}
for k, v in data:
  if k in dic1:
    dic1[k].append(v)
  else:
    dic1[k] = [v]

dic2 = OrderedDict()
for k, v in data:
  if k in dic2:
    dic2[k].append(v)
  else:
    dic2[k] = [v]

print(dic1) # {'A': ['4.0'], 'B': ['3.0'], 'C': ['2.0']}
print(dic2) # OrderedDict([('A', ['4.0']), ('B', ['3.0']), ('C', ['2.0'])])

 

(3) Counter : 카운터 타입은 iterable 객체를 받아 그 안의 요소들이 얼마나 있는지 개수를 세어 요소를 key로, 빈도를 value로 해서 카운터 딕셔너리를 만들어 돌려준다. most_common(n) 메소드를 쓰면 Counter 내에 n번째로 많이 등장하는 key를 찾아 return해준다.

from collections import Counter

def counter_example():
  seq1 = [1, 2, 3, 5, 1, 2, 5, 5, 2, 5, 1, 4]
  seq_counts = Counter(seq1)	# Counter 생성
  print(seq_counts)	# Counter({5: 4, 1: 3, 2: 3, 3: 1, 4: 1})

  seq2 = [1, 2, 3]
  seq_counts.update(seq2)	# Counter.update(iterable)로 추가 가능
  print(seq_counts)

  seq3 = [1, 4, 3]
  for key in seq3:
    seq_counts[key] += 1	# 이렇게 key로 접근해 추가도 가능
  print(seq_counts)

  seq_counts_2 = Counter(seq3)
  print(seq_counts_2)
  print(seq_counts + seq_counts_2)	# Counter 간 연산 가능
  print(seq_counts - seq_counts_2)
  
  print(seq_counts.most_common(1))	# [(1, 5)]

 

 

4. 셋

* 딕셔너리는 해시 테이블로 구현되어 있다. 셋(set)은 집합 개념이다. 리스트와 비슷하지만, 중복값을 허용하지 않아서 하나의 값은 항상 1개만 존재하는 자료구조다.

  • set & set -> set : set과 set의 교집합을 구한다. set.intersection(set)과도 동일하다.
  • set | set  -> set : set과 set의 합집합을 구한다. set.union(set)과도 동일하다.
  • set - set -> set : set에서 set을 뺀 차집합을 구한다. 교집합, 합집합 연산과 달리 set의 순서가 중요한 연산이므로 주의한다. set1.difference(set2)와 같다.
  • set.add(value) -> None : set에 value를 추가한다.
  • set.update(set) -> None : set에 인자로 주어진 set 안의 원소들을 추가한다. add와 비슷하지만, update의 경우 set을 인자로 받아 set 안의 중복되지 않은 값들을 한꺼번에 추가한다는 점이 다르다. set |= set 연산자와도 똑같다. union과 비슷하지만 연산자 왼쪽의 set이 합쳐진 set으로 변경된다는 점이 다르다.
  • set.remove(value) -> None : set에서 value를 제거한다. discard(value)를 써도 결과가 똑같지만, remove의 경우 value가 없을 경우 KeyError를 발생시킨다. 
  • set.copy() -> set : set의 깊은 복사를 하는 방법이다. 

 

 

5. 튜플

* 튜플(tuple)은 불변 리스트라고 생각하면 쉽다. 리스트와 달리 소괄호 ( )로 열고 닫는다.

  • tuple.count(x) -> int : tuple 안의 x 개수를 세서 반환한다.
  • tuple.index(x) -> int : tuple 안의 항목 x 인덱스 위치를 반환한다. 만약 x를 찾을 수 없다면 ValueError를 일으킨다.

 

 

 

References

 

728x90
반응형
Comments