Python-面向对象编程(超详细易懂)

超详细Python教程——面向对象编程基础 在Python中可以使用class关键字定义类,然后在类中通过之前学习过的函数来定义方法,这样就可以将对象的动态特征描述出来,代码如下所示。# __init__是一个特殊方法用于在创建对象时进行初始化操作# 通过这个方法我们可以为学生对象绑定name和age两个属性print('%s正在学习%s.' % (self.name, course_name))# PEP 8要求标识符的名字用全小写多个单词用下划线连接# 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识) 阅读详情
AI摘要

本文深入浅出地讲解了Python面向对象编程的基础概念,包括类和对象、封装、继承与多态等核心特性,并通过丰富的示例代码展示了如何在实际项目中应用。

面向对象编程(oop)

       面向对象是Python最重要的特性,在Python中一切数据类型都是面向对象的。

       面向对象的编程思想:按照真实世界客观事物的自然规律进行分析,客观世界中存在什么样的实体,构建的软件系统就存在什么样的实体。

       例如:在学校里,有学生实体,学生是抽象的描述,称为“类”;而张同学、李同学等具体的学生个体称为“对象”,也称为“实例”;学生有学号、姓名、班级等属性,还有吃饭、走路等操作。

面向对象三大特性:封装性、继承性、多态性

封装性:使外部访问者不能随意存取对象的内部数据,隐藏了对象的内部细节,只保留有限的对外接口。外部访问者不用关心对象的内部细节,操作对象变得简单。

继承性: 特殊类继承一般类,拥有一般类的全部数据和操作。一般类称为“父类”或“超类”,特殊类称为“子类”或“派生类”。

多态性:在父类中成员被子类继承后,可以具有不同的状态或表现行为。

类和对象

       Python中的数据类型都是类,类是组成Python程序的基本要素,它封装了一个类对象的数据和操作。

定义类

Python语言中一个类的实现包括类定义和类体。语法格式如下:

class 类名[(父类)]:
    类体

 输入下面代码

class Animal(): # 创建Animal类
    pass
class Books(): # #创建Books类
    pass

# 分别创建对应的类对象
a = Animal()
b = Books()

print(id(Animal))
print(type(Animal))
print(type(a))
print(type(b))

代码运行结果

1939387281408
<class 'type'>
<class '__main__.Animal'>
<class '__main__.Books'>

Process finished with exit code 0

       注意:object类是所有类的根类,在Python中任何一个类都直接或间接的继承object;代码的pass语句表示什么操作都不执行,用来维持程序结构的完整。

创建、使用和销毁对象

       一个对象的生命周期包括创建、使用和销毁。类实例化可生成对象,所以对象也称为“实例”。

       创建对象就是在类对象的后面加上一对小括号,表示调用类对象的构造方法,这就创建了一个对象,示例代码如下

class Animal:
    pass
'''
Animal()表达式创建了一个对象,并把创建的对象通过“=”赋给animal变量
animal是指向对象的一个引用。通过animal可以使用刚刚创建的对象
'''
animal = Animal()
# print函数实际上是调用了对象的__str__()方法(__str__()是object类的一个方法,
# 用于返回有关该对象的描述信息)输出字符串信息
print(animal)

代码运行结果

<__main__.Animal object at 0x000001A74F1F1970>

销毁对象

       Python会实现自动的垃圾回收:当对象没有被引用时(引用计数为0),由垃圾回收器调用__del__()(析构函数),__del__()被称为“析构方法”,用于实现对象被销毁时所需的操作。比如:释放对象占用的资源(例如:打开的文档资源、网络连接等)。我们也可以通过del语句删除对象,系统会自动调用__del__()方法,一般不需要自定义析构方法。

示例代码如下

class Person:
    def __del__(self):
        print("销毁对象:{0}".format(self))
p1 = Person()
p2 = Person()
del p2
'''
当 p2 的引用被 del 语句删除时
p2 的 __del__ 方法会被调用
但是,p1 的 __del__ 方法可能在程序结束前不会被调用
因为它的引用仍然存在于变量 p1 中
'''
print("程序结束")

代码运行结果

销毁对象:<__main__.Person object at 0x000001B649C01AF0>
程序结束
销毁对象:<__main__.Person object at 0x000001B649C01AC0>

 实例变量

“实例变量”就是某个实例(或对象)个体特有的数据。

示例代码如下

class Animal(object):
    def __init__(self,name,age,weight,gender):
        self.name = name # 定义姓名实例变量
        self.age= age # 定义年龄实例变量
        self.weight = weight # 定义体重实例变量
        self.gender =gender   # 定义性别实例变量
animal = Animal('Tom',18,66,1)
animal1 = Animal('Mary',18,50,0)

print("姓名:{0},年龄:{1},体重:{2}".format(animal.name,animal.age,animal.weight))
print("男性" if animal.gender==1 else '女性')
print("姓名:{0},年龄:{1},体重:{2}".format(animal1.name,animal1.age,animal1.weight))
print("男性" if animal1.gender==1 else '女性')

代码运行结果

姓名:Tom,年龄:18,体重:66
男性
姓名:Mary,年龄:18,体重:50
女性

 类变量

       “类变量”是所有实例(或对象)共有的变量,需要在方法外定义,访问实例变量通过“实例名.实例变量名”的形式,而访问类变量“类名.类变量名”的形式访问。

