Python 入门 之 类成员

1、类的私有成员

私有： 只能自己拥有

以 __ 开头就是私有内容

对于每一个类的成员而言都有两种形式：

- 公有成员，在任何地方都能访问
- 私有成员，只有在类的内部才能使用

私有成员和公有成员的访问限制不同：
	静态字段(静态属性)
		- 公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
		- 私有静态字段：仅类内部可以访问；

class Human:

    live = "有思想"        # 类公有的属性
    __desires = "有欲望"   # (程序级别)类私有的属性
    _desires = "有欲望"    # (程序员之间约定俗成)类私有的属性

    def __init__(self,name,age,sex,hobby):
        self.name = name
        self.age = age
        self.sex = sex        # 对象的公有属性
        self.__hobby = hobby  # 对象的私有属性

    def func(self):
        # 类内部可以查看对象的私有属性
        print(self.__hobby)

    def foo(self):            # 公有方法
        # 类内部可以查看类的私有属性
        print(self.__desires)

    def __abc(self):          # 私有方法
        print("is abc")

class B(Human):
    pass
    
    def run(self):
        print(self.__desires)
        self._Human__abc()    # 强制继承(非常不推荐使用)

b = B("天魔",28,"男","女孩子")
print(b.__desires)
b.run()
b._Human__abc()         # _类名私有的属性和方法
                        # 子类不能继承父类中私有的方法和属性

# 类的外部查看
print(Human.live)
print(Human._desires)

 # 保证数据的安全性
Human.live = "无脑"
print(Human.live)

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

2、类的其他成员

（1）类方法：

class A:

    def func(self):         #实例方法
        print("is A func")

a = A()  # 实例化 一个对象(实例)
A.func()  # 添加参数
a.func()

class A:

    def func(self):             #实例方法
        print("is A func")

import time
class Times:

    t = time.time()   # 类属性

    @classmethod    
    def func(cls):
        print(cls)   # 类的地址
        print("is A func")
        object = cls()    # 使用类方法可以获取到类地址进行实例化
        cls.t = 1010101

a = A()
a.func()

Times.func()
print(Times.t)

class Human:
    count = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def add_count(cls):
        cls.count += 1       # 可以通过类名修改类属性

    @classmethod
    def get(cls):
        return cls.count

Human("天魔",56)
Human("天魔",56)
Human("天魔",56)
Human("天魔",56)
Human("天魔",56)
Human("天魔",56)
Human("天魔",56)
print(Human.get())     # 输出实例化的次数

<1> 类方法的作用：

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

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

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

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

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

class A:

    def func(self):        # 实例方法
        print("is A func")

    @classmethod
    def cls_func(cls):     # 类方法
        print("is A cls_func")

    @staticmethod
    def static_func():      # 静态方法
        print("他就是普通的函数了")
        
def static_func():
    print("他就是普通的函数了")

A.static_func()
a = A()
a.static_func()

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

2、属性 ：组合（伪装）

class A:

    live = "有思想"

    def func(self):
        print("is A func")

A.live
A.func()

class A:

    @property 
    def func(self):
        print("is A func")

a = A()
a.func

class Bmi:

    live = "有思想"

    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

    @property
    def bmi(self):
        return self.weight / self.height ** 2

    @bmi.setter            # 设置属性时执行
    def bmi(self,value):
        print(value)
        print("设置属性时执行我")

    @bmi.getter            # 查看属性时执行
    def bmi(self):
        print("查看属性时执行我")

    @bmi.deleter		   # 删除属性时执行
    def bmi(self):
        print("删除属性时执行我")

rimo = Bmi(1.8,100)
print(rimo.live) # 真属性

rimo.live = "无脑"
del Bmi.live
print(rimo.live)
print(rimo.bmi)
print(Bmi.__dict__)

rimo.bmi = 20    # 伪装成属性进行设置
print(rimo.bmi)  # 伪装成属性
del rimo.bmi

class Foo:

    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')

    AAA = property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA = 'aaa'
del f1.AAA

3、元类

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

print(type("alex"))
print(type([1,2,3,4]))
print(type((1,2,3,40)))

class A:
    pass

a = A()

print(type(a))

print(type(A))
print(type(str))
print(type(list))
print(type(tuple))
print(type(object))

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

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

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

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

class A:
    pass

class B(A):
    pass

print(issubclass(B,A))

4、元类 -- 构建类

（1）object 与 type的关系

<1> object是type的对象

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

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