文章目录

高阶函数map()函数reduce()函数filter()函数 模块与包time模块random模块面向对象程序设计类定义语法属性方法继承方法的重写多重继承多态性运算符的重载

高阶函数

可以接收其他函数作为参数的函数。任务：利用add(x,y,f)函数，计算：x的平方根与y的平方根之和。

代码演示如下：

import math def func(x,y,f): # 可以接收其他函数作为参数，这样的函数即为“高阶函数” return f(x) + f(y) print(func(4,9,math.sqrt)) # 5 def compute(a): return a ** 2 print(func(2,3,compute)) # 13 print(func(2,3,lambda x:x**3)) # 补充：匿名函数

结果如下：

5.0 13 35

map()函数

map()是 Python内置的高阶函数，它接收一个函数f和列表或元组对象,并通过把函数f依次作用在列表或元组的每个元素上。任务：把列表中的每个字符串的第一个字母大写，其余小写。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-udlwRNNT-1593599285084)(C:\Users\Lenovo\Desktop\图片1.png)]

代码演示如下：

# map()高阶函数会对传入的列表或元祖中的每个元素使用接收的函数进行处理 # 任务：把列表中的每个字符串的第一个字母大写，其余小写 fruits = ["aPPLe","bANAna","oRANGE"] result = map(lambda s:s[0].upper()+s[1:].lower(),fruits) print("经过map()处理过的列表：",list(result)) # 使用list()函数将最终的结果转化为列表

结果如下：

经过map()处理过的列表： ['Apple', 'Banana', 'Orange']

reduce()函数

reduce()函数接收一个函数 f，一个序列，reduce()传入的函数 f 必须接收两个参数，reduce()对序列的每个元素反复调用函数f，并返回最终结果值。

代码演示如下：

# reduce()对序列的每个元素反复调用接收到的函数f,并返回最终结果值 # 注意：对于接收到的函数f,必须有两个参数 from functools import reduce # 导入reduce函数 def add(x,y): # 传入reduce()中的函数必须接收两个参数 return x + y print(reduce(add,range(1,101))) print(reduce(lambda x,y:x+y,range(1,101)))

结果如下：

5050 5050

filter()函数

filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个可迭代对象，这个函数 f 的作用是对每个元素进行判断f返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kt7bHA9d-1593599285087)(C:\Users\Lenovo\Desktop\图片2.png)]

代码演示如下： ~~~Python # filter()高阶函数用于对传入的可迭代对象进行元素过滤 filter_object = filter(lambda x:x%2==0,range(1,101)) print(list(filter_object)) # 使用list()函数转化为列表

结果如下：

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]

模块与包

模块是处理某一类问题的集合，模块由函数、类、变量组成。一个Python文件就是一个模块。包是由一系列模块组成的集合。包必须含有一个__init__.py文件，用于标识当前文件夹是一个包。

模块的导入

import 模块名 [ as 别名]from 模块名 import 函数名from 模块名 import *

注意：当在其他模块中import *的时候，只能导入被导入模块中__all__变量规定的内容。例如：all = [“color”,“country”]

只限制*的情况，其他调用情况不限制。

包的导入

from 包名 import 模块名from 包名.模块名 import 函数名from 包名 import *

注意：当from 包名 import *的时候，会去寻找该包的入口文件(init.py), 则import *只能导入入口文件中__all__规定的内容

代码演示如下:

import math as m # 导入模块，也可以起一个别名 print(m.sqrt(9)) from math import pow # 从模块中导入函数 print(pow(2,3)) from math import * # 从模块中导入该模块的所有内容 print(sin(90))

结果如下：

3.0 8.0 0.8939966636005579

time模块

time()函数返回1970年1月1日00:00:00AM以来的秒数sleep()函数用来休眠指定的秒数

代码演示如下：

import time start = time.time() # 开始计时 for i in range(1,100000): pass # 啥也不干 end = time.time() # 结束计时 print("循环经过的时间（以秒算）：",end-start) for i in range(1,5): print("i=",i) time.sleep(1) # 休眠1秒

结果如下：

循环经过的时间（以秒算）： 0.0049860477447509766 i= 1 i= 2 i= 3 i= 4

random模块

randint()函数在一个数字范围内随机挑选一个数字choice()函数从一个列表或元组中随机选取一个元素shuffle()函数给列表“洗牌”

代码演示如下：

import random print(random.randint(1,3)) # 从1（包括）到3（包括）选择一个随机整数 foods = ["noodles","rice","ice-cream","tamato","potato"] print(random.choice(foods)) # 从序列中随机选择一个元素 print("洗牌之前：",foods) random.shuffle(foods) # 对列表进行乱序处理 print("洗牌之后：",foods)

结果如下：

3 rice 洗牌之前： ['noodles', 'rice', 'ice-cream', 'tamato', 'potato'] 洗牌之后： ['potato', 'rice', 'ice-cream', 'tamato', 'noodles']

面向对象程序设计