示例代码如下

class Account:
    interest_rate = 0.068 # 类变量
# 重写构造方法
    def __init__(self,owner,amount):
        self.owner =  owner
        self.amount = amount
account = Account('Tony',1_800_000.0)
# 查看实例变量
print('account实例所有变量:{0}'.format(account.__dict__))
# 为account.interest_rate变量赋值,此时无论类中是否有同名变量都会创建一个新的实例变量
account.interest_rate = 0.01
account.interest_rate2 = 0.01
print('账户名:{0}'.format(account.owner))
print('账号金额:{0}'.format(account.amount))
print('利率:{0}'.format(Account.interest_rate))
# 查看实例变量
print('account实例所有变量:{0}'.format(account.__dict__))

代码运行结果

account实例所有变量:{'owner': 'Tony', 'amount': 1800000.0}
账户名:Tony
账号金额:1800000.0
利率:0.068
account实例所有变量:{'owner': 'Tony', 'amount': 1800000.0, 'interest_rate': 0.01, 'interest_rate2': 0.01}

       注意:不要通过实例存取类变量数据。当通过实例读取变量时,Python解释器会先在实例中找这个变量,如果没有再到类中去找;当通过实例为变量赋值时,无论类中是否有该同名变量,Python解释器都会创建一个同名实例变量。 

构造方法

       __init_()方法是构造方法,用来创建和初始化实例变量,定义时它的第一个参数应该是self,其后的参数才是用来初始化实例变量的;其中参数可以有默认值。调用构造方法时不需要传入self。如果未定义构造方法,则会自动调用默认的构造方法;一旦定义了构造方法,则不会调用默认的构造方法。

输入下面代码

class Animal(object):
    # 构造方法
    def __init__(self,name='mark',age=20,weight=120,gender=120):
        self.name = name # 定义姓名实例变量
        self.age= age # 定义年龄实例变量
        self.weight = weight # 定义体重实例变量
        self.gender =gender   # 定义性别实例变量
animal0 = Animal() # 此时没有传入参数,参数为默认值
animal = Animal('Tom',18,66,1)
animal1 = Animal('Mary',18,50,0)

print("姓名:{0},年龄:{1},体重:{2}".format(animal0.name,animal0.age,animal0.weight))
print("姓名:{0},年龄:{1},体重:{2}".format(animal.name,animal.age,animal.weight))
print("姓名:{0},年龄:{1},体重:{2}".format(animal1.name,animal1.age,animal1.weight))

代码运行结果

姓名:mark,年龄:20,体重:120
姓名:Tom,年龄:18,体重:66
姓名:Mary,年龄:18,体重:50

实例方法

       实例方法与实例变量一样都是某个实例个体特有的。定义实例方法时它的第一个参数应该是self,这个过程是将当前实例与该方法绑定起来,使该方法成为实例方法。

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.weight = weight

    def eat(self):
        self.weight += 0.05
        print("eat...")

    def run(self):
        self.weight -= 0.01
        print("run...")
a1 = Animal(2,0,10.0)
print('a1体重:{0:0.2f}'.format(a1.weight))
a1.eat()
print('a1体重:{0:0.2f}'.format(a1.weight))
a1.run()
print('a1体重:{0:0.2f}'.format(a1.weight))

代码运行结果

a1体重:10.00
eat...
a1体重:10.05
run...
a1体重:10.04

类方法

       类方法不需要与实例绑定,但需要与类绑定,定义时它的第一个参数是类的type实例。type是描述Python数据类型的类,Python中所有数据类型都是type的一个实例。类方法可以访问类变量和其他类方法,但不能访问其他实例方法和实例变量。

       定义类方法:方法第一个参数cls是type类型的一个实例;方法使用装饰器@classmethod声明该方法是类方法。该方法不能调用实例属性,也不能调用实例方法。

示例代码如下

class Account:
    interest_rate = 0.0668 # 类变量
# 重写构造方法
    def __init__(self,owner,amount):
        self.owner =  owner
        self.amount = amount

    # 类方法
    @classmethod
    def interest_by(cls,amt):
        return cls.interest_rate * amt

interest = Account.interest_by(12_000.0)
print('计算利息:{0:.4f}'.format(interest))

代码运行结果

计算利息:801.6000

静态方法

       如果定义的方法既不想与实例绑定,也不想与类绑定,只是想把类作为它的命名空间,那么可以定义静态方法。定义时使用@staticmethod装饰器,声明方法是静态方法,方法参数不指定self 和 cls。该方法不能调用实例属性,也不能调用实例方法。

示例代码如下

class Account:
    interest_rate = 0.0668 # 类变量
# 重写构造方法
    def __init__(self,owner,amount):
        self.owner =  owner
        self.amount = amount

    # 类方法
    @classmethod
    def interest_by(cls,amt):
        return cls.interest_rate * amt

    @staticmethod
    def interst_with(amt):
        return Account.interest_by(amt)
interest1 = Account.interest_by(12_000.0)
print('计算利息:{0:.4f}'.format(interest1))
interest2 = Account.interest_by(12_000.0)
print('计算利息:{0:.4f}'.format(interest2))

