파일 입출력을 알기 전에

파일 입출력을 알기 전에 알아야 하는 개념이 있다.

파일의 논리적 구조

• 파일 안에는 byte들이 순차적으로 저장되어 있다.
• 파일의 맨 끝에는 EOF(end-of-file)마커가 있다.

파일 포인터

파일의 입출력 동작이 발생하는 위치를 파일 포인터라고 한다.

• 파일을 처음 열면, 파일 포인터는 파일의 첫 번째 바이트를 가리킨다.
• 파일의 내용을 읽거나 쓰면 파일 포인터는 자동으로 업데이트(다음 바이트를 가리킴)된다.

파일 열고 닫기

파일 열기

open()함수를 이용하여 파일을 열 수 있다.

close()함수를 이용하여 파일을 닫을 수 있다.

• open() : 파일의 이름을 받아서 파일 객체를 생성한 후 이를 반환
• close() : 파일 객체가 가지고 있는 close()메소드 호출 시 파일 닫힘

open()함수로 파일을 열 때, 어떤 모드로 작업을 할 것인지 명시해야 한다.

file = open("input.txt", "r") #파일 열기(읽기 모드)
#명령
file.close() #파일을 열었으면 꼭 닫아주자

파일 닫기

파일 닫기는 기본적으로 close() 메소드를 이용하여 이루어지지만, 파일을 닫지 않았을 때, 닫히지 않은 파일 때문에 메모리가 계속 낭비되니 꼭 닫아줘야 한다. 아래의 내용은 프로그래머가 실수로 파일을 열고 닫지 않는 것을 방지하는 구문이다.

try - finally 구문 사용

파일을 열 때 오류가 발생되었을 때 사용한다.

finally구문은 오류가 나든 안 나든 무조건 실행되니, 파일을 확실히 닫을 수 있다.

try: # 예외가 발생할 가능성이 있는 작업들을 여기에  둔다.
     infile  = open("input.txt", "r", encoding = "UTF8") #input이 같은 위치에 있다 가정
     #여러가지 파일 처리 작업 코드 작성
finally:# try블록에서 예외 발생시 프로그램 종료 전 반드시  실행된다.
     infile.close( )

with구문 사용

with 명령문 내의 블록이 종료될 때 파일이 자동으로 닫힘

close() 메소드 호출이 필요 없다

with open("input.txt", "r", encoding = "UTF8") as infile:
    line = infile.readline().rstrip()
    while line != "" :
        print(line)
        line = infile.readline()

파일 읽고 쓰기

파일 읽기

한 줄씩 읽기

파일을 열었다면 readline 메소드를 이용하여 한 줄씩 읽을 수 있다.

파일 포인터는 파일의 첫 위치에 있다가 readline 메소드 실행 시 다음 줄로 이동한다.

infile  = open("input.txt", "r", encoding = "UTF8") #input이 같은 위치에 있다 가정
line = infile.readline()
while line != "" :
    print(line)
    line = infile.readline()
#출력 결과
#홍길동
#
#김철수

코드에 보이는 encoding = "UTF8"은 뒤에서 설명하겠다.

이런 식으로 코드를 작성하면 출력 결과와 같이 줄 바꿈이 같이 출력된다.

그 이유는 line 변수 안에 줄 바꿈(\n)이 포함되어 있어서 그런 것이다.

이럴 때는 아래의 코드로 변경해보자

infile  = open("input.txt", "r", encoding = "UTF8") #input이 같은 위치에 있다 가정
line = infile.readline().rstrip() #rstrip을 이용하여 오른쪽에 줄바꿈 문자와 같은 공백 제거
while line != "" :
    print(line)
    line = infile.readline().rstrip()
#출력 결과
#홍길동
#김철수

encoding = "UTF8" -> 인코딩 방식 설정
인코딩(Encoding)은 문자를 바이트로 변환하는 것, 디코딩(Decoding)은 바이트를 문자로 변환하는 것을 말한다
그리고 그 변환하는 방식에 UTF-8, CP949, ANSI 등등이 존재하는데
인코딩과 디코딩 방식이 서로 일치해야 프로그램이 정상적으로 읽어낼 수 있다.
인코딩 방식을 설정하지 않으면, 메모장의 인코딩 방식과 파이썬의 디코딩 방식이 일치하지 않아 오류가 발생한다.

통째로 읽기

파일을 한줄 씩 말고 통째로 읽을 수도 있다.

read()메소드를 이용하면 된다.

