네카라쿠배 프론트엔드 취업완성 스쿨 2기 2차 테스트 3일차 학습

함수

함수는 어떤 입력값을 가지고 일을 수행하고 그결과물을 내놓는 것이다. 함수를 사용하는 이유는 반복적이고 중복되는 프로그래밍을 피할 수 있어서이다.

#정의
def 함수명(매개변수) :
    <수행>
    ...

#호출
함수명(매개변수)

def hi(name):
    print('hi,', name)

hi('jiwon')
hi('python')

함수의 간단한 예제.

hi라는 함수를 정의하여 호출한다. 함수는 재사용이가능하다.

함수는 함수를 호출하기 전에 정의가 되어있어야하기 때문에, 호출부 위에 함수 선언이 되어있어야 한다.

반환이 있는 함수

def hi_return(name):
    val = 'Hi, ' + str(name)
    return val

print(hi_return('apple'))

이 예제에서 함수의 이름은 hi_return, 매개변수로 name을 가진다. 그리고 val이라는 새로운 변수를 생성하여 Hi, 라는 문자열과 매개변수로 받은 값을 붙여주고 반환한다.

print 문 내에서는 hi_return 함수를 호출하며 인수 'apple'을 전달하여 반환받은 'Hi, apple' 을 print()로 출력하게 된다.

다중 반환

파이썬은 다중리턴이 가능하다.

def func_mul(x):
    y1 = x * 100
    y2 = x * 200
    y3 = x * 300
    return y1,y2,y3

val1, val2, val3 = func_mul(100)
print(val1, val2, val3)

하나의 값이아닌 여러 값을 반환하는 함수를 만들 수있다는 것이다. , (콤마) 로 구분된 값을 반환하면 tuple로 값을 반환한다.

이때 리스트나 딕셔너리같은 자료형을 사용한 다중리턴도 가능하다. 그리고 여러개의 값으로 반환된 값들은 ,를 사용해 변수에 나눠 담을 수 있다.

인자가 몇개인지 모를때는 *args

def args_ex(*args):
    print(args)

args_ex(1,2,3,4)

입력값 즉, 인자가 몇개인지 모를 때(가변인자) 함수의 매개변수자리에 *args 처럼 매개변수 이름 앞에 *을 붙여주면 입력값을 모두 모아 튜플로 만들어준다.

튜플형태가 된다는것은 for문등을 사용한 이터레이션이 가능하다는 것이다.

https://jiminsun.github.io/2018-05-11/Iteration/

def args_ex(*args):
    for idx,val in enumerate(args):
        print(idx,val)

args_ex('a','b','c','d')

enumerate 함수와 함께 사용하면 index와 value 값을 같이 받아올 수 있다.

키워드 파라미터 **kwargs

이번에는 매개변수 앞에 **을 붙여 사용해본다. *args 와 마찬가지로 가변인자를 가진다.

키워드파라미터는 입력값을 딕셔너리로 만들어 출력한다. 호출할 때 인수로 key=value 의 형태를 입력한다.

def kwargs_ex(**kwargs):
    print(kwargs)
kwargs_ex(name='kim', age='21')

def kwargs_ex(**kwargs):
    for key, val in kwargs.items():
        print(key, val)
kwargs_ex(name='kim', age='21')

딕셔너리 형태이므로 items를 사용해서 key, value를 따로 추출할 수도 있다.

def function_ex(arg1, arg2, *args, **kwargs):
    print(arg1, arg2, args, kwargs)

function_ex('a','b') # a b () {}
function_ex('a','b','park','kim') # a b ('park', 'kim') {}
function_ex('a','b','park','kim',age=21, age2=31) # a b ('park', 'kim') {'age': 21, 'age2': 31}

이렇게 사용하면

arg1,arg2 같은 매개변수는 필수로 값이 있어야 하지만 가변인자를 가지는 args, *kwargs 는 꼭 값이 없어도 된다.

중첩함수

def nested_func(num):
    def func_in_func(num):
        print(num)
    print("in function")
    func_in_func(num + 10000)

nested_func(10000)

함수 내부에 함수를 선언한다.

그리고 함수 내부임을 알리는 in function을 출력시키고 내부에 선언한 함수를 호출하는데 nested_func 가 가진 num에 + 10000 을 계산해서 넘겨준다.

func_in_func에서 이를 수행하고 20000을 출력한다.

• 데코레이터는 조금 어려운 내용이므로 가볍게 훑었다.

