[Python] 2일차 - 시퀀스 자료형

김민정·2024년 2월 21일
python개발기술블로그백엔드부트캠프오즈스쿨웹개발초격차캠프코딩코린이프론트엔드

Python

목록 보기
2/4
post-thumbnail

1. 문자열

1. 'input()' & 'print()'

파이썬에서 요소를 입력받아 넣고 싶을때는 input()을 사용하고 (C언어에서 scanf 역할) 출력할때는 print()를 사용한다. input으로 입력한 값은 숫자와 문자 모두 데이터에 저장되기 위해서 문자열로 저장된다.

# 숫자와 문자 변수 설정 및 출력
숫자, 문자 = 5, "5"
print(숫자, 문자)
  
[출력]
5 5

파이썬에서는 문자열끼리의 연산도 가능하다.
그리고 input 괄호 안에 있는 문자열 먼저 나오고 뒤에 입력됨. 그리고 출력시 그 입력값만 출력됨.

# 1 
인사 = input() #scanf와 동일
print(인사)
print(인사 + "수줍게") # 뒤에 바로 문장 추가 가능.
  
[출력] input = 하잉
하잉
하잉수줍게

# 2
인소 = input("(우리 학교 최고 미남) 아...안녕?")
print(인소)

[출력] input = (뭔데)
(우리 학교 최고 미남) 아...안녕?(뭔데)
(뭔데)

# 3
print(type(인소))

[출력]
<class 'str'>

input으로 넣은 값은 형변환도 가능하다.

# 1
정수 = input()
정수 = int(정수)
print(정수, type(정수))
  
[출력] 
input = 5
5 <class 'int'>

# 2
실수 = input()
실수 = float(실수)
print(실수, type(실수))
  
[출력] 
input = 3.14
3.14 <class 'float'>

# 3. 한번에 하기
정수2 = int(input())
print(정수2,type(정수2))
  
[출력] 
input = 9
9 <class 'int'>

input으로 값을 입력 받을 때엔 한번에 하나씩만 가능하다.
그래서 여러개를 받고 싶을 땐 split을 사용해서 받을 수 있다. split()은 띄어쓰기로 변수를 구분하기 때문에 값을 입력할 때 주의해야한다. 띄어쓰기 말고 다른 방법으로 값을 구분하고 싶다면 그 방법을 소괄호 안에 적어주면 된다.

넌센스, 정답 = input().split()
print(f'넌센스 퀴즈 : {넌센스}')
print(f'정답 : {정답}')
퀴즈, 답 = input().split(",")
print(f'퀴즈 : {퀴즈}')
print(f'답 : {답}')
  
[출력]
스페인에서에스파를만나면? 에스파냐
넌센스 퀴즈 : 스페인에서에스파를만나면?
정답 : 에스파냐
스페인에서 에스파를 만나면?, 에스파냐
퀴즈 : 스페인에서 에스파를 만나면?
답 :  에스파냐

이 split은 시퀀스 자료형에도 사용 가능하다.

번호1, 번호2, 번호3, 번호4 = input().split(",")

번호1 = int(번호1)
번호2 = int(번호2)
번호3 = int(번호3)
번호4 = int(번호4)

print(type(번호1), 번호2, 번호3, 번호4)
  
[출력]
123,45,67,89
<class 'int'> 45 67 89

print 함수 속 유용한 기능 2가지가 있다.

1. sep

sep은 출력 값 사이에 작은 따옴표 안에 있는 것 추가하여 출력 추가하는 것이다.

print("초코칩", "민트", "샷추가", "휘핑크림")
print("초코칩", "민트", "샷추가", "휘핑크림", sep='/')
print("초코칩", "민트", "샷추가", "휘핑크림", sep=':')
print("초코칩", "민트", "샷추가", "휘핑크림", sep='   ')
print("초코칩", "민트", "샷추가", "휘핑크림", sep='\n') # 이건 c언어와 동일하게 띄어쓰기
  
[출력]
초코칩 민트 샷추가 휘핑크림
초코칩/민트/샷추가/휘핑크림
초코칩:민트:샷추가:휘핑크림
초코칩   민트   샷추가   휘핑크림
초코칩
민트
샷추가
휘핑크림

2. end

end는 작은 따음표 안에 있는 값 추가하여 한 줄에 출력해준다.

print("초코칩", "민트", "샷추가", "휘핑크림", end=' ')
print("초코칩", "민트", "샷추가", "휘핑크림", end=' ')
  
