Python学习笔记（十二）——面向对象三与运算符的重载

重载运算符

概念

让自定义的类生成的实例对象能够使用内置运算符

作用

•让自定义的实例像内建对象一样进行运算符操作

• 让程序简洁易读

• 对自定义对象将运算符赋予新的规则

实例

class vector:
    def __init__(self,value):
        self.value=value
    def __add__(self,other):
        sum=[i+j for i,j in zip(self.value,other.value)]
        return(tuple(sum))

x=vector((243,12,45))
y=vector((45,78,12))
#这里执行的加法运算，实际上是调用了add方法
z=x+y
print(z)

重载方法

方法	说明	何时调用方法
__add__	加法运算	对象加法:x+y,x+=y
__sub__	减法运算	对象减法:x-y,x-=y
__mul__	乘法运算	对象乘法:x*y,x*=y
__diy__	除法运算	对象除法:x/y，x/=y
__getitem	索引，分片	x[i],x[i:j]、没有__iter__的for循环等
__setitem__	索引赋值	x[i]=值、x[i:j]=序列对象
__delitem__	索引和分片删除	del x[i] 、del x[i:j]

索引和分片重载

与索引相关的重载方法包括如下3个：

__getitem__：索引、分片；

def__setitem__(self, index, value):

         self.data[index] = value

__setitem__：索引赋值；

 def __ setitem __(self, index, value):

        self.data[index] = value

__delitem__：索引和分片删除。

def __ delitem __(self, index):

        del self.data[index]

Pyhton面向对象编程的有关特征

 总述

Python面向对象共有三大特征，分别是封装、继承和多态。

封装

保护隐私，明确区分内外

多态

增加了程序灵活性与可扩展性

继承

易维护、易拓展、降低冗余度

简单例子

class student:
    def __init__(self,idnum,age,grade):
        self.idnum=idnum
        self.age=age
        self.grade=grade
xiaoming=student(2021211234,20,99)
print("小明的学号是：",xiaoming.idnum,"小明的年龄是：",xiaoming.age,"小明所得成绩是",xiaoming.grade)

封装

概念

通常把隐藏的属性、方法与方法实现细节的过程称为封装。

注意事项

为了保护类里面的属性，避免类的属性随便赋值，可以采取如下步骤解决：

• 属性定义为私有属性，即在属性名前加两个下划线。

• 添加供外界调用的两个方法，分别用于设置或获得属性值。

封装实例（年龄属性）

下面为错误代码（私有属性仍然使用实例对象直接调用）

class human:
    def __init__(self,name,age):
        self.name=name
        self.__age=age                #此处定义年龄属性为私有属性
    def __age(self,new_age):           #此处定义了年龄属性的修改方法
        if new_age>0 and new_age<=120:
            self.__age=new_age
    def get_age(self):                #此处定义了年龄属性的获取方法
        return self.__age
#调试
person=human("Peter",20)
print(person.age)

运行报错

 使用方法进行调用

class human:
    def __init__(self,name,age):
        self.name=name
        self.__age=age                #此处定义年龄属性为私有属性
    def _age(self,new_age):           #此处定义了年龄属性的修改方法
        if new_age>0 and new_age<=120:
            self.__age=new_age
    def get_age(self):                #此处定义了年龄属性的获取方法
        return self.__age
#调试
person=human("Peter",20)
print(person.get_age())

 

继承

在现实生活中，继承一般指的是子女继承父辈的财产。

 类的继承概念

类的继承是指在一个现有类的基础上构建一个新的类，构建出来的新类被称作子类。

Python程序中，继承使用如下语法格式标注:

class 子类名(父类名)：

 假设有一个类为A派生出来子类B，示例如下：

class B(A)：

 单继承

一个子类只能有一个父类，被称为单继承。

 

class Cat():
    def __init__(self, color="白色"):
        self.color = color # 颜色
    def run(self): # 定义用于跑的方法
        print(f"{self.color}颜色的猫在狂奔")
class PersianCat(Cat):
    pass

bosimao=PersianCat("黑色")
print(bosimao.color)
print(bosimao.run())

单继承的注意事项

tip：

object的有关解释

object是我们常见的一个词，object实际上是一个类的实例，而这个类的名字是Object，他是所有类的父类，换言之，Python中所有的类都继承自Object类，这也就解释了为什么继承时父类往往会在后面写上一个Object。

 多继承

概念

Python支持多继承，多继承就是子类拥有多个父类，并且具有它们共 同的特征， 即子类继承了父类的方法和属性。

多继承可以看做是单继承的扩展

格式

class 子类名(父类1，父类2…)：

 

水鸟拥有了鸟类和鱼类的特征 

实例

# 定义表示鸟的类
class Bird(object):
#飞
    def fly(self):
        print("--鸟儿在天空飞翔--")
