[Python] 코딩테스트 풀 때 유용한 파이썬 함수 (1)

코딩테스트 풀 때 유용한 파이썬 함수 Counter, join, zip, lambda 4가지에 대해서 알아보겠습니다. 

 

1. Counter()

collections 모듈에 포함된 데이터 카운팅을 위한 클래스이므로 사용할 때 import 해주어야 한다.

주어진 데이터에서 요소들의 개수를 빠르게 세어주며 결과를 딕셔너리 형태로 반환한다.

주로 문자열, 리스트, 튜플 등 반복 가능한(iterable) 객체에서 요소의 빈도를 계산할 때 사용한다.

 

1.1 사용법 

• 입력: iterable 객체
• 출력: 각 요소의 개수를 담은 딕셔너리 형태

from collections import Counter

# 1. 문자열
counter1 = Counter("abcabc")
print(counter1)  # Counter({'a': 2, 'b': 2, 'c': 2})

text = "abcabc"
counter_1 = Counter(text)
print(counter_1) # Counter({'a': 2, 'b': 2, 'c': 2})

# 2. 리스트
counter2 = Counter([1, 2, 2, 3])
print(counter2)  # Counter({2: 2, 1: 1, 3: 1})

# 3. 딕셔너리
counter3 = Counter({'a': 3, 'b': 1})
print(counter3)  # Counter({'a': 3, 'b': 1})

# 4. 키워드 인자
counter4 = Counter(a=2, b=3, c=1)
print(counter4)  # Counter({'b': 3, 'a': 2, 'c': 1})

 

 

1.2 요소 접근

딕셔너리처럼 사용하면 된다.

counter = Counter("banana")

# 특정 요소의 개수
print(counter['a'])  # 3

# 없는 요소를 접근하면 0 반환
print(counter['z'])  # 0

 

 

1.3 메소드

• elements() : 요소를 개수만큼 반복(iterable 형태로 반환)

counter = Counter({'a': 2, 'b': 1, 'c': 0})
print(list(counter.elements()))  # ['a', 'a', 'b']

• most_common() : 가장 빈도가 높은 요소를 내림차순으로 반환

counter = Counter("banana")

# 상위 2개 요소
print(counter.most_common(2))  # [('a', 3), ('n', 2)]

• subtract() : Counter의 요소에서 다른 Counter 또는 iterable 값을 빼줌

counter = Counter(a=3, b=2)
counter.subtract({'a': 1, 'b': 3})
print(counter)  # Counter({'a': 2, 'b': -1})

• update() : Counter에 요소를 추가하거나 기존 값을 증가

counter = Counter(a=1, b=2)
counter.update({'a': 2, 'c': 1})
print(counter)  # Counter({'a': 3, 'b': 2, 'c': 1})

 

 

1.4 산술 연산

Counter 객체끼리 더하기, 빼기, 교집합, 합집합 연산이 가능하다.

c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=4)

# 덧셈
print(c1 + c2)  # Counter({'a': 4, 'b': 5})

# 뺄셈 (0 이하 결과는 제외)
print(c1 - c2)  # Counter({'a': 2})

# 교집합 (최소값)
print(c1 & c2)  # Counter({'a': 1, 'b': 1})

# 합집합 (최대값)
print(c1 | c2)  # Counter({'a': 3, 'b': 4})

 

 

 

2. join()

문자열 메서드로, 문자열의 리스트나 다른 반복 가능한(iterable) 객체를 하나의 문자열로 합칠 때 사용된다.

각 요소를 특정 구분자로 연결하며 간단하지만 매우 강력하고 유용하다.

 

2.1 기본 문법

• 구성
  • 구분자: 각 요소를 연결할 때 사용할 문자열
  • iterable: 문자열, 리스트, 튜플 등 반복 가능한 객체

"구분자".join(iterable)

•  특징
  • 요소(iterable)는 무조건 문자열이여야 한다. → 숫자나 다른 타입이 포함되어 있으면 TypeError 발생

 

2.2 사용 예시

# 1. 리스트 요소 합치기
words = ["Hello", "World", "Python"]
result = " ".join(words)
print(result)  # "Hello World Python"

# 2. 튜플 요소 합치기
words = ("Python", "is", "awesome")
result = "-".join(words)
print(result)  # "Python-is-awesome"

# 3. 문자열의 각 문자 연결
chars = "ABC"
result = ",".join(chars)
print(result)  # "A,B,C"

# 에러 발생
words = ["Hello", 123, "World"]
result = " ".join(words)  # TypeError

# 숫자 배열 처리
nums = [1, 2, 3]
result = "-".join(map(str, nums))  # 숫자를 문자열로 변환
print(result)  # "1-2-3"

 

 

 

3. zip()

여러 반복 가능한(iterable) 객체를 묶어서 튜플의 형태로 반환하는 함수이다.

각 iterable의 요소를 병렬로 묶어줌으로써 데이터를 효율적으로 처리하거나 변환하는 데 사용된다.

 

3.1 기본 문법

• *iterables: 두 개 이상의 반복 가능한 객체
• 반환: 각 iterable의 요소를 하나씩 묶은 튜플로 구성된 zip 객체

