파이썬 자료구조

파이썬에서 제공하는 자료구조

• 리스트, 튜플, 딕셔러리, 세트

리스트

• 연속적으로 할당된 공간에 여러 개의 데이터를 저장하는 자료형
  • 리스트 이름과 인덱스를 통해 각 요소(원소, 항목)에 접근 → lst[i]
• 참조형 배열
  • 데이터의 주소 값을 저장
    • 실제 데이터 접근 위해 이중 참조 필요
• 장점) 다양한 타입의 데이터 저장 가능
• 단점) 데이터 접근 속도가 느리다
  • 단, 넘파이 배열을 사용하면 여러 데이터에 빠른 접근이 가능하다

리스트 생성

• 빈 리스트 생성 → lst = []
  • 항목 추가 → lst.append(추가할 항목)
• 초기 값을 가지는 리스트 생성
  • lst = [1,2,3,4,5]
  • string = [’apple’,’banana’,’grape’]
• list() 함수와 range() 함수를 이용해 생성
  • lst = list(range(5)) == lst = [0,1,2,3,4]
  • lst = list(range(5,10) == lst = [5,6,7,8,9]

리스트 내장 함수

• 리스트 항목이 수치 값일 때 사용 가능 함수
  • len() 함수 → 리스트 항목의 수 반환
  • max() 함수 → 리스트 항목 중 최대값 반환
  • min() 함수 → 리스트 항목 중 최대값 반환
  • sum() 함수 → 리스트 항목들의 합 반환

인덱싱

• 인덱스를 사용하여 리스트의 원소에 접근
  • lst[i] = lst의 i번째
• 인덱스의 시작은 0
• 파이썬 리스트는 음수 인덱싱 가능
  • lst[-1] 은 제일 마지막 원소

슬라이싱

• 리스트의 항목 중 일부를 잘라내 새로운 리스트 생성
• 슬라이싱 형식
  • lst[start:end:step]
    • start → 슬라이싱 시작 인덱스, 생략하면 0
    • end → 슬라이싱 끝 인덱스, 생략하면 리스트 마지막 항목까지
    • step → 슬라이싱 건너뛰기 간격, 생략하면 1

lst[0:6] → 0번째부터 6번째 원소까지 추출

lst[:] → 모든 원소 추출

lst[:-1] → 모든 원소 추출

lst[::2] → 0부터 시작하여 2씩 건너뛰기 한 모든 원소 추출

lst[1::2] → 1부터 시작하여 2씩 건너뛰기 한 모든 원소 추출

리스트 얕은 복사(참조복사)

• id() 함수
  • 리스트 객체가 할당된 시작 주소 반환(리스트 객체의 식별 값)
• 리스트 객체 생성
  • 새로운 리스트 식별 값을 가짐
• 리스트 복사 → 얕은 복사 = 참조
  • 원본 리스트와 동일한 식별값을 가짐 → id() 함수 반환 값 동일
  • 원본 리스트의 항목 변경 시 참조 리스트도 항목 변경

blist = alist

• blist는 alist를 참조한다
• alist의 값이 바뀌면 blist의 값도 함께 바뀐다

리스트 깊은 복사

• 리스트 깊은 복사 = 복제
  • 원본 리스트 값을 복사 받은 새로운 리스트 객체 생성
• 깊은 복사 방법
  • list() 함수 이용 → 리스트 객체 생성자
  • 슬라이싱 이용

blist = list(alist) - 생성자 활용 깊은 복사

clist = alist[:] - 슬라이싱 활용 깊은 복사

alist의 값이 변경되어도 blist, clist의 값이 변하지 않는다.

리스트의 정렬

• 메소드 이용 → 원본 리스트를 정렬
  • lst.sort() → 오름차순 정렬
  • lst.sort(reverse=True) → 내림차순 정렬
• 내장 함수 이용 → 정렬된 새로운 리스트 반환
  • sorted(lst) → 오름차순 정렬
  • sorted(lst, reverse=True) → 내림차순 정렬

메소드를 이용하여 정렬하면 원본 리스트가 변경됨

리스트 함축

• 리스트 함축을 통해 코드를 짧고, 간결하게 표현 가능
  • 반복문을 대체, 리스트 생성
• 집합을 조건 제시법으로 표현하는 것과 유사
• 리스트 함축 형식
  • [출력식 for x in 시퀀스]
  • [출력식 for x in 시퀀스 if 조건식]

lst = [x**2 for x in [1,2,3,4,5] ]

# == 두개 같은 결과

lst = []
for x in [1,2,3,4,5]:
	lst.append(x**2)

# 1~10 사이의 3의 배수 리스트 생성

lst = [i for i in range(1,11) if i%3==0]
print(lst)

# 정수 n의 약수들의 리스트

n = 100
lst = [x for x in range(1,n+1) if n%x == 0]
print(lst)

튜플

• 한번 생성되면, 그 값을 고칠 수 없는 자료형
  • 읽기 전용 리스트 객체
• 파이썬 데이터 형 분류
  • 변경 불가능 자료형 → 읽기 전용 데이터
    • 수치 자료형 : 정수(int) , 실수(float)
    • 문자열(str)
    • 튜플(tuple)
  • 문자열 변경 불가 설명
  • s1 = 'Hello' 
    s1 = 'World' 
    print(s1) # s1은 문자열을 참조하는 변수이다 = 참조 변수 
    # s1의 대입되는 문자를 변경하려고 하면 참조되는 주소가 변경되어 변경이 되는것처럼 보이는 것이다.
• 변경 가능 자료형
  • 리스트(list)
  • 집합(set)
  • 딕셔너리(dic)
• 튜플 객체 생성
  • tuple = ()
  • 소괄호 이용

딕셔너리

• 키와 값을 쌍으로 저장하는 자료구조
  • 키와 값은 콜론(:) 으로 구분
• 데이터 검색에 최적화
  • 키(key) 이용해 검색
    • dict[key]
• 빈 딕셔너리 객체 생성
  • 중괄호 이용
  • dict = {}
• 딕셔너리 생성
  • dict = {’book’: ‘책’ } → 초기값을 가지는 딕셔너리 객체 생성
• 딕셔너리에 데이터(키: 값) 추가

dict = {'book':'책'} # 딕셔너리 객체 생성 / 초기화
dict['note'] = '노트' # 항목 추가
dict['pen']= '연필' # 항목 추가
dict['book'] = '전공책' # 만약 있는 키값을 사용하면 값이 변경됨
print(dict)
print(dict['book'])  # 항목 검색 => 키 활용

• → {'book': '전공책', 'note': '노트', 'pen': '연필'}
  전공책

key in dict ⇒ True/False
→ 해당 키가 dict에 있는지 없는지 체크가능
만약 있으면(if) dict[key] = value 로 변경가능

 

딕셔너리의 메소드

• keys() 메소드 : 딕셔너리 내의 모든 키를 리스트로 반환
• values() 메소드 : 딕셔너리 내의 모든 값을 리스트로 반환
• items() 메소드 : 딕셔너리 내의 모든 항목(키와 값 쌍)을 리스트로 반환

dict = {'book':'책', 'note':'노트', 'pen':'연필'}
print(dict.keys())
print(dict.values())
print(dict.items())
for key, value in dict.items() :
  print(key, ':', value)

dict_keys(['book', 'note', 'pen'])
dict_values(['책', '노트', '연필'])
dict_items([('book', '책'), ('note', '노트'), ('pen', '연필')])
book : 책
note : 노트
pen : 연필

 

 

영단어를 입력받아 빈도수 출력

st = input('영단어 입력 : ')
st = st.upper()
dict = {}
for i in st:      # i는 st의 문자 하나씩 반복함
  if i in dict:   # i가 dict의 key값에 있으면
    dict[i] += 1  # dict의 i key값의 value를 1 증가 시켜준다 
  else:
    dict[i] = 1   # dict에 i key값이 없으면 value를 1로 세팅한다.
print(dict)

영단어 입력 : hello {'H': 1, 'E': 1, 'L': 2, 'O': 1}

 

가변 인자 함수

• 임의의 개수의 인자를 전달받는 함수
• 안 올 수도 있고 여러개 올수도 있다.
• 위치 가변 인자
  • def fun(x, *args) → 위치 인자 이후에 가변 인자 정의
    • 전달 값은 튜플 객체로 전달 받음
    • fun(10, 1,2,3) → x=10, args(1,2,3)
• 키워드 가변 인자
  • def fun(x, **kwargs) → 키워드 인자= 값을 여러개 받을 수 있음
    • 전달 값은 딕셔너리 객체로 전달 받는다
    • fun(10, a=1, b=2) → x=10, args={’a’:1,’b’:2}

집합

• 명확한 기준을 가진 대상들의 모임
  • 수학 집합과 유사하다
• 순서가 없는 자료형
  • 순서가 있는 자료형 : 리스트, 튜플
• 동일한 값을 가지는 항목의 중복이 허용 안됨
• 다양한 집합 연산 제공
  • 교집합, 합집합, 차집합, 대칭차집합 등등

집합 객체 생성

• 중괄호 이용
• num = {2, 1, 3}
• set() 생성자 이용num = set([1,2,3,2,1]) → {1,2,3} 집합 생성
• num = set(”abc”) → {’a’,’b’,’c’} 집합 생성
• num = set() → 빈 집합 생성
• 중복된 항목은 알아서 제외되어 추가됨

집합의 연산자 함수(특수 메소드)

• | : 합집합
• & : 교집합
  • : 차집합
• ^ : 대칭차집합 = 두 집합 중 겹치지 않는 요소만 포함

두 정수를 입력 받아, 최대 공약수 출력

조건) 집합 자료구조 활용

