[파이썬] 함수와 모듈, 내장함수,클래스

함수와 모듈

함수 선언

def print_ntimes(): 
 	print("대신증권") 
    
#값을 전달 할 때
def print_ntimes(n): 
 	print("대신증권") 
    

 

함수가 호출되고 전달하는 과정

def cal_upper(price): 
        increment = price * 0.3 
        upper_price = price + increment 
        return upper_price  
cal_upper(10000) 
#13000.0

#리턴 값을 두개 이상 돌려 줄 수 있다 단, 튜플 형태로 묶어 주어야한다.
#또한 전달 받는 변수도 2개가 있어야 한다.
>def cal_upper_lower(price): 
        offset = price * 0.3 
        upper = price + offset 
        lower = price - offset 
        return (upper, lower)
        
(upper, lower) = cal_upper_lower(10000) 
upper 
#13000.0 
lower 
#7000.0 

모듈

- 기능이 분리 되어있는 하나의 파일

함수를 만들어서 import 시켜서 가져오기

#함수를 만들어서 import 시켜서 가져오기

#stock.py

#상한가 구해주는 함수
def cal_upper(price): 
    increment = price * 0.3 
    upper_price = price + increment 
    return upper_price 

#하한가를 구해주는 함
def cal_lower(price): 
    decrement = price * 0.3 
    lower_price = price - decrement 
    return lower_price

author ="pystock"

#20200410.py
import stock

print(stock.cal_upper(10000)) 
print(stock.cal_lower(10000))
#stock.cal_lower(10000) #shell에서만 나옴
print(__name__) 


#shell
#13000.0
#7000.0
#__main__ 

########################################################################################
#print(__name__)
#__main__  관한 설명

if __name__ == "__main__": 
    print(cal_upper(10000)) 
    print(cal_lower(10000)) 
    print(__name__)
    
#shell   
#13000.0
#7000.0
#__main__ 

import stock 
#shell   
#13000.0
#7000.0
#stock
#print(__name__)의 결과로 __main__이라는 문자열이 출력되지만, 
#해당 모듈을 임포트했을 때는 모듈의 이름인 stock이라는 문자열이 출력된다는 점입니다
#__name__이라는 변수는 파이썬 자체에서 사용하는 변수로 특정 파이썬 파일이 직접 실행된 것인지
#또는 다른 파이썬 파일에서 임포트 된 것인지를 확인하는 용도로 사용됩니다
#모듈의 테스트 코드가 모듈을 임포트했을 때 자동으로 호출되는 문제를 해결

 

파이썬에서 시간 다루기

import time 
time.time() 
#1444532446.467043 
time.ctime()
#'Sun Oct 11 12:00:50 2015' 
type(time.ctime())
#<class 'str'> 

#문자열을 나누기
cur_time = time.ctime()
print(cur_time.split(' ')[-1]) 
#2015

#1초 간격으로 출력하기(파이썬은 1초 단위, 자바는 0.001초)
for i in range(10): 
        print(i) 
        time.sleep(1) 

내부에 있는 함수 알아보기

# 해당 내부에 있는 함수들을 알아보기dir() 
import time 
dir(time) 

#['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 
#'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 
#'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 
#'timezone', 'tzname'] 

#올대분자: 바꿀 수 없는 값 상수
#__로 시작: 변수
#아무 것도 없는 것 : 해당 함수 명

 

os 모듈

import os print(os.getcwd()) 
#C:\pythonwork #현재 내가 작업하는 곳에 있는 내용
print(os.listdir()) 
#['20200409.py', '20200409_1.py', '20200409_2.py', '20200409_3.py', '20200409_4.py', 
'20200409_5.py', '20200409_ex1.py', '20200409_ex2.py', '20200409_ex3.py', '20200409_ex4.py', 
'20200409_ex5.py', '20200409_ex6.py', #'20200410.py', '20200410_1.py', 'stock.py', 'test.py', 
'test2.py', '__pycache__'] 

#경로명을 넣으면 해당 경로의 파일 들을 찾아 줌 
print(os.listdir(경로명)) 