[출력]
초코칩 민트 샷추가 휘핑크림 초코칩 민트 샷추가 휘핑크림

3. 여러 단어 말하기

첫번째 방법.

name = '김민정'
age = 27
print(f'{name}은 {age}살이다.')
  
[출력]
김민정은 27살이다.

두번째 방법.

print("{name}은 {age}살이다.".format(name = "김민정", age=27))
print("{name}은 {0}살이다.".format(27, name = "김민정"))
  
[출력]
김민정은 27살이다. (둘 다 동일)

format 방법을 이용하여 문자 정열도 가능하다.

print("{0:>16}".format("JRCoding"))	# :> 오른쪽 정렬
print("{0:<16}".format("JRCoding"))	# :< 왼쪽 정렬
print("{0:^16}".format("JRCoding"))	# :^ 가운데 정렬
  
[출력]
        JRCoding
JRCoding        
    JRCoding

2. 내장 함수

함수란 어디에 속해있지 않고 단독 모듈로 따로 함수를 호출하여 사용 가능하다.
다양한 함수는 아래 링크를 통해 확인해볼 수 있다.

메소드란 함수의 클래스 안에 속해 있고 클래스의 멤버 변수들을 이용해서 구현된 것이다.

ex) "까먹으신건가요?".count("까")	# 1 출력
	"까먹으신건가요?".index("까")	# 0 출력

  1. .count
    : 요소의 갯수를 세는 내장함수이다.

  2. .index
    : 해당 요소의 인덱스 번호를 알려주는 내장함수이다.

  3. .find
    : 문자열 내 찾는 문자가 몇번째 문자에 있는지 알려주는 내장함수이다.
    찾는 문자가 없다면 '-1'을, 찾는 문자가 여러개라면 '가장 처음으로 값을 찾은 위치'를 알려준다.

  4. .len
    : 문자열의 길이를 알려주는 내장함수이다.
    위 모두 '변수.함수'이렇게 사용해도 되지만 바로 '"문자열".함수' 로 사용할 수도 있다.

  5. map
    : 괄호안에 메소드들을 누적해서 실행 가능하게 한다.

    # n1, n2, n3, n4 = map(int, input().split(",")) # 형 변환, 입력, 쪼개기 다 이루어짐.
print(type(n1), n2, n3, n4)
  
[출력]
123,45,67,89
<class 'int'> 45 67 89

3. 문자열 수정하는 함수들

  1. .join
    : "원하는 문자".join(변수)
    변수 글자 사이사이마다 원하는 문자를 넣어준다.

  2. .lower() / .upper()
    : "문자열".lower() / "문자열".upper()
    대문자를 소문자로 바꾸고 / 소문자를 대문자로 바꿔준다.

  3. .replace()
    : 변수/"문자열".replace("원래문자(열)", "바뀔문자(열)")
    변수나 문자열을 문자열내 원래 값을 다른 값으로 변환한다.

  4. .split()
    : 변수/"문자열".split(원하는 문자(열))
    변수나 문자열을 원하는 문자(열)로 나눈다.


+) 레거시 코드와 리팩토링

레거시 코드란 누군가 남겨놓고 간 코드를 말한다.
리팩토링이란 결과의 변경 없이 코드의 구조를 재조정하는 것이다. (끝난 프로젝트의 코드 다시 한번 보고 수정하기)

붕어빵 무인 주문 기계 코딩을 리팩토링 해보자.

# 무인 주문 기계 만들기. (리팩토링))
# 붕어빵(팥) : 2000원, 붕어빵 (슈크림) : 2500원, 붕어빵 (잡채) : 3000원

# 붕어빵 변수 설정.
fbp_c, fbs_c, fbj_c = 2000, 2500, 3000

fbp, fbs, fbj = "붕어빵(팥)", "붕어빵(슈크림)", "붕어빵(잡채)"

# 주문 계산.
fbp_o, fbs_o, fbj_o = map(int, input('붕어빵(팥), 붕어빵(슈크림), 붕어빵(잡채) 순으로 갯수 입력. 쉼표로 구분. 안 사는 것 0 입력.').split(","))
fbp_pay, fbs_pay, fbj_pay = fbp_c*fbp_o, fbs_c*fbs_o, fbj_c*fbj_o
total = fbp_o + fbs_o + fbj_o
total_pay = fbp_pay + fbs_pay + fbj_pay