with open("input.txt", "r", encoding = "UTF8") as infile:
    all = infile.read()
    print(all)

파일이 무척 크다면 많은 양의 메모리를 필요로 하기 때문에 주의가 필요하다

한 글자씩 읽기

read() 메소드에 매개변수로 1을 입력하면 한 글자씩 읽는다

with open("input.txt", "r", encoding = "UTF8") as infile:
    one = infile.read(1)
    while one != "":
        print(one)
        one = infile.read(1)
#출력 결과
#홍
#길
#동
#
#
#김
#철
#수

파일 쓰기

• “w”모드로  파일을  열었을  때  파일에  쓰기  가능
• wirte() 메소드 사용

with open("input.txt", "w", encoding = "UTF8") as infile:
    infile.write("ReBugs\n")

실행을 해보면 input.txt파일에 ReBugs라고 적혀있는 것을 볼 수 있다.

w모드는 기존에 있던 내용을 초기화하고 새로 쓰는 것을 인지하길 바란다.

이어서 쓰고 싶으면 a모드를 사용하면 된다.

또한 변수의 값을 문자열에 포함시켜서 쓸 수 있다.

with open("input.txt", "w", encoding = "UTF8") as infile:
    url = "https://rebugs.tistory.com/"
    infile.write(f"ReBugs 주소 : {url}\n")

모듈이란?

여러 개의 변수와 함수를 지니고 있는 집합체를 모듈이라고 한다.

  -자바의 라이브러리와 유사한 개념

모듈은 표준 모듈과 외부 모듈로 나뉜다

• 표준 모듈 : 파이썬이 기본적으로 내장하고 있는 모듈
• 외부 모듈 : 개발자가 만들어서 공개한 모듈

여러 개의 변수와 함수를 지닌 집합체를 모듈이라고 하고 이러한 모듈이 합쳐진 것을 패키지라고 한다.

  -모듈을 디렉토리 형식으로 구조화한 것이 패키지

모듈을 사용하는 이유

• 코드 재사용에 유리
• 코드를 기능별로 구분하고 관리에 편리
• 복잡하고 어려운 기능을 포함하는 프로그램을 간단한 코드로 제작 가능

모듈 사용하기

import문으로 모듈을 가져올 수 있다.

import random #랜덤 모듈 가져오기
print(random.randint(0,10))

from문으로 특정 모듈에서 필요한 함수만 가져올 수 있다.

from random import randint
print(randint(0,10))

import문으로만 모듈을 가져오는 것과 차이가 보이가 보이는가?

import문만 사용하면 특정 함수를 호출할 때, 모듈명.함수명() <- 이런 식으로 호출하지만

from문을 사용하면 함수명() <- 이런식으로 간편하게 호출할 수 있다.

하지만 현재 작성중인 프로그램 안에 함수의 이름이 중복되면 오류가 뜨니 유의해야 한다. 

as문으로 모듈에 이름(닉네임)을 붙힐 수 있다.

import random as rd
print(rd.randint(0,10))

모듈의 이름이 길거나 자신이 편한 이름을 붙이고 싶을 때 이용한다.

문자열

문자열도 시퀀스 자료구조에 속함

리스트에서 사용했던 인덱싱, 슬라이싱, 내장함수 모두 문자열에서 쓸 수 있음

문자열 내장 함수

하지만 문자열은 불변객체이기 때문에, 리스트와는 달리 문자열을 바꿀 수 없다.

word = "abcdef"
word[0]="A"
#TypeError: "str" object does not support item assignment

문자열 변경을 위해서는 새로운 사본 생성이 필요하다. ( 대부분 알아서 사본을 생성해주니 크게 신경 안 써도 된다)

word = "abcdef"
word = "A" + word[1:]
print(word)
#출력 결과 : "Abcdef"

문자열의 비교

==, !=, <, > 연산자를 문자열에도 적용 가능

a = input("문자열을 입력하시오: ")
b = input("문자열을 입력하시오: ")
if( a < b ):
	print(a, "가  앞에  있음")
else:
	print(b, "가  앞에  있음")
#문자열을 입력하시오: apple
#문자열을 입력하시오: orange
#apple 가 앞에 있음

문자열 출력하기

print함수의 가변 인수를 활용한 출력

대표적으로 밑의 두 개가 쓰임

• format()
• f-string

x = 25
y = 98
prod = x * y
#format()함수 이용
print("{}과 {}의 곱은 {}".format(x,y,prod))
#f-string이용
print(f"{x}과 {y}의 곱은 {prod}")
#25과 98의 곱은 2450
#25과 98의 곱은 2450

