1. 파이썬

1) 개요

귀도 반 로썸이 1991년 창시
스크립트 언어: 인터프리터 방식
동적 타이핑: 변수의 자료형을 지정하지 않고 선언
플랫폼 독립적: OS 상관없이 모두 동작
객체 지향 언어
간결하고 쉬운 문법, 빠른 개발 속도
높은 확장성 및 이식성
활발한 생태계

2) 파이썬 활용

자동화
웹 프로그래밍
인공지능
수치 연산 프로그래밍
데이터 분석
데이터베이스 프로그래밍
시스템 유틸리티
GUI 프로그래밍
C/C++와 결합
사물인터넷

3) 활용 사례

구글: C++과 파이썬을 결합해 활용
인스타그램: Django 사용
넷플릭스
스포티파이
드롭박스

2. 파이썬 기초

1) 숫자형

자동 형변환
print(type())은 자료형을 보여줌

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

사칙연산: 나눗셈의 결과는 항상 float
나누어 떨어져도 float형으로 출력됨

print(10 / 5)
# 2.0

제곱: **
나머지: %
몫: //

print(5 ** 2)  # 25
print(5 % 2)   # 1
print(5 // 2)  # 2

몫과 나머지는 정수형끼리만 연산 가능한 것이 아니라 실수형도 가능
실수형이 포함될 경우 결과는 항상 float

print(5.0 // 2)
# 2.0

2) 문자열

작은따옴표든 큰따옴표든 상관 없음

a = 'hello'
b = "hello"

같은 따옴표를 문자열 안에서 사용할 경우 역슬래시 사용

a = 'I\'m happy'

문자열끼리의 덧셈, 곱셈으로 여러 개를 한 번에 나타내기 가능

a = "Hello "
b = "world"

print(a + b)
# Hello world

print(a * 3)
# Hello Hello Hello

문자열과 숫자형을 더하면 오류 발생

print("Hello" + 3)
# 오류

2-1) 슬라이싱

슬라이싱 형식: [시작 : 끝]
인덱스는 0번부터 시작
시작 이상, 끝 미만

a = "computer software"

print(a[0])
# c

[인덱스]일 경우 해당 인덱스 위치의 하나의 값을 의미

print(a[:5])
# compt

시작부터 5 미만까지 출력

print(a[-1])
# e

뒤에서 첫 번째 값 출력

print(a[-5:])
# tware

뒤에서 다섯 번째부터 끝까지 출력

print(a[:-3])
# computer softw

시작부터 뒤에서 세 번째 전까지 출력

2-2) 문자열 출력 형식

.format() 방식

출력 형식 지정

print("subject: {0}, score: {1}".format(a, b))

{0}에는 a 값
{1}에는 b 값

문자열 보간

문자열에 변수를 같이 적음
f로 시작

print(f"subject: {a}, score: {b}")

2-3) 문자열 관련 함수

upper(), lower()

upper(): 문자열을 대문자로 변환
lower(): 문자열을 소문자로 변환
알파벳에만 적용됨
한글이나 숫자 등은 변화 없이 그대로 출력

a = "Hello123안녕"

print(a.upper())
# HELLO123안녕

print(a.lower())
# hello123안녕

2-4) 공백 제거

a.lstrip()

좌측 공백 제거

a.rstrip()

우측 공백 제거

a.strip()

양쪽 공백 제거
사이 공백을 지우지는 못함

2-5) replace()

replace('바꿀대상', '적용할 값')

예시:

a = "computer software"
b = a.replace("software", "good")

print(b)
# computer good

print(a)
# computer software

b는 computer good
a는 값이 바뀌지 않음

2-6) split()

split(기준 문자)

기준 문자를 기준으로 나눔
결과는 리스트로 나옴
기준 문자가 없을 경우 공백 기준

예시:

c = "You&I"
d = c.split("&")

print(d)
# ['You', 'I']

3) 리스트 list

리스트는 여러 값을 순서대로 저장하는 자료형이다.

a = [1, 2, 3, 4, 5]
b = ['a', 'b', 'c', 'd', 'e']
c = [1, 2, 'c', 'd', 'e']
d = [1, [1, 2], ['a', 'b'], 'd']

3-1. 리스트 특징

- 여러 값을 하나로 묶어서 저장
- 순서가 있음
- 인덱스로 접근 가능
- 값 변경 가능
- 값 추가 가능
- 값 삭제 가능

리스트는 인덱스를 사용해서 값을 꺼낼 수 있다.

d = [1, [1, 2], ['a', 'b'], 'd']

print(d[0])
# 1

print(d[1])
# [1, 2]

print(d[-1])
# d

인덱스는 0부터 시작하고, -1은 뒤에서 첫 번째 값을 의미한다.

3-2. 리스트 안에 리스트

리스트 안에는 다른 리스트를 넣을 수 있다.

d = [1, [1, 2], ['a', 'b'], 'd']

print(d[1])
# [1, 2]

print(d[1][0])
# 1

외우기 쉽게 보면 다음과 같다.

d[1]    → 두 번째 요소를 꺼냄
d[1][0] → 두 번째 요소 안에서 첫 번째 요소를 꺼냄

3-3. 리스트 연산

+ : 리스트 연결

a = [1, 3, 2, 7, 5]
b = [4, 2, 5, 7, 1]

print(a + b)
# [1, 3, 2, 7, 5, 4, 2, 5, 7, 1]

+는 숫자처럼 더하는 것이 아니라 리스트를 서로 연결한다.

* : 리스트 반복

a = [1, 3, 2, 7, 5]

print(a * 2)
# [1, 3, 2, 7, 5, 1, 3, 2, 7, 5]

*는 리스트의 내용을 반복해서 붙인다.

3-4. 리스트 값 변경

리스트는 값을 변경할 수 있다.

a = [1, 3, 2, 7, 5]

a[0] = 10

print(a)
# [10, 3, 2, 7, 5]

문자열이나 튜플과 다르게 리스트는 원본 값을 직접 바꿀 수 있다.

3-5. 리스트 값 삭제

del

a = [1, 3, 2, 7, 5]

del a[0]

print(a)
# [3, 2, 7, 5]

del은 인덱스를 기준으로 값을 삭제한다.

del a[0]
→ 0번 인덱스 값 삭제

remove()

a = [1, 8, 2, 3, 4, 5, 4]

a.remove(4)

print(a)
# [1, 8, 2, 3, 5, 4]

remove()는 값을 기준으로 삭제한다.

주의할 점은 같은 값이 여러 개 있으면 앞에 있는 첫 번째 값만 삭제한다.

remove(값)
→ 해당 값을 삭제
→ 같은 값이 여러 개면 첫 번째 값만 삭제

pop()

a = [1, 8, 2, 3, 5]

a.pop()

print(a)
# [1, 8, 2, 3]

pop()은 맨 뒤의 값을 꺼내고 삭제한다.

a = [1, 8, 2, 3, 5]

result = a.pop()

print(result)
# 5

print(a)
# [1, 8, 2, 3]

pop()은 값을 반환하면서 동시에 원본 리스트에서 삭제한다.

인덱스를 지정할 수도 있다.

a = [1, 8, 2, 3, 5]

result = a.pop(1)

print(result)
# 8

print(a)
# [1, 2, 3, 5]

pop()    → 맨 뒤 값을 꺼내고 삭제
pop(1)   → 1번 인덱스 값을 꺼내고 삭제

3-6. 리스트 값 추가

append()

a = [1, 2, 3]

a.append(4)

print(a)
# [1, 2, 3, 4]

append()는 리스트의 맨 뒤에 값을 추가한다.

리스트를 넣으면 리스트 자체가 하나의 요소로 들어간다.

a = [1, 2, 3]

a.append([4, 5])

print(a)
# [1, 2, 3, [4, 5]]

extend()

a = [1, 2, 3]

a.extend([4, 5])

print(a)
# [1, 2, 3, 4, 5]

extend()는 리스트 안의 값을 풀어서 추가한다.

append()와 비교하면 다음과 같다.

a = [1, 2, 3]
a.append([4, 5])
print(a)
# [1, 2, 3, [4, 5]]

b = [1, 2, 3]
b.extend([4, 5])
print(b)
# [1, 2, 3, 4, 5]

append() → 통째로 추가
extend() → 풀어서 추가

insert()

a = [1, 2, 3, 4, 5, 4]

a.insert(1, 8)

print(a)
# [1, 8, 2, 3, 4, 5, 4]

insert(위치, 값)은 원하는 위치에 값을 삽입한다.

