파이썬 기초 문법 포트폴리오 프로젝트 (26)

728x90

변수와 자료형

안녕하세요, 이번에는 프로그래밍의 기본이 되는 변수와 자료형에 대해 알아보겠습니다. 변수와 자료형은 프로그램을 작성할 때 핵심적인 역할을 하므로, 이 개념을 확실히 이해하는 것이 중요합니다. 변수와 자료형을 잘 다루면 프로그램의 가독성과 유지보수성이 높아지고, 데이터를 효율적으로 처리할 수 있습니다.

변수란 무엇일까요?

변수(variable) 란 프로그램에서 사용되는 데이터를 저장하는 공간입니다. 변수에는 숫자, 문자열, 리스트, 딕셔너리 등 다양한 값을 저장할 수 있습니다. 변수의 이름은 개발자가 직접 정할 수 있으며, 이름 규칙을 지켜야 합니다.

예를 들어, 변수에 숫자 10을 저장한다면 다음과 같이 작성할 수 있습니다.

num = 10

여기서 num은 변수 이름이고, 10은 변수에 저장된 값입니다. 이제 프로그램 내에서 num을 사용하면 10이라는 값을 참조할 수 있습니다.

변수 이름을 지을 때에는 다음 규칙을 따르는 것이 좋습니다.

문자, 숫자, 밑줄(_)만 사용할 수 있습니다.
첫 문자는 문자나 밑줄(_)만 가능합니다.
대소문자를 구분합니다.
예약어(reserved word)는 사용할 수 없습니다.
의미 있고 명확한 이름을 사용하는 것이 좋습니다.

자료형이란?

자료형(data type)은 프로그래밍 언어에서 값을 저장하는 방식을 정의합니다. 파이썬에서는 크게 숫자형, 문자열, 리스트, 튜플, 딕셔너리, 집합, 불린 등의 자료형이 있습니다. 자료형에 따라 값을 저장하는 방식과 사용할 수 있는 연산, 함수가 다릅니다.

숫자형

숫자형에는 정수형(int), 실수형(float), 복소수형(complex) 등이 있습니다. 정수형은 정수 값을, 실수형은 소수점이 있는 실수 값을, 복소수형은 복소수 값을 저장합니다.

a = 10    # 정수형
b = 3.14  # 실수형
c = 1 + 2j # 복소수형

문자열

