파이썬 한 눈에 보기

*본 내용은 KAIST 김문주 교수님의 [처음 배우는 프로그래밍(w.파이썬] 강의를 보고 공부하면서 요점 정리한 내용입니다.

⚫ 주석처리

# 샵을 이용해 주석처리를 할 수 있습니다.

⚫ 키보드 입력

• input 함수는 메시지를 출력하고, 키보드를 통한 사용자의 문자열 입력을 기다립니다.
  사용자가 Enter키를 입력하면 사용자가 입력한 전체 문자열이 반환됩니다.
• input 함수는 늘 문자열만 반환하므로 숫자 입력이 필요하다면 문자열을 숫자로 변환해야 합니다.

name = input("What is your name? ")
print("Welcome to CS101, " + name)

raw_n = input("Enter a positive integer> ")
n = int(raw_n)
for i in range(n):
	print("*" * i)

⚫ 객체

• 파이썬 프로그램에서 사용하는 각각의 데이터는 객체(Object)라 부릅니다.
• 모든 객체는 형태(Type)을 가지고 있습니다.
• 형태는 객체를 이용해 할 수 있는 일을 결정합니다.
• 하나의 객체는 여러 이름을 가질 수 있습니다.

▶ 객체 만드는 방법

• 숫자: 숫자 그대로 적습니다.
• 문자열: 문자열을 따옴표(",')사이에 적습니다.
• 논리값(Boolean): True 또는 False로 적습니다.

▶ 복잡한 객체 생성

• 복잡한 객체는 그 객체를 만드는 함수를 부르는 방법으로 만듭니다.

from cs1robots import *
Robot()

▶ 형태

• 모든 객체는 형태(Type)을 가지고 있습니다.
• 형태는 객체를 이용해 할 수 있는 일을 결정합니다.

• 정수: int
  실수: float
  문자열: str
  복소수: complex
  논리값: bool

• 파이썬에서는 다음과 같은 방법으로 객체가 어떤 형태를 가지고 있는지 알 수 있습니다.

>>>type(3)
<class 'int'>

>>>type(Robot())
<class 'cs1robots.Robot'>

▶ 대입문 (Assignment)

객체이름(변수) = 실제객체(값)

a = 3

▶ 변수/함수 이름 짓기 규칙

• 영어 문자, 숫자, 그리고 밑줄 문자(_)로만 이루어져야 합니다.
• 숫자는 이름의 첫 글자로 올 수 없습니다.
• 파이썬에서 등록된 키워드(예약어)와 동일한 이름은 지을 수 없습니다.
  (예. def, if, else, while)
• 이름은 대소문자를 구분합니다.

▶ 멤버 변수

• 객체가 할 수 있는 일은 객체의 형태에 따라 결정됩니다.
• 객체는 멤버 함수(Method)를 통해 이러한 일들을 할 수 있습니다.
• 멤버 함수는 점(.)연산자를 통해 실행할 수 있습니다.

>>>hubo = Robot()
>>>hubo.move()

▶ None 객체

• None이라는 이름의 특별한 객체는 비었다는 것을 의미하기 위해 사용됩니다.

n = None

>>> type(n)
<class 'None Type'>

◆ 튜플

• 튜플(Tuple)은 다른 객체들을 포함하는 객체입니다.
• 여러 객체들을 쉼표(,)를 사이에 두고 적어서 만들 수 있습니다.
• 튜플이 포함하는 객체의 type은 달라도 무관합니다.

a = (2012, "Kim")

• 튜플이 포함하는 객체들은 풀 수 있습니다.

>>> a, b = ("aa", "bb")
>>> a, b = b, a
>>> print(b)
aa

▶ 튜플 자르기

• 튜플의 특정 부분을 잘라내서 새로운 튜플로 만들 수 있습니다(slicing)

subtuple = mytuple[i;j]
list2 = list1[:]	# 튜플 복사하기

• subtuple은 mytuple의 인덱스 i, i+1, ... , j-1에 해당하는 원소를 포함한 튜플입니다.

• i 를 생략하면, subtuple은 mytuple의 첫 번째 원소부터 가지게 됩니다.
  j 를 생략하면, subtuple은 mytuple의 마지막 원소까지 가지게 됩니다.

◆ 리스트

• 리스트는 list 타입의 객체입니다.
• 리스트의 각 원소는 위치 값을 사용해서 접근할 수 있습니다.
• 음수 위치를 사용하면 리스트의 끝에서부터 접근할 수 있습니다.
• 빈 리스트는 []로 표기할 수 있습니다. 빈 리스트의 길이는 0입니다.
• 하나의 리스트는 여러 다른 종류의 객체를 담을 수도 있습니다.

>>> countries = [ "Australia", "South Korea" , "United States" ]
>>> gold = []

>>> countries[0]
＇Australia＇
>>> countries[-1]
'United States'
>>> countries[-2]
'South Korea'

>>> korea = [ "Korea", 'KR', (3, 3, 2) ]

• 리스트는 가변 객체입니다.

>>> nobles = [ 'helium', 'none', 'argon', 'krypton',
'xenon' ]

>>> nobles[1] = "neon"	# 원소 변경

>>> nobles
['helium', 'neon', 'argon', 'krypton', 'xenon']

>>> nobles.append('radon')	# 원소 추가

>>> nobles
['helium', 'neon', 'argon', 'krypton', 'xenon',
'radon']

• 하나의 객체는 여러 이름을 가질 수 있습니다. 이를 Aliasing이라 부릅니다.

# 하나의 객체가 여러 이름 갖는 경우
>>> list1 = ["A","B","C"]
>>> list2 = list1
>>> len(list1)
3
>>> list2.append("D")
>>> len(list1)
4
>>> list1[1] = "X"
>>> list2
['A', 'X', 'C', 'D']
>>> list1 is list2
True

# 두 객체를 따로 갖는 경우
>>> list1 = ["A","B","C"]
>>> list2 = ["A","B","C"]
>>> len(list1)
3
>>> list2.append("D")
>>> len(list1)
3
>>> list1[1] = "X"
>>> list2
['A', 'B', 'C', 'D']
>>> list1 is list2
False

▶ 리스트와 관련된 내장 함수들

• len은 리스트의 길이를 반환합니다.
• sum은 리스트의 각 원소의 합을 반환합니다.
• max는 리스트에서 가장 큰 원소를, min은 가장 작은 원소를 반환합니다.

>>> len(countries)

▶ 리스트 탐색하기

• 반복문을 이용해 리스트의 각 원소를 탐색할 수 있습니다.
• 함수 range는 range 타입의 객체를 만들어주는 함수입니다.

for country in countries:
	print(country)
    
for medals, country in top_ten:
	print(medals, country)    
    
>>> range(10)
range(0, 10)
>>> type(range(10))
<class 'range'>

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(10, 15))
[10, 11, 12, 13, 14]

>>> l = list(range(1, 11))
>>> for i in range(len(l)):
... l[i] = l[i] ** 2
>>> l
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

▶ 리스트의 멤버 함수

• 리스트 객체 L은 다음과 같은 멤버 함수들을 가지고 있습니다.

• L.append(v): v 객체를 리스트 끝에 추가
• L.insert(i, v): 객체를 리스트의 i번째 위치에 추가
• L.pop(): 리스트의 마지막 원소를 삭제하고, 그 값을 반환
• L.pop(i): i번째 원소를 삭제하고, 그 값을 반환
• L.remove(v): v와 일치하는 첫 번째 원소를 삭제
• L.index(v): v와 일치하는 첫 번째 원소의 위치를 반환
• L.count(v): v와 일치하는 원소들의 개수를 반환
• L.extend(K): K의 모든 원소를 리스트 L 끝에 추가
• L.reverse(): 리스트의 모든 원소를 역순으로 재배열
• L.sort(): 리스트 정렬

▶ 리스트 자르기

• 리스트의 특정 부분을 잘라내서 새로운 리스트로 만들 수 있습니다(slicing)

sublist = mylist[i;j]
list2 = list1[:]	# 리스트 복사하기

• sublist는 mylist의 인덱스 i, i+1, ... , j-1에 해당하는 원소를 포함한 리스트입니다.

• i 를 생략하면, sublist는 mylist의 첫 번째 원소부터 가지게 됩니다.
  j 를 생략하면, sublist는 mylist의 마지막 원소까지 가지게 됩니다.

◆ 문자열

• 문자열은 시퀀스입니다.
• 문자열은 불변 객체입니다.
• 문자열에는 in 연산자를 사용할 수 있습니다.
• 리스트와 튜플에서는 in 연산자가 리스트/튜플의 원소를 대상으로 하지만, 문자열에서는 부분 문자열을 대상으로 합니다.

>>> "abc" in "01234abcdefg"
True
>>> "abce" in "01234abcdefg"
False

▶ 문자열 서식화

• 문자열을 출력할 때 여러 변수의 값을 이용해야 하는 경우가 있습니다.
• 문자열 포맷 연산자 %를 사용하면 더 쉽고 간단하게 문자열을 출력할 수 있습니다.
• 하나의 문자열 포맷 코드만 사용하는 데는 튜플을 쓰지 않아도 됩니다.

print("Max between " + str(x0) + " and " +
str(x1) + " is " + str(val))

print("Max between %d and %d is %g" % (x0, x1, val))
print("Maximum is %g" % val)

# 포맷 연산자 사용 방법
format_string % (arg0, arg1, .... )

• 자료형에 따라 다른 문자열 포맷코드를 사용합니다.
  %d: 10진법 정수
  %g: 실수
  %.2f: 소수점 자리수가 설정된 실수(이 경우는 소숫점 둘째 자리까지)
  %s: 모든 자료형(문자열 등)

• 각 문자열 포맷 코드가 나타낼 문자열이 차지하는 영역의 크기를 설정할 수 있습니다.

>>> print("%3d~%3d:%10g" % (x0, x1, x2))

▶ 문자열의 멤버 함수

• upper(), lower(), capitalize(): 소문자 → 대문자, 대문자 → 소문자, 첫 글자 대문자로 변환
• isalpha(), isdigit(): 전부 알파벳인지, 숫자인지
• startswith(prefix), endswith(suffix): prefix로 시작하는지, suffix로 끝나는지
• find(str1), find(str1, start), find(str1, start, end): 문자열 안에 str1이 나타나는 첫 위치 반환, start 위치의 인덱스부터 검색, start부터 end 사이의 인덱스에서 검색, 없으면 -1을 return한다.
• replace(str1, str2): 문자열 치환
• rstrip(), lstrip(), strip(): 오른쪽, 왼쪽, 양옆 공백을 제거
• split(), split(sep): 공백 문자로 분리된, sep 기준으로 분리된 단어들을 포함한 리스트 생성
• join(list1): a.join(b) b에 있는 각각의 문자들 사이에 a를 넣음
  예) s1 = "1234", s2 = "abc"
  s1.join(s2) → "a1234b1234c"