insert(1, 8)
→ 1번 인덱스 위치에 8 삽입

3-7. 리스트 정렬과 뒤집기

sort()

a = [3, 2, 7, 5, 0]

a.sort()

print(a)
# [0, 2, 3, 5, 7]

sort()는 리스트를 오름차순으로 정렬한다.

a.sort(reverse=True)

print(a)
# [7, 5, 3, 2, 0]

reverse=True를 넣으면 내림차순 정렬이 된다.

주의할 점은 sort()는 원본 리스트 자체를 바꾼다는 것이다.

a = [3, 2, 7, 5, 0]

a.sort()

print(a)
# [0, 2, 3, 5, 7]

sorted()

원본을 바꾸지 않고 정렬 결과만 얻고 싶으면 sorted()를 사용한다.

a = [3, 2, 7, 5, 0]

result = sorted(a)

print(result)
# [0, 2, 3, 5, 7]

print(a)
# [3, 2, 7, 5, 0]

sort()   → 원본 변경
sorted() → 원본 유지, 새 리스트 반환

reverse()

b = [4, 2, 5, 7, 1]

b.reverse()

print(b)
# [1, 7, 5, 2, 4]

reverse()는 현재 순서를 반대로 뒤집는다.

정렬이 아니라 단순히 순서만 반대로 바꾸는 것이다.

sort(reverse=True) → 내림차순 정렬
reverse()          → 현재 순서 뒤집기

3-8. 리스트 조회 메서드

index()

a = [1, 2, 3, 4, 5, 4]

print(a.index(3))
# 2

index()는 해당 값이 있는 인덱스를 반환한다.

주의할 점은 찾는 값이 없으면 오류가 발생한다.

a.index(10)
# ValueError

count()

a = [1, 2, 3, 4, 5, 4]

print(a.count(4))
# 2

count()는 해당 값이 리스트 안에 몇 개 있는지 반환한다.

3-9. 리스트 메서드의 원본 변경 여부

리스트 메서드 중 대부분은 원본 리스트에 영향을 준다.

append()  → 원본 변경
extend()  → 원본 변경
insert()  → 원본 변경
remove()  → 원본 변경
pop()     → 원본 변경
sort()    → 원본 변경
reverse() → 원본 변경
clear()   → 원본 변경

반대로 조회만 하는 메서드는 원본이 바뀌지 않는다.

index() → 원본 변경 없음
count() → 원본 변경 없음

원본을 바꾸지 않고 새 리스트를 만드는 대표적인 경우는 다음과 같다.

sorted(a)  # 정렬된 새 리스트 반환
a + b      # 연결된 새 리스트 반환
a * 2      # 반복된 새 리스트 반환
a[:]       # 복사본 반환

4) 튜플 tuple

튜플은 리스트와 비슷하게 여러 값을 저장할 수 있지만, 한 번 만들면 수정할 수 없는 자료형이다.

t1 = (1, 2, 3, 4, 5)

4-1. 튜플 특징

- 여러 값을 하나로 묶어서 저장
- 순서가 있음
- 인덱스로 접근 가능
- 값 변경 불가능
- 값 삭제 불가능
- 값 추가 불가능

리스트와 가장 큰 차이는 수정 가능 여부이다.

리스트 [] → 수정 가능
튜플 ()   → 수정 불가능

4-2. 튜플 선언 방법

t1 = ()
t2 = (1,)
t3 = (1, 2, 3)
t4 = 1, 2, 3
t5 = ('a', 'b', ('ab', 'cd'))

빈 튜플은 다음과 같이 만든다.

t1 = ()

값이 하나인 튜플은 반드시 콤마를 붙여야 한다.

t2 = (1,)

주의할 점은 다음과 같다.

t = (1)
print(type(t))
# <class 'int'>

(1)은 튜플이 아니라 정수이다.

t = (1,)
print(type(t))
# <class 'tuple'>

값이 하나인 튜플은 (1,)처럼 콤마가 있어야 한다.

4-3. 괄호 없이도 튜플 가능

t = 1, 2, 3

print(t)
# (1, 2, 3)

튜플은 괄호 없이도 만들 수 있다.

하지만 가독성을 위해 보통 괄호를 사용하는 것이 좋다.

4-4. 튜플 안에 튜플

튜플 안에는 튜플을 넣을 수 있다.

