1. 딕셔너리  dictionary

 

👾  키 key 를 기반으로 값 value을 저장하는 것

       ➡️  '단어'와 '단어의 의미'처럼 사용

👾  딕셔너리는 인덱스가 존재하지 않는 대신 키를 인덱스처럼 사용
       ➡️  키 값을 알면 저장된 값을 확인할 수 있는 구조

 


 

1) 딕셔너리 선언

  ⚡️ 딕셔너리는 중괄호 {} 로 선언하며, 키:값 형태를 쉼표로 연결해서 만든다.

  ⚡️ 키는 문자열, 숫자, 불 등으로 선언 가능

# 딕셔너리 선언 방법
변수 = {
    키:값,
    키:값,
    ...
    키:값
}

# 키값의 자료형이 문자열(str) 이라면 dict() 함수를 이용해서 생성 가능
d = dict(a='apple', b='banana')
print(d)  # {'a': 'apple', 'b': 'banana'}

 

 

💡 딕셔너리 문자열 키와 관련된 오류

    - 키를 문자열로 사용할 때 따옴표를 붙이지 않으면 NameError가 발생한다

dict_key = {
    name : "망고",
    type : "절임"
}
# 이렇게 실행하면 NameError가 발생
# key에 따옴표("")를 붙여줘야 한다

 

2) 딕셔너리 요소 접근

  ⚡️ 리스트처럼 딕셔너리 뒤에 대괄호 []를 입력하고 내부에 인덱스처럼 키를 입력

  ⚡️ 주의할 점은 딕셔너리 선언할 때는 중괄호 {} 사용하지만, 요소에 접근할 때는 대괄호[] 사용

d = {'a': 'apple', 'b': 'banana'}
print(d)  # {'a': 'apple', 'b': 'banana'}
print(type(d))  # <class 'dict'>
print(d['a'])  # apple 
print(d['b'])  # banana

 


 

3) 딕셔너리에 값 추가/제거

 

  ⚡️  딕셔너리에 값을 추가할 때는 키를 기반으로 값을 입력

  ⚡️  setdefault() 메소드를 이용해 추가할 경우 동일한 키가 있는 경우 수정 x

  ⚡️  update() 메소드를 이용해 추가할 경우 동일한 키가 있으면 수정 o

딕셔너리[새로운키] = 새로운 값
dic['watermelon'] = '멜론'
print(dic)  # {'apple': '사과', 'watermelon': '멜론'}

# 존재하는 키값을 이용해서 정의하면, value 수정으로 인식
dic['watermelon'] = '수박'
print(dic)  # {'apple': '사과', 'watermelon': '수박'}

# setdefault() 메소드를 이용한 추가
me = {'name': 'james'}
me.setdefault('age', 20)
print(me)  # {'name': 'james', 'age': 20}
me.setdefault('age', 30) # 동일한 키가 있는 경우에 무시
print(me)  # {'name': 'james', 'age': 20}

# update() 메소드의 경우 존재하는 키값이면 수정
me.update(age=25)
print(me)  # {'name': 'james', 'age': 25}

# update() 메소드의 경우 존재하지 않는 키값이면 추가
me.update(address = 'seoul')
print(me)  # {'name': 'james', 'age': 25, 'address': 'seoul'}

 

 

  ⚡️  del 키워드 or  pop() 메소드를 사용하여 특정 키를 지정하면 해당 요소가 제거

# del 키워드 사용
dic = {'apple' : '사과', 'watermelon' : '수박'}
del dic['apple']  # {'watermelon': '수박'}


# pop() 메소드 사용
dic = {'apple' : '사과', 'watermelon' : '수박'}
dic.pop('watermelon')  # {'apple': '사과'}

 


💡  KeyError 예외

   - 존재하지 않는 키에 접근하면 발생

dic = {}
dic['key']
# -> 존재하지 않는 키이므로 KeyError 발생

 

 


4) 딕셔너리 내부에 키가 있는지 확인

  ⚡️ in 키워드나 get() 함수를 사용해 딕셔너리 내부에 키가 있는지 확인할 수 있다.