◆ 시퀀스

• 리스트, 문자열, 튜플은 시퀀스(Sequence)의 한 종류입니다.
• 시퀀스: 각각의 요소들이 연속적으로 이어진 것

▶ 리스트 vs 튜플, 문자열

• 리스트는 가변 객체지만, 튜플과 문자열은 불변 객체입니다.

>>> t = ("CS101", "A+", 13)
>>> t[0] = "CS206"
TypeError: 'tuple' object does not support item assignment

▶ list, tuple 형변환 함수

>>> list(t)
['CS101', 'A+', 13]
>>> tuple(gold)
(0, 4, 5, 10, 3, 0, 2, 1, 4, ..., 2, 6, 1, 9)
>>> list("CS101")
['C', 'S', '1', '0', '1']

◆ 집합

• 집합(Set)은 수학의 집합과 관련된 자료들을 쉽게 처리하기 위한 자료구조입니다.
• 집합은 원소의 순서가 중요하지 않고 똑같은 원소가 두 번 들어갈 수 없습니다.
• 집합은 중괄호{}나 set()함수를 이용해서 만들 수 있습니다.
• 주의) {}는 비어있는 사전을 만드는 방법이고 공집합을 만들기 위해선 set()함수를 사용해야 합니다.

>>> odds = {1, 3, 5, 7, 9}
>>> emptyset = set() # {} creates an empty dictionary

