220908 Day12

* 상속 후 변수 추가

-__init__와 관련이 있다 -> __init__에서 변수를 만들기 때문에

* 부모 클래스에서 인자로 입력 받는 것이 '없을 때'

>>> class Person:
		def __init__(self):
        	self.name = "Lee"
            self.age = 25    #변수의 값을 직접 지정해주었다

>>> class Korean(Person):
		pass
        
>>> p1 = Person()
	p1.name
'Lee'

>>> k1 = Korean()
	k1.name
'Lee'            

>>> class Korean(Person):
		def __init__(self):       #메서드는 부모 클래스와 동일
        	self.lang = "한국어"   #새로운 변수 추가 (값이 지정되어 있음)
            
>>> k1 = Korean()
	k1.lang
'한국어'

>>> k1.name
AttributeError: 'Korean' object has no attribute 'name'
#부모 클래스와 같은 이름의 메서드(__init__)로 오버라이딩 되어 부모 클래스에 있던 메서드는 실행되지 않음

>>> class Korean(Person):
		def __init__(self):
        	super().__init__()   #부모 클래스에 있던 __init__()를 불러옴
            self.lang = "한국어"
            
>>> k2 = Korean()
	print(k2.lang)
    print(k2.name)
한국어
Lee

>>> class American(Person):
		def __init__(self):
        	super().__init__()
            self.lang = "English"
            
>>> a1 = American()
	a1.lang
'English'    

* 부모 클래스에서 인자로 입력 받는 것이 '있을 때'

>>> class Person:
		def __init__(self, name, age):
        	self.name = name
            self.age = age
            
>>> class Korean(Person):
		def __init__(self, name, age):   #부모 클래스에 있는 변수를 똑같이 써준다
        	super().__init__(name, age)
            self.lang = "한국어"

>>> k1 = Korean("우영우", 32) 
	print(k1.name)
    print(k1.lang)
우영우
32

* 자식 클래스에서도 인자를 입력 받는 경우

>>> class Korean(Person):
		def __init__(self, name, age, lang):
        #모든 변수를 다 써준다 -> 초기화 하면서 세 변수를 모두 다 받아들임
        	super().__init__(name, age)
            self.lang = lang

>>> k2 = Korean("우영우", 32, "한국어")
>>> print(k2.name)
    print(k2.age)
    print(k2.lang)

(4) 클래스 변수

>>> class Family:
		lastname = "박"   #클래스 변수 생성
        
        def __init__(self, name):
        	self.name = name   #지역변수(instanse)

>>> Family1 = Family("길동")
    Family1.name
'길동'

>>> Family1.lastname
'박'
>>> Family.lastname
'박'

>>> Family2 = Family("우치")
    Family2.name
'우치'
>>> Family2.lastname
'박'

>>> print(id(Family1.lastname))
	print(id(Family2.lastname))
1902481486384
1902481486384    

>>> class Family:
		lastname = "박"
        
        def __init__(self, name):
        	self.name = name
        
        def show_name(self):
        	print(Family.lastname)
            print(self.lastname)
            print(self.name)
            
>>> fam1 = Family("길동")
	fam1.show_name()
박
박   #클래스 변수는 지역변수들이 다같이 공유한다  
길동    

#클래스 바깥에 변수 지정
>>> name = "우영우"   #전역변수(global)
   
    class Family:
		lastname = "박"
        
        def __init__(self, name):
        	self.name = name
        
        def show_name(self):
        	print(name)   #클래스 바깥에 있는 변수(전역변수)라서 공통적으로 보여짐
        	print(Family.lastname)
            print(self.lastname)
            print(self.name)

>>> fam1 = family("준호")
	fam1.show_name()
우영우
박
박
준호

>>> name = "IU"

	class Person:
    	lastname = "Son"
        
        def __init(self, name):
        	self.name = name
            
        def show_name(self):
        	print(name)
            print(Person.lastname)
            print(self.name)
            
>>> a = Person("흥민")
	a.show_name()
IU
Son
흥민

8. 모듈

-파이썬 확장자(.py)로 만든 모든 파이썬 파일
-함수나 변수 또는 클래스를 모아놓은 파일
-다른 파이썬 프로그램에서 불러와 사용할 수 있게끔 만든 파이썬 파일

(1) 모듈 만들기

-add와 sub 함수만 있는 파일 mod1.py를 만든다

>>> def add(a, b):
        return a+b

>>> def sub(a, b):
        return a-b

(2) 모듈 불러오기

-mod1.py 파일, 즉 모듈을 파이썬에서 불러와 사용하려면
-'명령 프롬프트 창'을 열고 mod1.py를 저장한 디렉터리로 이동한 다음 '대화형 인터프리터'를 실행한다

* import 모듈이름

-mod1.py 를 불러오기 위해 명령어 'import'를 실행한다
-'import'는 이미 만들어 놓은 파이썬 모듈을 사용할 수 있게 해주는 명령어이다
-'import'는 현재 디렉터리에 있는 파일이나, 파이썬 라이브러리가 저장된 디렉터리에 있는 모듈만 불러올 수 있다
-파이썬 라이브러리 : 파이썬을 설치할 때 자동으로 설치되는 파이썬 모듈

