[Python] 시퀀스 자료형 1탄 (str, list)

시퀀스 자료형

출처: 코딩도장

시퀀스 자료형(sequence types) 란 요소들(elements)이 연속적(sequence)으로 이어진 자료형을 의미해요.
파이썬에서는 list, tuple, range, str 을 주로 사용하고, bytes, bytearray 도 시퀀스 자료형입니다.

✅ 특징

시퀀스 자료형에는 몇가지 특징이 있어요.
여기서는 list 를 이용한 간단한 예시로 소개해볼게요. (tuple, range, str 은 아래에서 설명할게요.)

- 순서가 있는 자료형

# list 선언
list = [ a, b, c, d, e, f, g ]​

- indexing 이 가능
인덱싱이란 무언가를 "가리킨다"는 의미입니다.

# indexing
print(list[2]) # c

- slicing 이 가능
슬라이싱이란 무언가를 "잘라낸다"는 의미입니다.

# slicing
print(list[2:6]) # ['c', 'd', 'e', 'f']​

- 길이 확인 가능

# len()
print(len(list)) # 7​

- 요소 조회 가능: in 연산자

# in 연산자
print( c in list ) # True​

- 연결 연산 가능: + 연산자
* + 연산자 는 주의할 점이 있어요. 같은 type 만 연결이 가능하다는 점이죠.
  이를 지키지 않으면 아래와 같은 TypeError 를 만나게 됩니다.^^

# + 연산자
print( list + [ h, i ]) # [ a, b, c, d, e, f, g, h, i ]

# 주의할 점
>>> a = 3
>>> b = "Hi"
>>> a+b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

- 반복 연산 가능: * 연산자

# * 연산자
print(list*2) # [ a, b, c, d, e, f, g, a, b, c, d, e, f, g ]

---

문자열 (str)

* 문자열(String) 이란 문자, 단어 등으로 구성된 문자들의 집합을 의미해요.

문자열 만들기

문자열은 아래 4가지 방법으로 만들 수 있어요.

종류	특징	용도
" "	1. 문자열 중간의 ‘ 를 출력할 수 있어요. 2. 줄 바꿈 시 이스케이프 문자 필요해요.
' '	1. 문자열 중간의 “ 를 출력할 수 있어요. 2. 줄바꿈시 이스케이프 문자 필요해요.
""" """	1. 줄바꿈시 이스케이프 문자를 쓰지 않아도 돼요	줄 바꿈을 편하게 하기 위함
''' '''	1. 줄 바꿈 시 이스케이프 문자를 쓰지 않아도 돼요	줄 바꿈을 편하게 하기 위함

그렇다면 이스케이프 문자가 뭔지 알아볼까요?
이스케이프 문자는 "이스케이프 시퀀스"를 따르는 문자들입니다.
다음 문자가 특수 문자임을 알리는 백 슬래시(\)와 함께 사용해요. 

코드	설명
\n	문자열 안에서 줄을 바꿀 때 사용
\t	문자열 사이에 탭 간격을 줄 때 사용
\\	문자 \를 그대로 표현할 때 사용
\'	작은따옴표(')를 그대로 표현할 때 사용
\"	큰따옴표(")를 그대로 표현할 때 사용

예시

>>> a="Hello World"
>>> print(a)
Hello World

>>> print(type(a))
<class 'str'>               # 문자열일 string type 임을 표현


>>> a="""Hello
... world"""
>>> a
'Hello\nworld'              # """ """ 를 사용해서 자동으로 \n 이 저장됨
>>> print(a)
Hello
world

>>> b='''Hi
... world'''
>>> b
'Hi\nworld'                 # ''' ''' 를 사용해서 자동으로 \n 이 저장됨
>>> print(b)
Hi
world​

문자열 연산하기

문자열(str) 은 시퀀스 자료형이에요.
즉, 위에서 알아본 시퀀스 자료형의 특징을 가지고 있다는 말이죠.

문자열 연결하기 (+)

>>> a="""Hello
... world"""
>>> b=''' Hi
... world'''

>>> a+b
'Hello\nworld Hi\nworld'
>>> print(a+b)
Hello
world Hi
world​

문자열 곱하기 (*)

>>> a= '='
>>> b= "Python"
>>> print(a*20 + '\n' + b + '\n' + a*20)
====================
Python
====================​

문자열 길이 구하기 ( len() )

>>> print(a*20 + '\n' + b + '\n' + a*20)
====================
Python
====================

>>> len(a*20 + '\n' + b + '\n' + a*20)
48                                                # 20 + 1 + 6 + 1 + 20 = 48​

문자열 인덱싱 & 슬라이싱

문자열 인덱싱

>>> a= "Life is too short, You need Python"
>>> a[20]
'o'
>>> a[0]
'L'
>>> a[-2]                                         # 끝에서부터 -1, -2, 순으로도 인덱싱
'o'
>>> a[-3]
'h'​

