Python 入门 之 类成员

1、类的私有成员：

私有： 只能自己拥有

以 __ 开头就是私有内容

1对于每一个类的成员而言都有两种形式：
2
3- 公有成员，在任何地方都能访问
4- 私有成员，只有在类的内部才能使用
5
6私有成员和公有成员的访问限制不同：
7	静态字段(静态属性)
8		- 公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
9		- 私有静态字段：仅类内部可以访问；
10
11
12class Human:
13
14    live = "有思想"        # 类公有的属性
15    __desires = "有欲望"   # (程序级别)类私有的属性
16    _desires = "有欲望"    # (程序员之间约定俗成)类私有的属性
17
18    def __init__(self,name,age,sex,hobby):
19        self.name = name
20        self.age = age
21        self.sex = sex        # 对象的公有属性
22        self.__hobby = hobby  # 对象的私有属性
23
24    def func(self):
25        # 类内部可以查看对象的私有属性
26        print(self.__hobby)
27
28    def foo(self):            # 公有方法
29        # 类内部可以查看类的私有属性
30        print(self.__desires)
31
32    def __abc(self):          # 私有方法
33        print("is abc")
34
35class B(Human):
36    pass
37    
38    def run(self):
39        print(self.__desires)
40        self._Human__abc()    # 强制继承(非常不推荐使用)
41
42b = B("天魔",28,"男","女孩子")
43print(b.__desires)
44b.run()
45b._Human__abc()         # _类名私有的属性和方法
46                        # 子类不能继承父类中私有的方法和属性
47
48# 类的外部查看
49print(Human.live)
50print(Human._desires)
51
52 # 保证数据的安全性
53Human.live = "无脑"
54print(Human.live)

​ 为什么可以通过.类__私有成员名访问呢?因为类在创建时,如果遇到了私有成员(包括私有静态字段,私有普通字段,私有方法)它会将其保存在内存时自动在前面加上类名.

2、类的其他成员

（1）类方法：

1class A:
2
3    def func(self):         #实例方法
4        print("is A func")
5
6a = A()  # 实例化 一个对象(实例)
7A.func()  # 添加参数
8a.func()
9
10
11class A:
12
13    def func(self):             #实例方法
14        print("is A func")
15
16import time
17class Times:
18
19    t = time.time()   # 类属性
20
21    @classmethod    
22    def func(cls):
23        print(cls)   # 类的地址
24        print("is A func")
25        object = cls()    # 使用类方法可以获取到类地址进行实例化
26        cls.t = 1010101
27
28a = A()
29a.func()
30
31Times.func()
32print(Times.t)
33
34
35class Human:
36    count = 0
37
38    def __init__(self, name, age):
39        self.name = name
40        self.age = age
41
42    @classmethod
43    def add_count(cls):
44        cls.count += 1       # 可以通过类名修改类属性
45
46    @classmethod
47    def get(cls):
48        return cls.count
49
50Human("天魔",56)
51Human("天魔",56)
52Human("天魔",56)
53Human("天魔",56)
54Human("天魔",56)
55Human("天魔",56)
56Human("天魔",56)
57print(Human.get())     # 输出实例化的次数

<1> 类方法的作用：

类方法可以自动变换类名（最大的作用）

1> 使用类方法可以获取到类地址进行实例化

2> 可以通过类名修改类属性

类方法偶然会使用，使用最多的还是实例化方法

（2）静态方法（使用更少）

1class A:
2
3    def func(self):        # 实例方法
4        print("is A func")
5
6    @classmethod
7    def cls_func(cls):     # 类方法
8        print("is A cls_func")
9
10    @staticmethod
11    def static_func():      # 静态方法
12        print("他就是普通的函数了")
13        
14def static_func():
15    print("他就是普通的函数了")
16
17A.static_func()
18a = A()
19a.static_func()

<1> 静态方法不依赖于对象和类（静态方法就是一个普通的函数）

2、属性 ：组合（伪装）

1class A:
2
3    live = "有思想"
4
5    def func(self):
6        print("is A func")
7
8A.live
9A.func()
10
11
12class A:
13
14    @property 
15    def func(self):
16        print("is A func")
17
18a = A()
19a.func
20
21
22class Bmi:
23
24    live = "有思想"
25
26    def __init__(self, height, weight):
27        self.height = height
28        self.weight = weight
29
30    @property
31    def bmi(self):
32        return self.weight / self.height ** 2
33
34    @bmi.setter            # 设置属性时执行
35    def bmi(self,value):
36        print(value)
37        print("设置属性时执行我")
38
39    @bmi.getter            # 查看属性时执行
40    def bmi(self):
41        print("查看属性时执行我")
42
43    @bmi.deleter		   # 删除属性时执行
44    def bmi(self):
45        print("删除属性时执行我")
46
47rimo = Bmi(1.8,100)
48print(rimo.live) # 真属性
49
50rimo.live = "无脑"
51del Bmi.live
52print(rimo.live)
53print(rimo.bmi)
54print(Bmi.__dict__)
55
56rimo.bmi = 20    # 伪装成属性进行设置
57print(rimo.bmi)  # 伪装成属性
58del rimo.bmi
59
60
61
62class Foo:
63
64    def get_AAA(self):
65        print('get的时候运行我啊')
66
67    def set_AAA(self,value):
68        print('set的时候运行我啊')
69
70    def delete_AAA(self):
71        print('delete的时候运行我啊')
72
73    AAA = property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应
74
75f1=Foo()
76f1.AAA
77f1.AAA = 'aaa'
78del f1.AAA
79

3、元类

（1）type 查看数据类型（能够查看出当前内容从属于那个类）

1print(type("alex"))
2print(type([1,2,3,4]))
3print(type((1,2,3,40)))
4
5
6
7class A:
8    pass
9
10a = A()
11
12print(type(a))
13
14
15
16print(type(A))
17print(type(str))
18print(type(list))
19print(type(tuple))
20print(type(object))
21

python自带的str、list、tuple也是某一个类的对象(python中一切皆对象)

（2）isinstance 判断参数1是不是参数2的对象

1print(isinstance([1,2,3],list))
2print(isinstance(str,type))
3print(isinstance(list,type))
4print(isinstance(object,type))
5

（3）issubclass 判断参数1是不是参数2的子类

1class A:
2    pass
3
4class B(A):
5    pass
6
7print(issubclass(B,A))
8

4、元类 -- 构建类

（1）object 与 type的关系

<1> object是type的对象

<2> 新式类都默认继承object

1print(issubclass(type,object))  # type是object的子类
2print(isinstance(object,type))  # object是type的对象