面向对象程序设计（Object Oriented Programming，OOP）主要针对大型软件设计而提出，使得软件设计更加灵活，能够很好地支持代码复用和设计复用，并且使得代码具有更好的可读性和可扩展性。Python中对象的概念很广泛，Python中的一切内容都可以称为对象。

类定义语法

Python使用class关键字来定义类，class关键字之后是一个空格，然后是类的名字，再然后是一个冒号，最后换行并定义类的内部实现。

类名的首字母一般要大写。

class Car: def infor(self): print(" This is a car ")

定义了类之后，可以用来实例化对象，并通过“对象名.成员”的方式来访问其中的数据成员或成员方法。

car = Car() car.infor() This is a car

在Python中，可以使用内置函数isinstance()来测试一个对象是否为某个类的实例。

isinstance(car, Car) True isinstance(car, str) False

Python提供了一个关键字“pass”，类似于空语句，可以用在类和函数的定义中或者选择结构中。当暂时没有确定如何实现功能，或者为以后的软件升级预留空间，或者其他类型功能时，可以使用该关键字来“占位”。

class A: pass

def demo(): pass

if 5>3: pass

代码演示如下：

class Restaurant: # 定义一个饭店类 def make_food(self,food): # 实例方法（属于对象调用的方法）,self代表当前对象（当前正在调用该方法的对象） print("准备中...") print("做好了") return "香喷喷的" + food r = Restaurant() # 创建饭店对象，会自动调用“构造方法” food = r.make_food("米饭") # 使用对象调用方法 print(food) print("*"*30) print(r.make_food("面条")) print("r实例对象属于Restaurant类吗？",isinstance(r,Restaurant)) print("r实例对象属于字符串类型吗？",isinstance(r,str))

结果如下：

准备中... 做好了 香喷喷的米饭 ****************************** 准备中... 做好了 香喷喷的面条 r实例对象属于Restaurant类吗？ True r实例对象属于字符串类型吗？ False

属性

Python的属性分为实例属性和类属性实例属性是作为对象的属性，以self作为前缀的属性类属性是在类内部定义的属性，可以被类中的所有实例共享

代码演示如下：

class Car: count = 0 # 类属性，可以被所有的实例化对象共享 # 构造方法，当创建对象时,该对象会自动调用构造方法，经常用来初始化对象 def __init__(self,price,color): self.price = price # 添加一个名称为price的实例属性 self.color = color # 添加一个名称为color的实例属性 def describe(self): print("该汽车的价格是：",self.price,"颜色是：",self.color) if __name__ == '__main__': # 防止其他模块导入本模块的时候，直接执行下面的代码块 car1 = Car(20,"black") # 实例化对象（创建对象）的时候，自动调用构造方法 car1.describe() car1.country = "中国" # 在类的外面也可以动态添加实例属性 print("car1的国家是：",car1.country) print("*"*30) car2 = Car(10, "red") # 实例化对象（创建对象）的时候，自动调用构造方法 car2.describe() print("*" *30) print("使用类名直接调用类属性：",Car.count) print("使用car1对象调用类属性：",car1.count) Car.count = 100 # 使用“类名.类属性名”修改类属性的值 print("（修改后）使用类名直接调用类属性：", Car.count) print("（修改后）使用car2对象调用类属性：", car2.count)

结果如下：

该汽车的价格是： 20 颜色是： black car1的国家是： 中国 ****************************** 该汽车的价格是： 10 颜色是： red ****************************** 使用类名直接调用类属性： 0 使用car1对象调用类属性： 0 （修改后）使用类名直接调用类属性： 100 （修改后）使用car2对象调用类属性： 100

方法

类中的函数称为方法：实例方法、类方法、静态方法等init()方法：构造方法,用来初始化新创建的对象

静态方法与类方法：

Python使用@staticmethod装饰器把普通的函数转换为静态方法类方法是将类本身作为操作对象的方法。类方法可以使用@classmethod装饰器定义，被装饰器的方法把类对象作为第一个参数传递(习惯上使用cls)区别：类方法以类本身作为第一个参数(习惯用cls接收，静态方法没有参数)

代码演示如下：

class Cake: def __init__(self,price): self.price = price def describe(self): print("这个蛋糕的价格是：",self.price) @classmethod def cake_show(cls): # 经过@classmethod装饰器装饰的方法就成了类方法 print("这是个类方法，第一个参数是：",cls) # cls参数接收的是类对象（代表类本身） @staticmethod def cake_static(): print("这是个静态方法") if __name__ == '__main__': c = Cake(10) c.describe() # 调用实例方法 Cake.cake_show() # 调用类方法 Cake.cake_static() # 调用静态方法

结果如下：

这个蛋糕的价格是： 10 这是个类方法，第一个参数是： <class '__main__.Cake'> 这是个静态方法

继承

继承是为代码复用和设计复用而设计的，是面向对象程序设计的重要特性之一。设计一个新类时，如果可以继承一个已有的设计良好的类然后进行二次开发，无疑会大幅度减少开发工作量。

class 子类名(父类名): pass

