class person：
類名，首字母要大寫
方法間呼叫，使用self.方法名()
class a:
def test(self):
print('1111')
def test2(self):
self.test()
print('22222')
a=a()
a.test2()
#1111
#22222
class a:
@classmethod
def run(cls):
print('類方法')
a=a()
a.run()
a.run()
class a:
@staticmethod
def run(cls):
print('靜態方法')
a=a()
a.run()
a.run()
類方法：呼叫類屬性
靜態不呼叫任何self，cls
例項方法，運算元據
實際應用：
class test:
count=0
def sum(self,num):
test.count+=int(num)
print('例項方法')
@staticmethod
def info():
print('靜態方法')
@classmethod
def show(cls):
print(cls.count)
print('類方法')
t=test()
t.info()
t.sum(5)
t.show()
# 靜態方法
# 例項方法
# 5# 類方法
__str__ 列印物件名呼叫
__new__ 開闢空間
__call__ 物件當作函式用
__del__ 沒有指標引用呼叫
class test:
# def __new__(cls, *args, **kwargs):
# print('-----------new---------')
def __init__(self, name):
self.name = name
print('**********====init')
def __call__(self, *args, **kwargs):
print('--------call-----------')
def __str__(self):
print('---------str----------')
s=self.name
return s
def __del__(self):
print('---------del------------')
# def __new__(cls, *args, **kwargs):
# print('**********====new')
t = test('tom')
print(t)
t()# **********====init
# ---------str----------
# tom
# --------call-----------
# ---------del------------
#單例模式
#單例例模式就是確保乙個類只有乙個例項
#重寫__new__方法實現
# 應用場景：
# 很多地方同時呼叫就會例項多個浪費server資源
# 單例模式就可以解決！
class singleton:
__intance=none #私有化位址存放
def __new__(cls, *args, **kwargs):
if cls.__intance is none:
cls.__intance=object.__new__(cls)
return cls.__intance
else:
return cls.__intance
s=singleton()
s1=singleton()
print(s==s1) #true
class person():
def __init__(self, name, age):
self.name = name
self.__age = age
def __str__(self):
return 'name:{},age:{}'.format(self.name, self.__age)
p=person('tom',18)
print(p)
print(p.name)
#print(age) 不能呼叫私有
#使用get和set操作
def setage(self, age):
self.__age = age
def getage(self):
return self.__age
p.setage(19)
print(p.getage())
print(p.__dir__())
print(p._person__age) #只是間接系統改名，還是可以訪問
@property
def age(self):
return self.__age
@age.setter
def age(self, age):
self.__age = age
p=person('tom',10)
p.age=20
print(p.age)
2.is a 父子類
class father:
def __init__(self, name):
self.name = name
def a(self):
print('------fa')
def b(self):
print('--------fb')
class son1(father):
def __init__(self, name, age):
# 呼叫父類
super().__init__(name)
self.age = age
# override重寫(覆蓋)
def a(self,***):
super().a()
print('----son1.a_{}'.format(***))
class son2(father):
def __init__(self, name, color):
super().__init__(name)
self.color = color
s1 = son1('tom', 18)
s1.a('tttt')
s2 = son2('jimmy', 'red')
s2.b()
經典類：從左到右，深度優先 python2
新式類：廣度優先 python3
class p1:
def foo(self):
print('p1---foo')
class p2:
def foo(self):
print('p2--foo')
def bar(self):
print('p2--bar')
class c1(p1,p2):
pass
class c2(p1,p2):
def bar(self):
print('c2---bar')
class d(c1,c2):
pass
#檢視順序
import inspect
print(inspect.getmro(d))
print(d.__mro__)
d=d()
d.foo()
d.bar()
# p1---foo
# c2---bar
class animal:
pass
class person(animal):
pass
class pet(animal):
pass
def func(obj):
obj.run()
func(peo1)
func(pig1)
func(d1)
python物件導向學習 python物件導向學習
物件導向最重要的概念就是類 class 和例項 instance 必須牢記類是抽象的模板，比如student類，而例項是根據類建立出來的乙個個具體的 物件 每個物件都擁有相同的方法，但各自的資料可能不同。物件導向三個概念 1.封裝 即把客觀事物封裝成抽象的類，並且類可以把自己的資料和方法讓可信的類進...
python物件導向總結 Python物件導向總結
python 物件導向 oop 1 物件導向 是乙個更大封裝，把乙個物件封裝多個方法 2 類 是對一些具有相同特徵或行為的事物的乙個統稱，是抽象的，不能直接使用 特徵被稱為屬性 行為被稱為方法 3 物件 是由類建立出來的乙個具體的存在，可以直接使用 先有類再有物件，類只有乙個，而物件可以有多個 類中...
python登入物件導向 python 物件導向
一 屬性和方法 1.a a 例項屬性 通過例項物件來新增的屬性就是例項屬性 a.count 10 例項方法都是在類中直接定義的 以self為第乙個引數的方法都是例項方法 當通過例項物件呼叫時，會自動傳遞當前物件作為self傳入 當通過類物件呼叫時，不會自動傳遞self a.test 等價於 a.te...