힌트) 리스트 함축 리스트 생성 => 집합으로 변환

예) 두 정수 입력 : 36 24

약수 리스트 만들고 집합으로 변경

36의 약수 집합 = {1,2,3,4,6,9,12,18,36}

24의 약수 집합 = {1,2,3,4,6,8,12,24}

x, y = map(int,input('두 정수 입력 : ').split())
x_set = set([i for i in range(1,x+1) if x%i == 0 ])
y_set = set([j for j in range(1,y+1) if y%j == 0 ])
print(f'%d의 약수 집합 : '%x,(x_set))
print(f'%d의 약수 집합 : '%y,(y_set))
print(f'%d와 %d의 최대 공약수 : '%(x,y),max(x_set & y_set))

 

두 정수 입력 : 36 24

36의 약수 : {1, 2, 3, 4, 36, 6, 9, 12, 18}

24의 약수 : {1, 2, 3, 4, 6, 8, 12, 24}

36와 24의 최대 공약수 : 12

 

 

파일 입출력

• 파일 입출력 절차
  • 파일 열기 → 파일 읽기/파일 쓰기 → 파일 닫기
• 파일 열기
  • open() 함수 활용 → 파이썬 내장 함수
    • f = open(파일경로, 열기모드) → 성공 시 file 객체 반환
    • 열기 모드
      • ‘r’ : 읽기 용으로 열림(기본값)
      • ‘w’ : 쓰기 위해 열기, 파일을 먼저 자른다
      • ‘x’ : 배타적 생성을 위해 열리고, 이미 존재하는 경우 실패
      • ‘a’ : 쓰기를 위해 열려 있고, 파일의 끝에 추가하는 경우 추가
      • ‘b’ : 2진 모드(바이너리 모드)
      • ‘t’ : 텍스트 모드(기본값)
      • ‘+’ : 업데이트(읽기 및 쓰기)를 위한 디스크 파일 열기