# 붕어빵 값 계산 출력.
print(f'주문이 완료되었습니다. {fbp} {fbp_o}개, {fbs} {fbs_o}개, {fbj}, {fbj_o}개 총 {total}개 결제 금액은 {total_pay}원 입니다.')
  
[출력]
붕어빵(팥), 붕어빵(슈크림), 붕어빵(잡채) 순으로 갯수 입력. 쉼표로 구분. 안 사는 것 0 입력.0,2,3
주문이 완료되었습니다. 붕어빵(팥) 0개, 붕어빵(슈크림) 2개, 붕어빵(잡채), 3개 총 5개 결제 금액은 14000원 입니다.

<문자열 정리>

  • 시퀀스형에서 사용할 수 있는 메소드 (count(), index(), split() 등...)
  • 슬라이싱 ( [:][ : : ] )
  • 요소들이 이루어져 가능했던 기능들 (요소 합치기, 요소 찾기 등등)

2. 자료형 list

list 자료형은 원소들이 연속적으로 저장되는 형태의 자료형으로 어떤 것이든 넣을 수 있다.
list는 sequence 자료형으로 시퀀스 자료형으로는 str(문자열 자료형), list, tuple, dict, set이 있다.

  • list를 만드는 방법은 간단하다.
    1. 대괄호로 묶어주기
    2. 값들 ,로 구분하기.

    리스트 = []
print(리스트)

test = [23, "이게 리스트", 3.23, True, False]
print(test)
  
[출력]
[]
[23, '이게 리스트', 3.23, True, False]

만든 리스트를 재선언할 수도 있다.

리스트 = ["이","렇","게","만","들","어","요"]
print(리스트)
  
[출력]
['이', '렇', '게', '만', '들', '어', '요']

range를 사용하여 연속하는 숫자를 만들 수 있다.

# range(시작, 끝)
range(10) # 0~9까지 10개

# list(range(시작, 끝))
리스트_매직 = list(range(0,20))
print(리스트_매직)
  
[출력]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

시작, 끝 다음에 숫자를 하나 더 넣으면 증감을 원하는대로 조정 가능하다. 단, 시작 숫자는 끝 숫자보다 무조건 작아야하며 클 경우 아무것도 만들지 않는다.

# list(range(시작, 끝, 증가))
리스트_매직_2 = list(range(0,20,2))
print(리스트_매직_2)

리스트_매직_3 = list(range(20,0,-1))
print(리스트_매직_3)

리스트_매직_4 = list(range(20,0))
print(리스트_매직_4)
  
[출력]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[]

변수를 통해서도 리스트에 인수를 넣을 수 있다.

a, b, c = ["들","어","가"]
print(a, b, c)

d, e, f = [7, 7, 8]
print(d, e, f)

지갑 = [10000, 5000, 1000]
# 만원, 오천원, 천원 = 지갑 # 이렇게 해도 들어감. ㅋ
print(f'{만원} 2장, {오천원} 3장, {천원} 1장')
  
[출력]
들 어 가
7 7 8
10000 2장, 5000 3장, 1000 1장

입력값을 받아 split하던 것은 그 각 요소가 리스트의 인수로 저장된다.

input().split()
  
[출력] 기억? 나요? 입력
['기억?', '나요?']

리스트에서 슬라이싱, range 또한 적용된다.

로또 = [3, 5, 15, 33, 41, 44]

# 1. 로또 변수에 있는 리스트의 인덱스 1~2번까지 값 출력해
print(로또[1:3])	# [5, 15] 출력

# 2. 로또 변수의 마지막 위치 출력
print(로또[-1:])	# [44] 출력

# 3. 반대로 출력
print(로또[::-1])	# [44, 41, 33, 15, 5, 3] 출력

# 4. 로또 리스트 안에 33 있는지 확인
print(33 in 로또)	# True 출력

# 5. 로또 리스트 1와 리스트 2 합치기
로또2 = [2, 12, 15, 24, 33, 39]	
print(로또 + 로또2)	# [3, 5, 15, 33, 41, 44, 2, 12, 15, 24, 33, 39] 출력

# 6. range를 이용해서 1부터 10사이 짝수만 들어있는 짝수(변수) 리스트 만들기.
짝수 = list(range(2,12,2))
print(짝수)	# [2, 4, 6, 8, 10] 출력