代码运行结果

计算利息:801.6000
计算利息:801.6000

动态绑定属性和方法 

示例代码如下

class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def show(self):
        print(f'我的名字是{self.name},我的年龄是{self.age}')

person1 = Person('张三',18)
person2 = Person('李四',19)

# 为person2动态绑定属性
person2.gender = 'male'
# 为person2动态绑定方法
def method():
    print('这是用于动态绑定的方法')
person2.fun = method
# 输出绑定的属性
print(person2.gender) # person1并没有gender属性
person2.fun() # person1并没有fun()方法

代码运行结果

male
这是用于动态绑定的方法

Process finished with exit code 0

封装性

私有变量

       默认情况下,Python中的变量是公有的,可以在类的外部访问他们。如果想让他们成为私有变量,可以在变量前加上双下划线“__”,双下划线开头表示private私有的成员,这类成员只允许定义该属性或方法的类本身进行访问。如果以单下划线开头的属性或方法表示protected受保护的成员,这类成员被视为仅供内部使用,允许类本身和子类进行访问,但实际上它可以被外部代码访问。而首尾双下划线一般表示特殊的方法。

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__wight = weight

    def eat(self):
        self.__wight += 0.05
        print("eat...")

    def run(self):
        self.__wight -= 0.01
        print("run...")

a1 = Animal(2,0,10.0) # 该段代码发生错误,因为weight是私有变量,无法在类的外部访问
print('a1体重:{0:0.2f}'.format(a1.weight))
a1.eat()
a1.run()

代码运行结果

       Python语言并不像Java,私有变量只是形式上私有,并非严格意义上的私有;如果想要访问私有变量,可以通过  对象名._类名__变量名 来访问,但是一般不推荐这么做,因为这违反了封装的原则,使代码的维护变得困难(可见Python的封装性靠的是程序员的自律,而非强制性的语法)。

输入下面代码

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量

    def eat(self):
        self.__weight += 0.05
        print("eat...")

    def run(self):
        self.__weight -= 0.01
        print("run...")

a1 = Animal(2,0,10.0)
print('a1体重:{0:0.2f}'.format(a1._Animal__weight))
a1.eat()
a1.run()
# 通过内置函数dir打印对象的属性和方法
print(dir(a1))

代码运行结果

a1体重:10.00
eat...
run...
['_Animal__weight', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'eat', 'run', 'sex']

推荐的做法是定义一个公共方法来访问

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量

    def eat(self):
        self.__weight += 0.05
        print("eat...")

    def run(self):
        self.__weight -= 0.01
        print("run...")

    def get_weight(self): # 添加一个公共方法来获取私有变量的值
        return self.__weight

a1 = Animal(2,0,10.0)
print('a1体重:{0:0.2f}'.format(a1.get_weight()))
a1.eat()
a1.run()
print('a1体重:{0:0.2f}'.format(a1.get_weight()))

代码运行结果

a1体重:10.00
eat...
run...
a1体重:10.04

私有方法

       私有方法与私有变量是类似的,只要在方法前加上双下划线“__”就是私有方法,在类外面强制使用也是“对象名._变量名__方法名”(不推荐)。

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量

    def eat(self):
        self.__weight += 0.05
        print("eat...")

    def __run(self):
        self.__weight -= 0.01
        print("run...")

    def get_weight(self): # 添加一个公共方法来获取私有变量的值
        return self.__weight

a1 = Animal(2,0,10.0)
print('a1体重:{0:0.2f}'.format(a1.get_weight()))
a1.eat()
a1._Animal__run() #强制访问,不推荐这样做
print('a1体重:{0:0.2f}'.format(a1.get_weight()))

代码运行结果

a1体重:10.00
eat...
run...
a1体重:10.04

定义属性

       在实际的面向对象设计中,一个类是不应该有公有的实例成员变量的,这些实例成员变量被设计为私有的,然后通过共有的 setter 和 getter 访问器访问。(访问器形式的封装需要一个私有变量,需要提供 setter 和 getter 访问器,只读变量不用提供 setter 访问器)

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量

    def eat(self):
        self.__weight += 0.05
        print("eat...")

    def __run(self):
        self.__weight -= 0.01
        print("run...")

    def get_weight(self): # 添加一个公共方法来获取私有变量的值
        return self.__weight

    def set_weight(self,weight): # 添加一个set方法来访问
        self.__weight = weight

a1 = Animal(2,0,10.0) # 该段代码发生错误,因为weight是私有变量,无法在类的外部访问
print('a1体重:{0:0.2f}'.format(a1.get_weight()))
a1.set_weight(20.00)
print('a1体重:{0}'.format(a1.get_weight()))

代码运行结果

a1体重:10.00
a1体重:20.0

       访问器形式的封装在编写代码时比较麻烦,Python提供了属性(poperty),定义属性可以使用@property(将一个方法转换成属性去使用,即定义形式是方法,使用时可以将该方法当成属性来用,也就是不需要加括号)和 @属性名.setter装饰器(通过@property设置之后就只能访问不能修改,如果想要修改可以再定义@属性名.setter方法)。

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量
    @property
    def weight(self): # 添加一个公共方法来获取私有变量的值
        return self.__weight

    @weight.setter
    def weight(self,weight): # 添加一个set方法来访问
        self.__weight = weight

