python--面向对象编程

最新推荐文章于 2024-08-11 08:00:49 发布
最新推荐文章于 2024-08-11 08:00:49 发布
阅读量122 收藏 1
点赞数
分类专栏： python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44441263/article/details/119043348
版权

面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

通过class定义

class Student(object):
    pass

object就是继承的类。
实例的创建

ll= Student()

可以自由地给一个实例变量绑定属性

bart.name = ‘Bart Simpson’

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去

class Student(object):

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

有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去

bart = Student(‘Bart Simpson’, 59)
和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

数据封装

每个实例就拥有各自的name和score这些数据。我们可以通过函数来访问这些数据，比如打印一个学生的成绩：

>>> def print_score(std):
...     print('%s: %s' % (std.name, std.score))
...
>>> print_score(bart)
Bart Simpson: 59

但是，既然Student实例本身就拥有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法：

class Student(object):

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

    def print_score(self):
        print('%s: %s' % (self.name, self.score))

我们在调用的时候可以

bart.print_score()
调用很容易，但却不用知道内部实现的细节。

封装的另一个好处是可以给Student类增加新的方法

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

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

调用：

lisa = Student('Lisa', 99)
bart = Student('Bart', 59)
print(lisa.name, lisa.get_grade())
print(bart.name, bart.get_grade())

访问限制

在Class内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，这样，就隐藏了内部的复杂逻辑。但是外部代码还是可以自由修改一个实例的属性。
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

这样就不能让外部代码随便修改。如果要改可以增加方法：

class Student(object):
    ...

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

    def set_score(self, score):
        self.__score = score

之所以通过定义函数的方式来修改，一是可以增强代码的健壮性，二是可以对参数做检查，避免传入无效的参数：

class Student(object):
    ...

    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError('bad score')

在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。
如_name这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量。

继承和多态

当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。继承最大的好处是子类获得了父类的全部功能。即使在子类当中没有定义。

class Animal(object):
    def run(self):
        print('Animal is running...')
class Dog(Animal):
    def run(self):
        print('Dog is running...')
    def eat(self):
        print('Eating meat...')
        
class Cat(Animal):
    def run(self):
        print('Cat is running...')

调用

dog = Dog()
dog.run()
#要先从类创建实例
cat = Cat()
cat.run()

当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()。这样，我们就获得了继承的另一个好处：多态。当我们定义一个class的时候，我们实际上就定义了一种数据类型，跟str、list没有区别。判断一个变量是否是某个类型可以用isinstance()判断。在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做是父类。但是，反过来不行。

def run_twice(animal):
    animal.run()
    animal.run()

在执行

run_twice(Dog())
调用的是它自己的run

再定义

class Tortoise(Animal):
    def run(self):
        print('Tortoise is running slowly...')

run_twice(Tortoise())
显示
Tortoise is running slowly…
Tortoise is running slowly…

多态的好处就是，当我们需要传入Dog、Cat、Tortoise……时，我们只需要接收Animal类型就可以了，因为Dog、Cat、Tortoise……都是Animal类型，然后，按照Animal类型进行操作即可。由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法。
对扩展开放：允许新增Animal子类；

对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

获取对象信息

type()函数返回对应的Class类型。如果我们要在if语句中判断，就需要比较两个变量的type类型是否相同。
对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数
如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list。

dir(‘ABC’)
[‘add’, ‘class’,…, ‘subclasshook’, ‘capitalize’, ‘casefold’,…, ‘zfill’]

类似__xxx__的属性和方法在Python中都是有特殊用途的，比如__len__方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的__len__()方法，所以，下面的代码是等价的：

>>> len('ABC')
3
>>> 'ABC'.__len__()
3

我们自己写的类，如果也想用len(myObj)的话，就自己写一个__len__()方法：

>>> class MyDog(object):
...     def __len__(self):
...         return 100
...
>>> dog = MyDog()
>>> len(dog)
100

仅仅把属性和方法列出来是不够的，还需要配合getattr()、setattr()以及hasattr()。

给实例绑定属性的方法是通过实例变量

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

s = Student('Bob')
s.score = 90

