보다 더 나은 내일의 나를 위해

2020/05/10 - [python] - python - 상속

이전 포스팅 글에 의어서

상속 예제를 들어보겠습니다.

class Person:
    say = '안녕하세요 제 나이는 '
    nai = 20
    
    def __init__(self, nai):
        print('Persion 생성자')
        self.nai = nai
        
    def PrintInfo(self):
        print('이야기 :{} {}'.format(self.say, self.nai))
        
p = Person('22')
p.PrintInfo()


출력 결과

Persion 생성자
이야기 :안녕하세요 제 나이는  22

우선 Person 이라는 클래스를 생성하고, 생성자에 nai라는 변수를 주었습니다.

이후 p 객체를 생성하기 위에선 nai가 필요하기 때문에 나이를 22로 주었고 그에 따른 해당 출력 결과는

위와 같이 출력됩니다.

그럼 이제 자식 클래스를 만들어서 상속받아겠습니다.

class Student(Person):
    say = '공부하는 '
    subject = '학생'
    
    def __init__(self):
        print('Student 생성자생성')
        
    def PrintInfo(self):
        print('Student의 PrintInfo')    
                
    def EprintInfo(self):
        print(self.say, ' ' , super().say)
        super().PrintInfo() # super() 붙어서 처음부터 부모꺼
        self.PrintInfo() # 자기꺼 있으면 자기꺼 없으면 부모꺼
        
e = Student()
print(e.say, ' ' , e.nai, '살 ' , e.subject)
        
e.EprintInfo()  


출력 결과

Student 생성자생성
공부하는    20 살  학생
공부하는    안녕하세요 제 나이는 
이야기 :공부하는  20
Student의 PrintInfo

소스코드를 보시면

Student 클래스는 Person 부모클래스로부터 상속 받고있습니다.

그리고 Student 생성자를 생성하는 함수가 작성되어있습니다. 여기서 생성자가 작성되어있지 않다면 부모 클래스의 생성자를 따라가게 되어있습니다. 그렇다면 부모클래스의 생성자는 nai를 받기 떄문에 

Student 클래스에서 e 라는 변수로 객체를 생성할때 e = Student(나이값) 과 같이 나이 값을 넣어주어야 오류가 발생하지 않습니다.

EprintInfo() 함수에서 부모클래스의 say를 받아서 출력하는 것을 알 수 있습니다.

super() 여기서 super()는 부모클래스의 내용을 자식클래스에서 사용하고 싶은 경우 쓸 수 있습니다.

이번에는 다중 상속에 대해 알아보겠습니다.

다중 상속이란?

2개 이상의 클래스를 받아 사용하는 것을 뜻합니다.

우선 부모 클래스로 사용할 클래스 2개를 만들어보겠습니다.

class A:
    data = '파이썬'
    
    def Std(self):
        print('파이썬 공부')
        
    def Std1(self):
        print('파이썬 공부는 재밌다.')
        
        
class B:
    def Std(self):
        print('자바 공부')
        
    def dif(self):
        print('자바 공부는 어렵다')
        
    def kbs(self): 
        pass # 필수는 아니지만 다형성을 위해 강요 가능함

부모클래스 A와 B를 생성하였습니다.

이제 이 부모클래스를 호출할 자식 클래스를 만들어서 호출해보겠습니다.

class C(A, B):
    pass        

aa = C()

# 중복일 경우 먼저 상속한 값으로 가져옴 그래서 A.Std() 가져옴
aa.Std()
aa.Std1()
aa.dif()
print(aa.data)


출력 결과

파이썬 공부
파이썬 공부는 재밌다.
자바 공부는 어렵다
파이썬

자식클래스 C를 생성하였습니다.

부모 클래스 A에서 Std 함수가 존재하고 부모 클래스 B에도 Std 함수가 존재한다.

하지만 출력 결과를 보면 주석에도 언급하였듯, 먼저 상속받은 클래스의 함수를 출력 시키는 것을 알 수 있습니다.

