MIND UPLOAD

# day4 (2023-12-07)

# 시퀀스 자료형

#시퀀스 자료형(sequence types) : 리스트, 튜플, range, 문자열
# 시퀀스 객체 : 시퀀스 자료형으로 만든 객체
# 요소(element) : 시퀀스 객체에 들어있는 각 값
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
print(30 in a) # 특정 값이 있는지
print(100 not in a) # 특정 값이 없는지
# 튜플, range, 문자열도 같은 방법으로 활용
print(43 in (38, 76, 43, 62, 19))
print(1 in range(10))
print('P' in 'Hello, Python')
1
2
3
4
5
6
7
8
9
10
True
True
True
True
True

#시퀀스 객체 연결하기 : + 연산자를 사용하여 객체를 서로 연결하여 새 객체를 만들 수 있다.
a = [0, 10, 20, 30]
b = [9, 8, 7, 6]
a + b
1
2
3
4
[0, 10, 20, 30, 9, 8, 7, 6]

# 시퀀스 자료형 중에서 range는 + 연산자로 객체를 연결할 수 없습니다.
# range(0, 10) + range(10, 20) !!!Error!!!
# range를 리스트 또는 튜플로 만들어서 연결.
a = list(range(0, 10)) + list(range(10, 20))
b = tuple(range(0, 10)) + tuple(range(10, 20))
print(a)
print(b)
print('Hello, ' + 'world!') # 문자열 연결은 여러 가지 결과를 묶어서 한 번에 출력할 때 자주 사용
1
2
3
4
5
6
7
8
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)
Hello, world!

#문자열에 숫자 연결하기
# 'Hello, ' + 10 !!!Error!!!
'Hello, ' + str(10)      # str을 사용하여 정수를 문자열로 변환
1
2
3
'Hello, 10'

# 시퀀스 객체 반복하기
# * 연산자는 시퀀스 객체를 특정 횟수만큼 반복하여 새 시퀀스 객체를 만듭니다
# (0 또는 음수를 곱하면 빈 객체가 나오며 실수는 곱할 수 없습니다).
[0, 10, 20, 30] * 3
1
2
3
4
[0, 10, 20, 30, 0, 10, 20, 30, 0, 10, 20, 30]

# range는 * 연산자를 사용하여 반복할 수 없다.
# range(0, 5, 2) * 3 !!! Errir !!!
# range를 리스트 또는 튜플로 만들어서 반복하면 됩니다.
list(range(0, 5, 2)) * 3
tuple(range(0, 5, 2)) * 3
1
2
3
4
5
[0, 2, 4, 0, 2, 4, 0, 2, 4]

# 문자열은 * 연산자를 사용하여 반복할 수 있다.
'Hello, ' * 3
1
2
'Hello, Hello, Hello, '

# 리스트와 튜플의 요소 개수
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
len(a)
b = (38, 76, 43, 62, 19)
len(b)
1
2
3
4
5
5

len(range(0, 10, 2)) # range에 len 함수를 사용하면 숫자가 생성되는 개수를 구함.
1
5

hello = 'Hello, world!' # 문자열의 길이 구하기
len(hello)
1
2
13

hello = '안녕하세요'
len(hello)
1
2
5

# UTF-8 문자열의 바이트 수 구하기
# 한글, 한자, 일본어 등 UTF-8 인코딩 문자열이 차지하는 실제 바이트 수를 구하는 방법
hello = '안녕하세요'
len(hello.encode('utf-8'))
# UTF-8에서 한글 글자 하나는 3바이트로 표현하므로 '안녕하세요'가 차지하는 실제 바이트 수는 15바이트
# 파이썬 3에서 len은 문자의 개수를 구해주지만 파이썬 2.7에서는 실제 바이트 수를 구해주는 차이점이 있다
1
2
3
4
5
6
15