말그대로 장식하고 꾸미는 의미를 갖는데 function의 수행시간을 측정하거나 시작과 종료를 알리는 등 사용한다.

• 클로저

클로저는 함수를 둘러싼 환경(지역변수, 코드 등)을 계속 유지하다가 함수를 호출할 때 다시 꺼내서 사용하는 함수를 말한다.

타입 힌트

def func_mul3(x:int):
    y1 = x * 100
    y2 = x * 200
    y3 = x * 300
    return y1,y2,y3

val2 = func_mul3(100)
print(val2)

이 예제에서 x는 함수 내부에서 곱셈한 값을 반환하기 때문에 int형을 넣어줘야한다. 이를 명시적으로 나타내기 위해 매개변수 옆에 자료형을 hint로 적어 놓을 수 있다.

여기에 추가로

def func_mul3(x:int) -> tuple:
    y1 = x * 100
    y2 = x * 200
    y3 = x * 300
    return y1,y2,y3

val2 = func_mul3(100)
print(val2)

어떤 자료형으로 값을 반환하는지도 표현해줄 수 있다.

hint는 그냥 hint일 뿐 이 자체로 오류를 발생시켜주거나 하지는 않는다.

Lambda

함수는 객체생성 → 리소스(메모리) 할당의 과정을 가지지만 람다는 즉시 실행(Heap 초기화) → 메모리 초기화의 특성을 가진다.

따라서 람다식은 메모리절약, 가독성 향상, 코드간결의 장점을 가진다.

def mul_10(num:int) -> int:
    return num*10
var_func = mul_10
print(type(var_func))
print(var_func(10)) # 100

비교를위해 우선 10을 곱해주는 함수하나를 만들고 이 함수를 변수에 담아본다. 함수는 변수에 담을 수 있고 이 변수의 type 확인을 해보면 class형태로 function 자료형을 가진 것을 볼 수 있다.

lambda_mul_10 = lambda num : num * 10
print(lambda_mul_10(10)) # 100

람다식은 이런식으로 사용할 수 있다. num을 입력 받아 num * 10을 리턴한다.

이는 단순히 코드의 길이만 줄이는게 아니라 대량작업시 메모리 절약이 가능하다.

def func_final(x,y,func):
    print(x * y * func(10))
func_final(10,10,lambda_mul_10)

함수의 매개변수는 리스트나 딕셔너리, 그리고 함수도 사용가능한데 이를 이용해서 앞서 만들어놓은 lambda식을 전달해보자

x, y값과 func로 받은 lamda식이 전달되어 내부에서 호출되고 수행된다.

따라서 1010(10*10) 이 수행되며 10000을 출력한다.

정의한 lambda를 써야만 하는것은 아니다.

func_final(10,10,lambda x: x: * 10)

과 같이 람다식을 직접 사용하여 호출해도 된다..

클래스

클래스는 프로그램이 커지면 클래스 방식의 코딩을 통해 구조화를 시키고 서로간의 결합을 느슨하게 하여 유지보수나 생산성을 위해 사용한다. 이를통해 데이터를 효율적으로 관리하고 같은코드의 반복을 없애고 상속으로 재활용할 수 있다.

# 기본적인 선언
class 클래스명:
    <함수>
    <함수>
    ...

네이밍 컨벤션을 가볍게 알아보고 가자.

클래스의 이름의 첫 글자는 대문자를 사용하고 이름이 두단어의 조합으로 사용될 때는 두번째단어의 첫 글자도 대문자로 쓴다.

클래스는 보통 두 가지로 구분되는데 속성과 메소드로 구분된다.

User의 정보를 다루는 클래스에서는 이름, 나이, 성별, 키 등등이 속성이 될 수 있고

메서드는 클래스 내부의 함수를 의미한다. 따라서 어떤 행동등의 의미를 가진다.

class UserInfo:
    def __init__(self):
        print('초기화')

user1 = UserInfo()

클래스를 사용할 때 중요한 메서드가 있다. init 은 클래스를 초기화 할 때 자동으로 호출되는 함수이다.

class의 선언은 붕어빵틀을 만든 것 뿐이고 이를 반죽을 넣어 찍어내야 메모리에 올려서 사용할 수 있다.

user1에 UserInfo라는 클래스가 할당 되면서 자동으로 init 메서드를 실행하며 초기화가 진행되는것이다.

class UserInfo:
    def __init__(self,name):
        self.name = name
    def print_user(self):
        print("Name : ", self.name)