t = ('a', 'b', ('ab', 'cd'))

print(t[2])
# ('ab', 'cd')

print(t[2][0])
# ab

리스트 안에 리스트를 넣을 수 있듯이, 튜플 안에도 튜플을 넣을 수 있다.

t[2]    → 세 번째 요소인 ('ab', 'cd') 꺼냄
t[2][0] → 세 번째 요소 안에서 첫 번째 값 'ab' 꺼냄

단, 안쪽 튜플도 튜플이기 때문에 수정할 수 없다.

4-5. 튜플은 수정/삭제 불가능

t1 = (1, 2, 3, 4, 5)

del t1[0]
# TypeError

튜플의 특정 요소는 삭제할 수 없다.

t1[0] = 8
# TypeError

튜플의 특정 요소를 바꿀 수도 없다.

5) 딕셔너리 dict

딕셔너리는 key : value 형태로 데이터를 저장하는 자료형이다.

dic = {
    'first': 'a',
    'second': 'b',
    'third': 'c',
    'forth': 'd',
    'fifth': 'e'
}

5-1. 딕셔너리 특징

- key와 value를 한 쌍으로 저장
- 인덱스가 아니라 key로 접근
- key는 중복 불가능
- value는 중복 가능
- key가 있으면 수정
- key가 없으면 추가

리스트와 튜플은 인덱스로 값을 찾지만, 딕셔너리는 key로 값을 찾는다.

print(dic['first'])
# a

5-2. 딕셔너리 값 조회

dic = {
    'first': 'a',
    'second': 'b'
}

print(dic['first'])
# a

dic['first']는 'first'라는 key에 해당하는 value를 가져온다.

주의할 점은 없는 key를 사용하면 오류가 발생한다.

print(dic['third'])
# KeyError

5-3. keys()

print(dic.keys())

keys()는 딕셔너리의 key만 가져온다.

dict_keys(['first', 'second'])

5-4. values()

print(dic.values())

values()는 딕셔너리의 value만 가져온다.

dict_values(['a', 'b'])

5-5. items()

print(dic.items())

items()는 key와 value를 쌍으로 가져온다.

dict_items([('first', 'a'), ('second', 'b')])

5-6. 딕셔너리 값 변경

기존에 있는 key에 값을 넣으면 value가 변경된다.

dic = {
    'first': 'a',
    'second': 'b'
}

dic['first'] = 'aaaa'

print(dic)
# {'first': 'aaaa', 'second': 'b'}

기존 key에 대입 → value 변경

5-7. 딕셔너리 값 추가

없는 key에 값을 넣으면 새로운 key-value가 추가된다.

dic = {
    'first': 'a',
    'second': 'b'
}

dic['sixth'] = 'f'

print(dic)
# {'first': 'a', 'second': 'b', 'sixth': 'f'}

없는 key에 대입 → 새 데이터 추가

4. 파이썬 문법 정리: if문, while문, for문, 함수, 클래스

1. if문

if문은 조건에 따라 실행할 코드를 나누는 문법이다.

fun = True

if fun:
    print("Good!")
else:
    print("Bad!")

실행 결과:

Good!

fun이 True이면 if 아래 코드가 실행되고, False이면 else 아래 코드가 실행된다.

1-1. 비교 연산자

x < y   : x가 y보다 작다
x > y   : x가 y보다 크다
x == y  : x와 y가 같다
x != y  : x와 y가 같지 않다
x >= y  : x가 y보다 크거나 같다
x <= y  : x가 y보다 작거나 같다

주의할 점은 =와 ==의 차이이다.

x = 10     # 대입
x == 10    # 비교

1-2. if / elif / else

x = 2
y = 20

if x < y:
    print(f"{x}보다 {y}가 크다")
elif x == y:
    print(f"{x}와 {y}가 같다")
else:
    print(f"{x}가 {y}보다 크다")

실행 결과:

2보다 20가 크다

정리:

if    : 첫 번째 조건
elif  : 그 외 다른 조건
else  : 위 조건들이 모두 아닐 때

1-3. 문제: Money 조건문

문제 조건:

Money 초기화: 3000, 8000

Money가 5000 이하이면 print("버스")
Money가 5000 이상이면 print("택시")

코드:

money = 3000

if money <= 5000:
    print("버스")
else:
    print("택시")


money = 8000

if money <= 5000:
    print("버스")