# 시퀀스객체 인덱스(index, 색인)
a = [38, 21, 53, 62, 19]
a[0]    # 리스트의 첫 번째(인덱스 0) 요소 출력
a[2]    # 리스트의 세 번째(인덱스 2) 요소 출력
a[4]    # 리스트의 다섯 번째(인덱스 4) 요소 출력
1
2
3
4
5
19

# 튜플 b의 첫 번째(인덱스 0) 요소를 출력
b = (38, 21, 53, 62, 19)
b[0]        # 튜플의 첫 번째(인덱스 0) 요소 출력
1
2
3
38

# range도 인덱스로 접근할 수 있다.
r = range(0, 10, 2)
r[2]        # range의 세 번째(인덱스 2) 요소 출력
1
2
3
4

# 다음은 문자열 hello의 여덟 번째 요소를 출력합니다.
hello = 'Hello, world!'
1
2
# 다음은 문자열 hello의 여덟 번째 요소를 출력합니다.
hello = 'Hello, world!'
hello[7]    # 문자열의 여덟 번째(인덱스 7) 요소 출력
1
2
3
'w'

a = [38, 21, 53, 62, 19]
a    # 시퀀스 객체에 인덱스를 지정하지 않으면 시퀀스 객체 전체를 뜻함
1
2
[38, 21, 53, 62, 19]

# 시퀀스 객체에서 [ ](대괄호)를 사용하면 실제로는 __getitem__ 메서드를 호출하여 요소를 가져옴.
# __getitem__ 메서드를 직접 호출하여 요소를 가져올 수도 있다.
a = [38, 21, 53, 62, 19]
a.__getitem__(1)
1
2
3
4
21

# 음수 인덱스 지정
a = [38, 21, 53, 62, 19]
a[-1] ,a[-5]  # 리스트의 뒤에서 첫 번째(인덱스 -1), 다섯 번째(인덱스 -5) 요소 출력
1
2
3
(19, 38)

# 튜플, range, 문자열 음수 인덱스
b = (38, 21, 53, 62, 19)
b[-1]        # 튜플의 뒤에서 첫 번째(인덱스 -1) 요소 출력
1
2
3
19

# range 음수 인덱스
r = range(0, 10, 2)
r[-3]        # range의 뒤에서 세 번째(인덱스 -3) 요소 출력
1
2
3
4

# 문자열 음수 인덱스
hello = 'Hello, world!'
hello[-4]    # 문자열의 뒤에서 네 번째(인덱스 -4) 요소 출력
1
2
3
'r'

# 인덱스의 범위를 벗어나면?
a = [38, 21, 53, 62, 19]
# a[5]    # 인덱스 5는 범위를 벗어났으므로 에러
1
2
3
# 마지막 요소에 접근하기
a = [38, 21, 53, 62, 19]
len(a)    # 리스트의 길이를 구함
a[len(a) - 1]    # 마지막 요소(인덱스 4) 출력
1
2
3
4
19

# 시퀀스 객체의 요소에 값 할당하기
a = [0, 0, 0, 0, 0]    # 0이 5개 들어있는 리스트
a[0] = 38
a[1] = 21
a[2] = 53
a[3] = 62
a[4] = 19
a
1
2
3
4
5
6
7
8
[38, 21, 53, 62, 19]

# 튜플,range와 문자열 [ ]에 인덱스를 지정한 뒤 값을 할당하면 에러가 발생합니다.
# 튜플, range, 문자열은 읽기 전용
hello = 'Hello, world!'
# hello[0] = 'A' !!!ERROR!!!
1
2
3
4
# del로 요소 삭제하기
a = [38, 21, 53, 62, 19]
del a[2]
a
# 튜플, range와 문자열은 요소를 삭제할 수 없다.
1
2
3
4
5
[38, 21, 62, 19]

a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
a[0:4]     # 인덱스 0부터 3까지 잘라서 새 리스트를 만듦
1
2
[0, 10, 20, 30]