이번에는 자식클래스 D를 만들어 C클래스와 반대로 해보겠습니다.

class D(B, A):
    data = '프로그래밍 천국'
    
    def Play(self):
        self.Std()
        super().Std()
        
    def dif(self):
        print('어려워도 열심히하려한다.')
        
bb = D()
# 중복일 경우 먼저 상속한 값으로 가져옴 그래서 B.Std() 가져옴
bb.Play()
bb.dif()


출력 결과

자바 공부
자바 공부
어려워도 열심히하려한다.

 먼저 호출한 부모클래스의 함수를 가져오는 것을 알 수 있습니다.

추상 클래스

추상 클래스란?

추상 클래스는 기본골격을 만들고 상속받는 클래스에서 그 구현을 강제로 시키는 클래스입니다.

형식을 다음과 같습니다.

from abc import *
class 추상클래스이름(metaclass=ABCMeta):

     @abstractmethod
        def 추상메소드(self):
            pass

바로 예제로 들어가도록 하겠습니다.

추상클래스 AbstractCalss

from abc import *

class AbstractClass(metaclass=ABCMeta):
    # ABCMeta 클래스의 서브 클래스는 추상 클래스
    
    @abstractclassmethod
    def abcMethod(self): # 추상 메소드
        pass
    
    
    def normalMethod(self):
        print('AbstractClass 클래스의 일반 메소드')
        

이 추상 클래스를 받아서 사용할 Child1 클래스

class Child1(AbstractClass):
    name = 'Child1입니다.'

    def abcMethod(self):
        print('추상메소드를 오버라이딩')

c1 = Child1()

print(c1.name)

c1.abcMethod()
c1.normalMethod()


출력 결과

Child1입니다.
추상메소드를 오버라이딩
AbstractClass 클래스의 일반 메소드

AbstractClass 추상클래스에서 abcMethod를 추상메소드로 주었고,

Child1 클래스에서 위 추상클래스를 받아서 사용 하도록 하였습니다.

위와 같이 작성하면 추상클래스의 미구현 메소드를 받아 사용하였기 때문에 아무런 문제가 없이 잘 출력됩니다.

이번에는 추상클래스를 좀 더 자세히 보기 위해 Child1 클래스에서 받았던 미구현 추상메소드를 지워보겠습니다.

class Child1(AbstractClass):
    name = 'Child1입니다.'

c1 = Child1()

print(c1.name)

c1.abcMethod()
c1.normalMethod()

 그럼 다음과 같은 오류 메세지를 출력합니다.

이러한 에러를 출력하는 이유는 임포트 과정에서 에러를 출력하진 않지만 추상클래스에서 미구현 메소드를 Child1 클래스에서 받지 않고 객체 생성을 하려했기 때문에 객체 생성 과정에서 오류가 발생하는 것입니다.

2020/05/10 - [python] - python - 상속

클래스에서 상속이란 ?

- 부모 클래스의 내용을 받는 자식클래스가 받아서 사용하게 되는 것입니다.

- 형태는 다음과 같습니다.

class 부모클래스:
	소스코드
    
class 자식클래스(부모클래스):
	소스코드

class Animal: # 부모클래스
    def __init__(self):
        print('animal 생성자')
        
    def move(self):
        print('움직이는 동물')
        
class Dog(Animal):  # 자식클래스
    def __init__(self): # 해당 클래스의 생성자가 없으면 부모 생성자를 부르고 생성자가 있으면 자신을 호출한다.
        print('Dog 생성자')
    
    def my(self):
        print('나는 개')

dog1 = Dog()

dog1.my()
dog1.move()


출력 결과

Dog 생성자
나는 개
움직이는 동물

부모클래스 Aninal의 '움직이는 동물'을 자식클래스 Dog가 가져다가 사용하여 위와 같은 출력 결과를 가지고 온 것을 알 수 있습니다.

