Sso

Human 클래스를 선언해보자

class Human:
    # 클래스 속성
    greeting = 'Hello'

    # 초기화/인스턴스 속성
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def cmethod():
    	print('클래스 메소드 호출')
    
    def imethod(self):
    	print('인스턴스 메소드 호출')

다음으로 Human 클래스를 인스턴스화 해보자

a = Human('so', 20)
a2= Human('so', 20)
b = Human('yeon', 21)

print(a==a2)

Flase

a와 a2로 인스턴스화할 때 같은 값을 넣어줬지만 다르다!

id()를 사용해 객체의 고유 주소 값을 확인해봐도 다른 값이 들어있다.

인스턴스 속성  

인스턴스 속성을 확인해보자

print('my name is {}'.format(a.name))
print('{}'.format(b.age))

so

21

클래스 속성  (직접 접근)

클래스 속성은 직접 접근이 가능하다

print(Human.greeting)

Hello

클래스 속성의 값을 변경해보고 인스턴스화 된 변수로 접근해보자

Human.greeting += ' !'
print(a.greeting, b.greeting)

Hello ! Hello !

각 인스턴스 속성도 변경된 것을 확인할 수 있다.

a.greeting += '!!!'
print(a.greeting, b.greeting, Human.greeting)

Hello !!!! Hello ! Hello !

반대로 a.greeting을 변경하면 공유되지 않는다.

+ 인스턴스 변수명과 클래스 변수명

class Human():
    cnt = 1

    def __init__(self):
        self.cnt = 0

Sso = Human()
print(Sso.cnt)
print(Human.cnt)

0

1

인스턴스 변수와 클래스 변수명이 같아도 된다.

인스턴스에서 먼저 찾은 후 상위에서 찾게 된다.

class Human():
    cnt = 1

Sso = Human()
print(Sso.cnt)
print(Human.cnt)

1

1

클래스 메소드

간단하게 말해서 self가 붙으면 인스턴스만의 속성과 메소드가 되고
self가 붙어있지 않으면 클래스의 속성과 메소드가 된다.

클래스 메소드는 클래스로 직접 호출을 해야한다.

# a.cmethod()
Human.cmethod()

a.cmethod()로 접근하면 에러가 난다.

인스턴스 메소드

인스턴스 메소드인 imethod를 보면 매개변수로 self를 받는다.

객체를 생성한 후 self에 인스턴스를 넘겨줘야 한다.

# Human.imethod()
Human.imethod(a)
a.imethod()

Human.imethod()로 접근하면 에러가 난다. (인스턴스를 넘겨주지 않았기 때문)

따라서 위에 생성한 인스턴스 a를 넘겨주거나       :      Human.imethod(a)

인스턴스 자체로 호출하는 방법이 있다.      :      a.method()

파이썬에서 import를 하면 어디서 가져오는지 알아보자

import sys

print(sys)
print(sys.path)

<module 'sys' (built-in)>

['e:\\workspace\\Python_basic\\module', 'C:\\ProgramData\\Anaconda3\\python39.zip', 'C:\\ProgramData\\Anaconda3\\DLLs', 'C:\\ProgramData\\Anaconda3\\lib', 'C:\\ProgramData\\Anaconda3', 'C:\\Users\\SsoY\\AppData\\Roaming\\Python\\Python39\\site-packages', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32\\lib', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\Pythonwin']

빌트인 모듈은 파이썬 설치시 자동으로 설치되는 모듈이다.

sys.path에 나오는 경로를 토대로 파이썬 엔진이 찾게 된다.

sys.path.append('추가할 경로')

앞서 출력해본 sys.path는 리스트 타입이므로

추가할 모듈의 경로를 append함수를 사용해 추가할 수 있다.

새로운 모듈의 경로를 sys.path에 추가한 이후에는

해당 모듈을 import해서 사용할 수 있다.

가변인자

매개변수를 원하는 만큼 받을 수 있는 함수

• 가변 매개변수 뒤에 일반 매개변수는 올 수 없음
• 가변 매개변수는 하나만 사용 가능
• 기본 매개변수가 가변 매개변수보다 앞에 와도 의미 없음 (n=2, *values)
• 가변 매개변수가 기본 매개변수보다 앞에 올 때 가변 매개변수가 우선 (*values, n=2)

# *args(언팩킹)
def args(*args):
    for i, v in enumerate(args):
        print('Result : {}'.format(i), v)
    print('------')

args('Sso')
args('Yeon')

Result : 0 Sso 
------
Result : 0 Yeon
------

튜플 형태의 0번 인덱스로 인식

아래와 비교해보자.

def args2(args):
    for i, v in enumerate(args):
        print('Result : {}'.format(i), v)
    print('------')

args2('Sso')
args2('Yeon')

Result : 0 S   
Result : 1 s   
Result : 2 o   
------
Result : 0 Y   
Result : 1 e
Result : 2 o
Result : 3 n
------

딕셔너리 가변인자

# **kwargs(언팩킹)
def kwargs(**kwargs):
    for v in kwargs.keys():
        print("{}".format(v), kwargs[v])
    print('------')

kwargs(name='Kim')
kwargs(name='Kim', name2='Sso')