# [ ] 안에 시작 인덱스와 끝 인덱스를 지정하면 해당 범위의 리스트를 잘라서 가져올 수 있다.
# 끝 인덱스는 가져오려는 범위에 포함되지 않는다.
# 끝 인덱스는 실제로 가져오려는 인덱스보다 1을 더 크게 지정
a[0:10]    # 인덱스 0부터 9까지 잘라서 새 리스트를 만듦
1
2
3
4
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
a[1:1]    # 인덱스 1부터 0까지 잘라서 새 리스트를 만듦
a[1:2]    # 인덱스 1부터 1까지 잘라서 새 리스트를 만듦
1
2
3
[10]
1
[10]

a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
a[4:7]     # 인덱스 4부터 6까지 요소 3개를 가져옴
a[4:-1]    # 인덱스 4부터 -2까지 요소 5개를 가져옴
1
2
3
[40, 50, 60, 70, 80]

# 시퀀스객체[시작인덱스:끝인덱스:인덱스증가폭]
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
a[2:8:3]    # 인덱스 2부터 3씩 증가시키면서 인덱스 7까지 가져옴
1
2
3
[20, 50]

# 인덱스 생략하기
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
print(a[:7]) # 리스트 처음부터 인덱스 6까지 가져옴
print(a[7:]) # 인덱스 7부터 마지막 요소까지 가져옴
print(a[:]) # 리스트 전체를 가져옴
print(a[:7:2])   # 리스트의 처음부터 인덱스를 2씩 증가시키면서 인덱스 6까지 가져옴
print(a[7::2])    # 인덱스 7부터 2씩 증가시키면서 리스트의 마지막 요소까지 가져옴
print(a[::2])     # 리스트 전체에서 인덱스 0부터 2씩 증가시키면서 요소를 가져옴
print(a[::])    # 리스트 전체를 가져옴
print(a[5:1:-1]) # 인덱스 5부터 2까지 1씩 감소시키면서 요소를 가져옵
print(a[::-1]) # 리스트 전체에서 인덱스를 1씩 감소시키면서 요소를 가져오
1
2
3
4
5
6
7
8
9
10
11
[0, 10, 20, 30, 40, 50, 60]
[70, 80, 90]
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
[0, 20, 40, 60]
[70, 90]
[0, 20, 40, 60, 80]
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
[50, 40, 30, 20]
[90, 80, 70, 60, 50, 40, 30, 20, 10, 0]

# len 응용하기
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
print(a[0:len(a)])   # 시작 인덱스에 0, 끝 인덱스에 len(a) 지정하여 리스트 전체를 가져옴
print(a[:len(a)])     # 시작 인덱스 생략, 끝 인덱스에 len(a) 지정하여 리스트 전체를 가져옴
1
2
3
4
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

# 튜플, range, 문자열에 슬라이스 사용하기
b = (0, 10, 20, 30, 40, 50, 60, 70, 80, 90)
print(b[4:7])     # 인덱스 4부터 6까지 요소 3개를 가져옴
print(b[4:])      # 인덱스 4부터 마지막 요소까지 가져옴
print(b[:7:2])    # 튜플의 처음부터 인덱스를 2씩 증가시키면서 인덱스 6까지 가져옴
1
2
3
4
5
(40, 50, 60)
(40, 50, 60, 70, 80, 90)
(0, 20, 40, 60)

# range객체에 슬라이스를 사용하면 지정된 범위의 숫자를 생성하는 range 객체를 새로 만듭니다.
r = range(10)
print(r[4:7])    # 인덱스 4부터 6까지 숫자 3개를 생성하는 range 객체를 만듦
print(r[4:]) # 인덱스 4부터 9까지 숫자 6개를 생성하는 range 객체를 만듦
print(r[:7:2]) # 인덱스 0부터 2씩 증가시키면서 인덱스 6까지 숫자 4개를 생성하는 range 객체를 만듦
print(list(r[:7:2])) # 잘라낸 range 객체를 리스트로 만들려면 list에 넣기
1
2
3
4
5
6
range(4, 7)
range(4, 10)
range(0, 7, 2)
[0, 2, 4, 6]