여기서 부모클래스의 생성자를 가지고 오지 않는 이유는 주석에도 알 수 있듯이, 자식클래스에서 생성자가 있기 때문입니다.

오버라이딩 

-  부모 클래스의 메소드를 자식 클래스에서 재정의 하는 것입니다.

다형성

- 부모 클래스로부터 물려받은 내용을 자식 클래스 내에서 오버라이딩하여 사용하는 것입니다.

class Parent: # overriding
    def Prindata(self):
        pass
    
class Child1(Parent):
    def Prindata(self):
        print('Child1에서 overrding')
            
            
class Child2(Parent):
    def Prindata(self):
        print('Child2에서 재정의')
        
    def abc(self):
        print('Child2 고유 메소드')
        
c1 = Child1()
c1.Prindata()

c2 = Child2()
c2.Prindata()   


출력 결과


Child1에서 overrding
Child2에서 재정의

부모클래스인 Child1 에서 Printdata 메소드는 'child1에서 overrding'을 출력해준다.

하지만 오버라이딩 성질을 이용하면 Child2에서 Printdata 메소드의 출력문인 'Child2에서 재정의' 를 출력해줍니다.

2020/05/10 - [python] - python - 상속 (2)

클래스란 ?

- 객체의 구조를 나타낸다.

- 클래스에 의해 만들어진 객체를 인스턴스라고도 부른다.

객체와 인스턴스의 차이

- 객체는 클래스 정의시 메소드 밖에 존재하며, 클래스명.변수명 으로 사용한다. 

- 인스턴스는 메소드 안에서 사용하며, self.변수명으로 사용한다.

# 모듈의 멤버로 클래스

class TestClass:
    kk = 1 # 멤버변수 ( 전역 )
    
    def __init__(self):
        print('생성자')
        
    def __del__(self):
        print('소멸자')
        
    def printMsg(self): # 메소드 (public)
        name = '한국인' # 지역변수
        print(name)
        print(self.kk)
        
test = TestClass() # 생성자 호출. instance
print(test.kk) # 1을 출력
print(TestClass.kk) # prototype(원형) 클래스의 멤버 직접 호출
 
print()

test.printMsg() # Bound Method call
# TestClass.printMsg() # 이렇게 주면 아규먼트를 주지 않아서 ERR
print()
TestClass.printMsg(test) # UnBound Method call


출력 결과

생성자
1
1

한국인
1

한국인
1

소멸자

# Bound Method Call는 self가 붙은 쪽에 사용하고, UnBound Method Call 이란 self 를 안 붙은 쪽을 말합니다.

파이썬에서 사용하는 특별한 메소드

# __init__ : 

- 초기화(initialize) 메서드라고도 합니다.

- 어떤 클래스의 객체가 만들어질 때 자동으로 호출되어서 그 객체가 갖게 될 여러 가지 성질을 정해주는 역할을 함

- 위 소스에서는 TestClass() 를 작성하여 TestClass 객체를 생성하자마자 초기화가 되고 '생성자'를 출력하였습니다.

# __del__ :

- 객체가 없어질때 사용하는 메소드입니다.

- 위 소스에서는 그래서 맨 마지막에 '소멸자'가 출력되었습니다.

이번에는 __init__ 메소드에 인자를 받아야만 생성자가 생성되는 예제를 들어보겠습니다.

class Car:
    handle = 0
    speed = 0

    def __init__(self, name, speed):
        self.speed = speed
        self.name = name
        
    def showData(self):
        km = '킬로미터'
        msg = '속도:' + str(self.speed) + km
        return msg
    
print(Car.handle)
print(Car.speed)
#print(Car.name) # type object 'Car' has no attribute 'name'
print()
car1 = Car('tom',10)
print(car1.handle, car1.name, car1.speed)
print('------')
car2 = Car('james',20)
print(car2.handle, car2.name, car2.speed)

print()
print(car1.showData())
print(car2.showData())
car1.speed = 88
car2.speed = 100
print(car1.showData())
print(car2.showData())

Car.handle = 1
print(car1.handle)
print(car2.handle)


출력 결과

0
0

0 tom 10
------
0 james 20

속도:10킬로미터
속도:20킬로미터
속도:88킬로미터
속도:100킬로미터
1
1

위 소스코드는 __init__ 생성자에 self, name, speed 를 주었기 때문에 새로운 객체를 생성할때 name,과 speed를 가지고 가야 생성이 가능합니다. 그렇지 않으면 다음과 같은 에러를 출력합니다.

car1 객체와 car2 객체를 생성 한 후에는 speed 값을 기존 10에서 각각 88과 100으로 변경해주었습니다.

그 출력 결과 속도들의 변경된 점을 확인 가능했습니다.

# 클래스는 포함자원의 재활용 목적으로 다른 클래스를 불러다가 사용 가능합니다.

handle.py

# 다른 클래스에서 공유할 클래스

class PohamHandle:
    quantity = 0
    
    def LeftTurn(self, quantity): # self에 quantity 가 들어옴
        self.quantity = quantity
        
        return '좌로 돌아';
    
    def RightTurn(self, quantity): # self에 quantity 가 들어옴
        self.quantity = quantity
        
        return '우로 돌아';

PohanCar.py

import etc.handle

class PohanCar:
    turnShow = '정지'
    
    def __init__(self, ownerName):
        self.ownerName = ownerName
        self.handle = etc.handle.PohamHandle()
        
        
    def TurnHandle(self, q):
        if q > 0:
            self.turnShow = self.handle.RightTurn(q)
        elif q < 0:
            self.turnShow = self.handle.LeftTurn(q)
        else:
            self.turnShow = '직진'
            
if __name__ == '__main__':
    tom = PohanCar('tom')
    tom.TurnHandle(10)
    print(tom.ownerName + ' 의 회전량은 ' + tom.turnShow + str(tom.handle.quantity))            
    
    print()
    james = PohanCar('james')
    james.TurnHandle(0)
    print(james.ownerName + ' 의 회전량은 ' + james.turnShow + str(james.handle.quantity))

출력 결과

1급 함수의 조건 3가지

- 함수 안에 변수를 할당 할 수 있다.

- 인자로 함수를 전달 할 수 있다.

- 반환값이 함수가 가능하다.

대부분의 프로그래밍 언어는 1급함수의 조건에 충족합니다.

파이썬 또한 이 3가지를 충족합니다.

Ex 1)

def fun1(a, b):
    return a + b
fun2 = fun1
print(fun2(3,4))

def fun3(func):
    def fun4(): # 함수 안에 함수
        print('내부함수 출력')
    fun4()
    return func # 반환값이 함수
abc = fun3(fun1) # 인자로 함수 전달




출력 결과

7
내부함수 출력

조건1. 함수 안에 함수를 호출 할 수 있다.

func3 함수는 내부에서 fun4 함수를 호출하여 충족합니다.

조건2. 인자 abc로 함수 fun3을 호출하여 조건2을 충족합니다.

조건3. 반환값이 func으로 마지막 조건을 충족합니다.

가변인수란 ?

함수 호출시 , 함수에 정의된 매개변수 개수만큼 인자를 전달해주어야 하지만

가변 인수라는 것을 사용하면 하나의 매개변수로 인자의 개수를 맞춰주지 않고 처리 할 수 있다.

이유는 가변 인수가 튜플 형식으로 처리하기 때문이다.

바로 예를 들어보겠습니다.

Ex 1)

def func1(*ar):
    print(ar)
    for i in ar:
        print('음식: ' + i)
func1('비빔램명','물냄명','돌솥빔빔팝')



출력 결과

('비빔램명', '물냄명', '돌솥빔빔팝')
음식: 비빔램명
음식: 물냄명
음식: 돌솥빔빔팝