#끝이 exe로 끝나는 파일 찾기(확장자 찾기) 
for x in os.listdir('c:/Anaconda3'): 
	if x.endswith('exe'):
print(x) 

#모듈을 임포트하는 3가지 방법
import os 
from os import listdir # "os 모듈로부터(from) listdir을 임포트하라"
import os as winos # "os 모듈을 winos로 임포트하라"
  

 

주요 내장함수

 

#abs(x) 내장 함수

#-정수형 또는 실수형 값을 입력받은 후 해당 값의 절댓값을 반환하는 함수
#정수형 또는 실수형이 아닌 문자열 값이 입력되면 오류가 발생
abs(-3) 
#3
abs(3.0)
#3.0

#chr(i) 내장 함수

#유니코드 값을 입력받은 후 해당 값에 해당하는 문자열을 반환
chr(97)
#a

#enumerate() 내장 함수

#입력으로 시퀀스 자료형(리스트, 튜플, 문자열) 등을 입력받은 후 enumerate 객체를 반환
#for 문에서 시퀀스 자료형 내의 값과 인덱스를 동시에 구하고 싶을 때 자주 사용

for i, stock in enumerate(['Naver', 'KAKAO', 'SK']): 
	 print(i, stock)
#0 Naver 
#1 KAKAO 
#2 SK 

#id(object) 내장 함수

#객체를 입력받아 해당 객체의 고윳값을 반환
>>> a = 1 
>>> b = 1 
>>> id(a) 
#1918947744 
>>> id(b) 
#1918947744 

#len(s) 내장 함수

#리스트, 튜플, 문자열, 딕셔너리등을 입력받아 그 객체의 원소 개수를 반환
>>> len(['SK', 'naver']) 
#2 
>>> len('SK hynix') 
#8 
>>> len({1:'SK', 2:'Naver'}) 
#2

#list() 내장 함수
#문자열이나 튜플을 입력받은 후 리스트 객체로 만들고 해당 리스트를 반환
#튜플을 리스트로 변환할 때 자주 사용
>>> list('hello') 
['h', 'e', 'l', 'l', 'o'] 
>>> list((1,2,3)) 
[1, 2, 3] 

#max() 내장 함수는 입력값 중 최댓값을 반환합니다.
#min() 내장 함수는 입력값 중 최솟값을 반환합니다
>>> max(1,2,3) 
3 
>>> max([1,2,3]) 
3 
>>> min(1,2,3) 
1 
>>> min([1,2,3]) 
1 

#sorted() 내장 함수
#입력값을 정렬한 후 정렬된 결괏값을 '리스트'로 반환
>>> sorted((4,3,1,0)) 
[0, 1, 3, 4] 
>>> sorted([5, 4, 3, 2, 1]) 
[1, 2, 3, 4, 5] 
>>> sorted(['c', 'b', 'a']) 
['a', 'b', 'c'] 

#int(x) 내장 함수는 문자열을 인자로 입력받아 해당 문자열을 정수형으로 변환한 후 반환
#str(x) 내장 함수는 객체를 입력받아 문자열로 변환
#문자열을 정수형으로, 정수형을 문자열로 변환할 때 자주 사용
>>> int('3') 
3 
>>> str(3) 
'3'

 

연습문제

#1.두 개의 정수 값을 받아 두 값의 평균을 구하는 함수를 작성하세요.
def myaverage(a,b):
    a=int(input("첫번째 정수를 입력해주세요. :"))
    b=int(input("두번째 정수를 입력해주세요. :"))
    c = (a+b)/2
    print(c)

def myaverage(a, b):
    c = (a + b) / 2
    return c

#2.함수의 인자로 리스트를 받은 후 리스트 내에 있는
#모든 정수 값에 대한 최댓값과 최솟값을 반환하는 함수를 작성하세요.
data_list=[1,2,3,4,5]
def get_max_min(data_list):
    print(max(data_list))
    print(min(data_list))

def get_max_min(data_list):
    d1 = max(data_list)
    d2 = min(data_list)
    return (d1, d2)