else:
    print("택시")

실행 결과:

버스
택시

2. while문

while문은 조건이 참인 동안 반복하는 문법이다.

x = 1

while x < 5:
    print(x)
    x = x + 1

실행 결과:

흐름:

x = 1 → 출력 → x = 2
x = 2 → 출력 → x = 3
x = 3 → 출력 → x = 4
x = 4 → 출력 → x = 5
x = 5 → 조건 x < 5가 False라 종료

주의할 점은 반복문 안에서 조건을 바꾸는 코드가 있어야 한다.

x = x + 1

이 코드가 없으면 무한 반복될 수 있다.

2-1. while문에서 if문 사용

x = 1

while x < 7:
    if x % 2 == 0:
        print(str(x) + " 짝수입니다.")
    else:
        print(str(x) + " 홀수입니다.")

    x = x + 1

실행 결과:

1 홀수입니다.
2 짝수입니다.
3 홀수입니다.
4 짝수입니다.
5 홀수입니다.
6 짝수입니다.

x % 2 == 0은 x를 2로 나눈 나머지가 0이면 짝수라는 의미이다.

2-2. break

break는 반복문을 즉시 종료한다.

x = 1

while x < 10:
    print(x)

    if x == 3:
        break

    x = x + 1

실행 결과:

1
2
3

x가 3이 되는 순간 break를 만나서 반복문이 끝난다.

3. for문

for문은 리스트, 문자열, range 같은 값을 하나씩 꺼내면서 반복한다.

3-1. 리스트 반복

myList = ['a', 'b', 'c', 'd', 'e']

for li in myList:
    print(li)

실행 결과:

a
b
c
d
e

3-2. 튜플 언패킹 반복

a = [(1, 2), (3, 4), (5, 6)]

for first, second in a:
    print(first + second)

실행 결과:

3
7
11

흐름:

1회차: first = 1, second = 2 → 3
2회차: first = 3, second = 4 → 7
3회차: first = 5, second = 6 → 11

이런 식으로 튜플 안의 값을 변수 여러 개로 나눠 받는 것을 언패킹이라고 한다.

주의:

a = [(1, 2), (3, 4, 5)]

for first, second in a:
    print(first + second)

이건 오류가 난다.
first, second는 값 2개를 받아야 하는데 (3, 4, 5)는 값이 3개이기 때문이다.

3-3. range()

for i in range(10):
    print(i)

실행 결과:

range(10)은 0부터 10 미만까지이다.

for i in range(1, 10):
    print(i)

실행 결과:

range(1, 10)은 1부터 10 미만까지이다.

for i in range(1, 10, 2):
    print(i)

실행 결과:

range(1, 10, 2)는 1부터 10 미만까지 2씩 증가이다.

정리:

range(끝)           → 0부터 끝 미만
range(시작, 끝)      → 시작부터 끝 미만
range(시작, 끝, 간격) → 시작부터 끝 미만까지 간격만큼 증가

3-4. 인덱스로 리스트 반복

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

for i in range(len(a)):
    print(a[i])

실행 결과:

a
b
c
d
e

len(a)는 리스트 길이를 의미한다.

len(a)
# 5

그래서 range(len(a))는 range(5)와 같고, 인덱스 0~4까지 반복한다.

3-5. continue

continue는 현재 반복을 건너뛰고 다음 반복으로 넘어간다.

myList = [1, 2, 3, 4, 5]

for li in myList:
    if li == 3:
        continue

    print(li)

실행 결과:

li가 3이면 continue를 만나서 print(li)를 실행하지 않고 다음 반복으로 넘어간다.

3-6. 문제: 구구단 2단~9단, 3단 제외

문제 조건:

1. 구구단을 만드시오. 2단 ~ 9단
2. 3단은 제외하시오.

코드:

for i in range(2, 10):

    if i == 3:
        continue

    for j in range(1, 10):
        print(f"{i} X {j} = {i * j}")

핵심:

range(2, 10) → 2부터 9까지
range(1, 10) → 1부터 9까지
i == 3이면 continue로 3단 건너뜀

파이썬 주석은 //가 아니라 #이다.

# 파이썬 주석

4. 함수

함수는 자주 사용하는 코드를 하나로 묶어놓은 것이다.

4-1. return 있는 함수

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

print(add(2, 3))