# in 키워드 사용
dic = {'a': 'apple', 'b': 'banana', 'c': 'carrot'}
if 'a' in dic:
    print(dic['a'])
else:
    print("존재하지 않는 키에 접근하고 있습니다.)
    
# 실행결과: apple

 

# get() 함수 사용
dic = {'a': 'apple', 'b': 'banana', 'c': 'carrot'}
value = dic.get('b')
print('값 = ', value)  # 값 =  banana

# 존재하지 않는 키 접근
value = dic.get('d')
print('값 = ', value)  
if value == None:
    print('존재하지 않는 키에 접근했습니다.')  
# 실행결과) 
# 값 =  None
# 존재하지 않는 키에 접근했습니다.

 

 

 

 

[ 내용 참고 : IT학원 강의 및 책 '혼자 공부하는 파이썬' ]


 

1. for 반복문

 

🚀   값의 범위나 횟수가 정해져 있을 때 사용하면 편리한 반복문

🚀  for 반복문은 리스트에 있는 요소 하나하나가 변수에 들어가며 차례차례 반복하게 됨

       ➡️  print() 함수로 출력하게 되면 리스트 요소가 차례차례 출력됨
🚀   반복가능객체 ?
        a. 시퀀스 sequence 자료형 : 순서를 가지고 있는 자료형 ( 문자열, 리스트, 튜플, range )
        b. 비시퀀스 non-sequence 자료형 : 순서를 가지고 있지 않은 자료형 ( 세트, 딕셔너리 )

# 기본 구조 
for 변수 in 반복가능객체 :
    반복실행문

 

1) 문자열

for ch in 'Hello':  # 문자열 내부의 문자를 하나씩 꺼내서 사용할 수 있음
    print(ch)
    
'''    
실행결과)
H
e
l
l
o
'''

 


 

2) 리스트

for item in ['가위', '바위', '보']:
    print(item)

# 인덱스 번호 사용 1) 변수생성. 비추천
n = 0
for item in ['가위', '바위', '보']:
    print(f'{n} {item}')
    n += 1

# 인덱스 번호 사용 2) enumerate() 사용. 추천
li = ['가위', '바위', '보']
for i, v in enumerate(li):  # i:index, v:요소의 값 value
    print(f'{i} {v}')

실행 결과

 


 

3) 리스트 내포

# 기본형식
리스트 = [표현식 for 변수 in 반복가능객체]
li = [n * 2 for n in [1, 2, 3]]
print(li)  # [2, 4, 6]

# 조건에 맞는 데이터만 추출 가능
# 리스트 = [표현식 for 변수 in 반복가능객체 if 조건식]
li = [n * 2 for n in [1, 2, 3, 4, 5]]
print(li)  # [2, 4, 6, 8, 10]

li = [n * 2 for n in [1, 2, 3, 4, 5] if n % 2 == 1]  # 1, 3, 5만 추출
print(li)  # [2, 6, 10]

# 리스트 내포를 사용하지 않으면
li = []
for n in [1, 2, 3, 4, 5]:
    if n % 2 == 1:
        li.append(n * 2)
print(li)

 


 

4) 세트 set

👩🏻‍💻  수학의 집합 개념을 구현한 자료형
👩🏻‍💻  저장된 값들은 순서가 없기 때문에 인덱싱과 슬라이싱을 사용할 수 없음
👩🏻‍💻  대신 중복된 값의 저장이 불가능해서 중복 제거용으로 사용

 

    ⚡️  특징
        a. 중복된 값을 저장할 수 없음
        b. 저장되는 순서가 없음

# 중괄호({}) 또는 set() 함수를 이용하여 생성
li = [1, 1, 2, 2, 3, 3]
print(li)  # [1, 1, 2, 2, 3, 3]
print(set(li)) # {1, 2, 3}
li = list(set(li))  #중복된 값을 제거
print(li) # [1, 2, 3]
# 추가를 할 때 add() 메소드 사용
s = {10, 20, 30}
s.add(40) # 세트에 40을 추가
print(s) #{40, 10, 20, 30} / 저장된는 요소들은 순서가 없음