#3.절대 경로를 입력받은 후 해당 경로에 있는
#*.txt 파일의 목록을 파이썬 리스트로 반환하는 함수를 작성하세요.
import os

path='c:/Anaconda3'
def get_txt_list(path):
    for x in os.listdir(path):
        if x.endswith('txt'):
             print(x)
            
#절대경로 :'c:/Anaconda3/20155' 무조건 찾아줘야할 때
#상대경로:"./20155"

#4.체질량 지수(Body Mass Index, BMI)는 인간의 비만도를 나타내는 지수로서
#체중과 키의 관계로 아래의 수식을 통해 계산됩니다.
#여기서 중요한 점은 체중의 단위는 킬로그램(kg)이고 신장의 단위는 미터(m)라는 점입니다. 
#BMI=체중(kg)신장(m)2BMI=체중(kg)신장(m)2 
#일반적으로 BMI 값에 따라 다음과 같이 체형을 분류하고 있습니다.
#BMI <18.5, 마른체형 
#18.5 <= BMI < 25.0, 표준 
#25.0 <= BMI < 30.0, 비만 
#BMI >= 30.0, 고도 비만 
#함수의 인자로 체중(kg)과 신장(cm)을 받은 후
#BMI 값에 따라 '마른체형', '표준', '비만', '고도 비만' 중 하나를 출력하는 함수를 작성하세요.
def bmi_cal(kg, cm):
    bmi = kg / ((cm/100)**2)
    if bmi < 18.5:
        print("마른체형")
    elif 18.5 <= bmi < 25.0:
         print("표준")
    elif 25.0 <= bmi < 30.0:
        print("비만")
    elif bmi >= 30.0:
        print("고도비만")

#5.사용자로부터 키(cm)와 몸무게(kg)를 입력받은 후
#BMI 값과 BMI 값에 따른 체형 정보를 화면에 출력하는 프로그램을 작성해 보세요.
#파이썬에서 사용자로부터의 입력은 input() 함수를 사용하며,
#작성된 프로그램은 계속해서 사용자로부터 키와 몸무게를 입력받은 후 BMI 및 체형 정보를
#출력해야 합니다(무한 루프 구조).
def bmi_program():
    while 1:
        kg = int(input("몸무게를 입력하세요.(kg)"))
        m = int(input("키를 입력하세요.(cm)"))
        bmi = kg / ((m/100)**2)
        if bmi < 18.5:
            print("마른체형")
        elif 18.5 <= bmi < 25.0:
             print("표준")
        elif 25.0 <= bmi < 30.0:
            print("비만")
        elif bmi >= 30.0:
            print("고도비만")


#6.삼각형의 밑변과 높이를 입력받은 후 삼각형의 면적을 계산하는 함수를 작성하세요.
def get_triangle_area(width, height):
        width=int(input("밑변을 입력해주세요. :"))
        height=int(input("높이을 입력해주세요. :"))
        c = = width * height / 2
        print(c)
        
#7. 함수의 인자로 시작과 끝 숫자를 받아 시작부터
#끝까지의 모든 정수값의 합을 반환하는 함수를 작성하세요(시작값과 끝값을 포함).
def add_start_to_end(start, end):
    a = range(start, end+1)
    suma = sum(a)
    return suma

#8.함수의 인자로 문자열을 포함하는 리스트가 입력될 때 각 문자열의 첫 세 글자로만 구성된 리스트를 반환하는 함수를 작성하세요.
#예를 들어, 함수의 입력으로 ['Seoul', 'Daegu', 'Kwangju', 'Jeju']가 입력될 때 함수의 반환값은 ['Seo', 'Dae', 'Kwa', 'Jej']입니다.
a=['Seoul', 'Daegu', 'Kwangju', 'Jeju']
def first_three(list):
    lis = []
    for i in range(len(list)):
        lis.append(list[i][0:3])
    return lis

 

클래스

class BusinessCard:
    pass