zip(*iterables)

 

3.2 특징

• 가장 짧은 iterable의 길이에 맞춰 결과를 반환한다. → 길이가 다른 iterable을 묶으면 짧은 쪽에 맞게 나머지는 무시
• zip 객체를 반환하므로 필요하면 list(), tuple()로 변환해야 한다.

zipped = zip([1, 2, 3], ['a', 'b', 'c'])
print(zipped)  # <zip object at 0x...>
print(list(zipped))  # [(1, 'a'), (2, 'b'), (3, 'c')]

 

3.3 사용 예시

# 1. 두 리스트 병렬로 묶기
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
result = zip(list1, list2)
print(list(result))  # [(1, 'a'), (2, 'b'), (3, 'c')]

# 2. 3개 이상의 iterable 묶기
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
list3 = [True, False, True]

result = zip(list1, list2, list3)
print(list(result))  # [(1, 'a', True), (2, 'b', False), (3, 'c', True)]

# 3. 리스트뿐만 아니라 문자열, 튜플, 집합 등 서로 다른 타입의 iterable 사용
str1 = "abc"
tuple1 = (1, 2, 3)
result = zip(str1, tuple1)
print(list(result))  # [('a', 1), ('b', 2), ('c', 3)]

• 딕셔너리 생성

keys = ['name', 'age', 'job']
values = ['Alice', 25, 'Engineer']
result = dict(zip(keys, values))
print(result)  # {'name': 'Alice', 'age': 25, 'job': 'Engineer'}

• 두 개 이상의 iterable을 병렬로 순회

names = ['Alice', 'Bob', 'Charlie']
scores = [85, 90, 95]

for name, score in zip(names, scores):
    print(f"{name} scored {score}")
# Output:
# Alice scored 85
# Bob scored 90
# Charlie scored 95

• 묶여 있는 데이터를 분리 (언패킹)

zipped = [('a', 1), ('b', 2), ('c', 3)]
unzipped = zip(*zipped)

list1, list2 = map(list, unzipped)
print(list1)  # ['a', 'b', 'c']
print(list2)  # [1, 2, 3]

 

 

 

4. lambda()

익명 함수(anonymous function)를 생성하는 데 사용되며 이름이 없는 함수로 간단한 작업을 한 줄로 처리할 수 있다.

일반적인 def 키워드로 정의한 함수와 비슷하게 동작하지만 코드가 간결하고 일회성으로 사용할 때 주로 쓰인다.

 

4.1 기본 문법

• arguments: 입력 인자, 여러 개의 인자를 쉼표로 구분
• expression: 반환할 값, 반드시 단일 표현식이어야 하며 결과 반환

lambda arguments: expression

 

4.2 특징

• lambda로 정의된 함수는 보통 이름이 없어 필요한 곳에서 즉석으로 정의하고 사용하며 주로 일회성 작업에 적합하다.
• 단일 표현식만 가질 수 있어 복잡한 작업이나 여러 줄의 코드는 사용할 수 없다.
• 표현식의 결과가 자동으로 반환되어 반드시 반환값 존재한다.
• 단점
  • 단일 표현식만 허용되므로, 복잡한 로직을 처리하기 어렵다.
  • 지나치게 많은 lambda 사용은 코드의 가독성을 떨어뜨릴 수 있다.
  • 이름이 없으므로 디버깅이 어렵다.

 

4.3 def 와 비교

# Using def
def add(x, y):
    return x + y

# Using lambda
add = lambda x, y: x + y

특징	lambda	def
이름	없음 (익명 함수)	함수 이름 필요
코드 길이	짧고 간결	여러 줄 가능, 더 유연
표현식 제한	단일 표현식만 가능	여러 줄 코드 가능
가독성	간결하지만, 복잡하면 가독성 저하	복잡한 로직 처리 가능, 명확
사용 목적	일회성 간단 작업	재사용 가능한 복잡한 작업

 

 

4.4 사용 예시

# 1. 두 숫자를 더함
add = lambda x, y: x + y
print(add(3, 5))  # 8

# 2. 다양한 함수와 함께 사용
    # map()
    nums = [1, 2, 3, 4]
    squared = list(map(lambda x: x**2, nums))
    print(squared)  # [1, 4, 9, 16]

    # filter()
    nums = [1, 2, 3, 4, 5, 6]
    evens = list(filter(lambda x: x % 2 == 0, nums))
    print(evens)  # [2, 4, 6]

    # sorted()
    pairs = [(1, 2), (3, 1), (5, 0)]
    sorted_pairs = sorted(pairs, key=lambda x: x[1])
    print(sorted_pairs)  # [(5, 0), (3, 1), (1, 2)]

# 3. 리스트 컴프리헨션에서 사용
nums = [1, 2, 3]
squared = [(lambda x: x**2)(x) for x in nums]
print(squared)  # [1, 4, 9]

# 4. 정렬 기준 지정
pairs = [(1, 'b'), (3, 'a'), (2, 'c')]
sorted_pairs = sorted(pairs, key=lambda x: x[1])
print(sorted_pairs)  # [(3, 'a'), (1, 'b'), (2, 'c')]