，如果Student类本身需要绑定一个属性，可以直接在class中定义属性，这种属性是类属性，归类所有。但类的所有实例都可以访问到。

class Student(object):
    name = 'Student'


>>> class Student(object):
...     name = 'Student'
...
>>> s = Student() # 创建实例s
>>> print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
Student
>>> print(Student.name) # 打印类的name属性
Student
>>> s.name = 'Michael' # 给实例绑定name属性
>>> print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
Michael
>>> print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问
Student
>>> del s.name # 如果删除实例的name属性
>>> print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
Student

高级特性

使用__slots__

我们可以通过直接给实例绑定属性,即直接给一个不存在的属性赋值。如：

s=Student()
s.name = ‘Michael’

也可以通过给实例绑定一个方法：

>>> def set_age(self, age): # 定义一个函数作为实例方法
...     self.age = age
...
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
>>> s.set_age(25) # 调用实例方法
>>> s.age # 测试结果
25

但是，给一个实例绑定的方法，对另一个实例不起作用。
要对所有的实例都绑定方法，应该直接给class绑定方法。就是先定义一个方法，然后直接赋值给类的方法。这就是一种动态方法。

def set_score(self, score):
… self.score = score
…

Student.set_score = set_score

使用__slots__：用于限制实例的属性

class Student(object):
    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

这样只能绑定slots中的属性。

使用@property

@property的实现比较复杂，我们先考察如何使用。把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：

class Student(object):
    @property
    def score(self):
        return self._score
    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

>>> s = Student()
>>> s.score = 60 # OK，实际转化为s.set_score(60)
>>> s.score # OK，实际转化为s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

要知道的是只定义getter方法，不定义setter方法就是一个只读属性。

多重继承

就是继承多个父类的属性，可以同时获得多个父类的所有功能。
Mixln：需要“混入”额外的功能。比如，让Ostrich除了继承自Bird外，再同时继承Runnable。这种设计通常称之为MixIn。

class MyTCPServer(TCPServer, ForkingMixIn):
    pass

定制类

为了能让class作用于不同函数。
__str__:

>>> class Student(object):
...     def __init__(self, name):
...         self.name = name
...     def __str__(self):
...         return 'Student object (name: %s)' % self.name

这样打印出来的实例，不但好看，而且容易看出实例内部重要的数据。但是直接敲变量不用print，打印出来的实例还是不好看。采用__repr__

# 通常__str__和__repr__代码一样
class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name=%s)' % self.name
    __repr__ = __str__

__iter__:如果一个类想被用于for … in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):#返回的是可以迭代的对象
        return self # 实例本身就是迭代对象，故返回自己

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 100000: # 退出循环的条件
            raise StopIteration()
        return self.a # 返回下一个值

调用：

>>> for n in Fib():
...     print(n)
...
1
1
2
3
5
...
46368
75025

Fib实例虽然能作用于for循环，看起来和list有点像，但是，把它当成list来使用还是不行。要用

getitem

class Fib(object):
    def __getitem__(self, n):
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a

这样self不用传值，在调用时只需要传入n。

>>> f = Fib()
>>> f[0]
1
>>> f[1]
1
>>> f[2]
2
>>> f[3]
3
>>> f[10]
89
>>> f[100]
573147844013817084101

但是这种方法不能用于切片，原因是__getitem__()传入的参数可能是一个int，也可能是一个切片对象slice，要做判断。

class Fib(object):
    def __getitem__(self, n):
        if isinstance(n, int): # n是索引
            a, b = 1, 1
            for x in range(n):
                a, b = b, a + b
            return a
        if isinstance(n, slice): # n是切片
            start = n.start
            stop = n.stop
            if start is None:
                start = 0
            a, b = 1, 1
            L = []
            for x in range(stop):
                if x >= start:
                    L.append(a)
                a, b = b, a + b
            return L

除此以外如果想要实现其他的功能还有不少工作要做。

getattr
正常情况下，当我们调用类的方法或属性时，如果不存在，就会报错。(但是可以赋值后调用)，要避免这个错误，除了可以加上一个score属性外，Python还有另一个机制，那就是写一个__getattr__()方法，动态返回一个属性。

