[Python] 기초 문법 #3

40. tuple

tuple은 일반적으로 2개에서 5개 사이의 요소들을 저장할때 사용되며, 특정 데이터를 ad hoc(즉석적으로) 하게 표현하고 싶을 때 사용된다.

tuple은 주로 list와 같이 쓰인다. List의 요소들로 tuple을 사용한다.

coords = [(4, 4), (5, 2), (-2, 2), (-3, -4)]

튜플이 아니라 리스트로 묶어서 요소로 넣어줄 수도 있긴 하지만 튜플보다 차지라는 메모리 용량이 크기 때문에 간단한 형태의 데이터를 표현할 때는 튜플을 사용하는 게 훨씬 더 효율적이다.

41. Set (집합 자료형)

set 함수 사용하여 set 만들기

set(반복가능한객체)

set에는 반복 가능한 객체(iterable)를 넣는다.

set()의 괄호 안에 리스트를 입력하여 만들거나 문자열을 입력하여 만들 수도 있다.

set(range(5))와 같이 숫자를 만들어내는 range를 사용하면 0부터 4까지 숫자를 가진 세트를 만들 수 있다.

비어 있는 집합 자료형은 s = set()로 만들 수 있다.

Set에 특정 값이 있는지 확인하기

리스트, 튜플, 딕셔너리에 사용했던 in 연산자를 사용하면 된다.

if 'orange' in my_set:

in 앞에 not을 붙이면 특정 값이 없는지 확인한다.

if 4 not in my_set:

42. Dictionary

파이썬 코딩 도장 12.1 딕셔너리 만들기
https://dojang.io/mod/page/view.php?id=2213

딕셔너리는 값(value)마다 이름(key)을 붙여서 저장하는 방식이다.

사전에서 단어를 찾듯이 값을 가져올 수 있다고 하여 딕셔너리라고 부른다.

딕셔너리 = {key1: value1, key2: value2, key3: value3...}

중괄호 { } 사용

딕셔너리의 key는 문자열 뿐만 아니라 정수, 실수, 불도 사용할 수 있으며 섞어서 사용해도 된다. 단, key에는 리스트와 딕셔너리를 사용할 수 없다.

value는 리스트, 딕셔너리 등을 포함하여 모든 자료형을 사용할 수 있다.

dict 함수로 딕셔너리 만들기

🔷  딕셔너리 = dict(key1=value1, key2=value2)

key=value 형식으로 딕셔너리를 만들 수 있다.

lux1 = dict(health=490, mana=334, melee=550, armor=18.72)

이때 key에 작은 따옴표('')나 큰 따옴표("")를 사용하지 않아야 한다.

👇  Key는 딕셔너리를 만들고 나면 문자열로 바뀐다.