# 삭제를 할 때는 remove()나 discard() 메소드 사용
s.remove(20) # 세트에서 20을 제거. 20이 없으면 오류가 발생
print(s) # {40, 10, 30}

s.discard(30) # 세트에서 30을 제거. 30이 없어도 오류가 발생하지 않음
print(s) # {40, 10}

 

📌  for 반복문과 세트

# 기본형식
for 요소 in {세트}:
    반복실행문
for item in {'가위', '바위', '보'}:  # 순서가 지켜지지 않음
    print(item)

# 실행결과
# 바위
# 보
# 가위

 


 

5)  딕셔너리  

  👾  key와 value의 조합이라 다른 자료형과 다른 방식으로 사용을 함 (키만 출력)

person = {'name': '에밀리', 'age': 20}
for item in person:
    print(item)  # name age

# value 출력
for key, value in person.items():
    print(f'{key}:{value}')

for key in person:
    print(person[key])  # 에밀리 20

for key in person:  # get() 메소드를 이용해서 해당 key에 해당하는 value를 가져옴
    print(person.get(key))  # 에밀리 20

# 영어사전을 딕셔너리 자료형으로 구현하고
# 영어 사전에 등록된 모든 단어와 그 단어의 의미를 출력
eng_dict = {
    'sun': '태양',
    'moon': '달',
    'star': '별',
    'space': '우주'
}
for word in eng_dict:
    print(f'{word}의 뜻: {eng_dict.get(word)}')
    print(f'{word}의 뜻: {eng_dict[word]}')

 


 

2. 중첩 리스트와 중첩 반복문

 

🚀  반복문을 여러 겹 중첩해 사용하면 중첩 반복문

🚀  [1,2,3] 처럼 리스트가 한 겹으로 감싸진 리스트를 1차원 리스트

🚀  [[1,2,3], [4,5,6], [7,8,9]] 처럼 두 겹으로 감싸진 리스트를 2차원 리스트

 

# 2차원 리스트 반복문 한 번 사용
list_of_list = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8]
]

for items in list_of_list:
    print(items)
    
'''
실행결과)
[1, 2, 3]
[4, 5, 6]
[7, 8]
'''
# 2차원 리스트 반복문 두 번 사용
list_of_list = [
    [1, 2, 3]
    [4, 5, 6]
    [7, 8]
]

for items in list_of_list:
    for item in itmes:
        print(item)
'''
실행결과)
1
2
3
4
5
6
7
8
'''

 


 

3. 전개 연산자

 

🚀  전개 연산자를 사용하면 리스트 내용을 전개해서 입력할 수 있다.

🚀  리스트 내부와 함수의 매개변수 위치에 사용

# 리스트 내부에 사용하는 경우
a = [1, 2, 3, 4]
b = [*a]  # [1, 2, 3, 4]
c = [*b, 5]  # [1, 2, 3, 4, 5]
# -> b 내용에 어떠한 영향도 없이 새로운 리스트 c가 만들어짐

# 함수 매개변수 위치에 사용하는 경우
a = [1, 2, 3, 4]
print(*a)  # 1 2 3 4

 

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 책 '혼자 공부하는 파이썬' ]


 

1. 리스트  list

 

🚀  사전적 의미는 '목록'이며 파이썬에서 리스트 의미는 여러가지 자료를 저장할 수 있는 자료

🚀  저장하고자 하는 값들의 자료형(type)이 서로 다르더라도 하나의 리스트에 저장

 

  ⚡️  리스트를 생성하는 방법 : 대괄호 []에 자료를 쉼표로 구분해서 입력 또는 리스트 함수 list() 를 이용해서 생성

  ⚡️  대괄호 내부에 넣는 자료를 요소 element 라고 한다

[요소, 요소, 요소...]

 

# 정수, 실수, 문자열을 각 1개씩 저장하고 있는 리스트 생성
li = [100, 3.14, 'hello']
print(li)  # [100, 3.14, 'hello']
print(type(li))  # <class 'list'>

 

 

100 3.14 hello

                   [0]                                       [1]                                       [2]

                   [-3]                                     [-2]                                     [-1]

 

  👾  각각의 요소는 위와 같은 형태로 저장 된다.

  👾  대괄호 [] 안에 들어간 숫자를 인덱스 index라 부르며, 0부터 센다.

  👾  뒤에서부터 문자를 선택할 때 0이아닌 -1부터 센다

 


 

💡 리스트 접근 연산자를 이중으로 사용하는 방법

list = [333, 7, 'hello', True]
list[2]  # hello
list[2][0]  # h

 

👾  list [2]를 지정하면 'hello'를 꺼내오고 list[2][0] 이면 'hello'에서 다시 0번째를 가져와 출력

 


 

💡  리스트 안에 리스트 사용 가능

list = [[1,2,3], [4,5,6], [7,8,9]]
list[1]  # [4,5,6]
list[1][1]  # [5]

 


 

2. 리스트 연산하기: 연결(+), 반복(*), len()

 

🚀  문자열과 리스트는 비슷한 자료형으로 사용할 수 있는 연산자와 함수도 비슷함

# 리스트 선언
list_a = [1,2,3]
list_b = [4,5,6]

# 출력
print("list_a = ", list_a)
print("list_b = ", list_b)
print()

# 기본 연산자
print("list_a + list_b = ", list_a + list_b)  # 자료 연결
print("list_a * 3 = ", list_a * 3)  # 자료 반복
print()

# 함수
print("len(list_a) = ", len(list_a))

실행 결과

 


 

3. 리스트 정렬: sort(), sorted(), reverse = True

 

🚀  sort(), sorted()는 리스트 요소를 정렬할 때 쓰는 함수로 기본 오름차순 정렬이다

🚀  reverse = True 옵션을 추가할 경우 내림차순 정렬로 반환

리스트.sort()  # 원본이 정렬됨
sorted(리스트명)  # 원본이 정렬된 것 x

 

list_a = [33, 100, 1, 6, 29]
list_a.sort()  # 오름차순 정렬
print(list_a)  # [1, 6, 29, 33, 100]

 

my_list2 = ['b', 'c', 'a', 'd']
print(sorted(my_list2))  # ['a', 'b', 'c', 'd']
print(sorted(my_list2, reverse=True))  # ['d', 'c', 'b', 'a']

my_list = [6, 3, 1, 2, 5, 4]
print(sorted(my_list))  # [1, 2, 3, 4, 5, 6]
print(sorted(my_list, reverse=False))  # [1, 2, 3, 4, 5, 6]
print(sorted(my_list, reverse=True))  # [6, 5, 4, 3, 2, 1]

print(sorted(my_list))  # [1, 2, 3, 4, 5, 6]
print(my_list)  # [6, 3, 1, 2, 5, 4] / 실제로 정렬이 된건 아님

my_list = sorted(my_list)  # 오름차순 정렬 결과를 덮어쓰기
print(my_list)  # [1, 2, 3, 4, 5, 6]

 


 

4. 리스트 내부에 있는지 확인: in/not in 연산자

 

🚀  특정 값이 리스트 내부에 있는지 확인하기 위해 in 연산자 사용

🚀  리스트 내부에 값이 있으면 True, 없으면 False를 출력

🚀  not in 연산자는 리스트 내부에 해당 값이 없는지 확인하는 연산자

 

값 in 리스트
list_a = [273, 33, 100, 51, 99]
273 in list_a  # True
98 in list_a  # False

273 not in list_a  # False
98 not in list_a  # True

 

 

 

 

 

[ 내용 참고 : IT 학원 강의 자료 및 책 '혼자 공부하는 파이썬' ]


 

1. else 조건문

 

🐰  if 조건문 뒤에 사용하며 if 조건문의 조건이 거짓일 때 실행

# if 조건식
#    조건식의 결과가 True일 때 실행문
# else :
#    조건식의 결과가 False일 때 실행문

 

num = 6
if num >= 0:
   print('양수')
else:
   print('음수')

 


 

2. elif 구문

 

🐰  세 개이상의 조건을 연결해서 사용하는 조건문

# if 조건식1 :
#    조건식1의 결과가 True일 때 실행문
# elif 조건식2 :
#    조건식1의 결과가 False이고, 조건식2의 결과가 True일 때 실행문
# elif 조건식3 :
#    조건식1, 2의 결과가 False이고, 조건식3의 결과가 True일 때 실행문
# else :
#    조건식1, 2, 3의 결과가 False일 때 실행문

 

# 나이를 입력받아 7살 이하면 '미취학', 8~13살이면 '초등학생', 14 ~ 16살이면 '중학생',
# 17 ~ 19살이면 '고등학생', 20살 이상이면 '성인'을 출력하는 프로그램입니다.
age = int(input('몇 살입니까? >>> ')) # int() 함수를 이용해서 정수로 변환
if age <= 7:
   print('미취학')
elif age <= 13:
   print('초등학생')
elif age <= 16:
   print('중학생')
elif age <= 19:
   print('고등학생')
else:
   print('성인')

 

  📌  else 구문과 elif 구문은 이전의 조건이 맞지 않을 때 넘어오는 부분

         ➡️ 이미 제외된 조건을 한번 더 검사할 필요 없기 때문에 위의 예제와 같이 간단하게 표현 가능

 


 

3.  pass 키워드

 

🐰  프로그래밍을 하다 보면 전체 골격을 잡아 놓고 내부에서 처리할 내용은 나중에 채워넣는 경우가 있음

       ➡️  이런 경우 if 조건문에 구현 내용을 아무 것도 적어 놓지 않으면 error가 발생함

       ➡️  이때 '곧 개발하겠음' 이라는 의미로 'pass' 키워드를 넣어주면 error가 발생하지 않는다

 

# pass 키워드를 사용한 미구현 부분 입력

num = int(input('정수 입력 >>> '))
if num > 0:
    # 양수일 때 : 미구현 상태
    pass
else:
    # 음수일 때 : 미구현 상태
    pass

 


 

💡 raise NotImplementedError

   -  아직 구현하지 부분이라는 의미의 오류를 강제로 발생하게 함

 

num = int(input('정수 입력 >>> ')

if num > 0:
    # 양수일 때
    raise NotImplemetedError
else:
    # 음수일 때
    raise NotImplementedError

 

 

 

 

 

[ 내용 참고 : IT학원 강의 및 책 '혼자 공부하는 파이썬' ]


 

1. 불  자료형

 

👩🏻‍🚀  불린 Boolean 은 오직 참 True과 거짓 False 값만 가진다.

        ▶️ '어떤 명제'의 결과가 될 때 의미를 갖는다.

 

 

1) 비교연산자

  • 불은 비교연산자를 통해 만들 수 있다.
연산자 설명
== 같다
!= 다르다
< 작다
> 크다
<= 작거나 같다
>= 크거나 같다

 

# True나 False 모두 첫 글자는 반드시 대문자로 작성
# 파이썬에는 False는 값이 없는 모든 경우를 의미. 숫자0, 빈 문자열'', 빈 리스트[] 등은 모두 False로 인식

print(bool(0))  # False
print(bool(''))  # False
print(bool([]))  # False
print(type(True))  # <class 'bool'>

print("가방" == "가방")  # True
print("가방" < "하마")   # True

 

  📌  문자열도 비교 연산자 적용 가능하다. 사전 순서로 '가방'이 '하마'보다 앞에 있기 때문에 작은 값이다.

 

a = 15
print(f'{a} > 10 : {a > 10}') # True
print('{} < 10 : {}'.format(a, a < 10)) # False
print('{} >= 10 : {}'.format(a, a >= 10)) # True
print('{} <= 10 : {}'.format(a, a <= 10)) # False
print('{} == 10 : {}'.format(a, a == 10)) # False
print('{} != 10 : {}'.format(a, a != 10)) # True

 


 

2) 논리 연산자

 

 

연산자 의미 설명
not 아니다 불을 반대로 전환
and 그리고 피연산자 두 개가 모두 참일 때 True, 그 외 모두 False
or 또는 피연산자 두 개 중에 하나만 참이라도 True, 모두 거짓일 때 False

 

📌   not  연산자

  • 단항 연산자로, 참과 거짓을 반대로 바꿀 때 사용
a = 10
b = 0
print('not {} : {}'.format(a, not a)) # False
print('not {} : {}'.format(b, not b)) # True

 

 

📌   and 연산자와  or 연산자

 

[ and 연산자 ]

좌변 우변 결과
True True True
True False False
False True False
False False False

 

[ or 연산자 ]

좌변 우변 결과
True True True
True False True
False True True
False False False

 

a = 10
b = 0
print('{} > 0 and {} > 0 : {}'.format(a, b, a > 0 and b > 0)) # False
print('{} > 0 or {} > 0 : {}'.format(a, b, a > 0 or b > 0)) # True

 


 

2.  if 조건문

 

👩🏻‍💻  파이썬에서 if 조건문은 조건에 따라 코드를 실행하거나, 실행하지 않게 만들고 싶을 때 사용

👩🏻‍💻  이렇게 조건을 기반으로 실행의 흐름을 변경하는 것을 '조건 분기'라고 함

# 기본적인 구조
if 불 값이 나오는 표현식:  
  # if 조건문 뒤에 반드시 콜론(:)을 붙인다
    불 값이 참일 때 실행할 문장
    # 4칸 들여쓰기 한다 -> 들여쓰기 안하면 오류 발생!

 

num = 15
if num > 0:
   print('양수') # 조건식이 True라서 실행이 됨

if True:
   print('양수')

if False:
   print('양수')

 


💡  들여쓰기 indentation 규칙


    a. 공백 space이나 탭 tab을 이용하여 들여쓰기를 수행.
    b. 공백의 개수는 상관이 없음
    c. 탭은 1개만 사용
    d. 동일 구역에서 들여쓰기는 통일해야 함. 공백과 탭을 혼용하여 사용할 수 없고 들여쓰기 수준도 동일해야 함
    e. 주로 사용하는 들여쓰기는 공백 4개, 공백 2개, 탭 1개.

if num > 0: print('양수')  # 실행문이 하나면 한 줄 코드로 가능

 


 

3.  짝수와 홀수 구분

 

# 입력 받기
num = input('정수 입력 >>> ')

# 마지막 자리 숫자 추출
last_num = num[-1]

# 짝수 확인
if last_num in '02468':
    print('짝수입니다.')

# 홀수 확인
if last_num in '13579':
    print('홀수입니다.')

 


# 나머지 연산자 활용 예제
# 임의의 정수를 입력받은 뒤 해당 값이 3의 배수인지 아닌지 판별하는 프로그램을 구현하세요
'''
실행 예)
정수를 입력하세요 >>> 14
14는 3의 배수가 아닙니다.
---------------------
정수를 입력하세요 >>> 15
15는 3의 배수입니다.
'''

num = int(input('정수를 입력하세요 >>> '))
if (num % 3) == 0:
    print(f'{num}는 3의 배수입니다.')
else:
    print(f'{num}는 3의 배수가 아닙니다.')

print(f'{num}는 3의 {"배수입니다."if (num % 3) == 0 else "배수가 아닙니다."}')

 

 

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 책 '혼자 공부하는 파이썬' ]

 


1. 리스트 요소 추가

 

1)  append()

 

👾 '리스트의 끝'에 인수로 전달된 데이터를 추가하는 함수

리스트명.append(요소)
# 리스트 선언
my_list = ['apple', 'banana']
# 리스트 뒤에 요소 추가
my_list.append('cherry')
print(my_list)  # ['apple', 'banana', 'cherry']

 


 

2)  insert()

 

👾  리스트의 특정 인덱스에 데이터를 추가

리스트명.insert(위치, 요소)
# 리스트 선언
my_list = ['apple', 'banana']
# 0번 인덱스에 요소 추가
my_list.insert(0,'cherry')
print(my_list)  # ['cherry', 'apple', 'banana']

 


 

3) extend()

 

👾  한 번에 여러 요소를 추가하고 싶을 때 사용, 매개 변수로 리스트를 입력한다.

       ▶️ 리스트에 다른 리스트나 튜플과 같은 반복가능객체를 추가하여 기존 리스트를 확장

