class Student:
def __init__(self, name, tel, study_id='001', score=0):
self.name = name
self.tel = tel
self.study_id = study_id
self.score = score
# 在打印一个对象的时候，系统会自动用这个对象去调用__repr__方法，并且获取这个方法的返回值
# 返回值是什么就打印什么（返回值必须是字符串）
def __repr__(self):
return f'<{str(self.__dict__)[1:-1]}>'
# __dict__将对象转换成字典
stu1 = Student('小王', 123456, '0001', 1)
stu2 = Student('小林', 22222, '0002', 12)
print(stu1) # <'name': '小王', 'tel': 123456, 'study_id': '0001', 'score': 1>
# 对象属性的增删改查
# 查---获取对象的属性值
'''
对象.属性
getattr(对象，属性名) 可以做到动态获取属性值
'''
print(stu1.name) # 小王
# value=input('请输入要获取的属性名:')
# print(getattr(stu2,value)) # value="name" 小林 value="tel" 22222
print(getattr(stu2, 'height', 180)) # 180 获取不存在的属性如果不给默认值会报错，
# 增/改
'''
对象.属性=值 属性存在的时候就是修改，属性不存在的时候就是增加
setattr(对象，属性名，值) 可以做到动态增加/修改属性值
'''
stu1.name = '我不是小王'
stu1.height = '新添加的属性：身高170'
print(stu1) # <'name': '我不是小王', 'tel': 123456, 'study_id': '0001', 'score': 1, 'height': '新添加的属性：身高170'>
setattr(stu1, 'name', '我还是小王')
print(stu1) # <'name': '我还是小王', 'tel': 123456, 'study_id': '0001', 'score': 1, 'height': '新添加的属性：身高170'>
# 删
'''
del 对象.属性 删除属性
del 对象 删除对象
delattr(对象，属性名)
'''
del stu1.height
print(stu1) # <'name': '我还是小王', 'tel': 123456, 'study_id': '0001', 'score': 1>
delattr(stu1, 'study_id')
print(stu1) # <'name': '我还是小王', 'tel': 123456, 'score': 1>
Método de objeto:
Definición: Definición directa
Llamada: Objeto. Nombre del método ()
Características: Hay un parámetro predeterminado self, este parámetro no necesita pasarse al llamar, el sistema pasará automáticamente el objeto actual a self para su
uso: Si la función de la función requiere un objeto , Entonces esta función se define como un método de objeto
Método de clase:
Definición: agregue @classmethod antes de definir la función
. Llame: class.method name ()
Características: Hay un parámetro predeterminado cls, este parámetro no necesita pasarse al llamar, el sistema pasará automáticamente la clase actual a cls para su
uso: si la función está implementada La función no requiere que el objeto use la clase, entonces la función se define como un método de clase
Método estático
Definición: Agregue @staticmethod antes de definir la función
. Llame: Clase. Nombre del método ()
Características: Sin parámetros predeterminados.
Uso: Defina métodos estáticos sin necesidad de objetos o clases para realizar la función
class Student:
# func1是对象方法
def func1(self):
print('对象方法')
# func2是类方法
@classmethod
def func2(cls):
print('cls:', cls) # cls:<class '__main__.Student'>
# 当前类能做的，cls都可以做
# func3是静态方法
@staticmethod
def func3():
print('静态方法')
print('Student:', Student) # Student: <class '__main__.Student'>
class Person:
"""
人类
"""
num = 61
def __init__(self, name='张三', age=18, gender='男'):
self.name = name
self.age = age
self.gender = gender
def eat(self, food='面条'):
print(f'{self.name}在吃{food}')
@classmethod
def message(cls):
print(f'人类目前的数量是：{cls.num}')
@staticmethod
def destroy():
print('人类破坏环境')
p1 = Person()
# 类属性
'''
类名.__doc__ 获取类的说明文档
print(Person.__doc__) # 人类
类名.__module__ 获取指定类所在的模块 如果结果是__main__ 说明是当前模块
print(Person.__module__) # __main__
print(list.__module__) # builtins
对象.__class__ 获取指定对象对应的类型，和type(对象)功能一样
print(p1.__class__) # <class '__main__.Person'>
print(type(p1)) # <class '__main__.Person'>
类名.__name__ 获取类名类型为str
print(Person.__name__) # 'Person'
print(int.__name__) # 'int'
类名.__dict__ 获取类所有的字段和字段值，转化为字典，key是字段名，value是字段的值
print(Person.__dict__)
对象.__dict__ 获取对象所有的属性和属性值，转化为字典，key是属性名，value是属性的值
print(p1.__dict__) # {'name': '张三', 'age': 18, 'gender': '男'}
类名.__base__ 获取指定类的父类
类名.__bases__ 获取类所有的父类
object是python中所有类的基类
print(Person.__base__) # <class 'object'>
print(Person.__bases__) # (<class 'object'>,)
'''
# 根据数据不同的类型创建以该类型名命名的文件
datas = ['abc', -0.1234, '你好', 564]
for data in datas:
with open(rf'files\{data.__class__.__name__}.txt', 'a', encoding='utf-8') as f:
f.write(str(data) + '\n')
adquiridor
Uso: antes de obtener la propiedad del objeto, si desea hacer otra cosa, puede agregar un getter a esta propiedad.
Uso:
agregue _ antes del nombre de la propiedad que necesita agregar un getter y
defina una función después del decorador @property, el nombre de la función es el nombre de la propiedad eliminado _
La función no tiene parámetros, pero necesita un valor de retorno. El valor de retorno es el resultado de
obtener el valor del atributo. Al obtener el atributo a través del objeto, el atributo no necesita llevar _
class Circle:
pi = 3.14
def __init__(self, r=10):
self.r = r
@property
def area(self):
return Circle.pi * self.r ** 2
c1 = Circle(100)
print(c1.area)
Practique, agregue atributos a Persona, requisito: el valor de edad se guarda en edad, pero al obtener el atributo de edad, lo que
obtiene es: niños (0-4), adolescentes (5-12), jóvenes (13-28), mediana edad (29-) 40) De mediana edad (41-55), ancianos (mayores de 55)
class Person:
def __init__(self, age=0, name='张三', gender='男'):
self.name = name
self._age = age
self.gender = gender
@property
def age(self):
if 0 <= self._age <= 4:
return '儿童'
elif 5 <= self._age <= 12:
return '少年'
elif 13 <= self._age <= 28:
return '青年'
elif 29 <= self._age <= 40:
return '中年'
else:
return '老年'
setter: debe agregarse antes de agregar getter
'
para hacer algo más en las propiedades del objeto antes de la asignación, otorgue esta propiedad para agregar setter
use
para definir una función detrás del decorador @ nombre de función .setter, el nombre de la función es el nombre de la propiedad para eliminar _
función y solo Un parámetro (este parámetro apunta al valor asignado durante la asignación)
@age.setter
def age(self, value):
print(value)
if type(value) != int:
raise ValueError
if value < 0 or value > 150:
raise ValueError
p1 = Person()
# p1.age='dwa' ValueError
# p1.age=151 ValueError
permiso de acceso
Público: las propiedades y métodos públicos se pueden usar dentro y fuera de la clase, y se pueden heredar.
Protegido: las propiedades y métodos protegidos se pueden usar dentro de la clase, pero no se pueden usar afuera, pero los
privados se pueden heredar : propiedades y métodos privados . Los métodos se pueden usar dentro de la clase, no se pueden usar fuera y no se pueden heredar
Los atributos y métodos en
Python solo tienen derechos de acceso: la llamada privatización de Python público es solo una solicitud de explicación
El método de privatización:
agregue __ delante del nombre del atributo y el nombre del método (solo puede comenzar con dos __, no terminar con __)
class Person:
num = 100
__info = '动物'
def __init__(self, name='张三', age=18, gender='男'):
self.name = name
self.age = age
self.gender = gender
def func1(self):
return Person.__info
def __func2(self):
return Person.num
p1 = Person()
print(p1.func1()) # 动物
print(Person.num) # 100
# print(Person.__info) # AttributeError: type object 'Person' has no attribute '__info'
# print(p1.func2()) # AttributeError: 'Person' object has no attribute 'func2'
# print(Person._Person__info) # 动物 强行查看
Operador
Cuando Python usa operadores, la esencia es llamar al método correspondiente al
operador. El nombre del método del método correspondiente a cada operador es fijo. Diferentes tipos de datos
llamarán a los métodos correspondientes en diferentes clases al participar en la misma operación.
Si un determinado tipo de datos admite una determinada operación depende de si existe un método correspondiente a este operador en el tipo correspondiente a los datos
# __add__
class Person:
def __init__(self, age=0, name='？', gender='男'):
self.name = name
self._age = age
self.gender = gender
#self指向+前面的数据，other指向+后面的数据
def __add__(self, other):
return self.name + other.name
def __mul__(self, other):
return [self.name for _ in range(len(other.name))]
def __repr__(self):
return f'<{str(self.__dict__)[1:-1]}>'
def __gt__(self, other1):
return self._age>other1._age
p1 = Person(56,'王五','男')
p2 = Person(1, "小花",'女')
print(p1 + p2) # 张三李四 本质是：pi.__add__(p2)
print(p1 * p2) # ['张三', '张三'] 本质是：pi.__mul__(p2)
# 练习 根据年龄排序
p3=Person(20,'张三','男')
p4=Person(25,'老王','男')
# 方法一 重载 > 运算符
ps=[p1,p2,p3,p4]
print(sorted(ps))
# 方法二 实参高阶函数
ps.sort(key=lambda item :item._age)
print(ps)