a1 = Animal(2,0,10.0) # 该段代码发生错误,因为weight是私有变量,无法在类的外部访问
print('a1体重:{0:0.2f}'.format(a1.weight))
a1.weight = 20.0
print('a1体重:{0}'.format(a1.weight))

代码运行结果

a1体重:10.00
a1体重:20.0

示例代码二:加深对装饰器的理解

示例代码如下

class Person():
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self,value):
        if value<0 or value>150:
            print('年龄不在有效范围,已将年龄设置为默认18')
            self.__age = 18
        else:
            self.__age = value

person = Person('张三',18)
print(person.name,person.age)
person.age = 190
print(person.age)

 代码运行结果

张三 18
年龄不在有效范围,已将年龄设置为默认18
18

Process finished with exit code 0

 继承性

       多态性的前提是继承性,子类继承父类时只是继承父类中公有的成员变量和方法,不能继承私有的成员变量和方法。

示例代码如下

class Person:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.__weight = weight #定义私有变量

class Student(Person): # Student继承了Person类
    def __init__(self,name,age,school):
        super().__init__(name,age) 
# 定义子类的构造方法时先要调用父类的构造方法,初始化父类实例变量
        self.school = school

 重写方法

       如果子类方法名与父类方法名相同,而且参数列表也相同,只是方法体不同,那么子类重写了父类的构造方法;此时在用子类对象调用该方法时,会执行子类的该方法,而不是父类的。

示例代码如下

class Animal:
    def __init__(self,age,sex=1,weight=0.0):
        self.age = age
        self.sex = sex
        self.weight = weight #定义私有变量
    def eat(self):
        self.weight += 0.1
        print("动物吃...")


class Dog(Animal):
    def eat(self):
        self.weight += 0.1
        print("狗狗吃...")

a1 = Dog(2,0,10.0)
a1.eat()

代码运行结果

狗狗吃...

多继承

       多继承就是一个子类继承多个父类,在Java中只能单继承,因为多继承会发生方法冲突。Python支持多继承,当子类实例调用一个方法时,先从子类中查找,如果没有则查找父类,查找父类的顺序是按照子类声明的父类列表从左到右查找,若没有则查找父类的父类。

示例代码如下

class ParentClass1:
    def run(self):
        print('ParentClass1 run...')

class ParentClass2:
    def run(self):
        print('ParentClass2 run...')

class SubClass1(ParentClass1,ParentClass2):
    pass

class SubClass2(ParentClass2,ParentClass1):
    pass

class SubClass3(ParentClass1,ParentClass2):
    def run(self):
        print('SubClass3 run...')

sub1 = SubClass1()
sub1.run()
sub2 = SubClass2()
sub2.run()
sub3 = SubClass3()
sub3.run()

代码运行结果

ParentClass1 run...
ParentClass2 run...
SubClass3 run...

示例二:加深对多继承的理解

示例代码如下

# 在多继承时需要调用多个父类的方法进行初始化时,此处定义了A、B两个父类
class FatherA():
    def __init__(self,name):
        self.name = name
    def showA(self):
        print('我是FatherA中的方法')
class FatherB():
    def __init__(self,age):
        self.age = age
    def showB(self):
        print('我是FatherB中的方法')
class Son(FatherA,FatherB):
    def __init__(self,name,age,gender):
        # 此时不能再用super()来调用,因为无法区分哪个父类,因此需要直接指明调用哪个父类
        FatherA.__init__(self,name)
        FatherB.__init__(self,age)
        self.gender = gender

son = Son('CSDN@邂逅自己',18,'female')
son.showA()
son.showB()

代码运行结果

我是FatherA中的方法
我是FatherB中的方法

Process finished with exit code 0

多态性

 发生多态有两个前提条件:

  1. 继承—多态发生一定是子类和父类之间
  2. 重写—子类重写了父类的方法

示例代码如下

class Figure:
    def draw(self):
        print("Figure draw...")

class Ellipse(Figure):
    def draw(self):
        print("Ellipse draw...")

class Triangle(Figure):
    def draw(self):
        print("Triangle draw...")

f2 = Ellipse()
f2.draw()
f3 = Triangle()
f3.draw()

代码运行结果 

Ellipse draw...
Triangle draw...

案例二:加深对多态的理解

示例代码如下

# 多态可以在程序运行过程中动态决定调用哪个方法
# 该代码说明了在Python中要实现多态不需要对象之间有继承关系、也不关心对象的数据类型
# 需要有同名方法,即便在一开始不知道数据类型
class Person():
    def show(self):
        print('我是Person的show方法')
class Dog():
    def show(self):
        print('我是Dog的show方法')
class Cat():
    def show(self):
        print('我是Cat的show方法')
def fun(obj):
    obj.show()
person = Person()
dog = Dog()
cat = Cat()

fun(person)
fun(dog)
fun(cat)

代码运行结果

我是Person的show方法
我是Dog的show方法
我是Cat的show方法

Process finished with exit code 0

 类型检查

       与Java语言相比,多态性对于动态语言Python而言意义不大。但是无论多态性对Python的多大,Python作为面向对象的语言多态性是存在的。