👾  원래 리스트 뒤에 새로운 리스트 요소를 추가

my_list = ['apple', 'banana']
my_list.extend(['cherry', 'mango'])
print(my_list)  # ['apple', 'banana', 'cherry', 'mango']

my_list = ['apple', 'banana']
my_list += ['cherry', 'mango']
print(my_list)  # ['apple', 'banana', 'cherry', 'mango']

 

  📌 리스트 연결 연산자와 요소 추가의 차이

 

    - 리스트 연결 연산자와 extend() 함수는 비슷한 형태로 동작

    - 차이점리스트 연결 연산자는 원본에 어떠한 영향도 주지 않는 '비파괴적'   

                       리스트에 직접적인 영향을 주는 함수 (append(), insert(), extend()) 또는 연산을 '파괴적'

''' 리스트 연결 연산자 '''
list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_a + list_b
# 실행결과 : [1, 2, 3, 4, 5, 6]
print(list_a) # [1, 2, 3]
print(list_b) # [4, 5, 6]
# -> list_a, list_b에 어떠한 변화도 없다 (비파괴적 처리)

''' extend() 함수 '''
list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_a.extend(list_b)
print(list_a)  # [1, 2, 3, 4, 5, 6]
# -> 앞에 입력했던 list_a 자체에 직접적인 변화가 있다 (파괴적 처리)
print(list_b)  # [4, 5, 6]

 

   💡  헷갈리면 위의 예시처럼 직접 하나하나 입력해서 원본에 변화가 있는지 없는지 확인 

 


 

2. 리스트 요소 제거

 

1) 인덱스로 제거:  del 키워드, pop()

 

👾  요소의 위치를 기반으로 요소를 제거

# 1) del 키워드
del 리스트명[인덱스]
del 리스트명[시작_인덱스:종료_인덱스:증감값] # 범위 지정해 한꺼번에 제거, 종료 인덱스는 포함 x
# 2) pop()
리스트명.pop(인덱스)

 

# del 키워드로 제거
my_list = ['apple', 'banana']
del my_list[0]
print(my_list) # 결과 : ['banana']

# pop()으로 제거 
# 리스트의 마지막 요소가 반환되면서 삭제
my_list = ['apple', 'banana']
item = my_list.pop()
print(item)  # 결과 : banana
print(my_list)  # 결과 : ['apple']

# 인덱스 값을 인수로 전달하면 해당 인덱스 값이 삭제
my_list = ['apple', 'banana']
item = my_list.pop(0)
print(item)  # 결과 : apple
print(my_list)  # 결과 : ['banana']

 


 

2) 값으로 제거 :  remove()

 

👾  값을 지정해서 제거하는 함수

리스트.remove(값)

 

# 인수로 전달된 값과 동일한 요소를 찾아서 제거. 동일한 요소가 여러 개인 경우에는 첫 번째 요소가 제거
my_list = ['apple', 'banana', 'cherry', 'mango']
my_list.remove('cherry')
print(my_list)  # ['apple', 'banana', 'mango']

# 중복된 값이 있는 경우 제일 앞에 있는 것만 삭제
my_list = ['apple', 'banana', 'cherry', 'mango', 'cherry']
my_list.remove('cherry')
print(my_list)  # ['apple', 'banana', 'mango', 'cherry']

# 특정 값을 전부 삭제를 원할 경우 반복문 사용.
my_list = ['apple', 'banana', 'cherry', 'mango', 'cherry']
for idx in range(my_list.count('cherry')):
    my_list.remove('cherry')
print(my_list)  # ['apple', 'banana', 'mango']

 


 

3) 모두 제거: clear()

 

👾 리스트 내부의 요소를 모두 제거

리스트.clear()
my_list = ['apple', 'banana']
my_list.clear()
print(my_list)  # []

my_list = ['apple', 'banana']
my_list = []
print(my_list)  # []

 

 

 

 

 

 

[ 내용 참고 : IT 학원 강의 자료 및 책 '혼자 공부하는 파이썬' ]

+ Recent posts