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的对象