>>> import mod1
>>> print(mod1.add(3, 4))
7
>>>	print(mod1.sub(4, 2))
2

* from 모듈이름 import 모듈함수

-모듈 이름을 붙이지 않고 바로 해당 모듈의 함수를 사용하고 싶은 경우
-> "from 모듈이름 import 모듈함수" 를 사용하면 된다

>>> from mod1 import add
>>> add(3, 4)
7

#add 함수와 sub 함수 둘 다 바로 사용하고 싶다면
#1. 콤마로 구분하여 필요한 함수들 불러오기
>>> from mod1 import add, sub

#2. '*'문자 : '모든 것' 이라는 뜻 -> 모든 함수를 불러서 사용하겠다
>>> from mod1 import*

* if __name__ == "__main__": 의 의미

-mod1.py 파일에 add(1, 4)와 sub(4, 2)의 결과를 출력하는 문장을 추가하였다

>>> def add(a, b):
        return a+b

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

    print(add(1, 4))
    print(sub(4, 2))

-이렇게 작성한 mod1.py 파일을 대화형 인터프리터에 불러와서 실행해보면

C:\Users\admin>python
>>> import mod1
5
2

-import mod1을 수행하는 순간 mod1.py가 실행되어 결괏값이 출력된다
-> 단지 mod1.py 파일의 add 함수와 sub 함수만 사용할 수는 없는 것일까

>>> def add(a, b):
        return a+b

    def sub(a, b):
        return a-b
	
    if __name__ == "__main__": 
    	print(add(1, 4))
    	print(sub(4, 2))

-if __name__ == "__main__": 을 사용하면
-직접 mod1.py 파일을 실행했을 때 -> if문이 '참' -> if문 다음 문장 실행
-대화형 인터프리터나 다른 파일에서 mod1.py 파일을 불러서(import mod1) 사용할 때
-> if문이 '거짓' -> if문 다음 문장이 실행되지 않음

-mod1.py 파일을 직접 실행하지 않고 대화형 인터프리터에 불러서 실행할 것이므로,
if __name__ == "__main__": 을 사용하여 if문이 거짓이 되게 한다 -> 결과가 바로 출력되지 않고 add 또는 sub 함수만 사용할 수 있게 됨

• __name__ 변수란?
  -파이썬에서 내부적으로 사용하는 특별한 변수 이름이다
  -직접 mod1.py 파일을 실행할 경우,
  -> mod1.py의 __name__변수에는 __main__값이 저장된다
  -파이썬 셸이나 다른 파이썬 모듈에서 mod1을 import할 경우,
  -> mod1.py의 __name__변수에는 mod1.py의 모듈 이름 값 mod1이 저장된다
  -> if __name__ == "__main__": 이 '거짓'이 된다
  
  

(3) 클래스나 변수 등을 포함한 모듈

-모듈은 클래스, 함수, 변수 모두 포함할 수 있다

>>> PI = 3.141592    #전역변수

    class Math:      #클래스
        def solv(self, r):
            return PI * (r**2)

    def add(a, b):   #함수
        return a+b

#대화형 인터프리터에서 실행
C:\Users\admin>python

>>> import mod12
>>> print(mod12.PI)
3.141592
>>> a = mod12.Math()
>>> print(a.solv(2))
12.566368
>>> print(mod12.add(mod12.PI,4.4))
7.5415920000000005

9. 패키지

-모듈을 모아놓은 것
-점(.)을 사용하여 파이썬 모듈을 계층적(디렉터리 구조)으로 관리할 수 있게 해준다

>>> import os
	os.getcwd()
'C:\\Users\\admin'

>>> os.chdir("C:\\Users\\admin")

>>> os.mkdir("abc")     #워킹디렉토리 밑에 'abc'라는 폴더 생성
>>> os.mkdir("abc/a")   #'abc' 폴더 밑에 'a'라는 폴더 생성
>>> os.mkdir("abc/b")
>>> os.mkdir("abc/c")

>>> import sys
	sys.path
    
>>> sys.path.append("C:\\Users\\admin\\abc\\a")
>>> sys.path

10. 예외처리

-프로그램을 만들다가 발생하는 오류를 무시하고 싶을 때
-> 'try, except'문을 사용해서 예외적으로 오류를 처리할 수 있게 한다

-예외 : exception
-except : ~을 제외하고

-try: 1,2,3 except: 4,5 : 4,5는 제외하고 1,2,3만 실행해라
-4,5 -> error, 즉 except가 error라고 볼 수 있다

-예외처리는 다른 말로 에러처리
-for문에서 에러가 자주 발생한다

>>> a = ["hello", "good"]
	for i in range(3):
    	print(a[i])
hello
good
IndexError: list index out of range

>>> a = ["hello", "good"]
	try:
    	for i in range(3):
        	print(a[i])
    except:   #에러가 생기면 다음을 실행해라
    	print("에러입니다")
