面向对象基础

第一个类

class Circular:
    def __init__(self,radius):
        self.radius = radius
    def perimeter(self):
        print('周长：%s'%str(self.radius*3.14*2))
        return self.radius*3.14*2
    def area(self):
        print('面积：%s'%str(self.radius*self.radius*3.14))
        return self.radius*self.radius*3.14

obj = Circular(30)
obj.perimeter()
obj.area()

类的私有字段

# 类的私有字段、方法
# 在字段名前加上__该字段就成为了私有字段，只能在类的内部访问。就算是派生类（子类）也无法访问 
'''
私有字段的实现原理，在Python解释器读到__开头的字段时，会给该字段改名，改为 ‘_类名__字段名’,

所以使用_类名__字段名 这个可以在任何地方访问私有字段，但是不推荐这样访问

私有方法也是同理

注：在Python解释器从上到下读取类代码的时候，只要遇到私有字段都会将名字改为‘_类名__字段名’，不管是调用还是定义

'''

class A:
    __name = '类的私有字段'
    def __f1(self):
        print('__f1')
    def f2(self):
        self.__f1()
class B(A):
    def fun(self):
        print(self._A__name)
        
b1 = B()
b1.fun()
a1 = A()
a1.f2()

类的私有方法

class Parent():
    def __func(self):
        print('in Parent func Parent的私有方法')
        
    def __init__(self):
        self.__func()
        
        
class Son(Parent):
    def __fun(self):
        print('in Son func Son的私有方法')
        
son1 = Son()

类的私有静态属性

class A:
    __fun = 0
    def __init__(self,age):
        self.__arg = '类的私有静态对象属性'
        self.__age = age
    def func(self):
        print(self.__arg)
        print(self.__age)
#     def __fun(self):
#         print(666)
a1 = A(12)
print(A.__dict__)
a1.func()

@property装饰器

# 创建一个类，计算BMI指数
'''
@property装饰器
property 可以让一个方法，伪装成属性使用。下面是示例

'''
class Bmi:
    def __init__(self,weight,hight,name):
        self.weight = weight
        self.hight = hight
        self.name = name
    @property
    def bmi(self):
        b = self.weight / self.hight ** 2
        if b < 18.5:
            return '《Name:%s BMI:%s》过轻：低于：18.5'%(self.name,format(b,'0.2f'))
        
        elif b <= 23.9:
            return '《Name:%s BMI:%s》正常：18.5~23.9之间'%(self.name,format(b,'0.2f'))
        
        elif b <= 27:
            return '《Name:%s BMI:%s》过重：24~27之间'%(self.name,format(b,'0.2f'))
        
        elif b <= 32:
            return '《Name:%s BMI:%s》肥胖：28~32之间'%(self.name,format(b,'0.2f'))
        
        else:
            return '《Name:%s BMI:%s》非常肥胖：高于32'%(self.name,format(b,'0.2f'))
        
bmi = Bmi(73,1.77,'kkk')
print(bmi.bmi)

@property 属性的修改

# property 属性的修改
'''
@property装饰器
property 可以让一个方法 伪装成属性使用。

伪装属性的修改
@需要修改的属性.setter 下面是示例

注: 要使用 setter 装饰器 必须要存在@property  
'''
class A:
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
    # 查看属性
    @property    
    def age(self):
        return self.__age
    
    # 修改属性
    @age.setter 
    def age(self,a1):      

        self.__age = a1 if isinstance(a1,int) else self.__age
    # 删除属性
    @age.deleter
    def age(self):
        del self.__age
    
a1 = A('kkk',28)
print(a1.age)
a1.age = a1.age + 1
print(a1.age)
del a1.age

类方法

# 类方法

class A:
    def func(self):
        print(self)
    @classmethod    
    def func1(cls):
        # cls 就是 A 这个类
        print('传入的cls',cls)
        return cls()
    
    
a1 = A.func1()
a1.func()
# 对象调用类方法,自动传入的cls也是类本身。
a2 = A()
a2.func1()
'''
类方法的使用场景

1.类中 有些方法不需要对象参与
2.对类中的静态变量进行改变，要用类方法
3.在父类中获取，子类类空间

'''
# 在父类中获取，子类类空间
class A:
    @classmethod
    def func(cls):
        print(cls)