card1= BusinessCard()
card1
# 'BusinessCard'라는 클래스의 인스턴스가 메모리의 0x0302ABB0 위치에 생성되고
# card1이라는 변수가 이를 바인딩하게 됩니다.
#<__main__.BusinessCard object at 0x0302ABB0>

type(card1) 
#<class '__main__.BusinessCard'>

class BusinessCard: 
        def set_info(self, name, email, addr): #일반 함수 set_info : 3가지 값을 전달 받아서 name,email,addr에 값을 준다
                self.name = name 
                self.email = email 
                self.addr = addr 
#자바처럼 변수를 선언 해줄 필요가 없다. self를 붙이면 된다.
#무조건 매개 변수명은 self를 넣어준다.

member1= BusinessCard()

#클래스 인스턴스를 통한 메서드 호출
member1.set_info("Yuna Kim", "yunakim@naver.com", "Seoul") 
member1.name
#'Yuna Kim' 
member1.email
#'yunakim@naver.com' 
member1.addr
#'Seoul'

 

'''class BusinessCard:
    pass

card1= BusinessCard()
card1
# 'BusinessCard'라는 클래스의 인스턴스가 메모리의 0x0302ABB0 위치에 생성되고
# card1이라는 변수가 이를 바인딩하게 됩니다.
#<__main__.BusinessCard object at 0x0302ABB0>

type(card1) 
#<class '__main__.BusinessCard'>

class BusinessCard: 
        def set_info(self, name, email, addr): #일반 함수 set_info : 3가지 값을 전달 받아서 name,email,addr에 값을 준다
                self.name = name 
                self.email = email 
                self.addr = addr 
#자바처럼 변수를 선언 해줄 필요가 없다. self를 붙이면 된다.
#무조건 매개 변수명은 self를 넣어준다.

member1= BusinessCard()

#클래스 인스턴스를 통한 메서드 호출
member1.set_info("Yuna Kim", "yunakim@naver.com", "Seoul") 
member1.name
#'Yuna Kim' 
member1.email
#'yunakim@naver.com' 
member1.addr
#'Seoul'
'''

#생성자추가
class BusinessCard: 
        def __init__(self, name, email, addr): #일반 함수 set_info : 3가지 값을 전달 받아서 name,email,addr에 값을 준다
                self.name = name 
                self.email = email 
                self.addr = addr

        def print_info(self):
            print("----------")
            print("NAme",self.name)
            print("email",self.email)
            print("addr",self.addr)
            print("----------")
            
# 생성자에 전달되는 값이 없으면 오류
#member1= BusinessCard()
member1= BusinessCard("Yuna Kim", "yunakim@naver.com", "Seoul")
member1.print_info()

###self 이해하기####
class Foo:
    def func1():
        print("function 1")

    def func2(self):
        print("function 2")
'''
func1() 메서드의 첫번 째 인자가 self가 아님에도
클래스를 정의 할 때 에러가 발생하지 않는다는 점
'''
f=Foo()
#NAme Yuna Kim
#email yunakim@naver.com
#addr Seoul

"""
Foo 클래스의 func2 메서드는
메서드의 인자가 self 뿐이므로
실제 메서드를 호출할 때는 인자를 전달할 필요가 없다.

func2 메서드의 첫 번째 인자를 self 지만
호출할 때는 아묵서도 전달하지 않는 이유는
첫 번째 인자인 self에 대한 값은
파이썬이 자동으로 넘겨주기 때문
"""

f.func2()
#function 2

''' func1 처럼
메서드를 정의할 떄부터 아무 인자도 없는 경우에는
인스턴스를 통해 func1()을 호출하면 오류가 발생

'func1() 인자는 없지만 하나를 받았다'는 오류 발생
'''

