python (programación orientada a objetos)
Combine su propio conferenciante y escriba sus propias notas. Hay deficiencias y espero que puedan comentar las deficiencias. Todos aprenden unos de otros. Bienvenido a dejar un mensaje.
La aparición de
un grupo orientado a objetos con los mismos atributos completa una gran tarea.
Después de crear una instancia y definir la clase, use esta clase para construir un objeto (el objeto puede ser muchos
init (self) [constructor]
self se refiere al objeto instanciado actual
python no es un constructor real, solo una devolución de llamada de la instancia, no puede ser devuelto)
# Definir una clase
clase A (objeto): # definir clase, la primera letra del nombre está en mayúscula, el valor predeterminado () es la clase padre #
construcción del objeto (los atributos incluyen datos y métodos)
pasar
> 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)
Los métodos y funciones son métodos en diferentes clases y funciones fuera de las instancias.
Características del lenguaje dinámico Python
#define una clase
clase P (objeto): #define una clase, la primera letra del nombre está en mayúscula, el valor predeterminado () es la clase principal #
construcción del objeto (los atributos incluyen datos y métodos)
pasa
si nombre = = ' principal ':
p = P ()
p.name = 'nombre'
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))
Objeto llamada instanciación, llamada instanciación # define
una clase de
la clase A (objeto): # define una clase, el nombre se escribe con mayúscula, y el valor predeterminado () es la clase padre
#Object construcción (atributos incluyen datos y métodos)
pase
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 diferencia entre un tipo de variable y un tipo inmutable
#definir una clase
clase A (objeto): # definir una clase, el nombre está en mayúscula y el valor predeterminado () es la clase principal
# construcción del objeto (los atributos incluyen datos y métodos)
pasar
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 ) )
Cómo definir un objeto (diferentes instancias, usar diferentes constructores,)
# definir una
clase Nombre de clase (objeto): # definir clase, nombrar la primera letra en mayúscula, el valor predeterminado () es la clase padre #
construcción del objeto (los atributos incluyen datos y Método (fuera del constructor llamado función))
def init (self, nombre, edad): #constructor (método especial) agregar atributos: nombre, edad (self es el objeto actual this)
self.name = nombre #construir atributos (como el molde de la taza)
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')
Encapsulación (privatización de la propiedad -> proporcionar métodos externos para modificar propiedades) Python no es válido en el módulo, válido en la clase (el "__name" dentro de la clase es un guión bajo simple (atributo privado, accesible), guión bajo doble (atributo privado, Inaccesible) hay guiones bajos antes y después (atributos especiales)
Herencia (las subclases pueden acceder a las propiedades de la clase principal (siempre que la clase principal sea pública)
#definir una clase
1. Python es un mecanismo de implementación de herencia múltiple
2. Si hay métodos con el mismo nombre en varias clases principales, el orden de llamar a los objetos de la clase
python2:
| --- clases de estilo nuevo,
herencia primero en amplitud
| --- clases de estilo antiguo (clases clásicas),
herencia primero en profundidad, solo clases de estilo nuevo en
python3
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 ¿Cuál es
la diferencia entre override y overload?
(Sobrecarga: el nombre de la función es el mismo, el tipo o número de parámetro es diferente)
Sobrecarga:
no hay sobrecarga en la función python
Polimorfismo y herencia # definir
una clase
clase P (objeto): # definir una clase, la primera letra del nombre está en mayúscula, el valor predeterminado () es la clase padre
# construcción del objeto (los atributos incluyen datos y métodos)
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 es la clase instanciada, y ninguna subclase puede llamar a la clase padre. Si la clase secundaria lo tiene, no llamará a la clase principal (polimorfismo)
dir () ver atributos de clase
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 ) ) ) #
Ver propiedades de objetos de clase
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__ )#查看对象属性
Cuando la subclase no tiene método, se llama a la clase padre
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()
- El método principal llama a varios métodos
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()
El segundo método 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()
- Método de sobrecarga 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)
Sobrecargue __iter__ y __next__ para implementar un tipo iterable (versión de bucle limitado)
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 subclase anula la clase principal para cambiar el comportamiento predeterminado de la clase principal
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 clase secundaria hereda la clase principal inmutable (para cambiar el comportamiento inmutable de la clase principal)
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 )
Aplicación de slots de la clase (atributo de protección)
class A():
__slots__ = 'name','age'#定义了类的属性名称，不允许增加和修改
def __init__(self,name):
self.name=name
if __name__=='__main__':
a=A('li')
a.app()