변수 타입

숫자

• int
  • 0b11 : 2진수 (Binaray)
  • 0o17 : 8진수 (Octagonal)
  • 0x1F : 16진수 (Hexagonal)
• float
• complex
  • complex(1, 2)
  • 1 + 2j

문자열

• str

bool

• bool
  • True
  • False

List

• list
• Literal
  • [1,2,3]

Tuple

• tuple
• Literal
  • (1,2,3)

Set

• set
• Literal
  • {1,2,3}

Dictionary

• dict
• Literal
  • {“a”: 1, “b”: 2, “c”: 3”}

문자열 Formatting

1. %-formatting

arr=[1,2,3]
print("%s %s %s" % (arr[0], arr[1], arr[2]))

truple=(1,2,3)
print("%s %s %s" % truple)

2. format()

name = "rolroralra"
age = 20
print("Hello, {}. I am {}.".format(name, age))
print("Hello, {1}. You are {0}.".format(age, name))

person = {'name': 'Eric', 'age': 74}
print("Hello, {name}. You are {age}.".format(name=person['name'], age=person['age']))

# You can also use ** to do this neat trick with dictionaries
print("Hello, {name}. You are {age}.".format(**person))

3. F String Format

print(f"Hello, {name}. You are {age}.")

Comprehension

Python에서 "comprehension"은 특정한 컨테이너에서 파생된 새로운 컨테이너를 만들기 위해 한 줄의 간결한 코드를 사용하는 구문입니다.

이는 리스트(list), 세트(set), 딕셔너리(dictionary) 등 여러 종류가 있으며, 코드를 보다 간단하고 읽기 쉽게 만들어줍니다.

각 컨테이너 타입에 따라 약간씩 문법이 다를 수 있습니다.

List Comprehension

• [x * 2 for x in range(10)]

Set Comprehension

• {(i, j) for i in range(10) for j in range(i, 10)}

Dict Comprehension

• {f"{i}+{j}": i + j for i in range(10) for j in range(i, 10)}

Generator Expression

• gen = (x * x for x in range(10)) for i in enumerate(gen, start=0): print(i)

Generator 의 장점

Generator 사용 예시 코드

이 코드는 제너레이터 표현식을 사용합니다.

all(column in df.columns for column in ["sex_male", "sex_female"])

• 제너레이터 표현식을 사용합니다.
• all 함수는 제너레이터에서 생성된 값을 순차적으로 평가합니다.
• 첫 번째 False 값을 만나면 즉시 평가를 중단합니다. 따라서, 필요 이상으로 df.columns를 반복하지 않습니다.
• 메모리 효율적입니다.

List Comprehension 사용 예시 코드

이 코드는 리스트 컴프리헨션을 사용합니다.

all([column in df.columns for column in ["sex_male", "sex_female"]])

• 리스트 컴프리헨션을 사용합니다.
• all 함수는 리스트 컴프리헨션에서 생성된 리스트를 받아 평가합니다.
• 리스트의 모든 요소를 먼저 생성한 후에 평가를 시작합니다. 따라서, 모든 요소를 평가해야 합니다.
• 메모리를 더 많이 사용합니다.

차이점 요약

1. 메모리 사용량:
   • 코드 1 (all(column in df.columns for column in ["sex_male", "sex_female"])): 제너레이터 표현식을 사용하므로 메모리 효율적입니다.
   • 코드 2 (all([column in df.columns for column in ["sex_male", "sex_female"]])): 리스트 컴프리헨션을 사용하므로 리스트를 미리 생성하여 메모리를 더 많이 사용합니다.
2. 평가 방식:
   • 코드 1: 제너레이터 표현식은 첫 번째 False 값을 만나면 즉시 평가를 중단합니다.
   • 코드 2: 리스트 컴프리헨션은 리스트의 모든 요소를 생성한 후에 평가를 시작합니다.

결론

일반적으로 코드 1 (all(column in df.columns for column in ["sex_male", "sex_female"]))이 더 효율적이며, 특히 대규모 데이터에 대해서는 제너레이터 표현식을 사용하는 것이 좋습니다. 이는 메모리 사용량을 줄이고, 평가를 더 빠르게 끝낼 수 있는 장점이 있습니다.

Python 에서 withIndex 방법 = Enumerate 함수

1. Enumerate 함수 활용

arr = [2, 7, 10]
for idx, val in enumerate(arr):
    print(idx, val)

# Output:
# 0 2
# 1 7
# 2 10

2. index 변수 직접 추가

arr = [2, 7, 10]
for idx in range(len(arr)):
    print(idx, arr[idx])

# Output:
# 0 2
# 1 7
# 2 10

String 내장 함수