函数描述
isinstance(object,classinfo)可以检查 object 实例是否由 classinfo 类或 infoclass 子类所创建的实例 
issubclass(class,classinfo)可以检查 class 是否是 classinfo 的子类

示例代码如下

class Figure:
    def draw(self):
        print("Figure draw...")

class Ellipse(Figure):
    def draw(self):
        print("Ellipse draw...")

class Triangle(Figure):
    def draw(self):
        print("Triangle draw...")
f1 = Figure()
f2 = Ellipse()
f3 = Triangle()
print(isinstance(f2,Figure)) # True
print(isinstance(f3,Figure)) # True
print(isinstance(f1,Figure)) # True
print(isinstance(f1,object)) # True,因为任何类都是 object 类的子类
print(issubclass(Figure,object)) # True
print(issubclass(Ellipse,Triangle))# False

代码运行结果

True
True
True
True
True
False

 鸭子类型

       不关注变量的类型,而是关注变量具有的方法。鸭子类型像多态一样工作,但是没有继承,只要像“鸭子”一样的行为(方法)就可以了。(用“鸭子类型”代替多态性设计能够充分发挥Python动态语言特点,但是对程序员要求也非常高)

示例代码如下

class Animal(object):
    def run(self):
        print("Animal run...")

class Dog(Animal):
    def run(self):
        print("Dog run...")

class Car:
    def run(self):
        print("Car run...")

def go(animal):
    if not isinstance(animal, (Animal, Car)):  # 检查 animal 是否为 Animal 或 Car 的实例
        return  # 如果不是,则作为递归的基案结束递归
    animal.run()  # 调用 run 方法

# 创建实例
animal_instance = Animal()
dog_instance = Dog()
car_instance = Car()

# 使用实例调用 go 函数
go(animal_instance)
go(dog_instance)
go(car_instance)
#添加了一个类型检查来确保只有 Animal 或 Car 的实例才会调用 run 方法。如果传入的不是这些类的实例,#go 函数将直接返回,避免递归调用。

代码运行结果

Animal run...
Dog run...
Car run...

Python根类—object

Python所有类都直接或间接的继承 object 类,因此所有类拥有object类的属性和方法;object类有很多方法。

方法描述
__str__()默认返回对象的类名,以及内存地址等信息;可以重写该方法,输出描述信息
__eq__()重写该方法指定相等的规则(即指定比较的是哪些实例变量相等)
__new__()由系统调用,用于创建对象
__init__()创建对象时手动调用,用于初始化对象属性值

 示例代码1如下

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

    def __str__(self): # 重写str方法,返回什么样的字符串可以自己指定
        template = 'Person[name={0},age={1}]'
        s = template.format(self.name,self.age)
        return s
Person = Person('Tony',18)
print(Person)

代码运行结果

Person[name=Tony,age=18]

示例代码2如下

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

    def __str__(self): # 重写str方法,返回什么样的字符串可以自己指定
        template = 'Person[name={0},age={1}]'
        s = template.format(self.name,self.age)
        return s

    def __eq__(self,other): # 重写eq方法,指定只有姓名和年龄都相等时才是True
        if self.name == other.name and self.age == other.age:
            return True
        else:
            return False

p1 = Person('Tony',18)
p2 = Person('Tony',18)
p3 = Person('Mary',18)
print(p1 == p2)
print(p1 == p3)

代码运行结果

True
False

示例代码3如下

class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return '我是重写str方法后输出的内容'
person = Person('CSDN@邂逅自己',18)
# 若不重写str方法
# 则输出对象时是输出内存地址<__main__.Person object at 0x000002516EDB5D90>
# 重写str方法后
# 则输出对应的内容,如果有的话
print(person)

代码运行结果

我是重写str方法后输出的内容

Process finished with exit code 0

特殊方法

实际上,在Python中使用运算符时也是通过调用特殊方法来实现的

运算符特舒方法描述
+_add_()执行加法运算
-_sub_()执行减法运算
<,<=,==_It_(),_le_(),_eq_()执行比较运算
>,>=,!=_gt_(),_ge_(),_ne_()执行比较运算
*, /_mul_(),_truediv_()执行乘法运算,非整数运算
%,//_mod_(),_floordiv_()执行取余运算,整除算法
**_pow_()执行幂运算

特殊属性

特殊属性说明
obj.__dict__对象的属性字典,使用语法:对象名.__dict__
obj.__class__对象所属的类,使用语法:对象名.__class__
class.__bases__类的父类元组,使用语法:类名.__bases__
class.__base__类的父类,使用语法:类名.__base__
class.__mro__类的层次结构,使用语法:类名.__mro__
class._subclasses类的子类列表

示例代码如下

class FatherA():
    pass
class FatherB():
    pass
class son(FatherA,FatherB):
    def __init__(self,name,age):
        self.name = name
        self.age = age

