추상화

# 파이선 등호 : 지정연산자 (오른쪽 값을 왼쪽 변수에 지정)

 

 

 

 

 

 

# 함수의 실행 순서

# example 1
def hello():
    print("Hello!")
    print("Welcome to Codeit!")

print("함수 호출 전")
hello()
print("함수 호출 후")

print()

# example 2
def square(x):
    return x * x

print('함수 호출 전')
print(square(3) + square(4))
print('함수 호출 후')

 

 

 

 

 

 

# return 복습

 

return문 

• 함수가 무언가(어떤 값)를 돌려줌
• 함수 즉시 종료시킴

def square(x):
    print('함수 시작')
    return x * x
    print('함수 끝') # Dead Code (의미 없는 코드) 함수가 return 문에서 끝나기 때문

print(square(3))
print('Hello World')

 

 

 

 

 

 

# return VS print

def print_square(x): #print_square 함수에는 retrun 문 작성 X
    print(x * x)

def get_square(x):
    return x * x 

print_square(3) # 9 출력
get_square(3) # 함수 호출 부분이 9로 대체만 되었을 뿐 출력하라는 명령 없음 : 출력  X

print(get_square(3)) # 9 출력
print(print_square(3))
# 1. print_sqaure(3) 호출 : 9 출력
# 2. print_square(3) 부분이 None 으로 대체됨 : None 출력

# 파이썬에서는 return 문이 따로 없으면 return 값이 따로 없다는 의미에서 None 이라는 값이 return 됨

 

 

 

 

 

 

# 옵셔널 파라미터 (optional parameter)

• 파라미터에게 '기본값(default value)' 설정 가능
• 기본값을 설정해 두면, 함수를 호출할 때 꼭 파라미터에 값을 안 넘겨 줘도 됨 --> 옵셔널 파라미터 (optional parameter)

def myself1(name, age, nationality="한국"):
    print("내 이름은 {}" .format(name))
    print("나이는 {}" .format(age))
    print("국적은 {}" .format(nationality))

myself1("코드잇", 1, "미국")
print()
myself1("코드잇", 1)
print()


# f-string 사용
def myself2(name, age, nationality = "한국"):
    print(f"내 이름은 {name}")
    print(f"나이는 {age}")
    print(f"국적은 {nationality}")

myself2("코드잇", "1", "미국")
print()
myself2("코드잇", "1")

 

 

옵셔널 파라미터는 모두 마지막에 있어야 함. 아래처럼 중간에 넣으면 error

def myself(name, nationality="한국", age):
    print("내 이름은 {}" .format(name))
    print("나이는 {}" .format(age))
    print("국적은 {}" .format(nationality))

myself("코드잇", 1, "미국")
print()
myself("코드잇", 1)

 

 

 

 

 

 

# Syntatic Sugar : 자주 쓰이는 표현을 더 간략하게 쓸 수 있게 해주는 문법

# 다음 두 줄 같음
x = x + 1
x += 1

# 다음 두 줄 같음
x = x + 2
x += 2

# 다음 두 줄 같음
x = x * 2
x *= 2

# 다음 두 줄 같음
x = x - 3
x -= 3

# 다음 두 줄 같음
x = x / 2
x /= 2

# 다음 두 줄 같음
x = x % 5
x %= 5

 

 

 

 

 

 

# scope : 변수가 사용 가능한 범위

• 로컬 변수 : 변수를 정의한 함수 내에서만 사용 가능
• 글로벌 변수 : 모든 곳에서 사용 가능
• 함수에서 변수를 사용하면, 로컬 변수를 먼저 찾고 나서 글로벌 변수를 찾음

def my_function():
    x = 3 # 로컬 변수 : 함수 내에서만 사용 가능
    print(x)

my_function()
print(x) '''NameError: name 'x' is not defined'''

 

 

x = 2 # 글로벌 변수 : 모든 곳에서 사용 가능

def my_function():
    x = 3 # 로컬 변수 : 함수 내에서만 사용 가능
    print(x)

my_function()
print(x) 
print()

def square(x):
	return x * x
    
print(square(3)) # 파라미터도 로컬 변수

 

 

 

 

 

 

# 상수 (constant)

# 상수 (constant)
PI = 3.14 # PI 를 대문자로 쓴 건 값을 바꾸지 않겠다는 표현 (but 바꿀 수 있긴 함)

# 반지름을 받아서 원의 넓이 계산
def calculate_area(r):
    return PI * r * r

radius = 4 # 반지름
print("반지름이 {}면, 넓이는 {}" .format(radius, calculate_area(radius)))

radius = 6
print("반지름이 {}면, 넓이는 {}" .format(radius, calculate_area(radius)))

radius = 7
print("반지름이 {}면, 넓이는 {}" .format(radius, calculate_area(radius)))

 

 

 

 

 

 

# 스타일

 

이해하기 쉬운 코드 = 좋은 스타일을 가진 좋은 코드