String 내장 함수	설명
count(x: str, start, end)	문자열 내의 특정 문자 개수
join(itreable: Iterable[str])	Iterable[str] 문자열 조인
find(x: str, start, end)	찾는 문자열이 처음 나온 인덱스를 반환
rfind(sub: str, start, end)	끝에서부터 찾는 문자열이 처음 나온 인덱스를 반환
upper()	소문자를 대문자로 변환
lower()	대문자를 소문자로 변환
swapcase()	소문자는 대문자로, 대문자는 소문자로
replace(old, new, count)	문자열 내의 특정 값을 다른 값으로 치환
split(sep, maxsplit)	특정 문자를 구분자로 문자열 분리
startswith(prefix, start, end)	특정 문자열로 시작하는지 확인
endswith(suffix, start, end)	특정 문자열로 끝나는지 확인

Python 내장 함수

내장함수명	설명
help()	함수, 클래스 document 출력
dir()	내부 구성 멤버 목록
print()	출력
input()	키보드 입력
range()	정수 범위 설정
list()	리스트 생성
abs()	절대값
len()	모든 오브젝트의 길이를 구함
round()	반올림
type()	데이터의 자료형을 반환
sum(iterable: Iterable)	합산
min(arg1, arg2, *args, key: function)	최소값
max(arg1, arg2, *args, key: function)	최소값
pow(base: int, exp: int)	x 의 y 제곱
sorted(iterable, key=None, reverse=False)	iterable 컨테이너 정렬

List 객체의 Method 목록

함수명	설명
extend(iterable: Iterable) → None	배열에 배열을 추가 확장
append(object) → None	배열 끝에 원소 추가
sort(key: function, reverse: bool) → None	정렬
reverse() → None	뒤집기
index(value: T, start=0, stop=…) → int	값이 동일한 첫번째 인덱스 리턴
insert(index: int, value: T) → None	삽입
remove(value: T) → None	첫번째 동일한 값을 삭제
count(value: T) → int	동일한 값의 개수 리턴

Slice 객체

파이썬에서 슬라이스 객체는 리스트, 튜플, 문자열 등의 시퀀스(순서가 있는 데이터 타입)를 슬라이싱할 때 생성됩니다.

슬라이스 객체는 슬라이싱 연산을 표현하는데 사용되며, 해당 시퀀스의 부분집합을 선택할 때 사용됩니다.

슬라이스 객체는 시작(start), 끝(stop), 간격(step) 세 가지 요소로 구성됩니다.

• start
  • 슬라이스의 시작 인덱스를 반환합니다.
• stop
  • 슬라이스의 끝 인덱스를 반환합니다.
• step
  • 슬라이스의 간격(스텝)을 반환합니다.

Slice 객체 메서드

• indices(len: int) -> Tuple[int, int, int]
  • 주어진 길이(length)에 맞춰 슬라이스의 유효한 인덱스(start, stop, step) tuple를 반환합니다. 이 메서드는 음수 인덱스를 처리하고 범위를 벗어나는 인덱스를 조정합니다.

코드 예시

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
my_slice = slice(0, 5, 2)
result = my_list[my_slice]
print(result)  # 출력: [0, 2, 4]

Lambda

lambda arguments: expression

• arguments는 매개변수
• expression은 해당 매개변수를 이용하여 계산되는 표현식

코드 예시

my_list = [1, 2, 3, 4, 5]
result = map(lambda x: x * 2, my_list)
print(list(result))  # 출력: [2, 4, 6, 8, 10]

Java Stream 과 유사한 내장 함수

map

• 리스트의 각 요소에 함수를 적용하여 새로운 리스트를 생성합니다.

my_list = [1, 2, 3, 4, 5]
new_list = list(map(lambda x: x * 2, my_list))
# 출력: [2, 4, 6, 8, 10]

filter

• 주어진 함수의 조건을 만족하는 요소만을 선택하여 새로운 리스트를 생성합니다.

my_list = [1, 2, 3, 4, 5]
new_list = list(filter(lambda x: x % 2 == 0, my_list))
# 출력: [2, 4]

functools.reduce

• 리스트의 요소를 왼쪽부터 오른쪽으로 이진 연산하여 하나의 값으로 축소합니다.
• Python 3부터는 functools 모듈에서 제공됩니다.

from functools import reduce
my_list = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, my_list)
# 출력: 15 (1 + 2 + 3 + 4 + 5)

functools

functools 모듈은 Python의 내장 모듈 중 하나로, 함수형 프로그래밍을 지원하는 몇 가지 유용한 함수를 제공합니다.

partial

• 함수의 일부 인수를 고정하여 새로운 함수를 생성합니다.
• partial(func, *args, **keywords)

from functools import partial

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

add_five = partial(add, 5)
print(add_five(3))  # 출력: 8

reduce

• 시퀀스의 요소를 왼쪽부터 오른쪽으로 이진 연산하여 하나의 값으로 축소합니다.
• reduce(function, iterable[, initial]) -> value

