파이썬 기초강의 서강대 ocw - sogang - ac - kr

기초 PYTHON 프로그래밍
1. 시작하기
1. 소프트웨어 교육
2. 수업 목표
3. 파이썬 언어 소개
4. 파이썬 설치
5. hello world 출력
 소프트웨어 교육이 점점 중요해지는 이유는?

 미래 사회가 요구하는 역량
 미래 사회에서의 직업의 변화
 소프트웨어 교육이란?
 컴퓨팅의 기본적인 개념과 원리를 이해하고 그것을 바탕으로 문제
해결 능력을 키워주는 교육
 컴퓨팅 사고력 (Computational Thinking)
2
 소프트웨어 교육의 구성
 문제 해결 능력 함양 (컴퓨팅 사고력)
 프로그래밍 언어에 대한 학습
 프로그래밍 (코딩)
 프로그램 - 컴퓨터가 특정 작업을 수행할 수 있도록 일련의
순서대로 작성한 명령어의 집합
3
2. 수업 목표
 파이썬 언어의 문법을 익힌다.
 파이썬 언어를 이용하여 프로그래밍을 작성할 수 있도록 한다.
 프로그래밍 과정을 통해 기초적인 문제 해결 능력을 키운다.
4
3. 파이썬(Python) 언어
 1991년, 귀도 반 로썸(Guido Van Rossum) 발표
 파이썬 언어를 사용하는 이유

 Simplicity (단순함)
 Efficiency (효율성)
 Easy (배우기 쉬움)
 Readability (가독성)
 Extensibility (확장성)
 파이썬 언어 버전
 버전 2 : 2020년까지 지원 예정
 버전 3 : 새로운 버전 (버전 2와 완벽하게 호환되지 않음)
5
4. 파이썬 설치
6
4. 파이썬 설치
7
4. 파이썬 설치
prompt
python shell
(interpreter)
프롬프트에서 명령을 치면 인터프리터가 명

령을 해석하여 그에 맞는 결과를 보여준다.
8
 print 내장 함수
 print() 함수는 괄호의 내용을 출력한다.
 홑따옴표('…') 또는 쌍따옴표("…")를 이용하여 원하는 문자열을
출력할 수 있다.
 홑따옴표 세 개('''…''') 또는 쌍따옴표 세 개("""... """)를 사용할 수
도 있다.
print('hello world')
print("hello world")
print('''hello world''')
print("""hello world""")
9
 파일에 저장하여 실행하기
① IDLE 메뉴에서 File 선택

② New File 선택
10
③ 새로운 화면에서 코드 작성
④ File 메뉴에서 Save 선택
⑤ 파이썬 파일은 .py가 확장자임
11
⑥ 저장한 코드 실행하기
‘Run’ 메뉴 → ‘Run Module’
⑦ Shell에 결과 출력됨
12
2. 객체, 변수, 자료형
1. 객체(object)와 변수(variable)
2. 객체 삭제하기
3. 자료형 (9가지)
4. 주석 (comment)
 데이터 영역과 객체(object)
중앙처리장치
(CPU) 모니터, 프린터
입력 장치 출력 장치
키보드, 마우스 데이터 코드

영역 영역
주기억장치 보조기억장치
(memory) (하드디스크)
2
CPU : Central Processing Unit
 객체(object)
 메모리에 저장된 자료를 ‘객체’라고 부른다.
 모든 객체는 자료형(data types)을 갖는다.
 모든 객체는 고유 id를 갖는다.
 객체를 저장한 공간을 변수(variable)라고 하고 변수명(variable

name)으로 객체에 접근할 수 있다.
 객체 생성하기 객체
a = 100 a 100 변수
변수명
3
 객체와 변수 예
>>> x = 100 1571577664 >>> type(x)
>>> y = 200 x 100 <class 'int'>
>>> z = x + y 1571579264 >>> type(y)
>>> print(x,y,z) y 200 <class 'int'>
100 200 300 >>> type(z)
61314544
>>> id(x) <class 'int'>
z 300
1571577664
>>> id(y)
= assignment (할당연산자)
1571579264
오른쪽의 값을 왼쪽 변수에 넣어라.
>>> id(z) = 의 왼쪽에는 변수가 와야 한다.
4
61314544
 변수명 만들기
 변수명은 영어 소문자, 대문자, 숫자, _ (underscore)로만 구성한다.
 변수명은 숫자로 시작할 수 없다.
 대소문자를 구분한다. 즉, data와 Data는 다른 변수이다.
 변수명은 한글도 가능하다.
 키워드(keyword)를 변수명으로 사용하면 안 된다.
< 파이썬 키워드 (33개) >

False and class elif for import nonlocal raise with
None as continue else from in not return yield
True assert def except global is or try
break del finally if lambda pass while
5
 변수명 예
>>> number = 5
>>> score = 90
>>> python_score = 95
>>> _score = 100
>>> math-score = 90 # syntax 에러. 특수 기호는 _ 만 가능하다
>>> math1 = 80
>>> 1math = 80 # syntax 에러. 숫자로 시작할 수 없다
>>> 학생수 = 50 # 한글 변수명도 가능함

6
2. 객체 삭제하기
 del 을 이용하면 객체를 삭제할 수 있다.
>>> data = 100

>>> print(data)
100
>>> del data
>>> print(data)
Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
print(data)
NameError: name 'data' is not defined
7
3. 자료형
 파이썬 자료형 (data types)

 수치 자료형 - int (정수), float (실수), complex (복소수)
 부울 자료형 – bool (True / False)
 군집으로 다루는 자료형
- str (문자열)
- list (리스트)
- tuple (튜플)
- set (집합)
- dict (사전)
8
3.1. 수치 자료형 – 정수형
 정수형 (int)
 정수형 자료는 10진수, 2진수, 8진수, 16진수가 있다.
>>> score = 23
>>> print(score) 1525430384
23 score 23
>>> type(score)
<class 'int'>
type(변수명) : 변수의 자료형을 알려준다.
>>> id(score)
id(변수명) : 변수의 식별자를 알려준다.
1525430384
9
3.1 수치 자료형 - 실수형
 실수형 (float)
 소수점을 포함하는 수이다.
>>> data = 1.5

>>> print(data) 51659472
1.5 data 1.5
>>> type(data)
<class 'float'>
>>> id(data)
51659472
10
3.1 수치 자료형 - 복소수
 복소수형 (complex)
 복소수형은 실수부와 허수부로 표현한다. 허수부 뒤에는 j 또는 J를
붙인다.
>>> x = 3 + 5j
>>> print(x)
54137944
(3+5j) x 3+5j
>>> type(x)
<class 'complex'>
>>> id(x)
54137944 11
3.2 부울형
 부울형 (bool)
 파이썬의 부울형은 참 / 거짓을 나타내는 True / False 의 두
값만을 갖는다.
>>> a = True >>> x = 1

>>> b = False >>> y = x > 0
>>> type(a) >>> print(y)
<class 'bool'> True
>>> type(b) >>> type(y)
<class 'bool'> <class 'bool'>
12
3.3 문자열
 문자열 (str)
 따옴표를 이용하여 표현한다.
>>> name = 'Alice' # 홑따옴표

>>> print(name)
Alice
59750720
>>> type(name)
name A l i c e
<class 'str'>
>>> id(name)
59750720
13
3.3 문자열
 문자열 (str)
>>> city = "Seoul, Korea" # 쌍따옴표
>>> print(city)
Seoul, Korea
>>> language = '''python''' # 홑따옴표 세 개

>>> print(language)
Python
>>> w = """Python is widely used""" # 쌍따옴표 세 개

>>> print(w)
Python is widely used 14
3.4 군집 자료형 - 리스트
 리스트 (list) – 대괄호 [] 로 표현한다.

 여러 개의 자료들을 모아서 저장해야 하는 경우에 사용한다.
>>> scores = [80, 90, 85, 93, 78]

>>> print(scores)
[80, 90, 85, 93, 78] 57012752
>>> type(scores) scores 80 90 85 93 78
<class 'list'>
>>> id(scores)
57012752
15
3.4 군집 자료형 - 튜플
 튜플 (tuple) – 괄호 ( ) 로 표현한다.
 리스트처럼 여러 개의 자료를 저장할 수 있다.
>>> data = (3,6,5,9)

>>> print(data)
(3, 6, 5, 9) 58257504
>>> type(data) data 3 6 5 9
<class 'tuple'>
>>> id(data)
58257504
16
3.4 군집 자료형 - 집합
 집합 (set) – { } 로 표현한다.
 중복되지 않는 여러 개의 자료들을 모아서 저장해야 하는 경우에
집합을 사용한다.
>>> primes = {7,17,3,5,7,19}

>>> print(primes)
57212120
{17, 19, 3, 5, 7}
17 5
primes 3
>>> type(primes) 7
19
<class 'set'>
>>> id(primes)
57212120
17
3.4 군집 자료형 - 사전
 사전 (dict)
 키(key)와 값(value)의 쌍으로 구성되는 집합의 일종이다.
 예) 1반 35명, 2반 32명, 3반 30명, 4반 33명의 학생들이 있다면

사전을 이용하여 다음과 같이 표현할 수 있다.
>>> count = {1:35, 2:32, 3:30, 4:33}
>>> print(count)
{1: 35, 2: 32, 3: 30, 4: 33} 52998272
>>> type(count) 1:35 4:33
count
<class 'dict'> 3:30
2:32
>>> id(count)
52998272 18
4. 주석 (comment)
 프로그램에 설명을 넣을 때 주석을 사용함
 한 줄 주석 - # 기호를 사용함
# 숙제 1번
print('python programming')
print('what is your name?') # 이름 물어보기

print('how old are you?') # 나이 물어보기
19
4. 주석 (comment)
 여러 줄 주석 – 홑따옴표 세 개 또는 쌍따옴표 세 개를 사용함
""" 프로젝트 1.
작성자 : 홍길동
완성일 : 2016. 07. 31
프로젝트 버전 : 0.01
이 프로젝트는 파이썬 버전 3을 이용하였음 """
print('start of the program')
# 주요 코드 시작 부분
print('......')
""" …… """ – 쌍따옴표 3개로 작성한 부분을 docstring 이라고 한다.

docstring은 함수, 클래스, 모듈 등을 작성할 때 유용하다.
20
3. 수치 자료형과 연산자
1. 정수 자료형과 연산
2. 실수 자료형과 연산
3. 복소수 자료형과 연산
4. 자료형 변환
5. 수치 연산 함수들
6. math 모듈
 정수 (int) 표현하기
>>> x = 100
>>> x = 100 ; y = 200
>>> y = 200
>>> print(x, y)
100 200 491051008
>>> id(x) x 100

491051008
491052608
>>> id(y) y 200
491052608
2
 정수 객체는 immutable 하다.

immutable : 객체를 수정할 수 없음
>>> a = 10 C 언어에서는…
>>> id(a) 4297546848
a = 10;
a X 10 a = 20;
4297546848
>>> a = 20 a 10 20
4297547168
>>> id(a) 20
mutable
4297547168 (수정가능함)
3
 정수 자료형은 크기 제한이 없다.
>>> 2 ** 1024 # 2의 1024제곱

17976931348623159077293051907890247336179769789423
06572734300811577326758055009631327084773224075360
21120113879871393357658789768814416622492847430639
47412437776789342486548527630221960124609411945308
29520850057688381506823424628814739131105408272371
63350510684586298239947245938479716304835356329624
224137216
4
 산술 연산자
연산자 의미 예 결과
항1 연산자 항2
+ 더하기 10 + 5 15
- 빼기 20 – 13 7
* 곱하기 3 * 10 30
피연산자
/ 나누기 100 / 8 12.5
** 지수계산 2 ** 5 32 4 // 결과
// 몫 30 // 7 4 7 30
% 나머지 30 % 7 2 28
2 % 결과
5
 산술 연산자 우선순위
연산자 설명 결합 순서
** 지수 ←
* / % // 곱하기, 나누기, 나머지, 몫 →
+- 더하기, 빼기 →
>>> 2 + 3 * 5
17
>>> 2 ** 3 ** 2 # 2 ** 9
512
>>> (2 ** 3) ** 2 # 8 ** 2
64
>>> 2 ** 3 * 4
32
>>> 4 * 3 ** 2
36 6
 할당 연산자와 산술 연산자 예제
>>> a = 10
>>> b = 20
>>> c = a + b # a와 b를 더하여 c에 저장하시오
>>> a = a + 50 # a의 값을 50 증가하시오
>>> b = b + a # b의 값을 a 만큼 증가하시오
>>> print(a, b, c)
60 80 30
7
 산술 연산자 간략히 쓰기
a=a+b a += b >>> a = 10 ; b = 5 ; c = 22 ; d = 3
a=a-b a -= b >>> a += c # a가 32가 됨
a=a*b a *= b >>> b -= d # b가 2가 됨
a=a/b a /= b >>> a //= 3 # a가 10이됨
a = a ** b a **= b >>> c %= 5 # c가 2가 됨
a = a // b a //= b >>> a = 3; b = 2; c = 5; d = 10
a=a%b a %= b >>> d += b + c - a ** b # d가 8이 됨
8
 실수 (float) 표현하기
 소수점으로 표현하기