>>> odds
{9, 3, 5, 1, 7}
>>> emptyset
set()

• 집합의 원소에는 순서가 없기 때문에 원소의 위치를 특정할 수 없습니다.
  하지만, in 연산자는 사용할 수 있습니다.

>>> odds[1]
TypeError: 'set' object does not support indexing

>>> 2 in odds
False
>>> for num in odds:
... print(num)
9
3
5
1
7

▶ 형변환 함수

• 리스트, 문자열은 집합으로 변환할 수 있습니다.

>>> gold = [10, 3, 6]
>>> gold
[10, 3, 6]

>>> goldset = set(gold)

>>> goldset
{3, 6, 10}
>>> type(goldset)
<class 'set'>

>>> set("Good morning!")
{'G', 'm', 'i', 'd', 'o', '!', 'g', 'n', 'r', ' '}

▶ 집합의 멤버 함수

• s.add(v): 원소 v를 집합 s에 추가한다.
• s.remove(v): 원소 v를 집합 s에서 제거한다.
• s.pop(): 무작위 원소를 집합 s에서 제거하고 그 원소를 반환한다.
• s.intersection(k): 집합 s, k의 공통 원소를 반환한다. ($s ∩ 𝑘$)
• s.union(k): 집합 s, k의 합집합을 반환한다. ($s ∪ 𝑘$)
• s.difference(k): 집합 k에 있는 원소들을 s에서 제거한다. ($s ∩ 𝑘^𝑐$)

