핵심 파이썬 기초 프로그래밍(4)

본 포스팅은 elice의 2021 NIPA AI 온라인 교육을 듣고 개인 공부를 위해 정리한 것입니다.

4. 파이썬에서 자료를 담는 여러가지 방식

1) 리스트 활용하기

list.append(d)

.append() 맨 앞의 .은 dot access 이다. list의 자료형에서 함수를 사용할 때 dot access 사용

자료 d를 리스트 마지막 원소 뒤에 추가, 오직 한 개의 자료만 넣을 수 있다.

a = []
b = ['a', 'b', 'c']
a.append(10) 
b.append('d')
print(a, b)
>>> [10] ['a', 'b', 'c', 'd']

list.index(i, d)

어디에? 무엇을? 추가! list.index(위치, 값)
인덱스 i에 자료 d를 추가, 오직 한 개의 자료만 넣을 수 있다.
인덱스는 0부터 시작한다.

c = [1, 2, 4, 5]
c,insert(2, 3) # 2는 인덱스, 3이 추가할 값 
print(c)
>>> [1, 2, 3, 4, 5]

list.remove(d)

어떤 자료를 삭제할 것인가?
처음 나오는 자료 d를 제거, 중복 시 인덱스가 작은 원소 제거!

d = [3, 1, 2, 3]
d.remove(3)
print(d)
>>> [1, 2, 3] # 처음 나오는 3이 사라졌다!

list.sort()

리스트를 정렬
list.sort()의 괄호() 안에 아무것도 없을 때, 즉, 기본형에서 숫자형은 오름차순, 문자열은 사전순
sort 메서드의 reverse 를 True 로 설정하면 역순으로 정렬 가능

e = [6, 2, 4, 1]
f = ['carrot', 'apple', 'banana']
e.sort()
f.sort()
print(e, f)
>>> [1, 2, 4, 6] ['apple', 'banana', 'carrot']

💎주의💎
리스트는 각기 다른 자료형을 담을 수 있지만 리스트를 정렬할 때는 같은 자료형만 가지고
있어야 한다.

e = [6, 2, 4, 1, 'carrot']
e.sort()
print(e)
>>> Traceback (most recent call last): # Error 발생
  File "main.py", line 3, in <module>
    e.sort()
TypeError: '<' not supported between instances of 'str' and 'int'

참고

• index(x) : 인덱스 내에 x가 있으면 인덱스 값을 반환, 없으면 Error
• pop() : 뒤에서 부터 하나씩 꺼냄
• count(x) : 리스트 내에 x가 몇 개 있는지 그 개수를 반환
• remove(i) : 리스트 인덱스 i에 있는 요소를 제거
• extend(l) : 리스트 마지막에 리스트 l을 추가

실습✍ 리스트에 원소 추가하기

1. 빈 리스트 my_list를 하나 선언해봅시다.
2. my_list에 숫자 5, 4, 2, 1을 차례대로 넣어봅시다.

my_list = []
my_list.append(5)
my_list.append(4)
my_list.append(2)
my_list.append(1)

print(my_list)
>>> [5, 4, 2, 1]

실습✍ 리스트에 원소 정렬하기

1. 숫자 5, 4, 3, 2가 차례대로 담긴 리스트 my_list를 만들어봅시다.
2. my_list를 오름차순으로 정렬해봅시다.

my_list = [5, 4, 3, 2]
my_list.sort()
print(my_list)
>>> [2, 3, 4, 5]

2) 시퀀스 자료형이란?

순서가 있는 자료형
시퀀스의 종류 : 리스트, 튜플, 문자열, range

a = "Once" #문자열
b = ['T', 'W', 'I', 'C', 'E'] #리스트
c = (1, 2, 3, 4, 5) #튜플

시퀀스의 특징

1. 원소간의 순서가 존재한다

• 인덱싱/슬라이싱이 가능하다.
  • 인덱싱 : 시퀀스의 한 원소를 가져오는 것
  • 슬라이싱 : 시퀀스의 일부분을 가져오는 것, 슬라이싱을 하면 슬라이싱 이전 자료형의 특징을 그대로 가져간다. 치즈🧀를 슬라이스하면 치즈🧀!

a = "Once" #문자열
b = ['T', 'W', 'I', 'C', 'E'] #리스트
print(a[1]) # n
print(b[2:4]) # ['I', 'C']
>>> n 
['I', 'C']

• 인덱싱/슬라이싱을 할 때 음수를 넣거나, 자리를 비우는 것도 가능!
  [-1]은 뒤에서 첫번째!!! [start:end]앞이 비어있다면 처음부터! 끝이 비어있다면 끝까지!

a = "Once" #문자열
b = ['T', 'W', 'I', 'C', 'E'] #리스트
print(a[-1]) # e : 뒤에서 첫번째 원소
print(b[:3]) # ['T', 'W', 'I'] : 처음 ~ 3번째 슬라이싱
>>> e 
['T', 'W', 'I']

2. 멤버 조회

멤버 = 원소
in연산자로 시퀀스 안에 원소가 있는지 확인 가능
'원소' in 시퀀스 → True/False 반환

a = "Once" #문자열
b = ['T', 'W', 'I', 'C', 'E'] #리스트
print('O' in a) # 문자열 'O'가 문자열 a에 존재하는가? → True!
print('B' in b) # 문자열 'B'가 리스트 b에 존재하는가? → False!
>>> True False

3. 길이 확인