처음 파이썬을 배울 때는 format()함수를 많이 사용하지만, 개인적인 생각으로 f-string이 더 편한 것 같음

대소문자 변환

• capitalize() : 첫문자만  대문자  변환
• lower() : 모든 알파벳 문자가 소문자로 변환된 사본 반환
• upper() : 모든 알파벳 문자가 대문자로 변환된 사본 반환

s = "i am a student."
print(s.capitalize())
s = "Breakfast At Tiffany"
print(s.lower())
print(s.upper())
#I am a student.
#breakfast at tiffany
#BREAKFAST AT TIFFANY

문자열 찾기 및 바꾸기

바꾸기

• startswith(s) : 문자(열) s로 시작되는 문자열이면 True가  반환
• endswith(s) : 문자(열) s로 종료되는 문자열이면 True가  반환
• replace(a,b) : 문자열 내에 a 문자열을 b 문자열로 변환

s = input("파이썬  소스  파일  이름을  입력하시오: ")
if s.endswith(".py"):
    print("올바른  파일  이름입니다")
else :
    print("올바른  파일  이름이  아닙니다.")
#파이썬  소스  파일  이름을  입력하시오: abc.py
#올바른  파일  이름입니다

#파이썬  소스  파일  이름을  입력하시오: abc.cy
#올바른  파일  이름이  아닙니다.

s = "www.naver.com"
print(s.replace("com", "co.kr"))
#출력 결과 : www.naver.co.kr

찾기

• find() : 대상 문자열 안에서 부분 문자열을 찾아서 인덱스를 반환(못 찾으면 -1 리턴)
• rfind() : 끝에서 시작하여 지정된 부분 문자열을 찾아 인덱스 리턴
• count() : 주어진 문자열에서 부분 문자열이 등장하는 숫자 리턴

s = "www.naver.co.kr"
print(s.find(".kr"))
#출력 결과 : 12

s = "Let it be, let it be, let it be"
print(s.rfind("let"))
#출력 결과 22

s = "www.naver.co.kr"
print(s.count("."))
#출력 결과 : 3

문자열 분류, 공백 제거

문자 분류

• isalpha() : 문자열  안에  모든  문자가  알파벳이면  True
• isdigit(): 문자열  안에  모든  문자가  숫자이면  True
• islower(), isupper() : 문자열 안에 모든 문자가 소문자(대문자)이면 True

공백 제거

strip() : 문자열  첫  부분과  끝  부분의  불필요한  공백  제거

• 문자 사이의 공백은 제거하지 않음
• 인수가 전달될 경우 공백이 아닌 인수값으로 전달된 문자 제거
• rstrip(), lstrip() : 오른쪽(왼쪽) 끝의 공백 또는 원치 않는 문자 제거

s = "   Hello, World!   "
print(s.strip()) 
#출력 결과 : Hello, World!

s = "########this is example#####"
print(s.strip("#"))
#출력 결과 : this is example

문자열 분해, 결합

• split() : 문자열 분해 (자세한 설명은 예시 참고 바람)
• join() : 리스트  형태의  단어들을  모아서  하나의  문자열로  만드는  역할(연결될 문자 사이에 들어갈 문자 지정 가능)

s = "Welcome to Python"
print(s.split())
#출력 결과 : ["Welcome", "to", "Python"]

s = "Hello, World!"
print(s.split(","))
#['Hello', ' World!']

s = "Hello, World!"
print(s.split(", "))
#출력 결과 : ['Hello', 'World!']

print(list("Hello, World!"))
#['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!']

print(",".join(["apple", "grape", "banana"]))
#출력 결과 : "apple", "grape", "banana"

print("-".join("010.1234.5678".split(".")))
#출력 결과 : 010-1234-5678

딕셔너리란?

• 다수의 값을 저장하는 구조
• 값(value)과 관련된 키(key)도 저장됨
• 키를 통해 값에 접근
• 순서가 없음

딕셔너리의 생성

딕셔너리_이름 = {키1 : 값1, 키2 : 값2, 키3 : 값3, ........}

capitals = {} #공백 딕셔너리 생성
capitals = {"Korea" : "Seoul", "USA" : "Washingtom", "UK" : "London"} #키와 값을 정의

키는 반드시 불변 객체이며 유일해야 함

-유일한 문자열, 숫자 또는 튜플

항목 탐색하기