◆ 사전

• 사전(Dictionary)은 리스트나 집합처럼 여러 객체를 모아서 만든 객체입니다.
• 다른 자료 구조와의 큰 차이점은 다양한 종류의 불변 객체를 사용해서 자료에 접근할 수 있다는 점입니다. (예. 숫자, 문자열을 사용해서 자료에 접근이 가능)
• 사전에서 사용되는 인덱스는 키(key)라고 부르고, 키가 가리키는 대상 객체는 값(value)이라고 부릅니다. 키와 값의 쌍을 key-value pair라 합니다.
• 사전은 중괄호{}나 dict() 함수를 이용해서 만들 수 있습니다.

majors = {"CS": "Computer Science",
		"EE": "Electrical Engineering",
		"MAS": "Mathematical Sciences",
		"ME": "Mechanical Engineering"}
        
d1 = dict() # an empty dictionary
d2 = {} # an empty dictionary

• 사전의 원소들에는 순서가 없습니다. 사전의 원소에는 키로만 접근할 수 있습니다.

>>>majors[0]
KeyError: 0

• 사전에 새로운 키와 값을 넣을 수 있고, 키가 가리키는 값을 바꿀 수도 있습니다.

>>> majors["PH"] = "Physic"
>>> majors["PH"]
'Physic'

>>> majors["PH"] = "Physics"
>>> majors["PH"]
'Physics'

▶ 사전 관련 함수들

• len(d): d의 원소의 수를 반환한다.
• key in d: d가 key를 가지고 있으면 True를, 아니면 False를 반환한다.
• d.get(key, default=None): d에서 key가 가리키는 값을 반환한다.
  d가 key를 가지고 있지 않으면 default 값을 반환한다.
• d.keys(): d의 모든 key 객체 목록을 반환한다.
• d.values(): d의 모든 value 객체 목록을 반환한다.
• d.items(): d의 모든 key-value pair 목록을 반환한다.
• del d[key]: key에 해당하는 key-value pair를 사전 d에서 제거한다.

• 주의) keys(), values(), items()로 반환되는 객체는 리스트 객체가 아닙니다.
  이 객체들은 리스트처럼 원소들을 가지고 있지만, 객체를 변경할 수는 없습니다.
  (예. append()와 같이 원소를 추가할 수 없습니다.)

▶ 사전과 반복문

• 반복문과 in 연산자를 사용하면, 사전의 키들에 해당하는 값들을 찾을 수 있습니다.
• 반복문과 items() 함수를 사용하면 key-value pair들을 찾을 수 있습니다.
• 다음 예시는 서로 같은 역할을 합니다.

