문자열

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

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

문자열 내장 함수

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

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)