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