>>> for key in majors:
... print(＂%s is %s.＂ % (key, majors[key]))
CS is Computer Science.
PH is Physics.
ME is Mechanical Engineering.
EE is Electrical Engineering.
MAS is Mathematical Sciences.


>>> for key, value in majors.items():
... print("%s is %s." % (key, value))
CS is Computer Science.
PH is Physics.
ME is Mechanical Engineering.
EE is Electrical Engineering.
MAS is Mathematical Sciences.

◆ 리스트, 집합, 사전

• 언제 어떤 자료 구조를 사용하면 좋을까요?

• 순서가 있는 객체를 다룰 때 → 리스트 자료 구조
• 순서가 없는 객체를 다룰 때 → 집합 자료 구조
• 키를 통해 키가 가리키는 값을 쉽게 찾고 싶을 때 → 사전 자료 구조

• 참고) 리스트보다 집합에서 원소의 포함 여부를 더 빠르게 계산할 수 있습니다.

◆ 클래스

▶ 객체 (Object)

• 객체는 속성(Attribute)을 가집니다.
• 클래스로 만든 객체는 가변 객체입니다.
• 객체는 상태(State)를 가지고 있고, 동작(Action)을 수행할 수 있습니다.

class Card(object):
	""" A Blackjack card."""	# class comment: class 전체에 대한 설명을 적어줌
    pass	# 안에 내용들을 작성하지 않고 가장 간단하게 정의해줌
    
# Card 객체 생성하기
c = Card()
# card의 속성 설정하기
c.face = "Ace"
c.suit = "Spades"
c.value = 11

# c 객체의 형태는 사용자가 정의한 Card입니다.
>>> type(c)
<class '__main__.Card'>

• 함수 역시 객체입니다. 함수의 인자로 함수를 사용할 수 있습니다.

>>> def f(x): 	# 함수 정의하기
... return math.sin(x / 3.0 + math.pi/4.0)
>>> print(f)	#함수 자체 출력
<function f at 0xb7539a3c>
>>> print(type(f))	# 함수 타입 출력
<class 'function'>

#함수의 인자로 함수 사용
def print_table(func, x0, x1, step): 
	x = x0
	while x <= x1:
		print(x, func(x))
		x += step
print_table(f, -math.pi, 3 * math.pi, math.pi/8)

▶ 멤버 함수

• self 는 객체의 멤버 함수에서 객체 자신을 가리킵니다.
• 모든 멤버 함수는 첫번째 인자로 self를 받는다.
• 특별한 멤버 함수는 __로 시작한다.

class Card(object):
	"""A Blackjack card."""
	def value(self): # method of Card
		if type(self.face) == int:
			return self.face
		elif self.face == "Ace":
			return 11
		else:
			return 10

>>> card1 = Card()
>>> card1.face = "Ace"
>>> card1.suit = "Spades"
>>> card1.value()
11

▶ 생성자

• 객체는 __init__이라는 특별한 멤버 함수를 가지고 있습니다. 이 멤버 함수는 생성자(Constructor) 라고 불립니다.
• 객체가 생성될 때 생성자는 자동으로 호출됩니다

# face가 가능한 모든 값들
FACES = list(range(2, 11)) + ['Jack', 'Queen', 'King', 'Ace']
# suit가 가능한 모든 값들
SUITS = ['Clubs', 'Diamonds', 'Hearts', 'Spades']


Class Card(object):
	"""A Blackjack card."""
	def __init__(self, face, suit):
   		# 사용자가 넣은 입력이 잘못된 것인지 검사
		assert face in FACES and suit in SUITS
		self.face = face
		self.suit = suit
        
#이제 Card 객체를 훨씬 간단하게 만들 수 있습니다.
card1 = Card("Ace", "Spades")

▶ 문자열 반환

• 카드 내용을 문자열로 바꾸는 방법이 있습니다. str(card) 는 card의 특별한 멤버 함수 str 를 호출합니다.

