# 파이썬 마스터하기: 기초부터 심화까지 완벽 정복 안녕하세요, 여러분! 파이썬 제로 베이스부터 어드밴스드까지 아우르는 이 종합 과정에 오신 것을 환영합니다. 이번 강좌는 파이썬의 가장 기본적인 구조부터 시작하여 변수, 데이터 타입, 클래스 생성, 파일 처리, 람다 함수 등 고급 기능까지 모두 다룰 예정입니다. 약 9시간 분량으로 구성된 이 강좌를 통해 우리는 실습 위주로 파이썬을 배우게 될 것입니다. 수많은 예제와 함께 코드를 직접 작성하고 학습하며 파이썬 실력을 향상시키길 바랍니다! --- ## 1. 파이썬이란 무엇인가? 파이썬은 배우기 쉽고 강력한 프로그래밍 언어입니다. 1980년대 후반 귀도 반 로섬(Guido van Rossum)이 네덜란드 암스테르담 수학 및 컴퓨터 과학 센터에서 개발했습니다. 모듈라 3, C, C++, GOOL, Smalltalk 등 다양한 언어에서 파생되었으며, Unix 쉘 스크립트와 같은 스크립트 언어의 장점도 포함하고 있습니다. ### 파이썬 개발 동기 * **높은 수준의 언어 필요성**: Guido van Rossum은 암바(Ameba)라는 운영체제 프로젝트에서 시스템 관리를 위한 유틸리티 개발에 C언어를 사용했을 때 시간이 매우 오래 걸리는 것을 경험했습니다. 쉘 언어는 여러 이유로 기능이 부족했습니다. * **C와 쉘의 중간 지점**: C언어만큼 강력하면서도 쉘 스크립트처럼 쉽게 작성할 수 있는 언어의 필요성을 느꼈습니다. * **Ameba 운영체제**: 파이썬은 원래 1990년대 암스테르담 자유 대학에서 개발된 분산 운영체제인 Ameba를 위해 개발되었습니다. ### 파이썬 학습의 이점 * **쉬운 코딩 및 가독성**: 명확한 문법 구조 덕분에 코드를 읽고 작성하기 쉽습니다. * **오픈 소스 및 자유 소프트웨어**: 상업적 프로젝트를 포함한 모든 프로젝트에서 자유롭게 사용할 수 있습니다. * **확장된 표준 라이브러리**: 다양한 기능을 추가할 수 있는 풍부한 표준 라이브러리를 제공합니다. * **이식성**: 컴파일 언어는 아니지만, 다양한 플랫폼에서 스크립트가 실행될 수 있어 크로스 플랫폼 개발이 가능합니다. * **멀티패러다임 언어**: 절차적, 객체 지향, 함수형 프로그래밍 등 다양한 패러다임을 지원합니다. * **확장성**: C언어와 같은 다른 언어로 작성된 확장 기능을 추가하여 성능을 향상시킬 수 있습니다. ### 파이썬의 특징 및 단점 * **동적 타이핑**: 변수 타입을 명시적으로 선언할 필요가 없습니다. * **들여쓰기 기반 블록 구분**: 코드 블록을 구분하기 위해 들여쓰기를 사용합니다. * **풍부한 문서**: 학습 자료 및 라이브러리 관련 정보를 쉽게 찾을 수 있습니다. * **장점**: 배우기 쉽고 강력하며, 다양한 분야에 활용됩니다. * **단점**: 동적 타이핑으로 인한 런타임 오류 가능성, C나 C++보다 느린 실행 속도 (확장 기능으로 보완 가능) --- ## 2. 파이썬 활용 분야 파이썬은 매우 다재다능한 언어로, 다양한 분야에서 활용됩니다. * **웹 개발**: Django, Flask와 같은 프레임워크를 사용하여 웹 애플리케이션 개발. * **머신러닝 및 인공지능**: TensorFlow, Keras, PyTorch와 같은 라이브러리를 활용하여 AI 모델 개발. * **데이터 과학 및 분석**: Pandas, NumPy, SciPy와 같은 라이브러리를 사용하여 데이터 분석 및 처리. * **데이터 시각화**: Matplotlib, Seaborn과 같은 라이브러리를 사용하여 데이터를 시각화. * **데스크톱 애플리케이션**: PyQt, Tkinter 등을 사용하여 GUI 애플리케이션 개발. * **웹 스크래핑**: Beautiful Soup, Scrapy 등을 사용하여 웹에서 데이터 수집. * **네트워크 자동화 및 시스템 관리**: 스크립트를 사용하여 네트워크 장치 및 시스템 관리 자동화. * **임베디드 시스템 및 IoT**: 특정 기술을 사용하여 임베디드 시스템 및 사물 인터넷 개발. * **게임 개발**: Pygame, Arcade와 같은 라이브러리를 사용하여 간단한 게임 개발. **주의:** 실시간 애플리케이션이나 사람의 생명과 직결될 수 있는 미션 크리티컬한 시스템의 제어 등에는 파이썬의 실행 속도를 고려하여 신중하게 사용해야 합니다. --- ## 3. 파이썬 생태계: 누가 파이썬을 사용하는가? Google, YouTube, Netflix, NASA, Spotify 등 세계적인 기업들이 파이썬을 다양한 프로세스에 사용하고 있습니다. 이는 파이썬의 인기를 보여주는 단적인 예이며, 중소기업이나 개인 개발자들도 파이썬을 널리 활용하고 있습니다. **TIOBE Index**와 같은 프로그래밍 언어 인기 순위에서 파이썬은 오랫동안 최상위권을 유지하며 그 인기를 입증하고 있습니다. --- ## 4. 파이썬의 철학: Zen of Python 파이썬은 "Zen of Python"이라는 명확한 철학을 가지고 있습니다. 이 철학은 공식 웹사이트에서 확인할 수 있으며, 코드를 더 읽기 쉽고, 명확하며, 효율적으로 작성하는 데 도움을 줍니다. * **아름다운 것이 보기 싫은 것보다 낫다.** (Beautiful is better than ugly.) * **명시적인 것이 암시적인 것보다 낫다.** (Explicit is better than implicit.) * **단순한 것이 복잡한 것보다 낫다.** (Simple is better than complex.) * **복잡한 것이 매우 복잡한 것보다 낫다.** (Complex is better than complicated.) * **평탄한 것이 중첩된 것보다 낫다.** (Flat is better than nested.) * **희소한 것이 밀집된 것보다 낫다.** (Sparse is better than dense.) * **가독성이 중요하기 때문에, 읽기 쉬운 코드가 더 중요하다.** (Readability counts.) * **특수한 경우들이 일반적인 규칙을 위반하는 것을 허용하지 않는다.** (Special cases don't defer from the rules.) * **하지만 실제적인 규칙을 위반하는 것은 오히려 실용적이다.** (Although practicality beats purity.) * **오류는 결코 조용히 지나가서는 안 된다.** (Errors should never pass silently.) * **명시적으로 처리되지 않는 한.** (Unless explicitly silenced.) * **모호함에 직면했을 때, 추측하려는 유혹에 굴복하지 말라.** (When ambiguity is found, do not guess.) * **방법은 하나, 어쩌면 두 개가 명확하고 명백한 방법일 뿐이다.** (There should be one-- and preferably only one --obvious way to do it.) * **이것이 반드시 명확하지는 않을지라도, 그것이 좋을 때 그런 방식이 아닐 수 있다.** (Although that way may not be obvious at first unless you are Dutch.) * **지금이 좋지 않다면, 더 나은 방법은 없을 것이다.** (Now is better than never.) * **결코 좋지 않다는 것은 거의 항상 그렇다.** (Although never is often better than right now.) * **쉬운 구현이 어려운 설명을 야기한다면, 그것은 나쁜 아이디어이다.** (If the implementation is hard to explain, it's a bad idea.) * **쉬운 설명이 어려운 구현을 야기한다면, 그것은 좋은 아이디어일 수 있다.** (If the implementation is easy to explain, it may be a good idea.) * **네임스페이스는 훌륭한 아이디어입니다. 더 많은 네임스페이스를 하도록 합시다.** (Namespaces are one honking great idea -- let's do more of those!) --- ## 5. 개발 환경 설정: Python 설치 및 VS Code 파이썬을 배우기 위한 첫 단계는 파이썬 언어 자체와 코드를 작성하고 실행할 개발 도구를 설치하는 것입니다. ### Python 설치 1. **python.org 방문**: 공식 웹사이트에서 최신 버전의 파이썬을 다운로드합니다. 운영체제별 다운로드 버튼이 제공됩니다. 2. **설치 옵션**: 설치 중 "Add Python to PATH" 옵션을 반드시 체크하여 명령줄 어디서든 파이썬을 실행할 수 있도록 설정합니다. 3. **설치 확인**: 설치 완료 후 명령 프롬프트(CMD)에서 `python --version` 또는 `python -V` 명령으로 설치된 버전을 확인할 수 있습니다. ### VS Code 설치 및 설정 1. **Visual Studio Code 다운로드**: [code.visualstudio.com](https://code.visualstudio.com/)에서 VS Code를 다운로드하여 설치합니다. 2. **Python 확장 설치**: VS Code를 실행한 후, 좌측 사이드바의 확장(Extensions) 아이콘을 클릭하고 "Python"을 검색하여 Microsoft에서 제공하는 Python 확장을 설치합니다. 이 확장은 코드 자동 완성, 디버깅, 문법 강조 등 파이썬 개발에 필수적인 기능을 제공합니다. 3. **추가 확장 (선택 사항)**: * **vscode-icons**: 파일 탐색기에 아이콘을 표시하여 시각적으로 파일을 구분하기 쉽게 합니다. * **Code Runner**: 코드를 더 쉽게 실행할 수 있도록 도와주는 확장입니다. 4. **작업 공간 설정**: `File > Open Folder`를 통해 파이썬 프로젝트를 저장할 폴더를 열고 작업 공간으로 설정합니다. 5. **첫 코드 작성 및 실행**: * 새 파일(`Ctrl+Shift+N` 또는 `File > New File`)을 생성하고 `test.py`와 같이 `.py` 확장자로 저장합니다. * `print("Hello, Python!")`과 같은 간단한 코드를 작성합니다. * `Code Runner` 확장 기능을 사용하거나 VS Code의 실행 버튼(▶)을 클릭하여 코드를 실행합니다. `Run Python File in Terminal` 옵션을 사용하면 터미널에서 실행 결과를 확인할 수 있습니다. --- ## 6. 변수와 데이터 타입 파이썬에서 변수는 데이터를 저장하는 메모리 공간을 나타냅니다. 변수를 선언할 때 타입을 명시할 필요 없이, 할당되는 값에 따라 파이썬이 자동으로 타입을 추론합니다. ### 변수 선언 및 할당 * **기본 문법**: `변수명 = 값` * 예: `name = "Fabio"` * 예: `age = 30` * 예: `height = 1.75` * **변수명 규칙**: * 영문자, 숫자, 밑줄(`_`)로 구성됩니다. * 첫 문자는 반드시 영문자여야 합니다. * 띄어쓰기는 사용할 수 없습니다 (대신 `_` 사용: `user_name`). * 대소문자를 구분합니다 (`name`과 `Name`은 다른 변수입니다). * 파이썬 예약어는 사용할 수 없습니다. ### 데이터 타입 파이썬은 다양한 데이터 타입을 지원합니다. * **`int` (정수)**: `10`, `-5`, `0` * **`float` (실수)**: `3.14`, `-2.5`, `1.0` * **`str` (문자열)**: `"Hello"`, `'Python'` (작은따옴표 또는 큰따옴표 사용) * **`bool` (불리언)**: `True`, `False` (단, 첫 글자는 대문자) * **`complex` (복소수)**: `1 + 2j` (수학 및 공학 계산에 사용) ### 타입 확인: `type()` 함수 `type()` 함수를 사용하여 변수의 데이터 타입을 확인할 수 있습니다. ```python # 변수 선언 average = 7.5 age = 47 name = "Fábio" is_active = True complex_number = 1 + 2j # 타입 확인 및 출력 print(type(average)) # print(type(age)) # print(type(name)) # print(type(is_active)) # print(type(complex_number)) # ``` ### `isinstance()` 함수 `isinstance(object, classinfo)` 함수는 특정 객체가 지정된 클래스(`classinfo`)의 인스턴스인지 확인합니다. ```python # 변수 선언 a = 10 b = "Hello" # isinstance() 함수 사용 print(isinstance(a, int)) # True print(isinstance(b, str)) # True print(isinstance(a, float)) # False print(isinstance(a, (int, float))) # True (여러 타입 중 하나인지 확인) ``` --- ## 7. 연산자 파이썬은 다양한 종류의 연산자를 제공하여 데이터를 조작하고 계산을 수행합니다. ### 산술 연산자 | 연산자 | 설명 | 예시 | 결과 | | :----- | :------------- | :--------- | :--- | | `+` | 덧셈 | `10 + 5` | `15` | | `-` | 뺄셈 | `10 - 5` | `5` | | `*` | 곱셈 | `10 * 5` | `50` | | `/` | 나눗셈 (실수) | `10 / 4` | `2.5`| | `//` | 나눗셈 (정수) | `10 // 4` | `2` | | `%` | 나머지 (모듈로)| `10 % 4` | `2` | | `**` | 거듭제곱 | `2 ** 3` | `8` | **연산자 우선순위**: 괄호 > 거듭제곱 > 곱셈/나눗셈/나머지 > 덧셈/뺄셈 ```python # 산술 연산 예제 x = 10 y = 3 print(f"{x} + {y} = {x + y}") # 13 print(f"{x} - {y} = {x - y}") # 7 print(f"{x} * {y} = {x * y}") # 30 print(f"{x} / {y} = {x / y:.2f}") # 3.33 (소수점 둘째 자리까지) print(f"{x} // {y} = {x // y}") # 3 print(f"{x} % {y} = {x % y}") # 1 print(f"{x} ** {y} = {x ** y}") # 1000 # 연산자 우선순위 예제 result = x + y * 2 # 10 + (3 * 2) = 16 print(f"10 + 3 * 2 = {result}") result_parentheses = (x + y) * 2 # (10 + 3) * 2 = 26 print(f"(10 + 3) * 2 = {result_parentheses}") ``` ### 비교 연산자 비교 연산자는 두 값을 비교하여 `True` 또는 `False`를 반환합니다. | 연산자 | 설명 | 예시 | 결과 | | :----- | :----------- | :--------- | :--- | | `==` | 같음 | `a == b` | | | `!=` | 다름 | `a != b` | | | `>` | 큼 | `a > b` | | | `<` | 작음 | `a < b` | | | `>=` | 크거나 같음 | `a >= b` | | | `<=` | 작거나 같음 | `a <= b` | | ```python # 비교 연산 예제 a = 10 b = 5 c = 10 print(f"{a} == {c}: {a == c}") # True print(f"{a} != {b}: {a != b}") # True print(f"{a} > {b}: {a > b}") # True print(f"{b} < {a}: {b < a}") # True print(f"{a} >= {c}: {a >= c}") # True print(f"{b} <= {a}: {b <= a}") # True # 표현식 비교 print(f"{a} == {b} + 5: {a == b + 5}") # True ``` ### 논리 연산자 논리 연산자는 불리언 값(`True`, `False`)을 사용하여 논리적인 판단을 수행합니다. | 연산자 | 설명 | 예시 | 결과 | | :----- | :--------------- | :--------------- | :--- | | `and` | 두 조건 모두 참 | `x and y` | | | `or` | 둘 중 하나 참 | `x or y` | | | `not` | 반대 | `not x` | | ```python # 논리 연산 예제 age = 25 height = 1.75 # 조건 1: 나이가 18세 이상이고 키가 1.70m 이상 can_participate = (age >= 18) and (height >= 1.70) print(f"참여 가능 여부 (and): {can_participate}") # True # 조건 2: 문이 열렸거나 창문이 열렸을 때 알람 발생 door_open = False window_open = True alarm_triggered = door_open or window_open print(f"알람 발생 여부 (or): {alarm_triggered}") # True # 조건 3: 돈이 없을 때 구매 불가 (not) has_money = False can_buy = not has_money print(f"구매 가능 여부 (not): {can_buy}") # True ``` --- ## 8. 제어 흐름: 조건문 (if, elif, else) 조건문은 특정 조건이 참(True)일 때만 코드 블록을 실행하도록 합니다. ### 기본 구조 ```python if 조건: # 조건이 참일 때 실행될 코드 (들여쓰기 필수) elif 다른_조건: # 이전 조건이 거짓이고, 다른 조건이 참일 때 실행될 코드 else: # 모든 조건이 거짓일 때 실행될 코드 ``` ### 예제: 학점 계산 ```python score = 85 if score >= 90: print("A 등급") elif score >= 80: print("B 등급") elif score >= 70: print("C 등급") else: print("D 등급") ``` --- ## 9. 제어 흐름: 반복문 (while, for) 반복문은 특정 조건이 만족되거나 특정 횟수만큼 코드 블록을 반복 실행합니다. ### `while` 반복문 조건이 참인 동안 코드 블록을 반복 실행합니다. ```python # 1부터 10까지 출력 count = 1 while count <= 10: print(count) count += 1 # count = count + 1 (증감 필수, 무한 루프 방지) print("While 루프 종료") # 사용자 입력 받기 (종료 조건: 'x' 입력) while True: user_input = input("이름을 입력하세요 ('x'를 입력하면 종료): ") if user_input.lower() == 'x': # .lower()로 대소문자 구분 없이 비교 break # 루프 탈출 print(f"안녕하세요, {user_input}님!") print("프로그램 종료") ``` ### `for` 반복문 시퀀스(리스트, 튜플, 문자열 등)의 각 항목에 대해 코드 블록을 반복 실행합니다. ```python # 리스트 순회 fruits = ["apple", "banana", "cherry"] for fruit in fruits: print(fruit) # 문자열 순회 message = "Python" for char in message: print(char) # range() 함수 사용 # range(stop): 0부터 stop-1까지 for i in range(5): print(i) # 0, 1, 2, 3, 4 # range(start, stop): start부터 stop-1까지 for i in range(2, 6): print(i) # 2, 3, 4, 5 # range(start, stop, step): start부터 stop-1까지 step만큼 증가 for i in range(0, 11, 2): print(i) # 0, 2, 4, 6, 8, 10 # continue와 break numbers = [1, 2, 3, 4, 5, 6] for num in numbers: if num % 2 != 0: # 홀수이면 continue # 다음 반복으로 건너뛰기 if num > 4: # 4보다 크면 break # 루프 종료 print(num) # 짝수이고 4보다 작거나 같을 때만 출력 (2, 4) ``` --- ## 10. 함수 함수는 특정 작업을 수행하는 코드 블록이며, 재사용성을 높이고 코드를 모듈화하는 데 사용됩니다. ### 함수 정의 및 호출 ```python # 매개변수 없는 함수 def greet(): print("안녕하세요!") print("파이썬 강좌에 오신 것을 환영합니다.") # 함수 호출 greet() # 매개변수 있는 함수 def add(a, b): result = a + b print(f"{a} + {b} = {result}") # 함수 호출 add(5, 3) # 반환 값이 있는 함수 def multiply(x, y): return x * y # 함수 호출 및 반환 값 사용 product = multiply(4, 6) print(f"4 * 6 = {product}") # 반환 값이 있는 함수와 try-except 사용 def divide(numerator, denominator): if denominator == 0: return "0으로 나눌 수 없습니다." else: return numerator / denominator print(divide(10, 2)) print(divide(10, 0)) # 기본값 매개변수 def power(base, exponent=2): # exponent 기본값은 2 return base ** exponent print(power(3)) # 3 ** 2 = 9 print(power(3, 3)) # 3 ** 3 = 27 ``` ### 함수 스코프 (Scope) * **지역 변수 (Local Variables)**: 함수 내에서 선언되며 해당 함수 내에서만 접근 가능합니다. * **전역 변수 (Global Variables)**: 함수 외부에서 선언되며 프로그램 전체에서 접근 가능합니다. * **`global` 키워드**: 함수 내에서 전역 변수의 값을 변경하려면 `global` 키워드를 사용해야 합니다. ```python global_var = "Global Variable" def my_function(): local_var = "Local Variable" print(f"Inside function (Global): {global_var}") print(f"Inside function (Local): {local_var}") def modify_global(): global global_var # 전역 변수 사용 명시 global_var = "Modified Global Variable" print(f"Inside modify_global: {global_var}") my_function() print(f"Outside function (Global): {global_var}") # Global Variable 출력 # print(f"Outside function (Local): {local_var}") # NameError 발생 modify_global() print(f"Outside function (Modified Global): {global_var}") # Modified Global Variable 출력 ``` --- ## 11. 모듈과 패키지 모듈은 파이썬 코드를 담고 있는 파일이며, 패키지는 모듈들을 모아 놓은 디렉토리입니다. 이를 통해 코드를 재사용하고 관리하기 용이하게 만듭니다. ### `import` 문 ```python # 모듈 전체 가져오기 import math print(math.sqrt(16)) # 4.0 # 특정 함수/변수만 가져오기 from math import pi, sin print(pi) # 3.14159... print(sin(math.radians(90))) # 1.0 (math.radians로 각도 변환 필요) # 별칭(alias) 사용하여 가져오기 import numpy as np array_data = np.array([1, 2, 3]) print(array_data * 2) # [2 4 6] # 사용자 정의 모듈 사용 # my_module.py 파일에 def greet(): print("Hello from module!") 코드가 있다고 가정 # import my_module # my_module.greet() ``` ### `pip` 사용법 `pip`는 파이썬 패키지를 설치, 관리하는 도구입니다. * **패키지 목록 확인**: `pip list` * **패키지 설치**: `pip install package_name` (예: `pip install requests`) * **패키지 업데이트**: `pip install --upgrade package_name` * **패키지 제거**: `pip uninstall package_name` * **패키지 정보 확인**: `pip show package_name` ### `os` 모듈 운영체제와 상호작용하는 다양한 기능을 제공합니다. * **현재 작업 디렉토리 얻기**: `os.getcwd()` * **디렉토리 내용 확인**: `os.listdir(path)` * **디렉토리 변경**: `os.chdir(path)` * **디렉토리 생성**: `os.mkdir(path)` (단일 디렉토리), `os.makedirs(path)` (하위 디렉토리 포함) * **파일/디렉토리 이름 변경**: `os.rename(old_name, new_name)` * **파일/디렉토리 삭제**: `os.remove(file_path)`, `os.rmdir(dir_path)` (빈 디렉토리), `shutil.rmtree(dir_path)` (내용 포함 디렉토리) * **경로 조작**: `os.path.join()`, `os.path.basename()`, `os.path.dirname()`, `os.path.splitext()` ```python import os # 현재 작업 디렉토리 확인 print(f"Current Working Directory: {os.getcwd()}") # 디렉토리 내용 확인 (현재 디렉토리) print(f"Contents of current directory: {os.listdir()}") # 새 디렉토리 생성 (예: 'my_new_folder') # os.makedirs("my_new_folder", exist_ok=True) # exist_ok=True: 이미 존재하면 오류 발생 방지 # 파일 생성 및 쓰기 (간단 예제 - 자세한 내용은 파일 I/O 참고) # with open("sample_file.txt", "w") as f: # f.write("This is a sample file.\n") # 파일 이름 변경 # if os.path.exists("sample_file.txt"): # os.rename("sample_file.txt", "renamed_sample.txt") # 파일 삭제 # if os.path.exists("renamed_sample.txt"): # os.remove("renamed_sample.txt") # 경로에서 파일명과 확장자 분리 file_path = "/path/to/your/document.txt" filename, file_extension = os.path.splitext(file_path) print(f"Filename: {filename}, Extension: {file_extension}") ``` --- ## 12. 파일 입출력 (File I/O) 파이썬으로 파일을 읽거나 쓰는 것은 매우 중요하며, `open()` 함수와 다양한 모드를 사용하여 수행합니다. ### 파일 열기 및 닫기 * **`open(file_path, mode, encoding)`**: 파일을 열고 파일 객체를 반환합니다. * `mode`: `'r'` (읽기), `'w'` (쓰기, 기존 내용 덮어씀), `'a'` (추가, 파일 끝에 내용 추가), `'r+'` (읽기/쓰기), `'w+'` (쓰기/읽기, 기존 내용 덮어씀), `'a+'` (추가/읽기) * `encoding`: 파일의 문자 인코딩 지정 (예: `'utf-8'`) * **`with open(...) as ...:`**: 파일을 안전하게 열고 사용 후 자동으로 닫아줍니다 (권장). ### 파일 읽기 * **`read()`**: 파일 전체 내용을 하나의 문자열로 읽어옵니다. * **`readline()`**: 파일에서 한 줄씩 읽어옵니다. * **`readlines()`**: 파일의 모든 줄을 리스트로 읽어옵니다. ```python # 파일 생성 (예제용) with open("my_file.txt", "w", encoding="utf-8") as f: f.write("첫 번째 줄입니다.\n") f.write("두 번째 줄입니다.\n") f.write("세 번째 줄입니다.\n") # 파일 내용 읽기 try: with open("my_file.txt", "r", encoding="utf-8") as f: # content = f.read() # 파일 전체 읽기 # print(content) # 한 줄씩 읽기 # line1 = f.readline() # print(f"Readline 1: {line1.strip()}") # strip()으로 양쪽 공백/줄바꿈 제거 # line2 = f.readline() # print(f"Readline 2: {line2.strip()}") # 모든 줄 리스트로 읽기 lines = f.readlines() for line in lines: print(f"Readlines: {line.strip()}") except FileNotFoundError: print("파일을 찾을 수 없습니다.") except Exception as e: print(f"오류 발생: {e}") ``` ### 파일 쓰기 * **`write(string)`**: 문자열을 파일에 씁니다. * **`writelines(list_of_strings)`**: 리스트의 문자열들을 파일에 씁니다. (줄바꿈은 별도 추가 필요) ```python # 파일에 내용 추가 (append 모드) try: with open("my_file.txt", "a", encoding="utf-8") as f: f.write("새로운 내용 추가!\n") f.writelines(["또 다른 줄 추가!\n", "마지막 줄입니다.\n"]) except Exception as e: print(f"쓰기 오류: {e}") # 파일 내용 읽어 확인 try: with open("my_file.txt", "r", encoding="utf-8") as f: print("\n--- 파일 내용 확인 ---") print(f.read()) except Exception as e: print(f"읽기 오류: {e}") ``` --- ## 13. 예외 처리 (Error Handling) 예외 처리는 프로그램 실행 중 발생하는 오류(예외)를 감지하고, 프로그램이 비정상적으로 종료되는 것을 방지하며, 적절하게 대응하는 기술입니다. ### `try`, `except`, `else`, `finally` * **`try`**: 오류가 발생할 가능성이 있는 코드를 포함합니다. * **`except`**: `try` 블록에서 특정 예외가 발생했을 때 실행될 코드를 포함합니다. * `except ExceptionType:`: 특정 타입의 예외만 처리합니다. * `except:`: 모든 종류의 예외를 처리합니다 (일반적으로 특정 예외를 명시하는 것이 좋습니다). * **`else`**: `try` 블록에서 예외가 발생하지 않았을 때 실행됩니다. * **`finally`**: 예외 발생 여부와 상관없이 항상 실행됩니다. (자원 해제 등에 유용) ```python # 예제 1: 0으로 나누기 오류 처리 try: num1 = int(input("첫 번째 숫자를 입력하세요: ")) num2 = int(input("두 번째 숫자를 입력하세요: ")) result = num1 / num2 print(f"{num1} / {num2} = {result:.2f}") except ValueError: print("잘못된 입력입니다. 숫자를 입력해주세요.") except ZeroDivisionError: print("0으로 나눌 수 없습니다.") except Exception as e: # 그 외 예상치 못한 오류 처리 print(f"알 수 없는 오류 발생: {e}") else: print("계산이 성공적으로 완료되었습니다.") finally: print("프로그램 실행 종료.") # 예제 2: 사용자 정의 예외 발생 및 처리 class NegativeNumberError(Exception): """음수 입력 시 발생하는 사용자 정의 예외""" pass def process_positive_number(number): if number < 0: raise NegativeNumberError("입력된 숫자는 음수일 수 없습니다.") return number ** 2 try: num_input = int(input("양수를 입력하세요: ")) square = process_positive_number(num_input) print(f"제곱 값: {square}") except ValueError: print("잘못된 입력입니다. 숫자를 입력해주세요.") except NegativeNumberError as ne: # 사용자 정의 예외 처리 print(f"오류: {ne}") except Exception as e: print(f"알 수 없는 오류 발생: {e}") finally: print("프로그램 실행 종료.") ``` --- ## 14. 재귀 (Recursion) 재귀는 함수가 자기 자신을 호출하는 프로그래밍 기법으로, 복잡한 문제를 더 작고 관리하기 쉬운 하위 문제로 분해하여 해결할 때 유용합니다. ### 기본 원리 * **기본 사례 (Base Case)**: 재귀 호출을 멈추는 조건입니다. 반드시 있어야 하며, 무한 루프를 방지합니다. * **재귀 단계 (Recursive Step)**: 함수가 자기 자신을 더 작은 입력으로 호출하는 부분입니다. ### 팩토리얼 예제 팩토리얼(n!)은 1부터 n까지 모든 양의 정수의 곱입니다. * `n! = n * (n-1)!` * `0! = 1`, `1! = 1` (기본 사례) ```python def factorial(n): if n < 0: raise ValueError("팩토리얼은 음수에 대해 정의되지 않습니다.") elif n == 0 or n == 1: return 1 # 기본 사례 else: return n * factorial(n - 1) # 재귀 단계 try: num = int(input("팩토리얼을 계산할 양수를 입력하세요: ")) result = factorial(num) print(f"{num}! = {result}") except ValueError as ve: print(f"오류: {ve}") except RecursionError: # 재귀 깊이가 너무 깊을 때 발생하는 오류 print("입력 값이 너무 커서 계산할 수 없습니다. (재귀 깊이 초과)") ``` --- ## 15. 특수 함수: Lambda, Map, Filter, Reduce, Enumerate, Generators 파이썬은 간결하고 효율적인 코드 작성을 돕는 다양한 내장 함수와 라이브러리 함수를 제공합니다. ### 람다 (Lambda) 함수 이름 없이 함수를 정의하는 익명 함수입니다. 간단한 한 줄짜리 함수에 유용합니다. * **문법**: `lambda arguments: expression` ```python # 숫자 제곱 계산 square = lambda x: x ** 2 print(square(5)) # 25 # 두 숫자 더하기 add = lambda a, b: a + b print(add(10, 5)) # 15 # 짝수 판별 is_even = lambda x: x % 2 == 0 print(is_even(4)) # True print(is_even(7)) # False ``` ### `map()` 함수 시퀀스의 각 항목에 함수를 적용하고, 그 결과를 새로운 시퀀스로 반환합니다. ```python numbers = [1, 2, 3, 4, 5] # 각 숫자를 제곱 squared_numbers = list(map(lambda x: x**2, numbers)) print(f"Squared numbers: {squared_numbers}") # [1, 4, 9, 16, 25] # 단어들을 대문자로 변환 words = ["hello", "world", "python"] upper_words = list(map(str.upper, words)) # str.upper 메서드 직접 사용 print(f"Uppercase words: {upper_words}") # ['HELLO', 'WORLD', 'PYTHON'] ``` ### `filter()` 함수 시퀀스의 각 항목에 함수를 적용하여, 함수가 `True`를 반환하는 항목들만으로 구성된 새로운 시퀀스를 반환합니다. ```python numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 짝수만 필터링 even_numbers = list(filter(lambda x: x % 2 == 0, numbers)) print(f"Even numbers: {even_numbers}") # [2, 4, 6, 8, 10] # 5보다 큰 숫자 필터링 greater_than_5 = list(filter(lambda x: x > 5, numbers)) print(f"Numbers greater than 5: {greater_than_5}") # [6, 7, 8, 9, 10] ``` ### `reduce()` 함수 `functools` 모듈에 있으며, 시퀀스의 항목들을 누적적으로 함수를 적용하여 하나의 결과값으로 만듭니다. ```python from functools import reduce numbers = [1, 2, 3, 4, 5] # 모든 숫자 더하기 sum_of_numbers = reduce(lambda x, y: x + y, numbers) print(f"Sum of numbers: {sum_of_numbers}") # 15 # 모든 숫자 곱하기 (팩토리얼 계산과 유사) product_of_numbers = reduce(lambda x, y: x * y, numbers) print(f"Product of numbers: {product_of_numbers}") # 120 ``` ### `enumerate()` 함수 시퀀스를 순회할 때 인덱스와 값을 함께 얻고 싶을 때 사용합니다. ```python fruits = ["apple", "banana", "cherry"] for index, fruit in enumerate(fruits): print(f"Index: {index}, Fruit: {fruit}") # Index: 0, Fruit: apple # Index: 1, Fruit: banana # Index: 2, Fruit: cherry # 인덱스 시작 값 변경 for index, fruit in enumerate(fruits, start=1): # 시작 인덱스를 1로 설정 print(f"Index: {index}, Fruit: {fruit}") # Index: 1, Fruit: apple # Index: 2, Fruit: banana # Index: 3, Fruit: cherry ``` ### 제너레이터 (Generators) 메모리를 효율적으로 사용하면서 데이터를 생성하는 특별한 종류의 이터레이터입니다. 요청될 때마다 다음 값을 생성합니다. * **리스트 컴프리헨션과의 비교**: `comprehension = [expr for item in iterable if condition]` (리스트 전체를 메모리에 생성) * **제너레이터 표현식**: `generator = (expr for item in iterable if condition)` (괄호 사용, 메모리에 즉시 생성하지 않음) ```python # 리스트 컴프리헨션: 모든 제곱 값을 리스트로 생성 squares_list = [x**2 for x in range(5)] print(f"List comprehension: {squares_list}") # [0, 1, 4, 9, 16] # 제너레이터 표현식: 필요할 때만 값을 생성 squares_generator = (x**2 for x in range(5)) print(f"Generator object: {squares_generator}") # at ...> # 제너레이터 값 사용 (for 루프 또는 next() 함수) for square in squares_generator: print(square) # 0, 1, 4, 9, 16 (하나씩 생성하여 출력) ``` --- ## 16. 리스트 (Lists) 리스트는 파이썬에서 가장 유연하고 자주 사용되는 시퀀스 자료형으로, 다양한 타입의 데이터를 순서대로 저장할 수 있습니다. ### 리스트 생성 및 접근 * **생성**: `my_list = [item1, item2, ...]` 또는 `my_list = list((item1, item2, ...))` * **빈 리스트**: `empty_list = []` 또는 `empty_list = list()` * **인덱싱**: `my_list[index]` (0부터 시작, 음수 인덱스는 뒤에서부터) * **슬라이싱**: `my_list[start:stop:step]` (start는 포함, stop은 미포함) ```python # 리스트 생성 numbers = [1, 2, 3, 4, 5] mixed_list = [10, "Hello", 3.14, True, [1, 2]] # 리스트 요소 접근 print(numbers[0]) # 1 print(numbers[-1]) # 5 (마지막 요소) print(mixed_list[1]) # Hello # 리스트 슬라이싱 print(numbers[1:4]) # [2, 3, 4] (인덱스 1, 2, 3) print(numbers[:3]) # [1, 2, 3] (처음부터 인덱스 2까지) print(numbers[2:]) # [3, 4, 5] (인덱스 2부터 끝까지) print(numbers[::2]) # [1, 3, 5] (2칸씩 건너뛰며) print(numbers[::-1]) # [5, 4, 3, 2, 1] (리스트 뒤집기) ``` ### 리스트 조작 * **연결**: `list1 + list2` * **길이 확인**: `len(my_list)` * **요소 변경**: `my_list[index] = new_value` * **요소 추가**: * `append(item)`: 리스트 끝에 추가 * `insert(index, item)`: 지정한 인덱스에 추가 * **요소 제거**: * `pop()`: 마지막 요소 제거 및 반환 * `pop(index)`: 지정한 인덱스 요소 제거 및 반환 * `remove(value)`: 특정 값을 가진 첫 번째 요소 제거 * `del my_list[index]` 또는 `del my_list[start:stop]` * **정렬**: * `sort()`: 리스트 자체를 오름차순으로 정렬 (원본 변경) * `sorted(my_list)`: 정렬된 새 리스트 반환 (원본 유지) ```python list1 = [1, 2, 3] list2 = [4, 5, 6] combined_list = list1 + list2 print(f"Combined list: {combined_list}") # [1, 2, 3, 4, 5, 6] print(f"Length of combined list: {len(combined_list)}") # 6 # 요소 변경 combined_list[0] = 100 print(f"After changing element: {combined_list}") # [100, 2, 3, 4, 5, 6] # 요소 추가 combined_list.append(7) combined_list.insert(1, 200) # 인덱스 1에 200 삽입 print(f"After appending/inserting: {combined_list}") # [100, 200, 2, 3, 4, 5, 6, 7] # 요소 제거 last_item = combined_list.pop() # 7 제거 및 반환 print(f"Popped item: {last_item}, List after pop: {combined_list}") removed_item = combined_list.pop(1) # 인덱스 1의 200 제거 및 반환 print(f"Popped item at index 1: {removed_item}, List after pop: {combined_list}") combined_list.remove(4) # 값 4 제거 print(f"List after removing value 4: {combined_list}") # 정렬 unsorted_list = [5, 2, 8, 1, 9] unsorted_list.sort() # 원본 리스트 정렬 print(f"Sorted list (in-place): {unsorted_list}") # [1, 2, 5, 8, 9] sorted_new_list = sorted([5, 2, 8, 1, 9], reverse=True) # 새 리스트 생성, 역순 정렬 print(f"New sorted list (desc): {sorted_new_list}") # [9, 8, 5, 2, 1] # 합계, 최소값, 최대값 numbers_for_math = [10, 5, 20, 15] print(f"Sum: {sum(numbers_for_math)}") # 50 print(f"Min: {min(numbers_for_math)}") # 5 print(f"Max: {max(numbers_for_math)}") # 20 # 특정 값 존재 확인 print(f"Is 15 in list? {15 in numbers_for_math}") # True print(f"Is 100 in list? {100 in numbers_for_math}") # False ``` --- ## 16. 튜플 (Tuples) 튜플은 리스트와 유사하지만, 한 번 생성되면 내용을 변경할 수 없는 '불변(immutable)' 시퀀스입니다. ### 튜플 생성 및 특징 * **생성**: `my_tuple = (item1, item2, ...)` 또는 `my_tuple = tuple((item1, item2, ...))` * **불변성**: 생성 후에는 요소를 추가, 삭제, 변경할 수 없습니다. * **리스트보다 빠름**: 불변성 때문에 리스트보다 처리 속도가 빠를 수 있습니다. * **해시 가능**: 튜플은 해시 가능한(hashable) 객체이므로 딕셔너리의 키나 세트의 요소로 사용할 수 있습니다. ```python # 튜플 생성 my_tuple = (1, 2, 3, 4, 5) single_element_tuple = (1,) # 요소가 하나일 경우 쉼표 필수 mixed_tuple = (10, "Hello", 3.14, True) # 튜플 요소 접근 (리스트와 동일) print(my_tuple[0]) # 1 print(mixed_tuple[-1]) # True # 튜플 슬라이싱 (리스트와 동일) print(my_tuple[1:4]) # (2, 3, 4) # 튜플 조작 (변경 불가!) # my_tuple[0] = 100 # TypeError 발생 # my_tuple.append(6) # AttributeError 발생 # 튜플 길이, 합계, 최소/최대값, 존재 확인 (리스트와 동일) print(f"Length of my_tuple: {len(my_tuple)}") print(f"Sum of my_tuple: {sum(my_tuple)}") print(f"Is 3 in my_tuple? {3 in my_tuple}") # 튜플 연결 (새 튜플 생성) tuple1 = (1, 2) tuple2 = (3, 4) combined_tuple = tuple1 + tuple2 print(f"Combined tuple: {combined_tuple}") # (1, 2, 3, 4) # 튜플 내용 섞기 (원본 유지, 새 튜플 생성) print(f"Sorted tuple: {sorted(my_tuple)}") # [1, 2, 3, 4, 5] (리스트로 반환) # 튜플의 요소 개수 세기 data_tuple = (1, 2, 2, 3, 2, 4) print(f"Count of 2: {data_tuple.count(2)}") # 3 # 튜플에서 요소 인덱스 찾기 print(f"Index of 3: {data_tuple.index(3)}") # 3 # 튜플을 리스트로 변환 list_from_tuple = list(my_tuple) print(f"List from tuple: {list_from_tuple}") # [1, 2, 3, 4, 5] # 리스트를 튜플로 변환 tuple_from_list = tuple(numbers) # numbers는 이전 예제의 리스트 print(f"Tuple from list: {tuple_from_list}") # (1, 2, 3, 4, 5) ``` --- ## 17. 딕셔너리 (Dictionaries) 딕셔너리는 키(key)와 값(value)의 쌍으로 데이터를 저장하는 자료구조입니다. 리스트나 튜플처럼 순서가 정해진 것이 아니라, 키를 통해 값에 접근합니다. ### 딕셔너리 생성 및 접근 * **생성**: `my_dict = {key1: value1, key2: value2, ...}` 또는 `my_dict = dict(key1=value1, key2=value2)` * **빈 딕셔너리**: `empty_dict = {}` 또는 `empty_dict = dict()` * **접근**: `my_dict[key]` * **존재 확인**: `key in my_dict` ```python # 딕셔너리 생성 student = { "name": "Alice", "age": 20, "major": "Computer Science", "grades": [85, 90, 78] } # 빈 딕셔너리 생성 person = {} # 딕셔너리 요소 접근 print(f"Student name: {student['name']}") # Alice print(f"Student age: {student.get('age')}") # 20 (get() 메소드는 키가 없을 때 None 반환) print(f"Student major: {student['major']}") # Computer Science # 키 존재 확인 print(f"Is 'name' in student? {'name' in student}") # True print(f"Is 'gpa' in student? {'gpa' in student}") # False # 딕셔너리 크기 확인 print(f"Number of items in student: {len(student)}") # 4 ``` ### 딕셔너리 조작 * **항목 추가/수정**: `my_dict[key] = value` * **항목 제거**: * `pop(key)`: 특정 키의 항목을 제거하고 값을 반환 * `popitem()`: 임의의 항목(Python 3.7+에서는 마지막 삽입된 항목)을 제거하고 (key, value) 쌍을 반환 * `del my_dict[key]`: 특정 키의 항목을 삭제 * `clear()`: 딕셔너리의 모든 항목 삭제 * **키/값/항목 접근**: * `keys()`: 모든 키를 반환 (뷰 객체) * `values()`: 모든 값을 반환 (뷰 객체) * `items()`: 모든 (key, value) 쌍을 반환 (뷰 객체) ```python # 항목 추가/수정 student['university'] = "State University" # 추가 student['age'] = 21 # 수정 print(f"Student after update: {student}") # 항목 제거 removed_grade = student.pop('grades') # 'grades': [85, 90, 78] 제거 및 반환 print(f"Removed grades: {removed_grade}") last_item = student.popitem() # 마지막 항목 제거 및 반환 (university: State University) print(f"Removed item: {last_item}") # del student['age'] # age 항목 삭제 # 모든 항목 삭제 # student.clear() # 키, 값, 항목 접근 print(f"Keys: {student.keys()}") # dict_keys(['name', 'major', 'age']) print(f"Values: {student.values()}") # dict_values(['Alice', 'Computer Science', 21]) print(f"Items: {student.items()}") # dict_items([('name', 'Alice'), ('major', 'Computer Science'), ('age', 21)]) # 딕셔너리 순회 for key in student: print(f"Key: {key}, Value: {student[key]}") for key, value in student.items(): print(f"Item - Key: {key}, Value: {value}") ``` --- ## 18. 세트 (Sets) 세트는 순서가 없고 중복된 요소를 허용하지 않는 컬렉션입니다. 수학의 집합 연산을 지원합니다. ### 세트 생성 및 특징 * **생성**: `my_set = {item1, item2, ...}` (중복 자동 제거) 또는 `my_set = set((item1, item2, ...))` * **빈 세트**: `empty_set = set()` (주의: `{}`는 빈 딕셔너리를 만듭니다) * **불변성**: 세트 자체는 변경 가능하지만, 세트의 요소는 해시 가능해야 합니다 (불변이어야 함). * **순서 없음**: 요소에 인덱스로 접근할 수 없습니다. ```python # 세트 생성 numbers_set = {1, 2, 3, 2, 1, 4, 5, 5} print(f"Set with duplicates removed: {numbers_set}") # {1, 2, 3, 4, 5} # 빈 세트 생성 empty_set = set() # 세트 요소 추가 numbers_set.add(6) numbers_set.update([7, 8, 7]) # 여러 항목 추가 print(f"Set after adding elements: {numbers_set}") # {1, 2, 3, 4, 5, 6, 7, 8} # 세트 요소 제거 numbers_set.remove(8) # 요소 8 제거 (없으면 KeyError 발생) numbers_set.discard(9) # 요소 9 제거 (없어도 오류 발생 안 함) popped_item = numbers_set.pop() # 임의의 요소 제거 및 반환 print(f"Popped item from set: {popped_item}") print(f"Set after removals: {numbers_set}") # 세트 연산 set_a = {1, 2, 3, 4} set_b = {3, 4, 5, 6} print(f"Union (A | B): {set_a | set_b}") # {1, 2, 3, 4, 5, 6} print(f"Intersection (A & B): {set_a & set_b}") # {3, 4} print(f"Difference (A - B): {set_a - set_b}") # {1, 2} print(f"Symmetric Difference (A ^ B): {set_a ^ set_b}") # {1, 2, 5, 6} (A 또는 B에만 있는 요소) # 부분 집합 / 상위 집합 확인 set_c = {1, 2} print(f"Is C subset of A? {set_c.issubset(set_a)}") # True print(f"Is A superset of C? {set_a.issuperset(set_c)}") # True ``` --- ## 19. 클래스와 객체 (Classes and Objects) 객체 지향 프로그래밍(OOP)은 실제 세계의 객체를 모델링하여 소프트웨어를 설계하는 패러다임입니다. ### 클래스 정의 클래스는 객체를 생성하기 위한 "틀" 또는 "설계도"이며, 속성(attributes)과 메서드(methods)를 정의합니다. * **`class ClassName:`**: 클래스를 정의합니다. * **`__init__(self, ...)`**: 생성자 메서드로, 객체가 생성될 때 초기화 작업을 수행합니다. `self`는 객체 자신을 참조합니다. * **`self.attribute = value`**: 객체의 속성을 정의합니다. * **`def method_name(self, ...):`**: 객체의 동작을 정의하는 메서드입니다. ```python class Vehicle: # 생성자 메서드 def __init__(self, manufacturer, model): self.manufacturer = manufacturer # 속성 정의 self.model = model self._registration_number = None # private 속성 (관례) # 메서드 정의 def move(self): print(f"I am a vehicle and I move.") def get_manufacturer_model(self): return f"Manufacturer: {self.manufacturer}, Model: {self.model}" # Getter for private attribute def get_registration_number(self): return self._registration_number # Setter for private attribute def set_registration_number(self, number): self._registration_number = number # 클래스 상속 (Inheritance) class Car(Vehicle): # Vehicle 클래스를 상속받음 def __init__(self, manufacturer, model, car_type): super().__init__(manufacturer, model) # 부모 클래스의 __init__ 호출 self.car_type = car_type # 메서드 오버라이딩 (Overriding) def move(self): print(f"I am a car and I drive on roads.") def get_car_type(self): return f"Car type: {self.car_type}" class Motorcycle(Vehicle): def move(self): print(f"I am a motorcycle and I ride.") # 객체(인스턴스) 생성 my_car = Car("Toyota", "Corolla", "Sedan") my_bike = Motorcycle("Honda", "CBR500R") # 객체의 메서드 호출 my_car.move() # I am a car and I drive on roads. my_bike.move() # I am a motorcycle and I ride. # 속성 접근 print(my_car.get_manufacturer_model()) # Manufacturer: Toyota, Model: Corolla print(my_car.get_car_type()) # Car type: Sedan # private 속성 설정 및 접근 my_car.set_registration_number("ABC-123") print(f"Registration Number: {my_car.get_registration_number()}") # Registration Number: ABC-123 ``` ### 캡슐화 (Encapsulation), 다형성 (Polymorphism), 상속 (Inheritance) * **캡슐화**: 데이터(속성)와 해당 데이터를 조작하는 메서드를 하나의 단위(클래스)로 묶고, 내부 구현을 숨기는 것 (`_` 또는 `__` 접두사 사용). * **다형성**: 같은 이름의 메서드가 객체의 타입에 따라 다르게 동작하는 것 (예: `move()` 메서드). * **상속**: 부모 클래스의 속성과 메서드를 자식 클래스가 물려받아 재사용하고 확장하는 것. --- ## 20. 스크립트 재사용: 모듈과 패키지 심화 우리는 파이썬의 강력한 모듈과 패키지 시스템을 통해 코드를 재사용하고 라이브러리를 활용하여 개발 생산성을 극대화할 수 있습니다. ### 사용자 정의 모듈 생성 1. `my_module.py` 파일을 생성합니다. 2. 이 파일 안에 함수, 클래스, 변수 등을 정의합니다. ```python # my_module.py def greet(name): return f"Hello, {name}!" PI = 3.14159 ``` 3. 다른 파이썬 파일에서 `import my_module`을 사용하여 가져옵니다. ```python # main_script.py import my_module message = my_module.greet("World") print(message) print(f"PI value: {my_module.PI}") ``` ### `if __name__ == "__main__":` 파이썬 스크립트가 직접 실행될 때만 특정 코드가 실행되도록 하는 관용구입니다. 모듈로 임포트될 때는 해당 코드가 실행되지 않습니다. ```python # my_module.py def greet(name): return f"Hello, {name}!" def main(): # 메인 실행 로직 message = greet("Module User") print(message) if __name__ == "__main__": # 스크립트가 직접 실행될 때만 main() 호출 main() ``` `main_script.py`에서 `import my_module`하면 `greet` 함수만 사용할 수 있고, `my_module.py`를 직접 실행할 때만 "Hello, Module User!"가 출력됩니다. --- ## 21. 유용한 라이브러리 및 프레임워크 * **`NumPy`**: 과학 계산, 배열 처리, 선형 대수 등에 사용되는 핵심 라이브러리. * **`Pandas`**: 데이터 분석 및 조작에 탁월한 라이브러리로, DataFrame 구조를 제공. * **`Matplotlib` & `Seaborn`**: 데이터 시각화를 위한 라이브러리. * **`Requests`**: HTTP 요청을 보내고 응답을 받는 데 사용되는 라이브러리. * **`Beautiful Soup`**: HTML 및 XML 파일에서 데이터를 추출하는 웹 스크래핑 라이브러리. * **`Flask` & `Django`**: 웹 애플리케이션 개발 프레임워크. * **`TensorFlow` & `PyTorch`**: 딥러닝 및 머신러닝 라이브러리. --- ## 결론 이 강좌를 통해 우리는 파이썬의 기초부터 시작하여 변수, 데이터 타입, 연산자, 제어 흐름(조건문, 반복문), 함수, 모듈, 파일 입출력, 예외 처리, 재귀, 특수 함수(lambda, map, filter, reduce), 시퀀스 자료형(리스트, 튜플, 딕셔너리, 세트), 클래스와 객체, `os` 모듈, 그리고 몇 가지 유용한 프로그래밍 기법들까지 학습했습니다. 파이썬은 매우 방대한 언어이며, 여기서 다룬 내용은 빙산의 일각일 수 있습니다. 중요한 것은 이 기본기들을 바탕으로 끊임없이 배우고 실습하는 것입니다. **다음 단계**: * **라이브러리 및 프레임워크 학습**: 웹 개발, 데이터 과학, AI 등 관심 분야에 맞는 라이브러리 및 프레임워크를 학습하세요. * **프로젝트 진행**: 배운 내용을 활용하여 자신만의 프로젝트를 만들어 보세요. 작은 자동화 스크립트부터 시작하여 점차 복잡한 애플리케이션으로 발전시킬 수 있습니다. * **커뮤니티 참여**: 스택 오버플로우, GitHub 등에서 질문하고 답변하며 다른 개발자들과 교류하세요. * **공식 문서 활용**: 파이썬 공식 문서는 가장 정확하고 최신 정보를 제공하는 훌륭한 자료입니다. 파이썬 여정에 행운을 빌며, 앞으로도 즐겁게 코딩하시길 바랍니다!

파이썬 마스터하기: 기초부터 심화까지 완벽 정복

Comments (0)