a = FatherA()
b = FatherB()
c = son('张三',18)
print('-'*20,'__dict__','-'*20) # 输出对象的属性字典
print(a.__dict__)
print(b.__dict__)
print(c.__dict__)
print('-'*20,'__class__','-'*20) # 输出对象所属的类
print(a.__class__)
print(b.__class__)
print(c.__class__)
print('-'*20,'__bases__','-'*20) # 输出父类元组
print(FatherA.__bases__)
print(FatherB.__bases__)
print(son.__bases__)
print('-'*20,'__base__','-'*20) # 输出所属的父类
print(FatherA.__base__)
print(FatherB.__base__)
print(son.__base__) # 如果继承了多个父类,结果只显示第一个父类,要想知道所有的父类需要用__bases__
print('-'*20,'__mro__','-'*20) # 输出类的层次结构
print(FatherA.__mro__)
print(FatherB.__mro__)
print(son.__mro__)
# 输出结果解析,以 (<class '__main__.son'>, <class '__main__.FatherA'>, <class '__main__.FatherB'>, <class 'object'>) 
#     为例,其中,为分隔符 ,前面表示son类,中间的内容表示son类继承了FatherA和FatherB,最后内容白叟son类又间接继承了object类
print('-'*20,'__subclasses__','-'*20) # 输出类的子类列表
print(FatherA.__subclasses__())
print(FatherB.__subclasses__())
print(son.__subclasses__())

代码运行结果

-------------------- __dict__ --------------------
{}
{}
{'name': '张三', 'age': 18}
-------------------- __class__ --------------------
<class '__main__.FatherA'>
<class '__main__.FatherB'>
<class '__main__.son'>
-------------------- __bases__ --------------------
(<class 'object'>,)
(<class 'object'>,)
(<class '__main__.FatherA'>, <class '__main__.FatherB'>)
-------------------- __base__ --------------------
<class 'object'>
<class 'object'>
<class '__main__.FatherA'>
-------------------- __mro__ --------------------
(<class '__main__.FatherA'>, <class 'object'>)
(<class '__main__.FatherB'>, <class 'object'>)
(<class '__main__.son'>, <class '__main__.FatherA'>, <class '__main__.FatherB'>, <class 'object'>)
-------------------- __subclasses__ --------------------
[<class '__main__.son'>]
[<class '__main__.son'>]
[]

Process finished with exit code 0

类的浅拷贝与深拷贝

  • 浅拷贝:拷贝时对象包含的子对象内容不拷贝,因此,源对象与拷贝对象会引用同一个子对象。
  • 深拷贝:使用 copy 模块的 deepcopy 函数,递归拷贝对象中包含的子对象,源对象和拷贝对象所有的子对象也不相同。

示例代码如下

class CPU():
    pass
class Disk():
    pass
class computer():
    def __init__(self,cpu,disk):
        self.cpu = cpu
        self.disk = disk
cpu = CPU()
disk = Disk()
computer = computer(cpu,disk)
# 变量赋值
computer1 = computer
print(computer,'子对象的内存地址',computer.cpu,computer.disk)
print(computer1,'子对象的内存地址',computer1.cpu,computer1.disk)
# 类对象的拷贝
print('-'*20,'类对象的浅拷贝','-'*20)
import copy
computer2 = copy.copy(computer) # computer2是新产生的子对象,但是cpu和disk不变
print(computer2,'computer2子对象的内存地址',computer2.cpu,computer2.disk)
# 类对象的深拷贝
print('-'*20,'类对象的深拷贝','-'*20)
computer3 = copy.deepcopy(computer) # computer2、cpu和disk都是新产生的子对象
print(computer3,'computer3子对象的内存地址',computer3.cpu,computer3.disk)

代码运行结果

<__main__.computer object at 0x0000025DDC896840> 子对象的内存地址 <__main__.CPU object at 0x0000025DDC8968A0> <__main__.Disk object at 0x0000025DDC896810>
<__main__.computer object at 0x0000025DDC896840> 子对象的内存地址 <__main__.CPU object at 0x0000025DDC8968A0> <__main__.Disk object at 0x0000025DDC896810>
-------------------- 类对象的浅拷贝 --------------------
<__main__.computer object at 0x0000025DDC896990> computer2子对象的内存地址 <__main__.CPU object at 0x0000025DDC8968A0> <__main__.Disk object at 0x0000025DDC896810>
-------------------- 类对象的深拷贝 --------------------
<__main__.computer object at 0x0000025DDC8CEAE0> computer3子对象的内存地址 <__main__.CPU object at 0x0000025DDC8CEBA0> <__main__.Disk object at 0x0000025DDC8CEC00>

Process finished with exit code 0

参考书籍:《python从小白到大牛》(第2版)关东升 编著 


文章创作不易,本文18000+字,为了大家能理解,写的很详细,这也让我花了很多时间。最后,如果觉得本文对大家有帮助的话,还请给我点个赞和关注,谢谢大家!!!

Python14 面向对象编程 Python的面向对象编程(Object-Oriented Programming,简称OOP)是一种编程范式,它使用“对象”来设计应用程序和计算机程序。这些对象由数据和能够操作这些数据的方法组成。面向对象编程的主要目标是提高软件的可重用性、可维护性和灵活性。类(Class)类是创建对象的模板或蓝图。它定义了一组属性(称为字段或变量),以及操作这些数据的方法。一个类可以包括基本的数据属性(静态的信息片段),以及能够对数据执行特定功能的方法。对象(Object)对象是类的实例。 阅读详情

相关推荐

【Python】Python面向对象详解