실행 결과:

정리:

def add(a, b):  → 함수 정의
a, b            → parameter, 매개변수
return result   → 결과값 반환
add(2, 3)       → argument, 인자

4-2. return 없는 함수

def minus(a, b):
    print(f"{a} - {b} = {a - b}")

minus(5, 2)

실행 결과:

5 - 2 = 3

return이 없으면 값을 돌려주는 것이 아니라 함수 안에서 바로 출력한다.

4-3. input()

number = input("숫자를 입력하세요: ")
print(number)

실행 예시:

숫자를 입력하세요: 100
100

input()으로 입력받은 값은 기본적으로 문자열이다.

4-4. split()으로 여러 값 입력

a, b = input("두 수를 입력하세요: ").split()

print(a, b)

실행 예시:

두 수를 입력하세요: 3 7
3 7

split()은 공백을 기준으로 값을 나누고, a, b에 각각 저장한다.

숫자 계산을 하려면 형변환이 필요하다.

a, b = input("두 수를 입력하세요: ").split()

a = int(a)
b = int(b)

print(a + b)

4-5. 문제: add, minus, mul, div 함수 만들기

문제 조건:

1. add 함수를 참고하여 minus, mul, div 함수를 만드시오.
2. 사용자 입력을 통해 4개 함수가 동시에 실행되도록 하시오.

코드:

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

def minus(a, b):
    return a - b

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

def div(a, b):
    return a / b


a, b = input("두 수를 입력하세요: ").split()

a = int(a)
b = int(b)

print(f"{a} + {b} = {add(a, b)}")
print(f"{a} - {b} = {minus(a, b)}")
print(f"{a} * {b} = {mul(a, b)}")
print(f"{a} / {b} = {div(a, b)}")

실행 예시:

두 수를 입력하세요: 10 5
10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
10 / 5 = 2.0

주의:

/ 연산 결과는 항상 float
따라서 10 / 5 결과는 2가 아니라 2.0

5. 클래스

클래스는 변수와 함수를 하나로 묶어 객체를 만드는 문법이다.

5-1. 기본 클래스

class calculator:
    def setData(self, a, b):
        self.a = a
        self.b = b

    def add(self):
        return self.a + self.b


cal1 = calculator()
cal2 = calculator()

cal1.setData(3, 5)
cal2.setData(4, 7)

print(cal1.add())
print(cal2.add())

실행 결과:

8
11

핵심:

class calculator:
→ calculator라는 클래스 정의

cal1 = calculator()
→ calculator 클래스로 객체 생성

self.a = a
self.b = b
→ 객체 안에 값 저장

cal1.setData(3, 5)
→ cal1 객체의 a, b 값 설정

cal1.add()
→ cal1 객체에 저장된 a, b를 더함

5-2. self

self는 현재 객체 자신을 의미한다.

self.a = a
self.b = b

이렇게 저장하면 객체마다 다른 값을 가질 수 있다.

cal1.setData(3, 5)
cal2.setData(4, 7)

이 경우:

cal1.a = 3, cal1.b = 5
cal2.a = 4, cal2.b = 7

그래서 결과가 다르게 나온다.

5-3. 초기화 오류

class calculator:
    def add(self):
        return self.a + self.b

cal1 = calculator()

print(cal1.add())

이 코드는 오류가 난다.

이유:

self.a와 self.b가 만들어지기 전에 add()를 실행했기 때문

즉, setData()를 먼저 실행하지 않으면 a, b가 없어서 오류가 발생한다.

5-4. 생성자 init

생성자는 객체가 만들어질 때 자동으로 실행되는 함수이다.

class calculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def add(self):
        return self.a + self.b


cal1 = calculator(3, 4)

print(cal1.add())

실행 결과:

calculator(3, 4)를 실행하는 순간 __init__()이 자동 실행되어 self.a, self.b가 초기화된다.

정리:

setData() 방식
→ 객체 생성 후 직접 값을 넣어야 함

__init__() 생성자 방식
→ 객체 생성과 동시에 값 초기화

6. 상속

상속은 기존 클래스의 기능을 물려받아 새 클래스를 만드는 것이다.

class calculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def add(self):
        return self.a + self.b


class addition(calculator):
    def pow(self):
        return self.a ** self.b


ad = addition(3, 2)

print(ad.add())
print(ad.pow())