from functools import reduce

my_list = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, my_list)
print(result)  # 출력: 15

lru_cache

Least Recently Used

• 함수 호출 결과를 캐시하여 이전에 호출된 인수에 대해 결과를 재사용합니다.
  • 이는 함수 호출의 성능을 향상시킬 수 있습니다.

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    print(f"called fib({n})")
    
    if n <= 1:
        return n
    
    return fib(n-1) + fib(n-2)

print(fib(10))  # 출력: 55
print(fib(11))
print(fib(5))

wraps

• 데코레이터를 작성할 때 함수의 메타데이터를 보존합니다.

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print('데코레이터 실행 전')
        result = func(*args, **kwargs)
        print('데코레이터 실행 후')
        return result
    return wrapper

@my_decorator
def example_function():
    """예제 함수입니다."""
    print('함수가 실행됨')

print(example_function.__name__)  # 출력: example_function
print(example_function.__doc__)   # 출력: 예제 함수입니다.

cmp_to_key

• 이전 버전의 Python에서 사용되던 비교 함수를 키 함수로 변환합니다.
  • 이는 sorted() 함수와 같은 함수에 사용됩니다.

from functools import cmp_to_key

my_list = ["apple", "banana", "orange"]
sorted_list = sorted(my_list, key=cmp_to_key(lambda x, y: len(x) - len(y)))
print(sorted_list)  # 출력: ['apple', 'banana', 'orange']

Generator, Iterator

Generator와 Iterator는 둘 다 파이썬에서 반복 가능한(iterable) 객체를 다루는 데 사용됩니다.

그러나 두 가지는 다른 개념입니다.

Iterator(이터레이터):

• Iterator는 반복 가능한 객체(iterable)의 요소에 접근할 때 사용되는 객체입니다.
• __iter__()와 __next__() 메서드를 구현한 객체입니다. __iter__()는 이터레이터 자신을 반환하고, __next__()는 다음 값을 반환합니다.
• 예를 들어, 리스트, 튜플, 딕셔너리 등의 자료구조에서는 iter() 함수를 호출하여 이터레이터를 얻을 수 있습니다.

iter 함수

• Python의 내장 함수 중 하나로, iterable 객체를 받아 iterator를 반환합니다.
• 이터레이터는 __next__() 메서드를 갖고 있어서 반복할 때마다 다음 값을 반환하고, 더 이상 반환할 값이 없을 때 StopIteration 예외를 발생시킵니다.

  my_list = [1, 2, 3, 4, 5]
  my_iterator = iter(my_list)
  
  try:
      while True:
          value = next(my_iterator)
          print(value)
  except StopIteration:
      print("이터레이터의 끝에 도달했습니다.")

  • Python 3.7부터는 next() 함수에 기본값을 제공할 수 있습니다. 이를 활용하여 더 간결하게 코드를 작성할 수 있습니다.

    my_list = [1, 2, 3, 4, 5]
    my_iterator = iter(my_list)
    
    while True:
        value = next(my_iterator, None)
        if value is None:
            print("이터레이터의 끝에 도달했습니다.")
            break
        print(value)
    

• iter(iterable) -> iterator

  my_list = [1, 2, 3, 4, 5]
  my_iterator = iter(my_list)
  
  print(next(my_iterator))  # 출력: 1
  print(next(my_iterator))  # 출력: 2
  print(next(my_iterator))  # 출력: 3

• iter(callable, sentinel) -> iterator

  from functools import partial
  from random import randint
  
  pull_trigger = partial(randint, 1, 6)
  
  print('Starting a game of Russian Roulette...')
  print('--------------------------------------')
  
  for i in iter(pull_trigger, 6):
      print('I am still alive, selected', i)
  
  print('Oops, game over, I am dead! :(')

Generator

• Generator는 이터레이터를 생성하는 함수입니다.
• 함수 내에서 yield 키워드를 사용하여 값을 반환하면, 해당 함수는 제너레이터가 됩니다.
• Generator 함수는 호출될 때마다 이터레이터를 반환하며, 함수의 로컬 상태가 보존됩니다.
• Generator를 만들 때 메모리 효율성과 성능 면에서 장점이 있습니다. 예를 들어, 대규모의 데이터 집합을 처리할 때 메모리를 절약할 수 있습니다.
• Generator 표현식은 리스트 컴프리헨션과 유사하지만, 제너레이터를 생성합니다.

def random_generator(stop_value):
    while True:
        value = random.randint(1, 10)
        print(f"생성된 값: {value}")
        if value == stop_value:
            return  # stop_value가 생성되면 제너레이터 종료
        yield value

gen = random_generator(5)

for i in gen:
    print(i)
# 생성된 값: 4
# 4
# 생성된 값: 9
# 9
# 생성된 값: 5