>>> a = 10.5
>>> b = 11.
>>> c = .5
>>> print(a,b,c)
10.5 11.0 0.5
 과학적 표기 방법 (scientific notation)

>>> 2.5e5 # 2.5 * 105
250000.0
>>> 3.25E-4 # 3.25 * 10-4
0.000325
9
 실수의 특징
 실수 객체도 immutable하다.
 실수는 저장할 때 약간의 문제를 일으킬 수도 있다.
>>> x = 1.5 >>> 0.1 + 0.1

0.2
>>> id(x) >>> 2 * 0.2
57809984 0.4
>>> x = 2.0 >>> 0.2 + 0.1

>>> id(x) 0.30000000000000004
>>> 3 * 0.1
61313536 0.30000000000000004
10
 실수의 연산
 정수 자료형에서 사용하는 연산자를 모두 사용할 수 있다.
 정수와 실수 자료형을 같이 연산하면 결과는 실수가 된다.

>>> 2.3 + 3.7
>>> a = 10 # 정수
6.0
>>> 5.5 - 1.2 >>> b = 20.0 # 실수
4.3
>>> 1.5 * 2.1 >>> c = a + b
3.1500000000000004
>>> print(a, b, c)
>>> 20.2 / 10.1
2.0 10 20.0 30.0
>>> 1.5 ** 3.2
3.660092227792233 >>> type(c)
>>> 20.5 // 3.1
<class 'float'>
6.0
>>> 20.5 % 3.1 11
1.8999999999999995
 복소수 표현하기 (허수부에 j 또는 J를 붙인다)
>>> x = 2 + 5j
>>> y = 3.2 + 2.5J
>>> z = x + y
>>> print(z)
(5.2+7.5j)
>>> type(z)
<class 'complex'>
12
 복소수 연산하기
>>> x = 5 + 10j
>>> x.real # 실수부를 알려준다
5.0
>>> x.imag # 허수부를 알려준다
10.0
>>> x.conjugate() # 켤레복소수 반환한다
(5-10j)
13
4. 자료형 변환
 실수, 문자 → 정수로 변환하기 : int() 내장함수

>>> a = int(5.6) # 소수점 뒤를 무조건 버림
>>> b = int(-2.9)
>>> c = int('15') # 문자 '15'를 정수로 변환함
>>> print(a,b,c)
5 -2 15
>>> score = '85'
>>> score + 5 # TypeError 발생
>>> int(score) + 5
90
14
4. 자료형 변환
 정수, 문자 → 실수로 변환하기 : float() 내장함수

>>> x = float(3)
>>> y = float(100)
>>> z = float('15.7')
>>> print(x, y, z)
3.0 100.0 15.7
>>> type(x); type(y); type(z)
<class 'float'>
<class 'float'>
<class 'float'> 15
5. 수치 연산 함수들
 수치 연산 관련 내장함수