# 원의 둘레와 넓이 구하는 코드 보기 좋게 바꾸기
'''
1. 
print(6.28*4)
print(3.14*4 4)
print(6.28*8)
print(3.14*8*8)

2. 
a = 3.14 # 원주율(파이)
b = 4 # 반지름
print(2 * a * b)
print(a * b * b)
b = 8 # 반지름
print(2 * a * b)
print(a * b * b)
1. 보단 보기 편하지만 각 변수가 어떤 의미인지 모름

# 3.
PI = 3.14 # 원주율(파이)

radius = 4 # 반지름
print(2 * PI * radius)
print(PI * radius * radius)

radius = 8 # 반지름
print(2 * PI * radius)
print(PI * radius * radius)
'''

# 4. 누구나 이해 가능
PI = 3.14

# 반지름 r 인 원의 둘레 계산
def calculate_circumference(r):
    return 2 * PI * r

# 반지름 r 인 원의 넓이 계산
def calculate_area(r):
    return PI * r *r

radius = 4 # 반지름
print(calculate_circumference(radius))
print(calculate_area(radius))

radius = 8 # 반지름
print(calculate_circumference(radius))
print(calculate_area(radius))

 

 

 

 

 

 

# 파이썬 스타일 가이드 (PEP 8)

 

• 이름

 

이름 규칙

• 모든 변수와 함수의 이름 : 소문자
• 여러 단어일 경우 _ 로 나눠주기

# bad 
someVariableName = 1
SomeVariableName = 1

def someFunctionName():
	print("Hello")
    

# good
some_variable_name = 1

def some_function_name():
	print("Hello")

 

• 모든 상수 이름 : 대문자
• 여러 단어일 경우 _ 로 나눠주기

# bad
someConstant = 3.14
SomeConstant = 3.14
some_constant = 3.14


# good
SOME_CONSTANT = 3.14

 

의미있는 이름

# bad (의미 없는 이름)
a = 2
b = 3.14
print(b * a * a)


#good (의미 있는 이름)
radius = 2
pi = 3.14
print(pi * radius * radius)

# bad (의미 없는 이름)
def do_something():
	print("Hello, world!")
    
    
# good (의미 있는 이름)
def say_hello():
	print("Hello, world!")

 

 

 

• 화이트 스페이스

 

들여쓰기 : 스페이스 4개

 

 

함수 정의

• 위아래로 빈 줄이 두 개씩 있어야 함
• but. 파일의 첫 줄이 함수 정의인 경우 해당 함수 위에는 빈 줄이 없어도 됨

 

괄호 안 : 괄호 바로 안에는 띄어쓰기 X

# bad
spam( ham[ 1 ], { eggs: 2 } )


# good
spam(ham[1], {eggs: 2})

 

 

함수 괄호 : 함수를 정의하거나 호출할 때, 함수 이름과 괄호 사이에 띄어쓰기 X

# bad
def spam (x):
    print (x + 2)


spam (1)


# good
def spam(x):
    print(x + 2)


spam(1)

 

 

쉼표 : 쉼표 앞에는 띄어쓰기 X

# bad
print(x , y)


# good
print(x, y)

 

 

지정 연산자 : 지정연산자 앞뒤로 띄어쓰기 하나씩만

# bad
x=1
x    = 1


# good
x = 1

 

 

연산자 : 연산자 앞뒤로 띄어쓰기 하나씩

but. 연산자의 "우선 순위"를 강조하기 위해서는, 연산자 앞뒤로 띄어쓰기 붙이는 것을 권장함

# bad
x = x * 2 - 1
hypot2 = x * x + y * y
c = (a + b) * (a - b)


# good
x = x*2 - 1
hypot2 = x*x + y*y
c = (a+b) * (a-b)

 

 

코멘트 : 일반 코드와 같은 줄에 코멘트를 쓸 경우, 코멘트 앞에 띄어쓰기 최소 두 개

# bad
x = x + 1# 코멘트


# good
x = x + 1  # 코멘트

 

 

 

 

 

 

예제

 

# 짝수? 홀수?

def is_evenly_divisible(number):
    return((number % 2) == 0)

# 테스트
print(is_evenly_divisible(3))
print(is_evenly_divisible(7)) 
print(is_evenly_divisible(8))  
print(is_evenly_divisible(218))  
print(is_evenly_divisible(317))  

 

 

 

 

 

 

 

# 거스름돈 계산기

def calculate_change(payment, cost):
    change = payment - cost
    
    fifty_thousand = int(change / 50000)
    ten_thousand = int(change%50000 /10000)
    five_thousand = int(change%10000 / 5000)
    one_thousand = int(change%5000 / 1000)
    
    print(f"50000원 지폐: {fifty_thousand}장")
    print(f"10000원 지폐: {ten_thousand}장")
    print(f"5000원 지폐: {five_thousand}장")
    print(f"1000원 지폐: {one_thousand}장")


# 테스트
calculate_change(100000, 33000)
print()
calculate_change(500000, 378000)