如果需要在派生类(子类)中调用基类(父类)的方法，可以使用super().xxx 来实现这一目的。

代码演示如下：

class Animal: # 作为父类（基类） home = "地球" # 类属性 def __init__(self,name,color): self.name = name self.color = color def describe(self): print("这是",self.name,";颜色是：",self.color) class Dog(Animal): # Dog子类继承Animal父类 def __init__(self,name,color,food): super().__init__(name,color) # 调用父类的构造方法，并传入两个参数 self.food = food def describe(self): # 重写（重新实现）父类的describe方法 print("这是", self.name, ";颜色是：", self.color,"；食物是：",self.food) if __name__ == '__main__': dog1 = Dog("小狗","yellow","零食") # 创建dog1对象，该对象会自动调用构造方法 dog1.describe() print(dog1.home) print("*"*30) animal = Animal("动物","未知颜色") # 创建父类Aniaml对象，并传入name和color animal.describe()

结果如下：

这是 小狗 ;颜色是： yellow ；食物是： 零食 地球 ****************************** 这是 动物 ;颜色是： 未知颜色

方法的重写

目的：“取其精华，去其糟粕”如何重写？ 对于父类的方法，只要它不符合子类模拟的实物的行为，都可在子类中对其重新实现。也就是在子类中定义一个与要重写的父类方法同名的方法。这样，当子类对象去调用这个同名方法时，将不会考虑这个父类方法。

代码演示包含在继承程序。

多重继承

Python支持多重继承，即一个子类可以继承多个父类。语法为： class_name(parent_class1,parent_class2…) 其中：class_name是子类名,parent_class1和parent_class2是父类名。 注意：子类根据父类的顺序优先继承构造方法。

代码演示如下：

class Fruit: # 水果类 def __init__(self,color): print("Fruit __init__") self.color = color def sell_fruit(self): print("卖水果了，这个水果的颜色是：",self.color) def test(self): print("fruit test...") class Vegetable: # 蔬菜类 def __init__(self): print("Vegetable __init__") def sell_vegetable(self): print("卖菜了~~~") def test(self): print("vegetable test...") class Watermelon(Fruit,Vegetable): pass if __name__ == '__main__': w = Watermelon("绿色") w.sell_fruit() w.sell_vegetable() w.test()

结果如下：

Fruit __init__ 卖水果了，这个水果的颜色是： 绿色 卖菜了~~~ fruit test...

多态性

子类对象可以替代父类对象，在同一个变量在调用不同的方法时，可能表现出多种行为，这种特性称为多态性。

代码的演示如下：

class Animal: # 动物父类 pass class Dog(Animal): # 狗子类 pass class Cat(Animal): # 猫子类 pass def eat(obj): if isinstance(obj,Animal): # 先判断是否属于动物 if isinstance(obj,Dog): print("旺旺，小狗啃骨头~~~") if isinstance(obj,Cat): print("喵喵，小猫吃鱼......") else: print(obj,"不属于Animal！") if __name__ == '__main__': dog = Dog() # 创建Dog的实例化对象 cat = Cat() # 创建Cat的实例化对象 eat(dog) eat(cat) eat("hello")

结果如下：

旺旺，小狗啃骨头~~~ 喵喵，小猫吃鱼...... hello 不属于Animal！

运算符的重载

运算符的重载可以实现对象之间的运算。Python把运算符和类的内置方法关联起来，每个运算符都对应1个方法，例如：add(self,other)表示加号运算符”+”,gt(self,other)表示大于运算符”>”

代码演示如下：

class Fruit: def __init__(self,name,price): self.name = name self.price = price def __add__(self, other): # 重载加法运算符 # print("self.name=",self.name) # print("other.name=",other.name) return self.price + other.price def __sub__(self, other): # 重载减法运算符 return self.price - other.price def __gt__(self, other): # 重载大于运算符 return self.price > other.price if __name__ == '__main__': fruit1 = Fruit("苹果",12) fruit2 = Fruit("香蕉",10) print("fruit1+fruit2的结果：",fruit1+fruit2) print("fruit1-fruit2的结果：",fruit1-fruit2) print("fruit1>fruit2的结果：",fruit1>fruit2)

结果如下：

fruit1+fruit2的结果： 22 fruit1-fruit2的结果： 2 fruit1>fruit2的结果： True

(“self.name=”,self.name) # print(“other.name=”,other.name) return self.price + other.price

def __sub__(self, other): # 重载减法运算符 return self.price - other.price def __gt__(self, other): # 重载大于运算符 return self.price > other.price

if name == ‘main’: fruit1 = Fruit(“苹果”,12) fruit2 = Fruit(“香蕉”,10) print(“fruit1+fruit2的结果：”,fruit1+fruit2) print(“fruit1-fruit2的结果：”,fruit1-fruit2) print(“fruit1>fruit2的结果：”,fruit1>fruit2)

结果如下：

fruit1+fruit2的结果： 22 fruit1-fruit2的结果： 2 fruit1>fruit2的结果： True