[Python] Python 기본 문법 정리
1. 파이썬 기초
1.1 기본 입출력
1.1.1 print()
print()는 데이터를 출력하는 함수이다.
파이썬의 print() 함수는 입력된 인수를 str() 함수를 사용하여 문자열로 변환한다.
print("Hello, World!") # Hello, World!
print("시은", 1004) # 시은 1004
print() 함수의 매개변수 sep과 end
sep=" "- separator의 약어로 구분자라는 뜻을 지니고있다.
- 출력하려고 하는 값과 값 사이에 적용하는 것으로 맨 마지막에 출력하는 내용에는 반영되지 않는다.
print("시은", 1004, sep=", ") # 시은, 1004
end=" ": 문장을 출력하고 마지막에 무엇을 쓰고 끝낼지 정해준다.
# end= " "를 입력하여 출력하여 줄 바꾸지 않고
# "Hello World Python" 으로 공백을 삽입하여 출력
print("Hello", end = " ")
print("World", end = " ")
print("Python", end = " ")
1.1.2 input()
input()는 데이터를 입력하는 함수이다.
입력된 데이터는 항상 문자열로 반환된다.
name = input("이름을 입력하세요: ")
print("안녕하세요, " + name + "님!")
1.2 주석
한 줄 주석:
#
#를 사용하여 주석 작성
# 주석 처리 적용 문장 입력하기.
여러 줄 주석
''' 또는 """를 사용하여 여러 줄에 걸친 주석을 작성
'''
주석 처리
적용 문장
입력하기
'''
1.3 세미콜론
- 파이썬에서는 문장의 끝에 세미콜론(;)을 붙이지 않아도 된다.
- 하나의 줄에 여러 구문을 작성할 때, 구문 사이를 세미콜론으로 구분할 수 있다.
a = 5; b = 10; print(a + b) # 15
2. 변수
파이썬에서는 변수에 값을 할당할 때 데이터 타입을 명시하지 않으며, 변수의 타입은 할당된 값에 따라 자동으로 결정된다.
파이썬에서는 보통 snake_case를 사용하여 변수 명을 작성한다.
x = 10 # 정수형 변수
y = 3.14 # 실수형 변수
user_name = "sieun" # 문자열 변수
3. 자료형
- 파이썬의 주요 자료형에는 None, bool, 숫자형, 문자열, 리스트, 튜플, 집합, 딕셔너리가 있다.
- 리스트, 튜플, 집합, 딕셔너리는 이후의 목차에서 더 자세히 다룰 것이다.
3.1 None
result = None
print(result) # None
3.2 bool
파이썬에서 불리언 값은 대문자로 시작하는 True와 False로 표기해야 한다.
is_active = True
is_logged_in = False
3.3 숫자형
age = 20 # 정수형
height = 165.5 # 실수형
3.4 문자형 📌
3.4.1 문자열 만들기
# 1. 큰따옴표(")로 양쪽 둘러싸기
print("안녕")
# 2. 작은따옴표(')로 양쪽 둘러싸기
print('나는 시은이라고 해')
# 3. 큰따옴표 3개를 연속(""")으로 써서 양쪽 둘러싸기
print("""파이썬을 배우고 있지""")
# 4. 작은따옴표 3개를 연속(''')으로 써서 양쪽 둘러싸기
print('''파이썬은 참 간단하구나!''')
3.4.2 문자열 포맷팅
- 문자열 포맷팅이란, 문자열에 변수나 특정 값을 삽입하여 원하는 형식으로 문자열을 만드는 방법이다.
- 변수를 특정 위치에 삽입하거나, 숫자 형식을 지정하는 등 다양한 형태의 출력을 간편하게 생성할 수 있다.
| 포맷 코드 | 설명 |
|---|---|
| %s | 문자열 포맷팅 |
| %c | 문자 포맷팅(문자 1개) |
| %d | 정수 포맷팅 |
| %f | 부동소수점 포맷팅 (%.2f는 소수점 아래 2자리까지 표시) |
| %x | 16진수 포맷팅 |
| %o | 8진수 포맷팅 |
| %% | 문자 %를 출력하기 위한 포맷 코드 |
major = "컴퓨터공학"
year = 3
probability = 64.35
hex_value = 255
# 문자열 포맷팅 (%s)
print("제 전공은 %s 입니다." % major) # "제 전공은 컴퓨터공학 입니다."
# 정수 포맷팅 (%d)
print("현재 %d학년입니다." % year) # "현재 3학년입니다."
# 부동소수점 포맷팅 (%.2f)
print("제가 취업할 확률은 %.2f%%입니다." % probability) # "제가 취업할 확률은 64.35%입니다."
# 16진수 포맷팅 (%x)
print("16진수 값: %x" % hex_value) # "16진수 값: ff"
# 문자열, 정수, 부동소수점, 16진수 포맷팅이 모두 포함된 예시
print("제 전공은 %s이고, 현재 %d학년입니다. 취업할 확률은 %.2f%%이며, 16진수로 표현하면 %x입니다."
% (major, year, probability, hex_value))
# 출력: "제 전공은 컴퓨터공학이고, 현재 3학년입니다. 취업할 확률은 64.35%이며, 16진수로 표현하면 ff입니다."
3.4.3 문자열 연결
+ 연산자를 사용하여 두 개 이상의 문자열을 하나로 결합할 수 있다.
str1 = "Hello"
str2 = "World"
result = str1 + " " + str2
print(result) # "Hello World"
3.4.4 인덱싱과 슬라이싱
인덱싱
- 인덱싱은 무언가를 “가리킨다” 라는 의미로, 문자열에서 개별 문자를 추출하려면 인덱싱을 사용한다.
- 인덱스는 0부터 시작하며, 음수 인덱스는 문자열의 끝에서부터 문자를 센다.
text = "Python"
print(text[0]) # "P" (문자열의 첫 번째 문자)
print(text[-1]) # "n" (문자열의 마지막 문자)
슬라이싱
- 슬라이싱은 무언가를 “잘라낸다” 라는 의미로, 문자열의 특정 부분을 추출할 수 있다.
- 슬라이싱의 기본 구문은
[start:end]이다. - start는 포함되며, end는 포함되지 않는다.
text = "Python Programming"
print(text[0:6]) # "Python" (0부터 5까지의 문자)
print(text[7:]) # "Programming" (7부터 끝까지)
print(text[:6]) # "Python" (시작부터 5까지)
print(text[-11:-1]) # "Programming" (뒤에서 11번째부터 끝에서 1번째 전까지)
3.4.5 문자열 메소드와 함수
(1) 기본
| 메서드/함수 | 설명 |
|-------------------------------------------|------------------------------------------------------------------------------------------------------|
| `len(s)` | 문자열 `s`의 길이를 반환한다. |
| `ord(c)` | 문자 `c`의 유니코드 코드 포인트를 반환한다. |
| `chr(i)` | 유니코드 코드 포인트 `i`에 해당하는 문자를 반환한다. |
| `hex(x)` | 정수 `x`를 16진수 문자열로 변환한다. |
| `oct(x)` | 정수 `x`를 8진수 문자열로 변환한다. |
| `str.format(*args, **kwargs)` | 문자열 내에서 포맷팅을 수행한다. |
| `str.join(iterable)` | `iterable`의 각 요소를 문자열로 결합한다. |
적용 예시
```python # 문자열의 길이 구하기 s = "hello" length = len(s) print("문자열의 길이:", length) # 출력: 문자열의 길이: 5 # 문자 'A'의 유니코드 코드 포인트 얻기 c = "A" unicode_code_point = ord(c) print("문자의 유니코드 코드 포인트:", unicode_code_point) # 출력: 문자의 유니코드 코드 포인트: 65 # 유니코드 코드 포인트 65로 문자 얻기 code_point = 65 character = chr(code_point) print("유니코드 코드 포인트로 얻은 문자:", character) # 출력: 유니코드 코드 포인트로 얻은 문자: A # 정수를 16진수 문자열로 변환하기 number = 255 hex_string = hex(number) print("16진수 문자열:", hex_string) # 출력: 16진수 문자열: 0xff # 정수를 8진수 문자열로 변환하기 number = 8 oct_string = oct(number) print("8진수 문자열:", oct_string) # 출력: 8진수 문자열: 0o10 # 문자열 포맷팅 formatted_string = "{} {}".format("Hello", "World") print("포맷팅된 문자열:", formatted_string) # 출력: 포맷팅된 문자열: Hello World # 문자열 결합하기 words = ["apple", "banana", "cherry"] joined_string = ", ".join(words) print("결합된 문자열:", joined_string) # 출력: 결합된 문자열: apple, banana, cherry ```(2) 변환 및 포맷팅
| 메서드/함수 | 설명 |
|-------------------------------------------|------------------------------------------------------------------------------------------------------|
| `str.upper()` | 문자열을 모두 대문자로 변환한다. |
| `str.lower()` | 문자열을 모두 소문자로 변환한다. |
| `str.title()` | 문자열의 각 단어의 첫 글자를 대문자로 변환한다. |
| `str.capitalize()` | 문자열의 첫 글자만 대문자로 변환한다. |
| `str.swapcase()` | 문자열의 대문자는 소문자로, 소문자는 대문자로 변환한다. |
| `str.zfill(width)` | 문자열의 왼쪽에 `0`을 채워서 `width` 길이로 만든다. |
적용 예시
```python # 문자열을 대문자로 변환하기 lowercase_str = "hello" uppercase_str = lowercase_str.upper() print("대문자로 변환된 문자열:", uppercase_str) # 출력: 대문자로 변환된 문자열: HELLO # 문자열을 소문자로 변환하기 uppercase_str = "HELLO" lowercase_str = uppercase_str.lower() print("소문자로 변환된 문자열:", lowercase_str) # 출력: 소문자로 변환된 문자열: hello # 문자열의 각 단어의 첫 글자를 대문자로 변환하기 sentence = "hello world" title_case_str = sentence.title() print("각 단어의 첫 글자를 대문자로 변환된 문자열:", title_case_str) # 출력: 각 단어의 첫 글자를 대문자로 변환된 문자열: Hello World # 문자열의 첫 글자만 대문자로 변환하기 sentence = "hello world" capitalized_str = sentence.capitalize() print("첫 글자만 대문자로 변환된 문자열:", capitalized_str) # 출력: 첫 글자만 대문자로 변환된 문자열: Hello world # 문자열의 대소문자 반전하기 mixed_case_str = "Hello World" swapped_case_str = mixed_case_str.swapcase() print("대소문자 반전된 문자열:", swapped_case_str) # 출력: 대소문자 반전된 문자열: hELLO wORLD # 문자열의 길이를 5로 맞추기 위해 0을 왼쪽에 채우기 num_str = "42" padded_str = num_str.zfill(5) print("0으로 채운 문자열:", padded_str) # 출력: 0으로 채운 문자열: 00042 ```(3) 검색 및 치환
| 메서드/함수 | 설명 |
|-------------------------------------------|------------------------------------------------------------------------------------------------------|
| `str.find(sub[, start[, end]])` | 문자열에서 `sub`의 첫 번째 인덱스를 반환한다. `sub`이 없으면 `-1`을 반환한다. |
| `str.rfind(sub[, start[, end]])` | 문자열에서 `sub`의 마지막 인덱스를 반환한다. `sub`이 없으면 `-1`을 반환한다. |
| `str.index(sub[, start[, end]])` | 문자열에서 `sub`의 첫 번째 인덱스를 반환한다. `sub`이 없으면 `ValueError`를 발생시킨다. |
| `str.rindex(sub[, start[, end]])` | 문자열에서 `sub`의 마지막 인덱스를 반환한다. `sub`이 없으면 `ValueError`를 발생시킨다. |
| `str.count(sub[, start[, end]])` | 문자열에서 `sub`의 발생 횟수를 반환한다. `start`와 `end`로 검색 범위를 지정할 수 있다. |
| `str.replace(old, new[, count])` | 문자열에서 `old`를 `new`로 교체한다. `count`가 주어지면 최대 `count`회 교체한다. |
| `str.partition(sep)` | 문자열을 `sep`를 기준으로 세 부분으로 나누어 튜플로 반환한다. |
| `str.rpartition(sep)` | 문자열을 `sep`를 기준으로 세 부분으로 나누어 튜플로 반환한다. 오른쪽에서부터 시작한다. |
| `str.removeprefix(prefix)` | 문자열이 `prefix`로 시작하면 `prefix`를 제거한 문자열을 반환한다. |
| `str.removesuffix(suffix)` | 문자열이 `suffix`로 끝나면 `suffix`를 제거한 문자열을 반환한다. |
적용 예시
```python # 문자열에서 'sub'의 첫 번째 인덱스 찾기 text = "hello world" index = text.find("world") print("첫 번째 'world'의 인덱스:", index) # 출력: 첫 번째 'world'의 인덱스: 6 # 문자열에서 'sub'의 마지막 인덱스 찾기 text = "hello world world" last_index = text.rfind("world") print("마지막 'world'의 인덱스:", last_index) # 출력: 마지막 'world'의 인덱스: 12 # 문자열에서 'sub'의 첫 번째 인덱스 찾기 (없으면 ValueError 발생) text = "hello world" index = text.index("world") print("첫 번째 'world'의 인덱스:", index) # 출력: 첫 번째 'world'의 인덱스: 6 # 문자열에서 'sub'의 마지막 인덱스 찾기 (없으면 ValueError 발생) text = "hello world world" last_index = text.rindex("world") print("마지막 'world'의 인덱스:", last_index) # 출력: 마지막 'world'의 인덱스: 12 # 문자열에서 'sub'의 발생 횟수 세기 text = "hello world" count = text.count("o") print("문자 'o'의 발생 횟수:", count) # 출력: 문자 'o'의 발생 횟수: 2 # 문자열에서 'old'를 'new'로 교체하기 text = "hello world" new_text = text.replace("world", "Python") print("교체된 문자열:", new_text) # 출력: 교체된 문자열: hello Python # 문자열을 'sep'를 기준으로 나누기 text = "hello world" parts = text.partition(" ") print("나누어진 문자열:", parts) # 출력: 나누어진 문자열: ('hello', ' ', 'world') # 문자열을 오른쪽에서부터 'sep'를 기준으로 나누기 text = "hello world example" parts = text.rpartition(" ") print("오른쪽에서 나누어진 문자열:", parts) # 출력: 오른쪽에서 나누어진 문자열: ('hello world', ' ', 'example') # 문자열이 'prefix'로 시작하면 'prefix'를 제거하기 text = "TestHook" new_text = text.removeprefix("Test") print("접두사가 제거된 문자열:", new_text) # 출력: 접두사가 제거된 문자열: Hook # 문자열이 'suffix'로 끝나면 'suffix'를 제거하기 text = "MiscTests.x" new_text = text.removesuffix(".x") print("접미사가 제거된 문자열:", new_text) # 출력: 접미사가 제거된 문자열: MiscTests ```(4) 공백 및 줄 나누기
| 메서드/함수 | 설명 |
|-------------------------------------------|------------------------------------------------------------------------------------------------------|
| `str.strip([chars])` | 문자열의 양쪽 끝에서 지정한 문자를 제거한다. `chars`가 없으면 공백을 제거한다. |
| `str.lstrip([chars])` | 문자열의 왼쪽 끝에서 지정한 문자를 제거한다. |
| `str.rstrip([chars])` | 문자열의 오른쪽 끝에서 지정한 문자를 제거한다. |
| `str.split([sep[, maxsplit]])` | 문자열을 `sep`를 기준으로 분할하여 리스트를 반환한다. `maxsplit`이 주어지면 최대 `maxsplit`회 분할한다. |
| `str.splitlines([keepends])` | 문자열을 줄 단위로 분할하여 리스트를 반환한다. `keepends`가 `True`이면 줄 바꿈 문자를 유지한다. |
적용 예시
```python # 문자열의 양쪽 끝에서 공백 제거하기 text = " hello " stripped_text = text.strip() print("양쪽 끝 공백 제거된 문자열:", stripped_text) # 출력: 양쪽 끝 공백 제거된 문자열: hello # 문자열의 왼쪽 끝에서 공백 제거하기 text = " hello " lstripped_text = text.lstrip() print("왼쪽 끝 공백 제거된 문자열:", lstripped_text) # 출력: 왼쪽 끝 공백 제거된 문자열: hello # 문자열의 오른쪽 끝에서 공백 제거하기 text = " hello " rstripped_text = text.rstrip() print("오른쪽 끝 공백 제거된 문자열:", rstripped_text) # 출력: 오른쪽 끝 공백 제거된 문자열: hello # 문자열을 공백을 기준으로 분할하여 리스트로 변환하기 text = "hello world" split_text = text.split() print("공백 기준으로 나눈 문자열:", split_text) # 출력: 공백 기준으로 나눈 문자열: ['hello', 'world'] # 문자열을 줄 단위로 분할하여 리스트로 변환하기 text = "line1\nline2" split_lines = text.splitlines() print("줄 단위로 나눈 문자열:", split_lines) # 출력: 줄 단위로 나눈 문자열: ['line1', 'line2'] ```(5) 검사 및 변환
| 메서드/함수 | 설명 |
|-------------------------------------------|------------------------------------------------------------------------------------------------------|
| `str.isalnum()` | 문자열이 알파벳과 숫자만 포함되면 `True`를 반환한다. |
| `str.isnumeric()` | 문자열이 숫자만 포함되면 `True`를 반환한다. |
| `str.isalpha()` | 문자열이 알파벳만 포함되면 `True`를 반환한다. |
| `str.islower()` | 문자열이 모두 소문자면 `True`를 반환한다. |
| `str.isupper()` | 문자열이 모두 대문자면 `True`를 반환한다. |
| `str.isspace()` | 문자열이 공백 문자만 포함되면 `True`를 반환한다. |
| `str.capitalize()` | 문자열의 첫 글자만 대문자로 변환한다. |
적용 예시
```python # 문자열이 알파벳과 숫자만 포함되면 True 반환하기 text = "hello123" is_alnum = text.isalnum() print("알파벳과 숫자만 포함된 문자열인가요?:", is_alnum) # 출력: 알파벳과 숫자만 포함된 문자열인가요?: True # 문자열이 숫자만 포함되면 True 반환하기 text = "123" is_numeric = text.isnumeric() print("숫자만 포함된 문자열인가요?:", is_numeric) # 출력: 숫자만 포함된 문자열인가요?: True # 문자열이 알파벳만 포함되면 True 반환하기 text = "hello" is_alpha = text.isalpha() print("알파벳만 포함된 문자열인가요?:", is_alpha) # 출력: 알파벳만 포함된 문자열인가요?: True # 문자열이 모두 소문자면 True 반환하기 text = "hello" is_lower = text.islower() print("모두 소문자인 문자열인가요?:", is_lower) # 출력: 모두 소문자인 문자열인가요?: True # 문자열이 모두 대문자면 True 반환하기 text = "HELLO" is_upper = text.isupper() print("모두 대문자인 문자열인가요?:", is_upper) # 출력: 모두 대문자인 문자열인가요?: True # 문자열이 공백 문자만 포함되면 True 반환하기 text = " " is_space = text.isspace() print("공백 문자만 포함된 문자열인가요?:", is_space) # 출력: 공백 문자만 포함된 문자열인가요?: True ```2.3 데이터 타입의 변환(casting)
서로 다른 데이터 타입 간의 변환은 캐스팅(casting)을 통해 가능하다.
# 정수로 변환
int_res1 = print(int(3.14159)) # 3
int_res2 = print(int(7 / 3)) # 2
int_res2 = print(int("3000")) # 3000
# 실수로 변환
float_res1 = print(float(3)) # 3.0
float_res2 = print(float(6 / 3)) # 2.0
float_res3 = print(float("3000")) # 3000.0
float_res3 = print(float(3.141592)) # 3.141592
# 문자열로 변환
age = 20
message = str(age) + "번째 생일을 축하합니다!"
print(message) # 20번째 생일을 축하합니다!
3. 연산자
3.1 산술 연산자
파이썬은 //을 사용하여 몫만 추출할 수 있다.
a = 10
b = 3
print(a + b) # 13 (덧셈)
print(a - b) # 7 (뺄셈)
print(a * b) # 30 (곱셈)
print(a / b) # 3.3333... (나눗셈)
print(a // b) # 3 (몫)
print(a % b) # 1 (나머지)
print(a ** b) # 1000 (거듭제곱)
3.2 관계 연산자
x = 10
y = 5
print(x == y) # False
print(x != y) # True
print(x > y) # True
print(x < y) # False
print(x >= y) # True
print(x <= y) # False
3.3 논리 연산자
x = True
y = False
print(x and y) # False
print(x or y) # True
print(not x) # False
3.4 비트 연산자
a = 5 # 0b0101
b = 3 # 0b0011
print(a & b) # 1 (0b0001)
print(a | b) # 7 (0b0111)
print(a ^ b) # 6 (0b0110)
print(~a) # -6 (0b...1010)
print(a << 1) # 10 (0b1010)
print(a >> 1) # 2 (0b0010)
4. 조건문과 반복문
4.1 조건문
조건문 예제
x = 10
y = 5
if x > y:
print("x는 y보다 큽니다.")
elif x < y:
print("x는 y보다 작습니다.")
else:
print("x와 y는 같습니다.")
중첩 조건문
a = 15
if a > 10:
if a < 20:
print("a는 10보다 크고 20보다 작습니다.")
else:
print("a는 20 이상입니다.")
else:
print("a는 10 이하입니다.")
조건 표현식
단일 조건을 간단하게 표현할 때 사용한다.
result = "참" if x > y else "거짓"
print(result)
4.2 반복문
for 문
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
range() 함수와 for 문
range() 함수는 일정 범위의 숫자를 생성하여 for 문과 함께 사용할 수 있다.
for i in range(5):
print(i) # 0부터 4까지 출력
count = 0
while count < 5:
print(count)
count += 1
while 반복문
count = 0
while count < 5:
print(count)
count += 1
반복문 제어문
- break: 반복문을 강제로 종료
- continue: 현재 반복을 건너뛰고 다음 반복을 실행
- else: 반복문이 정상적으로 끝났을 때 실행 (반복문이 break로 종료된 경우 실행되지 않음).
for i in range(10):
if i == 5:
break # 5에서 반복문 종료
print(i)
for i in range(10):
if i % 2 == 0:
continue # 짝수는 건너뛰기
print(i)
else:
print("반복이 정상적으로 종료되었습니다.")
5. 리스트와 튜플
리스트와 튜플은 여러 값을 저장할 수 있는 자료형이다.
5.1 리스트 (List)
리스트는 변경 가능한(mutable) 시퀀스 자료형으로, 다양한 데이터 타입의 항목을 포함할 수 있다.
- 리스트 생성: 대괄호 []를 사용하여 생성
- 리스트 요소 접근: 인덱스를 사용하여 요소에 접근 가능
- 리스트 요소 추가: append(), insert(), extend() 메서드를 사용하여 요소 추가 가능
- 리스트 요소 제거: remove(), pop(), clear() 메서드를 사용하여 요소 제거 가능
- 리스트 정렬: sort() 메서드를 사용하여 리스트를 정렬 가능
# 리스트 생성 및 기본 연산
fruits = ["apple", "banana", "cherry"]
print(fruits[0]) # "apple"
fruits.append("orange") # 리스트에 요소 추가
print(fruits) # ["apple", "banana", "cherry", "orange"]
fruits.remove("banana") # 리스트에서 요소 제거
print(fruits) # ["apple", "cherry", "orange"]
fruits.sort() # 리스트 정렬
print(fruits) # ["apple", "cherry", "orange"]
5.2 튜플 (Tuple)
튜플은 변경할 수 없는(immutable) 시퀀스 자료형으로, 리스트와 유사하지만 생성된 후에는 값을 변경할 수 없다.
- 튜플 생성: 소괄호 ()를 사용하여 생성, 요소가 하나뿐인 튜플을 만들 때는
,를 추가해야 함 - 튜플 요소 접근: 리스트와 마찬가지로 인덱스를 사용하여 요소에 접근 가능
# 튜플 생성 및 기본 연산
colors = ("red", "green", "blue")
print(colors[1]) # "green"
# 튜플의 요소는 변경할 수 없다.
# colors[0] = "yellow" # 오류 발생
# 튜플의 길이
print(len(colors)) # 3
# 요소가 하나뿐인 튜플 생성
single_element_tuple = ("hello",)
print(type(single_element_tuple)) # <class 'tuple'>
6. 딕셔너리와 집합
딕셔너리와 집합은 파이썬에서 각각 키-값 쌍과 중복 없는 요소의 집합을 저장하는 데 사용
6.1 딕셔너리 (Dictionary)
딕셔너리는 키(key)와 값(value) 쌍을 저장하는 자료형으로, 키를 사용하여 값을 빠르게 조회할 수 있음
- 딕셔너리 생성: 중괄호 {}를 사용하여 생성
- 딕셔너리 요소 접근: 키를 사용하여 값에 접근
- 딕셔너리 요소 추가 및 수정: 키를 사용하여 요소를 추가하거나 수정
- 딕셔너리 요소 삭제: del 키워드 또는 pop() 메서드를 사용하여 요소 삭제
# 딕셔너리 생성 및 기본 연산
person = {"name": "Alice", "age": 25, "city": "New York"}
print(person["name"]) # "Alice"
person["age"] = 30 # 딕셔너리 값 수정
print(person) # {"name": "Alice", "age": 30, "city": "New York"}
person["email"] = "alice@example.com" # 딕셔너리 값 추가
print(person) # {"name": "Alice", "age": 30, "city": "New York", "email": "alice@example.com"}
del person["city"] # 딕셔너리 값 삭제
print(person) # {"name": "Alice", "age": 30, "email": "alice@example.com"}
6.2 집합 (Set)
집합은 중복되지 않는 요소들의 모임을 표현하며, 요소들은 순서가 없음
- 집합 생성: 중괄호 {}를 사용하여 생성
- 집합 요소 추가 및 제거: add() 메서드를 사용하여 요소를 추가하고, remove() 메서드를 사용하여 요소 제거
- 집합 연산: 교집합, 합집합, 차집합 등의 연산을 수행 가능
# 집합 생성 및 기본 연산
fruits = {"apple", "banana", "cherry"}
print(fruits) # {"apple", "banana", "cherry"}
fruits.add("orange") # 집합에 요소 추가
print(fruits) # {"apple", "banana", "cherry", "orange"}
fruits.remove("banana") # 집합에서 요소 제거
print(fruits) # {"apple", "cherry", "orange"}
# 집합 연산
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a & b) # 교집합: {3, 4}
print(a | b) # 합집합: {1, 2, 3, 4, 5, 6}
print(a - b) # 차집합: {1, 2}
7. 함수
함수 정의
def 키워드를 사용하여 정의
def greet(name):
return f"Hello, {name}!"
message = greet("sieun")
print(message) # "Hello, sieun!"
기본 매개변수
함수 정의 시 기본값을 가지는 매개변수를 설정할 수 있다.
def greet(name="Guest"):
return f"Hello, {name}!"
print(greet()) # "Hello, Guest!"
print(greet("sieun")) # "Hello, sieun!"
가변 매개변수
파이썬 함수는 매개변수의 개수를 가변적으로 받을 수 있다.
*args: 위치 인수를 튜플로 받음**kwargs: 키워드 인수를 딕셔너리로 받음
def add(*args):
return sum(args)
print(add(1, 2, 3, 4)) # 10
def display_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
display_info(name="짱구", age=5, city="떡잎마을")
# 출력:
# name: 짱구
# age: 5
# city: 떡잎마을
람다 함수 (Lambda Functions)
람다 함수는 익명 함수로, 짧고 간단한 함수를 정의할 때 사용한다.
# 두 수의 합을 반환하는 람다 함수
add = lambda x, y: x + y
print(add(5, 3)) # 8
# 리스트의 각 요소를 제곱하는 람다 함수와 map()의 결합
squares = list(map(lambda x: x ** 2, [1, 2, 3, 4]))
print(squares) # [1, 4, 9, 16]
8. 파일 입출력
8.1 파일 열기
파일을 열 때
open()함수는 파일 경로와 모드를 인수로 받는다.
- r: 읽기 모드 (파일이 존재해야 함)
- w: 쓰기 모드 (파일이 존재하지 않으면 새로 생성)
- a: 추가 모드 (파일의 끝에 데이터를 추가)
- b: 이진 모드 (바이너리 파일 읽기/쓰기 시 사용)
# 파일 열기
file = open("example.txt", "r")
8.2 파일 읽기
파일을 읽을 때
read(),readline(),readlines()메서드를 사용한다.
file = open("example.txt", "r")
# 파일 전체 읽기
content = file.read()
print(content)
# 한 줄씩 읽기
file.seek(0) # 파일 포인터를 처음으로 이동
line = file.readline()
print(line)
# 모든 줄을 리스트로 읽기
file.seek(0)
lines = file.readlines()
print(lines)
file.close() # 파일 닫기
8.3 파일 쓰기
파일에 데이터를 쓸 때는 write() 또는 writelines() 메서드를 사용한다.
file = open("example.txt", "w")
# 파일에 문자열 쓰기
file.write("Hello, World!\n")
# 여러 줄을 리스트로 작성하기
lines = ["First line\n", "Second line\n", "Third line\n"]
file.writelines(lines)
file.close() # 파일 닫기
8.4 파일 닫기
파일 작업을 마친 후에는 반드시
close()메서드를 사용하여 파일을 닫아야한다.(데이터 손실이나 메모리 누수를 막기 위함)
file = open("example.txt", "r")
# 파일 작업 수행
file.close() # 파일 닫기
8.5 with문과 함께 사용하는 파일 입출력
- 파일을 열고 닫는 작업을 안전하게 처리하기 위해 with문을 사용할 수 있다.
- with문을 사용하면 코드 블록이 끝날 때 파일이 자동으로 닫힌다.
with open("example.txt", "r") as file:
content = file.read()
print(content)
# 블록이 끝나면 파일이 자동으로 닫힘
댓글남기기