[전공 기말고사 정리] 파이썬 – 함수·리스트·튜플/세트/딕셔너리·객체와 클래스

함수란? 명령어 묶음에 이름을 붙인 것. 코드 중복 제거, 재사용, 문제 분해가 장점.

정의 문법
def 함수이름(매개변수1, 매개변수2, …):
명령문
return 반환값

예시
def get_area(radius):
area = 3.14 * radius ** 2
return area

핵심 키워드

• def: 함수 정의 시작
• return: 함수 종료 + 값 반환
• pass: 몸체를 나중에 작성할 때 쓰는 자리표시자

인수(Argument)와 매개변수(Parameter)

• 인수: 호출할 때 실제로 전달하는 값 (get_area(3)에서 3)
• 매개변수: 정의할 때 전달받는 변수 (radius)
• 매개변수를 함수 안에서 바꿔도 원래 인수 변수는 바뀌지 않음 (값 복사 방식)

인수의 4가지 종류

1. 일반 인수: sub(10, 20) - 순서대로 전달
2. 디폴트 인수: def f(x, y=5) - 기본값 있어 생략 가능
3. 가변 인수: def f(*args) - 개수 제한 없이 튜플로 받음
4. 키워드 인수: f(x=10, y=20) - 이름 지정 전달 (단, 키워드 인수 뒤에는 일반 인수 못 옴)

가변 인수 예시
def add(*numbers):
total = 0
for n in numbers:
total += n
return total

값 반환

• 값 1개: return area
• 여러 개: return name, age → 튜플로 반환, a, b = func()로 받기
• 반환 없으면 None 자동 반환
• if/else 모든 경우에 return 넣는 습관 들이기

변수의 범위

• 지역 변수: 함수 안에서만 접근 가능
• 전역 변수: 함수 밖에 선언, 어디서든 읽기 가능. 함수 안에서 수정하려면 global 키워드 필요

gx = 100
def myfunc():
global gx
gx = 200
myfunc()
print(gx)  # 200

global 없이 함수 안에서 gx=200 하면 새 지역 변수가 생기고 전역 gx는 그대로 100.

순환 호출(재귀)
함수가 자기 자신을 호출하는 것. 반드시 종료 조건(Base Case)이 필요 (없으면 무한 루프).

def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)

실전 예제: 주급 계산 (30시간 초과는 시급의 1.5배)
def weeklyPay(rate, hour):
if hour > 30:
money = rate * 30 + 1.5 * rate * (hour - 30)
else:
money = rate * hour
return money

5장 체크리스트

• def로 정의, 호출 전에 먼저 정의되어야 함(인터프리터 언어)
• 호출 시 전달=인수, 정의 시 받는 변수=매개변수
• return으로 값 반환, 여러 값도 가능
• 디폴트/키워드/가변 인수 구분
• 지역 vs 전역, global 키워드
• 재귀는 종료 조건 필수

[6장. 리스트(List)]

리스트는 여러 값을 순서대로 담는 자료구조. 대괄호[ ]로 생성, 쉼표로 구분, 어떤 타입도 혼합 가능.

temps = [28, 31, 33, 35, 27, 26, 25]
인덱스는 0부터 시작, 음수 인덱스는 뒤에서부터(-1이 마지막).
temps[3] = 36 처럼 요소 변경 가능. 존재하지 않는 인덱스 접근 시 IndexError.

리스트 순회

• range+len: 인덱스 번호가 필요할 때
• for element in 리스트: 값만 필요할 때 (더 간결)
• zip(): 두 리스트를 같은 위치끼리 묶어서 순회

for day, temp in zip(days, temps):
print(f”{day}: {temp}도”)

주요 메서드
append(값) - 끝에 추가
insert(위치, 값) - 지정 위치에 삽입
remove(값) - 값으로 삭제(없으면 오류)
pop(위치) - 위치 요소 삭제 후 반환
index(값) - 값의 위치 반환
sort() / sort(reverse=True) - 오름차순/내림차순 정렬(원본 변경)
reverse() - 순서 뒤집기
clear() - 모두 삭제
copy() - 복사본 반환
extend(리스트) - 다른 리스트 요소 전부 추가
count(값) - 등장 횟수
sorted(리스트) - 정렬된 새 리스트(원본 유지)

슬라이싱
리스트[start:stop:step] → start부터 stop-1까지, step 간격
numbers[2:7] → 인덱스 2~6
numbers[:3], numbers[5:], numbers[:]
numbers[::-1] → 역순
numbers[2:7:2] → 2칸씩 건너뛰기

리스트 복사 주의사항
values = temps 는 복사가 아니라 같은 리스트를 가리키는 것! (values 바꾸면 temps도 바뀜)
올바른 복사: values = list(temps) 또는 temps[:] 또는 temps.copy()

리스트 함축(List Comprehension)
새리스트 = [표현식 for 변수 in 반복대상 if 조건(선택)]

squares = [xx for x in range(10)]
even_squares = [xx for x in range(10) if x % 2 == 0]
fixed = [p if p > 0 else 0 for p in prices]

2차원 리스트
s = [[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]]
s[행][열] 형식으로 접근. s[1][2] → 8
동적 생성: s = [[0]*cols for _ in range(rows)]

함수로 리스트 전달
리스트를 함수에 넘기면 함수 안에서 변경한 내용이 원본에도 반영됨(정수/문자열과 다름, 같은 객체를 참조하기 때문).

[7장. 튜플/세트/딕셔너리/문자열]

튜플(Tuple)
리스트와 비슷하지만 한 번 만들면 수정 불가(Immutable). 괄호()로 생성.
fruits = (“apple”, “banana”, “grape”)
single = (“apple”,)  ← 요소 1개면 쉼표 필수(없으면 그냥 문자열)
수정 시도하면 TypeError.