capitals ={"Korea":"Seoul","USA":"Washington","UK":"London"} 
print( capitals["Korea"]) # 해당 딕셔너리 키가 없을 경우 예외 발생
#출력 결과 : Seoul

capitals ={"Korea":"Seoul","USA":"Washington","UK":"London"} 
print( capitals.get("France", "해당 키가 없습니다." ) ) #get() : 해당 키가 없을 경우 None 반환 또는 두 번째 인수 반환
#출력 결과 : 해당 키가 없습니다.

항목 추가 및 삭제하기

항목 추가

[  ]  를  사용한  데이터  추가

capitals ={}
capitals["Korea"]="Seoul"
capitals["USA"]="Washington"
capitals["UK"]="London"
capitals["France"]="Paris" print(capitals)
#출력 결과
#{'Korea': 'Seoul', 'USA': 'Washington', 'UK': 'London', 'France': 'Paris'}

딕셔너리  전체를  추가: update() 메소드  사용

capitals.update({“Germany”:”Berlin”, “Japan”:”Tokyo”})

항목 삭제

pop() 메소드 사용: 주어진 키가 없으면 Keyerror 예외 발생

city = capitals.pop("UK")

항목 접근하기

for루프 활용

capitals ={"Korea":"Seoul","USA":"Washington","UK":"London"}
for key in capitals :
	print( key,":", capitals[key])
#Korea : Seoul
#USA : Washington
#UK : London

items() 메소드 활용

capitals ={"Korea":"Seoul","USA":"Washington","UK":"London"} 
for key, value in capitals.items():
	print( key,":", value )
#Korea : Seoul
#USA : Washington
#UK : London

1. items() 함수는 키와 값을 튜플로 반환
2. 반환된 튜플이 key와 value로 언패킹

키와 값의 시퀀스를 각각 반환하기

• key() : 키의 시퀀스를 반환
• value() : 값의 시퀀스를 반환

capitals ={"Korea":"Seoul","USA":"Washington","UK":"London"}
print( capitals.keys())
print( capitals.values())

#출력결과
#dict_keys(['Korea', 'USA', 'UK'])
#dict_values(['Seoul', 'Washington', 'London'])

딕셔너리 메소드

세트의 개념

세트는 우리가 수학에서 배웠던 집합의 개념과 똑같음

세트는 리스트와 다르게 요소는 특정 순서로 저장되지 않으며 위치별로 액세스 할 수 없음

• 순서 유지의 필요가 없어 속도가 빠름
• 순서가 없기에 중복 항목은 지원하지 않음

세트의 생성

세트의 생성
세트_이름 = {항목1, 항목2, 항목3, ...}

numbers = {1,2,3} #초기화된 세트 생성
values = set() #공백 세트 생성​

리스트와 문자열을 사용한 세트의 정의

리스트로 세트 정의

numbers =set([1,2,3,1,2,3])
print(numbers)
#출력 결과 : {1,2,3} 중복 데이터는 하나로 전환

문자열로 세트 정의

