ch1 - 1. 파이썬 구조 및 기초 - 1

1.1 설정하기

Index

• 구름IDE환경설정(계속)

• 구름IDE로 파이썬 실행하기

• 주석처리하기

1.1 구름IDE환경설정(계속)

https://ide.goorm.io/

1.2 구름IDE로 파이썬 실행하기

1. 먼저 구름IDE에서 위에서 만든 컨테이너 안에 python 폴더를 하나 만들어 줍니다.

1.3 주석처리하기(계속)

#행 단위 주석입니다.
"""
큰 따옴표로 세번 묶거나
작은따옴표로 세번 묶으면
열단위 주석이 됩니다.
"""

1) 행 단위 주석(#)

#행 단위 주석입니다.

2) 열 단위 주석(''',""")

"""
큰 따옴표로 세번 묶거나
작은 따옴표로 세번 묶으면
열단위 주석이 됩니다.
"""

1.2 변수

Index

1. 입력함수_input

2. input_print

3. 출력함수_print

4. 변수의 type
4.1 변수
4.2 변수의 자료형
4.3 숫자 자료형
4.4 문자 자료형
4.5 문자열의 활용

5. 형변환

1. 입력함수_input

a = input("a를 입력하세요:")

a를 입력하세요: 10

2. input과 print

age = input('age를 입력하세요:')
lastname = input('lastname을 입력하세요:')
firstname = input('firstname을 입력하세요:')
print('당신의 이름은 ', lastname + firstname, '입니다.')
print('당신의 나이는 ', age, '입니다.')

age를 입력하세요: 22
last name을 입력하세요: hong
firstname을 입혁하세요: gildong
당신의 이름은 honggildong 입니다.
당신의 나이는 22 입니다.

3. 출력함수 print

age = 22
name = 'honggildong'

print('1. 제 이름은 ', name, '입니다. 제 나이는 ', age, '입니다')
print('2. 제 이름은 {}입니다. 제 나이는 {}입니다.'.format(name, age))
print('3. 제 이름은 %s입니다. 제 나이는 %d입니다.'%(name,age))

1. 제 이름은 honggildong입니다. 제 나이는 22입니다.
2. 제 이름은 honggildong입니다. 제 나이는 22입니다.
3. 제 이름은 honggildong입니다. 제 나이는 22입니다.

4. 변수의 type

a = 10
b = 10.1
c = -1
d = True
e = 'good'
f = '10'
g = 'kim'
h = 'honggildong'
i = 'example'
j = 10 + 2j
k = 0b110
l = 0o56
m = 0xAC

print('type(10) : ', type(a))
print('type(10.1) : ', type(b))
print('type(-1) : ', type(c))
print('type(True) : ', type(d))
print('type(\'good\') : ', type(e))
print('\'10\' + \'10\' : ', f + f)
print('\'10\' * 3', f * 3)
print('\'hong\' + \'gildong\'', g + h)
print('type(\'gildong\') : ', type(h))
print('type(\'gildong100!!\') : ', type(i))
print('type(10 + 2j) : ', type(j))
print('type(0b110) : ', type(k))
print(k)
print('type(0o56) : ', type(i))
print(i)
print('type(0xAC) : ', type(m))
print(m)

type(10) : <class 'int'>
type(10.1) : <class 'float'>
type(-1) : <class 'int'>
type(True) : <class 'bool'>
type('good') : <class 'str'>
'10' + '10' : 1010
'10' * 3 101010
'hong' + 'gildong' honggildong
type('gildong') : <class 'str'>
type('gildong100!!') : <class 'str'>
type(10 + 2j) : <class 'complex'>
type(0b110) : <class 'int'>
6
type(0o56) : <class 'int'>
46
type(0xAC) : <class 'int'>
172

4.1. 변수

4.2 변수의 자료형

4.3 숫자 자료형

A = 486
B = 0b100
C = 0o56
D = 0xAC
E = 3.14
F = 4-4j

print(type(A))
print(type(B))
print(type(C))
print(type(D))
print(type(E))
print(type(F))

<class 'int'>
<class 'int'>
<class 'int'>
<class 'int'>
<class 'float'>
<class 'complex'>

4.4 문자 자료형

• 시퀀스 자료형이란 무엇일까요?

valString = 'abc'
valList = [1, 2, 3]
valTuple = (1, 2, 3)
print(valString[0])
print(valString[1])
print(valString[2])
print(valList[0])
print(valList[1])
print(valList[2])
print(valTuple[0])
print(valTuple[1])
print(valTuple[2])

a
b
c
1
2
3
1
2
3

4.5 문자열의 활용

name = 'Guido van Rossum'
print(name[0])

G

birth = "1994.08.13"
year = birth[:4]
month = birth[5:7]
day = birth[8:]
print("태어난 연도 : ", year)
print("태어난 월 : ", month)
print("태어난 일 : ", day)

태어난 연도 : 1998
태어난 월 : 01
태어난 일 : 2

5. 형 변환

print(type(int(3.5)))
print(int(3.5))
print(type(float(3)))
print(float(3))
print(type(str(3))
print(str(3))

<class 'int'>
3
<class 'float'>
3.0
<class 'str'>
3

x = input('Insert the number.')
y = input('Insert the number.')
print(x + y)
print(type(x))
print(type(y))

Insert the number.4
Insert the number.56
456
<class 'str'>
<class 'str'>

num = '123'
print(type(num))
print(type(int(num))

<class 'str'>
<class 'int'>

string = 123
print(type(string))
print(type(str(string)))

<class 'int'>
<class 'str'>

print("bool('test') : ", bool('test'))
print("bool(1) : ", bool(1))
print("bool(0) : ", bool(0))
print("bool(-1) : ", bool(-1))
print("bool(' ') : ", bool(' '))
print("bool('') : ", bool(''))
print("bool(None) : ", bool(None))

bool('test') : True
bool(1) : True
bool(0) : False
bool(-1) : True
bool(' ') : True
bool('') : False
bool(None) : False

1.3 연산

연산

a = 9
b = 2

print('a + b = ', a + b)
print('a - b = ', a - b)
print('a * b = ', a * b)
print('a ** b = ', a ** b)
print('a / b = ', a / b)
print('a // b = ', a // b)
print('a % b = ', a % b)

[OUTPUT]

a + b = 11
a - b = 7
a * b = 18
a ** b = 81
a / b = 4.5
a // b = 4
a % b = 1

numA = 25
numB = 40

print("numA // numB:", numA // numB)
print("numA / numB:", numA / numB)

[OUTPUT]

# 몫이기 때문에 정수로 나오며 0입니다.
numA // numB: 0
# 나눈 결과이기 때문에 소숫점까지 나옵니다.
numA / numB: 0.625

numA = 10
numB = 20

numA += numB

print("numA:", numA)
print("numB:", numB)

[OUTPUT]

# numA와 numB가 더해져서 numA는 30이 됩니다.
numA: 30
# numB는 변화가 없습니다.
numB: 20

a = 2
b = 3

print(a & b)

[OUTPUT]

0

# a의 값 2를 2진수로 풀어줍니다.
0010

# b의 값 3을 2진수로 풀어줍니다.
0011

# 위아래로 붙여보겠습니다.
0010
0011

# & 연산의 경우 위와 아래 한짝씩 맞춰 and 비교를 해봅시다. 
# 이때 1 = True, 0 = False 입니다.
0010
0011
----
0010

# 결과값을 다시 10진수로 변환합니다.
2

a = 7
b = 8

print(a | b)

[OUTPUT]

15

# a의 값 7을 2진수로 변환합니다.
0101

# b의 값 8을 2진수로 변환합니다.
1000

# 위아래로 붙여보겠습니다.
0101
1000

# 연산의 경우 위와 아래 한짝씩 맞춰 or 비교를 해봅니다. 
# 이때 1 = True, 0 = False 입니다.
0101
1000
----
1101

# 결과값을 다시 10진수로 변환해줍니다.
15

1. 10진수를 2진수로 변환

2. 2진수에서 비트연산을 전개

3. 결과값을 다시 10진수로 변환

a = 7
b = 2

print(a << b)

[OUTPUT]

28

# a의 값 3을 2진수로 바꿉니다.
0111

# b 만큼 이동할 것이기 때문에 b는 바꾸지 않음

# a의 값들(집합)을 왼쪽으로 b만큼 이동시키고 뒤에 0을 붙임
011100

# 결과 값을 10진수로 다시 변환합니다.
28

a = 7
b = 2

print(a >> b)

[OUTPUT]

1

# a의 값 7을 2진수로 바꿉니다.
0111

# b만큼 이동할 것이기 때문에 b는 바꾸지 않음

# a의 값들(집합)을 오른쪽으로 b만큼 이동시키고 넘어간 것을 잘라냄
0001(11) # ()는 넘어간 것을 의미합니다. 이것들은 잘라내어 버립니다.

0001

# 결과 값을 10진수로 다시 변환합니다.
1

a = [1, 2, 3, 4, 5]

print(1 in a)

[OUTPUT]

True

a = [1, 2, 3, 4, 5]

print(0 not in a)

[OUTPUT]

True

coffee = "Brand"
orange = "Brand"

print(coffee is orange)
print(coffee == orange)

[OUTPUT]

True
True

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print('a == b', a == b)
print('a == c', a == c)
print('a is b', a is b)
print('a is c', a is c)

[OUTPUT]

a == b True
a == c True
a is b False
a is c True

1.4 함수

Index

• 들여쓰기

• function

• function 연습

• global

• function 응용

• 연산자 우선순위

들여쓰기

#들여쓰기
def printnum():
    print('1')
    print('2')
    print('3')
printnum()

1
2
3

def printnum():
    print('1')
    print('2')
print('3')
printnum()

3
1
2

function

def finction(x,y)
    z = x + y
    return z
print("function(5,7) = ", function(5,7))

function(5,7) = 12

def function(x,y): #Input
    z = x + y      #Function
    print(z)       #Output?
print("function(5,7) = ", function(5,7))

12
function(5,7) = None

function 연습

PI = 3.14
def circle(r,inputpi):
    z = r*r*inputpi
    return z
result = circle(10, PI)
print(result)

result : 314.0

π = 3.14 
def circle(r, inputpi):
    z = r*r*inputpi
    return z
result = circle(10,π)
print(result)

result : 314.0

def 한글코딩(글자):
    print(글자)
한글코딩('안녕, 세상아.')

안녕, 세상아

전역변수 global

x = 10
def addx():
    global x
    x = x + 1
    return x 
result = addx()
print("result : " , result)

result : 11 

지역변수와 전역변수를 왜 나누어 놓았나요?

# global 사용전
a = 100
def f():
    a = a + 1
f()

# global 사용후
a = 100
def f():
    global a 
    a = a + 1
f()

function 응용

함수안에 함수 만들기

def 함수이름1():
    코드
    def 함수이름2():
        코드

def print_text():
    text = 'Python 기초 배우기!'
    def print()
        print(text)
    print()

print_text()

Python 기초 배우기!

연산자 우선순위

1.5 자료형

자료형 Type

1. List

2. Tuple

3. Set

4. Dictionary

List

리스트는 순서를 가진 데이터들의 집합입니다.

number = [ 0, 1, 2, 3, 4, 5]
coffee = [ "Espresso", "Espresso Ristretto", "Espresso Lungo", "Americano" ]

messed_list = [ 100, "Study Python", 300, "Whatever", ["Complex", 50 ] ]

접근 (Access)

numbers = [ 0, 1, 2, 3, 4, 5]
coffee = [ "Espresso", "Espresso Ristretto", "Espresso Lungo", "Americano" ]

print("numbers:", numbers[0])
print("coffee:", coffee[1])

[OUTPUT]

numbers: 0
coffee: Espresso Ristretto

coffee = [ "Espresso", "Espresso Ristretto", "Espresso Lungo", "Americano" ]

print(coffee[10])

[OUTPUT]

Traceback (most recent call last):
  File "/studyLab.py", line 3, in <module>
    print(coffee[10])
IndexError: list index out of range

coffee = [ "Espresso", "Espresso Ristretto", "Espresso Lungo", "Americano" ]

print(coffee[-1])
print(coffee[-2])
print(coffee[-3])

[OUTPUT]

Americano
Espresso Lungo
Espresso Ristretto

coffee = [ "Espresso", "Espresso Ristretto", "Espresso Lungo", "Americano" ]


# 1. 리스트 전체를 호출 하는 경우
print(coffee)
print(coffee[:])
# 2. 리스트 인덱스 1 ~ 3 까지를 출력하고 싶을 경우
print(coffee[1:3])
# 3. 리스트 인덱스 1부터 끝까지 출력하고 싶은 경우
print(coffee[1:])
# 4. 리스트 인덱스 처음부터 2까지를 출력하고 싶을 경우
print(coffee[:3])
# 5. 리스트의 처음부터 시작하여 2만큼 건너뛰면서 호출하고 싶은 경우
print(coffee[::2])
# 6. 리스트 인덱스 처음부터 리스트 인덱스의 범위를 넣어가는 숫자를 넣을 경우
print(coffee[0:5])

[OUTPUT]

# 1. 리스트 전체를 호출 하는 경우
['Espresso', 'Espresso Ristretto', 'Espresso Lungo', 'Americano']
['Espresso', 'Espresso Ristretto', 'Espresso Lungo', 'Americano']
# 2. 리스트 인덱스 1 ~ 2 까지를 출력하고 싶을 경우
['Espresso Ristretto', 'Espresso Lungo']
# 3. 리스트 인덱스 1부터 끝까지 출력하고 싶은 경우
['Espresso Ristretto', 'Espresso Lungo', 'Americano']
# 4. 리스트 인덱스 처음부터 2까지를 출력하고 싶을 경우
['Espresso', 'Espresso Ristretto', 'Espresso Lungo']
# 5. 리스트의 처음부터 시작하여 2만큼 건너뛰면서 호출하고 싶은 경우
['Espresso', 'Espresso Lungo']
# 6. 리스트 인덱스 처음부터 리스트 인덱스의 범위를 넣어가는 숫자를 넣을 경우
['Espresso', 'Espresso Ristretto', 'Espresso Lungo', 'Americano']

리스트에 있는 데이터는 추가, 수정, 삭제를 할 수 있습니다.

추가

coffee = [ "Americano" ]

# 뒤에 삽입하고 싶은 경우
coffee = coffee + [ "Espresso" ]
print(coffee)

# 앞에 삽입하고 싶은 경우
coffee = [ "Ristretto" ] + coffee
print(coffee)

# 앞, 뒤 한번에 하고 싶은 경우
coffee = [ "Lungo" ] + coffee + [ "Cappuccino" ]
print(coffee)

[OUTPUT]

# 뒤에 삽입하고 싶은 경우
['Americano', 'Espresso']
# 앞에 삽입하고 싶은 경우
['Ristretto', 'Americano', 'Espresso']
# 앞, 뒤 한번에 하고 싶은 경우
['Lungo', 'Ristretto', 'Americano', 'Espresso', 'Cappuccino']

coffee = [ "Espresso", "Americano" ]

double_coffee = coffee * 2
print(double_coffee)

[OUTPUT]

['Espresso', 'Americano', 'Espresso', 'Americano']

coffee = [ "Americano" ]
coffee.append("Cafe Latte")

print(coffee)

[OUTPUT]

[ 'Americano', 'Cafe Latte' ]

coffee = [ "Americano" ]

coffee.extend([ "Cafe Mocha", "Ristretto" ])
print(coffee)

other_menu = [ "Ice tea", "Green Tea" ]
coffee.extend(other_menu)
print(coffee)

[OUTPUT]

['Americano', 'Cafe Mocha', 'Ristretto']
['Americano', 'Cafe Mocha', 'Ristretto', 'Ice tea', 'Green Tea']

coffee = [ "Americano" ]
coffee.insert(1, "Maxim Mocha Gold")
coffee.insert(2, "Strawberry Yogurt Blended")
coffee.insert(10, "More Info")

print(coffee)

[OUTPUT]

['Americano', 'Maxim Mocha Gold', 'Strawberry Yogurt Blended', 'More Info']

수정

coffee = [ "Espresso", "Espresso Ristretto", "Espresso Lungo" ]
coffee[1] = "Ristretto"
coffee[2] = "Lungo"

print(coffee)

[OUTPUT]

[ 'Espresso', 'Ristretto', 'Lungo' ]

삭제

coffee = [ "Espresso", "Cafe Mocha", "Espresso Ristretto", "Espresso Lungo" ]
# "Cafe Mocha" 문자열을 삭제하고 싶습니다.
del coffee[1]

print(coffee)

[OUTPUT]

['Espresso', 'Espresso Ristretto', 'Espresso Lungo']

coffee = [ "Espresso", "Cafe Mocha", "Cafe Mocha", "Dolce Latte" ]
coffee.remove("Cafe Mocha")

print(coffee)

[OUTPUT]

['Espresso', 'Cafe Mocha', 'Dolce Latte']

그 외에 리스트의 다른 내장함수들을 살펴보도록 하겠습니다.

정렬

coffee = [ "Espresso", "Cafe Mocha", "Cafe Mocha", "Dolce Latte" ]

# 오름차순 정렬
coffee.sort()
print(coffee)

# 내림차순 정렬
coffee.sort(reverse=True)
print(coffee)

[OUTPUT]

# 오름차순 정렬
['Cafe Mocha', 'Cafe Mocha', 'Dolce Latte', 'Espresso']
# 내림차순 정렬
['Espresso', 'Dolce Latte', 'Cafe Mocha', 'Cafe Mocha']

cafe_menu = [ 
	"1.Espresso",
	"2.Cafe Mocha",
	"3.Cafe Mocha",
	"11.Dolce Latte",
	"12.Ice tea",
	"13.Green Tea" ]
cafe_menu.sort()

print(cafe_menu)

[OUTPUT]

['1.Espresso', '11.Dolce Latte', '12.Ice tea',
 '13.Green Tea', '2.Cafe Mocha', '3.Cafe Mocha']

반전

coffee = [ "Espresso", "Espresso Ristretto", "Espresso Lungo", "Americano" ]

coffee.reverse()
print(coffee)

[OUTPUT]

['Americano', 'Espresso Lungo', 'Espresso Ristretto', 'Espresso']

coffee = [ "Espresso", "Espresso Ristretto", "Espresso Lungo", "Americano" ]

print(coffee[::-1])

[OUTPUT]

['Americano', 'Espresso Lungo', 'Espresso Ristretto', 'Espresso']

원하는 데이터 개수 세기

coffee = [ "Espresso", "Cafe Mocha", "Cafe Mocha", "Dolce Latte" ]

print(coffee.count("Cafe Mocha"))

[OUTPUT]

2

Tuple

number_list = [1, 2, 3]
number_tuple = (1, 2, 3)

number_list[1] = 4
print(number_list)

number_tuple[1] = 4
print(number_tuple)

# number_list
[1, 4, 3]
# number_tuple
Traceback (most recent call last):
  File "/study.py", line 7, in <module>
    tuple[1] = 4
TypeError: 'number_tuple' object does not support item assignment

Set

number_set = set([1, 1, 2, 2, 3, 3, 4])
print(number_set)

[OUTPUT]

{1, 2, 3, 4}

number_set = set('apple coffee')
print(number_set)

[OUTPUT]

{'o', 'e', 'c', ' ', 'l', 'f', 'p', 'a'}

menu = set(['americano', 'cafe latte'])
menu.add('ice coffee')
print(menu)

[OUTPUT]

{'cafe latte', 'ice coffee', 'americano'}

menu = set(['americano', 'cafe latte'])
menu.update(['ice coffee', 'ice tea', 'green tea'])
print(menu)

[OUTPUT]

{'ice coffee', 'green tea', 'americano', 'ice tea', 'cafe latte'}

menu = set(['americano', 'cafe latte'])
menu.remove('cafe latte')
print(menu)

[OUTPUT]

{'americano'}

my_cafe = set(['americano', 'water', 'yogurt strawberry blended', 'cafe latte'])
other_cafe = set(['americano', 'water', 'green tea'])

print(my_cafe & other_cafe)
print(my_cafe.intersection(other_cafe))

[OUTPUT]

{'water', 'americano'}
{'water', 'americano'}

my_cafe = set(['americano', 'water', 'yogurt strawberry blended', 'cafe latte'])
other_cafe = set(['americano', 'water', 'green tea'])

print(my_cafe | other_cafe)
print(my_cafe.union(other_cafe))

[OUTPUT]

{'americano', 'green tea', 'cafe latte', 'yogurt strawberry blended', 'water'}
{'americano', 'green tea', 'cafe latte', 'yogurt strawberry blended', 'water'}

my_cafe = set(['americano', 'water', 'yogurt strawberry blended', 'cafe latte'])
other_cafe = set(['americano', 'water', 'green tea'])

print(my_cafe - other_cafe)
print(my_cafe.difference(other_cafe))

[OUTPUT]

{'yogurt strawberry blended', 'cafe latte'}
{'yogurt strawberry blended', 'cafe latte'}

Dictionary

{ key : value }

teammate_age = { 'Kevin': 15, 'Dean': 20, 'Berra': 17 }

menu = { 
	coffee : ['americano', 'cafe latte', 'mocah latte'],
	tea: ['green tea', 'black tea'],
	fruits: ['orange juice', 'pineapple juice']
}

my_score = {
    'korean': 90,
    'english': 80,
    'math': 100
}

my_score['science'] = 95

print(my_score)

[OUTPUT]

{'korean': 90, 'english': 80, 'math': 100, 'science': 95}

my_score = {
    'korean': 90,
    'english': 80,
    'math': 100
}

del my_score['english']

print(my_score)

[OUTPUT]

{'korean': 90, 'math': 100}

# 국어 성적을 알고 싶은 경우
my_score = {
    'korean': 90,
    'english': 80,
    'math': 100
}

print(my_score['korean'])
# get 함수를 이용하여 가져올 수도 있습니다.
print(my_score.get('korean'))

# 다만 해당하는 키가 없을 때
# 키값만을 이용하여 가져오는 경우에는 오류가 발생하며 get을 사용할 때에는 None을 리턴합니다.
# 오류에 대한 예외처리가 있는 안전한 get을 사용하는 것이 바람직해 보입니다.

[OUTPUT]

90
90

my_score = {
    'korean': 90,
    'english': 80,
    'math': 100,
    'math': 90
}

print(my_score)

[OUTPUT]

{'korean': 90, 'english': 80, 'math': 90}

map_check = {
    (1, 3): 10293,
    (1, 2): 39492,
    (1, 1): 49377,
    (1, 4): 12375
}

print(map_check)

[OUTPUT]

{(1, 3): 10293, (1, 2): 39492, (1, 1): 49377, (1, 4): 12375}

my_check = {
    [1, 3]: 10293,
    [1, 2]: 39492,
    [1, 1]: 49377,
    [1, 4]: 12375
}

print(my_check)

[OUTPUT]

Traceback (most recent call last):
  File "/study.py", line 5, in <module>
    [1, 4]: 12375
TypeError: unhashable type: 'list'

map_check = {
    (1, 3): 10293,
    (1, 2): 39492,
    (1, 1): 49377,
    (1, 4): 12375
}

print(map_check.keys())

[OUTPUT]

dict_keys([(1, 3), (1, 2), (1, 1), (1, 4)])

map_check = {
    (1, 3): 10293,
    (1, 2): 39492,
    (1, 1): 49377,
    (1, 4): 12375
}

print(map_check.values())

[OUTPUT]

dict_values([10293, 39492, 49377, 12375])

map_check = {
    (1, 3): 10293,
    (1, 2): 39492,
    (1, 1): 49377,
    (1, 4): 12375
}

print(map_check.items())

[OUTPUT]

dict_items([((1, 3), 10293), ((1, 2), 39492), ((1, 1), 49377), ((1, 4), 12375)])

my_score = {
    'korean': 90,
    'english': 80,
    'math': 100
}

print('math' in my_score)
print('science' in my_score)

[OUTPUT]

True
False

1.6 클래스

클래스

class Car(object):
	MaxSpeed = 300
	MaxPeople = 5
	def move(self, x):
		print(x, '의 스피드로 움직이고 있습니다.')
	def stop(self):
		print('멈췄습니다.')

k5 = Car()
k3 = Car()
k5.move(10)
k5.stop()
k3.move(5)
k3.stop()

print(k5.MaxSpeed)
print(k3.MaxSpeed)

[OUTPUT]

10 의 스피드로 움직이고 있습니다.
멈췄습니다.
5 의 스피드로 움직이고 있습니다.
멈췄습니다.
300
300

클래스 변수

class Car(object):
	# 클래스 변수 위치 (파이썬 규약에 따라 indent로 결정)
	kinds = []
	MaxSpeed = 300
	MaxPeople = 5
	def move(self, x):
		print(x, '의 스피드로 움직이고 있습니다.')
	def stop(self):
		print('멈췄습니다.')

k5 = Car()
Car.kinds.append('k5')
k3 = Car()
Car.kinds.append('k3')

print(k5.kinds)

[OUTPUT]

['k5', 'k3']

class Car(object):
	kinds = []
	speed = 300
	def add_kinds(self, name):
		self.kinds.append(name)
	def change_speed(self, speed):
		self.speed = speed

k5 = Car()
k3 = Car()
k5.add_kinds('k5')
k3.add_kinds('k3')
k5.change_speed(500)
k3.change_speed(250)

print('k5.kinds:', k5.kinds)
print('k3.kinds:', k3.kinds)
print('k5.speed:',k5.speed)
print('k3.speed:',k3.speed)

[OUTPUT]

k5.kinds: ['k5', 'k3']
k3.kinds: ['k5', 'k3']
k5.speed: 500
k3.speed: 250

__init__ 함수

class Car(object):
	kinds = []
	MaxSpeed = 300
	MaxPeoeple = 5
	def __init__(self, name):
		Car.kinds.append(name)
	def move(self, x):
		print(x, '의 스피드로 움직이고 있습니다.')
	def stop(self):
		print('멈췄습니다.')

k5 = Car('k5')
k3 = Car('k3')
print(k5.kinds)
print(k3.kinds)

[OUTPUT]

['k5', 'k3']

인스턴스 변수

class Car(object):
    # 클래스 변수
    max_speed = 300

    def __init__(self, name):
        # 인스턴스 변수
        self.kinds = []
        self.auto_drive = False
        self.kinds.append(name)

    def add_auto_drive(self):
        self.auto_drive = True


my_car = Car('mini')
your_car = Car('big')

print('my_car.kinds:', my_car.kinds)
print('your_car.kinds:', your_car.kinds)

print('my_car.auto_drive:', my_car.auto_drive)
my_car.add_auto_drive()
print('my_car.auto_drive:', my_car.auto_drive)
print('your_car.auto_drive:', your_car.auto_drive)

[OUTPUT]

my_car.kinds: ['mini']
your_car.kinds: ['big']
my_car.auto_drive: False
my_car.auto_drive: True
your_car.auto_drive: False

상속

class Car(object):
  maxSpeed = 300
  maxPeople = 5
  def __init__(self, name):
    self.kinds = []
    self.kinds.append(name)
  def move(self, x):
    print(x, '의 스피드로 움직이고 있습니다.')
  def stop(self):
    print('멈췄습니다.')

class HybridBigCar(Car):
  battery = 1000
  batteryKM = 300
  maxPeople = 7
  def electronic_power(self):
    print('전기를 생산합니다')

my_car = Car('mini')
my_second_car = HybridBigCar('e-big')

print(my_second_car.kinds)
print(my_second_car.battery)
print(my_second_car.maxPeople)
my_second_car.electronic_power()

[OUTPUT]

['e-big']
1000
7
전기를 생산합니다

다중 상속

class Car(object):
  maxSpeed = 300
  maxPeople = 5
  def __init__(self, name):
    self.kinds = []
    self.kinds.append(name)
  def move(self, x):
    print(x, '의 스피드로 움직이고 있습니다.')
  def stop(self):
    print('멈췄습니다.')


class MaxWheel(object):
  wheel = 19

class MiniWheel(object):
  wheel = 15

class LargeCar(Car, MaxWheel):
  pass

class CompactCar(Car, MiniWheel):
  pass

my_car = LargeCar('big')
your_car = CompactCar('mini')

print(my_car.wheel)
print(your_car.wheel)

[OUTPUT]

19
15

class Car(object):
  maxSpeed = 300
  maxPeople = 5
  def __init__(self, name):
    self.kinds = []
    self.kinds.append(name)
  def move(self, x):
    print(x, '의 스피드로 움직이고 있습니다.')
  def stop(self):
    print('멈췄습니다.')


class MaxWheel(object):
  wheel = 19
  def move(self, x):
    print(x, '의 스피드로 큰 차가 이동 중입니다.')

class MiniWheel(object):
  wheel = 15
  maxSpeed = 250
  def move(self, x):
    print(x, '의 스피드로 작은 차가 이동 중입니다.')

class TestWheel(object):
  def move(self, x):
    print(x, '의 스피드로 테스트 차가 이동 중입니다.')

class LargeCar(Car, MaxWheel):
  pass

class CompactCar(Car, MiniWheel):
  pass

class TestCar(Car, MaxWheel, TestWheel):
  pass

my_car = LargeCar('big')
your_car = CompactCar('mini')
test_car = TestCar('test')

print(my_car.wheel)
print(your_car.wheel)
print(your_car.maxSpeed)
your_car.move(100)
test_car.move(100)

[OUTPUT]

19
15
300
100 의 스피드로 움직이고 있습니다.
100 의 스피드로 움직이고 있습니다.

TestCar > Car > MaxWheel > TestWheel

특별 메소드(magic method)

class Cafe(object):
  def __init__(self, name):
    self.name = name
  def rename(self, name):
    self.name = name
  def __getattr__(self, item):
    print(item + '속성은 존재하지 않습니다.')

my_cafe = Cafe('Dutch')
print(my_cafe.name)
print(my_cafe.menu)

[OUTPUT]

Dutch
menu속성은 존재하지 않습니다.
None