name Kim
------
name Kim
name2 Sso
------

가변인자  + 딕셔너리 가변인자

def variable_param(args_1, args_2, *args, **kwargs):
    print(args_1, args_2, args, kwargs)

# *args, **kwargs를 하나로 취급함
variable_param(10, 20, 'Kim', 'Sso', 'Yeon', age1=20, age2=30, age3=40)

10 20 ('Kim', 'Sso', 'Yeon') {'age1': 20, 'age2': 30, 'age3': 40}

*args, **kwargs를 각 하나로 취급함

코드부터 보자

num = [1, 2, 3, 4, 5, 6]

for n in num:
    if n == 10:
        print('Found : ', n)
        break
else:
    print('Not Found : ', n)

while-else문도 똑같다!

break를 만나지 않는다면 else문이 한번 실행되고 종료된다.

선언 방법 , 팩킹

t = ('so', 'ye', 'on', '2')
t2 = 's',

('so', 'ye', 'on', '2') <class 'tuple'>
('s',) <class 'tuple'>

튜플 선언에서 괄호 () 는 생략 가능 콤마(,) 만 있으면 됨!

원소가 하나일 때는 원소 마지막에 콤마(,) 를 붙이면 tuple

언팩킹

(x1, x2, x3, x4) = t

print(type(x1), type(x2), type(x3), type(x4))
print(x1, x2, x3, x4)

<class 'str'> <class 'str'> <class 'str'> <class 'str'>
so ye on 2

선언 방법

dic1 = {
    'Name' : 'kim',
    'Age' : 24
}

dic2 = dict([
    ('Name', 'kim'),
    ('Age', 24)
])

dic3 = dict(
    Name = 'kim',
    Age = 24
)

{'Name': 'kim', 'Age': 24}
{'Name': 'kim', 'Age': 24}
{'Name': 'kim', 'Age': 24}

주로 dic1 형식으로 선언했는데 dic3이 명시적이고 편한 듯!

key로 value 출력

print('key로 value 출력 : ', dic3.get('Age'))
print('키가 존재하지 않으면 None으로 출력 : ', dic3.get('Company'))

# 에러
print('키가 존재하지 않으면 에러 발생 : ', dic3['Company'])

key로 value 출력 :  24
키가 존재하지 않으면 None으로 출력 :  None

KeyError: 'City'

값 가져오기

추가 & 수정

dic3['Num'] = [1, 2, 3]

{'Name': 'kim', 'Age': 24, 'level': [1, 2, 3]}

dic1['Name'] = [1, 2, 3]

{'Name': [1, 2, 3], 'Age': 24}

수정 (update)

dic3.update(Name='Lee')

{'Name': 'Lee', 'Age': 24, 'Num': [1, 2, 3]}

key의 길이 (len)

print(len(dic3))

3

삭제 

pop : 해당 key 삭제

dic3.pop('Name')

{'Age': 24, 'Num': [1, 2, 3]}

popitem : 무작위 key 삭제 (dictionary는 순서가 없기 때문)

dic1.popitem()

{'Name': 'kim'}

escape

print('\\\"')

\"

raw string

# raw string (있는 그대로)
raw_str = r'D:\python\test\역슬래시 있어도 있는 그대로'
print(raw_str)

print(r'\\\"')
print(r'\\\\\n있는 그대로 출력하고 싶어')

# 오류
print(r'\')

D:\python\test\역슬래시 있어도 있는 그대로

\\\"
\\\\\있는 그대로 출력하고 싶어

r을 사용해서 \ 하나 출력은 왜 안되는거지..?

multiline

# 멀티라인 입력
multi_str = '''
안
녕
'''
print(multi_str)

# \로 끝나면 이 다음에 어떤 변수를 바인딩 한다는 의미
multi_str2 = \
'''
안
녕
'''
print(multi_str2)

안

녕

안

녕

__name__이라는 변수는 파이썬에서 해당 모듈의 이름이 저장됨   
"실행하는 코드"에서는 __main__값이 들어감

* test.py

print('test.py __name__ : ', __name__)

test.py __name__ :  __main__

* start.py

import test

print('start.py __name__ : ', __name__)

test.py __name__ :  test
start.py __name__ :  __main__

파이썬에서 모듈을 import하면 해당 모듈의 전역코드가 실행됨

* test2.py

def add_one(data):
    return data + 1

def add_two(data):
    return data + 2

# 파일 자체로 실행할 때는 실행되도록 하고, 모듈로써 실행할 땐 안되게 하기 위해 이렇게 작성하기도 함
if __name__ == '__main__':  # 모듈이 아니라, 해당 코드 직접 실행시만 아래 코드가 실행됨
    print(add_one(10))
    print(add_two(10))

11
12

* start2.py

import test2

print('start.py __name__ : ', __name__)
# 이 땐 test2에 있는 코드는 __name__이 모듈로써 실행이 돼서 __name__에 test2가 들어가 있어서 코드 실행 안됨

print('start.py __name__ : ', test2.add_one(10))
# 모듈의 있는 기능을 사용하려면 위와 같이 사용해야됨

start.py __name__ :  __main__
start.py __name__ :  11