class Card(object):
	"""A Blackjack card."""
	"""Already defined init and value methods"""
	def __str__(self):
		article = "a "
		if self.face in [8, "Ace"]:
			article = "an "
		return (article + str(self.face) + " of" + self.suit)

# 이제 다음처럼 카드 내용을 출력할 수 있습니다.
# print 함수는 인자 card 를 __str__를 사용해서 자동으로 문자열 형태로 바꿉니다.
>>> for card in hand:
... print(card, "has value", card.value())

▶ 객체 비교

# 객체에서 비교 연산자 (==, !=, < 등)를 사용하면 예상과 다른 결과가 나올 수 있습니다.
>>> Card(8, "Diamonds") == Card(9, "Diamonds")
False
>>> Card(8, "Diamonds") == Card(8, "Diamonds")
False

# 사용자의 생각대로 비교 연산자를 통해 객체를 비교하기 위해서는 다음과 같이 정의를
해야 합니다.
class Card(object):
	"""A Blackjack card."""
	"""Already defined other methods"""
	def __eq__(self, rhs): # rhs는 right hand side 의미
		return (self.face == rhs.face and self.suit == rhs.suit)
	def __ne__(self, rhs):
		return not self == rhs
        
# __ne__함수를 정의해주지 않으면 
>>> Card(8, "Diamonds") == Card(8, "Diamonds")
True
>>> Card(8, "Diamonds") != Card(8, "Diamonds")
Ture 	# 의도와 다른 결과

⚫ 연산자

▶ 숫자 연산자

• +, -, *, /(나눗셈), //(정수 나눗셈), %(나머지), **(거듭제곱)

>>>9/7
1.2857142857142858

>>>9//7
1

▶ 문자열 연산자

• +, *

>>> "Hello" + "World"
'HelloWorld'

>>> "Hello" * 3
'HelloHelloHello'

▶ 비교 연산자

• ==, !=, >, <, <=, >=
• 문자열은 사전식 순서를 기준으로 적용된다.

>>>"Apple" < "Banana"
True

▶ 논리 연산자

• not, and, or
• 주의) 만약 논리 연산자 왼쪽 값으로 연산의 결과가 결정된다면 파이썬은 논리 연산자 오른쪽 값을 계산하지 않습니다.
  (False and ... 또는 True or ...)

(not True) == False
(not False) == True

(False and False) == False
(False and True) == False
(True and False) == False
(True and True) == True

(False of False) == False
(False of True) == True
(True of False) == True
(True of True) == True

⚫ 반복문

▶ for 반복문

for i in range(4):
	print("Hello World")

▶ while 반복문

while 조건문:
	print("Hello World")

▶ break

• break 키워드는 현재 실행중인 반복문을 중지하고 빠져나옵니다.
• break를 사용하면 가장 안쪽의 반복문만 빠져나옵니다.

▶ continue

• continue 키워드는 현재 실행중인 반복을 건너뜁니다.

⚫ 조건문

if True:
	print("It is true")		// 출력됨
if False:
	print("It is false")	// 출력되지 않음
    
if a>b:
	print("a가 b보다 큽니다.")

elif a==b:
	print("a와 b가 같습니다.")

else:
	print("b가 a보다 큽니다.")

⚫ 함수

• 함수의 인자들을 가리키는 변수들을 매개 변수(Parameter)라고 부릅니다.
  함수의 인자는 매개 변수에 하나씩 왼쪽부터 대입됩니다.
• 반환문이 없는 함수(return이 없는 함수)는 자동으로 None을 반환합니다.

def 함수이름(인자) :
	함수 내용
    return 결과

def to_radians(deg):
	return (deg / 180.0) * math.pi

▶ 여러 값 반환하기

• 함수는 하나의 값만 반환할 수 있습니다. 하지만 함수는 튜플을 반환할 수도 있습니다. 파이썬은 함수가 여러 값을 반환할 때 자동으로 이 값들을 튜플로 만들어 반환합니다.

def student():
	name = "Hong, Gildong"
	id = 20101234
	return name, id

>>> name, id = student()
>>> print(name)
"Hong, Gildong"
>>> print(id)
20101234

▶ 매개 변수의 대상

def swap(a, b):
	a, b = b, a
    