user1 = UserInfo('jiwon') 
user1.print_user()

이번에는 name이라는 속성을 받아 self라는 UserInfo의 instance변수안의 name 에 name을 넣어준다.

그리고 새로운 메서드를 만든다. print_user는 이 클래스를 사용하는 user1의 이름을 출력하게 한다.

user1의 print_user 메서드를 호출하면 name을 출력해준다.

class UserInfo:
    def __init__(self,name):
        self.name = name
    def print_user(self):
        print("Name : ", self.name)

user1 = UserInfo('jiwon') 
user1.print_user()
user2 = UserInfo('sana') 
user2.print_user()

instance 가 무엇일까?

user1 과 user2는 같은 클래스를 사용해서 인스턴스화 시켜 user1과 user2를 만들었다. 이 둘은 같은 사람일까? 다르다.

이름뿐만아니라 모든 속성이 다를것인데 현재 user1의 namespace(각각의 객체를 인스턴스화 할때 저장되는 독립적인 공간) 내에는 jiwon이 있고 user2는 sana가 있는데. 각각 인스턴스 내의 namespace에는 다른 값이 들어있다.

클래스 변수 : 직접 사용가능, 객체보다 먼저 생성

인스턴스 변수 : 객체마다 별도로 존재, 인스턴스 생성후 사용

대체 self는 무엇인가

class SelfTest:
    def function1():
        print('func 1')
    def function2(self):
        print('func 2')

self_test = SelfTest()
self_test.function1()

self_test 라는 인스턴스가 function1이라는 메서드를 호출하려 하자 function1은 self 인자가 없기 때문에 누구의 function1 함수인지 구분할 수 없는것이다.

그래서 class메서드로 구분되어

SelfTest.function1로 호출해야한다. (self가 없는 것들은 class에서 직접 호출한다)

즉 인스턴스를 생성해야 self 인자를 통해 자신 고유의 인스턴스네임을 가질 수 있고 반대로 인스턴스를 생성하면 self 인자를 통해야 인스턴스의 독립적인 네임스페이스에 접근할 수 있는것이다.

class 변수 , instance 변수

class WareHouse:
    stock_num = 0 # 클래스변수 self 가 없기 때문에 여러 인스턴스에서 공유한다.
    def __init__(self,name):
        self.name = name
        WareHouse.stock_num +=1  #클래스 변수는 self 가 없으므로 직접 접근
    def __del__(self): # 인스턴스가 종료될 때 호출되는 함수
        WareHouse.stock_num -= 1

user1 = WareHouse('kim')
user2 = WareHouse('park')
user3 = WareHouse('lee')

print(user1.__dict__)
print(user2.__dict__)
print(user3.__dict__)
print(WareHouse.__dict__) # 클래스 네임스페이스, 클래스변수(공유됨)

stock_num 은 클래스 변수로 선언하고

초기화 함수 init 을 선언한다. self를 받아와서 self.name을 사용하면 각각의 인스턴스는 고유의 네임스페이스를 가질 것이다.

그리고 WareHouse의stock_num 은 클래스 변수이므로 직접접근하여 +1 해준다.

이제 인스턴스를 생성하고 각각 인스턴스의 네임스페이스를 확인해보자.(dict)

{'name': 'kim'}
{'name': 'park'}
{'name': 'lee'}

클래스 내에서 선언했던 클래스변수는 나오지 않는다.

이제 WareHouse의 dict 속성을 출력해보면 stock_num이 3이되어있다. 클래스 변수는 모두가 공유하기 때문에 인스턴스가 하나씩 호출될 때마다 +1씩 되어 3이 된것이다.

print(user1.name)
print(user2.name)
print(user3.name)
print(user1.stock_num)

각각 user1,2,3 은 각각의 인스턴스 변수들을 가지고있으므로 출력하고stock_num(클래스변수)는 공유되므로 인스턴스의 네임스페이스에 없으면 클래스 네임스페이스에서 찾는다.

상속

슈퍼클래스(부모클래스) 및 서브클래스(자식클래스)

자식클래스는 모든 속성, 메소드를 사용가능하다. 상속은 왜 사용할까?

코드 재사용과, 중복되는 코드를 최소화 할 수 있다. 이는 코드의 생산성과 가독성과 연결된다.

class Car:
    """Parent Class"""
    def __init__(self, tp, color):
        self.type = tp 
        self.color = color

    def show(self):
        return 'Car class "Show Method"'

