欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Python 入门 之 类成员

程序员文章站 2022-06-07 14:34:41
Python 入门 之 类成员 类的私有成员 类的其他成员 元类 元类 -- 构建类 ......

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