文章目录



python七：类_实例化

推荐指数：⭐⭐⭐

类的定义


类名的命名规范和变量名命令规范一致类名一般使用驼峰命名法


# -*- coding: utf-8 -*-
#类的定义
class OBJ:
    #pass 不做任何事情，一般用做占位语句。
    pass    #pass 是空语句，是为了保持程序结构的完整性

类的属性


类中的属性其实就是变量


# -*- coding: utf-8 -*-
class Cls:
    id = 362424
    name = '张三'

对类的属性进行增删查改

# -*- coding: utf-8 -*-
#类的定义
class OBJ:
    id = 1002
#增加属性 修改属性 查找属性
OBJ.name = "新增属性"   #如果该类中不存在该属性则新增，否则修改
print(OBJ.name)
#删除属性
del OBJ.name        #如果该类中不存在该属性则报错，否则删除
#print(OBJ.name)    #已被删除，报错

类的实例


实例 = 类名() 生成实例的过程叫做实例化 即 类名()称之为实例化


# -*- coding: utf-8 -*-
#类的定义
class OBJ:
    id = 1002

obj = OBJ() #实例化对象

对实例的属性进行增删查改

# -*- coding: utf-8 -*-
#类的定义
class OBJ:
    id = 1002

obj = OBJ() #实例化对象
#增加实例属性 修改实例属性 查找实例属性
obj.id = '编号'
print(obj.id,OBJ.id)    #实例的属性的改变不会影响类的属性
编号 1002

​​类的属性的改变影响实例的属性​​

# -*- coding: utf-8 -*-
#类的定义
class OBJ:
    id = 1002

obj = OBJ() #实例化对象
#类的属性的改变在没有对实例进行修改时会影响实例的属性     
OBJ.id = '编号'
print(obj.id,OBJ.id)
编号 编号

​​对实例的属性修改时，类的属性改变不会影响实例的属性​​

# -*- coding: utf-8 -*-
#类的定义
class OBJ:
    id = 1002;

obj = OBJ() #实例化对象
#增加实例属性 修改实例属性 查找实例属性
obj.id = '独立'
OBJ.id = '编号'
print(obj.id,OBJ.id)

类的方法


class 类名:
def 方法名(参数):
pass


类调用方法

# -*- coding: utf-8 -*-
class OBJ:
    def fun():
        print('fun')
OBJ.fun()

实例调用方法

# -*- coding: utf-8 -*-
#实例调用方法
class OBJ:
    def fun():
        print('类调用方法')
    def function(self):
        print('实例调用方法')
OBJ.fun()       #类调用的方法不能带参数
obj = OBJ()
obj.function()  #实例调用方法会将自身当做参数传入到第一个参数中去
类调用方法
实例调用方法

访问控制权限

受保护的属性/方法


_属性名=属性值
def _方法名(参数)


​​一个下划线代表该成员为保护成员，只有类实例和子类实例能访问到这些变量，​​

私有的属性/方法


__属性名=属性值
def __方法名(参数)


​​两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问​​

# -*- coding: utf-8 -*-
#类的访问控制权限
class Cls:
    _id = '身份证'         #只有类实例和子类实例能访问
    __name = '张三'        #只有类对象自己能访问，连子类对象也不能访问
    def fun():
        print('fun')
    def _live(self):       #只有类实例和子类实例能访问
        print("hello")
    def __information(self):    #只有类对象自己内部能访问，连子类对象也不能访问
        print(self._id,self.__name)

Cls.fun()
obj = Cls()     #实例化对象
obj._live()     #实例可以调用保护方法
#Python会在类的内部自动的把我们定义的__information私有变量的名字替换成为_
#classname__information classname为类名，私有是通过改名实现的伪私有
print(obj._id,obj._Cls__name)   #访问私有成员
obj._Cls__information()

魔术方法

__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__str__: 打印实例，将实例转为字符串，优先级比repr高
__call__: 函数调用   

__class__ 查看类名
__dict__  查看全部属性，返回属性和属性值键值对形式
__doc__  查看对象文档，即类中的注释(用引号注视的部分)
__dir__ 查看全部属性和方法

__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方

初始化/销毁方法

​​实例化之后触发的方法,相当于C++里面的构造函数，程序结束时或者实例被销毁是触发销毁方法​​

# -*- coding: utf-8 -*-
class Cls:
    def __init__(self):
        print('初始化方法__init__')
    def __del__(self):
        print('销毁方法__del__')
obj = Cls()
temp = Cls()
del temp
str = input('input something:')
print('data:',str)
print('程序运行结束，实例被销毁，运行销毁方法')
初始化方法__init__
初始化方法__init__
销毁方法__del__
input something:python
data: python
程序运行结束，实例被销毁，运行销毁方法
销毁方法__del__

str/repr

​​__str__ 方法可以在打印实例的时候触发 将实例转为字符串的时候触发，适用于给用户提供必要信息，便于用户使用产品​​

​​__repr__ 可以在打印实例的时候触发 将实例转为字符串的时候触发，适用于给开发者提供必要信息，便于测试以及维护​​

# -*- coding: utf-8 -*-
class OBJ:
    def __repr__(self):
        print('触发了repr方法')
        return 'repr方法返回值'
obj = OBJ()
print(obj)  #打印实例时触发repr方法
recv = str(obj) #将实例转为字符串时触发repr方法 
print(recv)
触发了repr方法
repr方法返回值
触发了repr方法
repr方法返回值
# -*- coding: utf-8 -*-
class OBJ:
    def __str__(self):
        print('触发了str方法')
        # 一般写的是给  用户看的东西
        return 'str方法返回值'
    def __repr__(self):
        print('触发了repr方法')
        # 给开发者看的  例如错误信息
        return 'repr方法返回值'
obj = OBJ()
print(obj)  #打印实例时触发str,repr方法,str优先级更高
recv = str(obj) #将实例转为字符串时触发str,repr方法 str优先级更高
print(recv)
触发了str方法
str方法返回值
触发了str方法
str方法返回值

call方法


实例名()：触发call方法


# -*- coding: utf-8 -*-
#call方法
class OBJ:
    """
    call方法：这是一个测试
    """
    def __call__(self, *args, **kwargs):
        print('触发call方法')
obj = OBJ() 
obj()   #OBJ()()也可以触发call方法
触发call方法

运算符重载

__add__(self,other) # x+y
__sub__(self,other) # x-y
__mul__(self,other) # x*y
__mod__(self,other) # x%y
__iadd__(self,other)  # x+=y
__isub__(self,other)  # x-=y
__radd__(self,other)  # y+x
__rsub__(self,other)  # y-x
__imul__(self,other)  # x*=y
__imod__(self,other)  # x%=y

只演示加法运算。其余类似

# -*- coding: utf-8 -*-
#运算符重载
class OBJ:
    def __add__(self, other):
        print("进行a+b的自定义运算操作")
obj1 = OBJ()
obj2 = OBJ()
obj1 + obj2
进行a+b的自定义运算操作

其他方法

__class__ 查看类名
__dict__  查看全部属性，返回属性和属性值键值对形式
__doc__  查看对象文档，即类中的注释(用引号注视的部分)
__dir__ 查看全部属性和方法
# -*- coding: utf-8 -*-
#其他
class OBJ:
    """
    doc 类说明
    """
    age = 18
    height = 180
    pass #空语句，不进行任何操作

obj = OBJ()
obj.age = 20
print(obj.__class__())  #打印类名
print(obj.__dict__)     #height没有改变，不会被打印
print(obj.__doc__)      #打印类说明
print(obj.__dir__())    #打印类所有信息

#print(dir(obj)) #打印obj的信息，底层调用的是__dir__函数
{'age': 20}

    doc 类说明

['age', '__module__', '__doc__', 'height', '__dict__', '__weakref__', '__repr__', '__hash__', '__str__', '__getattribute__', '__setattr__', '__delattr__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__init__', '__new__', '__reduce_ex__', '__reduce__', '__subclasshook__', '__init_subclass__', '__format__', '__sizeof__', '__dir__', '__class__']

继承


class 类名(父类):
pass


​​继承父类的所有的属性和方法​​

重写

​​如果对继承的属性和方法的内容进行修改,子类重写父类的属性和方法叫做重写​​

# -*- coding: utf-8 -*-
#继承
class Base:
    name = '祖先'
    sex = '男'
class Father(Base):
    profession = '程序员'
    name = '子孙' #重写父类中的name
    def __init__(self):
        self.sex = '女'  #sex为父类继承过来的成员
        print(self.name,self.sex,self.profession)

base = Base()   #实例化对象
obj = Father()  #实例化对象

多继承

​​多个父类有相同属性或者方法的时候会优先继承第一顺位父类的属性和方法​​

# -*- coding: utf-8 -*-
#多继承
class Telephone:
    prise = 200
    def call(self):
        print('打电话')
class Camera:
    prise = 500
    def photo(self):
        print('照相')

class Ipod:
    prise = 1000
    def music(self):
        print('听歌')

class IphoneXs(Telephone,Camera,Ipod):
    def __init__(self):
        print(self.prise)   #prise在三个父类中都存在，继承第一顺位Telephone的self
        self.call()
        self.photo()
        self.music()

myIphoneXs = IphoneXs()
200
打电话
照相
听歌

菱形继承

​​菱形继承也叫钻石继承，在这种结构中，当子类的对象使用一个属性时，首先会在子类中查找是否有该属性和方法，如果没有则会到父类中查找，如果还没有则会继续往父类的父类中查找。​​

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iIJI3BFO-1625017112688)(D:\微信公众号\图片\python\20200715195730.png)]

看一个示例：

# -*- coding: utf-8 -*-
#菱形继承
class Base:
    age = 100

class Father:
    age = 60

class Mather:
    age = 50

class Son(Father,Mather):
    def fun(self):
        print(self.age);    #age继承的是第一顺位的也就是Father的age=60
obj = Son()
obj.fun()
print(Son.mro())    #查看继承顺序
60
[
<class '__main__.Son'>, 
<class '__main__.Father'>,
<class '__main__.Mather'>, 
<class 'object'>]

​​object是所有对象的基类，从继承顺序可以看出Son的第一顺位是Father​​

棱形继承的顺序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JSWvrf6M-1625017112689)(D:\微信公众号\图片\python\20200715195606.png)]

通过​​__mro__​​方法查看棱形继承顺序

子类调用父类的方法

​​该父类在继承顺序上是当前类的上一级​​


supper().属性名

supper().方法名()


​​该父类在继承顺序上不是当前类的上一级,假设Parent为子类的第一顺位​​


supper(Parent, self).属性名

supper(Parent, self).方法名()


# -*- coding: utf-8 -*-
#菱形继承
class Base:
    age = 100
    def __init__(self):
        print('Base 初始化')

class Father:
    age = 60
    def __init__(self):
        print('Father 初始化')

class Mather:
    age = 50
    def __init__(self):
        print('Mather 初始化')

class Son(Father,Mather):
    def __init__(self):
        #print("Son 初始化")
        #调用Father的初始化
        #super().__init__()             #该父类在继承顺序上是当前类的上一级
        #调用Mather的初始化
        super(Father, self).__init__()  #该父类在继承顺序上不是当前类的上一级
obj = Son()
print(Son.mro())    #查看继承顺序