x, y = 123, 456
swap(x, y)
print (x, y) // 바뀌지 않고 123, 456 출력됨

• a는 변수 x를 가리키는 이름이 아니라 객체 123의 새로운 이름이다.

▶ 매개 변수의 기본값

• 함수의 매개 변수에는 기본값을 설정할 수 있습니다.
• 기본값을 가지는 매개 변수는 다른 매개 변수의 뒤에 와야 합니다.

def create_sun(radius = 30, color = "yellow"):
	sun = Circle(radius)
	sun.setFillColor(color)
    sun.setBorderColor(color)
    sun.moveTo(100, 100)
    return sun

moon = create_sun(28, "silver")
star = create_sun(2) # create_sun(2, "yellow")과 동일
sun = create_sun() # create_sun(30,"yellow")과 동일

def f1(x, y=0): # 옳은 함수 정의
	return x+y
Def f2(x=0, y): # 틀린 함수 정의
	return x+y

▶ 이름이 있는 인자

• 함수를 부를 때 인자에 이름을 붙여서 부를 수 있습니다.
• 함수를 부를 때 인자의 순서를 고려하지 않아도 됩니다.

moon = create_sun(color = "silver")
moon = create_sun(color = "silver", radius = 28)

>>> avg(d, end=3)
5.0
>>> avg(data=d, end=3)
5.0
>>> avg(end=3, data=d)
5.0
>>> avg(end=3, d)
SyntaxError: non-keyword arg after keyword arg

▶ 유용한 함수 - 형 변환 함수

>>> int("32")
32
>>> int(17.3)
17
>>> float(17)
17.0
>>> float("3.1415")
3.1415
>>> str(17) + " " + str(3.1415)
'17 3.1415'
>>> complex(17)
(17 + 0j)

▶ 유용한 함수 - 수학 함수

import math
sin = math.sin
pi = math.pi
radians = degrees / 360.0 * 2 * pi
print(sin(radians))

◆ 지역 변수와 전역 변수

▶ 지역 변수

• 지역 변수(local variable)는 함수 안에서만 사용할 수 있는 변수입니다.
• 함수의 매개 변수 또한 지역변수입니다.

▶ 전역 변수

• 함수 밖에서 정의된 변수들은 전역 변수(global variable)라 부릅니다.
• 전역 변수는 어느 함수에서나 사용할 수 있기 때문에 실수를 일으키기 쉽습니다. 이 때문에 큰 프로그램일수록 전역 변수를 조심해서 사용해야 합니다.

▶ 지역 변수와 전역 변수

• 함수 안에서 값을 읽기만 하는 변수는 전역 변수로 파이썬이 추론합니다.

def f1():
	return 3 * a + 5

• 함수 안에서 값을 쓰는(write) 변수는 지역 변수로 파이썬이 추론합니다.

def f2(x):
	a = 3 * x + 17
	return a * 3 + 5 * a

• 오류 발생 상황
  변수 a는 test 함수 안에서 값을 썼기(write) 때문에 지역 변수지만, 첫 번째 print문이 불린 시점에서 지역 변수 값이 정의되지 않았기 때문에 오류가 발생합니다.

a = 17
def test():
    print(a) # a는 전역 변수로 판단
    a = 13
    print(a) # a는 지역 변수로 판단
test()

• 전역 변수의 값을 바꿔야 할 때 → global 이용

def turn_left():
    hubo.turn_left()
    global hubo_direction
    hubo_direction += 90

a = "Letter a"	# 전역 변수

def f(a):	# 지역 변수(매개 변수)
	print("A = ", a)
    
def g():
	a = 7	# 지역 변수
    f(a+1)
    print("A = ", a)
    
print("A = ", a)	# Letter a 출력
f(3.14)				# 3.14 출력
print("A = ", a)	# Letter a 출력
g()					# 8  7 출력
print("A = ", a)	# Letter a 출력

⚫ 모듈

• 파이썬의 모듈은 여러 함수들을 묶어서 파일로 만든 것입니다.
• 새로운 모듈을 직접 만들 수도 있습니다.

▶ 파이썬의 모듈들

