Python 기본 연산자 및 문자열, 리스트, 튜플, 세트, 딕셔너리 내장 메서드

컴퓨터는 다양한 연산을 수행할 수 있으며, 연산은 산술, 비교, 논리, 할당, 멤버십, 식별 연산으로 분류됩니다. 문자열과 리스트는 +와 * 연산만 지원하며, 딕셔너리는 순서가 없으므로 산술 및 비교 연산을 수행할 수 없습니다. 비교 연산에서 ==는 값을 비교하고, is는 객체의 ID를 비교합니다. 비교 연산은 동일한 타입의 객체 간에만 수행할 수 있으며, 문자열 비교는 순서대로 문자를 비교합니다. 논리 연산의 우선순위는 괄호를 사용하여 명확히 해야 합니다.

기본 연산자

산술 연산

a=10, b=20이라고 가정합니다.

비교 연산

a=10, b=20이라고 가정합니다.

할당 연산

논리 연산

멤버십 연산

식별 연산

내장 메서드란?

내장 메서드는 파이썬에 이미 구현되어 있어, 원리를 알지 못해도 바로 사용할 수 있는 함수입니다. 따라서 내장 메서드는 규정된 것이므로, 사용법을 익히려면 모두 숙지해야 합니다.

문자열 내장 메서드

문자열 내장 메서드에는 공백 제거(strip), 분리(split), 길이(len), 슬라이싱(부분 문자열 추출), 시작/끝 확인(startswith, endswith), 대체(replace), 찾기(find: 처음과 끝을 포함하지 않으며, 찾지 못하면 -1 반환, 오류 없음), index(find와 유사하나, 찾지 못하면 오류 발생), 개수 세기(count: 처음과 끝을 포함하지 않으며, 범위를 지정하지 않으면 전체 검색), 포맷팅 출력(% 또는 .format()), 결합(join), 탭 문자 변환(expandtabs), 대문자 변환(upper), 소문자 변환(lower), 첫 글자 대문자화(capitalize), 대소문자 뒤집기(swapcase), 단어별 첫 글자 대문자화(title) 등이 있습니다.

공백 제거 (strip)


msg = '             hello         '
print(msg)
print(msg.strip())  # 출력: hello

msg = '***hello*********'
msg = msg.strip('*')
print(msg)  # 출력: hello

print(msg.lstrip('*'))  # 출력: hello*********
print(msg.rstrip('*'))  # 출력: ***hello

예시 (사용자가 사용자 이름이나 비밀번호 입력 시 실수로 공백을 더 입력해도 오류 없이 정상적으로 로그인될 수 있습니다):


while True:
    name = input('user: ').strip()
    password = input('password: ').strip()

    if name == 'egon' and password == '123':
        print('login successfull')

분리 (split)


info = 'root:x:0:0::/root:/bin/bash'
print(info[0] + info[1] + info[2] + info[3])  # 출력: root

user_l = info.split(':')
print(user_l[1])  # 출력: x

msg = 'hello world egon say hahah'
print(msg.split())  # 출력: ['hello', 'world', 'egon', 'say', 'hahah'] (기본 구분자는 공백)

cmd = 'download|xhp.mov|3000'
cmd_l = cmd.split('|')
print(cmd_l[1])  # 출력: xhp.mov
print(cmd_l[0])  # 출력: download

print(cmd.split('|', 1))  # 출력: ['download', 'xhp.mov|3000']

길이 (len)


print(len('hell 123'))

슬라이싱 (부분 문자열 추출)


msg = 'hello world'
print(msg[1:3])  # 출력: el
print(msg[1:4])  # 출력: ell

시작/끝 확인 (startswith, endswith)


name = 'you_suck'
print(name.endswith('uk'))  # 출력: True
print(name.startswith('y'))  # 출력: True
print(name.startswith('w'))  # 출력: False

대체 (replace)


name = 'jack say :i have a iphone,my name is jack'
print(name.replace('jack', 'john', 1))  # 출력: john say :i have a iphone,my name is jack

찾기 (find), index, 개수 세기 (count)

find: 처음과 끝을 포함하지 않으며, 찾지 못하면 -1 반환 (오류 없음).
index: find와 동일하나, 찾지 못하면 오류 발생.
count: 처음과 끝을 포함하지 않으며, 범위를 지정하지 않으면 전체 검색.


name = 'jack say hello'
print(name.find('S', 1, 3))  # 처음과 끝을 포함하지 않고 검색, 찾지 못하면 -1 반환
print(name.index('S'))  # 처음과 끝을 포함하지 않고 검색, 찾지 못하면 오류 발생