문자열 슬라이싱
  > a [시작번호:끝번호:간격] ————— 시작번호 ≤ a < 끝번호
     >> 시작번호는 끝번호보다 왼편의 자리를 가리켜야 합니다.
     >> 슬라이싱 하면 시작번호는 포함되고, 끝번호는 포함되지 않아요.
     >> 끝번호를 생략하면 시작번호부터 문자열의 끝까지 모두 포함돼요. (시작번호 생략, 둘 다 생략도 같은 원리)

>>> d="1234567890"
>>> d[1:8:2]
'2468'
>>> d[::2]
'13579'

>>> print(a[0:-3])
Life is too short, You need Pyt
# Python 의 h는 31이자 -3
>>> a[-3]
'h'
>>> a[31]
'h'

>>> print(a[0:13])
Life is too s
>>> print(a[-1:-13])                         # 슬라이싱은 [왼쪽:오른쪽] 순으로 입력해야 하는데
                                             # -1 은 -13 보다 오른편에 있으므로 인식을 못 함!!!!
>>> print(a[-13:-1])
u need Pytho

>>> a[12:]
'short, You need Python'​

 

위 특징들을 아래처럼 응용할 수 있어요.
응용 1 - 오타 수정하기
 > 문자열의 요소는 직접 수정할 수 없어요. 하지만 슬라이싱을 활용하는 방법은 있죠.

# Pithon >>> Python
>>> b="Pithon"
>>> b[1]
'i'
>>> b[1]=y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined

# 정답
>>> b[:1] + 'y' + b[2:]
'Python'​

응용 2 - 문자열 나눠서 저장하기

>>> c='20220405Sunny'
>>> year= c[:4]
>>> day= c[4:8]
>>> weather= c[8:]

>>> year
'2022'
>>> day
'0405'
>>> weather
'Sunny'​

문자열 포메팅

포매팅 연산자 (%) 사용

문자열 포매팅이란 문자열 안에 어떤 값을 삽입하는 방법이에요.
예시를 보기 전에 문자열 포맷 코드를 먼저 알아볼까요?

코드	설명	비고
%s	문자열 (String)	무슨 값이든 넣을 수 있어요.(아래 코드 참고)
%c	문자 1개 (Character)
%d	정수 (Integer)
%f	부동소수 (Floating-point)
%o	8진수
%x	16진수
%%	Literla % (문자 % 자체)	% 포매팅 연산자와 함께 % 출력

예시 - 포매팅 연산자 (%) 사용

>>> "i have %s apple" %"a"
'i have a apple'
>>> "i have %d apples" %3
'i have 3 apples'

# 비교: b 가 더 복잡!!!!
>>> a= "i have %d apples" %3
>>> b= "i have " + str(3) + " apples"
>>> a
'i have 3 apples'
>>> b
'i have 3 apples'

# 변수이용 + 여러 값 넣기 (포맷에 주의)
>>> num1 = 3
>>> num2 = "ten"
>>> c= "i have %d apples. and i have %s oranges" % (num1, num2)
>>> c
'i have 3 apples. and i have ten oranges'

# % 출력하기
>>> d=" %s%%" % 3.253
>>> d
' 3.253%'

# 포맷코드와 숫자 사용하기
# 오른쪽 정렬
>>> "%10s" % "hi"
'        hi'
# 왼쪽 정렬
>>> "%-10sEnd" % "hi"
'hi        End'
# 소수점 표현 - 자리수 올림
>>> "%10.4f" % 3.141592
'    3.1416'

format 함수 사용하기

포매팅 연사자 대신 format 함수를 활용해서 포매팅을 할 수도 있어요.

format 함수 특징
- index를 사용할 수 있어요.
- % 를 사용하던 자리에 { }와. format()를 사용해요.
- format 함수를 사용하면 변수명의 순서에 상관없이 포매팅이 가능해요.

# {} & .format()
>>> "I ate {} apples.".format(3)
'I ate 3 apples.'

# 순서에 상관없는 포매팅
>>> "I ate {num} {0}".format("oranges", num=10)     # {index} 로 oranges 를 대입
'I ate 10 oranges'

>>> "I ate {num} apples.".format(num=3)
'I ate 3 apples.'

>>> "I ate {num} {fruit}".format(fruit="oranges", num=10)
'I ate 10 oranges'

>>> num=3
>>> "I ate {} apples.".format(num)
'I ate 3 apples.'

>>> num=3
>>> fruit="apples"
>>> "I ate {} {}".format(num, fruit)
'I ate 3 apples'​​

format 함수 응용하기