class BmwCar(Car):
    """Sub class"""
    def __init__(self,car_name, tp, color):
        super().__init__(tp, color)
        self.car_name = car_name
    def show_model(self):
        return 'Your Car Name : %s' %(self.car_name)

class BenzCar(Car):
    """Sub class"""
    def __init__(self,car_name, tp, color):
        super().__init__(tp,color)
        self.car_name = car_name
    def show_model(self):
        return 'Your Car Name : %s' %(self.car_name)

model1 = BmwCar('520d','sedan','red')
print(model1.color) # Super
print(model1.type) # Super
print(model1.car_name) # Sub
print(model1.show()) # Super
print(model1.show_model()) # Sub
print(model1.__dict__)

Class Car를 정의해주고 init을 정의해준다. 여기까진 이전의 class와 똑같다.

그리고 BmwCar를 생성하면서 () 괄호 사이에 Car를 입력한다. 이는 Car를 상속받겠다는 의미이다. 여기서 car_name과 부모에게 전달해줄 tp와 color를 입력하고

이를 super().init 메소드를 통해 tp,color를 전달해준다. BmwCar 고유의 네임스페이스의 car_name을 가지면서 슈퍼클래스에 물려받아 사용할 것은 물려 받아 사용하며 재사용성을 지키는 것이다.

show_model 이라는 함수까지 만들어주고 나서

인스턴스를 생성해보자.

인스턴스를 생성후에 보면

color는 슈퍼클래스, type도 슈퍼클래스에 구현되어있고, 하지만 car_name은 서브클래스의 네임스페이스에 있는 속성이고 show() 또한 슈퍼클래스에 속해있는 메소드 임을 알 수 있다. 그리고 sho_model은 서브클래스 네임스페이스에 위치해 있다.

마지막으로 model1의 네임스페이스를 확인해보면

{'type': 'sedan', 'color': 'red', 'car_name': '520d'}

부모에서 초기화된 내용도 가지고 있고 당연히 car_name같은 자식에서 초기화된 속성도 가지고 있다.

Method Overriding (오버라이딩)

class Car:
    """Parent Class"""
    def __init__(self, tp, color):
        self.type = tp 
        self.color = color

    def show(self):
        return 'Car class "Show Method"'

class BmwCar(Car):
    """Sub class"""
    def __init__(self,car_name, tp, color):
        super().__init__(tp, color)
        self.car_name = car_name
    def show_model(self):
        return 'Your Car Name : %s' %(self.car_name)

class BenzCar(Car):
    """Sub class"""
    def __init__(self,car_name, tp, color):
        super().__init__(tp,color)
        self.car_name = car_name
    def show_model(self):
        return 'Your Car Name : %s' %(self.car_name)
    ## 아래 부분을 추가해줍니다 ##
    def show(self):
        return 'Car info : %s %s %s' % (self.car_name, self.type, self.color) 

model2 = BenzCar('220d', 'suv', 'black')
print(model2.show())

기존 코드에서

BenzCar에 show() 메서드를 추가해줍니다. show는 Super class에도 존재하는 메서드인데 일단 추가해주고 인스턴스를 생성해주고 show를 출력해본다. 그럼 BenzCar의 show가 출력되는데 이걸 overriding 이라고 한다. 부모에 있는것을 모두다 사용하는게 아니라 상속받을것은 받고 기능을 개선하거나 추가하여 추구하는 방향에 맞게 재구현하는 것이다.

부모에게 상속받은 인스턴스변수도 self를 오버라이딩하여 사용할 수 있는 것이다.

Parent Method Call

model3 = BenzCar('350s','sedan','silver')
print(model3.show())

를 출력해보면 방금처럼 오버라이딩된 show가 출력 될 것이다.

근데 여기서 부모의 메소드도 출력해주고 싶다면

class BenzCar(Car):
    """Sub class"""
    def __init__(self,car_name, tp, color):
        super().__init__(tp,color)
        self.car_name = car_name
    def show_model(self):
        return 'Your Car Name : %s' %(self.car_name)

    def show(self):
                ### 아래 한 줄 추가 ###
        print(super().show())
        return 'Car info : %s %s %s' % (self.car_name, self.type, self.color)

print(super().show())를 추가해준다. super라는 키워드를 통해 부모의 변수나 생성자에 접근이 가능하다.

Inheritance Info

# 클래스명.mro()
print(BmwCar.mro())