hello
good
에러입니다

>>> print(4 / 2)
	print(4 / 0)
2.0
ZeroDivisionError: division by zero

>>> try:
		print(4 / 2)
		print(4 / 0)
    except ZeroDivisionError as e:   #e : explain; 오류 메세지 변수
    	print(e)    #오류 메세지 출력
2.0
division by zero

(1) 일반적인 예외처리

-오류 종류에 상관없이 오류가 발생하면 except 블록을 수행한다

>>> a = ["hello", "good"]

	try:
    	for i in range(3):
        	print(a[i])
    except:
    	print("에러입니다")
hello
good
에러입니다

(2) 에러 종류에 맞게 예외처리

-오류가 발생했을 때 except문에 미리 정해놓은 오류 이름과 일치할 때만 except 블록 수행
-as 다음 오류 메세지 변수로 오류 메세지의 내용까지도 알 수 있다

>>> a = ["hello", "good"]

	try:
    	for i in range(3):
        	print(a[i])
	except IndexError as e:
    	print(e)
hello
good
list index out of range

* 에러 이름이 안 맞다면

>>> a = ["hello", "good"]

	try:
    	for i in range(3):
        	print(a[i])
	except ZeroDivisionError as e:
    	print(e)
hello
good
IndexError: list index out of range   #또 빨간 에러가 뜬다

11. 내장함수

-파이썬이 제공해주는 함수, 총 69개
-외부 모듈과 달리 import가 필요하지 않다
-참고 사이트 : https://docs.python.org/ko/3/library/functions.html#func-range

>>> a = "Hello"
	dir(a)   #객체(a)가 자체적으로 가지고 있는 변수나 함수를 보여준다
    
>>> len(a)
5

* dir()

-객체가 자체적으로 가지고 있는 변수나 함수를 보여준다

>>> dir([1,2,3])
['append', 'count', 'extend', 'index', 'pop' ...]

(1) enumerate()

-enumerate : 열거하다
-순서가 있는 자료형(리스트, 튜플, 문자형)을 입력으로 받고,
인덱스 값을 포함하는 enumerate 객체로 돌려준다
-"for문" 처럼 반복되는 구간에서 객체가 현재 어느 위치에 있는지 알려주는 "인덱스 값" 이 필요할 때 사용하면 유용하다

>>> a = ['a','b','c']
	for i in a:
    	print(i)
a
b
c

>>> a = ['a','b','c']
	for i in enumerate(a):
    	print(i)
(0, 'a')
(1, 'b')
(2, 'c')        
        
>>> for i, j in enumerate(a):
		print(i, j)
0 a
1 b
2 c

• a = ['a','b','c']일 때 enumerate를 사용하여 딕셔너리 c를 만들어라

#dics = {'a':0, 'b':1, 'c':2}

>>> a = ['a','b','c']
	c = {}
    
    for i, j in enumerate(a):
    	c[j] = i
	print(c)        
{'a':0, 'b':1, 'c':2}    

(2) filter()

-filter : 무엇인가 걸러낸다
-구조 : filter(함수이름, 데이터(자료형))
(데이터(자료형)은 반복 가능해야 한다)
-자료형 요소가 함수에 입력되었을 때 반환 값이 '참'인 것만 묶어서(걸러내서) 돌려준다

-들어가는 함수는 True, False를 출력할 수 있어야 한다
-자료 안의 원소 하나하나에 대해 함수를 적용시켜주는 함수 -> map과 같다

-두 번째 인수인 반복 가능한 자료형 요소가 첫 번째 인수인 함수에 입력되었을 때 "반환 값이 참" 인 것만 묶어서(걸러내서) 돌려준다

>>> a = [1, -3. 2. 0. -5. 6]
	print(a > 0)   #'리스트 전체(a)'가 0보다 큰건지 판별 -> 파이썬으로는 할 수 없다	
TypeError: '>' not supported between instances of 'list' and 'int'

>>> def positive(a):
		return a > 0   #return값이 True, False로 나올 것이다

	positive(-3)
False

>>> a = [1, -3, 2, 0, -5, 6]
	list(filter(positive, a))
[1, 2, 6]

* 함수 이름을 번거롭게 지정해주어야만 할까? -> 익명으로 할 수 있는 "lambda 함수" 사용

-filter 에서는 lambda 함수를 많이 사용한다

>>> a = [1, -3, 2, 0, -5, 6]
	list(filter(lambda x: x > 0, a))
[1, 2, 6]

* 파이썬에서는 리스트 안 각각의 요소를 확인하기 어려웠다 -> numpy

>>> import numpy as np
	a = np.array([1, -3, 2, 0, -5, 6])
    a   #numpy로 인해 a의 각 요소마다 T, F를 확인할 수 있게 되었다
array([ 1, -3,  2,  0, -5,  6])

>>> a > 0
array([ True, False,  True, False, False,  True])

>>> a[a > 0]
array([1, 2, 6])