• 파일 쓰기

# 파일쓰기
f = open('test.txt', 'w')  # 쓰기 모드로 파일 열기

f.write('hello world')     # 문자열 파일 쓰기
f.write('hi\n')            # 줄바꿈 문자 파일 쓰기
print(f.write('test'))     # write() 메소드 반환값 출력

f.close()                  # 파일 닫기

• 해당 test.txt를 확인하여 보면

정상적으로 쓰기가 된 것을 확인

• 파일 읽기
  • file 객체의 read(), readline() 메소드 활용
  • 파일 포인터 위치에서 데이터 읽기
  • 파일 읽기 후 파일 포인터는 다음 데이터로 자동 이동
  • read() : 파일 내용 전체를 읽어 하나의 문자열로 반환
  • read(n) : 파일에서 n개 문자를 읽어와 문자열로 반환
  • readline() : 파일에서 한 줄을 읽어와 문자열로 반환
  • readlines() : 파일에서 각 줄을 항목으로 가지는 리스트를 반환

# 파일 읽기
f = open('test.txt', 'r')   # 읽기 모드로 파일 열기, 'r' 생략가능
print(f.read())             # 파일의 모든 데이터를 문자열로 반환
f.close()

f = open('test.txt')
print(f.read(11))           # 11개의 문자를 읽어와 문자열로 반환
print(f.readline())         # 한 줄을 읽어와 문자열로 반환한다
print(f.readline())         # 한 줄을 읽어와 문자열로 반환한다
f.close()

f = open('test.txt')
print(f.readlines())       # 파일에서 각 줄을 항목으로 가지는 리스트 반환됨
f.close()

 

hello worldhi
test

hello world
hi
test
['hello worldhi\n', 'test']

 

 

# 파일 읽기
f = open('test.txt', 'r')   # 읽기 모드로 파일 열기, 'r' 생략가능
print(f.read())             # 파일의 모든 데이터를 문자열로 반환
f.close()

f = open('test.txt')
print(f.read(11))           # 11개의 문자를 읽어와 문자열로 반환
print(f.readline())         # 한 줄을 읽어와 문자열로 반환한다
print(f.readline())         # 한 줄을 읽어와 문자열로 반환한다
f.close()

f = open('test.txt')
print(f.readlines())       # 파일에서 각 줄을 항목으로 가지는 리스트 반환됨
f.close()

hello worldhi

 

test

hello worldhi

 

test

 

여러 개 오류 처리

• 다중 예외 처리 방법
  • try : 예외가 발생할 수 있는 문장
  • except 오류 타입1: 예외처리 1
  • except 오류 타입2: 예외처리 2 → 오류타입1> 오류타입2이면 예외처리 2 수행안됨

# 예외 처리
try:
  a = [1,2]
  print(a[3])
  1/0
except ZeroDivisionError:
  print("0으로 나누기 오류")
except IndexError:
  print("인덱싱 오류")

 

• finally 블록 : 예외가 발생해도 반드시 수행
  • try: 예외가 발생할 수 있는 문장
  • except 오류타입 : 예외처리
  • finally : 반드시 수행해야 하는 문장(ex. 파일닫기)

try:
  f = open("test2.txt", "r") # 존재하지 않는 파일 
  print(f.read())
except IOError:
  print("파일 입출력 오류 발생")
finally:
  f.close()
  print("finally 블록 수행 확인")