mro 메소드를 통해 어떤 클래스를 상속받았는지 확인할 수 있다. 왼쪽에서 오른쪽으로 읽어나가면 된다. 상속정보를 리스트형태로 반환해준다.

다중상속

class X():
    pass
class Y():
    pass
class Z():
    pass

class A(X,Y):
    pass

class B(Y,Z):
    pass

class M(B,A,Z):
    pass

print(M.mro())

다중상속의 확인을 위해 여러 클래스들을 선언해준다.

A는 X,Y를 상속받고 B는 Y,Z를 상속받는데 M은 B,A,Z를 상속받는다.

M의 상속정보를 확인해보면

[<class 'main.M'>, <class 'main.B'>, <class 'main.A'>, <class 'main.X'>, <class 'main.Y'>, <class 'main.Z'>, <class 'object'>]

상속정보가 나온다.

하지만 상속의 깊이가 깊어질수록 어떤 클래스인지 파악하기가 어려워질 수 있다.

모듈,패키지

패키지: 모듈들을 디렉터리 구조로 구조적으로 관리하는 것을 패키지라고 한다.

파이썬 패키지는 디렉터리와 파이썬 모듈로 이뤄진다.

모듈 : 함수나 변수 또는 클래스를 모아놓은 파일로 다른 파이썬 프로그램에서 불러와 사용할 수 있게끔 만든 파이썬 파일이라고 할 수 있다.

패키지를 실습하기위해 새로운 폴더를 하나 생성해고 해당 폴더 내에 어떤 역할을 하는지 유추할 수 있는 이름을 가진 파일로 만들어주는 것이 좋다.

/pkg/fibonacci.py

# fibonacci.py
class Fibonacci:
    def __init__(self, title="fibonacci"):
        self.title = title

    def fib(n):
        a,b = 0 , 1
        while a<n:
            print(a, end=' ')
            a,b = b, a + b
        print()
    def fib2(n):
        res = []
                a,b = 0, 1
        while a<n:
            res.append(a)
            a,b = b, a + b
        return res

피보나치 수의 결과를 반환하는 클래스를 만들어서 메서드로 print해주는 메서드와 리스트형태로 반환해주는 리스트를 만든다. 피보나치 코드를 이해할 필요는 없다.

이제 피보나치클래스 내에 피보나치를 출력해주는 메서드와 리스트로 반환해주는 메서드가 있는 것이다.

pkg라는 폴더안에 피보나치 파일내에 피보나치 클래스가 있고 그안에 메서드가 있는 것이다.

그리고 pkg 폴더내에 2개의 파일을 더 만들어 보자

# prints.py
def prt1():
    print('hi')

def prt2():
    print('bye')

#calc.py
def add(l,r):
    return l + r
def mul(l,r):
    return l + r
def div(l,r):
    return l + r

간단하게 두 개의 파일을 더 만든다 여기서 fibonacci와 다른 것은 클래스가 아닌 함수형태로 선언한다는 점이다.

이제 이 패키지들을 사용하기 위해 상위 폴더로 이동해서 python파일 하나를 만들어보자

from pkg.fibonacci import Fibonacci

파일 상단에 폴더와 파일명을 적어주고 그 파일 내의 클래스인 Fibonacci를 import 시켜준다.

from pkg.fibonacci import Fibonacci

Fibonacci.fib(300)

print(Fibonacci.fib2(400))
print(Fibonacci().title)

그리고 클래스를 import 시켰으니 클래스의 메서드에 접근해서 값을 출력하는것이 가능하다.

pkg 폴더 내 피보나치 모듈형태로 사용자가 사용할 수 있는 것이다.

클래스를 인스턴스화 시키면 title도 출력할 수 있다.

권장하는 방법은 아니지만.

from pkg.fibonacci import *

파일내에 여러개의 클래스가 있을 때 모두 가져오기 위해서는 *을 사용할 수 있지만. 사용하지 않는 클래스도 불러오는 것은 리소스 낭비이다.

Alias

말그대로 별칭 지정하는 것이다.

from pkg.fibonacci import Fibonacci as fb

import해온 클래스에 별명을 지정해주고

from pkg.fibonacci import Fibonacci as fb

fb.fib(300)

print(fb.fib2(400))
print(fb().title)

클래스 이름대신 사용할 수 있다.

이번에는 함수 형태의 모듈을 불러와본다

import pkg.calc as c
print(c.add(10,100))
print(c.mul(10,100))

패키지의 모듈을 통째로 가져와서 호출하여 사용할 수 있다.