print(name.count('S', 1, 5))  # 처음과 끝을 포함하지 않고 개수 세기, 범위를 지정하지 않으면 전체 검색

포맷팅 출력 (% 또는 .format())

자리 표시자를 사용하여 포맷팅된 출력을 생성합니다. 일반적으로 %s를 사용합니다.


print('my name is %s my age is %s my sex is %s' % ('jack', 18, 'male'))
# 출력: my name is jack my age is 18 my sex is male

print('my name is {} my age is {} my sex is {}'.format('jack', 18, 'male'))
# 출력: my name is jack my age is 18 my sex is male

print('my name is {0} my age is {1} my sex is {0}:{2}'.format('jack', 18, 'male'))
# 출력: my name is jack my age is 18 my sex is jack:male

print('my name is {name} my age is {age} my sex is {sex}'.format(
    sex='male',
    age=18,
    name='jack'))
# 출력: my name is jack my age is 18 my sex is male

결합 (join)

split의 반대 연산입니다.


info = 'root:x:0:0::/root:/bin/bash'
print(info.split(':'))  # 출력: ['root', 'x', '0', '0', '', '/root', '/bin/bash']

l = ['root', 'x', '0', '0', '', '/root', '/bin/bash']
print(':'.join(l))  # 출력: root:x:0:0::/root:/bin/bash

탭 문자 변환 (expandtabs)


name = 'jack\thello'
print(name)  # 출력: jack    hello (탭 문자만큼 공백 삽입)
print(name.expandtabs(1))  # 출력: jack hello (지정된 길이만큼 공백 삽입)

전체 대문자 (upper), 전체 소문자 (lower)


name = 'jAck'
print(name.lower())  # 출력: jack
print(name.upper())  # 출력: JACK

첫 글자 대문자화 (capitalize), 대소문자 뒤집기 (swapcase), 단어별 첫 글자 대문자화 (title)


name = 'jAck'
print(name.capitalize())  # 출력: Jack (첫 글자만 대문자, 나머지는 소문자)
print(name.swapcase())  # 출력: Jack (대소문자 뒤집기)
msg = 'jack say good morning'
print(msg.title())  # 출력: Jack Say Good Morning (각 단어의 첫 글자만 대문자)

문자열 채우기 및 정렬


name = 'jack'
print(name.center(30, '-'))  # 출력: -------------jack-------------
print(name.ljust(30, '*'))  # 출력: jack**************************
print(name.rjust(30, '*'))  # 출력: **************************jack
print(name.zfill(50))  # 출력: 0000000000000000000000000000000000000000000000jack (숫자 앞에 0으로 채우기)

Python 3에서 문자열 관련 메서드는 다음과 같은 데이터 타입에 적용됩니다:

  • isdigit(): 숫자형 문자인지 확인 (str, bytes, unicode).
  • isdecimal(): 십진수 문자형인지 확인 (str, unicode).
  • isnumeric(): 숫자형 문자인지 확인 (str, unicode, 중국어 숫자, 로마 숫자 포함).

num0 = '4'
num1 = b'4'  # bytes 타입
num2 = '4'  # python3에서 'u' 접두사는 필요 없음 (unicode)
num3 = '四'  # 중국어 숫자
num4 = 'Ⅳ'  # 로마 숫자

print(num0.isdigit())
print(num1.isdigit()) # bytes는 isdigit()을 직접 호출할 수 없습니다.
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())

print(num0.isdecimal())
# print(num1.) # bytes는 isdecimal()을 직접 호출할 수 없습니다.
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())

print(num0.isnumeric())
# print(num1) # bytes는 isnumeric()을 직접 호출할 수 없습니다.
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())

리스트 내장 메서드

리스트 내장 메서드에는 인덱싱, 슬라이싱, 추가(append), 삭제(pop), 길이(len), 포함 여부 확인(in), 삽입(insert), 개수 세기(count), 비우기(clear), 복사(copy), 뒤집기(reverse), 정렬(sort) 등이 있습니다.

슬라이싱


l = ['a', 'b', 'c', 'd', 'e', 'f']

print(l[1:5])  # 출력: ['b', 'c', 'd', 'e']
print(l[1:5:2])  # 출력: ['b', 'd'] (2는 스텝)
print(l[2:5])  # 출력: ['c', 'd', 'e']
print(l[-1])  # 출력: f

추가 (append)


hobbies = ['play', 'eat', 'sleep', 'study']
hobbies.append('girls')
print(hobbies)  # 출력: ['play', 'eat', 'sleep', 'study', 'girls']