함수 설명
abs(x) x의 절대값을 반환한다
divmod(x,y) (x//y, x%y) 쌍을 반환한다
pow(x,y) xy을 반환한다
>>> abs(-3)
3
>>> divmod(17,4)
(4, 1)
>>> pow(2,5)
32
16
6. math 모듈
 모듈 – 연관된 함수들을 모아서 모듈로 관리한다

>>> import math
>>> math.fabs(-3)
3.0
>>> math.pow(2,5)
32.0
>>> math.sqrt(16)
4.0
>>> math.floor(4.5) # 4.5 이하의 정수 중에서 가장 큰 정수
4
>>> math.ceil(4.5) # 4.5 이상의 정수 중에서 가장 작은 정수
17
5
4. 문자열 자료형
1. 문자열 생성하기
2. 문자열 인덱싱 / 슬라이싱
3. 문자열 연결 / 반복
4. 문자열 길이 / 포함 관계
5. 문자열 메소드 사용하기
 문자열 객체는 따옴표를 이용하여 생성한다.

 홑따옴표(' … ')
 쌍따옴표(" … ")
 홑따옴표 세 개(''' … ''')
 쌍따옴표 세 개(""" … """)
>>> s = 'Python is great!'

>>> s = "Python is great!" >>> print(s)
>>> s = '''Python is great!''' Python is great!
>>> s = """Python is great!"""
2
 역슬래쉬(\)를 이용하여 긴 문자열 생성하기

 홑따옴표 또는 쌍따옴표 한 쌍을 사용할 때 역슬래쉬(\)는 문자열이
연결됨을 의미한다.
>>> sentence = 'Python is the \

most popular programming \
language in these days.'
>>> print(sentence)
Python is the most popular programming language in these
days.
3
 홑따옴표와 쌍따옴표를 같이 사용하기

 say 'hello' to mom.
>>> a = 'say 'hello' to mom' >>> s = 'say "hello" to mom'

SyntaxError: invalid syntax >>> s = '''say "hello" to mom'''
>>> s = """say "hello" to mom"""
>>> b = "say 'hello' to mom"
>>> print(s)
>>> c = '''say 'hello' to mom'''
say "hello" to mom
>>> d = """say 'hello' to mom"""
>>> print(d)
say 'hello' to mom
4
 홑따옴표 또는 쌍따옴표 세 개 사용하기
>>> s = '''say 'hello' to "mom"'''

>>> print(s)
say 'hello' to "mom"
>>> s = """say "hello" to 'mom'"""
>>> print(s)
say "hello" to 'mom'
5
 홑따옴표 또는 쌍따옴표 세 개 사용하기

# letter to Alice
print('''Dear Alice,
How are you?

I am busy to study programming this vacation.
Say hello to your parents.
Sincerely,
Bob''')
6
 문자열 객체의 특징
 immutable하다.
 순서가 있는 자료형으로 인덱싱을 이용할 수 있다.
>>> greeting = 'hello world'
인덱스 0 1 2 3 4 5 6 7 8 9 10
greeting h e l l o w o r l d
음수 인덱스 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
7
 문자열 인덱싱
>>> greeting = 'hello world'
인덱스 0 1 2 3 4 5 6 7 8 9 10
greeting h e l l o w o r l d
-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
>>> print(greeting[7])
o
>>> print(greeting[0])
h
>>> greeting[0] = 'H' # TypeError 발생
문자열 객체는 immutable하기 때문에 생성

된 후에 수정할 수 없다. 8
 문자열 슬라이싱 – 범위를 이용하여 문자열 일부분에 접근한다

>>> lang = 'python programming'
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
lang p y t h o n p r o g r a m m i n g
-18 -17 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
 lang[a] – 인덱스 a의 문자
 lang[a:b] – 인덱스 a부터 b-1까지의 문자열 (a < b)
 lang[a:b:c]
• a<b, c>0 - a부터 b-1까지 c 간격의 문자열
• a>b, c<0 - a부터 b+1까지 c 간격의 문자열
lang[:] – lang 문자열 전체

lang[::]– lang 문자열 전체
9
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
lang p y t h o n p r o g r a m m i n g
-18 -17 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
lang[3:10] # 'hon pro'

lang[:5] # 'pytho' (lang[0:5]와 같다)
lang[10:] # 'gramming' (10부터 끝까지)
lang[5:-8] # 'n pro' (양수, 음수 섞어서 사용 가능)
lang[10:5] # 빈 문자열
lang[-10:-13] # 빈 문자열
lang[2:10:3] # ' tnr'
lang[:10:3] # 'ph o' (lang[0:10:3]와 같다)
lang[10::2] # 'gamn' (10부터 끝까지 2칸씩)
lang[12:3:-2] # 'agr o' (12에서 4까지 2칸씩 앞으로)
10
 문자열 연결하기 (+)

a = 'hello' c=a+b
b = 'world' print(c)
d=a+''+b
print(d)
score = 95
x = 'I got ' + score + ' in the exam.' # 에러
x = 'I got ' + str(score) + ' in the exam.'

print(x)
11
 문자열 반복하기 (*)
>>> a = 'hello'
>>> a * 3 # 문자열을 3회 반복한다
'hellohellohello'
12
4. 문자열 길이 / 포함 관계
 문자열 길이 – len() 내장 함수
>>> subject = 'programming'

>>> len(subject)
11
 문자열 포함 - in, not in 연산자
>>> 'r' in subject
True
>>> 'gram' in subject
True
>>> 'abcd' not in subject
13
True
5. 문자열 메소드 이용하기
 문자열 객체에서 사용할 수 있는 메소드

 메소드는 객체에 어떤 일을 처리하도록 하는 코드이다.
 문자열.메소드() 형태로 사용한다.
>>> dir(str)
['__add__', '__class__', ……'__subclasshook__', 'capitalize', 'casefold',
'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format',
'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit',
'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle',
'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace',
'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines',
'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
14
메소드 설명
문자열을 모두 대문자로 바꾼다.
upper() >>> name = 'steve jobs'
>>> name.upper() # 'steve jobs'.upper()
'STEVE JOBS'
문자열을 모두 소문자로 바꾼다.
lower() >>> school = 'SOGANG University'
>>> school.lower()
'sogang university'
isupper() 메소드는 문자열이 모두 대문자이면 True를 반환한다.
islower() 메소드는 문자열이 모두 소문자이면 True를 반환한다.
isupper()
>>> a = 'hello'; b = 'WORLD'
islower() >>> a.islower()
True
>>> b.isupper()
True
15
메소드 설명
첫 문자를 대문자로 바꾼다.
capitalize() >>> y = 'steve jobs made toy story'

>>> y.capitalize()
'Steve jobs made toy story'
문자열에서 각 단어의 첫 문자들을 대문자로 바꾼다.
title() >>> y.title()
'Steve Jobs Made Toy Story'
>>> x = 'I Am Learning Programming.'
>>> x.istitle()
True
istitle()
>>> y = 'I am learning Programming.'
>>> y.istitle()
False
16
메소드 설명
부분 문자열을 센다.
>>> state = 'mississippi'
>>> state.count('s')
4
count() >>> state.count('ssi')
2
>>> state.count('s', 5) # [5:]으로 잘라서 count한 결과
2
>>> state.count('s', 1, 5) # [1:5] 범위
2
부분 문자열 찾아서 첫 인덱스 알려 준다.
>>> state.find('s')
find() 2
>>> state.find('i', 5) # [5:] 범위에서 'i'를 찾는다
7 17
메소드 설명
문자열.join(리스트) – 리스트에 있는 자료들을 문자열로
연결한다.
join(리스트) >>> friends = ['alice', 'bob', 'cindy']

>>> dash = '-'
>>> dash.join(friends) # '-'.join(friends)
'alice-bob-cindy'
문자열을 스페이스 기준으로 잘라서 리스트에 저장한다.
>>> lists = 'alice bob cindy david'
>>> lists.split() # 스페이스로 분리
split() ['alice', 'bob', 'cindy', 'david']
>>> date = '2016/12/25'
>>> date.split('/') # '/'로 분리
['2016', '12', '25']
18
5. 파이썬 입출력문
1. print() 함수
2. 특수 문자 출력
3. % 이용한 서식 출력
4. print() 함수와 end
5. input() 함수
1. print() 함수
 출력문 – print() 내장 함수
Python2 Python3 : print 함수로만 사용 가능

>>> print "hello" >>> print "hello"
hello SyntaxError: Missing parentheses ……
>>> print 'hello' >>> print 'hello'
hello SyntaxError: Missing parentheses ……
>>> print("hello") >>> print("hello")

hello hello
>>> print('hello') >>> print('hello')
hello hello
- Python2에서는 괄호를 써도 되고 안 써도 된다.

- Python3에서는 반드시 괄호를 써야 한다.
2
1. print() 함수
 출력문 – print() 내장 함수
 print() 함수는 괄호의 내용을 출력한다.
 출력하고자 하는 값이 여러 개인 경우에는 콤마로 구분할 수 있으며, 출력
할 때 각각의 값 사이에 공백 한 개가 추가된다.
 문자열을 출력하려면 홑따옴표('…') 또는 쌍따옴표("…")를 이용한다.
(홑따옴표 세 개('''… '''), 쌍따옴표 세 개("""... """) 사용 가능)
>>> x = 10; y = 5; z = 7
>>> print(x,y,z)
10 5 7
>>> print('x')
x
>>> print(x)
10
3
1. print() 함수
 변수에 저장된 값 출력하기
>>> a = 100 ; b = 200

>>> c = a + b
>>> print(a,b,c) # 콤마에 공백이 추가된다.
100 200 300
>>> print(a+b) # 수치 연산자는 계산 결과를 보여준다.
300
>>> print(a+50)
150
4
1. print() 함수
 문자열 출력하기
>>> print('hello world!')
hello world!
>>> print('hello', 'world!') # 콤마에 공백이 추가된다.
hello world!
>>> x = '5'
>>> print('hello' + 'world!')
>>> y = 5
helloworld!
>>> print(x)
>>> movie = 'toy story' 5
>>> print(y)
>>> print(movie) 5
toy story >>> x
'5'
>>> movie >>> y
'toy story' 5
5
1. print() 함수
 + 연산자
>>> print('hello' + 100) # 에러

>>> print('hello' + str(100))
hello100
>>> x = '10'
>>> n = 100
>>> n + x # 에러
>>> n + int(x)
110
6
 print() 함수 내에 사용하는 특수 문자
특수문자 설명 >>> print('hello \ # 다음 줄과 연결됨

\ 다음 줄과 연속임 world')
hello world
\' '
\" " >>> print('hello \'world\' !!')
\\ \ 문자 자체 hello 'world' !!
\n 개행문자(줄 바꿈)
\t 탭키 >>> print("hello \"world\" !!")
hello "world" !!
'\'는 키보드에서 \ 을
>>> print('hello "world"')
누르면 된다.
hello "world"
>>> print("hello 'world'")

hello 'world' 7
 print() 함수 내에 사용하는 특수 문자
>>> print('hello \\ world')

hello \ world
>>> print('hello \n world \n python \t programming')

hello
world
python programming
8
 출력문 – % 이용한 서식 출력 (문자열, 정수)

문자열 : %s
정수 : %d
실수 : %f
print(' '%( , ))
>>> name = 'Alice' ; score = 95

>>> print('%s got %d score' % (name, score))
Alice got 95 score
>>> print('%10s got %5d score' % (name, score))
Alice got 90 score
(10칸 잡아서 Alice 출력, 5칸 잡아서 90 출력) 9

 출력문 – % 이용한 서식 출력 (실수)

>>> math_score = 87.3
>>> print('You got %f in math' % (math_score))
데이터가 한 개인 경우에는
You got 87.300000 in math 괄호가 없어도 된다
%a.bf 소수점을 포함하여 a칸을 잡고 소수점 아래 b자리까지 출력
>>> math = 93.5 ; eng = 88.3

>>> print('Math is %5.2f and Eng is %6.3f' % (math, eng))
Math is 93.50 and Eng is 88.300
>>> print("score is %d and gpa is %10.2f" % (85, 3.7))
score is 85 and gpa is 3.70 %.2f – 소수점 둘째자리까지 출력
10
4. print() 함수와 end
 print() 함수는 항상 '\n'을 추가한다.
a = 'hello' a = 'hello\n'
b = 'world' b = 'world'
print(a) print(a)
print(b) print(b)
 print() 함수에 ‘\n’ 대신에 다른 문자를 출력하고자 한다면

end = '…' 를 추가한다.
print(a, end=' ')
print(b)
print(a, end='*****')
print(b)
print(a, end='\t')
print(b) 11
5. input() 함수
 입력문 – input() 내장 함수
데이터를 입력할 때 타입을 정확히 판단할 수 있는

input()
Python2 형태로 넣어야 함.
raw_input() 입력되는 데이터는 모두 문자열로 취급함.
Python2의 input() 함수는 없어지고

Python3 input() raw_input() 함수가 input()으로 바뀐 것. 즉, 입
력되는 데이터는 모두 문자열로 취급함.
12
5. input() 함수
 키보드로부터 입력을 받는다.
>>> x = input('Enter x : ')

Enter x : 10 ← 10이 변수 x 에 저장된다.
>>> print(x)
10
>>> x
'10'
>>> type(x) # 입력받은 데이터는 항상 문자열로 처리한다.
<class 'str'>
13
5. input() 함수
 필요하다면 입력 받은 데이터의 자료형을 적절히 변환해야 한다.
>>> x = input('정수를 입력하시오 : ')

정수를 입력하시오 : 15
>>> x + 10
x + 10
TypeError: Can't convert 'int' object to str implicitly
>>> int(x) + 10
25
14
5. input() 함수
 일반적으로 다음과 같이 이용한다.
>>> x = int(input('Enter one integer : '))
Enter one integer : 100
>>> type(x)
<class 'int'>
>>> y = float(input('Enter one float number : '))

Enter one float number : 3.14
>>> type(y)
<class 'float'>
15
6. 실습 1
문제 1.
 세 과목(국어, 수학, 영어) 성적을 input() 함수로 입력받아 세 과

목의 총점과 평균을 구하는 프로그램을 작성하시오. 평균은 소수점
둘째 자리까지 출력되도록 한다.
2
문제 1.
kor = int(input('국어 성적을 입력하세요 : '))
math = int(input('수학 성적을 입력하세요 : '))
eng = int(input('영어 성적을 입력하세요 : '))
print()
print('입력받은 성적')
print('-' * 15)
print('국어 성적 :', kor)

print('수학 성적 :', math)
print('영어 성적 :', eng)
print()
print('-' * 15)
print()
total = kor + math + eng

average = total / 3
print('총점 :', total)

print('평균 : %.2f' % (average)) 3
문제 2.
 input() 함수를 이용하여 원의 반지름을 입력받는다. 입력받은 반

지름으로 원의 넓이와 원의 둘레를 구하여 소수 셋째 자리까지 출
력하는 프로그램을 작성하시오. 원주율을 3.141592로 한다.
4
문제 2.
radius = int(input('반지름을 입력하시오 : '))

print('반지름 :', radius)
area = 3.141592 * radius * radius # area = 3.141592 * pow(radius,2)

perimeter = 2 * 3.141592 * radius
print('원의 넓이 : %7.3f' % area)
print('원의 둘레 : %.3f' % perimeter)
5
문제 3.
 다섯 자리 양의 정수를 입력받아서 다음과 같이 각 자리수를 떼어

서 출력하는 프로그램을 작성하시오. 항상 올바르게 다섯 자리 숫
자를 입력하고 1~9의 수만 입력한다고 가정한다.
6
문제 3.
n = int(input('다섯 자리 정수를 입력하시오 : '))

print()
n10000 = n // 10000
n = n % 10000
n1000 = n // 1000
n = n % 1000
n100 = n // 100
n = n % 100
n10 = n // 10
n1 = n % 10
print(n10000, ',' , n1000, ',' , n100, ',' , n10, ',' , n1)
print()
print('프로그램을 끝내려면 엔터를 누르세요.')
input() 7
7. 조건문
1. 불리언(Boolean) 표현식
2. 관계 연산자
3. 논리 연산자
4. if 조건문
5. 중첩된 if 조건문
1. 불리언(Boolean) 표현식
 True(참) 또는 False(거짓)의 값을 판단할 수 있는 문장
 불리언 표현식의 예
 3은 5보다 크다 → False
 x=10일 때, x%2 == 0 이다 → True
2
2. 관계 연산자
 관계 연산자 – 두 데이터 값을 비교하는 연산자
>>> x = 100
연산자 의미 >>> y = 200
> 크다 >>> x > y
>= 크거나 같다 False
< 작다 >>> x >= y
False
<= 작거나 같다
>>> x < y
== 같다 True
!= 같지 않다 >>> x <= y
True
>>> x == y
False
>>> x != y
True 3
3. 논리 연산자
 논리 연산자
 not, and, or 세 종류가 있다.
 True 또는 False 값을 피연산자로 취해서 논리값을 계산한다.
논리 연산자 설명
not x x가 False이면 True이고, True이면 False 이다.
x와 y가 모두 True이면, x and y는 True이다. 나머지 경우에

x and y
대해서는 x and y 는 False이다.
x와 y가 모두 False인 경우에만 False이다. 즉, x와 y 둘 중에

x or y
하나라도 True이면 x or y는 True이다.
4
3. 논리 연산자
 논리 연산자의 예
a = 10
b = 20
a > 5 and b > 10 # True a > 5 or b > 10 # True

a > 5 and b < 5 # False a > 5 or b < 5 # True
a < 5 and b > 10 # False a < 5 or b > 10 # True
a < 5 and b < 5 # False a < 5 or b < 5 # False
0<a<b # True not a < 5 # True
not b > 10 # False
5
4. if 조건문
 조건 논리
 특정 조건에 따라 명령을 선택적으로 수행해야 하는 경우
 ‘조건’에는 불리언 표현식이 와야 함. (참/거짓)

if 조건 :
T F 명령문
조건 …… if 블록(block)
명령문 명령문 명령문
… … else :
명령문 명령문 명령문
…… else 블록(block)
명령문
명령문
… 명령문
명령문
……
6
명령문
4. if 조건문
 조건 논리 유형 1
 조건이 참인 경우에만 어떤 특정 명령을 실행한다.
T F
조건 if 조건 :
명령문 명령문
… ……
명령문 명령문
명령문
명령문
……
… 명령문
명령문
7
4. if 조건문
 조건 논리 유형 1 예제
 성적(score)을 입력받는다.
 70점 이상이면 ‘축하합니다.’와 ‘수고하셨습니다’를 출력한다.
 70점 미만이면 ‘수고하셨습니다’ 만 출력한다.
score = int(input('성적을 입력하시오 : '))
if score >= 70 :
print('축하합니다')
print('수고하셨습니다')
8
4. if 조건문
 하나의 정수를 입력받는다.
 그 수가 짝수이면 ‘짝수입니다’와 ‘프로그램 종료’를 출력한다.
 그 수가 홀수이면 ‘홀수입니다’와 ‘프로그램 종료’를 출력한다.
number = int(input('정수를 입력하시오 : '))
if number%2 == 0 :
print(number, '는 짝수입니다.')
else :
print(number, '는 홀수입니다.')
print('프로그램 종료')
9
4. if 조건문
 조건 논리 유형 2 예제 – 두 수 중에서 큰 수 출력하기
a = int(input('Enter a : '))
b = int(input('Enter b : '))
if a > b :
max = a if a > b : max = a
else: else : max = b
max = b
조건문에 해당하는 블록이 한 줄인
print(max)
경우 콜론 옆에 작성하기도 한다.
10
4. if 조건문
 조건 논리 유형 3 if 조건1 :
A
T F
조건1 elif 조건2 :
B
T F
조건2 elif 조건3 :
T F C
조건3
…
elif 조건n :
……
A B C …
else :
명령문 …
…
명령문 명령문
11
4. if 조건문
 성적을 입력받는다.
 성적이 90점 이상이면 ‘당신의 학점은 A입니다’라고 출력한다.
 성적이 80점 이상이고 90점 미만이면 ‘당신의 학점은 B입니다’ 라고

출력한다.
 성적이 70점 이상이고 80점 미만이면 ‘당신의 학점은 C입니다’라고

출력한다.
 성적이 70점 미만이면 ‘당신의 학점은 D입니다’라고 출력한다.
12
4. if 조건문
if score >= 90 :
grade = 'A'
elif 80 <= score < 90 : # elif 80 <= score :
grade = 'B'
elif 70 <= score < 80 : # elif 70 <= score :
grade = 'C'
else:
grade = 'D'
print('당신의 학점은', grade, '입니다.')
13
 중첩된 if 조건문 형태
if 조건A :
명령어 A
if 조건1 :
명령어 1
elif 조건2 :
명령어 2
else :
명령어 3
elif 조건B :
명령어 B
else :
명령어 C
명령어 D 14
 중첩된 if 조건문 예제
 성적을 입력받는다.
 성적이 70점 이상이면 통과이다.
- ‘통과하셨습니다’를 출력한다.
- 90점 이상이면 ‘A장학금 대상자’를 출력한다.
- 80점 이상 90점 미만이면 ‘B장학금 대상자’를 출력한다.
 성적이 60점 이상 70점 미만이면 ‘조건부 통과’라고 출력한다.
 성적이 60점 미만이면 ‘재수강’이라고 출력한다.
 끝나기 전에 ‘수고하셨습니다’를 출력한다.

15
 중첩된 if 조건문 예제
if score >= 70 :
print('통과하셨습니다.')
if score >= 90 :
print('A장학금 지급 대상자입니다.')
elif score >= 80 :
print('B장학금 지급 대상자입니다.')
elif score >= 60 :
print('조건부 통과자입니다.')
else:
print('재수강 대상자입니다.')
print('수고하셨습니다.')
16
8. while 반복문
1. 반복 논리
2. 파이썬의 두 가지 반복문
3. while 반복문
4. 중첩된 while 반복문
1. 반복 논리
 반복 논리
 특정 명령 또는 연산을 반복적 F
조건
으로 수행해야 하는 경우 T
명령문 1
 반복을 제어할 조건문이 있어야
한다. 명령문 2
명령문 n
명령문 n+1
2
2. 파이썬의 두 가지 반복문
 while 반복문  for 반복문
while 조건식 : for x in 데이터 :

명령어 1 명령어 1
명령어 2 명령어 2
…… ……
명령어 n 명령어 n
3
3. while 반복문
 예제 1 : 1부터 5까지 출력하기
a=1
while a <= 5 :
print(a)
a += 1
4
3. while 반복문
 예제 2 : 1부터 10까지의 합
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = ?
a sum
a=1 1 0
2 1
sum = 0
3 3
while a <= 10 : 4 6
sum += a 5 10
6 15
a += 1
7 21
print('sum :', sum) 8 28
9 36
sum(range(11)) 10 45 5
55
3. while 반복문
 예제 3 : 1부터 10까지 짝수의 합 구하기

방법 1 : 2부터 시작하여 2씩 증가시켜 나가면서 합을 구한다.
방법 2 : 1부터 시작하여 1씩 증가시켜 나가면서 짝수인지 판단하여 짝수
이면 합을 구한다.
a=2 a=1
sum = 0 sum = 0
while a <= 10 : while a <= 10 :
sum += a if a % 2 == 0 :
a += 2 sum += a
print('sum :', sum) a += 1
print('sum :', sum) 6
4. while 반복문 제어하기
 while 구문에 break 사용하기

 break 는 반복문 안에서 사용하면 반복문을 끝내도록 한다.
a=1
a=1
while a <= 10 :
while a <= 10 :
……
…… print('a =', a)
if 조건 : if a >= 5 :
break break
……
a += 1
……
a += 1 print('after while')
……
…… 7
 무한루프와 break
a=1
while True :
print(a)
if a == 5 : break
a += 1
8
 while 반복문에 continue 사용하기

 continue 는 반복문의 조건으로 제어가 가도록 한다.
a=1 a=0
while a <= 10 :
while a <= 10 :
…… a += 1
…… if a%3 == 0 :
if 조건 : continue
print('a =',a)
continue
…… print('after while')
……
a += 1 continue 조건이 참인 경우 continue
…… 아래 부분은 실행하지 않는다. 9
……
 while 반복문 안에 while 반복문이 필요한 경우에는 중첩된

반복문을 사용한다.
 예제 4 : 구구단 출력하기 (2단 ~ 9단)
10
dan = 2
while dan <= 9 :

n=1
while n <= 10 :
value = dan * n
print('%3d' % (value), end='')
n += 1
print()
dan += 1
11
9. 실습 2
문제 1.
 A 학교에서는 주당 12시간 강의를 기본으로 하고 있다. 만약에 강

의 시간이 12시간을 초과하면 초과한 시간에 대해 시간당 급여의
30%를 더 지급한다. 주당 총 근무 시간과 A학교의 시간당 급여를
입력받아 1주일 급여를 계산하는 프로그램을 작성하시오.
2
문제 1.
working_hour = int(input('근무 시간을 입력하시오 : '))

pay_per_hour = int(input('시간당 수당을 입력하시오 : '))
total_pay = working_hour * pay_per_hour
if working_hour > 12 :
additional_pay = (working_hour - 12) * pay_per_hour * 0.3
total_pay += additional_pay
print()
print('총 급여는', total_pay, '원입니다.')
3
문제 2.
 하나의 양의 정수를 입력받아서 그 수의 약수를 모두 출력하고

약수의 개수도 출력하시오.
4
문제 2.
n = int(input('정수를 입력하시오 : '))

print()
a=1
count = 0
while a <= n :
if n % a == 0 :
print(a)
count += 1
a += 1
print()
print(n, '의 약수의 개수 :', count)
5
문제 3.
 다섯 개의 정수를 하나씩 입력받아서 그 정수들 중에서 가장 큰

값을 출력하시오.
6
문제 3.

max = n
loop_count = 1
while loop_count <= 4:
if n > max :
max = n
loop_count += 1
print()
print('가장 큰 값 :', max)
7
10. 리스트(list), 튜플(tuple)
1. 리스트와 연산
2. 리스트 사용하기
3. 튜플과 연산
4. 튜플 사용하기
 대괄호 []를 사용하여 여러 데이터를 저장할 수 있는 자료형
 순서가 있고, 인덱스를 이용하여 데이터에 접근할 수 있다.
 리스트는 mutable 하다
>>> score = [80, 90, 75, 88, 92] index → 0 1 2 3 4

>>> print(score) score 80 90 75 88 92
[80, 90, 75, 88, 92] index → -5 -4 -3 -2 -1
>>> print(score[2])
>>> score[2] = 78 # mutable
75
>>> print(score)
>>> print(score[-2])
[80, 90, 78, 88, 92]
88
2
 슬라이싱 (slicing)
A = [15, 27, 32, 20, 17, 13, 10, 22]
0 1 2 3 4 5 6 7
15 27 32 20 17 13 10 22
-8 -7 -6 -5 -4 -3 -2 -1
A[:] # [15, 27, 32, 20, 17, 13, 10, 22]

A[:5] # [15, 27, 32, 20, 17]
A[0:5] # [15, 27, 32, 20, 17]
A[2:5] # [32, 20, 17]
A[2:-1] # [32, 20, 17, 13, 10]
A[:-1] # [15, 27, 32, 20, 17, 13, 10]
A[-3:-1] # [13, 10] 3
 슬라이싱 (slicing)
B = ['a','b','c','d','e','f','g','h','i','j','k']
0 1 2 3 4 5 6 7 8 9 10
a b c d e f g h i j k
-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
B[::] # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']
B[2:9:3] # ['c', 'f', 'i']
B[0:-1:2] # ['a', 'c', 'e', 'g', 'i']
B[::2] # ['a', 'c', 'e', 'g', 'i', 'k']
B[-1:-7:-2] # ['k', 'i', 'g']
4
 리스트에 대한 +(연결) , *(반복) 연산

>>> L = [1,3,5,7,9]
>>> M = [2,4,6,8]
>>> L + M # 리스트 L과 리스트 M을 연결한 리스트를 반환한다.

[1, 3, 5, 7, 9, 2, 4, 6, 8]
>>> print(L, M) # L과 M은 변하지 않는다.

[1, 3, 5, 7, 9] [2, 4, 6, 8]
>>> K = L + M
>>> print(K)
[1, 3, 5, 7, 9, 2, 4, 6, 8]
>>> L * 3 # 리스트 L을 3회 반복한 리스트를 반환한다.

[1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1, 3, 5, 7, 9] 5
 in, not in, len()
>>> L = [1,3,5,7,9]
>>> 7 in L # 리스트 L에 데이터 7이 있다면 True
True
>>> 10 in L
False
>>> 10 not in L # 리스트 L에 데이터 10이 없다면 True
True
>>> len(L)
5
6
 메소드 (method) – 데이터 객체에 대해서 어떤 일을 처리할 수

있도록 하는 코드
 리스트에서 사용할 수 있는 메소드
>>> dir(list)
['__add__', '__class__', …… '__subclasshook__', 'append',
'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop',
'remove', 'reverse', 'sort']
 리스트.메소드 의 형태로 사용해야 한다.
7
메소드 설명
append (x) 데이터 x를 리스트 끝에 추가한다.
clear() 리스트를 비운다.
copy() 리스트를 복사한다.
count (x) 데이터 x의 개수를 알아낸다.
extend (M) 리스트 M을 연결한다.
index (x) 데이터 x의 위치를 알아낸다 (인덱스를 알려준다).
insert (i,x) 데이터 x를 지정한 위치 (인덱스 i)에 삽입한다.
pop() 리스트의 지정한 값 하나를 읽어 내고 삭제한다.
remove (x) 리스트에서 데이터 x를 삭제한다.
reverse() 리스트의 순서를 역순으로 바꾼다.
sort() 리스트를 정렬한다.
8
 리스트에 데이터 추가하기

 append(x) – 데이터 x를 리스트 끝에 추가한다.
 insert(i,x) – 인덱스 i에 데이터 x를 삽입한다.
>>> L = [1,4,7,8]
>>> L.append(5)
>>> print(L)
[1, 4, 7, 8, 5]
>>> L.insert(2,10)
>>> print(L)
[1, 4, 10, 7, 8, 5]
9
 리스트에서 데이터 삭제하기

 pop() – 리스트의 맨 마지막 데이터를 반환하고 삭제한다.
 pop(i) – 리스트에서 인덱스 i 에 있는 데이터를 반환하고 삭제한다.
 remove(x) – 리스트에서 데이터 x를 삭제한다. x가 여러 개 있으면
맨 처음 x를 삭제한다.
>>> L = [1,2,3,4,5] >>> L = [4,2,5,3,2,7,1,2,5]
>>> L.pop() >>> L.remove(7)
5 >>> print(L)
>>> print(L) [4, 2, 5, 3, 2, 1, 2, 5]
[1, 2, 3, 4] >>> L.remove(2)
>>> L.pop(2) >>> print(L)
3 [4, 5, 3, 2, 1, 2, 5]
>>> print(L)
[1, 2, 4] 10
 리스트에서 데이터 위치 찾기 / 데이터 개수 세기

 index(x) – 리스트에서 데이터 x의 인덱스를 반환한다.
 count(x) – 리스트에서 데이터 x의 개수를 반환한다.
>>> L = ['g','a','c','f','g','b']
>>> L.index('f')
3
>>> L.index('g') # 데이터가 여러 개이면 첫 번째 인덱스 반환
0
>>> L.count('g')
2
>>> L.count('b')
1
>>> L.count('m')
0 11
 빈 리스트와 리스트 비우기 - clear()
>>> A = [] # 빈 리스트
>>> A.append('red')
>>> A.append('blue')
>>> A.append('yellow')
>>> print(A)
['red', 'blue', 'yellow']
>>> A.clear()
>>> print(A)
[]
12
 리스트 복사하기 (‘=’ 이용하기)

>>> L = [1,3,5,7,9]
>>> id(L)
53794056
53794056
>>> M = L L 1 3 5 7 9
>>> M[2] = 100
>>> print(L)
M
[1, 3, 100, 7, 9]
>>> print(M)
[1, 3, 100, 7, 9]
>>> id(M)
13
53794056
 리스트 복사하기 – copy()

>>> L = [1,3,5,7,9]
>>> N = L.copy()
>>> N[2] = 100 53794216
>>> print(L)
L 1 3 5 7 9
[1, 3, 5, 7, 9]
2324360
>>> print(N)
N 1 3 5 7 9
[1, 3, 100, 7, 9]
>>> id(L)
53794216
>>> id(N)
14
2324360
 리스트 연결하기 – extend(M)
>>> L = [1,3,5]
>>> M = [10,20]
>>> L.extend(M) # L에 M를 연결한다.
>>> print(L)
[1, 3, 5, 10, 20]
>>> print(M)
[10, 20]
15
 리스트 정렬하기 – sort()
>>> L = [3,5,1,4,2]
>>> L.sort() # 오름차순으로 정렬
>>> print(L)
[1, 2, 3, 4, 5]
>>> L = [3,5,1,4,2]
>>> L.sort(reverse=True) # 내림차순으로 정렬
>>> print(L)
[5, 4, 3, 2, 1]
16
 리스트 역순으로 바꾸기 – reverse()
>>> L = [3,5,1,4,2]
>>> L.reverse()
>>> print(L)
[2, 4, 1, 5, 3]
17
3. 튜플과 연산
 리스트처럼 여러 데이터를 저장할 수 있는 자료형
 인덱싱, 슬라이싱 이용할 수 있다.
 +, *, in, not in, len() 사용할 수 있다.
 [] 대신에 ( )를 사용
 리스트와의 차이점 – 튜플은 immutable 하다.
18
3. 튜플과 연산
>>> T = (1,3,5,7,9)
index → 0 1 2 3 4
>>> M = (2,4,6,8) T 1 3 5 7 9
>>> print(T[2]) index → -5 -4 -3 -2 -1
5
>>> L + M
(1, 3, 5, 7, 9, 2, 4, 6, 8) 튜플에서는 다음과 같이 데이터를 바꾸는 일이 불가능하다.
>>> M * 3 >>> T[2] = 10
(2, 4, 6, 8, 2, 4, 6, 8) ……
TypeError: 'tuple' object does not support item
>>> 7 in L
assignment
True
>>> len(L)
5 19
메소드 설명
index(x) 튜플에서 데이터 x의 인덱스를 반환한다.
count(x) 튜플에서 데이터 x의 개수를 반환한다.
>>> T = (4,3,5,7,6,5,7,4,7,2)
>>> T.count(7) # 7의 개수
3
>>> T.index(2) # 데이터 2의 첫 번째 인덱스
9
>>> T.index(7) # 데이터 7의 첫 번째 인덱스. 없으면 에러 발생.
3
>>> dir(tuple)
['__add__', '__class__', ……'__subclasshook__', 'count', 'index']
20
 빈 튜플 T = ()
T = tuple()
 원소가 하나인 튜플 만들기
>>> T = (1,) # 콤마 필요 >>> A = 1,2,3 >>> C = 10
>>> type(T) >>> type(A) >>> D = 20,

<class 'tuple'> >>> type(C)
<class 'tuple'>
>>> B = (4,5,6) <class 'int'>
>>> type(B) >>> type(D)
>>> S = (1) # S = 1 과 같음
<class 'tuple'> <class 'tuple'>
>>> type(S)
콤마를 사용하면 괄호가
<class 'int'>
없어도 튜플로 인식한다. 21
 튜플은 여러 변수에 값을 동시에 할당할 수 있도록 한다.

>>> a = 1
>>> a,b,c = 1,2,3
>>> b = 2
>>> (a,b,c) = (1,2,3)
>>> c = 3
 튜플 이용한 swap
>>> x=10; y=20
 튜플은 함수에서 유용하게 사용된다.
>>> print(x,y)
 튜플은 immutable하므로 프로그램 수행 동안
10 20
변경하지 않아야 하는 데이터는 튜플로 저장하
>>> x,y = y,x
는 것이 좋다.
>>> print(x,y)
20 10
22
11. 집합(set), 사전(dict)
1. 집합 (set)
2. 집합 사용하기
3. 사전 (dict)
4. 사전 사용하기
1. 집합 (set)
 집합은 중복된 데이터를 가질 수 없고 순서가 없는 데이터 구조이다.
 인덱스 기호 ([ ]), +, * 를 사용할 수 없다.
 in, not in, len()은 사용할 수 있다.
 mutable 자료형이다.
 집합 생성하기 >>> S = set() # 빈 집합 생성

>>> type(S)
>>> s = {1,2,5} # set 생성
<class 'set'>
>>> print(s)
{1, 2, 5} >>> A = {} # 빈 사전
>>> type(s) >>> type(A)
<class 'set'> <class 'dict'>
2
메소드 설명
add (x) 집합에 원소 x를 추가한다.
clear() 공집합으로 만든다.
copy () 집합을 복사한다.
집합에서 원소 x를 삭제한다. 없는 원소를 삭제하려고 할
discard (x)
때에도 에러를 발생하지 않는다. (remove와 비교)
집합에서 임의의 원소를 하나 가져온다. 어떤 원소를 가져
pop()
올 지 알 수 없다. 집합에서 그 원소는 삭제된다.
집합에서 원소 x를 삭제한다. 없는 원소를 삭제하려고 하면
remove (x)
에러가 발생한다.
>>> dir(set)
['__and__', '__class__', …… '__xor__', 'add', 'clear', 'copy', 'difference',
'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint',
'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference',
'symmetric_difference_update', 'union', 'update'] 3
 집합에 원소 추가하기
>>> A = {4,2,6,8,3}
>>> print(A)
{8, 2, 3, 4, 6}
>>> A.add(5) # 집합 A에 데이터 5를 추가한다.
>>> print(A)
{2, 3, 4, 5, 6, 8}
>>> A.add(3) # 이미 있는 데이터를 추가하면 변동이 없다.
>>> print(A)
{2, 3, 4, 5, 6, 8}
4
 집합에서 원소 삭제하기
>>> A = {4,6,2,5,3}
>>> A.discard(5)
>>> print(A)
{2, 3, 4, 6}
>>> A.discard(7) # 집합 A에 없는 원소 삭제해도 에러 없다.
>>> print(A)
{2, 3, 4, 6}
>>> A.remove(4) # remove도 집합에서 원소를 삭제한다.

>>> print(A)
{2, 3, 6}
>>> A.remove(7) # 집합에 없는 원소를 remove하면 에러발생함.
5
 집합에서 원소 삭제하기 / 공집합 만들기
>>> A = {1,3,5,6,4}
>>> A.pop() # pop 메소드는 집합에서 임의의 원소를 반환하고 삭제한다.
1
>>> print(A)
{3, 4, 5, 6}
>>> A.clear() # 집합 A를 공집합으로 만든다.
>>> print(A)
set()
6
3. 사전 (dict)
 사전은 집합의 일종이다 (순서 개념이 없다).
 +, * 를 사용할 수 없다. 인덱스 기호([])는 사용한다.
 in, not in, len()은 사용할 수 있다.
 사전에는 (키:값)의 쌍으로 하나의 데이터가 저장된다.
 사전 예
 1반 25명, 2반 30명, 3반 27명이라는 정보를 저장하고자 한다.
>>> number = {1:25, 2:30, 3:27}

>>> type(number)
<class 'dict'>
7
3. 사전 (dict)
 사전의 키
 mutable 자료형은 ‘키’가 될 수 없다. (리스트, 집합, 사전)
 정수, 실수, bool, 복소수, 문자열, 튜플은 ‘키’가 될 수 있다.
 사전의 값
 모든 자료형이 사전의 ‘값’이 될 수 있다.
 빈 사전 생성하기
>>> mydict = {} # mydict = dict()

>>> type(mydict)
<class 'dict'>
8
3. 사전 (dict)
 사전에 아이템 추가 / 수정하기
>>> colorpen = {'red':2, 'blue':3, 'yellow':1}

>>> colorpen['green'] = 3 # 추가하기
>>> print(colorpen)
{'green': 3, 'red': 2, 'yellow': 1, 'blue': 3}
>>> colorpen['red'] = 4 # 수정하기
>>> print(colorpen)
{'green': 3, 'red': 4, 'yellow': 1, 'blue': 3}
9
3. 사전 (dict)
 사전에 아이템 삭제하기 / in, not in, len()
>>> del colorpen['red'] # 삭제하기

>>> colorpen
{'yellow': 1, 'green': 4, 'blue': 3}
>>> len(colorpen)
3
>>> 'blue' in colorpen
True
>>> 'red' not in colorpen
True
10
>>> dir(dict)
['__class__', '__contains__', ……'__subclasshook__', 'clear',
'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem',
'setdefault', 'update', 'values']
메소드 설명
clear () 사전의 내용을 모두 지운다.
copy () 사전을 복사한다.
items() 사전에 있는 모든 데이터의 (키,값)을 모두 반환한다.
keys() 사전에서 키만 반환한다.
values() 사전에서 값만 반환한다.
update(D) 사전 D를 추가한다.
11
 clear() 메소드
>>> D = {1:30, 2:25, 3:27}

>>> print(D)
{1: 30, 2: 25, 3: 27}
>>> D.clear()
>>> print(D)
{}
12
 copy() 메소드 51111016

>>> D1 = {1:30, 2:25, 3:27} 1:30 4:32
D1
>>> id(D1) 3:27
2:25
D2
51111016
>>> D2 = D1
>>> id(D2) >>> D1 = {1:30, 2:25, 3:27}
51111016 >>> D2 = D1.copy()
>>> D2[4] = 32 >>> D2[4] = 32
>>> print(D1) >>> print(D1)
{1: 30, 2: 25, 3: 27, 4: 32} {1: 30, 2: 25, 3: 27}
>>> print(D2) >>> print(D2)
{1: 30, 2: 25, 3: 27, 4: 32} {1: 30, 2: 25, 3: 27, 4: 32} 13
 update(D) 메소드
>>> Voca = {1:'one', 2:'two', 3:'three'}

>>> Voca2 = {100:'hundred', 1000:'thousand'}
>>> Voca.update(Voca2)
>>> print(Voca)
{1: 'one', 2: 'two', 3: 'three', 1000: 'thousand', 100: 'hundred'}
>>> print(Voca2)
{1000: 'thousand', 100: 'hundred'}
14
 items() – 사전에서 (키,값)을 쌍으로 반환한다.
사전 count는 A 영어 학원의 각 강좌 등록생 수를 저장하고 있다.
>>> count = {'toefl':40, 'toeic':50, 'sat':25}

>>> A = count.items()
>>> print(A)
dict_items([('sat', 25), ('toefl', 40), ('toeic', 50)])
>>> B = list(count.items())
>>> print(B)
[('sat', 25), ('toefl', 40), ('toeic', 50)]
15
 keys() – 사전에서 키만을 반환한다.
>>> count = {'toefl':40, 'toeic':50, 'sat':25}

>>> A = count.keys()
>>> print(A)
dict_keys(['sat', 'toefl', 'toeic'])
>>> B = list(count.keys())
>>> print(B)
['sat', 'toefl', 'toeic']
16
 values() – 사전에서 값만을 반환한다.
>>> A = count.values()
>>> print(A)
dict_values([25, 40, 50])
>>> B = list(count.values())
>>> print(B)
[25, 40, 50]
17
12. for 반복문
1. range() 함수
2. for 반복문
3. 리스트 내에 for 반복문
4. 군집자료형의 형변환
1. range() 함수
 range() 함수 : 일정 범위의 수를 반환한다.

range(b) – 0부터 b-1까지의 수를 반환한다.
range(a,b) – a부터 b-1까지의 수를 반환한다.
range(a,b,n) – a부터 b-1까지의 n 간격의 수를 반환한다
>>> A = range(5) >>> list(range(5))

>>> type(A) [0, 1, 2, 3, 4]
<class 'range'> >>> list(range(5,10))
>>> print(A) [5, 6, 7, 8, 9]
range(0, 5) >>> list(range(3,10,2))
>>> B = list(range(5)) [3, 5, 7, 9]
>>> print(B) >>> list(range(10,1,-2))
2
[0, 1, 2, 3, 4] [10, 8, 6, 4, 2]
2. for 반복문
 for 구문을 이용한 반복문

변수
데이터 집합
for x in [ …… ] : range() 함수
문자열
명령어 1 리스트
명령어 2 튜플
집합
… 사전
명령어 n
 데이터 집합에서 데이터를 하나씩 변수 x에 넣고 반복을 수행한다.

 for 구문에도 break와 continue를 사용할 수 있다.
3
3. range() 함수와 for 반복문
예제 1
for x in range(5):
print(x)
range(5) 자리에 [0,1,2,3,4]가 온다.
차례대로 x값이 되어 for 블록을 수행한다.
예제 2
for data in range(1,10,2):
print(data+1)
4
4. 문자열과 for 반복문
예제 3
for letter in 'PYTHON':
print(letter)
'PYTHON'이 하나씩 letter 변수에 저장되어
for 블록을 수행한다.
예제 4
for alpha in 'sogang':
y = alpha.upper()
print(y)
5
5. 리스트와 for 반복문
예제 5
for x in [1,3,5,7,9]:
print(x)
[1,3,5,7,9] 원소가 하나씩 변수 x값이

되어 for 블록을 수행한다.
예제 6
for x in [1,2,3,4,5]:
for y in [2,4,6,8,10]:
print(x*y, end=' ')
print() 6
6. 사전과 for 반복문
 keys() 메소드 이용하기

사전 score는 {학생번호:성적}으로 구성된다.
score = {4:90, 2:80, 1:95, 5:88, 3:92}
예제 7
for x in score :
print(x)
예제 8
for x in score.keys():
print(x)
7
 items() 메소드 이용하기

score = {4:90, 2:80, 1:95, 5:88, 3:92}
예제 9
for x,y in score.items() :
print(x,y)
items() 메소드를 이용하는 경우에는 키와 값을 순서대로 가져온다. 따라서

for 다음에 두 개의 변수를 사용해야 한다. x에는 키가 저장되고, y에는 값이
저장되어 이용할 수 있다.
8
 values() 메소드 이용하기

score = {4:90, 2:80, 1:95, 5:88, 3:92}
예제 10
for x in score.values() :
print(x)
9
7. 리스트 안에 for 반복문 사용하기
A = { x2 : x ∈ {0, 1, 2, …, 9} }
B = { 1, 2, 22, 23, …, 210 } [ 표현식 for x in 데이터집합 if 조건 ]
C = { x | x ∈ A and x is even }
>>> A = [ x**2 for x in range(10) ] >>> C = [ x for x in A if x%2 == 0]

>>> print(A) >>> print(C)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] [0, 4, 16, 36, 64]
>>> B = [ 2**i for i in range(11) ]

>>> print(B)
[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
10
8. 군집 자료형의 형 변환
함수명 설명 A = [1,2,3,4]
str(A) A를 문자열로 변환한다. B = (1,3,5)
list(A) A를 리스트로 변환한다. C = {2,4,6,8,10}
tuple(A) A를 튜플로 변환한다. D = {1:90, 2:88, 3:93}
set(A) A를 집합으로 변환한다.
E = tuple(A) # (1, 2, 3, 4)
dict(A) A를 사전으로 변환한다.
F = set(B) # {1, 3, 5}
G = list(C) # [8, 10, 2, 4, 6]
H = list(D) #[1, 2, 3]
I = tuple(D) # (1, 2, 3)
J = set(D) # {1, 2, 3}
11
13. 실습 3
문제 1.
 for 구문과 range() 함수를 이용하여 다음과 같이 출력되도록 하

시오.
2
문제 1.
for x in range(10):
print(x, end=' ')
print()
for x in range(0, 51, 5):

print(x, end=' ')
print()
for x in range(10, 0, -1):

print(x, end=' ')
3
문제 2.
 score 리스트에 다섯 개의 성적(정수)를 입력 받아서 다음과 같이

출력하시오. 성적을 입력받을 때는 반드시 for 구문을 사용하고 파
이썬 내장 함수를 적절히 이용하시오.
4
문제 2.
score = []
for i in range(5):
data = int(input('성적을 입력하시오 : '))
score.append(data)
print()
print('입력한 성적들 :', score)
print('최고 성적 :', max(score))
print('최저 성적 :', min(score))
average = sum(score) / len(score)
print('평균 : %.2f' % average)
5
문제 3.
 A 고등학교 어떤 반 학생들 5명의 번호와 국어, 영어, 수학 성적이

다음과 같다. 5명 각자의 평균을 출력하시오.
(‘사전’과 ‘리스트’ 이용할 것)
번호 국어 영어 수학
1 80 90 86
2 78 88 85
3 85 85 92
4 70 69 65
5 90 95 100
6
문제 3.
score = {1:[80,90,86],
2:[78,88,85],
3:[85,85,92],
4:[70,69,65],
5:[90,95,100]}
for key,value in score.items():

print(key, '번 :', sum(value)/len(value))
7
14. 함수 - 1
1. 함수
2. 파이썬 내장 함수
3. 사용자 정의 함수
4. 함수의 인수와 반환값
5. 함수의 위치와 main 작성하기
1. 함수
 블랙 박스 (black box) >>> print('Hello world')

 함수는 입력과 출력을 갖는 black Hello world
box이다.
 주어진 입력에 대해서 어떤 과정

을 거쳐 출력이 나오는지가 숨겨
print
져 있다.
 함수의 재사용성 (reuse)
 함수 이름, 입력, 출력 중요함. Hello world
2
 내장 함수 (built-in functions)
 파이썬 언어에서 미리 만들어서 제공하는 함수들
 IDLE에서 dir(__builtins__)라고 입력하면 파이썬에서 제공하는 내

장 함수 목록을 볼 수 있다.
 내장 함수에 어떤 것들이 있는지 학습하고 적절히 사용할 줄 아는 것

이 중요하다.
 사용자 정의 함수 (user-defined functions)

 사용자가 직접 만드는 함수
 함수 작성 문법을 익히고 직접 작성해 보는 것이 중요하다.

3
>>> dir(__builtins__)
['ArithmeticError', …… 'ZeroDivisionError', '_', '__build_class__',
'__debug__', '__doc__', '__import__', '__loader__', '__name__',
'__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray',
'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright',
'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',
'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash',
'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len',
'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object',
'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr',
'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str',
'sum', 'super', 'tuple', 'type', 'vars', 'zip'] 4
 군집자료형에 유용한 함수들

 len(), max(), min(), sum(), sorted(), reversed() 함수
>>> L = [6,4,9,8,10,50,7] >>> T = (4,6,10,2,1,5) >>> S = {4,6,2,7,5}
>>> len(L) >>> a = len(T) >>> a = len(S)
7 >>> b = max(T) >>> b = max(S)
>>> max(L) >>> c = min(T) >>> c = min(S)
50 >>> d = sum(T) >>> d = sum(S)
>>> min(L) >>> print(a,b,c,d) >>> print(a,b,c,d)
4 6 10 1 28 5 7 2 24
>>> sum(L)
94 >>> S = sorted(T) >>> T = sorted(S)
>>> sorted(L) >>> print(S) >>> print(T)
[4, 6, 7, 8, 9, 10, 50] [1, 2, 4, 5, 6, 10] [2, 4, 5, 6, 7]
>>> L >>> type(S) >>> type(T)
[6, 4, 9, 8, 10, 50, 7] <class 'list'> <class 'list'>
5
 reversed 함수 – 군집자료형 데이터를 역순으로 바꾼다.

 순서가 있는 list, tuple, str 에만 적용할 수 있다.
>>> L = [1,3,5,7,9]
>>> M = reversed(L)
>>> print(M)
<list_reverseiterator object at 0x03DC92B0>
>>> M = list(reversed(L))
>>> print(M)
[9, 7, 5, 3, 1]
>>> T = (2,4,6,8) >>> S = 'HELLO'
>>> K = list(reversed(T)) >>> P = list(reversed(S))
>>> print(K) >>> print(P)
[8, 6, 4, 2] ['O', 'L', 'L', 'E', 'H'] 6
 함수 정의하기
parameter
def 함수명 ( parameter ) : (매개변수)
a b
""" 이 함수는 두 정수에서 큰 값 함수명 : find_max
을 찾아서 반환하는 함수이다. """ def find_max (a,b):
if a > b :
if a > b :
y=a
y=a
else : else :
y=b y=b
return 반환값
return y
 docstring : """ …… """ y

 함수명 – 변수명 규칙과 같다. 반환값
 영문 대소문자, 숫자, _ 로 구성됨.
 숫자로 시작할 수 없음. 7
 함수 호출하기 – 함수명에 인수를 넘기면서 호출함.
def find_max (a,b): a,b : 매개변수 (parameter)

if a > b :
y=a
else :
y=b
return y
# main
m = find_max(10,20) # 10, 20 : 인수 (arguments)

n = find_max(7,3) # 7, 3 : 인수 (arguments)
print(m,n)
8
 인수, 반환값이 없는 함수
 함수에 입력이 없으면 빈 괄호로 둔다.
 함수에 출력이 없을 수도 있다 (return 구문이 없다).

def hello():
print('hello python~')
# main – 여기에서 프로그램 수행 시작
print('start of the program')

hello()
print('middle of the program')
hello()
print('end of the program')
9
 인수가 여러 개인 함수 (인수 개수만큼 parameter 필요함)

 예) main 에서 국어, 영어, 수학 성적을 입력받아 calculate함수의
입력으로 넘긴다. calculate 함수는 평균을 반환한다.
def calculate(kor, eng, math):
total = kor + eng + math
average = total / 3
return average
# main
kor_score = int(input('국어 성적을 입력하시오 : '))
eng_score = int(input('영어 성적을 입력하시오 : '))
math_score = int(input('수학 성적을 입력하시오 : '))
avg = calculate(kor_score, eng_score, math_score)

print('평균 :', avg) 10
 함수에서 return 문이 여러 번 나오는 경우

 return 문이 여러 번 나오더라도 가장 먼저 return을 만나는 순간
함수는 값을 반환하고 종료한다.
def find_max (a,b): def find_max (a,b):

if a > b : if a > b :
y=a return a
else : else:
y=b return b
return y
함수명 : find_max
11
 반환값이 여러 개인 경우
 함수에 반환값이 2개 이상인 경우 튜플로 묶어서 반환한다.
 예) 두 수를 입력받아서 두 수의 합과 두 수의 곱을 반환하는 함수
def add_multiply(x,y):
sum = x + y
mult = x * y
return sum, mult # 튜플로 반환한다.
# main
m,n = add_multiply(a,b)
print(m,n)
12
5. 함수의 위치와 main 작성하기
 함수의 위치
 함수는 호출 전에 정의되어 있어야 한다.
print('start of the program') a = 10
hello() b = 20
print('middle of the program') print('before test definition')
hello()
print('end of the program') def test():
print('I am test')
def hello(): print(a, b)
print('start')
test()
print('end')
13
5. 함수의 main 작성하기
 main 함수 작성하기
 main은 프로그램 시작점을 의미한다.
def find_max (a,b): def find_max (a,b):

if a > b : return a if a > b : return a
else: return b else: return b
x = find_max(10, 20) def main():

y = find_max(7,3) x = find_max(10, 20)
print(x,y) y = find_max(7,3)
print(x,y)
if __name__ == '__main__':
main()
14
15. 함수 - 2
1. 전역 변수와 지역 변수
2. 함수의 인수
3. 람다 함수 (lambda)
 전역 변수(global variable) : 프로그램 전체에서 사용 가능

 지역 변수(local variable) : 함수 내에서만 사용 가능
 scoping rule : 변수를 찾을 때 지역 변수 → 전역 변수 순서로 찾는다.
def test(): def test(): def test():

print(a) b = 20 # 지역변수 a = 200 # 지역변수
print(a,b) print(a)
# main
# main # main
a = 100 # 전역변수
a = 100 # 전역변수
print(a) a = 100 # 전역변수
print(a)
test() print(a)
test()
print(a) test()
print(a)
print(a)
print(b) # 에러
2
 global 선언
 전역 변수를 함수 내에서 바꾸고자 하면, global 선언이 필요함
def test(): def test():

a = 200 global a
a = 200
# main
# main
a = 100
test() a = 100
print(a) test()
print(a)
3
 global 선언
 함수에서 만든 지역 변수를 전역 변수로 사용하고자 한다면 global 선
언이 필요함
def test(): def test():

a = 100 global a
print(a) a = 100
print(a)
# main
# main
test()
print(a) test()
print(a)
에러 발생
4
 함수 매개변수는 지역 변수이다.
def test(a):
a += 200 지역 변수 a
print(a)
# main
a = 100 전역 변수 a
test(a)
print(a)
함수 test를 호출할 때 100을 인자로 넘기면 지역 변수 a가

생성되고 값으로 100을 갖는다.
5
 mutable 객체가 인수인 경우 (리스트, 집합, 사전)

 리스트 인수
def test(M): M
M[2] += 2
M[4] += 10 L 90 80 95 85 77 83
# main
만약에 L 복사본이 생겨서 원본 L을 바꾸고
싶지 않다면 다음과 같이 test 함수에 인수
L = [90,80,95,85,77,83] 를 넘겨야 한다.
test(L)
print(L) test(L[:]) 또는 test(L[::])
6
2. 함수의 인수
 기본값(default value)이 있는 인수
 함수를 호출할 때 인수를 넘겨주지 않아도 인수가 자신의 기본값을 취
하도록 하는 기능.
def inc(a, step=1):  첫 번째 매개 변수 a 에는 반드시

return a + step
인수를 넘겨야 한다.
b = inc(10)  두 번째 매개 변수인 step에는 인
print(b) # 11
수를 넘기면 그 값이 step에 저장
c = inc(10, 50) 되고, 인수를 넘기지 않으면 1이
print(c) # 60
step 값으로 이용된다.
7
2. 함수의 인수
 함수를 정의할 때 인수의 기본값 사용시 주의점

 기본값이 있는 인수가 먼저 올 수 없다.
>>> L = [4,3,5,1,2]
def inc(step=1, a): >>> L.sort()
return a + step
에러
>>> print(L)
[1, 2, 3, 4, 5]
>>> M = [3,5,1,2,4]
 인수가 여러 개인 경우의 예 >>> M.sort(reverse=True)
>>> print(M)
def test(a, b=1, c=2): # OK [5, 4, 3, 2, 1]
return a + b + c >>> a,b = 10, 20
>>> print(a,b)
def test2(a, b, c=10): # OK 10 20
return a + b + c >>> print(a,b,sep=':')
10:20
def test3(a, b=1, c): # 에러 >>> print(a,end=' ^^ '); print(b)
return a + b + c 10 ^^ 20
8
2. 함수의 인수
 키워드 인수
 함수 호출 시에 인수 이름(매개변수)과 값을 같이 전달하기
def area(x, y):

return x * y
a = area(10,5)
b = area(x=4, y=9) # 매개변수와 값을 같이 적어 준다
c = area(y=5, x=10) # 매개변수와 값을 같이 적으면 순서 상관없다
d = area(10, y=5) # OK (일반 인수 뒤에 키워드 인수 올 수 있다)
e = area(x=10, 5) # 에러
9
2. 함수의 인수
 키워드 인수
 키워드 인수의 위치는 일반 인수 이후이다.
def volume(x,y,z):
일반 인수 : positional argument
return x * y * z
volume(1, 3, 5) # 15
volume(y=7, z=5, x=2) # 70
volume(z=2, x=4, y=5) # 40
volume(5, z=10, y=2) # 100
volume(5, x=2, z=20) # 에러 (x에 두 개의 값이 할당된다는 에러)
volume(z=10, 20, x=2) # 에러 (일반 인수가 키워드 인수 뒤에 오면 안됨)
10
2. 함수의 인수
 가변 인수 사용하기
 정해지지 않은 수의 인수를 함수에 전달하기
 함수를 정의할 때 인수 목록에 반드시 넘겨야 하는 고정 인수를 우선 나열

하고, 나머지를 마지막에 튜플 형식으로 한꺼번에 받는다.
def friends(*name): def arg(a, b, *c):

for n in name: print(a,b,c)
print(n.title()) print(sum(c))
friends('alice', 'paul') # main

print('------') arg(10,20)
friends('cindy', 'sally', 'david', 'tom') print('----------')
arg(7,8,9)
print('----------')
arg(1,2,3,4,5) 11
2. 함수의 인수
 정의되지 않은 키워드 인수 처리하기

 ** 형식으로 기술
 전달받는 형식은 사전이다. 즉, 키는 키워드(변수명)가 되고, 값은 키워

드 인수로 전달되는 값이 된다.
def name_age(**lists):
print(lists)
name_age(Alice=10, Paul=12)
print('-----------------------------')
name_age(Cindy=5, David=7, Tom=10)
12
 람다 함수의 정의
 이름없는 한 줄짜리 함수이다.
 람다 함수는 return 문을 사용하지 않는다.
 람다 함수의 몸체는 문이 아닌 하나의 식이다.
 람다 함수는 함수를 함수 인자로 넘길 때 유용하다.
lambda <인수들> : <반환할 식>
def add(x,y):
lambda x, y: x + y
return x+y
13
 map 내장 함수
map( 함수명 , 함수에 대한 인수 집합 )
시퀀스 자료형 (리스트, 튜플, 문자열)
>>> names = ['Alice', 'Paul', 'Bob', 'Robert']

>>> A = map(len, names)
>>> print(A)
<map object at 0x036091D0>
>>> list(A)
[5, 4, 3, 6]
14
 map 내장 함수 예
>>> def f(x):
return x * x
>>> X = [1, 2, 3, 4, 5]
>>> list(map( f, X )) # 함수 f 에 X의 값들을 하나씩 적용한다
[1, 4, 9, 16, 25]
>>> X = [1, 2, 3, 4, 5]
>>> Y = map( lambda a:a * a, X )
>>> list(Y)
[1, 4, 9, 16, 25]
# range(10)의 원소를 식 x2+4x+5 에 대입한 결과를 내 준다

>>> Y = map( lambda x: x * x + 4 * x + 5, range(10) )
>>> list(Y)
[5, 10, 17, 26, 37, 50, 65, 82, 101, 122] 15
 filter 내장 함수
filter( 함수명 , 함수에 대한 인수 집합 )
시퀀스 자료형 (리스트, 튜플, 문자열)

참/거짓을 반환하는 함수
>>> X = [1,3,5,7,9]
>>> result = filter( lambda x:x>5, X )
>>> print(result)
<filter object at 0x03FAD0D0>
>>> list(result)
[7, 9]
>>> list(filter( lambda x:x%2==1, range(11)))

[1, 3, 5, 7, 9]
16
16. 파이썬 모듈
1. 모듈 소개하기
2. 모듈 사용하기
3. 모듈 만들기
4. random 모듈
 파이썬 구성 요소
modules + classes + built-in functions (내장함수)
random module 내장 함수들

sum()
random() abs() input()
int()
shuffle()
randint() …… type() print() list() pow() ……
math module
pow () class str
sin() class list upper ()
cos() …… lower()
append () count() ……
insert()
…… module들 sort() ……
…… class들
2
 모듈 (module)
 코드들을 한 단위로 묶어 사용할 수 있게 하는 하나의 단위.
 모듈의 종류
① 표준 모듈 – 파이썬 패키지 안에 포함된 모듈
② 사용자 모듈 – 사용자가 만드는 모듈
③ 써드 파티 (third party) 모듈 – 개인이 만들어서 제공하는 모듈
 모듈 사용의 장점
① 코드의 재사용성
② 서로 다른 모듈에 같은 이름의 메소드가 있어도 충돌이 생기지 않음
3
 모듈은 반드시 import 후에 사용할 수 있다
>>> import math

>>> math.pow(2,3) # 모듈 math 내의 pow 함수
8.0
>>> math.pi
3.141592653589793
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos',
'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos',
'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial',
'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isfinite', 'isinf',
'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'pi',
'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
4
 모듈 import 방법
① import <모듈>
>>> import math

>>> math.pi # math 모듈에 있는 pi 속성
3.141592653589793
>>> math.pow(2,5) # math 모듈에 있는 pow 함수
32.0
>>> math.trunc(10.9) # 소수점 아래를 버린다
10
5
② from <모듈> import <함수명>
>>> from math import pow
>>> pow(2,5) # 이 경우 함수명만 사용 가능하다
32.0
>>> from math import pow, sqrt, trunc # 콤마로 여러 함수 사용 가능
>>> sqrt(9)
3.0
>>> trunc(1.5)
1
>>> pow(2,3)
8.0
>>> from math import * # math 모듈에 있는 모든 함수를 이름으로 사용
>>> log2(1024)
6
10.0
③ import <모듈> as <alias>
<모듈명> 대신 <alias>를 모듈명으로 사용함.
>>> import math as mt

>>> mt.pow(3,5)
243.0
>>> mt.log2(1024)
10.0
7
3. 모듈 만들기
 데이터, 함수들로 구성된 파일을 만든다.
 파일명이 모듈명이 된다.

파일명 : calc.py
""" 연산에 필요한 함수들을 import calc
모아 놓은 연산 모듈이다. """
x = 10
data = 100 y = 20
z=5
def add_all(a,b,c):
total = a + b + c ans1 = calc.add_all(x,y,z)
return total ans2 = calc.multiply_all(x,y,z)
def multiply_all(a,b,c): print(ans1, ans2)

result = a * b * c print('data :', calc.data)
return result 8
4. random 모듈
 임의의 값을 선택하는 함수들로 구성된 모듈
>>> import random
>>> dir(random)
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST',
'SystemRandom', 'TWOPI', '_BuiltinMethodType', '_MethodType', '_Sequence',
'_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__',
'__name__', '__package__', '__spec__', '_acos', '_ceil', '_cos', '_e', '_exp', '_inst',
'_log', '_pi', '_random', '_sha512', '_sin', '_sqrt', '_test', '_test_generator',
'_urandom', '_warn', 'betavariate', 'choice', 'expovariate', 'gammavariate',
'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate',
'paretovariate', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate',
'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
9
4. random 모듈
 임의의 값을 선택하는 함수들로 구성된 모듈
함수 설명
randint(a,b) a<=N<=b 사이의 임의의 정수 N 선택
정수 선택
randrange( ,,) range() 결과 중에서 임의의 값 선택
random() 0.0 <= F < 1.0 사이의 임의의 실수 F 선택
실수 선택
uniform(a,b) a와 b 사이의 임의의 실수 선택
choice(X) 군집자료형 X에서 임의의 원소 선택

군집 자료형 sample(X,k) 군집자료형 X에서 k개의 원소를 임의로 중복없이 선택
에서 선택
군집자료형 X를 섞는다. immutable 자료형에는 적용
shuffle(X)
할 수 없다.
10
4. random 모듈
 임의의 정수 생성 (randint())
>>> import random

>>> random.randint(10,20) # 10 <= N <= 20 사이에서 임의의 수 선택
20
>>> random.randint(11,13)
12
1
90
11
4. random 모듈
 임의의 정수 생성 (randrange())
>>> import random

>>> random.randrange(10) # range(10)에서 임의의 수 반환
3
>>> random.randrange(5,10) # range(5,10)에서 임의의 수 반환
9
>>> random.randrange(5,10)
5
>>> random.randrange(5,15,3) # range(5,15,3)에서 임의의 수 반환
5
>>> random.randrange(5,15,3)
11
>>> random.randrange(5,15,3)
8
12
4. random 모듈
 임의의 정수 여러 개 생성
>>> import random

>>> [random.randrange(20) for i in range(10)] # 중복 허용
[8, 6, 12, 8, 8, 0, 12, 11, 6, 8]
>>> [random.randrange(0,20,3) for i in range(5)]
[3, 9, 0, 0, 18]
>>> random.sample(range(20),10) # 중복 허용하지 않음

[12, 8, 17, 1, 3, 6, 9, 0, 11, 10]
13
4. random 모듈
 임의의 실수 생성 (random(), uniform())

 random() : 0.0에서 1.0 사이의 임의의 float 값 반환
 uniform(a,b) : 두 인수 a와 b 사이의 임의의 float 값 반환

>>> from random import random, uniform
>>> random()
0.2832728368301739
>>> random()
0.4033935667377505
>>> uniform(3,4)
3.757279572878299
>>> uniform(100, 200)
188.10693319776624
14
4. random 모듈
 리스트에 random 모듈 이용하기

>>> L = list(range(10))
>>> L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.choice(L)
6
>>> [random.choice(L) for i in range(3)]
[1, 6, 4]
>>> random.sample(L,3)
[5, 0, 4]
>>> L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(L)
>>> L
[1, 4, 0, 6, 3, 7, 5, 2, 8, 9]
15
4. random 모듈
 튜플에서 random 모듈 이용하기
>>> T = tuple(range(1,10,2))
>>> print(T)
(1, 3, 5, 7, 9)
>>> random.choice(T)
7
>>> random.sample(T,2)
[1, 7]
>>> random.shuffle(T) # 에러
16
4. random 모듈
 문자열에서 random 모듈 이용하기
>>> w = 'abcdefghijklmn'
>>> random.choice(w)
'b'
>>> random.choice(w)
'l'
>>> random.sample(w,3)
['n', 'c', 'a']
>>> random.shuffle(w) # 에러
17
17. 실습 4
문제 1.
 이전 실습에서 했던 문제이다. A 학교에서는 주당 12시간 강의를

기본으로 하고 만약에 강의 시간이 12시간을 초과하면 초과한 시
간에 대해 시간당 급여의 30%를 더 지급한다. 주당 총 근무 시간
과 시간당 급여를 입력받아 1주일 급여를 계산하는 부분을 함수로
작성하고 main에서 함수를 호출하시오.
2
문제 1.
def week_salary(hour, pay):

total_pay = hour * pay
if hour > 12:
additional_pay = (hour-12) * pay * 0.3
total_pay += additional_pay
return total_pay
# main
working_hour = int(input('근무 시간을 입력하시오 : '))

pay_per_hour = int(input('시간당 수당을 입력하시오 : '))
answer = week_salary(working_hour, pay_per_hour)
print()
print('총 급여는', int(answer), '원입니다.')
3
문제 2.
 섭씨 온도를 화씨 온도로 바꾸는 프로그램을 작성하려고 한다. 섭

씨 시작 온도와 섭씨 끝 온도를 입력받아서 다음과 같이 출력되도
록 프로그램을 작성하시오. 이 때, 섭씨 온도를 화씨 온도로 바꾸는
부분은 반드시 함수로 작성하도록 한다.
화씨 = 섭씨 * 9 / 5 + 32
4
문제 2.
def CtoF(temp):
result = temp * 9 / 5 + 32
return result
# main
start_temp = int(input('시작 온도를 입력하시오 : '))

end_temp = int(input('끝 온도를 입력하시오 : '))
print()
for t in range(start_temp, end_temp+1):
r = CtoF(t)
print('섭씨 %.2f도는 화씨 %.2f도입니다.' % (t,r))
5
문제 3.
 컴퓨터는 1부터 100사이의 정수 하나를 임의로 선택한다. 사용자

는 컴퓨터가 선택한 수를 맞춘다. 최종적으로 몇 번의 guess로 맞
췄는지와 컴퓨터가 선택한 숫자를 출력한다.
6
문제 3.
import random
number = random.randint(1,100)
guess = int(input('숫자를 맞춰보세요 (1~100) : '))

count = 1
while guess != number:

if guess > number:
print('더 작은 수를 선택하세요.')
else:
print('더 큰 수를 선택하세요.')
guess = int(input('숫자를 맞춰보세요 (1~100) : '))
count += 1
print('\n빙고 ~~', count,'번만에 맞췄습니다. 입력한 숫자는', number,'입니다.\n')
input('프로그램을 마치려면 엔터를 누르세요.')

7
18. 예외 처리
1. 구문 에러
2. 예외
3. 예외 처리
1. 구문 에러
 구문 에러 (syntax error)
 문법 에러
>>> print('hello world)
SyntaxError: EOL while scanning string literal
>>> a = 100
>>> if a > 100 ; print(a)
SyntaxError: invalid syntax
2
2. 예외
 예외(exception)
 구문 에러가 없이 잘 작성된 코드라도 실행 도중에 에러가 발생할 수
있다. 이러한 잠재적인 에러를 ‘예외’라고 한다.
>>> print(x)
print(x)
NameError: name 'x' is not defined
>>> a = 1 ; b = 'A'
>>> a + b
a+b
TypeError: unsupported operand type(s) for +: …… 3
2. 예외
 예외(exception)
>>> a = 10; b = 0
>>> a / b
a/b
ZeroDivisionError: division by zero
>>> L = [1,2,3]
>>> print(L[3])
print(L[3])
IndexError: list index out of range
4
3. 예외 처리
 예외 처리 예
c=a/b
print(c)
5
3. 예외 처리
 예외 처리 예
try :
c=a/b
print(c)
except ZeroDivisionError :
print('Cannot divide by 0')
6
3. 예외 처리
 예외 처리
try :
< 예외 발생 가능성이 있는 문장 >
except < 예외 종류 > :
< 예외 처리 문장 >
except < 예외 종류 > :
< 예외 처리 문장 >
else :
< 예외가 발생하지 않은 경우, 수행할 문장 >
finally :
< 예외 발생 유무에 상관없이 try 블록 이후 수행할 문장 >
7
3. 예외 처리
a=5
 예외 처리 예 b=0
L = [1,2,3]
a=5 print('hello')
b=0 try :
L = [1,2,3] c=a/b
print(x)
print('hello') print(L[3])
except ZeroDivisionError:
c=a/b print('cannot divide by zero !!!')
print(x) except NameError:
print(L[3]) print('no variable named "x"')
except IndexError:
print('out of indexing in list')
print('good bye') else:
print('else part')
print('good bye') 8
3. 예외 처리
a=5
 예외 처리 예 b=1 수정하였음.
L = [1,2,3]
print('hello')
try :
c=a/b
print(x)
print(L[3])
print('cannot divide by zero !!!')
except NameError:
print('no variable named "x"')
except IndexError:
else:
print('else part')
print('good bye') 9
3. 예외 처리
 예외 발생하지 않는 경우 – else 가 있다면 수행함.

a=5
b=1
L = [1,2,3]
print('hello')
try :
c=a/b
print(L[2])
print('cannot divide by zero !!!')
except IndexError:
else:
print('else part')
10
print('good bye')
3. 예외 처리
 finally 구문이 있는 경우 – 무조건 수행되는 구문
L = [1,2,3] 예외 발생 예제
print('hello')
try:
print(L[3])
except IndexError:
else:
print('else part')
finally:
print('finally part')
print('good bye')
11
3. 예외 처리
 finally 구문이 있는 경우 – 무조건 수행되는 구문
L = [1,2,3] 예외 없는 예제
print('hello')
try:
print(L[2]) 수정하였음.
except IndexError:
else:
print('else part')
finally:
print('finally part')
print('good bye')
12
19. 파일 입출력
1. 파일 연결 – open() 내장 함수
2. 파일 입력 - 파일로부터 데이터 읽어오기
3. 파일 출력 - 파일에 데이터 저장하기
1. 파일 연결
 open() 내장 함수
파일객체 = open( file, mode )
file 파일명
파일을 열 때의 모드를 의미하며, 다음 문자열 조합으로 사
용함.
mode • r : 읽기 모드 (디폴트)
• w : 쓰기 모드
• a : 쓰기 + 이어쓰기 모드 (append)
• r+ : 읽기와 쓰기를 모두 하고자 할 때
2
1. 파일 연결
 file open 후에 사용할 수 있는 메소드
read() - 파일 내용을 모두 읽어서 문자열(str)로 반환

read()
read(n) – 파일에서 n 바이트 읽어서 문자열(str)로 반환
읽기
readline() 한 줄씩 읽어서 문자열(str)로 반환한다.
readlines() 파일 전체를 리스트(list)로 반환한다.
write() 문자열을 파일에 저장한다.

쓰기
writelines() 문자열 리스트를 파일에 저장한다.
3
2. 파일 입력
 read()와 read(n)
f = open('newfile.txt', 'r')
a = f.read(4)
print(a)
b = f.read()
print(b)
f.close()
4
2. 파일 입력
 한 줄씩 읽어 오기 - readline()
f = open('about.txt', 'r')
a = f.readline()
print(a)
b = f.readline()
print(b)
f.close()
5
2. 파일 입력
 한 줄씩 읽어 오기 - for 구문 이용하기
for line in f:
print(line)
f.close()
6
2. 파일 입력
 readlines() - 파일 전체를 리스트(list)로 반환한다.
a = f.readlines()
print(a)
f.close()
7
2. 파일 입력
 파일 내용을 통째로 읽어 들여 한 줄씩 리스트에 저장 - 1

< 입력 파일 > 한 줄에 정수 한 개씩 저장되어 있음
< 출력 결과 >
f = open('score.txt', 'r') score = []

파일명
score = []
for line in f: with open('score.txt') as f:
score.append(int(line)) for line in f:
score.append(int(line))
print(score)
f.close() print(score) 8
f.close()
2. 파일 입력
 파일 내용을 통째로 읽어 들여 한 줄씩 사전에 저장 - 2

< 입력 파일 > 한 줄에 정수가 두 개씩 저장되어 있음 (사전으로 저장)
< 출력 결과 >
D = {}
with open('ban.txt') as f:
for line in f:
(key, val) = line.split()
D[int(key)] = val
for key, val in D.items():
print(key, val) 9
f.close()
2. 파일 입력
 파일 내용을 통째로 읽어 들여 한 줄씩 사전에 저장 - 3

< 입력 파일 > 첫 번째 자료는 키로, 나머지 자료는 값으로 하여 사전에 저장하고자 함.
D = {}
f = open('ban_student.txt', 'r')
for line in f:
items = line.split()
key, values = items[0], items[1:]
D[key] = values
print(D) 10
3. 파일 출력
 write() 예제
f = open("subject.txt", "w")
f.write('hello world')
f.write('python programming')
f.write('good bye')
f.close()
11
3. 파일 출력
 writelines() 예제
f = open("subject2.txt", "w")
f.writelines(['hello\n','world\n','python\n',
'programming','good','bye'])
f.close()
12
20. 클래스와 객체
1. 객체 (object)
2. 클래스 (class)
3. 연산자 중복
4. 클래스와 모듈
1. 객체 (object)
 파이썬에서 모든 데이터는 객체이다.

>>> a = 10; b = 3.5; c = 2+10j; d = True >>> L = [1,2,3]; type(L)
>>> type(a); type(b); type(c); type(d) <class 'list'>
<class 'int'> >>> T = (1,2,3); type(T)
<class 'float'> <class 'tuple'>
<class 'complex'> >>> S = 'hello'; type(S)
<class 'bool'> <class 'str'>
>>> A = {1,2,3}; type(A)
<class 'set'>
>>> D = {1:20, 2:25, 3:22}; type(D)
<class 'dict'>
2
1. 객체 (object)
 파이썬에서 모든 함수는 객체이다.
>>> def test():

>>> type(test)
<class 'function'>
>>> type(range)
<class 'type'>
>>> type(input)
<class 'builtin_function_or_method'>
>>> type(print)
<class 'builtin_function_or_method'>
3
2. 클래스
 클래스 (class)
 객체(object)를 만들기 위한 도구
 클래스를 이용하면 현실 세계의 모든 물체들을 객체로 만들 수 있다.
 클래스의 구성
속성 객체를 구성하는 데이터

메소드 속성에 대해 어떤 기능을 수행하는 함수
생성자, 소멸자 객체 생성과 소멸 시에 자동 호출되는 특별한 메소드
연산자 중복 연산자(+, - 등) 기호를 이용하여 표현할 수 있도록 함
생성자는 def __init__(self,…): 으로 정의함

소멸자는 def __del__(self,…): 으로 정의함
4
2. 클래스
 강아지를 클래스를 이용하여 객체로 표현하기

class Dog :
""" 강아지를 이름과 나이로 표현하는 클래스 """
""" 속성은 강아지 객체를 구성하는 데이터임. """
def __init__(self, name, age):

""" 강아지 객체를 생성하는 생성자 메소드 """
생성자
self.name = name
속성
self.age = age
def bark(self):
메소드 (method)
print(self.name, 'is barking')
5
2. 클래스
class Dog :

name : Jack
self.name = name x age : 3
self.age = age
def bark(self): name : Daisy

print(self.name, 'is barking') y
age : 2
x = Dog('Jack', 3)
y = Dog('Daisy', 2)
x.bark()
y.bark()
print(x.name, 'is', x.age, 'years old.')
print(y.name, 'is', y.age, 'years old.')
6
2. 클래스
 원(circle)을 클래스를 이용하여 객체로 표현하기

class circle :
c1 radius : 5
c1 = circle(5)
def __init__(self, radius): c2 = circle(10)
self.radius = radius
c2 radius : 10
def area(self):
a = 3.14 * pow(self.radius, 2) print('c1 area :', c1.area())
return a print('c1 perimeter : %.2f' % c1.perimeter())
def perimeter(self): print('c2 area :', c2.area())

p = 2 * 3.14 * self.radius print('c2 perimeter : %.2f' % c2.perimeter())
return p
7
2. 클래스
 list 클래스
>>> L1 = [1,3,5]
>>> dir(list)
>>> L2 = list([2,4,6])
['__add__', '__class__', '__contains__', '__delattr__',
'__delitem__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__',
'__getitem__', '__gt__', '__hash__', '__iadd__', >>> L1.append(7)
'__imul__', '__init__', '__iter__', '__le__', '__len__',
>>> print(L1)
'__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__reversed__', [1, 3, 5, 7]
'__rmul__', '__setattr__', '__setitem__', '__sizeof__',
'__str__', '__subclasshook__', 'append', 'clear', >>> L2.pop()
'copy', 'count', 'extend', 'index', 'insert', 'pop',
6
'remove', 'reverse', 'sort']
>>> print(L2)
[2, 4]
8
3. 연산자 중복
 int 클래스
>>> dir(int) >>> x = 10
['__abs__', '__add__', '__and__', '__bool__', '__ceil__',
'__class__', '__delattr__', '__dir__', '__divmod__', >>> y = int(20)
'__doc__', '__eq__', '__float__', '__floor__',
'__floordiv__', '__format__', '__ge__', >>> z = x.__add__(y) # z = x + y
'__getattribute__', '__getnewargs__', '__gt__',
'__hash__', '__index__', '__init__', '__int__', >>> print(z)
'__invert__', '__le__', '__lshift__', '__lt__', '__mod__',
30
'__mul__', '__ne__', '__neg__', '__new__', '__or__',
'__pos__', '__pow__', '__radd__', '__rand__', >>> p,q,r = 100,100,200
'__rdivmod__', '__reduce__', '__reduce_ex__',
'__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', >>> p.__eq__(q) # p == q
'__rmul__', '__ror__', '__round__', '__rpow__',
'__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', True
'__rxor__', '__setattr__', '__sizeof__', '__str__',
'__sub__', '__subclasshook__', '__truediv__', >>> p.__gt__(r) #p>q
'__trunc__', '__xor__', 'bit_length', 'conjugate',
'denominator', 'from_bytes', 'imag', 'numerator', False
'real', 'to_bytes']
9
3. 연산자 중복
 수치 연산자 메소드
메소드 연산자
__add__(self, other) +
__sub__(self, other) -
__mul__(self, other) *
__truediv__(self, other) /
__floordiv__(self, other) //
__mod__(self, other) %
__pow__(self, other[, modulo]) **
__gt__(self, other) >
__ge__(self, other) >=
__lt__(self, other) <
__le__(self, other) <=
__eq__(self, other) ==
10
__ne__(self, other) !=
3. 연산자 중복
 연산자 중복 예제 : 좌표 클래스 만들기
class Point:
def __init__(self, x=0, y=0):
p1 = Point(2,3)
self.x = x
p2 = Point(4,7)
self.y = y
p3 = p1 + p2
print(p1.get())
def get(self):
print(p2.get())
return "(" + str(self.x) + "," + str(self.y) + ")"
print(p3.get())
def __add__(self, other):
newX = self.x + other.x
newY = self.y + other.y
return Point(newX, newY)
11
4. 클래스와 모듈
 클래스가 저장된 파일을 모듈로 사용할 수 있다.

""" 나의 애완동물 클래스 """ from pet import Dog, Cat
class Dog : a = Dog('Jack', 3)

""" 강아지 클래스 """ b = Dog('Daisy', 2)
self.name = name c = Cat('Kitty', 'white')
self.age = age d = Cat('Molly', 'black')
def bark(self):
a.bark()
print(self.name, 'is barking')
b.bark()
class Cat :
""" 고양이 클래스 """ c.show_color()
def __init__(self, name, color): d.show_color()
self.name = name
self.color = color
def show_color(self):
print(self.name, 'is', self.color)
pet.py 12

파이썬 기초강의 서강대 ocw - sogang - ac - kr

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

파이썬 기초강의 서강대 ocw - sogang - ac - kr

Uploaded by

Copyright:

Available Formats

기초 PYTHON 프로그래밍

 소프트웨어 교육이 점점 중요해지는 이유는?

 컴퓨팅 사고력 (Computational Thinking)

 파이썬 언어의 문법을 익힌다.

 파이썬 언어를 이용하여 프로그래밍을 작성할 수 있도록 한다.

 프로그래밍 과정을 통해 기초적인 문제 해결 능력을 키운다.

 1991년, 귀도 반 로썸(Guido Van Rossum) 발표

 파이썬 언어를 사용하는 이유

프롬프트에서 명령을 치면 인터프리터가 명

 파일에 저장하여 실행하기

① IDLE 메뉴에서 File 선택

 파일에 저장하여 실행하기

 파일에 저장하여 실행하기

 데이터 영역과 객체(object)

키보드, 마우스 데이터 코드

 모든 객체는 자료형(data types)을 갖는다.

 모든 객체는 고유 id를 갖는다.

 객체를 저장한 공간을 변수(variable)라고 하고 변수명(variable

 변수명은 숫자로 시작할 수 없다.

 대소문자를 구분한다. 즉, data와 Data는 다른 변수이다.

 변수명은 한글도 가능하다.

 키워드(keyword)를 변수명으로 사용하면 안 된다.

< 파이썬 키워드 (33개) >

>>> 학생수 = 50 # 한글 변수명도 가능함

 del 을 이용하면 객체를 삭제할 수 있다.

>>> data = 100

 파이썬 자료형 (data types)

 부울 자료형 – bool (True / False)

 군집으로 다루는 자료형

>>> data = 1.5

>>> a = True >>> x = 1

>>> name = 'Alice' # 홑따옴표

>>> language = '''python''' # 홑따옴표 세 개

>>> w = """Python is widely used""" # 쌍따옴표 세 개

 리스트 (list) – 대괄호 [] 로 표현한다.

>>> scores = [80, 90, 85, 93, 78]

>>> data = (3,6,5,9)

>>> type(data) data 3 6 5 9

>>> primes = {7,17,3,5,7,19}

 예) 1반 35명, 2반 32명, 3반 30명, 4반 33명의 학생들이 있다면

 프로그램에 설명을 넣을 때 주석을 사용함

print('what is your name?') # 이름 물어보기

 여러 줄 주석 – 홑따옴표 세 개 또는 쌍따옴표 세 개를 사용함

""" …… """ – 쌍따옴표 3개로 작성한 부분을 docstring 이라고 한다.

>>> id(x) x 100

 정수 객체는 immutable 하다.

 정수 자료형은 크기 제한이 없다.

>>> 2 ** 1024 # 2의 1024제곱

a=a-b a -= b >>> a += c # a가 32가 됨

a=a/b a /= b >>> a //= 3 # a가 10이됨

 과학적 표기 방법 (scientific notation)

 실수는 저장할 때 약간의 문제를 일으킬 수도 있다.

>>> x = 1.5 >>> 0.1 + 0.1

>>> x = 2.0 >>> 0.2 + 0.1

 정수와 실수 자료형을 같이 연산하면 결과는 실수가 된다.

 복소수 표현하기 (허수부에 j 또는 J를 붙인다)

 실수, 문자 → 정수로 변환하기 : int() 내장함수

 정수, 문자 → 실수로 변환하기 : float() 내장함수

 모듈 – 연관된 함수들을 모아서 모듈로 관리한다

 문자열 객체는 따옴표를 이용하여 생성한다.

 홑따옴표 세 개(''' … ''')

 쌍따옴표 세 개(""" … """)

>>> s = 'Python is great!'