실행 결과:

5
9

핵심:

class addition(calculator):
→ addition 클래스가 calculator 클래스를 상속받음

addition은 calculator의 add()를 사용할 수 있음
addition에서 pow() 기능을 추가할 수 있음

7. 오버라이딩

오버라이딩은 부모 클래스의 메서드를 자식 클래스에서 다시 정의하는 것이다.

class calculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def add(self):
        return self.a + self.b


class addition(calculator):
    def pow(self):
        return self.a ** self.b

    def add(self):
        return self.a + 200


ad = addition(3, 2)

print(ad.add())
print(ad.pow())

실행 결과:

203
9

부모 클래스에도 add()가 있지만, 자식 클래스에서 add()를 다시 정의했기 때문에 자식 클래스의 add()가 실행된다.

정리:

상속
→ 부모 클래스 기능을 물려받음

오버라이딩
→ 부모 클래스의 메서드를 자식 클래스에서 다시 정의함

자식 클래스에 같은 이름의 메서드가 있으면
→ 자식 클래스 메서드가 우선 실행됨

5. 모듈

1) 모듈 전체 가져오기

import 모듈

import 모듈1, 모듈2

import 모듈 as 이름

예시:

import pandas as pd

별명으로 사용

2) 모듈 안에서 일부만 가져오기

from 모듈 import 변수

from 모듈 import 함수

from 모듈 import 클래스

from 모듈 import *

*는 전체를 의미함.

* 연습문제: 로또생성기

import random

a = [0] * 6

for i in range(len(a)):
    while True:
        num = random.randint(1, 45)

        if num not in a[:i]:
            a[i] = num
            break

for n in a:
    print(n)

'보안' 카테고리의 다른 글

정보보안 14주차 - 보안 솔루션 (0)	2026.06.11
정보보안 13주차 - 악성코드와 소프트웨어 보안 (0)	2026.06.10
정보보안 12주차 - 암호 (0)	2026.06.03
정보보안 10,11 주차 - 소켓 프로그래밍 (0)	2026.06.01

정보보안 9주차 - 파이썬 기초

1. 파이썬

1) 개요

2) 파이썬 활용

3) 활용 사례

2. 파이썬 기초

1) 숫자형

2) 문자열

2-1) 슬라이싱

2-2) 문자열 출력 형식

.format() 방식

문자열 보간

2-3) 문자열 관련 함수

upper(), lower()

2-4) 공백 제거

2-5) replace()

2-6) split()

3) 리스트 list

3-1. 리스트 특징

3-2. 리스트 안에 리스트

3-3. 리스트 연산

+ : 리스트 연결

* : 리스트 반복

3-4. 리스트 값 변경

3-5. 리스트 값 삭제

del

remove()

pop()

3-6. 리스트 값 추가

append()

extend()

insert()

3-7. 리스트 정렬과 뒤집기

sort()

sorted()

reverse()

3-8. 리스트 조회 메서드

index()

count()

3-9. 리스트 메서드의 원본 변경 여부

4) 튜플 tuple

4-1. 튜플 특징

4-2. 튜플 선언 방법

4-3. 괄호 없이도 튜플 가능

4-4. 튜플 안에 튜플

4-5. 튜플은 수정/삭제 불가능

5) 딕셔너리 dict

5-1. 딕셔너리 특징

5-2. 딕셔너리 값 조회

5-3. keys()

5-4. values()

5-5. items()

5-6. 딕셔너리 값 변경

5-7. 딕셔너리 값 추가

4. 파이썬 문법 정리: if문, while문, for문, 함수, 클래스

1. if문

1-1. 비교 연산자

1-2. if / elif / else

1-3. 문제: Money 조건문

2. while문

2-1. while문에서 if문 사용

2-2. break

3. for문

3-1. 리스트 반복

3-2. 튜플 언패킹 반복

3-3. range()

3-4. 인덱스로 리스트 반복

3-5. continue

3-6. 문제: 구구단 2단~9단, 3단 제외

4. 함수

4-1. return 있는 함수

4-2. return 없는 함수

4-3. input()

4-4. split()으로 여러 값 입력

4-5. 문제: add, minus, mul, div 함수 만들기

5. 클래스

5-1. 기본 클래스

5-2. self

5-3. 초기화 오류

5-4. 생성자 __init__

5-4. 생성자 init