class B(A):
    pass
B.func()

静态方法

# 静态方法
'''
静态方法：没有self,cls 不用默认传入 对象和类
'''
class A:
    @staticmethod
    def func():
        print(666)
A.func()

类继承C3算法

# 类多继承c3算法
'''
在下面各类的关系
     H
G(H)     F(H)
E(G)     D(F)
C(E)     B(D)
    A(B,C,D)
    
查看A的寻找方法：
1.列出 B,C,D的深度查找顺序(从左往右),然后把A的继承顺序放到最后
    得到：[B,D,F,H] [C,E,G,H] [D,F,H] [B,C,D]
    在后面，我们把列表的第0个元素，叫做头 后面的叫做尾

2.我们取出第一个列表的头 也就是[B,D,F,H]中的第一个元素B，去和剩下列表的尾里面查找，是否有重复的。
    的到结果，没有重复的。
    那就把B放到一个新列表中，并且在原来所有列表中删除B
    执行完这一步之后的结果：
        [D,F,H] [C,E,G,H] [D,F,H] [C,D]
        新列表 [B,]
        
3.然后我们用 [D,F,H] [C,E,G,H] [D,F,H] [C,D] 来继续执行 2步骤。取出头 D 查看在其他列表的尾中是否有重复的
    的到结果，有重复的。那么我们跳过第一个列表，取出第二个列表的头 C。来执行2步骤 
    得到结果，没有重复的。
    执行之后的结果：
        [D,F,H] [E,G,H] [D,F,H] [D]
        新列表 [B,C ]
========================== 后面都是重复前面的步骤2 ====================================== 

4.然后我用继续用 [D,F,H] [E,G,H] [D,F,H] [D]来继续执行 2步骤。取出头 D 查看在其他列表的尾中是否有重复的
    的到结果，没有重复的
    执行之后的结果：
        [F,H] [E,G,H] [F,H] []
        新列表 [B,C,D ]
5.然后我用继续用 [F,H] [E,G,H] [F,H]来继续执行 2步骤。取出头 F 查看在其他列表的尾中是否有重复的
    的到结果，没有重复的
    执行之后的结果：
        [H] [E,G,H] [H] 
        新列表 [B,C,D,F ]
        
6.然后我用继续用 [H] [E,G,H] [H]来继续执行 2步骤。取出头 H 查看在其他列表的尾中是否有重复的
    得到结果，有重复的 那么我们跳过第一个列表，取出第二个列表的头 E。来执行2步骤 
    得到结果，没有重复的。
    执行之后的结果：
        [H] [G,H] [H] 
        新列表 [B,C,D,F,E ]
      
7.然后我用继续用 [H] [G,H] [H] 来继续执行 2步骤。取出头 H 查看在其他列表的尾中是否有重复的
    得到结果，有重复的 那么我们跳过第一个列表，取出第二个列表的头 G。来执行2步骤 
    得到结果，没有重复的。
    执行之后的结果：
        [H] [H] [H] 
        新列表 [B,C,D,F,E,G ]

8.然后我用继续用 [H] [H] [H]  来继续执行 2步骤。取出头 H 查看在其他列表的尾中是否有重复的
    得到结果，没有重复的。
    执行之后的结果：
        [] [] [] 
        新列表 [B,C,D,F,E,G,H ] 最后把A类自己加到第一个,把object加到最后

9.得到最终寻找结果 [A,B,C,D,F,E,G,H,object ]
    
 '''
class H:
    def func(self):
        print('H func')
        
class G(H):
    def func(self):
        print('G func')

class F(H):
    def func(self):
        print('F func')
        
class E(G):
    def func(self):
        print('E func')

class D(F):
    def func(self):
        print('D func')
        
class C(E):
    def func(self):
        print('C func')

class B(D):
    def func(self):
        print('B func')

class A(B,C,D):
    def func(self):
        print('A func')

print(A.mro())

posted on 2019-07-24 16:47 信奉上帝的小和尚阅读(116) 评论(0) 编辑收藏举报

刷新页面返回顶部

信奉上帝的小和尚

面向对象基础

导航

公告