class Student(object):

    def __init__(self):
        self.name = 'Michael'

    def __getattr__(self, attr):
        if attr=='score':
            return 99

>>> s.score
99

返回函数

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25

>>> s.age()
25

__getattr__默认返回就是None。要让class只响应特定的几个属性，我们就要按照约定，抛出AttributeError的错误：

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

就是实例直接–def

class Chain(object):

    def __init__(self, path=''):
        self._path = path

    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))

    def __str__(self):
        return self._path

    __repr__ = __str__

>>> Chain().status.user.timeline.list
'/status/user/timeline/list'

这就是chain()的实例，直接到return Chain…。

call

用它可以直接调用对象就像调用函数一样。

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

    def __call__(self):
        print('My name is %s.' % self.name)

>>> s = Student('Michael')
>>> s() # self参数不要传入
My name is Michael.

使用枚举类

两个方法：
1.

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

这就获得了Month类型的枚举类，可以直接使用Month.Jan来引用一个常量，或者枚举它的所有成员

for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)#value属性则是自动赋给成员的int常量，默认从1开始计数

from enum import Enum, unique

@unique # 可以帮助我们检查保证没有重复值
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

元类

查看元类

George_ray
关注
专栏目录
python之面向对象编程
m0_59485658的博客
02-26 622
时帮你给self参数赋值了，并且传参的时候其实r1也被传入的r1 = Role('Alex','police','AK47’)其实是r1 = Role(r1,'Alex','police','AK47’),所以在类中的self就相当于传入的r1。上面的这个r1 = Role('Alex','police','AK47’)动作，叫做类的“实例化”， 就是把一个虚拟的抽象的类，通过这个动作，变成了一个具体的对象了， 这个对象就叫做实例。而是只需要说一句开始工作，这样各个部门就开始工作这就是一种多态的体现。
Python的面向对象编程
weixin_39056447的博客
03-25 423
1.前言：什么是面向对象编程和面向过程编程？ 1.1面向过程编程 【就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用】 以下是来自度娘的部分介绍： 面向过程其实是最为实际的一种思考方式，就算是面向对象的方法也是含有面向过程的思想。可以说面向过程是一种基础的方法。它考虑的是实际地实现。一般的面向过程是从上往下步步求精，所以面向过程最重要的是模块化的...
python面向对象、封装、继承
vhkgcf的博客
09-06 154
面向对象 oop:object oriented programming 面向对象的基本概念 我们之前学习的编程方式就是面向过程的 面向过程和面向对象，是两种不同的编程方式 对比面向过程的特点，可以更好的了解什么是面向对象 过程和函数(都是对一段功能的代码进行封装) 过程：是早期的一个编程概念     过程类似于函数，只能执行，但是没有返回值 函数：不仅能执行，还可以返回结果(return) =...
收藏！一篇Python系列 | 面向对象编程
最新发布
相信相信的力量
08-11 420
作者:郭震面向对象编程（OOP）是Python中一种强大的编程范式,它可以使代码结构更加模块化和可重用.在本文中,我们将探讨 OOP 的核心概念,使用实际示例进行说明,并对 OOP 的各个方面进行分类,以帮助你全面理解这一重要主题.目录面向对象编程简介OOP 的核心概念类和对象封装继承多态实际示例定义类和创建对象使用方法和属性实现继承利用多态高级 OOP 概念抽象类和接口多重继承运算符重载总结1....
Python中的面向对象编程
Trb401012的博客
01-19 572
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。最后祝大家天天进步！python复制代码。
java多态的笔试题-Python-OOP:面向对象编程
06-13
和面向对象编程 通过我们与行业合作伙伴的研究和合作，Make School 决定专注于四种核心语言。 Python - 用于计算机科学、数据科学和白板编码。 JavaScript - 用于后端和前端 Web 开发 Swift - 用于移动 iOS 开发 ...
Python-3-Object-Oriented-Programming-Third-Edition:Packt发行的《 Python 3面向对象编程》第三版
05-05
Python 3面向对象编程-第三版 这是Packt发布的的代码存储库。 在Python 3.8中使用面向对象的设计模式构建健壮且可维护的软件 这本书是关于什么的？ 面向对象编程（OOP）是一种流行的设计范例，其中数据和行为以...
amandamnf-amanda-sa-poo-python-ifce-p7:面向对象编程活动的Python代码存储库
04-20
【标题】"amandamnf-amanda-sa-poo-python-ifce-p7"是一个专注于Python面向对象编程（Object-Oriented Programming, OOP）的代码仓库。面向对象编程是编程的一种重要范式，它强调通过定义对象来组织和管理代码，使...
python-oop:Python面向对象编程文章目录和链接
05-03
python-oop：Python面向对象的编程 有关所有新数据，请参见Wiki ！！！ 核心，但仍然是附加组件 通常会忘记 。 但是，在许多情况下，最好使用词典。 附加组件 traitlite-是的，这与traitlets不同！ 和 。 原子 ...
圣诞树python-01-了解面向对象三大特性.ev4.rar
12-25
在这个“圣诞树python-01-了解面向对象三大特性”的课程中，我们将深入探讨Python中的面向对象编程（Object-Oriented Programming，简称OOP）的核心概念。面向对象编程是Python编程的重要组成部分，它基于类和对象，...
python中面向对象编程
AAIT11的博客
03-19 363
python中面向对象编程1.类（class）1.1. 类的定义：1.2 类的使用1.2.1. 类中参数`self`1.3 类的构造函数1.4. Python对象销毁（垃圾回收）2. 访问权限2.1. 私有变量2.2 私有函数3. 面向对象的特点3.1 继承3.1.1 继承的语法3.1.2. 多重继承3.1.3. 检测3.2 封装3.3 多态 向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函
python 中的面向对象编程
杨海吉
09-30 259
..在实践中，类定义内的语句通常都是函数定义，但也允许有其他语句，有时还很有用 — 我们会稍后再回来说明这个问题。在类内部的函数定义通常具有一种特别形式的参数列表，这是方法调用的约定规范所指明的 — 这个问题也将在稍后再说明。当进入类定义时，将创建一个新的命名空间，并将其用作局部作用域 — 因此，所有对局部变量的赋值都是在这个新命名空间之内。特别的，函数定义会绑定到这里的新函数名称。当（从结尾处）正常离开类定义时，将创建一个类对象。这基本上是一个包围在类定义所创建命名空间内容周围的包装器；
python的面向对象编程
wanger5354的博客
12-13 227
当前浏览器不支持播放音乐或语音，请在微信或其他浏览器中播放 孤独患者 音乐： 陈奕迅 - ? 在网络和现...
Python之面向对象编程
WELCOME TO LL's BLOG
05-05 289
面向对象编程（Object Oriented Programming），简称OOP，是一种编程方式。OOP把==对象（object）==作为程序的基本单元，一个对象包含了数据和操作数据的函数。 面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。 而面向对象的程序设计把计算机程...
python-面向对象编程
yujinlong2002的博客
04-08 938
_init__封装，将方法或者数据封装到对象中，以便后面进行使用继承，将类中的公共方法提升到基类中多态，python默认支持多态（这种被称为鸭子类型），最简单的记住下面这段代码即可v1 = arg.copy() # 浅拷贝print(v1)# func("阿龙的代码在爆粗")int("发消息")v1.send()v2.send()在程序设计中，这种情况被称为鸭子类型，是一种动态类型的一种风格，在鸭子类型中关注点在于对象的行为，能在什么；
Python面向对象编程
Nelson_hehe的博客
11-20 1556
在上一篇文章中的第十四个知识点已经对Python面向对象编程做了基本的了解 基本的知识点已经涵盖全面了： https://blog.csdn.net/hehe_soft_engineer/article/details/102904263#t5 面向对象的内容包括：类、变量、数据成员（类变量或实例变量）、方法重写、局部变量、实例变量、继承、实例化、方法、对象等。 下面来详细记录一下Pyth...
Python面向对象编程基础详解
"Python面向对象编程基础解析" 在Python编程中，面向对象编程（Object-Oriented Programming，简称OOP）是一种强大的设计模式，它通过模拟现实世界中的对象和概念来组织代码，使得程序更加模块化、可维护和易于扩展...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值