文章目录

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

高阶函数

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

代码演示如下：

import mathdef func(x,y,f):   # 可以接收其他函数作为参数，这样的函数即为“高阶函数”return f(x) + f(y)print(func(4,9,math.sqrt))  # 5def compute(a):return a ** 2print(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 + yprint(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 timestart = 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 randomprint(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 "香喷喷的" + foodr = 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 = pricedef describe(self):print("这个蛋糕的价格是：",self.price)@classmethoddef cake_show(cls):   #  经过@classmethod装饰器装饰的方法就成了类方法print("这是个类方法，第一个参数是：",cls)   # cls参数接收的是类对象（代表类本身）@staticmethoddef 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 = nameself.color = colordef describe(self):print("这是",self.name,";颜色是：",self.color)class Dog(Animal):   #  Dog子类继承Animal父类def __init__(self,name,color,food):super().__init__(name,color)   # 调用父类的构造方法，并传入两个参数self.food = fooddef 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和coloranimal.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 = colordef 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):passif __name__ == '__main__':w = Watermelon("绿色")w.sell_fruit()w.sell_vegetable()w.test()

结果如下：

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

多态性

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

代码的演示如下：

class Animal:  # 动物父类passclass Dog(Animal):  # 狗子类passclass Cat(Animal):  # 猫子类passdef 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 = nameself.price = pricedef __add__(self, other):  # 重载加法运算符# print("self.name=",self.name)# print("other.name=",other.name)return self.price + other.pricedef __sub__(self, other):  # 重载减法运算符return self.price - other.pricedef __gt__(self, other):  # 重载大于运算符return self.price > other.priceif __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.pricedef __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

Python基础教程（学习笔记整理DAY3）相关推荐

Python基础教程学习笔记：第一章基础知识
Python基础教程第二版学习笔记 1.python的每一个语句的后面可以添加分号也可以不添加分号:在一行有多条语句的时候,必须使用分号加以区分 2.查看Python版本号,在Dos窗口中输入&q ...
【莫烦Python】Python 基础教程——学习笔记
文章目录本笔记基于p1-p29[莫烦Python]Python 基础教程大家可以根据代码内容和注释进行学习. 安装我的:python3.8+anaconda+VS code print() pr ...
python笔记基础-Python基础教程学习笔记-1
今天学习了第9章的八皇后问题,Python简洁的语法令我叹服.现总结如下: Python实现程序如下: def conflict(state,nextX): nextY=len(state) for ...
python基础课程第12章,Python基础教程学习笔记 | 第12章 | 图形用户界面
Python支持的工具包很多,但没有一个被认为标准的工具包,用户选择的自由度大些.本章主要介绍最成熟的跨平台工具包wxPython.官方文档: ------ 丰富的平台: Tkinter实际上类似于标 ...
python基础教程学习笔记十二
图形用户界面 Tkinter Wxpython Pythonwin Java swing PyGTK pyQt 第五章数据库支持一python数据库api 1 全局变量 Apilevel 版本 ...
【莫烦Python】Python 基础教程学习笔记与代码
文章目录 2 print 3 数学 4 自变量 5 while循环 6 for循环 7 if 条件 8 if else条件 9 if elif else 10 def 函数 11 函数.参数 12 函 ...
Python基础教程学习笔记：第二章列表和元组
1.序列中元素的索引: 第一个元素索引是0,第二个是1,依次递增最后一个元素索引是-1,倒数第二个是-2,依次递减 2.序列(Sequence)的种类: 列表(list).元组(tuple).字符串 ...
python基础教程学习笔记 —字符串
字符串的基本操作字符串是不可变的,所以类似下面的操作是错误的. >>> str="abcdefghijklmn" >>> str 'abcde ...
Python 基础知识学习笔记——OpenCV（1）
Python 基础知识学习笔记--OpenCV(1) OpenCV是一个开源的跨平台计算机视觉和机器学习软件库,它轻量而且高效,被广泛的使用. 整理一下OpenCV学习笔记,以防忘记. 文章目录 Py ...
Python基础知识学习笔记——Matplotlib绘图
Python基础知识学习笔记--Matplotlib绘图整理python笔记,以防忘记文章目录 Python基础知识学习笔记--Matplotlib绘图一.绘图和可视化 1.导入模块 2.一个简 ...

Python基础教程（学习笔记整理DAY3）

文章目录

高阶函数

map()函数

reduce()函数

filter()函数

模块与包

time模块

random模块

面向对象程序设计

类定义语法

属性

方法

继承

方法的重写

多重继承

多态性

运算符的重载

Python基础教程（学习笔记整理DAY3）相关推荐

最新文章

热门文章