Python-面向对象编程（超详细易懂）

于 2024-06-21 10:37:30 发布
阅读量1.5k 收藏 25
点赞数 44
文章标签： python 数据结构 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76708905/article/details/139812237
版权

面向对象编程（oop）

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

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

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

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

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

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

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

类和对象

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

定义类

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

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

 输入下面代码

class Animal:
    pass
print(id(Animal))
print(type(Animal))

代码运行结果

2519404222224
<class 'type'>

       注意：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

封装性

私有变量

       默认情况下，Python中的变量是公有的，可以在类的外部访问他们。如果想让他们成为私有变量，可以在变量前加上双下划线“__”

示例代码如下

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()

代码运行结果

a1体重：10.00
eat...
run...

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

示例代码如下

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装饰器。

示例代码如下

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,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...

多态性

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

  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...

 类型检查

       与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类有很多方法。

方法描述
__str__()默认返回对象的类名，以及内存地址等信息；可以重写该方法，输出描述信息
__eq__()重写该方法指定相等的规则（即指定比较的是哪些实例变量相等）

 示例代码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

参考书籍《Python从小白到大牛》（第2版）关东升 

邂逅自己
关注
  • 44
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Python-到底啥是面向对象＆面向过程？
小孟的博客
05-08 4315
Hi！我是@xiaomeng 今天我们开始学习python的面(yu)向(fa)对(yao)象(dian) 废话不多说，开始！ 首先:我们先要搞明白什么是面向对象: 面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。 面向对象是相对于面向.
【Python】系列之面向对象编程
康师傅没有眼泪
06-11 4527
对象(class)是一种抽象的概念，上面定义的对象Person，指的就是学生这个概念，而实例(instance)则指一个个具体的对象，例如上面的张三丰和l张无忌就是两个具体的Person，也就是实例从上面的案例可以看出，面向对象的程序设计思想其实就是抽象出对象(class)，然后根据对象创建实例(instance)最后，面向对象的抽象程度比函数高，因为一个对象既包含数据，也包含操作数据的方法，封装、继承、多态是面向对象的三大特点。
Python面向对象编程
shield911的博客
09-25 3988
面向对象基本概念，自定义类，类的调用，类属性和实例属性，私有属性，类的继承
python快速入门【五】---- 面向对象编程、python类
丨汀、的博客
03-12 1916
目录 Python面向对象编程 什么是面向对象编程（OOP）？ Python中的类 Python对象（实例） 如何在Python中定义类 实例属性 类属性 实例化对象 这是怎么回事？ 练习 实例方法 修改属性 Python对象继承 狗公园示例 扩展父类的功能 父类与子类 覆盖父类的功能 练习: 狗狗继承 练习: 狗狗饿不饿 Python面向对象编程 在本文中，您将学习Python中的OOP的以下基本概念： Python类 对象实例 定义和使用方法 OOP继承
Python面向对象详解（非常详细）
ZTLJQ的博客
04-21 2万+
面向对象编程（Object-Oriented Programming，OOP）是一种常用的编程思想，它强调万物皆对象，因此在编程时我们可以将现实世界中的事物抽象成程序中的对象，从而更好实现软件的设计与开发。与传统的基于函数的编程不同，面向对象编程注重于将数据与行为封装在一起，即对象既包含数据状态，还包含可调用的行为方法。面向对象编程的特点在于，它具有封装、继承和多态三大特性。封装意味着将对象的状态和行为进行封装，使其对外只暴露必要的接口，从而提高了安全性和可维护性；
python之面向对象编程
qq_43428929的博客
08-23 1429
面向对象程序设计面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是种具有对象概念的编程典范，同时也是一种程序开发的抽象方针。它可能包含数据、特性、代码与方法。对象则指的是类（class）的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性，对象里的程序可以访问及经常修改对象相关连的数据。在面向对象程序编程里，计算机程序会被设计成彼此相关的对象。从维基百科的定义可以看出，面向对象编程的对象。
Python零基础入门-面向对象编程
04-01
本视频为撩课学院Python课程的核心阶段——面向对象编程。毫不夸张的说，这是我所看过的对于面向对象讲解最通俗易懂的教程了，在此安利给大家。 Python教程配套的全套资料更新如下：链接:...
Python面向对象编程速成(速记速学小例子和源码迅速学会Python面向对象编程)
01-08
自己整理的Python面向对象编程速记速学小例子和源码，只有6页，可以迅速学会Python面向对象编程。原书已加入书签方便阅读。介绍了类的声明，实例化，绑定属性，构造函数，数据封装，继承，多态，实例属性和类属性。...
谈一谈基于python的面向对象编程基础
12-31
活在当下的程序员应该都听过“面向对象编程”一词，也经常有人问能不能用一句话解释下什么是“面向对象编程”，我们先来看看比较正式的说法。 把一组数据结构和处理它们的方法组成对象（object），把相同行为的对象...
python-游戏篇-初级-超级画板
02-03
7. **程序结构**：了解如何组织代码，使其清晰易懂，遵循面向对象编程的原则，创建类来封装功能。 8. **异常处理**：学习如何处理可能出现的错误，比如用户尝试打开不存在的文件。 通过这个项目，初学者不仅能够...
Python-一个易懂的类C结构解析Python库
08-12
Python是一种强大的、面向对象的编程语言，其语法简洁明了，易于学习，使得它成为许多初学者和专业开发者的首选。在处理底层数据结构或与C语言交互时，Python提供了多种库来帮助开发者理解并操作类C结构。本文将重点...
Python基础—面向对象(超详版)
weixin_50804299的博客
03-14 1万+
面向对象是一种编程范式，它将程序中的数据和操作封装在一个对象中，从而使得程序更加模块化、可重用和易于维护。在面向对象编程中，对象是类的实例化，类是一种抽象的数据类型，它定义了一组属性和方法。面向对象编程的核心思想是封装继承和多态。封装是将数据和操作封装在一个对象中，隐藏对象的内部实现细节，只暴露必要的接口给外部访问。继承是通过继承父类的属性和方法，来创建一个新的子类，子类可以重写父类的属性和方法，从而实现更加灵活的功能。多态是指同一个方法可以根据不同对象的实现方式，实现不同的行为。
Python 面向对象编程详解(8)
weixin_30790841的博客
08-04 620
Python 的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解释程序,作为ABC语言的一种继承.Python是纯粹的自由软件,源代码和解释器CPython遵循 GPL(GNU General Public License)协议.关于python的哲学：python崇尚:"优雅"、"明确"、...
整理了70个Python面向对象编程案例，建议收藏！
Python数据之道
04-14 7345
Python 作为一门面向对象编程语言，常用的面向对象知识怎么能不清楚呢，今天就来分享一波文章很长，高低要忍一下，如果忍不了，那就收藏吧，总会用到的在 Python 中创建一个类及其对象在 Python 中创建一个空类在 Python 中使用 Type 创建类在 Python 中创建和调用类的方法使用 __init__() 方法为数据属性赋值在 Python 中更新对象属性在 Python 中删除...
面向对象编程（Python版详解）
热门推荐
辰兮要努力
04-03 2万+
本篇是面向对象编程Python版详解！案例教学超详细，欢迎打卡、阅读学习！
Python系列之面向对象编程（一文详解）
最新发布
Luan__Yu的博客
03-09 1774
Python系列之面向对象编程，一文详解，极其详细！
python的OOP机制
zy010101博客
12-28 1495
python的OOP机制 在Python中，实际上一切都是对象，我们使用的内置数据类型，本质上也是类的实例化。例如： >>> type("123") <class 'str'> 而类本身也是对象，只不过是元类的对象而已。 例如： >>> type(int) <class 'type'> >>> type(list) <class 'type'> 从本质上讲，python的OOP机制主要依赖两个基础：1.函数的第一个
Python系列之面向对象编程
qq_35240555的博客
02-18 3998
Python 面向对象编程 常见的编程方式有三种： 面向过程：根据业务逻辑从上到下写垒代码，最常见的操作就是粘贴复制，将之前实现的代码块复制到现需功能处。 函数式：将某功能代码封装到函数中，日后无需重复编写，仅调用函数即可。 面向对象：对函数进行分类和封装，让开发变得更快更好更强。 相比于Java和C#这种只支持面向对象编程的语言，python更加灵活，既支持面向过程编程，也支持函数式编程和面向对象编程。 一般在Python开发中，通常将面向对象和函数式混合使用，今天重点介绍一下Python的面向对象编程。
Python 面向对象编程在数值计算方面的应用
05-30
在数值计算领域，Python 面向对象编程也有着广泛的应用。下面列举了一些常见的应用场景： 1. 矩阵运算：可以使用类来实现矩阵的基本运算，例如加减乘除、转置、求逆等。可以使用魔法方法来重载运算符，使得代码更加简洁易懂。 2. 数值积分：可以使用类来实现数值积分算法，例如梯形法、辛普森法等。可以使用继承来实现不同的积分算法，使用多态来调用不同的算法。 3. 插值和拟合：可以使用类来实现插值和拟合算法，例如拉格朗日插值、最小二乘法等。可以使用多态来实现不同的插值和拟合算法，使得代码更加灵活。 4. 随机数生成：可以使用类来实现随机数生成算法，例如线性同余法、梅森旋转算法等。可以使用封装来隐藏算法的具体实现，使得代码更加安全可靠。 5. 数值优化：可以使用类来实现数值优化算法，例如梯度下降法、牛顿法等。可以使用魔法方法来重载运算符，使得代码更加简洁易懂。 总之，Python 面向对象编程在数值计算方面的应用非常广泛，可以提高代码的可读性、可维护性和可扩展性，也可以提高代码的运行效率和精度。如果你对数值计算感兴趣，可以尝试使用 Python 面向对象编程来实现一些算法，提高自己的编程水平。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

邂逅自己

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

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

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

打赏作者

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

抵扣说明：

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

余额充值