hello = 'Hello, world!'
print(hello[2:9])    # 인덱스 2부터 인덱스 8까지 잘라서 문자열을 만듦
print(hello[2:])     # 인덱스 2부터 마지막 요소까지 잘라서 문자열을 만듦
print(hello[:9:2])   # 문자열의 처음부터 인덱스를 2씩 증가시키면서 인덱스 8까지 잘라서 문자열을 만듦
print(hello[2:])     # 인덱스 2부터 마지막 요소까지 잘라서 문자열을 만듦
1
2
3
4
5
llo, wo
llo, world!
Hlo o
llo, world!
1
2
[0, 2, 4, 6]

# slice 객체를 사용하여 시퀀스 객체(시퀀스 자료형으로 만든 변수)를 잘라낼 수도 있습니다.
#시퀀스 객체의 [ ](대괄호) 또는 __getitem__ 메서드에 slice 객체를 넣어주면 지정된 범위만큼 잘라내서 새 객체를 만듬.
print(range(10)[slice(4, 7, 2)])
print(range(10).__getitem__(slice(4, 7, 2)))
1
2
3
4
range(4, 7, 2)
range(4, 7, 2)

a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
s = slice(4, 7)    # 인덱스 4부터 6까지 자르는 slice 객체 생성
print(a[s])
r = range(10)
print(r[s])
hello = 'Hello, world!'
print(hello[s])
1
2
3
4
5
6
7
[40, 50, 60]
range(4, 7)
o,

# 슬라이스에 요소 할당하기
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
a[2:5] = ['a', 'b', 'c']    # 인덱스 2부터 4까지 값 할당
a
1
2
3
4
[0, 10, 'a', 'b', 'c', 50, 60, 70, 80, 90]

# 요소 개수를 맞추지 않아도 알아서 할당
# 만약 할당할 요소 개수가 적으면 그만큼 리스트의 요소 개수도 줄어듭니다.
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
a[2:5] = ['a']    # 인덱스 2부터 4까지에 값 1개를 할당하여 요소의 개수가 줄어듦
print(a)
#할당할 요소 개수가 많으면 그만큼 리스트의 요소 개수도 늘어남
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
a[2:5] = ['a', 'b', 'c', 'd', 'e'] # 인덱스 2부터 4까지 값 5개를 할당하여 요소의 개수가 늘어남
a
1
2
3
4
5
6
7
8
9
[0, 10, 'a', 50, 60, 70, 80, 90]





[0, 10, 'a', 'b', 'c', 'd', 'e', 50, 60, 70, 80, 90]

# 인덱스 증가폭을 지정하여 인덱스를 건너뛰면서 할당
# 인덱스 증가폭을 지정했을 때는 슬라이스 범위의 요소 개수와 할당할 요소 개수가 정확히 일치해함.
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
a[2:8:2] = ['a', 'b', 'c']    # 인덱스 2부터 2씩 증가시키면서 인덱스 7까지 값 할당
a
1
2
3
4
5
[0, 10, 'a', 30, 'b', 50, 'c', 70, 80, 90]

# del로 슬라이스 삭제하기
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
del a[2:5]    # 인덱스 2부터 4까지 요소를 삭제
print(a)
a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
del a[2:8:2]    # 인덱스 2부터 2씩 증가시키면서 인덱스 6까지 삭제
print(a)
# 튜플, range, 문자열은 del로 슬라이스를 삭제할 수 없습니다.
1
2
3
4
5
6
7
8
[0, 10, 50, 60, 70, 80, 90]
[0, 10, 30, 50, 70, 80, 90]
#python

← 리액트 환경설정 →