A, decorador propriedade
Sob Antes de aprender a função de decoração não está mudando é chamado a função original e premissa de código-fonte é para adicionar novos recursos função decorativa, são objetos decorativos pode realmente ser uma classe, a mesma decoração também pode ser uma classe, classe propriedade é feita com uma decoração, é utilizado um método para se ligar o pseudo-objecto faz com que um atributo de dados.
Caso I:
Suponha que temos um índice de massa corporal da demanda por computação pessoal:
"""
成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
体质指数（BMI）=体重（kg）÷身高^2（m）
EX：70kg÷（1.75×1.75）=22.86
"""
Extractos o índice de massa corporal BMI-calculada como: (IMC) = peso corporal (kg) ÷ altura ^ 2 (m)
Pessoas definir uma classe como um
class People:
def __init__(self, name, weight, height):
self.name = name
self.weight = weight
self.height = height
def BMI(self): # 计算体质指数的功能属性
return self.weight / (self.height ** 2)
obj1 = People('tom', 70, 1.75) # 获得一个人的对象
print(obj1.BMI()) # 22.857142857142858
função Por IMC a ser definido na classe por duas razões:
- IMC pode ser visto a partir da equação, este valor deve ser calculado a função de gatilho para obter o
- IMC é como altura, peso mudança e dinâmica, diferentes pessoas podem ser diferentes IMC, IMC mesmo pode ser diferente em diferentes momentos, cada vez para obter necessidades em tempo real de computação.
Mas bmi soa mais como um atributo de dados, em vez de função, os usuários não querem chamar a função de conseguir, mas você pode obter uma consulta simples sobre o IMC, desta vez, podemos usar os decoradores de propriedade para ser concluído.
No caso de um conjunto colocar algo sobre a base da propriedade:
class People:
def __init__(self, name, weight, height):
self.name = name
self.weight = weight
self.height = height
@property #将方法伪造成数据属性
def BMI(self): # 计算体质指数的功能属性
return self.weight / (self.height ** 2)
obj1 = People('tom', 70, 1.75) # 获得一个人的对象
print(obj1.BMI) # 22.857142857142858
Caso II:
propriedade também oferece uma função de configuração e as propriedades de exclusão, como se segue
class People:
def __init__(self, name):
self.__name = name
def get_name(self):
return self.__name
def set_name(self, val):
if type(val) is not str:
print('必须传入str类型')
return
self.__name = val
def del_name(self):
print('不能删除')
name = property(get_name, set_name, del_name)
obj1 = People('egon')
# # 按照人正常的思维逻辑来访问
print(obj1.name) #egon
obj1.name=18 #必须传入str类型
del obj1.name #不能删除
Caso 3:
Caso II para mais otimizado para alcançar novas formas:
class People:
def __init__(self, name):
self.__name = name
@property
def name(self):
return self.__name
@name.setter
def name(self, val):
if type(val) is not str:
print('必须传入字符串')
return
self.name = val
@name.deleter
def name(self):
print('不能删除！')
# del self.__name
obj1 = People('egon')
# 人正常的思维逻辑
print(obj1.name) # egon
obj1.name = 18 # 必须传入字符串
del obj1.name # 不能删除！
print(obj1.name) # egon
Em segundo lugar, herança
O que é herdado:
1. A herança é uma forma de criar uma nova classe, ao criar uma nova classe, outra classe vai passar entre parênteses,
A nova classe é uma classe derivada ou subclasse, classe pai classe entre parênteses, também pode ser chamado de uma classe base ou superclasse.
2, python pode suportar herança de classe múltipla, que a nova classe pode herdar uma ou mais classes pai
Definir tanto uma classe pai:
class Parent1(object):
x=2222
class Parent2(object):
pass
Criar uma subclasse herda a classe pai:
class sub1(Parent1): # 单继承
pass
class sub2(Parent1,Parent2): # 多继承
pass
Você pode ver as herda subclasse os métodos utilizados .___ bases__ cujo pai:
print(Sub1.__bases__) #(<class '__main__.Parent1'>,)
print(Sub2.__bases__) #(<class '__main__.Parent1'>, <class '__main__.Parent2'>)
Propriedades Localizar: Localizar corpo subclasse, olhar novamente não consegue encontrar a classe pai
print(Sub1.x) #2222
Em segundo lugar, o clássico para a nova classe
Nota: Existem novas classes e subclasses de clássico em python2 in; não herda qualquer um dos python3
Classe, ele herdará a classe de objeto padrão, portanto, todas as classes são python3 classe nova
1, distinção de classe python2:
A nova categoria: a subclasse herda a classe de objeto, bem como sub-sub-subclasse desta subclasse de ......
Clássico: há subclasses classes de objetos e sub-sub-subclasse desta subclasse de ......
2, as vantagens e desvantagens de python herança múltipla
Vantagens: uma subclasse pode ser herdada atributos simultaneamente várias classes pai, para maximizar a reutilização de código
Desvantagens: 1, ao contrário do hábito humano de pensar: A herança é uma expressão do que "é" Qual é a relação
2, a legibilidade do código será pior
3, não recomenda o uso de herança múltipla, que poderia levar a questão de diamantes de ódio, mudança escalável
Diferença, realmente refere-se a uma subclasse inevitavelmente reutilização propriedades pluralidade de classe principal, deve ser utilizada
mixins
Por que usar a herança: herança pode ser usado para resolver o problema de código redundante entre classes
3, como implementar herança
Modelo 1: não herdam, há redundância entre as classes
class Student:
school='OLDBOY'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def choose_course(self):
print('学生%s 正在选课' %self.name)
class Teacher:
school='OLDBOY'
def __init__(self,name,age,sex,salary,level):
self.name=name
self.age=age
self.sex=sex #实例化的前三个属性和Student类相同，代码冗余
self.salary=salary
self.level=leve
def score(self):
print('老师 %s 正在给学生打分' %self.name)
Modelo 2: resolver a herança baseada em redundância entre as questões de classe e de classe
class OldboyPeople:
school = 'OLDBOY'
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
class Student(OledboyPeople):
def choose_course(self):
print(f'学生{self.name}正在选课')
stu_obj1=Student('tom',18,'male')
print(stu_obj1.__dict__) #{'name': 'tom', 'age': 18, 'sex': 'male'}
print(stu_obj1.school) #OLDBOY
stu_obj1.choose_course() #学生tom正在选课
class Teacher(OldboyPeople):
# 老师的空对象，'egon',18,'male',3000,10
def __init__(self, name, age, sex, salary, level):
# 指名道姓地跟父类OldboyPeople去要__init__
OldboyPeople.__init__(self,name,age, sex)
self.salary = salary
self.level = level
def score(self):
print('老师 %s 正在给学生打分' % self.name)
tea_obj=Teacher('egon',12,'male',3000,10)
print(tea_obj.__dict__) #{'name': 'egon', 'age': 12, 'sex': 'male', 'salary': 3000, 'level': 10}
print(tea_obj.school) #OLDBOY
tea_obj.score() #老师egon正在给学生打分
Em terceiro lugar, olhar para as propriedades
Um único encontrar propriedades herdadas
Com a herança, o objeto quando se olha para a propriedade, começando com o objeto em seu achado __dict__, se não, em seguida, ir à procura de classe criança, e depois ir à procura de classe pai ......
Uma demonstração:
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
obj=Bar()
obj.f2()
#Foo.f2
#Foo.f1
Modelo II:
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
Foo.f1(self) #调用当前类中f1
class Bar(Foo):
def f1(self):
pirnt('Bar.f1')
obj=Bar()
obj.f2()
# # Foo.f2
# # Foo.f1
Modelo três: o atributo oculto
class Foo:
def __f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.__f1() # self._Foo__f1 调用当前类中的f1
class Bar(Foo):
def __f1(self): #_Bar__f1
print('Bar.f1')
obj=Bar()
obj.f2()
# Foo.f2
# Foo.f1
Em quarto lugar, o tipo de diamante problemas de herança múltipla causada por
A maioria das linguagens orientadas a objeto não suporta herança múltipla, mas em Python, uma subclasse pode herdar várias classes pai, ao mesmo tempo, certamente pode beneficiar uma subclasse pode ser reutilizado para um número de classe pai diferente, mas há também pode levar ao famoso problema diamante problema diamante (também conhecido como diamantes, às vezes conhecido como o "diamante da morte"), na verdade, a imagem do diamante abaixo desta estrutura de herança da metáfora
Um: Introdução e problema diamante MRO
class A(object):
def test(self):
print('from A')
pass
class B(A):
# def test(self):
# print('from B')
pass
class C(A):
# def test(self):
# print('from C')
pass
class D(C,B):
# def test(self):
# print('from D')
pass
print(D.mro()) # 类D以及类D的对象访问属性都是参照该类的mro列表
#
obj = D()
obj.test()
Resumo: classe atributos associado de pesquisa (.. propriedade nome de classe, propriedades do objecto da classe), esta classe é uma referência mro
2: Se um não-diamante herança herança múltipla, clássico e novas propriedades olhar o mesmo fim
É um ramo de um ramo de encontrá-lo, e então finalmente encontrou objeto
class E:
# def test(self):
# print('from E')
pass
class F:
def test(self):
print('from F')
class B(E):
# def test(self):
# print('from B')
pass
class C(F):
# def test(self):
# print('from C')
pass
class D:
def test(self):
print('from D')
class A(B, C, D):
# def test(self):
# print('from A')
pass
# 新式类
# print(A.mro()) # A->B->E->C->F->D->object
obj = A()
obj.test() # 结果为：from F
3: Se a herança múltipla é a herança diamante, propriedade clássico ea nova ordem não é o mesmo tipo de olhar
Classic: em profundidade, será uma maneira de recuperar diretamente o primeiro ramo quando que recupera grande cabeça (uma classe pai comum)
As novas categorias: em largura, recupera grande cabeça (classe pai comum) em busca da última vez que um ramo
Nota: Em python2, há classes de objetos herdados explícitas e suas subclasses são clássicos
class G:
# def test(self):
# print('from G')
pass
class E(G):
# def test(self):
# print('from E')
pass
class F(G):
def test(self):
print('from F')
class B(E):
# def test(self):
# print('from B')
pass
class C(F):
def test(self):
print('from C')
class D(G):
def test(self):
print('from D')
class A(B,C,D):
# def test(self):
# print('from A')
pass
# 新式类
# print(A.mro()) # A->B->E->C->F->D->G->object
# 经典类：A->B->E->G->C->F->D
Resumo: questões de sucessão para evitar o uso de mais de
1, tente não ser muito complicado herança estrutura
2, recomendado mecanismo mixins: conhecer a herança herança múltipla no contexto do que "é" Qual é a relação