# 7. 짝수 리스트에 들어있는 값을 2배 늘리고 다시 짝수에 넣기.
짝수 = 짝수 * 2
print(짝수)	# [2, 4, 6, 8, 10, 2, 4, 6, 8, 10] 출력

# 8. 짝수 리스트에 들어있는 요소 갯수
print(len(짝수))	# 10 출력

# 9. 짝수 리스트 3번째 인덱스 출력
print(짝수[3])	# 8 출력

# 10. len() 함수 이용해서 인덱스 마지막 값 출력.
print(짝수[len(짝수)-1]) # ⭐️ 어느 숫자던지 마지막 자리 값 출력을 위해 사용할 수 있다.
# 10 출력

list 내 요소를 변경하는 방법은 appen와 insert, del 함수가 있다.

  • append
    : 마지막 요소에 값을 넣기.

  • insert
    : 원하는 곳에 값을 넣기.

  • del
    : 해당 요소 값 삭제. (슬라이싱 사용 가능)

    mzfood = ["숙주", "분모자", "마라", "소세지", "소고기", "옥수수면"]

# append() 사용
mzfood.append("고수") # 고수 추가
print(mzfood)

# insert() 사용
mzfood.insert(0,"탕후루") # 탕후루 추가
print(mzfood)

# dle 사용
del mzfood[-1] # 고수 빼기
print(mzfood)

del mzfood[0] # 탕후루 빼기
print(mzfood)

# 값 바꾸기 - 요소 위치 정해서 넣기
mzfood[-2] = "양고기"
print(mzfood)
  
[출력]
['숙주', '분모자', '마라', '소세지', '소고기', '옥수수면', '고수']
['탕후루', '숙주', '분모자', '마라', '소세지', '소고기', '옥수수면', '고수']
['탕후루', '숙주', '분모자', '마라', '소세지', '소고기', '옥수수면']
['숙주', '분모자', '마라', '소세지', '소고기', '옥수수면']
['숙주', '분모자', '마라', '소세지', '양고기', '옥수수면']

단, 문자열은 리스트가 아니기 때문에 단어단위로 다른 값으로 변경할 수 없다.

리스트에서 자주 쓰이는 메소드 중에 reverse와 sort가 있다.

  • reverse
    : 순서 뒤집기

  • sort()
    : 오름차순 정렬

    # reverse()
print(mzfood)
print("\n")
mzfood.reverse()
print(mzfood)

# sort()
mzfood.sort()
print(mzfood)

# 괄호에 바로 저 기능들을 추가해서 넣을 시 none 출력.
# none은 빈 변수라는 뜻
	
[출력]
['마라', '분모자', '소세지', '숙주', '양고기', '옥수수면']

['옥수수면', '양고기', '숙주', '소세지', '분모자', '마라']
['마라', '분모자', '소세지', '숙주', '양고기', '옥수수면']

리스트트는 2차 배열도 만들 수 있다.

양파같은 = [[2,0], [3,1]]
print(양파같은)

print(양파같은[0])
print(양파같은[1])
print(양파같은[1][0])

양파같은.append([4,1]) # 2차원 배열 추가도 가능.
print(양파같은)
	
[출력]
[[2, 0], [3, 1]]
[2, 0]
[3, 1]
3
[[2, 0], [3, 1], [4, 1]]

<list 정리>

  • 시퀀스형에서 사용할 수 있는 메소드 (count(), index(), split() 등...) # 초기화시 대괄호
  • 슬라이싱 ( [:][ : : ] )
  • 요소들이 이루어져 가능했던 기능들 (요소 합치기, 요소 찾기 등등)
  • list 메소드 (append(), insert(), del, sort(), reverse 등...)

3. 자료형 tuple

1. tuple (튜플)의 특징

튜플의 method를 print(dir(튜플))로 확인해 볼 수 있다.
확인하면 count, index 가 가능하다.
*python에서는 형 변환이 자유롭기 때문에 문제를 풀기 전에 형 확인이 중요하다.

  1. 소괄호나 값을 , 와 함께 연속적으로 적음으로 튜플을 만들 수 있다.

    튜플 = (1, "이", 3.0)
print(type(튜플))
print(튜플)

튜플2 = 1, "이", 3.0
print(type(튜플2))
print(튜플2)

튜플3 = 1, # 하나의 값만 들어 있는 튜플
print(type(튜플3))
print(튜플3) # 저 , 가 없다면 int 형으로 저장된다.