문자열(str)은 텍스트 데이터를 저장하는 자료형입니다. 문자열은 작은따옴표('), 큰따옴표("), 세 개의 작은/큰따옴표(''' 또는 """)로 표현할 수 있습니다.

greet = "Hello, World!"  # 큰따옴표
name = 'John Doe'        # 작은따옴표
multiline = '''This is    # 세 개의 작은따옴표
a multiline string'''

리스트

리스트(list)는 여러 개의 값을 순서대로 저장하는 자료형입니다. 리스트는 대괄호([ ])로 정의하며, 값은 쉼표(,)로 구분합니다.

fruits = ['apple', 'banana', 'cherry'] # 문자열 리스트
numbers = [1, 2, 3, 4, 5]              # 숫자 리스트
mixed = [1, 'hello', 3.14]             # 다양한 자료형 혼합 가능

리스트는 인덱스(index)를 사용하여 값에 접근할 수 있습니다. 인덱스는 0부터 시작합니다. 예를 들어, fruits[0]은 'apple'을 반환합니다.

리스트는 슬라이싱(slicing)을 통해 일부 값을 추출할 수도 있습니다. fruits[1:3]은 ['banana', 'cherry']를 반환합니다.

튜플

튜플(tuple)은 리스트와 비슷하지만, 값을 변경할 수 없습니다. 튜플은 소괄호(())로 정의하며, 값은 쉼표(,)로 구분합니다.

point = (3, 4)           # 숫자 튜플
person = ('John', 30, 'USA') # 다양한 자료형 혼합 가능

튜플도 인덱스와 슬라이싱을 사용할 수 있습니다.

딕셔너리

딕셔너리(dictionary)는 키(key)와 값(value) 쌍으로 이루어진 자료형입니다. 딕셔너리는 중괄호({})로 정의하며, 키와 값은 콜론(:)으로 구분합니다.

person = {'name': 'John', 'age': 30, 'country': 'USA'}

딕셔너리에서 값에 접근하려면 dict[key] 형식을 사용합니다. person['name']은 'John'을 반환합니다.

집합

집합(set)은 유일한 값들의 모음입니다. 집합은 중괄호({})로 정의하거나, set() 함수를 사용하여 생성할 수 있습니다.

fruits = {'apple', 'banana', 'cherry'}  # 직접 중괄호로 정의
numbers = set([1, 2, 3, 2, 1])          # set() 함수 사용, 중복 제거

집합은 수학에서의 집합 개념과 유사하게 교집합, 합집합, 차집합 등의 연산을 지원합니다.

불린

불린(bool)은 True나 False만 가질 수 있는 자료형입니다. 불린은 주로 조건문이나 반복문에서 활용됩니다.

is_student = True
has_job = False

자료형을 확인하려면 type() 함수를 사용합니다.

num = 10
print(type(num))  # <class 'int'>

이렇게 변수와 다양한 자료형을 사용하면 프로그램에서 데이터를 효율적으로 표현하고 처리할 수 있습니다. 변수와 자료형을 잘 활용하는 것은 프로그래밍의 기본 기술이므로, 이 개념을 확실히 이해하는 것이 중요합니다.

예를 들어, 학생 성적을 관리하는 프로그램을 만든다고 가정해 봅시다. 여기에서 학생 이름은 문자열, 성적은 숫자형, 과목 리스트는 리스트 등으로 표현할 수 있습니다. 또한 딕셔너리를 사용하면 학생 이름과 성적을 쌍으로 저장할 수 있어 편리합니다.

student_scores = {
    'Alice': 90,
    'Bob': 85,
    'Charlie': 92
}

subjects = ['Math', 'Science', 'English']

이제 변수와 자료형을 이해했으니, 다음으로 제어문에 대해 알아보겠습니다.

제어문 (조건문, 반복문)

프로그램을 작성할 때 일정한 조건에 따라 코드를 실행하거나, 반복적인 작업을 수행해야 하는 경우가 많습니다. 파이썬에서는 이를 위해 조건문과 반복문을 제공합니다.

조건문

조건문(conditional statement)은 특정 조건에 따라 코드를 실행할지 여부를 결정합니다. 파이썬에서는 if, elif, else를 사용하여 조건문을 작성할 수 있습니다.

if문

if 문은 가장 기본적인 조건문입니다. if 뒤의 조건이 True이면 코드 블록이 실행되고, False이면 실행되지 않습니다.

age = 18
if age >= 18:
    print("You are an adult.")

위 예제에서는 age가 18 이상이므로 "You are an adult."가 출력됩니다.

else문

else는 if 조건이 False인 경우에 실행되는 코드 블록을 정의합니다.

age = 15
if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

이 예제에서는 age가 18 미만이므로 "You are a minor."가 출력됩니다.

elif문

elif(else if의 약자)는 여러 개의 조건을 차례로 확인할 때 사용합니다.

score = 85
if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
elif score >= 70:
    print("Grade: C")
else:
    print("Grade: F")

위 예제에서는 score가 85이므로 "Grade: B"가 출력됩니다.

조건문에서 사용되는 연산자에는 ==(같음), !=(다름), <(작음), >(큼), <=(작거나 같음), >=(크거나 같음) 등이 있습니다. 또한 and, or, not과 같은 논리 연산자도 사용할 수 있습니다.

반복문

반복문(loop statement) 은 특정 작업을 반복적으로 수행할 때 사용합니다. 파이썬에서는 for와 while 반복문을 제공합니다.

for문

for 반복문은 시퀀스 자료형(리스트, 튜플, 문자열 등)의 값을 순차적으로 반복할 때 사용합니다.

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

위 예제에서는 fruits 리스트의 각 요소를 fruit 변수에 차례로 대입하면서 반복문이 실행됩니다.

range() 함수를 사용하면 숫자 시퀀스를 생성할 수 있습니다.

for i in range(5):
    print(i)  # 0 1 2 3 4

range(start, stop, step) 형태로 사용하면 start부터 stop-1까지 step 간격으로 숫자를 생성합니다.

for i in range(1, 11, 2):
    print(i)  # 1 3 5 7 9

while문

while 반복문은 특정 조건이 True인 동안 코드 블록을 반복 실행합니다.

count = 0
while count < 5:
    print(count)
    count += 1  # count = count + 1

위 예제에서는 count가 0부터 시작해서 5 미만일 때까지 반복문이 실행됩니다.

break문을 사용하면 반복문을 강제로 종료할 수 있고, continue문은 현재 반복을 건너뛰고 다음 반복으로 넘어갑니다.

조건문과 반복문은 프로그램의 흐름을 제어하는 핵심적인 도구입니다. 이를 효과적으로 활용하면 복잡한 로직을 쉽게 구현할 수 있습니다. 특히 반복문은 리스트나 딕셔너리 등의 자료형과 함께 사용되어 데이터 처리에 많이 활용됩니다.

예를 들어, 학생 리스트에서 평균 점수 이상인 학생만 출력하는 코드를 작성해 봅시다.

student_scores = {'Alice': 90, 'Bob': 75, 'Charlie': 85, 'David': 92}
avg_score = sum(student_scores.values()) / len(student_scores)

for name, score in student_scores.items():
    if score >= avg_score:
        print(f'{name} 학생의 성적은 {score}점입니다.')

이처럼 조건문과 반복문을 조합하면 다양한 방식으로 데이터를 처리할 수 있습니다.

함수

함수(function)는 특정 작업을 수행하는 코드 블록으로, 재사용성과 가독성을 높여줍니다. 함수를 효과적으로 활용하면 코드를 모듈화하고 중복을 줄일 수 있어 프로그램의 유지보수가 쉬워집니다.

함수 정의하기

파이썬에서 함수는 def 키워드를 사용하여 정의합니다.

def 함수이름(매개변수):
    # 함수 코드 블록
    return 반환값

def: 함수를 정의한다는 것을 나타내는 키워드입니다.
함수이름: 함수의 이름입니다. 변수 이름 규칙을 따라야 합니다.
매개변수: 함수에 전달되는 입력값입니다. 여러 개일 수 있으며, 쉼표로 구분합니다.
함수 코드 블록: 함수가 실행할 코드입니다. 들여쓰기를 사용하여 정의합니다.
return: 함수의 결과값을 반환합니다. return문이 없으면 None을 반환합니다.

예를 들어, 두 수를 더하는 함수를 정의해 봅시다.

def add(x, y):
    result = x + y
    return result

sum = add(3, 5)
print(sum)  # 8

add 함수는 x, y라는 두 개의 매개변수를 받습니다.
함수 내부에서 x와 y를 더한 값을 result에 저장합니다.
return 문을 통해 result 값을 반환합니다.
add(3, 5)를 호출하면 8이 반환되어 sum 변수에 저장됩니다.

가변 인수 함수

함수에서 매개변수의 개수를 미리 정하지 않고, 가변적으로 전달받을 수 있습니다. 이를 가변 인수(arbitrary arguments) 함수라고 합니다.

*args: 임의의 개수의 위치 인수를 튜플로 받습니다.
**kwargs: 임의의 개수의 키워드 인수를 딕셔너리로 받습니다.

def print_args(*args):
    print(args)

print_args(1, 2, 3)  # (1, 2, 3)

def print_kwargs(**kwargs):
    print(kwargs)

print_kwargs(name='Alice', age=25)  # {'name': 'Alice', 'age': 25}

람다 함수

람다 함수(lambda function) 는 이름이 없는 익명 함수로, 간단한 함수를 정의할 때 사용합니다. 람다 함수는 lambda 키워드를 사용하여 정의합니다.

lambda 매개변수: 표현식

예를 들어, 두 수를 곱하는 람다 함수는 다음과 같이 정의할 수 있습니다.

multiply = lambda x, y: x * y
result = multiply(3, 4)
print(result)  # 12

람다 함수는 간단한 연산에 유용하지만, 복잡한 로직은 일반 함수로 정의하는 것이 좋습니다.

함수 응용

함수는 다양한 방식으로 활용할 수 있습니다. 예를 들어, 함수를 인수로 전달하거나 반환값으로 사용할 수 있습니다. 이를 고차 함수(higher-order function)라고 합니다.

def apply_operation(x, y, operation):
    return operation(x, y)

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

print(apply_operation(3, 4, add))      # 7
print(apply_operation(3, 4, multiply)) # 12

위 예제에서 apply_operation 함수는 operation 함수를 매개변수로 받아 실행합니다. add와 multiply 함수를 각각 전달하면 덧셈과 곱셈 연산이 수행됩니다.

또한 map(), filter(), reduce() 등의 내장 함수를 활용하면 함수형 프로그래밍 스타일로 코딩할 수 있습니다.

함수는 프로그래밍의 핵심 개념 중 하나입니다. 함수를 효과적으로 사용하면 코드의 재사용성과 가독성이 높아지고, 복잡한 문제를 쉽게 해결할 수 있습니다. 특히 파이썬에서는 함수를 일급 객체(first-class object)로 취급하므로, 함수를 인수로 전달하거나 반환값으로 사용할 수 있습니다. 이러한 기능을 잘 활용하면 더욱 강력한 프로그래밍이 가능해집니다.

모듈과 패키지

프로그램의 규모가 커지면 코드를 체계적으로 관리하고 재사용하는 것이 중요해집니다. 파이썬에서는 모듈과 패키지를 통해 코드를 구조화하고 모듈화할 수 있습니다.

모듈

모듈(module)은 함수, 클래스, 변수 등을 정의한 파이썬 파일입니다. 모듈을 사용하면 코드를 재사용할 수 있고, 프로젝트를 논리적으로 구조화할 수 있습니다.

모듈은 .py 확장자를 가진 파일로 생성합니다. 예를 들어, math.py 모듈에 수학 관련 함수를 정의할 수 있습니다.

# math.py
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

다른 파일에서 이 모듈을 불러와 사용할 수 있습니다.

# main.py
import math

result1 = math.add(3, 4)
result2 = math.subtract(5, 2)
print(result1)  # 7
print(result2)  # 3

import 문을 사용하여 모듈을 불러올 수 있습니다. math는 모듈 이름이며, add와 subtract는 모듈 내의 함수입니다.

파이썬에는 많은 내장 모듈(built-in module)과 외부 모듈이 있습니다. 예를 들어, math, os, sys 등은 내장 모듈이고, numpy, pandas, requests 등은 외부 모듈입니다. 외부 모듈은 pip를 통해 설치할 수 있습니다.

pip install numpy

패키지

패키지(package) 는 모듈들의 집합입니다. 패키지를 사용하면 모듈을 계층적으로 구조화할 수 있어 더 큰 프로젝트를 관리하기 쉬워집니다.

패키지는 디렉토리로 구성되며, 해당 디렉토리에 __init__.py 파일이 있어야 합니다. __init__.py 파일은 패키지를 초기화하고 패키지 레벨의 코드를 작성하는 데 사용됩니다.

예를 들어, 다음과 같은 디렉토리 구조를 가진 패키지가 있다고 가정해 봅시다.

mypackage/
    __init__.py
    math.py
    stats.py

mypackage 디렉토리가 패키지이며, math.py와 stats.py는 모듈입니다. 다른 모듈에서 이 패키지를 불러오려면 다음과 같이 합니다.

import mypackage.math
import mypackage.stats

또는 다음과 같이 패키지에서 특정 모듈만 불러올 수도 있습니다.

from mypackage import math
from mypackage.stats import mean

이렇게 모듈과 패키지를 활용하면 코드를 체계적으로 관리할 수 있고, 다른 프로젝트에서도 쉽게 재사용할 수 있습니다. 모듈화와 패키지 구조는 프로그램의 유지보수성과 확장성을 높여줍니다.

모듈과 패키지는 파이썬 프로그래밍의 핵심 개념 중 하나입니다. 이를 잘 활용하면 코드를 논리적으로 구조화하고 재사용성을 높일 수 있습니다. 또한 파이썬 표준 라이브러리와 다양한 외부 라이브러리를 활용할 수 있어, 더 효율적인 프로그래밍이 가능해집니다.

파일 입출력

프로그램에서 파일을 읽고 쓰는 것은 매우 중요한 작업입니다. 파이썬에서는 파일 입출력(I/O, Input/Output) 기능을 통해 파일을 쉽게 다룰 수 있습니다.

파일 열기

파일을 열기 위해서는 open() 함수를 사용합니다.

file = open("파일경로", "모드")

파일경로: 열고자 하는 파일의 경로와 이름입니다.
모드: 파일을 어떤 모드로 열지 지정합니다. 주요 모드는 다음과 같습니다.
- 'r' (읽기 모드, 기본값)
- 'w' (쓰기 모드, 파일이 없으면 새로 생성)
- 'a' (추가 모드, 파일 끝에 새로운 내용 추가)
- 'x' (새로 쓰기 모드, 파일이 존재하면 오류 발생)
- 'b' (바이너리 모드)
- 't' (텍스트 모드, 기본값)

파일을 열면 파일 객체가 반환되며, 이를 통해 파일을 읽고 쓸 수 있습니다.

파일 읽기

파일을 읽는 방법에는 여러 가지가 있습니다.

# 전체 파일 읽기
file = open("data.txt", "r")
content = file.read()
file.close()
print(content)

# 한 줄씩 읽기
file = open("data.txt", "r")
lines = file.readlines()
file.close()
for line in lines:
    print(line)

# 반복문으로 한 줄씩 읽기
file = open("data.txt", "r")
for line in file:
    print(line)
file.close()

read(): 전체 파일 내용을 문자열로 반환합니다.
readlines(): 전체 파일 내용을 라인 단위로 리스트에 저장하여 반환합니다.
for 반복문을 사용하면 파일을 한 줄씩 읽을 수 있습니다.

파일 읽기가 완료되면 close() 메서드를 사용하여 파일을 닫아야 합니다. 파일을 닫지 않으면 메모리 누수가 발생할 수 있습니다.

파일 쓰기

파일에 데이터를 쓰려면 write() 메서드를 사용합니다.

# 새 파일 생성하고 내용 쓰기
file = open("output.txt", "w")
file.write("Hello, World!")
file.close()

# 기존 파일에 내용 추가하기
file = open("output.txt", "a")
file.write("\nThis is a new line.")
file.close()

write() 메서드는 문자열을 받아 파일에 씁니다. 파일 쓰기도 마찬가지로 close() 메서드를 사용하여 파일을 닫아야 합니다.

컨텍스트 매니저 (with 문)

파일 핸들링에서 close() 메서드를 호출하는 것을 잊어버리면 메모리 누수가 발생할 수 있습니다. 이를 방지하기 위해 컨텍스트 매니저(context manager)를 사용하는 것이 좋습니다.

with open("data.txt", "r") as file:
    content = file.read()
    print(content)

with 문은 파일을 자동으로 열고 닫습니다. 따라서 close() 메서드를 직접 호물론입니다. 계속해서 설명드리겠습니다.

예외 처리

프로그램을 실행하는 동안 예기치 않은 오류가 발생할 수 있습니다. 이러한 오류를 예외(exception)라고 하며, 프로그램이 중단되지 않고 계속 실행되도록 예외를 적절히 처리하는 것이 중요합니다.

예외 발생

파이썬에서 예외는 raise 문으로 발생시킬 수 있습니다.

x = 10
if x > 5:
    raise Exception("x는 5보다 클 수 없습니다.")

위 코드에서 x가 5보다 크므로 Exception이 발생합니다. 이 때 "x는 5보다 클 수 없습니다."라는 메시지와 함께 예외가 출력됩니다.

예외 처리하기

예외를 처리하려면 try문과 except문을 사용합니다.

try:
    # 예외 발생 가능 코드
except 예외종류1:
    # 예외 처리 코드1
except 예외종류2:
    # 예외 처리 코드2
else:
    # 예외가 발생하지 않았을 때 실행할 코드
finally:
    # 예외 발생 여부와 상관없이 실행할 코드

try 블록: 예외 발생 가능 코드를 작성합니다.
except 블록: 예외 종류에 따라 적절한 처리 코드를 작성합니다.
else 블록(선택): 예외가 발생하지 않았을 때 실행할 코드를 작성합니다.
finally 블록(선택): 예외 발생 여부와 상관없이 실행할 코드를 작성합니다. 주로 리소스 정리에 사용됩니다.

예시:

try:
    x = int(input("숫자를 입력하세요: "))
    y = 10 / x
    print(y)
except ValueError:
    print("숫자가 아닌 값을 입력했습니다.")
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")
else:
    print("계산 성공!")
finally:
    print("프로그램 종료")

이 예제에서는 사용자에게 숫자를 입력받아 10을 나누는 코드입니다. 숫자가 아닌 값을 입력하면 ValueError가 발생하고, 0을 입력하면 ZeroDivisionError가 발생합니다. 각 예외 상황에 따라 적절한 메시지를 출력하고, 예외가 발생하지 않으면 "계산 성공!"이 출력됩니다. 마지막으로 finally 블록에서 "프로그램 종료"를 출력합니다.

사용자 정의 예외

파이썬에서는 Exception 클래스를 상속받아 사용자 정의 예외를 만들 수 있습니다.

class MyException(Exception):
    def __init__(self, message):
        self.message = message

    def __str__(self):
        return self.message

try:
    raise MyException("이것은 사용자 정의 예외입니다.")
except MyException as e:
    print(e)

위 예제에서는 MyException 클래스를 정의하고, 예외 메시지를 생성자에서 받아 message 속성에 저장합니다. __str__ 메서드를 재정의하여 예외 메시지를 문자열로 반환합니다. raise 문으로 MyException을 발생시키면, 정의한 예외 메시지가 출력됩니다.

예외 처리는 프로그램의 안정성과 견고성을 높이는 데 매우 중요합니다. 적절한 예외 처리를 통해 프로그램이 예기치 않은 상황에서도 중단되지 않고 계속 실행될 수 있습니다. 또한 사용자 정의 예외를 만들어 프로그램의 특정 상황을 처리할 수 있습니다.

객체 지향 프로그래밍 (OOP)

객체 지향 프로그래밍(Object-Oriented Programming, OOP)은 프로그램을 객체 단위로 설계하고 구현하는 프로그래밍 패러다임입니다. OOP는 코드 재사용성과 유지보수성을 높여주며, 대규모 프로젝트를 효율적으로 관리할 수 있게 해줍니다.

파이썬은 객체 지향 언어로, 클래스와 객체를 지원합니다.

클래스와 객체

클래스(class)는 객체를 정의하는 청사진이나 설계도 역할을 합니다. 클래스에는 속성(attribute)과 메서드(method)가 정의되어 있습니다.

객체(object)는 클래스에 정의된 대로 생성된 인스턴스입니다. 객체는 클래스의 속성과 메서드를 상속받아 사용할 수 있습니다.

class Person:
    def __init__(self, name, age):
        self.name = name  # 속성
        self.age = age

    def greet(self):  # 메서드
        print(f"Hello, my name is {self.name}.")

person1 = Person("Alice", 25)  # 객체 생성
person1.greet()  # 메서드 호출

Person 클래스는 name과 age 속성을 가지고 있습니다.
__init__ 메서드는 생성자로, 객체를 초기화할 때 호출됩니다.
self는 현재 인스턴스를 가리키는 인스턴스 객체입니다.
greet 메서드는 인사말을 출력합니다.
person1은 Person 클래스의 인스턴스 객체입니다.

상속과 다형성

상속(inheritance) 은 기존 클래스의 속성과 메서드를 새로운 클래스에서 물려받는 것을 말합니다. 상속을 통해 코드 재사용성이 높아집니다.

다형성(polymorphism) 은 동일한 메서드 이름을 가지고 있지만, 각 클래스에 맞게 다르게 동작하는 것을 말합니다.

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass  # 구현 부분이 없음

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

dog = Dog("Buddy")
cat = Cat("Whiskers")

animals = [dog, cat]
for animal in animals:
    animal.speak()  # 다형성 예시

Animal 클래스는 name 속성과 speak 메서드를 가지고 있습니다.
Dog와 Cat 클래스는 Animal 클래스를 상속받고, speak 메서드를 각자의 방식으로 구현했습니다.
animals 리스트에 Dog와 Cat 객체가 들어있습니다.
반복문에서 각 객체의 speak 메서드를 호출하면, 객체의 종류에 따라 다른 동작을 수행합니다(다형성).

캡슐화와 정보 은닉

캡슐화(encapsulation)는 객체의 속성과 메서드를 하나로 묶는 것을 말합니다. 이를 통해 객체의 내부 구현을 외부에 숨길 수 있습니다.

정보 은닉(information hiding)은 객체의 속성과 메서드에 대한 접근을 제한하는 것을 말합니다. 파이썬에서는 이름 앞에 _를 붙여 private 속성이나 메서드를 정의할 수 있습니다.

class BankAccount:
    def __init__(self, balance=0):
        self._balance = balance  # private 속성

    def deposit(self, amount):
        self._balance += amount

    def withdraw(self, amount):
        if self._balance >= amount:
            self._balance -= amount
        else:
            print("잔액이 부족합니다.")

    def get_balance(self):
        return self._balance

account = BankAccount(1000)
account.deposit(500)
account.withdraw(2000)  # 잔액이 부족합니다.
print(account.get_balance())  # 1500

BankAccount 클래스에서 _balance는 private 속성입니다.
deposit와 withdraw 메서드를 통해서만 _balance를 변경할 수 있습니다.
get_balance 메서드로 _balance를 외부에 공개할 수 있습니다.

이렇게 캡슐화와 정보 은닉을 사용하면 객체의 상태를 보호하고, 객체 간의 의존성을 낮출 수 있습니다.

OOP 원칙

OOP에는 다음과 같은 주요 원칙이 있습니다.

단일 책임 원칙(Single Responsibility Principle): 클래스는 단 하나의 책임만 가져야 합니다.
개방-폐쇄 원칙(Open-Closed Principle): 소프트웨어 엔티티는 확장에는 열려 있어야 하지만, 수정에는 닫혀 있어야 합니다.
리스코프 치환 원칙(Liskov Substitution Principle): 프로그램의 객체는 프로그램의 상위 타입으로 교체될 수 있어야 합니다.
인터페이스 분리 원칙(Interface Segregation Principle): 특정 클라이언트를 위한 인터페이스 여러 개가 범용 인터페이스 하나보다 낫습니다.
의존 역전 원칙(Dependency Inversion Principle): 상위 계층이 하위 계층에 의존하면 안 됩니다. 둘 다 추상화에 의존해야 합니다.

이러한 원칙을 따르면 유지보수가 용이하고 확장 가능한 소프트웨어를 만들 수 있습니다.

OOP는 프로그래밍 패러다임 중 하나로, 코드 재사용성과 유지보수성을 높여줍니다. 클래스와 객체, 상속과 다형성, 캡슐화와 정보 은닉 등의 개념을 활용하면 대규모 프로젝트를 효율적으로 관리할 수 있습니다. 또한 OOP 원칙을 따르면 더욱 견고하고 확장 가능한 소프트웨어를 개발할 수 있습니다.

참고 자료

점프 투 파이썬 (https://wikidocs.net/book/1)
파이썬 공식 문서 (https://docs.python.org/3/)
"Automate the Boring Stuff with Python" by Al Sweigart
"Python Tricks: A Buffet of Awesome Python Features" by Dan Bader
"Clean Code" by Robert C. Martin

이것으로 파이썬 기초 문법에 대한 설명을 마치겠습니다. 변수와 자료형, 제어문, 함수, 모듈과 패키지, 파일 입출력, 예외 처리, 객체 지향 프로그래밍 등 핵심 개념을 다루었습니다. 이 내용을 확실히 이해하면 파이썬 프로그래밍의 기반을 단단히 다질 수 있을 것입니다.

요약: 파이썬은 간결하고 강력한 프로그래밍 언어로, 다양한 영역에서 활용되고 있습니다. 이번 챕터에서는 변수와 자료형, 제어문, 함수, 모듈과 패키지, 파일 입출력, 예외 처리, 객체 지향 프로그래밍 등의 핵심 개념을 자세히 살펴보았습니다. 변수와 자료형을 통해 데이터를 효율적으로 표현하고, 제어문으로 프로그램의 흐름을 제어할 수 있습니다. 함수를 활용하면 코드를 모듈화하고 재사용할 수 있으며, 모듈과 패키지로 프로젝트를 체계적으로 관리할 수 있습니다. 파일 입출력을 통해 데이터를 영구적으로 저장하고 읽을 수 있고, 예외 처리로 프로그램의 안정성을 높일 수 있습니다.

한 고대 문서 이야기

여기 한 고대 문서가 있습니다. 이 문서는 B.C. 1,500년 부터 A.D 100년까지 약 1,600 여 년 동안 기록되었습니다. 이 문서의 저자는 약 40 명입니다. 이 문서의 고대 사본은 25,000 개가 넘으나, 사본간 오

gospel79.tistory.com

유튜브 프리미엄 월 1만원 할인받고 월 4000원에 이용하는 방법

올해 5월부터 월 8000원 정도이던 유튜브 프리미엄 요금이 15000원 정도로 인상됩니다. 각종 OTT 서비스, ChatGPT 같은 서비스들이 늘어나다보니 이런 거 몇 개만 이용하더라도 월 이용요금이 5만원을

stock79.tistory.com

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."