패킹/언패킹
t = (“apple”, “banana”, “grape”)  # 패킹
(s1, s2, s3) = t  # 언패킹
두 변수 값 교환: n1, n2 = n2, n1 (temp 변수 불필요)

enumerate() - 인덱스+값 동시에
for index, value in enumerate(fruits):
print(index, value)

리스트 vs 튜플: 튜플은 변경 불가지만 속도가 빠르고 딕셔너리 키로 쓸 수 있음.

세트(Set)
수학의 집합. 중복 자동 제거, 순서 없어 인덱스 접근 불가.
numbers = {1, 2, 3}
공백 세트는 반드시 set() 사용 ({}는 딕셔너리가 됨)
add(값) - 추가 / remove(값) - 삭제(없으면 오류) / discard(값) - 삭제(없어도 안전)

집합 연산
합집합: A | B 또는 A.union(B)
교집합: A & B 또는 A.intersection(B)
차집합: A - B 또는 A.difference(B)
부분집합 확인: A < B 또는 A.issubset(B)

중복 제거 활용: len(set(list1))
공통 원소 찾기: set(list1) & set(list2)

딕셔너리(Dictionary)
키(Key)와 값(Value)을 쌍으로 저장.
capitals = {“Korea”: “Seoul”, “USA”: “Washington”}
접근: capitals[“Korea”] (없는 키면 KeyError)
안전한 접근: capitals.get(“France”, “없음”)

추가/수정: capitals[“France”] = “Paris”
삭제: capitals.pop(“UK”)

반복 처리
for key, value in capitals.items():
print(key, “:”, value)
keys(), values(), items() 로 각각 목록 얻기

딕셔너리 함축
dic = {x: x**2 for x in values if x % 2 == 0}

문자열(String) 심화
문자들의 시퀀스. 인덱싱/슬라이싱 가능하지만 튜플처럼 수정 불가.
s = “Monty Python”
s[0], s[-1], s[6:10], s::-1

주요 메서드
upper(), lower(), capitalize()
strip() - 공백 제거
replace(a,b) - 대체
find(sub) - 위치 찾기
count(sub) - 개수
split(sep) - 자르기 → 리스트
sep.join(list) - 리스트를 하나의 문자열로 합치기
startswith(x), endswith(x)
isalpha(), isdigit()

f-문자열
print(f”{x}과 {y}의 곱은 {prod}”)

자료구조 비교표
리스트[ ]: 순서O, 중복O, 변경 가능
튜플( ): 순서O, 중복O, 변경 불가, 딕셔너리 키 사용 가능
세트{ }: 순서X, 중복X, 집합 연산 가능
딕셔너리{ }: 순서O, 키는 중복 불가, 키:값 쌍
문자열” “: 순서O, 중복O, 변경 불가

[8장. 객체와 클래스]

객체 지향 프로그래밍(OOP)
데이터와 함수를 객체로 묶어서 프로그래밍하는 방식. 절차 지향은 함수 중심, 객체 지향은 객체(데이터+함수 결합) 중심.
파이썬은 모든 것이 객체 (정수, 문자열, 리스트도 객체).

객체와 클래스

• 객체: 속성(attribute)+동작(action)을 가진 것
• 클래스: 객체를 만들기 위한 설계도(blueprint)
• 인스턴스: 클래스로부터 만들어진 실제 객체

클래스 작성법
class 클래스이름:
def init(self, 매개변수):
self.속성1 = 값1
def 메소드이름(self):
# 동작 코드

핵심 키워드

• class: 클래스 정의 시작, 이름은 대문자로 시작(관례)
• init(self): 생성자, 객체 생성 시 자동 호출
• self: 현재 인스턴스를 가리키는 참조, 모든 메소드의 첫 매개변수
• 객체명 = 클래스명(): 인스턴스 생성

예시
class Counter:
def init(self, initValue=0):
self.count = initValue
def increment(self):
self.count += 1

정보 은닉(캡슐화)
변수명 앞에 __(밑줄 두 개)를 붙이면 외부에서 직접 접근 불가(private).
접근자(getter)/설정자(setter)로만 값을 읽고 쓰게 함.

class Student:
def init(self, name=None, age=0):
self.__name = name
self.__age = age
def getName(self): return self.__name
def setName(self, name): self.__name = name

정보 은닉이 필요한 이유: 잘못된 값이 직접 들어가는 것을 막기 위해(예: 나이에 음수 방지).

객체 참조
파이썬 변수는 객체의 주소(참조)를 저장. s = t는 복사가 아니라 같은 객체를 가리킴.
s.channel = 9 하면 t.channel도 바뀜(같은 객체이므로).
is / is not - 같은 객체 참조인지 확인
함수에 객체를 전달하면 원본 참조가 전달되므로, 함수 안에서 속성을 바꾸면 원본도 바뀜.

클래스 변수 vs 인스턴스 변수

• 인스턴스 변수: 각 객체마다 독립적 (self.변수)
• 클래스 변수: 모든 객체가 공유, 클래스 블록에서 메소드 밖에 선언

class Television:
serialNumber = 0  # 클래스 변수
def init(self, ch, vol, on):
self.channel = ch  # 인스턴스 변수
Television.serialNumber += 1

특수 메소드(매직 메소드)
init: 생성자
str: str()/print() 호출 시 반환 문자열
add, sub: +, - 연산자 정의
eq: == 비교
lt: < 비교

class Vector2D:
def init(self, x, y):
self.x = x; self.y = y
def add(self, other):
return Vector2D(self.x + other.x, self.y + other.y)
def str(self):
return “(%g, %g)” % (self.x, self.y)