>>> lux1
{'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}

43. For Loops

my_list = [int(s) for s in input().split()]
odd_numbers = []

## 먼저 홀수값들을 골라내서 리스트를 만들고

for element in my_list:
    if (element % 2) == 1:
        odd_numbers.append(element)

## 홀수값들을 하나 하나 기존 리스트에서 지워준다

for odd_number in odd_numbers:
    my_list.remove(odd_number)

print(my_list)

remove 함수 인수로 리스트를 넣어도 되는구나...

43. Assignment

주어진 리스트 my_list에서 오직 한번만 나타나는 값 (unique value)을 가지고 있는 요소는 출력해주세요.

리스트에 포함된 요소 x의 개수 세기(count)
count(x)는 리스트 안에 x가 몇 개 있는지 조사하여 그 개수를 돌려주는 함수이다.

my_list = [1, 2, 3, 4, 5, 1, 2, 3, 7, 9, 9, 7]

## 아래 코드를 입력해주세요.
# 중복되지 않는 요소를 출력해라
# for문 사용

for i in my_list:
    if my_list.count(i) == 1:
        print(i)

44. Assignment

my_list에 1부터 9까지 홀수를 입력하는 함수 for_loops()를 완성 해주세요.

def for_loops():
    # 아래의 코드는 수정하지 마세요.
    my_list = []

    # 아래에 코드를 작성해 주세요.
    for i in range(1, 10, 2):
        my_list.append(i)

    # 아래의 코드는 수정하지 마세요.
    return my_list

49. While Loops

for문은 list, set, dictionary 등의 data structure 등을 기반으로 코드블록을 반복 실행할 때 사용한다.

하지만 가끔 data structure 기반이 아니더라도 코드블록을 반복해야 할 때가 있다. 이때 while문을 사용한다.

while문은 조건문이 참(True)인 동안에 while문 아래의 문장이 반복해서 수행된다.

While Else

파이썬의 while문은 else문이 추가될 수 있다.

While문의 else문도 while의 조건문이 False이면 실행된다.

else문을 추가하여 while문이 종료되고 난 후, number 변수의 값을 출력하는 용도로 쓸 수 있다.

number = 0
 
while number <= 10:
    print(number)
    number += 1
 
else:
    print(f"while 문이 끝나고 난 후 의 number : {number}")

49. Assignment

find_smallest_integer_divisor 라는 이름의 함수를 구현해 주세요.

find_smallest_integer_divisor 함수는 하나의 parameter를 받습니다.

Parameter 값은 integer만 주어집니다.

find_smallest_integer_divisor 주어진 parameter 값을 나눌 수 있는 1을 제외한 최소의 양의 정수를 리턴하여야 합니다.

예제:

find_smallest_integer_divisor(15) == 3

def find_smallest_integer_divisor(numb):
    ## 아래 코드를 입력해주세요.
    #  최소의 정수 리턴
    i = 1
    while i >= 1:
        i += 1
        if numb % i == 0:  # i로 나눴을 때 나머지가 0이면
            return i

50. Looping Dictionary

for에 range 대신 시퀀스 객체를 넣어도 된다.
리스트, 튜플, 문자열 등 시퀀스 객체로 반복할 수 있다.

딕셔너리는 key와 value로 이루어져 있는데
for에 딕셔너리를 사용하면 각 요소의 key만 리턴한다.

value 값으로 리턴 받고 싶으면 values 함수를 사용하면 된다.

Looping Dictionary With Values Instead of Keys

Value 리스트 만들기(values)

values 함수를 호출하면 dict_values 객체를 돌려준다.

파이썬 3.0 이후 버전에서는 메모리 낭비를 줄이기 위해 dict_values 객체를 돌려준다.

dict_keys, dict_values, dict_items 등은 리스트로 변환하지 않더라도 기본적인 반복(iterate) 구문(예: for문)을 실행할 수 있다.

>>> a.values()
dict_values(['pey', '0119993323', '1118'])

bts_rm = {'실명': '김남준', '가명': 'RM', '태어난 년도': 1991}

for each_value in bts_rm.values():
  print(f"{each_value} 은/는 BTS 멤버 RM의 정보입니다.")
  
--------------------------------------------------
김남준 은/는 BTS 멤버 RM의 정보입니다.
RM 은/는 BTS 멤버 RM의 정보입니다.
1991 은/는 BTS 멤버 RM의 정보입니다.

Looping Dictionary With Both Keys And Values

Key, Value 쌍 얻기(items)

items 함수는 Key와 Value의 쌍을 튜플로 묶은 값을 dict_items 객체로 돌려준다.

dict_values 객체와 dict_items 객체 역시 dict_keys 객체와 마찬가지로 리스트로 변환하지 않더라도 반복분에서 리스트를 사용하는 것과 동일하게 사용할 수 있다.

>>> a.items()
dict_items([('name', 'pey'), ('phone', '0119993323'), ('birth', '1118')])

bts_rm = {'실명': '김남준', '가명': 'RM', '태어난 년도': 1991}

for each_key, each_value in bts_rm.items():
  print(f"{each_key} 은/는 {each_value} 입니다.")
  
------------------------------------------------
실명 은/는 김남준 입니다.
가명 은/는 RM 입니다.
태어난 년도 은/는 1991 입니다.

50. Assignment

Input으로 주어진 list의 각 요소(element)가 해당 list에 몇번 나타나는지 수를 dictionary로 만들어서 리턴해주세요. Dictionary의 key는 list의 요소 값이며 value는 해당 요소의 총 빈도수 입니다.

예를 들어, 다음과 같은 list가 input으로 주어졌다면:

my_list = ["one", 2, 3, 2, "one"]

다음과 같은 dictionary가 리턴되어야 합니다.

{
   "one" : 2,
    2 : 2,
    3: 1
}

def get_occurrence_count(my_list):
    # 이 함수를 구현 해주세요
    my_list2 = list(set(my_list))
    my_dict = {}
    for i in my_list2:
        my_dict[i] = my_list.count(i)
    return my_dict

51. Complex Dictionary

List of Dictionaries

list를 dictionary로 구성하면 손쉽게 여러 dictionary들을 grouping 할 수 있다.

for 구문을 사용하여 각각의 dictionary들을 읽어들이고 원하는 로직을 실행할 수 있다.

Nested Dictionary

딕셔너리 안에서 딕셔너리 사용하기
https://dojang.io/mod/page/view.php?id=2310

딕셔너리 안에서 딕셔너리를 사용하는 중첩 딕셔너리

딕셔너리는 값(value) 부분에 다시 딕셔너리가 계속 들어갈 수 있다.

딕셔너리 = {KEY1: {keyA: valueA}, KEY2: {keyB: valueB}}

중첩 딕셔너리는 계층형 데이터를 저장할 때 유용하다.

딕셔너리 안에 들어있는 딕셔너리에 접근하려면 딕셔너리 뒤에 [ ](대괄호)를 단계만큼 붙이고 Key를 지정해주면 된다.

딕셔너리[Key][Key] 👉 key에 해당하는 value가 나온다.

여기서는 딕셔너리가 두 단계로 구성되어 있으므로 대괄호를 두 번 사용한다.

금성(Venus)의 반지름(mean radius)를 출력하려면 다음과 같이 먼저 'Venus'를 찾아가고 다시 'mean_radius'의 값을 가져오면 됩니다.

print(terrestrial_planet['Venus']['mean_radius'])

-------------------------------------------------
6051.8

이렇게 dictionary 안에 dictionary를 중첩적으로 사용하면 원하는 데이터를 더 효과적으로 표현하는 방법이 될 수 있다.

52. More Complex Function Parameters

파이썬 코딩 도장 30.2 키워드 인수 사용하기
https://dojang.io/mod/page/view.php?id=2346

함수에 인수를 순서대로 넣는 방식을 위치 인수(positional argument)라고 한다. 즉, 인수의 위치가 정해져 있다.

언패킹 사용하기

이렇게 인수를 순서대로 넣을 때는 리스트나 튜플을 사용할 수도 있다.

리스트 또는 튜플 앞에 *(애스터리스크)를 붙여서 함수에 넣어주면 된다.

함수(*리스트)
함수(*튜플)

def print_numbers(a, b, c):
    print(a)
    print(b)
    print(c)


myList = [10, 20, 30]
print_numbers(*myList)  # 리스트 앞에 *를 붙여준다.
-------------------------------
10
20
30

리스트 또는 튜플 앞에 *를 붙이면 언패킹(unpacking)이 되어서 print_numbers(10, 20, 30)과 똑같은 동작이 된다. (tuple로 변환하여 함수에 전달된다.) 말 그대로 리스트의 포장을 푼다는 뜻이다.

가변 인수 함수 만들기

위치 인수와 리스트 언패킹은 인수의 개수가 정해지지 않은 가변 인수(variable argument)에 사용한다.

즉, 같은 함수에 인수 한 개를 넣을 수도 있고, 열 개를 넣을 수도 있고, 인수를 넣지 않을 수도 있다.

가변 인수 함수는 함수를 만들 때 매개변수 앞에 *를 붙여서 만든다.

def 함수이름(*매개변수):
    코드

숫자 여러 개를 받고 숫자를 각 줄에 출력하는 함수를 만들어보자.

함수를 만들 때 괄호 안에 *args와 같이 매개변수 앞에 *를 붙인다.
그리고 함수 안에서는 for로 args를 반복하면서 print로 값을 출력한다.

def print_numbers(*args):
    for arg in args:
        print(arg)

특히 이 args는 튜플이라서 for로 반복할 수 있다.

def print_numbers(*args):
    for arg in args:
        print(arg)


print_numbers(10)
---------------------------
10

def print_numbers(*args):
    for arg in args:
        print(arg)


print_numbers(10, 20, 30, 40)
-----------------------------
10
20
30
40

함수에 인수 여러 개를 직접 넣어도 되고, 리스트(튜플) 언패킹을 사용된다.

키워드 인수 (keyword argument)

파이썬에서는 인수의 순서와 용도를 매번 기억하지 않도록 키워드 인수(keyword argument)라는 기능을 제공한다.

키워드 인수는 말 그대로 인수에 이름(키워드)을 붙이는 기능인데 키워드=값형식으로 사용한다.

키워드 인수를 사용해서 순서를 지키지 않고 값을 넣을 수 있다.

print 함수에서 사용했던 sep, end도 키워드 인수이다.

파이썬 코딩 도장 30.3 키워드 인수와 딕셔너리 언패킹 사용하기
https://dojang.io/mod/page/view.php?id=2347

이번에는 딕셔너리를 사용해서 키워드 인수로 값을 넣는 딕셔너리 언패킹을 사용해보자.

딕셔너리 앞에 **(애스터리스크 2개)를 붙여서 함수에 넣어준다.

def personal_info(name, age, address):
    print('이름: ', name)
    print('나이: ', age)
    print('주소: ', address)


x = {'name': '홍길동', 'age': 30, 'address': '서울시 용산구 이촌동'}

personal_info(**x)  # 딕셔너리이름 앞에 ** 붙임
-------------------------------------------
이름:  홍길동
나이:  30
주소:  서울시 용산구 이촌동

딕셔너리의 키워드(Key)는 반드시 문자열 형태이어야 한다.

**x처럼 딕셔너리를 언패킹하면 딕셔너리의 값들이 함수의 인수로 들어간다.

딕셔너리 변수 대신 딕셔너리 앞에 바로 **를 붙여도 동작은 같다.

def personal_info(name, age, address):
    print('이름: ', name)
    print('나이: ', age)
    print('주소: ', address)


personal_info(**{'name': '홍길동', 'age': 30, 'address': '서울시 용산구 이촌동'})
-------------------------------------------
이름:  홍길동
나이:  30
주소:  서울시 용산구 이촌동

딕셔너리 언패킹을 사용할 때는 함수의 매개변수 이름과 딕셔너리의 Key 이름이 같아야 한다. 또한, 매개변수 개수와 딕셔너리 Key의 개수도 같아야 한다.

**를 두 번 사용하는 이유

딕셔너리는 key-value 쌍 형태로 값이 저장되어 있기 때문이다.

*를 한 번만 사용해서 함수를 호출해보자

def personal_info(name, age, address):
    print('이름: ', name)
    print('나이: ', age)
    print('주소: ', address)


x = {'name': '홍길동', 'age': 30, 'address': '서울시 용산구 이촌동'}

personal_info(*x)  # *을 한 개만 붙였다.
-------------------------------------------
이름:  name
나이:  age
주소:  address

Key가 출력되었다.

즉, 딕셔너리를 한 번 언패킹하면 키를 사용한다는 뜻이 된다.

따라서 **처럼 딕셔너리를 두 번 언패킹해서 값을 사용하도록 만들어야 한다.

키워드 인수를 사용하는 가변 인수 함수 만들기

이번에는 키워드 인수를 사용하는 가변 인수 함수를 만들어보자.

키워드 인수를 사용하는 가변 인수 함수는 매개변수 앞에 **를 붙여서 만든다.

def 함수이름(**매개변수):  # 매개변수 앞에 ** 붙임
    코드

함수를 만들 때 괄호 안에 **kwargs와 같이 매개변수 앞에 **를 붙인다.

함수 안에서는 for로 kwargs.items()를 반복하면서 print로 값을 출력한다.

※ items() 함수는 Key와 Value의 쌍을 튜플로 묶은 값을 dict_items 객체로 돌려준다.

매개변수 이름은 원하는 대로 지어도 되지만 관례적으로 keyword arguments를 줄여서 kwargs로 사용한다.

def personal_info(**kwargs):
    for kw, arg in kwargs.items():  
        print(kw, ': ', arg, sep='')

특히 이 kwargs는 딕셔너리라서 for로 반복할 수 있다.

personal_info 함수에 키워드와 값을 넣어서 실행해보자.
값을 한 개 넣어도 되고, 세 개 넣어도 된다.

def personal_info(**kwargs):
    for kw, arg in kwargs.items():  
        print(kw, ': ', arg, sep='')


personal_info(name='홍길동', age=30, address='서울시 용산구 이촌동')
--------------------------------------------
name: 홍길동
age: 30
address: 서울시 용산구 이촌동

인수를 직접 넣어도 되고, 딕셔너리 언패킹을 사용해도 된다. 다음과 같이 딕셔너리를 만들고 앞에 **를 붙여서 넣어보자.

def personal_info(**kwargs):
    for kw, arg in kwargs.items():
        print(kw, ': ', arg, sep='')


x = {'name': '홍길동'}
personal_info(**x)
--------------------------------------
name: 홍길동

딕셔너리 x는 {'name': '홍길동'}이므로 personal_info(**x)로 호출하면 personal_info(name='홍길동')과 같다.

이처럼 함수를 만들 때 def personal_info(**kwargs):와 같이 매개변수 앞에 **를 붙여주면 키워드 인수를 사용하는 가변 인수 함수를 만들 수 있다.

그리고 이런 함수를 호출할 때는 키워드와 인수를 각각 넣거나 딕셔너리 언패킹을 사용하면 된다.

보통 **kwargs를 사용한 가변 인수 함수는 다음과 같이 함수 안에서 특정 Key가 있는지 확인한 뒤 해당 기능을 만든다.

def personal_info(**kwargs):
    if 'name' in kwargs:  # in 으로 딕셔너리 안에 특정 Key가 있는지 확인
        print('이름: ', kwargs['name'])
    if 'age' in kwargs:
        print('나이: ', kwargs['age'])
    if 'address' in kwargs:
        print('주소: ', kwargs['address'])

고정 인수와 가변 인수(키워드 인수)를 함께 사용하기

고정 인수와 가변 인수(키워드 인수)를 함께 사용할 때는 다음과 같이 고정 매개변수를 먼저 지정하고, 그 다음 매개변수에 **를 붙여주면 된다.

단, 이때 def personal_info(**kwargs, name):처럼 **kwargs가 고정 매개변수보다 앞쪽에 오면 안 된다. 매개변수 순서에서 **kwargs는 반드시 가장 뒤쪽에 와야 한다.

def personal_info(name, **kwargs):
    print(name)
    print(kwargs)


personal_info('홍길동')
----------------------------------------
홍길동  # print(name)
{}    # print(kwargs)

def personal_info(name, **kwargs):
    print(name)
    print(kwargs)


personal_info('홍길동', age=30, address='서울시 용산구 이촌동')
--------------------------------------------------------
홍길동  # print(name)
{'age': 30, 'address': '서울시 용산구 이촌동'}  # print(kwargs)

def personal_info(name, **kwargs):
    print(name)
    print(kwargs)


personal_info(**{'name': '홍길동', 'age': 30, 'address': '서울시 용산구 이촌동'})
--------------------------------------------------------------------------
홍길동  # print(name)
{'age': 30, 'address': '서울시 용산구 이촌동'}  # print(kwargs)

위치 인수와 키워드 인수를 함께 사용하기

함수에서 위치 인수를 받는 *args와 키워드 인수를 받는 **kwargs를 함께 사용할 수도 있다.

대표적인 함수가 print인데 print는 출력할 값을 위치 인수로 넣고, 키워드 인수로 sep, end 등을 넣는다.

다음과 같이 함수의 매개변수를 *args, **kwargs로 지정하면 위치 인수와 키워드 인수를 함께 사용한다.

단, 이때 def custom_print(**kwargs, *args):처럼 **kwargs가 *args보다 앞쪽에 오면 안 된다. 매개변수 순서에서 **kwargs는 반드시 가장 뒤쪽에 와야 한다.

특히 고정 매개변수와 *args, **kwargs를 함께 사용한다면 def custom_print(a, b, *args, **kwargs):처럼 매개변수는 고정 매개변수, *args, **kwargs 순으로 지정해야 합니다.

def custom_print(*args, **kwargs):
    print(*args, **kwargs)


custom_print(1, 2, 3, sep=':', end='')
---------------------------------------
1:2:3

위치 인수와 키워드 인수를 둘 다 사용하면 어떠한 형태와 수의 argument도 허용 가능한 함수가 된다.

즉, parameter에 있어서 굉장히 유동적인 함수가 되는 것이다.

52. Assignment

함수 2개를 구현해주세요. 함수의 이름은 다음과 같아야 합니다.

sum_of_numbers
what_is_my_full_name
함수 sum_of_numbers는 arugment로 주어지는 모든 수를 합한 값을 리턴해야 합니다.

예를 들어, sum_of_numbers(1, 2, 3, 4, 5) 는 15를 리턴해야 하고 sum_of_numbers(1,2)는 3을 리턴해야 합니다.

만일 parameter가 주어지지 않으면 0을 리턴해야 합니다.

what_is_my_full_name 함수는 주어진 parameter중 first_name 과 last_name 이라는 parameter를 조합하여 full name을 리턴해주어야 합니다.

예를 들어, first_name이 "우성" 이고 last_name 이 "정" 이면 "정 우성" 라고 리턴하면 됩니다.

Last name과 first name 사이에 space(빈칸)이 들어가 있어야 합니다.

만일 last_name이 없거나 first_name이 없으면 둘 중하나만 리턴하면 됩니다.

예를 들어, last_name이 없으면 "우성" 이라고 이름만 리턴하면 됩니다,

마지막으로, last_name과 first_name 둘다 없으면 "Nobody" 라고 리턴하면 됩니다.

def sum_of_numbers(*args):
    result = 0
    for arg in args:
        result += arg
    return result


def what_is_my_full_name(**kwargs):
    if 'first_name' in kwargs and 'last_name' in kwargs:
        return kwargs['last_name'] + " " + kwargs['first_name']
    if 'first_name' in kwargs:
        return kwargs['first_name']
    if 'last_name' in kwargs:
        return kwargs['last_name']
    if 'first_name' not in kwargs and 'last_name' not in kwargs:
        return "Nobody"