소스코드를 보시면 매개변수 앞에 * 표시를 해주었습니다.

Ex 2)

def func2(*ar):
    print(ar)
    
func2('비빔밥', '공기밥', '주먹밥')


출력 결과

('비빔밥', '공기밥', '주먹밥')

키워드 가변 인수

키워드 가변 인수는 매개변수 앞에 **을 붙여주면 됩니다.

키워드 가변 인수는 DICT 형태로 전달되며 key : values 형태로 저장됩니다.

이것도 예제를 바로 들어보겠습니다.

Ex 1)

print()
def func3(**v2):

print(v2)
    

func3(m=6, n=7)


출력 결과

{'m': 6, 'n': 7}

range 함수란 ?

이 함수는 입력받은 숫자에 해당하는 범위 값을 반복 가능한 객체로 만들어준다.

아래 소스코드를 기준으로 인수가 1개일때, 2개일때, 등등 풀어보겠습니다.

def ShowGugu(start, end = 5):
    for dan in range(start, end+1):
        print(str(dan) + '단출력')

인수가 1개일 때,

# 인수가 1개일 때
ShowGugu(3)

출력 결과

3단출력
4단출력
5단출력

인수가 2개일 때,

# 인수가 2개 일때
ShowGugu(2,3)
print()

출력 결과

2단출력
3단출력

* 주의점 끝 숫자는 해당 범위에 포함되지 않는다

인수의 시작을 2 끝을 4로 주었을 경우

# 인수의 시작이 2부터 끝인 4까지
ShowGugu(start=2, end=4)
print()

출력 결과

2단출력
3단출력
4단출력

Module 이란 ?

함수나 변수 또는 클래스를 모아 놓은 파일

모듈은 이미 만들어져있는 것을 사용할 수도 있고 사용자가 직접 만들어서도 사용이 가능합니다.

파이썬에서 기본적으로 제공하는 함수들을 다 작성 할 순 없어서 아래 링크를 참조하면 확인 가능합니다.

https://docs.python.org/ko/3.7/library/index.html

Module의 사용 목적 ?

코드의 재사용을 가능하게 하며, 하나의 이름 공간으로 별도 관리가 가능하다.

Module의 사용 위치

 package 내에서 작성해야 한다.

Module import 방법

방법 1)

import 불러올모듈A

불러올모듈A 전체를 가져온다.

이 방식을 이용하는 경우 '불러올모듈A.메소드' 처럼 모듈명을 적고 사용하여야한다.

방법 2)

from 불러올모듈B import 메소드 or 변수

불러올모듈B 내에 있는 특정 메소드 또는 모듈에 정의된 변수를 가져온다.

방법 1과 다르게 불러온 메소드 또는 변수 앞에 모듈명을 적지 않고 사용 가능하다.

Ex 1)

# import math

# math의 모듈 함수 : fabs(절대값), ceil(올림), floor(버림), exp(지수함수), log(로그), sqrt(루트), sin(사인함수),

# asin(사인 역함수), cos(코사인), acos(코사인역함수), tan(탄젠트), degrees(라디안을 각도로), radians(각도를 라디안)

# math의 모듈 상수 : pi, e

import math
print(math.ceil(1.2), math.ceil(1.6)) # 정수 근사치 중 큰 수
print(math.floor(1.2), math.floor(1.6)) # 정수 근사치 중 작은 수
print()

출력 결과

이번에는 사용자 모듈을 생성하고 불러와서 사용해보겠습니다.

mymod1.py

gvar = 123
def ListHap(*ar):
    print(ar)
    
def kbs():
    print('채널9')
    
def mbc():
    print('문화방송')

mymod2.py

def Hap(a, b):
    return a + b

def Cha(a, b):
    return a - b

불러오기 위한 사용자 모듈 2개를 생성하였습니다. 이번에는 불러올 최상위 모듈에서 호출해보겠습니다.