面向对象的官方解释“把一组数据结构和处理它们的方法组成对象(object),把相同行为的对象归纳为类(class),通过类的封装(encapsulation)隐藏内部细节,通过继承(inheritance)实现类的特化(specialization)和泛化(generalization),通过多态(polymorphism)实现基于对象类型的动态分派。知乎上比较有趣的解释一句话说明什么是面向对象?你个士鳖,你们全家都是士鳖!好像有人说过这样的话,当头棒喝的方式虽然情感上不易接受,但记忆效果十分显著。

qq_60491112的博客 1648

【Python】系列之面向对象编程

对象(class)是一种抽象的概念,上面定义的对象Person,指的就是学生这个概念,而实例(instance)则指一个个具体的对象,例如上面的张三丰和l张无忌就是两个具体的Person,也就是实例从上面的案例可以看出,面向对象的程序设计思想其实就是抽象出对象(class),然后根据对象创建实例(instance)最后,面向对象的抽象程度比函数高,因为一个对象既包含数据,也包含操作数据的方法,封装、继承、多态是面向对象的三大特点。

康师傅没有眼泪 6517

一文秒懂Python面向对象

在类定义中,

qq_69153564的博客 4454

Python面向对象编程

面向对象基本概念,自定义类,类的调用,类属性和实例属性,私有属性,类的继承

shield911的博客 4310

什么是面向对象编程?

初识面向对象、以及学会如何创建类和对象,没有对象的看完便有”对象“了

小贺想改变 3380

推荐国内可使用的chatGPT的工具

是基于ChatGPT 3.5和ChatGPT 4开发的chatGPT应用程序版,这个应用可以直接使用而不需要魔法,如果我们有自己的APT KEY的话可以一直使用,但是如果没有的话,我们只能使用ChatGPT 3.5 版本的,次数也是有所限制,应该是20次每天,这也足够我们的使用了,响应的速度也是非常的快。

有你真好的博客 1万+

Python面向对象编程(OOP)详解:通俗易懂的全面指南

文章详细讲解了类与对象的区别、类结构组成,并通过代码示例展示了封装的实现方式(如私有属性)、继承的多种类型(单继承、多继承等)以及多态的应用场景(不同子类对同一方法的不同实现)。

x15514104477的博客 2059

【脑电绘图教程 2】使用Brainstorm进行脑电处理及源定位

Brainstorm 是一个开源应用程序,支持MEG、EEG、fNIRS、ECoG、深度电极和其他电生理学的数据分析,尤其用于MEG、EEG的源定位。Brainstorm的主要优点是其简单直观的图形界面,不需要进行任何编程,即可上手MEG、EEG分析,此外,它还支持多种数据类型(基本上EEGLab支持的,它都支持),并且具有数据批量处理功能,可以很方便的分析自己的数据。

qq_40735196的博客 1万+

python 面向对象编程

带你走进 python 面向对象编程的世界

不能再留遗憾了的博客 4615

scp 出现Permission denied错误 解决方法

第一种说辞(来源于网络),说是scp涉及root远程登录,默认是没有打开的,只需要把配置文件中的permit打开即可。最后scp的时候发现还不行,只需要将其scp的服务器用户名 修改为root即可。第二种解决方案,将scp 传输的服务器用户名改为root即可。(这是最基本的,一开始我忽视了这个问题,导致一直scp不了)window系统下,向ubuntu操作系统 scp传输文件。

码农研究僧的博客 6733

手撕数美风控三板斧:device_fingerprint/device_id/hmac生成逻辑全解析

摘要:逆向分析数美风控核心参数生成机制 本文详细记录了逆向分析数美(Shumei)风控系统中三个关键参数(device_id、device_fingerprint、hmac)的生成逻辑。通过抓包分析和动态调试(使用Frida、IDA等工具)发现:device_id由设备IMEI和Android ID经MD5哈希生成;device_fingerprint融合23项设备与环境信息,并采用SHA-256哈希和动态环境检测;hmac则是参数+指纹+动态盐值的SHA-256签名。文章揭示了数美"设备指纹+动

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 1496

【Python基础】Python面向对象编程

​ Python面向对象编程(简称OOP)是Python语言中最重要的特性之一。它是一种通过“对象”来设计软件的方法。它通过将数据和操作数据的方法封装在对象中,使得程序更加模块化、可重用和易于维护。它遵循一切皆对象的理念,可以将现实世界的事物使用类与实例进行模拟。​ 对于初学者来说,理解面向对象编程的基本原理和Python中的实现方式是非常有帮助的。本文旨在为初学者提供一个易于理解的Python面向对象编程介绍,并探讨其在实际编程中的应用和优势。什么是Python?

分享是一种境界,勤于分享,乐于分享! 2182

智能车图像处理0-图像处理整体框架思路

1.总体框架如上所示,具体代码请查看后续文章。2.因为参与竞赛时间是大二,所以在编程中有许多不规范的地方(如变量的命名),大家见谅。3.原创文章,请勿侵权=-=

taiyuezyh的博客 1万+

Python 面向对象编程

在Python中,类(Class)是面向对象编程(Object-Oriented Programming, OOP)的基础概念。类是创建对象(Object)的蓝图,它定义了对象的属性和方法。每个对象都是类的一个实例,具有类定义的属性和行为。类是一种用户自定义的数据结构,它包含了一组属性(成员变量)和行为(成员方法)。在Python中,可以使用class关键字来定义一个类,并使用def关键字来定义类的成员方法。使用class关键字定义一个类,类名作为该类的标识符。