# 定义表示鱼的类
class Fish(object):
#游
    def swim(self):
        print("--鱼儿在水中遨游--")
# 定义表示飞鱼的类
class Volador(Bird, Fish):
    pass

feiyu=Volador()
print(feiyu.fly())
print(feiyu.swim())

 多继承——就近原则

概念

如果子类继承的多个父类间是 平行的关 系，子类先继承的哪个类就会调用哪个类的方法函数功能（是模块化程序设计的基本构成单位）

实例

继承顺序为Bird,Fish

# 定义表示鸟的类
class Bird(object):
#飞
    def breath(self):
        print("--鸟儿在天空呼吸--")
# 定义表示鱼的类
class Fish(object):
#游
    def breath(self):
        print("--鱼儿在水中呼吸--")
# 定义表示飞鱼的类
class Volador(Bird, Fish):
    pass

feiyu=Volador()
print(feiyu.breath())

 改变继承顺序后(继承顺序为Fish,Bird)：

# 定义表示鸟的类
class Bird(object):
#飞
    def breath(self):
        print("--鸟儿在天空呼吸--")
# 定义表示鱼的类
class Fish(object):
#游
    def breath(self):
        print("--鱼儿在水中呼吸--")
# 定义表示飞鱼的类
class Volador(Fish,Bird):
    pass

feiyu=Volador()
print(feiyu.breath())

 

重写父类方法和调用

在继承关系中，子类会自动拥有父类定义的方法，但是有时子类想要按照自己 的方式实现方法，即对父类中继承来的方法进行重 写，使得子类中的方法覆盖 掉跟父类同名的方法。

需要注意的是，在子类中重写的方法要和父类被重写的方法具有相同的方法名和参数列表。

 实例

## 定义国家打招呼的类
class Person(object):
# 打招呼的方法
    def sayHello(self):
        print("--Hello--")
# 定义Chinese类继承自Person类
## 定义中国人打招呼的子类
class Chinese(Person):
# 中国人打招呼的方法
    def sayHello(self):
        print("吃了吗？")
chinese=Chinese()
chinese.sayHello()

 

 

调用父类被重写的方法

若子类调用父类中被重写的方法，需要使用super方法访问父类中的成员。

 

多态

概念

大白话

多态是同一类事物具有的多种形态

• 水：冰、水蒸气、液态水

• 动物：人、狗、猪

Python本身就是一种多态语言

• >>> a=“123“ #字符串

• >>> a=[1,2,3,4] #列表

• >>> a=(1,2,3,4) #元组

专业解释

继承同一个类的多个子类中有相同的方法名， 那么子类产生的对象就可以不用 考虑具体的类型而直接使用同一的形式调用方法。

多态性的前提

• 类的继承关系

• 要有方法重写

多态性的优点

•增加了程序的灵活性：不论对象千变万化，使用者都是同一种形式去调用

• 增加了程序额可扩展性：通过继承animal类创建了一个新的类，使用者无需更改自己 的代码，还是用func(animal)去调用。

                                                                                

 实例

可迭代对象

 可循环迭代的对象称为可迭代对象，通常使用for语句实现元素遍历。

相对于序列，可迭代对象仅在迭代时产生数据，故可以节省内存空间。

Python语言提供了若干内置可迭代对象，例如range、map、filter、 enmunerate、zip函数；

标准库itertools模块中包含各种迭代器。 __iter() __方法

可迭代对象的识别: isinstance(obj,collections.abc)

 

 可迭代对象的迭代

实现了 __next()__方法的对象是迭代器(iterator) ；

使用内置函数iter(obj)可以调用可迭代对象的__iter()__方法，并返回一个迭代器

使用内置函数next()可以依次返回迭代器对象的下一个项目值，若没有新项目则将导StopIerration.

t=(1,2)
iterable=iter(t) #生成迭代器
print(next(iterable))
print(next(iterable))

 

没有新项目了

t=(1,2)
iterable=iter(t) #生成迭代器
print(next(iterable))
print(next(iterable))
print(next(iterable))

 

生成器函数

在函数定义中，若使用yield语句代替return返回一个值，则定义了一个生成器函数(generator)。

生成器函数使用yield语句返回一个值，然后保存当前函数的整个执行状态，等待一下调用。

def gentrips(n):
    for i in range(n):
        yield i*3
f=gentrips(10)
print(f)
for t in f:print(t,end=' ')

def gentrips(n):
    for i in range(n):
        yield i*3
f=gentrips(10)
print(f)
# for t in f:print(t,end=' ')
i=iter(f)
print(next(i))
print(next(i))
print(next(i))

 

小结

 加入对您有帮助，不要忘记点个赞再走哦~~

传送门：Python全套学习笔记