삭제 (pop)


hobbies = ['play', 'eat', 'sleep', 'study']

x = hobbies.pop(1)  # 요소를 삭제하고 반환
print(x)  # 출력: eat
print(hobbies)  # 출력: ['play', 'sleep', 'study']

del hobbies[1]  # 단순히 요소 삭제
hobbies.remove('eat')  # 지정한 요소 삭제

append와 pop을 활용한 큐(Queue) 및 스택(Stack) 예제:


# 큐 (선입선출 - FIFO)
queue_l = []
queue_l.append('first')
queue_l.append('second')
queue_l.append('third')
print(queue_l)  # 출력: ['first', 'second', 'third']
print(queue_l.pop(0))  # 출력: first
print(queue_l.pop(0))  # 출력: second
print(queue_l.pop(0))  # 출력: third


# 스택 (후입선출 - LIFO)
l = []
l.append('first')
l.append('second')
l.append('third')
print(l)  # 출력: ['first', 'second', 'third']
print(l.pop())  # 출력: third
print(l.pop())  # 출력: second
print(l.pop())  # 출력: first

길이 (len)


hobbies = ['play', 'eat', 'sleep', 'study']
print(len(hobbies))  # 출력: 4

포함 여부 확인 (in)


hobbies = ['play', 'eat', 'sleep', 'study']
print('sleep' in hobbies)  # 출력: True

msg = 'hello world jack'
print('jack' in msg)  # 출력: True

삽입 (insert)


hobbies = ['play', 'eat', 'sleep', 'study', 'eat', 'eat']
hobbies.insert(1, 'walk')
hobbies.insert(1, ['walk1', 'walk2', 'walk3'])
print(hobbies)
# 출력: ['play', ['walk1', 'walk2', 'walk3'], 'walk', 'eat', 'sleep', 'study', 'eat', 'eat']

확장 삽입 (extend)


hobbies = ['play', 'eat', 'sleep', 'study', 'eat', 'eat']
hobbies.extend(['walk1', 'walk2', 'walk3'])
print(hobbies)
# 출력: ['play', 'eat', 'sleep', 'study', 'eat', 'eat', 'walk1', 'walk2', 'walk3']
# extend는 insert와 다르게 리스트의 각 요소를 개별적으로 추가합니다.

인덱스 찾기 (index), 개수 세기 (count)


hobbies = ['play', 'eat', 'sleep', 'study', 'eat', 'eat']
print(hobbies.count('eat'))  # 출력: 3 (개수)
print(hobbies.index('sleep'))  # 출력: 2 (인덱스 위치)

clear와 copy 메서드는 간단하므로 자세히 설명하지 않습니다.

딕셔너리 내장 메서드


# 저장/조회
info_dic = {'name': 'egon', 'age': 18, 'sex': 'male'}
# print(info_dic['name11111111']) # 키가 없으면 KeyError 발생
print(info_dic.get('name', None))  # 키가 없으면 None 반환
print(info_dic.get('non_existent_key', 'default_value')) # 키가 없으면 'default_value' 반환

# 삭제
info_dic = {'name': 'egon', 'age': 18, 'sex': 'male'}

# pop(): 키가 존재하면 해당 키의 값을 반환하고 삭제. 없으면 기본값을 반환하거나 오류 발생.
print(info_dic.pop('nam123123123123123123e', None)) # 키가 없으므로 None 반환
print(info_dic)

# popitem(): 임의의 키-값 쌍을 삭제하고 튜플로 반환 (Python 3.7+ 부터는 마지막에 삽입된 순서대로)
print(info_dic.popitem())
print(info_dic)

del info_dic['name'] # 키를 직접 지정하여 삭제

# keys(), values(), items()
info_dic = {'name': 'egon', 'age': 18, 'sex': 'male'}
print(info_dic.keys())  # dict_keys(['name', 'age', 'sex'])
print(info_dic.values())  # dict_values(['egon', 18, 'male'])
print(info_dic.items())  # dict_items([('name', 'egon'), ('age', 18), ('sex', 'male')])

# 반복문으로 키-값 쌍 출력
for key in info_dic:
    print(key, info_dic[key])

# len() 및 in 연산자는 간단하므로 설명 생략

# 업데이트 (update)
info_dic = {'name': 'jack', 'age': 18, 'sex': 'male'}
info_dic.update({'a': 1, 'name': 'jAck'}) # 'name' 키가 있으면 값 업데이트, 없으면 새로 추가
print(info_dic) # 출력: {'name': 'jAck', 'age': 18, 'sex': 'male', 'a': 1}

