clase
1: La primera letra de todos los nombres de las clases debe escribirse en mayúscula, y varias palabras usan la nomenclatura de camello
El formato de nomenclatura de la clase:
class Phone:
#属性
pass
#方法Crea objetos usando clases
class Phone:
brand = '华为'
#使用类创建对象
小明=Phone()
小红=Phone()
print(小明)
print(小红)
<__main__.Phone object at 0x000001A2B2C54390>
<__main__.Phone object at 0x000001A2B2CF7978>Creemos un objeto cuando haya algunos atributos
class Phone:
brand = '华为'
yz=Phone() #使用类创建对象
yz.brand
print(yz.brand)
ab=Phone() #使用类创建对象
ab.brand
print(ab.brand)
华为
华为
class Phone:
brand = '华为'
yz=Phone() #使用类创建对象
# print(yz.brand)
yz.brand = 'iphone' ###修改该对象的属性值
print(yz.brand)
ab=Phone() #使用类创建对象
print(ab.brand)
iphone
华为
Definir clases y atributos
Cuando el objeto juzga su propio atributo, primero verifique si existe, si no, luego vaya a la clase para encontrarlo
class Student:
name = 'dog' ##类属性
age =2
xiaowei=Student() ##使用Student类创建对象xiaowei
xiaowei.name = "pig" ##对象属性
print(xiaowei.name)
print(xiaowei.age)
xiaoming = Student()
print(xiaoming.name)
print(xiaoming.age)
pig ###发现对象在使用属性的时候先查看自己的空间中是否存在对应的熟悉，如果没有的话再去类中去找。
2
dog
2
La parte del método (acción) en la clase
Tipo: método ordinario, método de clase, método estático, método mágico
1: método ordinario
#类中的方法：动作
#种类：普通方法 类方法 静态方法 魔术方法
class Phone:
brand = '小米手机'
price = '3500'
def call(self): ###定义一个call的方法
print(self) ###此处可以看出来，self就是对象，phone1和phone2
print(self.note) ###谁调用就拿谁的note瞒不过这里有一个要注意的，此处如果使用self.note，那么我传进来的self对象中必须都要有note属性，否则就会报错
print(self.brand)
phone1 = Phone() ##用Phone类创建一个对象
phone1.brand = 'huawei' ##修改phone1的brand属性
# print(phone1.brand)
phone1.note = "我是phone1的通信录" ##phone1的属性note
phone1.call()
phone2 = Phone()
print(phone2.price)
phone2.note = "我是phone2的通信录" ##phone2的属性note
phone2.call()
<__main__.Phone object at 0x000002407FE15E80>
我是phone1的通信录
huawei
3500
<__main__.Phone object at 0x000002407FE15EF0>
我是phone2的通信录
小米手机
2: método mágico
class Phooe:
def __init__(self): ###魔术方法
print('--------------init')
def call(self):
print('--------------self')
print('价格',self.price) ###在ide集成环境中，此时的price下面其实是标成阴影的，因为在call函数中，当我传进来self的时候，并不知道我传进来的所有对象都有price这个属性
p1 = Phooe()
p2 = Phooe()
Entonces, ¿cómo resolvemos este problema? En este punto usaremos el método mágico.
class Phone:
def __init__(self): ###魔术方法
self.brand = "小米" ##用来做一个统一的，如果我传递给call函数的对象没有brand，price属性，则会给它进行赋值之歌默认的，保证代码不会出错。
self.price = 4399
def call(self):
print('价格为{}'.format(self.price))
p1 = Phone()
p1.price= 5999 ###如果对象中定义了对象的属性，那么就不会只要默认，而是使用我对象自带的那个属性
p1.call()
p2 = Phone()
p2.call()
价格为5999
价格为4399
El método mágico y el método ordinario aceptan parámetros
##在类中定义的对象的属性等级是最低的，其次是在魔术方法中，优先级最高的是在对象中定义的属性
class Person:
name = '小p'
def __init__(self,name,age): ###接受来自对象的参数
self.age = age
self.name = name
def eat(self,food):
print("{}爱{}".format(self.name,food)) ##记住此时传进来的food的参数只是一个普通的参数，不是对象自身的属性，所以不是self.food
def run(self):
print("{}今年{}岁爱跑步".format(self.name,self.age))
p1=Person('小光',20) ##此处就必须要加上与魔术方法对应的参数
# p1.name = "小明"
p1.run()
p1.eat("臭豆腐")
p2=Person('小黑',19)
p2.eat("炸酱面")
p2.run()
小光今年20岁爱跑步
小光爱臭豆腐
小黑爱炸酱面
小黑今年19岁爱跑步
3: método de clase
1: Confíe en el decorador @classmethod al definir
2: El parámetro en el método de clase no es un objeto sino una clase definida por usted
print (cls) <class '__ main __. Dog'> ### La impresión es la clase Dog que definí
3: Los métodos de clase solo se pueden usar en mi clase, que es el atributo definido en mi clase, y el atributo definido en el objeto no se puede usar
4: Los métodos comunes no se pueden usar en métodos de clase
El papel de los métodos de clase: debido a que solo puede acceder a la familiaridad de la clase y a los métodos de clase, si necesita crear algunas acciones (funciones) antes de que se cree el objeto, puede usar métodos de clase.
class Dog(): ###定义的Dog类
price = 3000 ##定义的类熟悉
age = 4
def __init__(self,name,color): ##魔术方法
self.name = name
self.color = color
def buy(self): ##buy方法
print("当时买的时候{}元".format(self.price))
def eat(self,food): ##eat方法
print("{}爱吃{}".format(self.name,food))
self.buy() ###在一个方法中，调用另一个方法，需要使用self然后进行调用
def sleep(self,time): ##sleep方法
if time > 5:
print("{}快起来去干活，你都睡了{}小时了".format(self.name,time))
@classmethod ###定义的类方法
def test(cls):
print(cls)
print("今年{}岁了".format(cls.age)) ##这里面传入的参数只能是类中定义的属性，比如price和age
dog = Dog("小黄","黄色")
# dog.price = 4000
dog.buy()
dog.eat("鸡腿")
dog.sleep(8)
dog.test()
当时买的时候3000元
小黄爱吃鸡腿
当时买的时候3000元
小黄快起来去干活，你都睡了8小时了
<class '__main__.Dog'>
今年4岁了
Suplemento del método de clase
Escenario: no dependa del objeto, modifique las propiedades en la clase
###在我还没有创建对象之前就对类的属性进行了修改
class Person:
age = 18
@classmethod
def update_age(cls):
cls.age += 1
print("年龄是{}".format(cls.age))
Person.update_age()
年龄是19
Método estático
1: muy similar a los métodos de clase
2: Necesita decorador @staticmethod
3: Los métodos estáticos no necesitan pasar parámetros (self, cls)
4: Solo puede acceder a las propiedades y métodos de la clase, y no se puede acceder a los objetos
5: La carga realmente requiere métodos similares
Resumen: comparación de métodos de clase y métodos estáticos
diferente:
- Diferentes decoradores
- Los métodos de clase requieren parámetros, los métodos estáticos no tienen parámetros
lo mismo:
- Solo puede acceder a las propiedades y métodos de la clase, el objeto no es accesible
- Se puede acceder llamando al nombre de la clase.
- Se pueden utilizar antes de crear el objeto, porque no dependen del objeto.
La diferencia entre el método ordinario y los dos
- El método normal no tiene decorador
- Los métodos ordinarios dependen del objeto, porque cada método ordinario tiene un yo. Solo cuando se crea el objeto se puede llamar al método ordinario, de lo contrario no se puede usar