파이썬 함수 종류

함수 종류:

파이썬 함수에 대한 다양한 팁을 제공하는 문서입니다.

리스트 거꾸로 출력, 딕셔너리 출력, 깊은 복사, 얕은 복사, 패킹과 언 패킹

replace 함수, enumerate 함수, bin 함수, divmod 함수, map 함수, zip 함수, lambda 함수, join 함수

sys.stdin.readline() / array.pop(i) / i for i in a if~~~등에 대한 내용이 포함되어 있습니다.

리스트 거꾸로 출력

makit = '동서남북'
print(makit[::-1])

# array[::-1] -> -1씩 출력한다
# 결과값 : 북남서동

replace(’기존의 값’,.’바꾸고자 하는 값’)함수

phone = '010-1234-5678'
new_phone = phone.replace('-','.')
print(new_phone)

# 결과값
010.1234.5678

딕셔너리 출력

fruits = {
    '사과': 'apple',
    '바나나': 'banana',
    '키위': 'kiwi'
}
for fruit in fruits:
    print(fruit + "는 영어로 " + fruits[fruit])
# 결과값

사과는 영어로 apple
바나나는 영어로 banana
키위는 영어로 kiwi

깊은 복사

import copy
a = [1,2,3]
b = copy.deepcopy(a)
a.append[5]
print(a, b)

# 결과값
[1, 2, 3, 5] [1, 2, 3]

얕은 복사

얕은 복사의 오류를 범하지 않도록 주의하자!!!

a = [1,2,3]
b = a
a.append(5)
print(a, b)

# 결과값
[1, 2, 3, 5] [1, 2, 3, 5]

i for i in a if ~~~

def oddnum():
    t = int(input())
    k = 1
    while k <= t:
        a = list(map(int, input().split()))
        sm = sum([i for i in a if i % 2==1])
        print(f'#{k} {sm}')
        k += 1

######
print([i for i in range(10)])
print([i**2 for i in range(10)])
print(' '.join(map(str, [i for i in range(10)])))
print(*[i for i in range(10)]) # 언팩 씀

# 결과값
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9

굉장히 유용하게 쓸 수 있으니 기억해두자

sum([i for i in a if i % 2==1])와 같이 한번에 쓸 수 있음

'구분자'.join(리스트{스트링 형태로 들어가야 함})

string_list = ['블로그', '많이', '사랑해주세요']
print(' '.join(string_list)) ## 공백 한칸을 구분자로 한다.

# 결과값
블로그 많이 사랑해주세요

b = [1, 0, 0, 1]

print(''.join(map(str, b)))
# 여기서 map str은 b값이 int라서 스트링으로 map함수를 사용해 바꾼후 join을 사용했다
# 결과값
1001

리스트로 출력된 값을 스트링으로 바꿀 수 있음

리스트를 문자열로 합쳐준다.

enumerate 함수

data = enumerate({1,2,3})
for i, value in data:
	print(i, ":", value)
print()

# 결과값 :
0 : 1
1 : 2
2 : 3

alpha = enumerate({'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5})

for i, value in alpha:
    print(f"{value}: {i}") # 들어가는 순서? 잘모르겠음

# 결과값 :
a: 0
b: 1
c: 2
d: 3
e: 4
f: 5

# enumerate함수의 시작 인덱스 값을 바꿀 수 있다.
fruits = ['사과', '바나나', '배']
answer = list(enumerate(fruits, 100))
for index, value in answer:
    fruits[index] = value + "+"
print(fruits)

# 결과값 :
[(100, '사과'), (101, '바나나'), (102, '배')]

store = {'새우칩': 1500, '옥수수칩': 1800, '콜라': 700, '양파칩': 1300}
for index, key in enumerate(store.keys()):
print(f'{index} 번 물품은 {key} 이고 가격은{store[key]} 입니다.')

# 결과값
0 번 물품은 새우칩 이고 가격은1500 입니다.
1 번 물품은 옥수수칩 이고 가격은1800 입니다.
2 번 물품은 콜라 이고 가격은700 입니다.
3 번 물품은 양파칩 이고 가격은1300 입니다.

arr = [1, 5, 7, 43, 76, 2, 3, 5, 3, 6, 1]
idx, val = max(enumerate(arr), key = lambda x: x[1])
print(idx, val)
# 결과값
4 76
# enumerate함수를 사용해서 출력

index 값을 포함하는 객체를 리턴 한다.

(list, set, tuple, dictionary, string)을 입력으로 받을 수 있다.

bin 함수, divmod 함수

bin(9) # 이진수로 바꿔주는 함수

# 결과값
0b1001 #0b는 이진수를 의미한다.

a, b = divmod(5, 2)
a, b = divmod(10, 1)
print(a, b)

# 결과값
2, 1
10, 0

divmod(num. a)는 num을 a로 나눈 값의 몫과 나머지를 반환한다.

sys.stdin.readline()

import sys

n = int(input())
num = []
for _ in range(n):
    num.append(int(sys.stdin.readline()))

num.sort()

for i in num:
    print(i)

input()과의 차이점 input이 프롬프트 메시지를 리턴하고, rstrip()이 적용되어 나오는 반면

sys.stdin.readline()함수는 개행 문자를 포함한 값을 리턴해서 상대적으로 빠르다.

array.pop(i)

a = [85, 65, 77, 83, 75, 22, 98, 88, 38, 100]
sum = 0
while 0 < len(a):
    s = a.pop(0)
    if s >= 80:
        sum += s
print(sum)

# 결과값 = 454

a.pop(0)을 하면 리스트 a에서 0번째 값을 뽑아내고 전체 리스트가 줄어든다.

반복문 한번 실행 시 a에 들어있는 값:

a = [65, 77, 83, 75, 22, 98, 88, 38, 100]

map(function, iterable)

****# iterable : 데이터 구조

• 순회 가능한 데이터 구조의 모든 요소에 함수를 적용하고, 그 결과를 map object로 반환

zip(*iterables)

• 임의의 iterable을 모아 튜플을 원소로 하는 zip object를 반환

girls = ['jane', 'ashley']
boys = ['peter', 'jay']
pair = zip(girls, boys)

print(pair) # <zip object at 0x000001C76DE58700>
print(list(pair)) # [('jane', 'peter'), ('ashley', 'jay')]

Packing 패킹

여러 개의 값을 하나의 변수에 묶어서 담는 것

# 예시
packed_values = 1, 2, 3, 4, 5
print(packed_values) # (1, 2, 3, 4, 5) 튜플 형태로 묶인다.

# *을 활용한 패킹
numbers = [1, 2, 3, 4, 5]
a, *b, c = numbers

print(a) # 1
print(b) # [2, 3, 4]
print(c) # 5
# *b는 남는 요소들을 리스트로 패킹하여 할당

*’을 활용한 패킹

print(*objects, sep=’’, end=’\n’, file=sys.stdout, flush=False)인자

Unpacking 언 패킹

패킹 된 변수의 값을 개별적인 변수로 분리하여 할당하는 것

• 튜플 이나 리스트 등의 객체의 요소들을 개별 변수에 할당
• ‘*’ 는 리스트의 요소를 언 패킹

names = ['alice', 'jane', 'peter']
print(*names) # alice jane peter

‘’을 활용한 언 패킹**

• **는 딕셔너리의 키-값 쌍을 함수의 키워드 인자로 언 패킹

def my_function(x, y, z):
	print(x, y, z)

my_dict = {'x':1, 'y':2, 'z':3}
my_function(**my_dict) # 1 2 3

*, ** 패킹/ 언 패킹 연산자 정리

• ‘*’
  • 패킹 연산자로 사용될 때, 여러 개의 인자를 하나의 튜플로 묶는 역할
  • 언 패킹 연산자로 사용될 때, 시퀀스나 반복 가능한 객체를 각각의 요소로 언 패킹하여 함수의 인자로 전달
• ‘**’
  • 언 패킹 연산자로 사용될 때, 딕셔너리의 키-값 쌍을 키워드 인자로 언 패킹하여 함수의 인자로 전달하는 역할

zip 함수 / 전치 행렬

# zip 함수 응용
arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(list(zip(*arr)))

# 결과값 // 전치행렬
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

filter(함수, 반복 가능한 개체)

반복 가능한 객체에서 특정 조건에 맞는 요소만 가져온다.

filter에 지정한 함수의 반환 값이 True일 때만 해당 요소를 가져온다!

a = list(i for i in range(1,11))
print(list(filter(lambda x: x%2==0, a)))

# 결과값
[2, 4, 6, 8, 10]

2차원 리스트 만드는 방법

multi = []
for i in range(2, 10):
    a = []
    for k in range(1, 10):
        a.append(i*k)
    multi.append(a)
print(multi)

# 결과값
[[2, 4, 6, 8, 10, 12, 14, 16, 18], [3, 6, 9,...] ...,[9, 18, ..., 72, 81]]

#2중 for문
col * row
arr = [[0 for j in range(cols)] for i in range(rows)]

# 3차원 리스트 만드는 법
a = []

for i in range(3):
	line = []
	for j in range(2):
		line.append(0)
	a.append(line)

print(a)
# 결과값
[[0, 0], [0, 0], [0, 0]]

list.index()

a = [12, 24, 35, 70, 88, 120, 155]
print([i for i in a if a.index(i) % 2 == 1])

# 결과값
[24, 70, 120]

특정 원소가 몇 번째에 처음으로 나오는 지 알려주는 함수

sorted 함수

리스트.sort() : 본체의 리스트를 정렬해서 변환

sorted(리스트) : 본체 리스트는 내버려두고, 정렬한 새로운 리스트를 반환

구조 : sorted(정렬할 데이터, key, reverse)

key : 어떤 것을 기준으로 정렬할 것인가?

reverse : True(내림차순), False(오름차순)

d = dict()
d['a'] = 66
d['i'] = 20
d['e'] = 30
d['d'] = 33
d['f'] = 50
d['g'] = 60
d['c'] = 22
d['h'] = 80
d['b'] = 11

 
# 딕셔너리 키 정렬 
g = sorted(d.items(), reverse=True) # 내림차순, Fale:오름차순
print(g)
 
# 딕셔너리 키만 정렬 및 출력1
h = sorted(d.keys()) 

# 딕셔너리 키값들을 매개변수 x에 넣어 x로 정렬하여 키값을 출력한다.
print(sorted(dict.keys(), key=lambda x:x)) 
 
# 딕셔너리 키만 정렬 및 출력2
i = sorted(d) 

# 딕셔너리 value 기준 정렬
g = sorted(d.items(), key=operator.itemgetter(1))
g = sorted(d.keys(), key=operator.itemgetter(1))

# 딕셔너리 value값들을 매개변수 x에 넣어 x로 정렬하여 key값을 출력한다.
print(sorted(dict.values(), key=lambda x:x))
== g = sorted(d.keys(), key=operator.itemgetter(1))
# key 기준 정렬, key값만 출력 둘이 같은 식

# 딕셔너리 키값들을 매개변수 x에 넣어 dict[x] dict의 value값으로 정렬하며 키값을 출력
print(sorted(dict, key=lambda x: dict[x]))

# 딕셔너리 value 기준 정렬, lambda 함수 이용
g = sorted(d.items(), key=lambda x: x[1]) # value 값 기준 정렬
g = sorted(d.items(), key=lambda x: x[0]) # 키 값 기준 정렬
print(g)
# d = 딕셔너리

https://blockdmask.tistory.com/466 원문, 추가 설명

extend 함수

array.extend(iterable)형태로 사용한다. 입력한 iterable 자료형의 항목 각각을 array의 끝에 하나씩 추가한다.

append와 유사하지만 다른 점은 괄호 안에는 반복 가능한 자료형 만 올 수 있다는 것이다.

nums = [1, 2, 3]
nums.extend([4, 5])

# 결과값
[1, 2, 3, 4, 5]

a = [10]
nums.extend(a)

# 결과값
[1, 2, 3, 4, 5, 10]

insert()

array.insert(i,x) 형태

i는 위치 인덱스, x에는 반복 가능한 자료형이 올 수 잇음

nums = [1, 2, 3]
nums.insert(0, [10, 20]) # 0번째 추가
# 결과값
[[10, 20], 1, 2, 3]

nums.insert(-1, 100) # 끝에서 1번째 전에 추가
print(nums)

# 결과값
[[10, 20], 1, 2, 100, 3]

N X N 2차원 배열 리스트 내장으로 생성

N = int(input())
arr = [list(map(int, input().split())) for _ in range(N)]

N = int(input)
arr = [list(map(int, input())) for _ in range(N)]