len연산자로 시퀀스 안에 원소가 몇 개 인지 확인 가능

a = "Once" #문자열
b = ['T', 'W', 'I', 'C', 'E'] #리스트
print(len(a)) # 4
print(len(b)) # 5
>>> 4 
5

4. 연결 연산

+연산자로 같은 시퀀스 두개를 이어붙일 수 있다.

c = ['t', 'w', 'i'] + ['c', 'e']
print(c)
>>> ['t', 'w', 'i', 'c', 'e']

5. 반복 연산

*연산자로 시퀀스를 반복할 수 있다.

d = "shy" * 3
print(d)
>>> shyshyshy

실습✍ 시퀀스의 인덱싱과 슬라이싱

1. 문자열 "Impossible"이 담긴 변수 my_str을 만들어봅시다.
2. 리스트 ["Apple", "Banana", "Chamwae", "Durian"]이 차례대로 담긴 변수 my_list를 만들어봅시다.
3. 리스트 my_list에서 인덱싱을 이용해 변수 var1에 "Chamwae"를 넣어봅시다.
4. 문자열 my_str에서 슬라이싱을 이용해 변수 var2에 "possible"을 넣어봅시다.

my_str = "Impossible"
my_list = ["Apple", "Banana", "Chamwae", "Durian"]

var1 = my_list[2]
var2 = my_str[2:]

실습✍ 시퀀스의 길이와 멤버 조사하기

1. 문자열 "Impossible"이 담긴 변수 my_str을 만들어봅시다.
2. 리스트 ["Apple", "Banana", "Chamwae", "Durian"]이 담긴 변수 my_list를 만들어봅시다.
3. len을 이용해서 변수 var1에 my_str의 길이를 넣어봅시다.
4. in을 이용해서 "Egg"가 my_list에 들어있는지 확인하고, 이 결과(True or False)를 변수 var2에 넣어봅시다.

my_str = "Impossible"
my_list = ["Apple", "Banana", "Chamwae", "Durian"]

var1 = len(my_str) # 10
var2 = "Egg" in my_list # False

print(var1, var2)

>>> 10 Flase

3) Dictionary(사전)

짝꿍이 있는 자료형! 진짜 사전을 생각해봐😃
중괄호{}로 묶어서 표현, {key : value}의 형식 : key를 알면 value를 알 수 있음

• key : 열쇠처럼 자료를 꺼낼 수 있는 도구
• value : Dictionary에서 Key로 꺼낸 자료

dict_zero = {}
person = {'name':'Michael', 'age':10}

Dictionary[key]

인덱싱과 유사

• Dictionary에서 자료 꺼내기

person = {'name':'Michael', 'age':10}
print(person['name']) # Michael
print(person['age']) # 10
>>> Michael
10

• Dictionary에서 자료 추가

person = {'name':'Michael', 'age':10}
person['hometown'] = 'Seoul' # person : Dictionary, 'hometown' : key, 'Seoul' : Value

print(person)

>>> {'name':'Michael', 'age':10, 'hometown' = 'Seoul'}

del

del함수로 Dictionary의 원소 삭제

person = {'name':'Michael', 'age':10}
del person['age']

print(person)
>>> {'name':'Michael'}

Dictionary의 특징

💎 key는 변할 수 없는 자료형이어야 한다.
→ key로 리스트는 안되고 튜플은 된다.

datas = {[1, 2, 3]:'Alphabet'} # Error
datas = {(1, 2, 3):'Number'} # OK

실습✍ 넌 나랑 한패! Dictionary

1. 다음 대응관계가 담긴 Dictionary를 하나 만들고, 이를 변수 my_dict에 넣어봅시다.

• “사과” → “apple”
• “바나나” → “banana”
• “당근” → “carrot”

2. 사과를 영어로 뭐라고 할까요? my_dict에서 “사과”를 Key로 넣어 나온 Value를 변수 var1에 넣어봅시다.
3. 당근은 싫어요! my_dict에서 당근-carrot을 제거해봅시다.
4. 체리는 좋아요! my_dict에서 체리-cherry를 추가해봅시다.

my_dict = {"사과":"apple", "바나나":"banana", "당근":"carrot"}

var1 = my_dict["사과"]
print(var1)
>>> apple

del my_dict["당근"]
print(my_dict)
>>> {"사과":"apple", "바나나":"banana"}

my_dict["체리"] = "cherry"
print(my_dict)
>>> {"사과":"apple", "바나나":"banana", "체리":cherry}

실습✍ Dictionary의 열쇠?

1. 빈 Dictionary를 만들고, 이를 변수 my_dict에 넣어봅시다.
2. my_dict에 다음 대응관계를 넣어봅시다.

• 1 → “Integer”
• ‘a’ → “String”
• (1, 2, 3) → “Tuple”

3. my_dict에 다음 대응관계를 추가하는 코드를 10번째 줄에 작성해봅시다.

• [1, 2, 3] → “List”

my_dict = {}

my_dict[1] = "Integer"
my_dict['a'] = "String"
my_dict[(1, 2, 3)] = "Tuple"


try:
    #여기에 [1, 2, 3] → "List"의 대응관계를 만들어봅시다.
    my_dict[[1, 2, 3]] = "List"
    
except TypeError:
    print("List는 Dictionary의 Key가 될 수 없습니다.")
    

print(my_dict)
>>>List는 Dictionary의 Key가 될 수 없습니다.
{1: 'Interger', 'a': 'String', (1, 2, 3): 'Tuple'}