# fromkeys()
# 지정된 키들로 새로운 딕셔너리를 생성합니다. 원본 딕셔너리와는 관련이 없습니다.
info_dic = {'name': 'jack', 'age': 18, 'sex': 'male'}
d = dict.fromkeys(('name', 'age', 'sex'), None) # 모든 키의 값을 None으로 초기화
print(d) # 출력: {'name': None, 'age': None, 'sex': None}

d1 = dict.fromkeys(('name', 'age', 'sex'), 'default_value') # 모든 키의 값을 'default_value'로 초기화
print(d1) # 출력: {'name': 'default_value', 'age': 'default_value', 'sex': 'default_value'}

d2 = dict.fromkeys(('name', 'age', 'sex'), ('jack', 18, 'male')) # 모든 키의 값을 튜플 ('jack', 18, 'male')로 초기화
print(d2) # 출력: {'name': ('jack', 18, 'male'), 'age': ('jack', 18, 'male'), 'sex': ('jack', 18, 'male')}

# copy()와 clear() 메서드는 간단하므로 설명 생략

튜플 내장 메서드

튜플은 변경 불가능하므로 내장 메서드가 적습니다. 주로 슬라이싱, in 연산, len(), index(), count()가 있습니다.

슬라이싱


goods = ('iphone', 'lenovo', 'sanxing', 'suoyi')
print(goods[1:3])  # 출력: ('lenovo', 'sanxing')

포함 여부 확인 (in)


goods = ('iphone', 'lenovo', 'mi', 'zuk')
print('iphone' in goods)  # 출력: True

d = {'a': 1, 'b': 2, 'c': 3}
print('b' in d)  # 딕셔너리에서 'in'은 키를 확인합니다. 출력: True

길이 (len)


hobbies = ('play', 'eat', 'sleep', 'study')
print(len(hobbies))  # 출력: 4

인덱스 찾기 (index), 개수 세기 (count)


goods = ('iphone', 'lenovo', 'mi', 'zuk')
print(goods.index('iphone'))  # 출력: 0 (인덱스 위치)
print(goods.count('iphone'))  # 출력: 1 (개수)

세트(Set) 내장 메서드

포함 여부 확인 (in, not in)


s = {'a', 'b', 'c', 'd'}
print('a' in s)  # 출력: True

합집합 (| 또는 union())


s_1 = {'a', 'b', 'c'}
s_2 = {'a', 'b', 'd'}
print(s_1 | s_2)  # 출력: {'a', 'b', 'c', 'd'}
print(s_1.union(s_2))  # 출력: {'a', 'b', 'c', 'd'}

교집합 (& 또는 intersection())


s_1 = {'a', 'b', 'c'}
s_2 = {'a', 'b', 'd'}
print(s_1 & s_2)  # 출력: {'a', 'b'}
print(s_1.intersection(s_2))  # 출력: {'a', 'b'}

차집합 (- 또는 difference())


s_1 = {'a', 'b', 'c'}
s_2 = {'a', 'b', 'd'}
print(s_1 - s_2)  # 출력: {'c'}
print(s_1.difference(s_2))  # 출력: {'c'}
print(s_2.difference(s_1))  # 출력: {'d'}

대칭 차집합 (^ 또는 symmetric_difference())

합집합에서 교집합을 제외한 부분입니다.


s_1 = {'a', 'b', 'c'}
s_2 = {'a', 'b', 'd'}
print(s_1 ^ s_2)  # 출력: {'c', 'd'}
print(s_1.symmetric_difference(s_2))  # 출력: {'c', 'd'}

상위 집합/부분 집합


set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3, 4}
print(set1 >= set2)  # set1이 set2의 상위 집합인지 확인. 출력: True
print(set1.issuperset(set2))  # 상위 집합 확인

print(set2 <= set1)  # set2가 set1의 부분 집합인지 확인. 출력: True
print(set2.issubset(set1))  # 부분 집합 확인

간단한 요점 (자세한 설명 생략):

  • 추가: add()
  • 삭제: pop() (무작위 요소 삭제), remove() (지정한 요소 삭제, 없으면 오류), discard() (지정한 요소 삭제, 없어도 오류 없음)
  • 업데이트: update()
  • 비우기: clear()
  • 복사: copy()
  • 해제: * (unpacking)

태그: python 연산자 문자열 리스트 튜플

7월 22일 23:55에 게시됨

인기 태그

©2026 괴물 클럽