2201_75479454的博客 2629

<IBM AIX> 《HACMP 实用手册和命令 HA切换手册》 - 鸿篇巨制,全网最全

操作命令检查磁盘预留策略要将磁盘预留策略更改为 no_reserve集群状态实用程序查看集群状态是否正常SMIT System Management (C-SPOC)Cluster ServicesShow Cluster Services 面板上的选项或 lssrc 命令查看资源组、资源组对应的VG、资源组对应的APPLICATION SERVER# ./cldispsmit常用命令F3退出F4列表Esc+6或者F6查看命令Esc+7或者F7选择多项检查状态。

Else 的博客 3366

预编码算法(个人总结)

预编码算法是无线通信系统中的关键技术,通过在发送端对信号进行处理,可以有效减少干扰,提高系统性能。预编码算法在5G、Wi-Fi、卫星通信等领域具有广泛的应用前景,同时,随着深度学习、大规模MIMO和物理层安全等技术的发展,预编码算法的研究将进一步推动无线通信技术的发展。CSI的准确性直接影响到预编码的效果。预编码是一种在发送端对信号进行线性变换的技术,以优化信号的空间分布,使得接收端能够更好地接收和解码信号。预编码算法,特别是基于矩阵分解的预编码算法,计算复杂度较高,限制了其在实际系统中的应用。

年糕的博客 5290

面向对象编程python

类是一种抽象的数据类型。它具有特定的属性和方法,面向对象编程就是利用类来进行的。# 定义了一个称之为Myclass的类(类的首字母一般大写)# 类的初始化(也是一种方法),将参数传递# 类的方法(该方法为展现输入的值)在这个例子中,MyClass是一个类,它有两个属性:value和display。value是一个实例属性,它被定义在__init__方法中,display是一个实例方法,它被定义在类内部。self是一个参数,表示对象自身【对象的id号】,里面存放着对象自身的地址。

qq_62780060的博客 750

【银河麒麟桌面系统】安装英伟达(NVIDIA)显卡驱动

本文详细介绍了在麒麟桌面操作系统V10 SP1(版本号2503)上安装NVIDIA RTX 5060显卡驱动的完整流程。主要内容包括:查看系统版本信息,从NVIDIA官网下载Linux 64位驱动,授予执行权限后运行安装程序,处理安装过程中的X server警告、32位库安装、DKMS模块选择等问题,以及安装完成后如何验证驱动状态。同时提供了卸载驱动的步骤和常见问题解决方案,如处理X server警告、libglvnd EGL依赖问题等。该指南适用于需要在国产麒麟系统上安装NVIDIA显卡驱动的用户,包含完

信创运维工程师 · 银河麒麟 & 容器实战 | 金融生产环境迁移·等保加固 | 142篇原创·17万+阅读 6326

Python 语法及入门(超全超详细)

定义函数"""这是一个问候函数"""# 定义函数 def greet(name) : """这是一个问候函数""" return f"Hello, {name }!" # 调用函数 message = greet("Alice") print(message) # Hello, Alice!

2301_78096295的博客 5402

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

python学习-面向对象编程

在 Python 中,可以使用class关键字来定义类。以下是一个简单的类定义示例:​在上面的示例中,我们定义了一个名为Person的类,它有两个属性name和age,以及一个方法say_hello。面向对象编程是一种强大的编程范式,它可以提高代码的可维护性、可扩展性和可复用性。Python 提供了丰富的面向对象编程特性,使得开发者可以更加方便地进行面向对象编程。在实际开发中,可以根据具体需求选择合适的面向对象编程特性,以提高代码的质量和效率。

wu73guang5jian的博客 1693

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

【python】python进阶——面向对象编程

Python 从设计之初就是一门面向对象的语言,它的核心机制建立在“一切皆对象”的基础上,但它也优雅地支持函数式、过程式等多种编程范式,是一门真正的多范式语言。

weixin_51924657的博客 1945

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

Python Birds:用Python学习面向对象编程的趣味游戏

Python Birds:用Python学习面向对象编程的趣味游戏 项目介绍 Python Birds 是一个专为Python初学者设计的开源项目,旨在通过一个简单的游戏来教授面向对象编程(OOP)的基本概念。该项目以经典的“愤怒的小鸟”为灵感,通过模拟游戏中的角色和物理行为,帮助学习者理解和掌握Python中的类、对象、继承、多态等核心概念。 项目提供了两种版本:一个简化版和一个更复杂的功能丰富...

gitblog_00010的博客 402

Python语言的面向对象编程

在Python中,可以使用class关键字定义一个类。如下所示:```pythonclass Dog:definitself.name = name # 属性self.age = age # 属性def bark(self): # 方法")```pythonprint(my_dog.name) # 输出:Buddymy_dog.bark() # 输出:Buddy says woof!首先,我们定义一个Book类,用于表示书籍的信息。

dasinigeguisun01的博客 1544
上一篇: 面向对象和面向过程
下一篇: Python异常处理
邂逅自己
博客等级 码龄4年 948粉丝 58原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

邂逅自己

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址