# 정렬 :<  :>  :^
>>> "{0:<10}".format("hi")
'hi        '
>>> "{0:>10}".format("hi")
'        hi'
>>> "{0:^10}".format("hi")
'    hi    '

# 정렬 & 채우기
>>> "{0:=<10}".format("hi")
'hi========'
>>> "{0:=>10}".format("hi")
'========hi'
>>> "{0:=^10}".format("hi")
'====hi===='

# 소수점 표현하기 - 자리수 올림
>>> y=3.141592
>>> "{0:0.4f}".format(y)
'3.1416'
>>> "{0:10.4f}".format(y)
'    3.1416'

# { } 출력하기 - { or } 를 2번 연속 사용
>>> "{{ and }}asd  }}".format()
'{ and }asd  }'​

f-string 포매팅 하기 (python 3.6 이상)

f-string 포매팅은 가장 최근에 나온 기능이에요.
f와 { }를 활용하는 방법인데요.
문자열 맨 앞에 f를 붙이고, { } 안에 직접 변수 이름이나 출력할 것을 입력하면 돼요.

f'문자열 {변수} 문자열'​

예시를 보면 쉬워요.

# 기본 개념
>>> name = "kay"
>>> age = 33
>>> f'나의 이름은 {name}입니다. 나이는 {age}입니다.'
'나의 이름은 kay입니다. 나이는 33입니다.'

# Dictionary 활용하기
>>> d={'name': 'kay', 'age':33}
>>> f'나의 이름은 {d["name"]}입니다. 나이는 {d["age"]}입니다.'   # 주의: 문자열과 dictionary는 '' "" 서로 다른 것 쓰기
'나의 이름은 kay입니다. 나이는 33입니다.'

# 정렬
>>> f'{"hi":<10}'
'hi        '
>>> f'{"hi":^10}'
'    hi    '

# 정렬 & 채우기
>>> f'{"hi":=<10}'
'hi========'
>>> f'{"hi":=^10}'
'====hi===='

# 소수점 표현
>>> y= 3.141592
>>> f'{y:10.4f}'
'    3.1416'

# { } 문자열 표현
>>> f'{{ and }} or }}'
'{ and } or }'​

문자열 관련 함수들

문자열 관련 함수들

마지막으로 문자열과 관련된 함수들을 알아볼게요.
문자열 자료형은 자체적으로 함수를 가지고 있어요. 이런 함수들을 내장함수라고 하죠. 
내장 함수를 사용하려면 문자열 변수 이름 뒤에 '.' 를 붙인 후 함수 이름을 써주면 돼요.
❗문자열을 수정하는 함수들은 저장된 문자열을 바꾸는 게 아니라 임시로 변형해서 출력하는 함수입니다.❗

예시를 볼게요.

# .count(' ') - 문자수 세기
>>> a="abbcccddddeeeee"
>>> a.count(b)
0
>>> a.count('b')
2

# .find(' ') - 위치 찾기 1
>>> a=" Python is the best choice"
>>> a.find('t')
3                           # 첫 번째 일치 한 위치를 출력
>>> a.find('th')
3                           # 여러 문자 입력 시 모두 일치하면서 처음 만나는 위치를 출력
>>> a.find(' th')
10
>>> a.find('k')
-1                          # 불일치 시 -1 을 출력

# .index(' ') - 위치 찾기 2
>>> a="Life & life"
>>> a.index('L')
0
>>> a.index('l')
7
>>> a.index('k')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

# .join('') - 문자열 삽입 // 문자열 사이마다 삽입
>>> ",".join('abcd')
'a,b,c,d'
>>> a="abcd"
>>> ",".join(a)
'a,b,c,d'

# .upper() & .lower() - 대, 소문자 변환
>>> a="hi"
>>> a.upper()
'HI'
>>> a="HI"
>>> a.lower()
'hi'

# .lstrip() & .rstrip() & .strip() - 좌, 우, 양쪽 공백 지우기
>>> a=" hi "
>>> a.lstrip()
'hi '
>>> a.rstrip()
' hi'
>>> a.strip()
'hi'
>>> a
' hi '

# .replace("a", "b") - 문자열 바꾸기 (a를 b로)
>>> a=" Life is too short"
>>> a.replace("Life", "your leg")
' your leg is too short'

# .split() - 문자열 나누기
>>> a=" Life is too short"
>>> a.split()                       # 나누는 기준이 없을 경우 '공백'을 기준으로 나눔
['Life', 'is', 'too', 'short']
>>> b="a:b:c:d"
>>> b.split(':')
['a', 'b', 'c', 'd']
>>> c= b.split(':')
>>> c
['a', 'b', 'c', 'd']​

---

여기까지 "시퀀스 자료형"에 대해 알아봤어요.
다음글(링크)에 이어서 더 알아볼게요.
글이 도움이 되셨다면 공감 버튼 눌러주세요. 😊