letters = set("abcab”)

리스트와 세트 간 전환을 활용한 예제

-리스트의 중복되지 않는 항목의 개수는?

list1 =[1,2,3,4,5,1,2,4 ]
print(len(set(list1)))
#출력 결과 : 5 -> 중복 항목은 제외되었기 때문

-두 리스트 간 중복되는 항목은?

list1 =[1,2,3,4,5]
list2 =[3,4,5,6,7]
print(set(list1)&set(list2))
#출력 결과 : {3, 4, 5} 교집합의 결과

세트와 메소드

all(), any(), enumerate(), len(), max(), min, sorted(), sum()등의 메소드 사용 가능

fruits ={"apple","banana","grape"}
size =len(fruits) #size는 3

in 연산자로 항목 검사 가능

fruits = { "apple", "banana", "grape" }
if "apple" in fruits:
	print("집합  안에  apple이  있습니다.")

인덱스는 없지만 for문을 사용하여 각 항목에 접근 가능(순서는 의미 없음)

fruits ={"apple","banana","grape"}
for x in fruits:
	print(x, end=" ")

fruits ={"apple","banana","grape"}
for x in sorted(fruits): #순서 필요시 sorted함수 사용
	print(x, end=" ")

세트에 요소 추가하고 삭제하기

세트에 요소 추가하기

• add() : 단일 항목
• update() : 여러 항목 추가

fruits ={"apple","banana","grape"}
fruits.add("kiwi")
print(fruits)
#출력 결과 : {'kiwi', 'apple', 'banana', 'grape'}

fruits ={"apple","banana","grape"}
a = {"kiwi","pitch"}
fruits.update(a)
print(fruits)
#출력 결과 : {'banana', 'grape', 'apple', 'pitch', 'kiwi'}

밑의 방법으로 하면 원치 않는 결과가 나옴

fruits ={"apple","banana","grape"}
fruits.update("kiwi","pitch")
print(fruits)
#{'w', 'k', 'i', 'h', 't', 'p', 'grape', 'apple', 'c', 'banana'}

세트에 요소 제거하기

• remove() : 삭제하는 요소가 없으면 예외 발생
• discart() : 예외를 발생시키지 않으려면 이 메소드 사용
• clear() : 모든 요소 삭제

fruits ={"apple","banana","grape","kiwi","pitch"}
fruits.remove("apple")
print(fruits)
#{'banana', 'kiwi', 'pitch', 'grape'}

fruits ={"apple","banana","grape","kiwi","pitch"}
fruits.discard("apple")
print(fruits)
#{'kiwi', 'banana', 'grape', 'pitch'}

fruits ={"apple","banana","grape","kiwi","pitch"}
fruits.clear()
print(fruits)
#출력 결과 : set()

세트의 연산

부분집합 연산 :  < (또는 issubset())

A = {"apple","banana","grape"}
B = {"apple","banana","grape","kiwi"}

if A < B:
	print("A는 B의 부분 집합")

집합간 비교 연산 : ==, !=

A = {"apple","banana","grape"}
B = {"apple","banana","grape","kiwi"}

if A == B:
	print("A와 B는 같습니다")
else : 
	print("A와 B는 같지 않습니다")

합집합, 교집합, 차집합 연산

C = A|B 또는 C = A.union(B)

C = A&B 또는 C = A.intersection(B)

C = A-B 또는 C = A.difference(B)

A ={"apple","banana","grape"}
B ={"orange","banana","grape"}

print(A|B) #합집합
print(A&B) #교집합
print(A-B) #차집합

#출력 결과
#{'grape', 'apple', 'orange', 'banana'}
#{'banana', 'grape'}
#{'apple'}

튜플이란

튜플은 리스트와 동일한 형태

다른 점은 리스트와 다르게 변경이 불가능하다(read-only)

• 나머지 기능(인덱싱, 슬라이싱 등)은 리스트와 동일함
• 튜플은 소괄호()를 사용하여 정의

fruits = () #공백 튜플 생성
fruits = ("apple","banana","grape") #초기값을 가진 튜플 생성

result = fruits[1] # 인덱스를 사용해서 요소 접근 가능

튜플은 괄호 없이 항목을 쉼표로 분리하여도 자동으로 튜플을 생성함

fruits = ("apple","banana","grape")
fruits = "apple", "banana", "grape" #괄호 없이 튜플 생성

튜플 생성 시 주의할 점

요소가 하나뿐인 튜플을 만들 때는 요소의 끝에 반드시 쉼표를 추가해야 함

쉼표가 없으면 튜플이 아니라 문자열로 인식함

single_tuple = ("apple",)
no_tuple = ("apple") #쉼표가 없으면 문자열임

튜플은 읽기만 가능

fruits = ("apple", "banana", "grape")
fruits[1] = "pear" #TypeError: "tuple" object does not support item assignment

튜플과 리스트 간 전환

생성자 함수를 사용하여 변환 가능

#리스트 -> 튜플
myList = [1,2,3,4]
myTuple = tuple(myList) # tuple()는  튜플을  생성하는  함수(생성자)이다.
print(myTuple)
#출력 결과 : (1,2,3,4)

myTuple = (1, 2, 3, 4)
myList = list(myTuple) # list()는  리스트를  생성하는  함수(생성자)이다.
print(myList)
출력 결과 : [1, 2, 3, 4]

튜플 연산

튜플은 한번 생성되면 요소의 추가 및 삭제 불가능함

하지만 += 연산자를 이용하여 다른 튜플을 추가하는 것은 가능함

->기존 튜플이 변경되는 것이 아닌 새로운 튜플을 만드는 것임

fruits = ("apple", "banana", "grape")
fruits += ("pear", "kiwi")
print(fruits)
#출력 결과 : ("apple", "banana", "grape", "pear", "kiwi")

+=연산자를 이용하여 리스트에 튜플을 추가할 수 있다

numbers = [10, 20, 30]
numbers += (40, 50)
print(numbers)
#출력 결과 : [10, 20, 30, 40, 50]

튜플 패킹과 언패킹

패킹은 여러 개의 항목을 합쳐서 튜플을 만드는 것을 뜻함

언패킹은 튜플에 저장된 데이터를 개별 변수로 푸는 것을 뜻함

자료형이 다른 경우에도 패킹과 언패킹이 가능하다

student = (“kim”, [3.1, 3.6, 4.0, 0.0])
name, grades = student #언패킹
print(name) # Kim
print(grades) # [3.1, 3.6, 4.0, 0.0]

튜플은 기본적으로 변경이 불가능하다고 위에서 언급했다

하지만 위의 예제에서 튜플의 요소로 리스트가 들어가 있는데,

이럴 경우 요소로 들어간 리스트에 대한 수정은 가능하다.

student[1][3] = 4.3 #가능

패킹과 언패킹을 활용해서 변수의 값 스왑 하기

n1 = 10 
n2 = 90
n1, n2 = (n2, n1)   # (90 10)​

enumerate()

enumerate()함수는 리스트 또는 튜플에 대해, 각 요소 별 (인덱스, 값) 형태의 튜플 반환

튜플은 왜 쓸까?

• 변경 불가능 객체이기에 튜플을 통한 반복이 더 빠름
• 변경 불가능 객체이기에 딕셔너리 키로 사용 가능
• 다른 개발자가 특정 데이터를 변경하는 것을 금지 가능(보안성)

이전 리스트에 관한 글을 읽고 싶다면

2022.12.06 - [Language/Python] - [Python] 리스트(1)

리스트 합병, 복제, 비교

리스트의 합병 및 복제

+연산자를 활용하여 2개의 리스트를 하나로 합병 가능

heroes1 = [ "아이언맨", "토르" ]
heroes2 = [ "헐크", "스칼렛 위치" ] 
avengers = heroes1 + heroes2 
# avengers는 ['아이언맨', '토르', '헐크', '스칼렛 위치']가 됨​

*연산자를 활용하여 복제 후 합병 가능

numbers = [ 1, 2, 3, 4 ] * 3  
# 리스트는 [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

리스트 초기화에 활용

numbers = [ 0 ] * 12                             
# 리스트는 [0,0,0,0,0,0,0,0,0,0,0,0]

리스트 비교

비교 연산자 == , !=, >, < 를 사용하여 리스트 간 비교 가능

list1 = [ 1, 2, 3 ] 
list2 = [ 1, 2, 3 ]
print(list1 == list2) #True

list1 = [ 3, 4, 5 ]
list2 = [ 1, 2, 3 ]
print(list1 > list2) #첫번째 인덱스만 비교함
#출력 결과는 True
for  i in range(3): #모든 인덱스 비교
    print(list1[i] > list2[i])
#출력 결과는
#False
#False
#False​

리스트 복사 : 얕은 복사(shallow copy)

temps = [28, 31, 33, 35, 27, 26, 25] 
values = temps

temps: temps리스트의 시작항목의 주소
values: temps리스트의 시작항목의 주소
temps, values 둘 다 같은 공간을 참조하고 있음

temps = [28, 31, 33, 35, 27, 26, 25] 
values = temps      #얕은 복사 (shallow copy)
print(temps)
values[3] = 39
print(temps)
#[28, 31, 33, 35, 27, 26, 25]
#[28, 31, 33, 39, 27, 26, 25]

둘 다 같은 공간을 참조하기 때문에 한 쪽만 값을 바뀌어도 둘 다 값이 바뀌게 된다.

리스트 복사 : 깊은 복사(deep copy)

temps = [28, 31, 33, 35, 27, 26, 25] 
values = list(temps) #복사 생성자 활용

list의 복사 생성자를 활용하면 깊은 복사를 할 수 있다.

이렇게 하면 한 공간을 참조하지 않기 때문에 한쪽 값을 바꾸어도 다른 쪽은 영향을 받지 않는다.

슬라이싱

기본 슬라이싱

슬라이싱이란 리스트에서 한 번에 여러 개의 항목을 추출하는 기법이다.
리스트[start : stop]

numbers = [10, 20, 30, 40, 50, 60, 70, 80, 90]
sublist = numbers[2:7]

2번째 인덱스(30) 에서 6번째 인덱스까지(70)([2:7]에서 7은 포함하지 않는다) 추출한다는 뜻이다

시작과 끝 인덱스는 생략이 가능하다

numbers= [10,20,30,40,50,60,70,80,90]
numbers[:3] # [10, 20, 30]
numbers[3:] # [40, 50, 60, 70, 80, 90]
numbers[:] # [10, 20, 30, 40, 50, 60, 70, 80, 90]

깊은 복사의 또 다른 방법

new_numbers = numbers[:]​

고급 슬라이싱

슬라이싱을 할 때 단계 지정이 가능
리스트[start:stop:step]

numbers= [10,20,30,40,50,60,70,80,90]
numbers[2:7:2] # [30, 50, 70]

음수 단계를 사용하여 리스트 역순화

numbers = [ 10, 20, 30, 40, 50, 60, 70, 80, 90 ]
numbers[:: -1]
#[90, 80, 70, 60, 50, 40, 30, 20, 10]​

리스트 변경

lst = [1, 2, 3, 4, 5, 6, 7, 8]
lst[0:3] = ['white', 'blue', 'red']
#lst : ['white', 'blue', 'red', 4, 5, 6, 7, 8]​

lst = [1, 2, 3, 4, 5, 6, 7, 8]
lst[:] = [ ]
#lst : []​

lst = [1, 2, 3, 4, 5, 6, 7, 8]
del lst[0:2]
lst : [3, 4, 5, 6, 7, 8]​

파이썬에서 문자열은 문자들이 모여있는 리스트이다.

s = "Monty Python"
print(s[0]) #M
print(s[6:10]) #Path
print(s[-12:-7]) #Monty​

2차원 리스트

2차원 리스트란

2차원 리스트는 1차원 리스트가 행과 열을 이루어 모여있는 것

정적 할당 2차원 리스트

2차원 리스트 구현(정적 할당)
-각각의 행들이 하나의 리스트 형태로 저장
-각각의 행에 대한 레퍼런스(주소)가 하나의 리스트 형태로 저장

s = [
	[ 1, 2, 3, 4, 5 ] ,
	[ 6, 7, 8, 9, 10 ], 
	[11, 12, 13, 14, 15 ] 
    ]​

동적 할당 2차원 리스트

2차원 리스트의 동적 할당

rows = 3 
cols = 5
s = [ ]
for row in range(rows): 
	s += [[0]*cols] # 1차원  리스트끼리  순차적으로  합쳐짐
print("s =", s)
# [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]​

2차원 리스트 요소 접근

s = [[ 1, 2, 3, 4, 5 ] ,[ 6, 7, 8, 9, 10 ], [11, 12, 13, 14, 15 ] ]
print(s[1][1]) #7
print(s[2][1]) #12
#7
#12

2차원 리스트의 구현

s = [[ 1, 2, 3, 4, 5 ] ,[ 6, 7, 8, 9, 10 ], [11, 12, 13, 14, 15 ] ]

rows = len(s)
cols = len(s[0])

for r in range(rows):
  for c in range(cols):
    print(s[r][c], end=",")
  print( )

출력결과

리스트와 함수

일반적 프로그래밍 언어에서 함수의 인수 전달 방식
값으로 호출 (call by value)
참조로 호출 (call by reference)

불변 객체(int, float, tuple, string등)

파이썬에서는?
불변 객체(int, float, tuple, string등) :
객체의 참조값이 함수의 매개 변수로 전달되지만
함수 안에서 객체의 값을 변경하면 새로운 객체가 생성 (call by value형태)

가변 객체 (리스트)

가변 객체 (리스트) :
참조값으로 전달되며, 함수 내에서 리스트의 변경이 가능 (call by reference)

2차원 리스트를 함수로 넘기기

2차원 배열의 총 합을 구하는 함수

def sum(numbers) :
  total = 0
  for i in range(len(numbers)) :
    for j in range(len(numbers[0])) :
      total = total + numbers[i][j]
  return total
  
s = [[ 1, 2, 3, 4, 5 ] ,[ 6, 7, 8, 9, 10 ], [11, 12, 13, 14, 15 ] ]
print(sum(s))

출력 결과 : 120

리스트의 개요

리스트란?

- 리스트는 항목들을 저장하는 컨테이너로서 그 안에 항목들이 순서를 가지고 저장됨
- 리스트의 크기는 항목의 개수가 증가(감소)하면 자동으로 증가(감소)함 -> 동적 할당
- 리스트는 어떤 타입의 항목이라도 저장할 수 있음
- 파이썬에서 리스트는 가장 많이 사용되는 데이터 구조

리스트 항목 접근하기

• 인덱스(index) : 리스트에서의 항목의 위치(번호)
• 0부터 시작(메모리 주소 계산의 편의성)

리스트의 항목 변경

list1 = ["가", "나", "다", "라", "마"]
list1[2] = "안녕" #2번째 인덱스의 값 변경
print(list1)

출력 결과는 ['가', '나', '안녕', '라', '마']이다.

음수 인덱스

마지막 데이터에 대한 빠른 접근 허용

리스트의 마지막 데이터에 접근하는 2가지 방법

• list1[-1]
• list1[len(list1)-1]

리스트 접근

리스트 안에 저장된 요소들을 모두 접근하기 위해서는?

• 첫 번째 방법 : 인덱스 값을 사용하여 접근

list1 =[28,31,33,35,27,26,25]
for  i in  range(len(list1)):
	print(list1[i], end=', ') #end=',’는  출력  후  엔터  대신  ,를  붙임

 출력 결과는 28, 31, 33, 35, 27, 26, 25,

• 두 번째 방법 : 인덱스 값이 필요 없다면 for-each 루프 사용

list1 =[28,31,33,35,27,26,25] 
for  element in  list1:
    print(element, end=', ')

 출력 결과는 28, 31, 33, 35, 27, 26, 25,

zip() 함수

zip() 함수는 2개의 리스트를 받아서 항목 2개를 묶어서 제공함

questions =['name','quest','color'] 
answers =['Kim','파이썬','blue']
for  q, a  in  zip(questions, answers): 
    print(f"What is your {q}? It is {a}")

출력 결과

What is your name? It is Kim
What is your quest? It is 파이썬
What is your color? It is blue

리스트의 연산

append()

새로운 요소를 리스트의 맨 끝에 추가

heroes = [ ] 
heroes.append("아이언맨")
heroes.append("토르") 
print(heroes)

실행 결과 : ['아이언맨', '토르']

insert()

지정된 위치에 요소를 추가

index()

특정 항목이 리스트에 어느 위치에 있는지 확인

heroes = [ “아이언맨”  , “토르”  , “헐크”, “스칼렛  위치”, “헐크” ]
n = heroes.index(“헐크”) #n은 2가 됨

탐색 시작 위치 지정 가능

heroes = [ "아이언맨", "토르", "헐크", "스칼렛  위치", "헐크" ]
n = heroes.index("헐크", 3) #n은 4가 됨

탐색하고자 하는 항목이 리스트에 없으면 오류가 발생한다는 것을 주의해야 함

in 연산자

리스트 안에 특정 항목이 있는지 알기 위함

l_list = [0,1,2,3,4,5,6,7,8,9]
if 5 in l_list: #5가 리스트에 있다면
	print("5는 리스트에 있습니다")
else:
	print("5는 리스트에 없습니다")

not in 연산자

리스트 안에 특정 항목이 없는지 알기 위함

l_list = [0,1,2,3,4,5,6,7,8,9]
if 10 not in l_list: #리스트에 10이 없다면
	l_list.append(10) #리스트에 10 추가
else:
	print("10는 리스트에 이미 있습니다.")

pop(), remove()

pop(i) : 리스트에서 i번째 항목을 삭제하여 반환

(i가 없으면 마지막 데이터 삭제 후 반환)

remove() : 리스트에서 지정된 값을 삭제, 값을 반환하진 않음

heroes = [ "아이언맨", "토르", "헐크" ]
heroes.remove("토르")

삭제하고자 하는 항목이 없다면 오류(예외)가 발생

리스트 항목의 최댓값과 최솟값

max()와 min()은 내장 함수로서 거의 모든 객체에 사용 가능

values = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
min(values) # 1 반환
max(values) # 10 반환

리스트의 정렬

메소드 사용

a = [ 3, 2, 1, 5, 4 ]
a.sort() #[1,2,3,4,5] #오름차순으로 정렬

heroes =['아이언맨','헐크','토르']
heroes.sort()
# ['아이언맨', '토르', '헐크']

a = [ 3, 2, 1, 5, 4 ]
a.sort(reverse = True) #[5,4,3,2,1] #내림차순으로 정렬

내장 함수 사용

numbers =[10,3,7,1,9,4,2,8,5,6] 
ascending_numbers = sorted(numbers)
print(ascending_numbers)

리스트 메소드 정리

리스트에 대해 더 알고 싶다면

2022.12.06 - [Language/Python] - [Python] 리스트(2)