'''self의 정체를 좀더 확실하 밝혀보기 위해
Foo클래스를 수정 해 파이썬 내장 함수인 id()를 이용해
인스턴스가 메모리에 할당된 주소 값을 확인
'''
print("----------")
print("f = Foo() => ", id(f))
#f = Foo() =>  59880472
#인스턴스의 메모리 주소 확인
"""
실행 결과를 살펴보면 42315162 라는 값이 출력됨을 확인할 수 있다.

Foo 클래스를 정의할 때 id(self)를 출력하게 했는데
id(self)의 값이 바로 61068096 인 것
"""
print("----------")
f2=Foo()
print("f2 = Foo() => ", id(f2))
f.func2()
#f2 = Foo() =>  51160112
#function 2
"""
f2를 통해 func2 메서드를 호출해보면 57730192가 출력됐습니다.
이 값은 바로 f2가 가리키고 있는 객체를 의미한다.
"""

'''
파이썬의 클래스는 그 자체가 하나의 네임스페이스이기 때문에
인스턴스 생성과 상관없이
클래스 내의 메서드를 직접 호출 할 수 있다.
'''
print("----------")
Foo.func1()
#function 1
'''
func1()을 호출 했지만 앞서 인스턴스를 통해 메서드를 호출 했던 것과는 달리
오류가 발생하지 않는다.
왜냐하면 인스턴스.메서드() 형태로 호출한 것과 달리
이번에는 클래스 이름.메서드() 형태로 호출했기 때문
'''

#Foo.func2() 로 호출하면 self값을 전달 못해서 에러 발생
"""
클래스 이름을 통해 func2() 메서드를 호출하려고 하면
self 위치에 인자를 전달해야 한다고 파이썬 인터프리터가 알려주낟.
>>> 모드에서 테스트

self 위치에 인자를 전달하지 않고 메서드를 호출하면 오류 발생

오류 메시지:
 func2() missing 1 required positional argument:'self'

오류 메시지를 확인하면
 func2()를 호출할 때 인자를 하나 빼먹읐음을 알 수 있다.
 즉, 인자를 하나 전달해야 하는데 전달하지 않아서 오류가 발생한 것.
"""

 

class Stock:
    market = "kospi"

print(dir())

"""
2개의 언더바로 시작하는 것은 파이썬에서 이미 사용 중인 특별한 것들

이를 제외하고 보면 조금 전에 정의했던 Stock 클래스의 이름이 포함된 것을 확인할 수 있다.

파이썬에서는 클래스가 정의되면 하나의 독립적인 네임스페이스가 생성된다.
그리고 클래스 내에 정의된 변수가 메서드는
그 네임스페이스 안에 파이썬 딕셔너리 타입으로 저장된다.

Stock 클래스는
Stock 이라는 네임스페이스 안에 'market':'kospi'라는 값을 가진 딕셔너리를 포함한다.
"""

# 파이썬 클래스 네임스페이스

"""
Stock 클래스의 네임스페이스를 파이썬 코드로 확인하려면
클래스의 __dict__ 속성을 확인.
"""

print("Stock.__dict__ => ", Stock.__dict__)

"""클래스가 독립적인 네임스페이스를 가지고
클래스 내의 변수나 메서드를 네임스페이스에 저장하고 있으므로
다음과 같이 클래스 내의 변수에 접근할 수 있는 것이다.
"""

print("Stock.market =>", Stock.market)


s1 = Stock() 
s2 = Stock()

print("s1 = Stock() =>", id(s1))
print("s2 = Stock() =>", id(s2))

"""
생성된 s1, s2 인스턴스가 네임스페이스에 있는지 코드를 통해 확인.
dir() 내장함수의 반환값을 확인하면
s1, s2가 Stock과 마찬가지로 존재하는 것을 확인할 수 있다.
"""

print(dir())



"""
s1과 s2인스턴스의 네임스페이스는 현재 비어있는 것을 확인할 수 있다.
"""

print("s1.__dict__ =>", s1.__dict__)
print("s2.__dict__ =>", s2.__dict__)

"""
s1 인스턴스에 market 이라는 변수를 추가한 후, 다시 __dict__ 속성을 확인해보면
'market':'kosdaq' 이라는 키:값 쌍이 추가된 것을 볼 수 있다.
"""

s1.market='kosdaq'
print("s1.__dict__ =>", s1.__dict__)
print("s2.__dict__ =>", s2.__dict__)




# 파이썬 클래스 네임스페이스

