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