from pkg.calc import div as d
print(d(100,10))

이렇게 사용하는 것만 따로 가져오는것이 더 권장되는 방법이다.

import builtins
print(dir(builtins))

빌트인 은 기본으로 임포트가 된다. 빌트인에 있는 모듈들에는 우리가 자주사용하던 len이나 ord 등등 이 들어있다.

파이썬 2점대에서는 pkg 폴더내에 보통 init.py를 만들어 놨어야했다. 이 파일은 해당 디렉터리가 패키지임을 선언한다. python3.x 에서는 파일이 없어도 인식을 하지만 하위호환을 위해 생성하는 것을 추천한다.

단위테스트를 진행할 때 파일을 독립적으로 실행시켜볼 때는

if __name__ == "__main__:
    <실행>

이상태로 테스트 해볼 수 있다.

이렇게 하는 이유는 다른곳에서 불러와서 실행할 때는 main이 아니기 때문에 실행되지 않기 때문이다.

단위 테스트를 안전하게 할 수 있다.

파일 읽기, 쓰기

읽기 모드 : r , 쓰기 모드(기존 파일 덮어쓰기) : w, 추가 모드(파일 생성 또는 추가) : a

f = open('읽어올 파일 경로', 'r')
content = f.read()
print(content)
f.close()

open에 읽어올 파일의 경로와 모드를 지정해주고 read()로 읽어서 변수에 담아준다.

중요한 것은 반드시 close를 통해서 리소스를 반환해줘야 하는것이다.

with open('./resource/review.txt', 'r') as f:
    c = f.read()
    print(c)

with 를 사용하면 close 해주지 않아도 with문이 끝나면 close를 해주지 않아도 파이썬이 알아서 자원반환을 해준다.

with open('./resource/review.txt', 'r') as f:
    for c in f:
        print(c)

f는 이터러블해서 바로 for을 사용해서 사용할 수 있다. 이렇게 사용하면 1 line 단위로 리스트를 가져와준다.

with open('./resource/review.txt', 'r') as f:
    content = f.read()
    print(">", content)
    content = f.read()
    print(">", content)

f를 한번 read로 읽어온뒤에 다시한번 read()를 해도 빈 내용만 출력된다. 이는 읽어오는 위치 , cursor가 이미 파일의 제일 마지막에 위치해있기 때문에 더이상 읽어올 것이 없기 때문이다.

with open('./resource/review.txt', 'r') as f:
    line = f.readline()

    while line:
        print(line ,end =' ')
        line = f.readline()

readline을 사용하면 한 줄씩 읽어오는것이 가능하다.

while을 사용하면 line이 null이 될 때까지 수행되는데, 내에서 line을 한줄 씩 출력하고 읽어오는것으로 출력할 수 있다.

with open('./resource/review.txt', 'r') as f:
    content = f.readlines()
    print(content)

readlines는 개행을 기준으로 리스트형태로 반환해준다. 이 또한 for문에서 바로 출력할 수 있을 것이다.

with open('./resource/text.txt', 'w') as f:
    f.write('hello world\n')

이번에는 resource폴더 내에 text.txt 라는 파일을 생성해본다.

위 코드를 실행하면 파일이 생성된다. w 쓰기모드를 사용한다.

text.txt 파일내에는

hello world

가 잘 들어있을 것이다.

with open('./resource/text.txt', 'a') as f:
    f.write('Good bye')

a 수정모드를 사용하면

파일에

hello world

Good bye

로 수정되어 있다.

from random import randint

with open('./resource/text2.txt', 'w') as f:
    for cnt in range(6):
        f.write(str(randint(1,50)))
        f.write('\n')

이번에는 정수를 랜덤으로 불러오는 메서드를 사용해서

1~49 사이의 숫자를 text2.txt에 쓰게하는 파일을 만들어 봤다.

range를 사용해서 6번 반복하고 6개의 랜덤값을 출력한다.

# writelines : 리스트 -> 파일로 저장
with open('./resource/text3.txt', 'w') as f:
    list = ['kim\n', 'park\n', 'cho\n',]
    f.writelines(list)

writelines를 사용하면 리스트를 파일로 저장할 수 있다.

마지막으로 print문에는 file이라는 파라메터가 있어서

with open('./resource/text4.txt', 'w') as f:
    print('test contents1', file=f)
    print('test contents2', file=f)

print를 써도 출력되는 것이 아니라 파일이 생성이 된게 할 수 있다.