방법 1.

import pack1.mymod1
list1 = [1,2]
list2 = [3,4,5]
pack1.mymod1.ListHap(list1, list2)

pack1.mymod1.kbs()

출력 결과

방법 2.

from pack1 import mymod1
mymod1.kbs()

방법 3.

from pack1.mymod1 import kbs, mbc, gvar
kbs()
mbc()
print(gvar)

방법 4.

from etc.mymod2 import *
print(Hap(5, 3))
print(Cha(5, 3))

해당 방법은 etc 패키지 안에 있는 mymod.py 에 있는 것들을 전부 import 하겠다는 의미입니다.

if __name__ == '__main__': 

불러올 모듈에서 함수뿐 아니라 내용까지 전부 실행할 경우 __name__ 변수에 __main__이 저장되어 전부 실행된다.

하지만 다른 모듈에서 불러와서 사용할 경우 __name__ 변수에 불러올 모듈명 저장된다.

main.py

# 여러 모듈 중 응용프로그램의 시작 모듈을 명시적으로 표시하기
# 이곳은 모듈을 불러온 파이썬 모듈
if __name__ == '__main__':
    print('여기가 최상위 모듈')
    
pack1.mymod1.kbs()

from pack1 import mymod1
mymod1.kbs()

mymod1.py

gvar = 123
def ListHap(*ar):
    print(ar)
    # 최상위 모듈이 아니라 출력되지 않음
    if __name__ == '__main__':
        print('최상위메인모듈')
    
def kbs():
    print('채널9')
    
def mbc():
    print('문화방송')

mymod1.py의 파일에 if __name__ == '__main__' 부분을 추가하였습니다.

여기서 위 mymod1.py 에서 직접 실행하면 __name__ 이 참이 되면서 mymod1.py 에서의 print 문이 출력됩니다.

하지만 main.py 에서  부를 경우 mymod1.py 의 if문이 거짓이 되면서 print문이 출력되지 않습니다.

해당 이유는 위에 작성하였습니다.

클래스를 포함한 모듈 

class TestClass:
    kk = 1 # 멤버변수 ( 전역 )
    
    def __init__(self):
        print('생성자')
        
    def __del__(self):
        print('소멸자')
        
    def printMsg(self): # 메소드 (public)
        name = '한국인' # 지역변수
        print(name)
        print(self.kk)
        
test = TestClass() # 생성자 호출. instance
print(test.kk) # 1을 출력
print(TestClass.kk) # prototype(원형) 클래스의 멤버 직접 호출
 
print()

test.printMsg() # Bound Method call
# TestClass.printMsg() # 이렇게 주면 아규먼트를 주지 않아서 ERR
print()
TestClass.printMsg(test) # UnBound Method call

__init__과 self에 대해서는 다음에 추가 설명 작성 또는 포스팅을 하도록 하겠습니다.

위에 작성한 클래스들을 호출한 출력 결과

내장 함수란 ?

파이썬에서 기본적으로 제공하는 기능입니다.

내장 함수의 종류는 많기 때문에, 예제는 제가 주로 공부한 함수에 대해 작성하였으며 더 많은 내장함수 종류들은 해당 링크에 첨부하였습니다 !

https://wikidocs.net/32

Ex 1)

print(sum([3,5,7]))
print(int(1.7), float(4), str(5))
print(round(1.2), round(1.6)) # 반올림

sum 은 합을 구하는 함수로 3 + 5 + 7 의 값을 출력한다.

int 는 정수이므로 1 출력, float 는 실수이므로 4.0 출력 str 은 문자열이므로 5를 문자열로 출력

round는 반올림으로 1.2 -> 1 출력, 1.6 -> 2 출력

출력 결과

Ex 3)

# zip 함수란 ? 동일한 개수로 이루어진 자료형을 묶어주는 함수