"""
Stock 클래스의 네임스페이스를 파이썬 코드로 확인하려면
클래스의 __dict__ 속성을 확인.
"""

print("Stock.__dict__ => ", Stock.__dict__)

"""
클래스가 독립적인 네임스페이스를 가지고
클래스 내의 변수나 메서드를 네임스페이스에 저장하고 있으므로
다음과 같이 클래스 내의 변수에 접근할 수 있는 것이다.
"""

print("Stock.market =>", Stock.market)


s1 = Stock() 
s2 = Stock()

print("s1 = Stock() =>", id(s1))
print("s2 = Stock() =>", id(s2))

"""
생성된 s1, s2 인스턴스가 네임스페이스에 있는지 코드를 통해 확인.
dir() 내장함수의 반환값을 확인하면
s1, s2가 Stock과 마찬가지로 존재하는 것을 확인할 수 있다.
"""

#print(dir())



"""
s1과 s2인스턴스의 네임스페이스는 현재 비어있는 것을 확인할 수 있다.
"""

#print("s1.__dict__ =>", s1.__dict__)
#print("s2.__dict__ =>", s2.__dict__)

"""
s1 인스턴스에 market 이라는 변수를 추가한 후, 다시 __dict__ 속성을 확인해보면
'market':'kosdaq' 이라는 키:값 쌍이 추가된 것을 볼 수 있다.
"""

#s1.market='kosdaq'

#print("s1.__dict__ =>", s1.__dict__)
#print("s2.__dict__ =>", s2.__dict__)

###############

"""
만약 s1.market, s2.market과 같이 인스턴스를 통해 market이라는 값에 접근하면?
"""
#print("s1.market =>", s1.market)
#print("s2.market =>", s2.market)

"""
s2 인스턴스를 통해 변수에 접근하면
파이썬은 먼저 s2 인스턴스의 네임 스페이스에서 해당 변수가 존재하는지 찾는다.


만약 s2의 네임스페이스에 해당 변수가 존재하지 않으면
s2 인스턴스의 클래스 네임스페이스로 가서 다시 변수를 찾게 된다.
"""

"""
 
즉,
    
s2.market 이라는 문장이 실행되면
Stock 클래스의 네임스페이스에 있는
'market':kospi''
키:값 쌀에서 'kospi'라는 문자열을 출력하게 된다.

"""

  
# 클래스 변수와 인스턴스 변수


"""
은행 계좌를 클래스로 표현

Account 클래스
생성자(__init__) : 클래스의 인스턴스가 생성될 때 자동으로 호출되는 함수
소멸자(__del__) : 클래스의 인스턴스가 소멸될 때 자동으로 호출되는 함수

"""

 

#클래스 상속#
class Parent:
    def can_sing(self):
        print("Sing a song")

father = Parent()
father.can_sing()

class LuckyChild(Parent):
    pass

child1 = LuckyChild()
child1.can_sing()

class UnLuckyChild:
    pass

child2=luckyChild2()
child2.can_sing()
child2.can_sing()

#### 파일 읽기 #####

"""
open('파일경로/파일명.확장자','모드')

경로: '\\' 또는 '/'
파일을 읽기 모드로 열려명 r 을
텍스트 파일인 경우에는 t
"""

f = open("C:\\rStudy\\20200410\\list.TXT","rt", encoding='UTF8')

lines = f.readlines()

print("lines => ", lines)

"""
출력된 후 빈 줄이 하나씩 존재
print()는 문자열을 출력할 때 자동으로 줄바꿈을 하는데
기존에 lines라는 리스트에 있는 문자열에도
줄 바꿈을 의미하는 값인 '\n'가 들어 있기 때문.
"""

for line in lines:
    print(line)

"""
lines 리스트에 있는 원소에서 \n 기호를 제거함으로써 중복으로 줄바꿈되지 않도록
코드를 작성
"""

for line in lines:
    print(line, end="")


################ 파일 쓰기 #############
f = open('sel_list.TXT', 'wt')

f.write('삼전\n')
f.write('하이닉스\n')
f.close()

 

 

 

 

파이참 설치