• math 모듈: 수학적 함수들을 제공합니다.
• random 모듈: 난수, 무작위 섞기 등의 함수들을 제공합니다.
• sys와 os 모듈: 운영체제와 관련된 함수들을 제공합니다.
• urllib 모듈: 웹에서 파일을 다운받는 함수들을 제공합니다.
• cs1robots 모듈: 휴보에 관련된 함수들을 제공합니다.
• cs1graphics 모듈: 그래픽과 관련된 함수들을 제공합니다.
• cs1media 모듈: 사진의 처리와 관련된 함수들을 제공합니다.

• 모듈의 정보는 help 함수를 이용해서 볼 수 있습니다.

>>> help("cs1media")

▶ 모듈 들여오기

• 모듈을 사용하려면 import를 이용해 모듈을 들여와야 합니다.
• 여러 모듈을 불러올 때 이름이 같은 함수의 충돌을 막기 위해 일반적으로 import * 는 사용하지 않는 것이 좋습니다.

import math
print(math.sin(math.pi))

# 모듈 이름 붙이지 않고 사용하기
from math import *
print(sin(pi)) # OK
print(math.pi) # NameError: name 'math'

# 필요한 함수만 들여오기
from math import sin
print(sin(3.14)) # OK
print(pi) # NameError: name ‘pi'
print(cos(3.14)) # NameError: name 'cos‘
print(math.cos(3.14)) # NameError: name 'math'

⚫ 버블 정렬

• 리스트 a의 원소들을 크기 순으로 정렬

def bubbleSort(a):
	sorted = False
	while(not sorted):
		sorted = True
		for i in range(1,len(a)):
			if(a[i-1] > a[i]):
				a[i-1],a[i]=a[i],a[i-1]
				sorted = False

⚫ 파일 읽고 쓰기

▶ 파일 읽기

planets.txt 파일

Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

• f는 파일의 내용이 아니라 파일 객체입니다. (type: <class ‘_io.TextIOWrapper’>)

>>> f = open("planets.txt", "r")
>>> s = f.readline()
>>> s, len(s)
('Mercury\n', 8)

• 파일 객체에 for 반복문을 사용하면 반복할 때마다 readline() 함수를 실행합니다. 반복문은 파일의 마지막 줄을 읽은 후에 종료됩니다.

• 파일 객체의 사용이 끝나면 f.close()함수를 실행해야 합니다.

• 파일에서 읽어온 문자열 앞뒤의 공백 문자(줄 바꿈 문자, 띄어쓰기 등)를 제거하기 위해서 strip(), rstrip()함수를 사용합니다.
  print()문에 end=" " 인자를 추가하면 문자열을 출력한 후 줄을 바꾸는 대신 한 칸을 띄어 쓸 수 있습니다.

>>> for l in f: # 파일 내용을 한 줄씩 읽는다.
... s = l.strip()
... print(s, end=" ")
Venus Earth Mars Jupiter Saturn Uranus Neptune

• 다음은 파일 전체의 내용을 읽어 리스트에 저장하는 프로그램입니다.

planets = []
f = open("planets.txt", "r")
for line in f:
	planets.append(line.strip()) # strip() 통해 개행문자 제거
f.close()
print(planets)

파일 객체는 위와 비슷한 일을 하는 멤버 함수를 가지고 있습니다. (하지만 이 함수는 공백 문자를 따로 제거하지는 않습니다.)

planets = f.readlines()

▶ 파일 쓰기

• 파일을 쓰기 위해서는 "w" 모드를 사용해야 합니다.
• 파일 객체에는 파일에 내용을 쓰기 위한 write(text)멤버 함수가 있습니다.
• print()와는 달리, write() 함수는 text 내용 출력 후 자동으로 줄을 바꾸거나 공백문자를 넣지 않습니다. 줄을 바꾸고 싶다면 개행 문자 '\n'을 추가로 출력해야 합니다.
• 파일 사용이 끝나면 close()를 호출해야 합니다. (호출하지 않으면 파일이 불완전하게 저장될 수 있습니다)

f = open("./test.txt", "w")
f.write("CS101 is fantastic\n")
f.close()