# 아래 예제는 공통 개수만큼 묶어주기 때문에 30은 출력되지 않는다.

x = [10,20,30]
y = ['a', 'b']

for i in zip(x,y):
    print(i)
    

출력 결과

Ex 4) 사용자 정의 함수

사용자 정의 함수 형태는 이렇습니다.

def 함수명():
	print('내용')

def DoFunc1():
    print('DoFunc1 실행')
    
DoFunc1()
  
print(DoFunc1) # 주소를 출력한 것

abc = DoFunc1
abc()

함수명을 DoFunc1() 로 주었고 실행하면 'DoFunc1 실행' 이 출력되도록 작성하였습니다.

DoFunc1() 에서 print 내용을 출력하고

DoFunc1 로 줄 경우 값이 아닌 해당 주소를 출력하게 됩니다.

abc에 DoFunc1을 정의해주었기 때문에 abc() 또한 'DoFunc1 실행'을 출력하게 됩니다.

출력 결과

Ex 5) 사용자 함수 내에 또다른 사용자 함수를 정의

def DoFunc2(a, b):
    print('DoFunc2')
    result = DoFunc3(a,b)
    return result

def DoFunc3(m,n):
    imsi = m+n
    return imsi  

bcd = DoFunc2
print(bcd(5, 6))

DoFunc2(a, b) 함수 안에 DoFunc3 함수를 또 한번 정의 해주었습니다.

출력 내용 bcd(5,6)을 보면 DoFunc2 함수로 가게됩니다.

이후 우선 'DoFunc2'를 출력하고 DoFunc3 함수의 a에는 5 b에는 6이 들어가고 ,

그 해당 값 계단을 DoFunc3 함수에서 imsi 변수에 5 + 6을 하여 반환해주면 그 값이 result 값으로 들어가게 됩니다.

출력 결과

Ex 6) 비슷한 내장함수 응용

player = '전국대표'

def FuncSoccer():
    name = '축구선수'
    print(name,player)
    
FuncSoccer()
print(player)

출력 결과

Ex 7) 사용자 정의 함수에 전역변수 지역변수 이용

a = 10; b = 20; c = 30
print('1) a: ' , a, ', b:', b, ', c: ', c)
def Good():
    a = 40
    b = 50
    print('2) a: ' , a, ', b:', b, ', c: ', c)
Good()

 초기에 전역변수로 주었지만, Good 함수 안에서 a는 40 b는 50으로 주었기 때문에

1)은 각각의 출력 값이 10 20 30 이지만 2)는 40 50 30 입니다.

출력 결과

여기서 지역변수로 값을 변경 하는 것이 아닌 전역변수의 값을 내장 함수 안에서 바꾸고 싶다면

global keyword를 사용해주면 됩니다.

a = 10; b = 20; c = 30
print('1) a: ' , a, ', b:', b, ', c: ', c)
def Good():
    a = 40
    b = 50
    global c
    c = 100
    
Good()
print('2)a: ' , a, ', b:', b, ', c: ', c)

변수 c를 global 키워드를 통해 100으로 변경해주었습니다.

여기서 global 선언을 해주지 않는다면 c 값은 100이 아닌 30 이 출력 됩니다.

lambda

# def 와 동일한 역할로 함수 이름이 길면 사용하기에 부적합하다.

lambda 매개변수1, 매개변수2, ... : 표현식

aaa = lambda a, su = 10: a + su
print(aaa(5))
print(aaa(5,6))

여기서는 a+su를 더한 값을 반환하는 람다 함수를 만들었습니다.

출력 결과

bbb = lambda a, *tu, **di:print(a, tu, di)
bbb(1,2,3,m=4, n=5)

li = [lambda a, b: a+b, lambda a, b: a*b]
print(li[0](3,4))
print(li[1](3,4))

# 다른 함수에서 람다 사용
print(list(filter(lambda a:a<5, range(10))))
print(list(filter(lambda a:a % 2, range(10))))