In [1]:
a = "str"
In [2]:
class Dummy:
pass
In [3]:
d = Dummy()
In [4]:
d.name = "더미"
In [5]:
def toString(self):
print(self.name)
In [6]:
d.to_string = toString(d)
In [7]:
d.to_string
In [8]:
d.to_string()
In [9]:
d.to_string = toString
In [10]:
d.to_string(d)
In [11]:
d.get_name = lambda self: self.name
In [12]:
d.get_name(d)
Out[12]:
In [13]:
class Car:
count = 0
def plus_cnt(self):
Car.count += 1
def get_cnt(self):
return Car.count
In [14]:
c1 = Car()
c2 = Car()
In [15]:
c1.plus_cnt()
c2.plus_cnt()
In [16]:
print(c1.get_cnt())
print(c2.get_cnt())
In [17]:
class Book:
name = "pattern"
In [18]:
b1 = Book()
In [19]:
b2 = Book()
In [20]:
b1.name
Out[20]:
In [21]:
b2.name
Out[21]:
In [22]:
Book.name = "java"
In [23]:
b1.name
Out[23]:
In [24]:
b2.name
Out[24]:
In [25]:
b1.name = "python" #인스턴스 변수 name 하나를 생성한다. 그리고 그 인스턴스에 python을 저장 한다.
In [26]:
b2.name #b2 객체에는 name이라는 인스턴스 변수가 없다 그래서 스코핑룰에 의해 클래스 변수 name의 내용인 출력된다.
Out[26]:
In [27]:
b1.name #b1 객체에는 좀전에 name이라는 인스턴스 변수를 생성하고 거기에 python을 입력 했으므로 그인스턴스 변수의 내용이 출력된다.
Out[27]:
In [28]:
def func1(self,a):
self.a = a
In [29]:
def func2(self,b):
self.b = b
In [30]:
class Test():
f1 = func1
f2 = func2
def show_attr(self):
print("(a:{}, b:{})".format(self.a, self.b))
In [31]:
inst = Test()
inst.f1(1)
In [32]:
inst.f2(2)
In [33]:
inst.show_attr()
In [34]:
func1(inst, 77)
In [35]:
inst.show_attr()
In [45]:
class Test2:
var = 100
def method1(self):
print(var)
var = 200
In [46]:
inst = Test2()
In [47]:
inst.method1()
In [48]:
class Test3:
var = 100
In [52]:
def func_test2(self):
print(self.var)
def func2_test2(self):
print(var)
In [53]:
inst = Test3()
var = '외부 전역 변수 입니다.'
In [55]:
"""
Test3인스턴스의 인스턴스 변수 var를 찾는다 그런데 없네?
그래서 스코핑 룰에 의해 상위의 네임스페이스를 뒤진다 그래서 클래스 변수 var의 값이 출력된다.
"""
func_test2(inst)
In [56]:
"""
이럴 경우 출력하려는 var는 self의 var가 아니라 func2_test2와 같은 레벨에 있는 즉 전역에있는 var를 찾는다.
"""
func2_test2(inst)
In [57]:
class Test:
def __init__(self, a, b):
self.a = a #인스턴스 네임스페이스에 a등록
self.b = b #인스턴스 네임스페이스에 b등록
@classmethod
def cls_method(cls, a, b, c):
cls.a = a #클래스 네임스페이스에 a등록
cls.b = b #클래스 네임스페이스에 b등록
cls.c = c #클래스 네임스페이스에 c등록
In [58]:
test_a = Test(1,2)
In [59]:
test_a.cls_method(3,4,5)
In [60]:
test_a.a
Out[60]:
In [61]:
test_a.b
Out[61]:
In [62]:
test_a.c
Out[62]:
In [63]:
outter = 1
In [92]:
class Out:
def to_string(self):
print(self.outter)
def cls_setter(cls):
cls.outter = 200
@staticmethod #꼭 붙여줘야 한다. 안그러면 self에 해당하는 인자를 넘길려고 한다.
def func_firt():
print("about Algorithm")
In [93]:
o = Out()
o.cls_setter() #자동으로 o인스턴스의 타입인 Out클래스가 인자로 넘어간다.
In [94]:
o.to_string()
In [95]:
o.func_firt()
In [96]:
Out.func_firt()
In [97]:
mylist = []
mylist_append = getattr(mylist, "append")
mylist_append(10)
In [98]:
print(mylist)
In [100]:
class Container_x:
@staticmethod
def func_first():
print("First")
@staticmethod
def func_second():
print("Second")
@staticmethod
def func_third():
print("Third")
In [101]:
list1 = ["first"]
list2 = ["second"]
list3 = ["third"]
In [108]:
"""
일종의 디자인 패턴이네!
"""
def func_selector(data):
sel_func = getattr(Container_x, "func_{}".format(data[0]))
return sel_func()
In [109]:
func_selector(list1)
In [110]:
func_selector(list2)
In [111]:
type(func_selector(list3))
Out[111]:
In [112]:
class House2(object):
company = "Python Factory"
def __init__(self, year, acreages, address, price):
self.__year = year
self.__acreages = acreages
self.__address = address
self.__price = price
def show_company(self):
print(House2.company)
def change_price(self, rate):
self.__price = __self.price * rate
def show_info(self):
print("""This house is built by {} in {},
acreages : {},
address : {},
price : {}""".format(House2.company, self.__year, self.__acreages, self.__address, self.__price))
In [113]:
h = House2(2010,10,20,20)
In [114]:
h.show_info()
In [117]:
h._House2__price #이렇게 하면 private의 인스턴스변수도 접근 할 수 있게 된다.
Out[117]:
In [118]:
dir(h)
Out[118]:
In [119]:
class Ticket():
def __init__(self, distance):
self.__distance = distance
def get_distance(self):
return "{} m(meter) ".format(self.__distance)
def set_distance(self, distance):
self.__distance = distance
def get_fare(self):
return "{} \\(Won) ".format(self.__distance * 13)
In [120]:
p1 = Ticket(15000)
In [121]:
print(p1.get_distance())
In [122]:
print(p1.get_fare())
In [123]:
p1.set_distance(30000)
In [124]:
print(p1.get_fare())
In [125]:
dir(Ticket)
Out[125]:
In [126]:
dir(p1)
Out[126]:
In [130]:
class Ticket():
def __init__(self, distance):
self.__distance = distance
@property
def distance(self):
return "{} m(meter) ".format(self.__distance)
@distance.setter
def distance(self, distance):
self.__distance = distance
@property
def fare(self):
return "{} \\(Won) ".format(self.__distance * 13)
In [131]:
p1 = Ticket(1500000)
In [132]:
print(p1.distance)
In [134]:
p1.distance = 3000
In [135]:
print(p1.distance)
In [143]:
class Parent:
var = "hello"
def __init__(self, money):
self.__money = money
def show_money(self):
print(self.__money)
In [144]:
class Child(Parent):
var = "Hi~"
def get_var(self):
print(self.var) #먼저 클래스변수 부터 점검 한다.
In [145]:
c = Child(150) #초기화 메서드까지 상속 받는거 같다.
c.show_money()
In [146]:
c.get_var()
In [152]:
class Account():
def __init__(self, money):
self.balance = money
def deposit(self, money):
self.balance += money
def withdraw(self, money):
self.balance -= money
def show_Account(self):
print("Balance : {}원".format(self.balance))
In [153]:
class YellowAccount(Account):
def deposit(self, money):
self.balance += money * 1.07
def withdraw(self, money):
self.balance -= money + 10
In [154]:
a1 = YellowAccount(100)
In [155]:
a1.show_Account()
In [156]:
a1.deposit(200)
In [157]:
a1.show_Account()
In [158]:
class BlueAccount(Account):
def __init__(self, name, money):
Account.__init__(self, money)
self.name = name
def show_Account(self):
Account.show_Account(self)
print("Account owner : {}".format(self.name))
In [160]:
b = BlueAccount("Alice",300)
In [161]:
b.show_Account()
In [ ]: