014 Python语法之类与对象-优快云博客

本文详细介绍了Python中类与对象的基本概念，包括类的定义、结构、权限设计，实例变量与类变量的区别，以及继承、多态、动态绑定属性和方法等高级特性。同时还探讨了类方法、静态方法和属性方法的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

类与对象

类

class Person:
    def __init__(self):
        self.name = "Luo"
        self.mystr = "任你千般芳华万般妖娆，我只问一句，可解Bug否？"
    
    def work(self):
        print("生命不息，奋斗不止！")

p1 = Person()
print(p1.name)
print(p1.mystr)
p1.work()

类的定义与结构

class 类名:
    def __init__(self, 形参1, 形参2):
        self.属性1 = 形参1
        self.属性2 = 形参2
    
    def __del__(self):
        pass

类的介绍

class关键字修饰类
init方法用于类的初始化自动调用
del方法(析构函数)用于类被销毁时自动调用

类的权限设计

class Bank:
    def __init__(self, money, yearRate, year):
        self.__money = money
        self.__yearRate = yearRate
    
    def __getRateMoney(self):
        return self.money * (1 + self.yearRate)**year
    
    def getMoney(self):
        self.__getRateMoney()
        
bank = Bank(10000, 0.04, 10)
bank.getmoney()

类的权限设计注意点

加上双下划线，变量和方法就变成私有的了，外部不能直接访问
私有变量和方法可通过对象._类名__变量名访问

类内部访问私有变量的方式

class Circle:
    def __init__(self, radius):
        self.__radius = radius

    def getRadius(self):
        return self.__radius

这里外部不能访问 __radius 属性
c1 = Circle(5)
c1.__radius 和 c1.radius 都不能访问到 radius 这个私有变量
-----------------------
下面这种方式才能访问私有变量
c1.getRadius()这个能访问到 self.__radius 这个私有变量的值

类外部访问私有变量的方式

1. Python私有变量在类内部的命名特性,根据 name mangling 技术,
2. 私有变量的名字都会变成(_类名__变量名)的形式

class Circle:
    def __init__(self, radius):
        self.__radius = radius

    def getRadius(self):
        return self.__radius

c1 = Circle(5)
c1._Circle__radius 这个能访问到 self.__radius

实例变量（类修改变量值不会对实例变量产生影响）

一个类修改实例变量不会影响该类创建时候该类实例变量的值

类变量（类修改变量的值会影响类实例调用该变量的值）

类也会创建一个实例，每次创建一个对象时都会从类中拷贝类的所有状态
如果在创建一个类之前通过类名修改了类的不可变变量的值，创建的实例中的值也会相应的改变，但是实例变量修改不会影响类变量
如果在创建一个类之前通过类名修改了类的可变变量的值，创建的实例中的值也会相应的改变，但是实例变量修改会影响类变量

继承

儿子的属性和方法会覆盖父亲类
儿子类继承所有父类非私有方法和属性
儿子想自己也拥有自己的属性需要调用父类的init方法

继承的格式

class 类1(类2):
    pass

继承的用法

class Person:
    def __init__(self):
        self.name = "Luo"
        self.mystr = "任你千般芳华万般妖娆，我只问一句，可解Bug否？"
    
    def work(self):
        print("生命不息，奋斗不止！")

class Luo(Person):
    pass

luo1 = Luo()
print(luo1.name)
print(luo1.mystr)
luo1.work()

经典类与新式类

class People:   经典类写法
    pass

class Man:   
    def __init__(self,name,age):
        People.__init__(self,name,age)  经典类写法


class People(object):   新式类的写法
    def __init__(self,name,age):
        super(Man,self).__init__(name,age)  新式类的写法

Python2/3中经典类与新式类继承方式

py2中经典类时按照深度优先来继承的，新式类时按照广度优先来继承的
py3中经典类与新式类都是统一按照广度优先来继承的

多继承

多继承情况下，如果该类想拥有自己的属性，那么必须用类名去分别调用init方法
属性后面调用的init覆盖前面调用的（后覆盖前）
方法会前者覆盖后者

多继承用的场合

同时要用到多个类的功能就需要多继承

继承的局限性

无法拿到父类的私有方法与属性（通过父类名还是能拿到）

类的一般属性

doc:类的说明（类似文档注释）
name:类的名字
module:从哪开始执行的
bases:类的多个父类
base:类的单个父类
dict:类全部信息，以字典的形式
class:当前类的类型

super关键字

父类少初始化，节省内存

多态接口

class F:
    def show(self):
        print("F Show")

class A(F):
    def show(self):
        print("A Show")

class B(F):
    def show(self):
        print("B Show")

def Fun(C):
    C.show()

a = A()
b = B()
Fun(a)
Fun(b)

--------------------------------
class Animal:
    def __init__(self, name):
        self.name = name

    def talk(self):
        pass

    @staticmethod
    def animal_talk(obj):
        '''接口'''
        obj.talk()

class Cat(Animal):
    def talk(self):
        print('Meow!')


class Dog(Animal):
    def talk(self):
        print('Woof! Woof!')


d = Dog("D1")

c = Cat("C1")

Animal.animal_talk(c)
Animal.animal_talk(d)

多态介绍

因为Python定义参数不需要数据类型，所以在Python中用方法当做接口去实现多态
为了解决不同对象的各种需求，接口就应运而生了

类的动态绑定属性和方法

类可以在对象创建时动态添加属性和方法
动态添加的属性和方法只在当前对象有用，对其他对象无影响

动态添加属性

class XiaoA:
    pass

xiaoA = XiaoA()
xiaoA.女神的备胎数量 = 99   # 动态添加的

动态添加方法

class XiaoA:
    def __init__(self):
        self.女神的备胎数量 = 99

def 中奖(self):
    self.女神的备胎数量 = 0

xiaoA = XiaoA()
xiaoA.中奖 = types.MethodType(中奖, xiaoA)
xiaoA.中奖()
print(xiaoA.女神的备胎数量) --> 0

类的属性动态操作

判断当前对象是否有某属性

hasattr(对象,"属性名")

设置当前对象的属性(有该属性就覆盖值)

setattr(对象, "属性名", 设置值)

读取属性的细节

如果有该属性就返回该属性值，没有就返回默认值

读取这个对象的属性

getattr(对象, "属性名", 默认值)

读取属性的细节

如果有该属性就返回该属性值，没有就返回默认值

类的方法动态操作

判断当前对象是否有某方法

hasattr(对象,"方法名")

设置当前对象的方法(有该属性就覆盖值)

class XiaoA:
    def __init__(self):
        self.女神的备胎数量 = 99

def 中奖(self):
    self.女神的备胎数量 = 0

xiaoA = XiaoA()
xiaoA.中奖 = types.MethodType(中奖, xiaoA)
xiaoA.中奖()
print(xiaoA.女神的备胎数量) --> 0

读取方法的细节

如果有该方法就返回该方法

读取这个对象的属性

getattr(对象, "属性名", 默认值)

对象属性方法与类属性方法

class XiaoA:
    def __init__(self):
        self.女神的备胎数量 = 99    # 类属性

xiaoA.name = "xiaoB"    # 对象属性

限制属性(只能操作和使用限制的属性)

class XiaoA:
    __slots__ = ("name", "love")

xiaoA = XiaoA()
xiaoA.name="xiaoA"
xiaoA.love = "xiaoB"
xiaoA.loveother = "aaa" # 会报错

类方法与静态方法和属性方法

class XiaoA:
    @classmethod
    def love(self):
        self.name=

类方法介绍

@classmethod修饰的方法是类方法
类方法可以用类名调用，也可以用对象调用
类方法无法覆盖类属性，可以在这里初始化
必须加上self
只能访问类变量，不能访问实例变量

静态方法

静态方法实际上和类没有关系了，仅仅只要类名调用
@staticmethod修饰的方法是静态方法
静态方法可以用类名调用，也可以用对象调用
参数可以不带self
作用一般多态会用到，或者一个工具类集合

静态方法与类方法的对比

不用加self，其他差不多

属性方法property(类似Java中get/set方法)

把一个方法变成一个属性，然后像属性一样用，不用加括号调用
屏蔽信息获取解析过程，只暴露结果

静态方法

class Dog(object):
    def __init__(self,name):
        self.name = name

    @staticmethod #实际上跟类没什么关系了
    def eat(self):
        print("%s is eating %s" %(self.name,'dd'))

    def talk(self):
        print("%s is talking"% self.name)
d = Dog("ChenRonghua")
d.eat(d)
d.talk()

类方法

class Dog(object):
    #n = 333
    #name = "huazai"
    def __init__(self,name):
        self.name = name
        #self.n  = 333
    #@staticmethod #实际上跟类没什么关系了
    @classmethod
    def eat(self):
        print("%s is eating %s" %(self.name,'dd'))

    def talk(self):
        print("%s is talking"% self.name)


d = Dog("ChenRonghua")
d.eat()

属性方法

class Flight(object):
    def __init__(self,name):
        self.flight_name = name


    def checking_status(self):
        print("checking flight %s status " % self.flight_name)
        return  0

    @property
    def flight_status(self):
        status = self.checking_status()
        if status == 0 :
            print("flight got canceled...")
        elif status == 1 :
            print("flight is arrived...")
        elif status == 2:
            print("flight has departured already...")
        else:
            print("cannot confirm the flight status...,please check later")
    @flight_status.setter
    def flight_status(self,status):
        print("flight %s has changed status to %s" %(self.flight_name,status))

    @flight_status.deleter
    def flight_status(self):
        del self.flight_name
    
    
f = Flight("CA980")
f.flight_status
f.flight_status = 2

枚举类

import enum # 枚举

@enum.unique
class 象棋(enum.Enum):
    帅=1000     # 无需排序
    车=10
    马=5
    炮=5

枚举类的介绍

象棋.帅.value # 象棋.帅的值
象棋.帅.name # 象棋.帅的名字

动态创建类

def show(self,name):
    print("我是", name)
    
# A是类的名字，(object父类) dict字典
A = type("A", (object,), dict(showname = show))

a = A() # 初始化
a.showname("Luo")   # 调用了show方法
print(type(A))  # type类型：动态类型
print(type(a))  # A类型，两个A可以不一样

动态创建类第二版

def func(self):
    print("hello %s"%self.name)

def __init__(self,name,age):
    self.name = name
    self.age = age

Foo = type("Foo",(object,), {"talk":func,"__init__":__init__})
f = Foo("Luo",22)
f.talk()