python (programmation orientée objet)
Combinez votre propre conférencier et rédigez vos propres notes. Il y a des lacunes, et j'espère que vous pourrez commenter les lacunes. Tout le monde apprend les uns des autres. Bienvenue à laisser un message.
L'émergence de l'orientation objet
Un groupe avec les mêmes attributs accomplit une grande tâche.
Après avoir instancié et défini la classe, utilisez cette classe pour construire un objet (l'objet peut être plusieurs
init (self) [constructeur]
self se réfère à l'objet actuel instancié
python n'est pas un vrai constructeur, juste un rappel de l'instance, il ne peut pas être renvoyé)
# Définir une classe
classe A (objet): #define class, la première lettre du nom est en majuscule, la valeur par défaut () est la classe parente #object
construction (les attributs incluent des données et des méthodes)
pass
> class P():
> def __init__(self):
> print('+'*20)
>
> def __init__(self,name,age):
> self.name=name
> self.age=age
>
> def run(self):
> pass
>
> if __name__=='__main__':
> p=P()#实例化
> #p2=P('xxx',20)
Les méthodes et les fonctions sont des méthodes appartenant à différentes classes et des fonctions en dehors des instances.
Fonctionnalités du langage dynamique Python
#define une classe
classe P (objet): #define une classe, la première lettre du nom est en majuscule, la valeur par défaut () est la classe parente #object
construction (les attributs incluent des données et des méthodes)
pass
if name = = ' main ':
p = P ()
p.name = 'nom'
p.age = 10
print(p.name )
print(p.age )
print(hasattr(p,'name') )#hasatter作用在p上查找name属性
print(hasattr(p,'age') )
p.func=lambda x: x+1
print(p.func (1))
Appel d'instanciation d'objet, appel d'instanciation #define
une classe
classe A (objet): #define une classe, le nom est en majuscule, et la valeur par défaut () est la classe parente
#Object construction (les attributs incluent des données et des méthodes)
pass
class P():
def __init__(self,name,age):
self.name=name
self.age=age
def run(self):
print(self .name +'run...')
if __name__=='__main__':
p2=P('xxx',20)#实例化
print(p2 .age)
print(p2 .name)
La différence entre un type de variable et un type immuable # définir
une classe
classe A (objet): # définir une classe, le nom est en majuscule et la valeur par défaut () est la classe parente
# construction d'objet (les attributs incluent des données et des méthodes)
pass
class P():
has_two_eyes=[]#定义静态的属性
#def func(self):
# print('func invoke...')
def __init__(self,name,age):
self.name=name
self.age=age
def run(self):
print(self .name +'run...')
if __name__=='__main__':
p1=P('p1',1)#实例化对象
p2=P('p2',2)
# print(P .has_two_eyes )
#print(p1.has_two_eyes )
#print(p2.has_two_eyes )
###########################
#P.has_two_eyes +=1#静态属性的更新
#print(P .has_two_eyes )
#########################
#p1 .has_two_eyes +=1
#print(P.has_two_eyes )
#print(p2.has_two_eyes )
#print(p1 .has_two_eyes )
#print(id(P.has_two_eyes ) )
#print(id(p1.has_two_eyes ) )
##########################列表表示.int是不可变，列表是可以改变的类型
p1 .has_two_eyes .append(123)
print(p1 .has_two_eyes )
print(id(P.has_two_eyes ) )
print(id(p1.has_two_eyes ) )
Comment définir un objet (différentes instances, utiliser différents constructeurs,)
#define une classe de
classe Nom (objet): #define class, nommez la première lettre en majuscule, la valeur par défaut () est la classe parente #object
construction (les attributs incluent des données et Méthode (hors du constructeur appelé fonction))
def init (self, name, age): #constructor (méthode spéciale) add attributes: name, age (self est l'objet courant this)
self.name = name #construct attributes (comme la tasse moule)
self.age = age
def __del__(self):#类的属性都一样（就是对象有相同的属性:如吃）
print(self .__class__.__name__+'name del')
def eat(self):
print(self .__class__ .__name__+'eat')
def move(self):
print(self .__class__ .__name__ +'move')
Encapsulation (privatisation des propriétés -> fournir en externe des méthodes pour modifier les propriétés) python n'est pas valide dans le module, valide dans la classe (le "__name" à l'intérieur de la classe est un trait de soulignement simple (attribut privé, accessible), double trait de soulignement (attribut privé, inaccessible) il y a des traits de soulignement avant et après (attributs spéciaux)
Héritage (les sous-classes peuvent accéder aux propriétés de la classe parente (à condition que la classe parente soit publique)
#define une classe
1. Python est un mécanisme d'implémentation de multi-héritage
2. S'il y a des méthodes avec le même nom dans plusieurs classes parentes, le ordre d'appel des objets à partir de la classe
python2:
| --- classes de style nouveau,
héritage en largeur d'abord
| --- classes à l'ancienne (classes classiques),
héritage en profondeur d'abord,
python3
uniquement classes de style nouveau
class Name(object ):#定义类，名称首字母大写，默认（）里面为父类
#对象的构建（属性包括数据和方法）
def __init__(self,name,age): #构造器构建实例（特殊方法）添加属性：名字，年龄(self为当前对象this)
self.name=name #构造属性（如同杯子的模具）
self.age=age
def __del__(self):#类的属性都一样（就是对象有相同的属性:如吃）
print(self .__class__.__name__+'name del')
def eat(self):
print(self .__class__ .__name__+'eat')
def move(self):
print(self .__class__ .__name__ +'move')
def sleep(self):
print(self .__class__ .__name__ +'sleep')
class Person(Name ):#Persin继承Name(继承有属性，但有不同，有区分）
#非绑定方法
def __init__(self,name,age,sex):
Name.__init__(self, name, age) # 子类调用父类的构造方法
self .sex=sex#多的属性区分父类
def think(self):
print(self .__class__ .__name__ +'think')
def wear(self):
print(self.__class__.__name__ + 'wear')
if __name__=='__main__':
#a=Name('青蛙',2)#参考定义的构造器规划，实现对象的实例化
#print('name=%s'%a.name )
#print('age=%d'%a.age )
#a.sleep()#aelp不需要传递，解释器自动完成
#a.eat()
#a.move()
b=Person ('人',30,'男')#实例化对象
print(b.name )#自己独特的属性
print(b.age )
print(b.sex )
b.eat()#继承的属性
b.move()
b.sleep()
Overwrite | Override Quelle est
la différence entre le remplacement et la surcharge?
(Surcharge: le nom de la fonction est le même, le type ou le numéro de paramètre est différent)
Surcharge:
il n'y a pas de surcharge dans la fonction python
Polymorphisme et héritage # définir
une classe
classe P (objet): # définir une classe, la première lettre du nom est en majuscule, la valeur par défaut () est la classe parente
# construction d'objet (les attributs incluent des données et des méthodes)
def __init__(self,name,age):
self.name=name
self.age=age
def run(self):
print('P run...')
class C(P):
def __init__(self,name,age,sex):
P.__init__(self ,name,age )#传递父类的构造
self. sex=sex
def run(self):
P.run(self ) #子类方法体调用父类方法
print('C run...')#方法的覆盖
if __name__=='__main__':
c=C('child',20,'man')
c.run () # Binding est la classe instanciée, et aucune sous-classe ne peut appeler la classe parente. Si la classe enfant l'a, elle n'appellera pas la classe parent (polymorphisme)
dir () afficher les attributs de classe
class A():
'''
this is a class
'''
def __init__(self):
pass
if __name__=='__main__':
for item in dir(A ):#将A放出来
print(str (item )+str (getattr(A,item ) ) ) #
Afficher les propriétés des objets de classe
class A():
'''
this is a class
'''
def __init__(self,name):
self .name=name
if __name__=='__main__':
a=A('name')
#print(dir(a ) )#查看类的属性和对象
print(a .__dict__ )#查看对象属性
Lorsque la sous-classe n'a pas de méthode, la classe parente est appelée
class P():
#父类实现构造方法，实例化子类对象时会，调用父类的方法
def __init__(self):
print('p__e')
class A(P ):
pass
if __name__=='__main__':
a=A()
python父类如果实现了构造方法,子类没有，实例化子类对象时会默认调用父类的构造方法
```clike
class P():
def __init__(self):
print('P __init__ invoke...')
class A(P):
def __init__(self):
P.__init__(self)
print('A __init__ invoke...')
if __name__ == '__main__':
a=A()
- La méthode parent appelle plusieurs méthodes
class P1():
def __init__(self):
print('P1 __init__ invoke...')
class P2():
def __init__(self):
print('P2 __init__ invoke...')
class A(P1,P2):
def __init__(self):
P1.__init__(self)
P2.__init__(self)
print('A __init__ invoke...')
if __name__ == '__main__':
a=A()
La deuxième méthode super (A, self). Init ()
class P1():
def __init__(self):
print('P1 __init__ invoke...')
class P2():
def __init__(self):
print('P2 __init__ invoke...')
class A(P2,P1):
def __init__(self):
P1.__init__(self)
P2.__init__(self)
super(A,self).__init__()
print('A __init__ invoke...')
if __name__ == '__main__':
a=A()
+ 静态方式无法访问对象的自身属性变量
```python
class A():
method = 1 # 静态属性
def __init__(self, name):
self.name = name
def run(self):
print('run invoke...')
@staticmethod
def func(x):
print('self.name=%s' % x)
print('func invoke...')
@classmethod
def test(cls):
print('test ...')
print('method=%d'%A.method )#静态的查找
if __name__ == '__main__':
# a=A('name')
# a.run()
# A.func('liwenbo')
# A('xxx').func('yyy')
A.test()
- Surcharge de méthode str
class A(object):
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):#方法重载
return 'name=%s,age=%d'%(self.name,self.age)
if __name__ == '__main__':
a=A('liwen',20)
print(a)
+ 重载__iter__和__next__实现一个可迭代的类型(无限循环的版本)
import random
class A():
def __init__(self,seq):
'''seq type(iterable)'''
self.seq=seq
def __iter__(self):
return self#返回当前对象，变成可迭代的对象
def __next__(self):
return self.seq[random.randint(0,len(self.seq)-1)]
if __name__ == '__main__':
a=A([1,2,3])
for item in a:
print(item)
Surcharger __iter__ et __next__ pour implémenter un type itérable (version à boucle limitée)
import random
class A():
def __init__(self,seq):
'''seq type(iterable)'''
self.seq=seq
self.index=0
def __iter__(self):
return self#返回当前对象
def __next__(self):
if self.index > len(self.seq) - 1:
raise StopIteration
else:
tmp = self.seq[self.index]
self.index+=1
return tmp
if __name__ == '__main__':
a=A([1,2,3,50,43])
for item in a:
print(item)
**单链表结构**
```python
#实现一个单链表
#用node来作为链表的节点抽象类
class Node():
def __init__(self,data):
self.data=data
self.next=None
def show(self):
print('node data=%d'%self.data)
def __str__(self):
return 'node data=%s'%self.data
class LinkList():
def __init__(self):
self.head=None
def insertFirst(self,data):
newNode = Node(data)#创建新节点
newNode.next=self.head
self.head = newNode
def deleteFirst(self):
tmpNode= self.head
self.head=self.head.next
return tmpNode
def travel(self):
currentNode = self.head
while currentNode is not None:
print(currentNode)
currentNode = currentNode.next
if __name__ == '__main__':
n1=Node('A')
n2=Node('B')
n3=Node('C')
link=LinkList()
link.insertFirst(n1)
link.insertFirst(n2)
link.insertFirst(n3)
link.travel()
print('+'*30)
link.deleteFirst()
link.deleteFirst()
link.deleteFirst()
link.travel()
La sous-classe remplace la classe parente pour modifier le comportement par défaut de la classe parente
class Mr(dict ):#子类覆盖父类方法
def keys(self):
return sorted(super(Mr,self).keys(),reverse=False)#super父类方法调用
if __name__=='__main__':
w=Mr({'a':1,'b':2})
print(w.keys())
La classe enfant hérite de la classe parente immuable (pour changer le comportement immuable de la classe parente)
class WrapperFloat(float):#改变父类不可变变量，保留小数点后二位。
def __init__(self,val):#禁止返回return
self.val=val
print('__init__')
def __new__(cls,val):
#return float.__new__(cls,round(val,2))
return super(WrapperFloat, cls ).__new__(cls,round(val,2))#方法2
if __name__=='__main__':
w=WrapperFloat(3.0098)
print(w )
Application des slots de la classe (attribut de protection)
class A():
__slots__ = 'name','age'#定义了类的属性名称，不允许增加和修改
def __init__(self,name):
self.name=name
if __name__=='__main__':
a=A('li')
a.app()