[출력]
<class 'tuple'>
(1, '이', 3.0)
<class 'tuple'>
(1, '이', 3.0)
<class 'tuple'>
(1,)

  2. .append 나 del과 같은 값 변경이 불가능하다.

    튜플.append("두리안") # 오류 발생.
del 튜플[2] # 오류 발생.
튜플[1] = "메세지" # 오류 발생.

  3. 튜플의 길이를 구할 수 있고 연산으로 요소를 더하고, 복사할 수 있다. 

    print(튜플 + 튜플)
print(튜플*3)

[출력]
(1, '이', 3.0, 1, '이', 3.0) 
(1, '이', 3.0, 1, '이', 3.0, 1, '이', 3.0)

  4. index가 가능하므로 인덱싱이 가능하고, 요소의 갯수 세기 count가 가능하다.

    print(튜플[1:3])

[출력]
('이', 3.0)

2. tuple 사용 이유

  1. 3GO가 불가하기 때문에
    : 여러명이 코딩을 하는 경우 변경되면 안되는 변수 사용할 시, 값이 변경되면 안되는 중요한 데이터를 넣어 보완적으로 관리할 시 유용하다.
    ex) 은행 계좌, 비밀번호 등...

  2. list는 tuple보다 무겁기 때문에
    : 단지 메소드 갯수 때문만이 아니다. 파이썬은 c언어 기반으로 동적배열을 지원한다.
    list로 4개의 값을 생성해서 모두 넣은 후 그 다음 값을 추가할 시 그 과정이 (추가 할당 진행 → 할당시 더블링)이다. 이때 이 메모리 크기가 엄청나게 커질 수 있다.

  3. list 는 가변, tuple은 불변이기 때문에
    : 값이 고정 되어야 하거나 크기가 작을 경우 튜플을 권장한다.

<tuple 정리>

  • 리스트처럼 요소를 일렬로 저장하지만 안에 저장된 요소를 변경, 추가, 삭제할 수 없다. 따라서, 사용할 수 없는 메소드가 많다.
  • tuple 생성 방법
    1. tuple = 값, 값
    2. tuple = (값, 값) # 소괄호!!

4. 자료형 dict

1. dict (딕셔너리)

  • 기본 형태

    # {키 : 값}
# {key1 : value1, key2 : value2}
캐릭터 = {"힘": 30, "지능": 20, "체력": 40, "민첩":90 }
print(캐릭터)

[출력]
{'힘': 30, '지능': 20, '체력': 40, '민첩': 90}

  • 빈 dict 생성

    딕셔너리 = {}
딕셔너리2 = dict()
print(딕셔너리, 딕셔너리2)

# 딕셔너리2 와 같은 방법으로 만들시 기호 " " , : 주의.
딕셔너리3 = dict(힘=30, 지능=20, 체력=40, 민첩=90)
print(딕셔너리3)

[출력]
{} {}
{'힘': 30, '지능': 20, '체력': 40, '민첩': 90}

  • 복잡한 dict

    코디 = {
  "모자" : {
    "캡" : "발렌시아가",
    "비니" : "셀린느"
  },
  "상의" : {
    "후드티" : "칼하트",
    "맨투맨" : "슈프림"
  },
  "하의" : {
    "청바지" : "게스",
    "슬랙스" : "타임"
  }
}
print(코디["모자"]["비니"])

[출력]
셀린느

2. dict의 특징

  1. Indexing 가능하다.

    print(캐릭터["힘"])
print(f'이 캐릭터의 힘은 {캐릭터["힘"]}입니다.')

[출력]
30
이 캐릭터의 힘은 30입니다.

  2. zip으로 병렬처리 할 수 있다.

    딕셔너리4 = dict(zip(["힘", "지능", "체력", "민첩"],[30,20,40,90])) # 배열의 갯수 맞추기 주의!!
print(딕셔너리4)

[출력]
{'힘': 30, '지능': 20, '체력': 40, '민첩': 90}

  3. 값의 중복을 허락한다. 단, 키의 중복은 허락하지 않는다.
    중복될 경우 가장 마지막 값을 가진다.

    캐릭터1 = {"힘": 30, "지능": 20, "체력": 40, "민첩":90, "힘":60, "지구력":45 }
print(캐릭터1)

"체력" in 캐릭터1 # Ture, False로 출력됨.
  
[출력]
{'힘': 60, '지능': 20, '체력': 40, '민첩': 90, '지구력': 45}
True

3. dict의 다양한 method

  1. .key

    print(캐릭터1.keys())

[출력]
dict_keys(['힘', '지능', '체력', '민첩', '손재주', '매력'])

  2. .values

    print(캐릭터1.values())

[출력]
dict_values([60, 100, 40, 90, 35, 100])

  3. .items

    print(캐릭터1.items())
print(type(캐릭터1.items())) # 이거 자체는 indexing화 못함.

[출력]
dict_items([('힘', 60), ('지능', 100), ('체력', 40), ('민첩', 90), ('손재주', 35), ('매력', 100)])
<class 'dict_items'>

  4. list로 형 변환하여 indexing화 가능.

    리스트화 = list(캐릭터1.items())
print(리스트화)
리스트화[0][1]

[출력]
[('힘', 60), ('지능', 100), ('체력', 40), ('민첩', 90), ('손재주', 35), ('매력', 100)]
60

  5. 값의 삭제 및 변경 가능.

    del 캐릭터1["지구력"]
print(캐릭터1)

캐릭터1["지능"]=70
print(캐릭터1)

캐릭터1.update({"손재주":15, "매력":50})	# 새로운 항목 추가도 가능.
print(캐릭터1)

[출력]
{'힘': 60, '지능': 100, '체력': 40, '민첩': 90, '손재주': 35, '매력': 100}
{'힘': 60, '지능': 70, '체력': 40, '민첩': 90, '손재주': 35, '매력': 100}
{'힘': 60, '지능': 70, '체력': 40, '민첩': 90, '손재주': 15, '매력': 50}

4. 연습

# 1 
ozkim = { "국어" : 90, "'수학" : 80, "과학" : 82, "영어" : 72 }
result = (ozkim["국어"]+ozkim["'수학"]+ozkim["과학"]+ozkim["영어"])/len(ozkim)
print(result)

[출력]
81.0

# 2
상자 = {"아디다스": ["신발", "2개"],
            "나이키": ["모자", "5개"],
            "뉴발란스": ["가방", "1개"]}
상자.setdefault('칼하트',["후드티", "2벌"])
print(상자)

[출력]
{'아디다스': ['신발', '2개'], '나이키': ['모자', '5개'], '뉴발란스': ['가방', '1개'], '칼하트': ['후드티', '2벌']}

# 3
keys = ["뉴진스", "아이브", "에스파"]
vals = ["하이브" , "스타쉽", "SM"]
result = dict(zip(keys, vals))
print(result)

[출력]
{'뉴진스': '하이브', '아이브': '스타쉽', '에스파': 'SM'}

<dict 정리>

  • list, tuple, str, range 의 공통적인 특징
    : 데이터의 연관성이 없었다.
  • dict는 여러개의 값이 일렬로 정렬되면서도 값끼리의 연관성이 존재한다.
    ex) 게임 캐릭터 - 힘 : 30, 지능 : 20, 체력 : 40, 민첩 :90
  • 중괄호로 생성한다.

5. 자료형 set

1. set (집합)

set는 수학에서 집합을 의미한다.
만드는 방법에는 아래 두 가지가 있다.

# 만드는 방법 1
세트 = set()
print(세트)

# 만드는 방법 2
세트2 = {} 
print(세트2)

[출력]
set()
{}

시퀀스 자료형의 구분을 위해서 리스트, 튜플, 세트를 비교해본 예제가 아래와 같다.

사과_리스트 = list("apple")
print(사과_리스트)
사과_튜플 = tuple("apple")
print(사과_튜플)
사과_세트 = set("apple")
print(사과_세트)

[출력]
['a', 'p', 'p', 'l', 'e'] ➡️ 대괄호
('a', 'p', 'p', 'l', 'e') ➡️ 소괄호
{'p', 'l', 'e', 'a'} ➡️ 중괄호 & 순서 무관

2. set의 특징

  1. 입력한 값과 출력되는 값의 순서가 다르다.

    채소 = {"당근", "배추", "대파", "양파"}
print(type(채소))
print(채소)

[출력]
<class 'set'>
{'배추', '대파', '당근', '양파'}

  2. 집합의 개념 표현이 가능하다. (합집합, 교집합, 차집합)

    채소1 = {"당근", "양파", "오이", "배추"}
채소2 = {"양파", "오이", "대파", "가지"}

# 합집합 (union)
합집합 = 채소1 | 채소2 # 중복된 요소 삭제
print(합집합)
set.union(채소1, 채소2)

# 교집합 (intersection)
교집합 = 채소1 & 채소2
print(교집합)
set.intersection(채소1, 채소2)

# 차집합 (difference)
차집합 = 채소1 - 채소2
print(차집합)
set.difference(채소1, 채소2)

# 대칭차집합 (symmetric difference)
x = {1, 2, 3, 4, 5}
y = {3, 5, 7, 9}
print(x^y)	# 합집합 - 교집합
print(x > y)	# 포함되어 있나?
x.issuperset(y)	# x가 y의 상위 집합인가?

[출력]
{'가지', '당근', '양파', '배추', '대파', '오이'}
{'오이', '양파'}
{'배추', '당근'}
{1, 2, 4, 7, 9}
False
False

3. set의 다양한 method

  1. .add
    : 한 단어로 추가 요소를 삽입한다. |=이 동일한 기능을 수행한다.

  2. .update
    : 한 글자씩 추가 요소를 삽입한다.

  3. .remove
    : 요소 중에 값이 있으면 해당 요소를 삭제하고 없으면 오류가 발생한다.

  4. .discard
    : 요소 중에 값이 있으면 해당 요소를 삭제하고 없어도 오류가 발생하지 않는다.

  5. .pop
    : 임의의 값 삭제한다. (다른 자료형에서는 맨 뒤의 값 삭제)

    채소.add("토마토")
print(채소)
채소.update("깻잎")
print(채소)
채소 |= {"콩"}
print(채소)

채소.remove("잎")
print(채소)
반환 = 채소.pop()
print(반환)
print(채소)

[출력]
{'양파', '배추', '당근', '토마토', '대파'}
{'양파', '배추', '깻', '당근', '토마토', '잎', '대파'}
{'양파', '콩', '배추', '깻', '당근', '토마토', '잎', '대파'}
{'양파', '콩', '배추', '깻', '당근', '토마토', '대파'}
양파
{'콩', '배추', '깻', '당근', '토마토', '대파'}

<set 정리>

  • set : 수학의 집합을 의미
  • dict과 동일하게 순서 없음.
  • 값의 중복을 허락하지 않음. ⭐️⭐️⭐️
  • 중괄호로 생성 (dict와의 차이점은 key:value가 아니란 것.)

<시퀀스 자료형 정리>

  1. 문자열
  • 시퀀스형에서 사용할 수 있는 메소드 (count(), index(), split() 등...)
  • 슬라이싱 ( [:][ : : ] )
  • 요소들이 이루어져 가능했던 기능들 (요소 합치기, 요소 찾기 등등)
  1. list
  • 시퀀스형에서 사용할 수 있는 메소드 (count(), index(), split() 등...) # 초기화시 대괄호
  • 슬라이싱 ( [:][ : : ] )
  • 요소들이 이루어져 가능했던 기능들 (요소 합치기, 요소 찾기 등등)
  • list 메소드 (append(), insert(), del, sort(), reverse 등...)
  1. tuple
  • 리스트처럼 요소를 일렬로 저장하지만 안에 저장된 요소를 변경, 추가, 삭제할 수 없다. 따라서, 사용할 수 없는 메소드가 많다.
  • tuple 생성 방법
    1. tuple = 값, 값
    1. tuple = (값, 값) # 소괄호!!
  1. dict (dictionary)
  • list, tuple, str, range의 공통적인 특징
    : 데이터의 연관성이 없었다.
  • dict는 여러개의 값이 일렬로 정렬되면서도 값끼리의 연관성이 존재.
    ex) 게임 캐릭터 - 힘 : 30, 지능 : 20, 체력 : 40, 민첩 :90
  • 중괄호로 생성!!!
  1. set
  • set : 수학의 집합을 의미
  • dict과 동일하게 순서 없음.
  • 값의 중복을 허락하지 않음. ⭐️⭐️⭐️
  • 중괄호로 생성!!! (dict와의 차이점은 key:value가 아니란 것.

◉ list = [ ], tuple = ( ), dict = {키 : 값}, set = { } ⭐️⭐️⭐️

<참고 자료>

  • [오즈스쿨 스타트업 웹 개발 초격차캠프 백엔드 Python 강의]
profile
김민정
백엔드 코린이😁
이전 포스트

[Python] 1일차 - 기초 문법, 자료형

다음 포스트

[Python] 3일차 - 조건문, 반복문

0개의 댓글