Python基础超详细笔记[为了自己复习写的笔记~]

加粗样式@[toc]

计算机组成

硬件系统

• 中央处理器：cpu
• 存储器： 内存储器：内存 外存储器：硬盘 u盘
• 输入设备：键盘、鼠标…
• 输出设备：显示器、打印机…

软件系统

• 系统软件：操作系统、…
• 应用软件：qq、微信…

python基础

注释

• 单行注释

#

• 多行注释

#第二种
"""

"""
#第一种
'''

'''

变量

• 变量的作用
  • 变量就是一个存储数据的时候把当前数据所在的内存地址的名字
• 定义变量

变量名 = 值    #先计算等号右边值然后再赋值到左边

变量名自定义，要满足标识符命名规则

• 认识数据类型

标识符

标识符命名规则是python定义各种名字的时候的统一规范，具体如下：

• 由数字、字母、下划线组成
• 不能数字开头
• 不能使用内置关键字
• 严格区分大小写

False None True and as assert break class
continue def del elif else except finally for
from global if import in is lambda nonlocal
not or pass raise return try while with yield

命名规则

• 见名知义。
• 大驼峰：即每个单词首字母都大写，列如：MyName。
• 小驼峰：第二个（含）以后的单词首字母大写，例如：myName
• 下划线：列入：my_name

使用变量

my_name = 'TOM'
print(my_name)

schoolName = '全文'
print(schoolName)

认识bug

Debug工具

Debug工具是pyCharm IDE中集成的用来调试程序的工具，在这里程序员可以查看程序的执行细节和流程或者调解bug。

Debug工具使用步骤：

1.打断点

2.Debug调试

打断点

• 断点位置

目标要调试的代码块的第一行代码即可，即一个断点即可。

• 打断点的方法

单击目标代码的行号右侧空白位置。

数据类型

• 数值：int(整数)、float(浮点数)
• 布尔型
• str（字符串）
• list（列表）
• tuple（元组）
• set（集合）
• dict（字典）

#type()函数检查python数据类型

输出

作用：程序输出内容给用户

print('hello Python')

age =  18
print(age)

#需求：输出“今年我的年龄是18岁”

格式符号	转换
%s	字符串
%d	有符号的十进制整数
%f	浮点数
%c	字符
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数（小写ox）
%X	十六进制整数（大写OX）
%e	科学计数法（小写‘e’）
%E	科学计数法（大写‘E’）
%g	%f和%e的简写
%G	%f和%E的简写

age = 18
name = 'TOM'
weight =75.5
stu_id = 1

print('今年我的年龄是%d岁' % age)
print('我的名字是%s' % name)
print('我的体重是%.3f公斤' % weight)   #.3f保留三位小数
print('我的学号是%03d' % stu_id)       #03d格式化输出三位数
print('我的名字是%s,今年%d岁了,体重是%.3f公斤,学号是%03d' % (name,age,weight,stu_id))

# 拓展
print('我的名字是%s,今年%s岁了，体重%s公斤' % (name,age,weight))
print(f'我的名字是{name},明年{age+1}岁了') #3.6出来的

转义字符

• \n：换行
• \t：制表符，一个tab键（4个空格）的距离。

输入

在python中，程序接收用户输入的数据的功能即是输入。

输入语法

input("提示信息")

输入的特点

• 当程序执行到input，等待用户输入，输入完成之后才继续向下执行。

• 在python中，input接收用户输入后，一般存储到变量，方便使用。

• 在python中，input会把接收到的任意用户输入的数据都当做字符串处理。

  转换数据类型

问：input（）接收用户输入的数据都是字符串类型，如果用户输入1，想得到整型该如何操作？

答：转换数据类型即可，即将字符串类型转换成整型。

typle()                 #将一个序列转换为元组
str()                   #将数据转换成字符串型
float()                 #将数据转换成浮点型 
list()                  #将一个序列转成列表
eval()                  #计算在字符串中的有限python表达式，并返回一个对象 

pycharm交互

python console（软件左下角）

运算符的分类

• 算数运算符
• 赋值运算符
• 复合赋值运算符
• 比较运算符
• 逻辑运算符

算数运算符

运算符	描述	实例
+	加	1+1
-	减	1-1
*	乘	2*2
/	除	10/2
%	取余	9%4输出结果为1
**	指数	2**4输出结果为16
()	小括号	小括号用来提高运算优先级，即(1+2)*3输出结果为9
/	除	10/2输出结果为5
//	整除	9//4输出结果为2

• 混合运算优先级顺序：()高于**高于* / // % 高于 + -

赋值运算符

运算符	描述	实例
=	赋值	将=右侧的结果赋值给等号左侧的变量

• 单个变量赋值

num = 1
print(num)

• 多个变量赋值

num1,float1,str1 =10,0.5,'hello world'
print(num1)
print(float1)
print(str1)

• 多变量赋相同值

a = b = 10
print(a)
print(b)

复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	c += a 等价于c = c + a
-=	减法赋值运算符	c -= a 等价于c = c - a
*=	乘法赋值运算符	c *= a 等价于c = c * a
/=	除法赋值运算符	c /= a 等价于 c = c / a
//=	整除赋值运算符	c //= a 等价于 c = c // a
%=	取余赋值运算符	c %= a 等价于 c = c % a
**=	幂赋值运算符	c **= a 等价于 c = c ** a

• 注意点：先算符合赋值运算符右边表达式，再算复合赋值运算

比较运算符

比较运算符也叫关系运算符，通常用来判断。

运算符	描述	实例
==	判断相等。如果两个操作数的结果相等，则条件结果为真(True),否则条件结果为假(False)	如a=3，b=3,则（a==b）为true
!=	不等于。如果两个操作数的结果不相等，则条件为真(True),否则条件结果为假(False)	如a=1，b=3,则（a!=b）为true
>	运算符左侧操作数结果是否大于右侧操作数结果，如果大于，则条件为真，否则为假	如a=7，b=3则(a>b)为true
<	运算符左侧操作符结果是否小于右侧操作数结果，如果小于，则条件为真，否则为假	如a=7,b=3,则(a<b)为false
>=	运算符左侧操作数结果是否大于等于右侧操作数结果，如果大于，则条件为真，否则为假	如a=7,b=3,则(a>=b)为true
<=	运算符左侧操作数结果是否小于等于右侧操作数结果，如果小于，则条件为真，否则为假	如a=3,b=3,则(a <= b)为true

逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	一假即假	true and true 返回true
or	x or y	一真即真	false or true 返回 true
not	not x	非真即假	not true 返回 false

a = 1
b = 2
c = 3
print((a < b) and (b < c)) #true
print((a > b) and (b < c)) #false
print((a > b) or (b < c))  #true
print(not (a > b))    #true

拓展

数字之间的逻辑运算

a = 0
b = 1
c = 2

# and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
print(a and b)   # 0
print(b and a)   # 0
print(a and c)   # 0
print(b and c)   # 2
print(c and b)   # 1
#or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字
print(a or b)  # 1
print(a or c)  # 2
print(b or c)  # 1

条件语句

假设一个场景：

• 同学们这个年龄去过网吧吗？
• 去网吧进门想要上网必须做的一件事是做什么？（考虑重点）
• 为什么要把身份证给工作人员？
• 是不是就是为了判断是否成年？
• 是不是如果成年可以上网？如果不成年则不允许上网？

其实这里所谓的判断就是条件语句，即条件成立执行某些代码，条件不成立则不执行这些代码。

单分支语法

if 条件:
    条件成立执行的代码1
    条件成立执行的代码2
    ......

多分支语法

if 条件:
    条件成立执行的代码1
    条件成立执行的代码2
    ......
elif 条件:
    条件成立执行的代码1
    条件成立执行的代码2
    ......
else 条件:
    条件成立执行的代码1
    条件成立执行的代码2
    ......

拓展

age >= 18 and age <= 60 可以化简为  18 <= age <= 60

if嵌套

if 条件1:
    条件成立执行的代码1
    条件成立执行的代码2
    ......
    
    if 条件2:
        条件成立执行的代码1
    	条件成立执行的代码2
   		......

随机数拓展

import 模块名   #导出random模块
random.randint(开始,结束)  #使用random模块中的随机整数功能

三目运算符

三目运算符也叫三元运算符或三元表达式。

语法如下:

# 条件成立执行的表达式 if 条件 else 条件不成立执行的表达式

实例：

a = 1
b = 2

c = a if a > b else b
print(c)

#需求：有两个变量，比较大小，如果变量1 大于 变量2 执行 变量1 - 变量2；否则 变量2 - 变量1

q =22
w =12
r = q - w if q > w else w - q
print(r)

while循环

循环的作用

循环的作用：让代码更高效的重复执行。

循环的分类

在python中，循环分为while和for两种，最终实现效果相同。

语法

while 条件:
    条件成立重复执行的代码1
    条件成立重复执行的代码2
    ......

计数器

# 循环的计数器
i = 0
while i < 5:
    print('媳妇儿，我错了')
    i+=1
    
print('任务结束')

break和continue

break和continue是循环中满足一定条件退出循环的两种不同方式。

理解

• break是终止此循环
• continue是退出当前一次循环继而执行下一次循环代码。

实例：九九乘法表

for循环

for 临时变量 in 序列:
    重复执行的代码1
    重复执行的代码2
    ......

else

循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码。

while…else

语法：

while 条件:
    条件成立重复执行的代码
else:
    循环正常结束之后要执行的代码

• 所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。
• 因为continue是退出当前一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执行了else缩进的代码。

for…else

语法：

for 临时变量 in 序列:
    重复执行的代码
    ...
else:
    循环正常结束之后要执行的代码

• 所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。
• 因为continue是退出当前一次循环，继续下一次循环，所以该循环在continue控制下可以正常结束的，当循环结束后，则执行了else缩进的代码。

字符串

下标

“下标"又叫"索引”，就是编号。比如火车座位号，座位号的作用：按照编号快速找到对应的座位。同理，下标的作用即是通过下标快速找到对应的数据。

切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

语法

序列[开始位置下标:结束位置下标:步长]

注意

• 不包含结束位置下标对应的数据，正负整数均可；
• 步长是选取间隔，正负整数均可，默认步长为1。

常用方法

字符串的常用操作方法有查找、修改和判断三大类。

查找

所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。

• find():检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。

1.语法

字符串序列.find(子串，开始位置下标，结束位置下标)

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

• index():检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常.

1.语法

字符串序列.index(子串，开始位置下标，结束位置下标)

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

• rfind()：和find()功能相同，但查找方向为右侧开始。

• rindex()：和index()功能相同，但查找方向为右侧开始。

• count()：返回某个子串在字符串中出现的次数

1.语法

字符串序列.count(子串，开始位置下标，结束位置下标)

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

修改

所谓修改字符串,指的就是通过函数的形式修改字符串中的数据。

• replace()：替换

1.语法

字符串序列.replace(旧子串，新子串，替换次数)

注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。

​ 调用replace函数后，发现原有字符串的数据并没有得到修改，修改后的数据是 replace函数的返回值；

​ 说明字符串是不可变数据类型；

​ 数据是否可以改变分为可变类型 和不可变类型。

• split()：按照指定字符分割字符串。

1.语法

字符串序列.split(分割字符，num)

注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。

​ 分割返回一个列表，丢失分割字符；

• join()：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。

1.语法

字符或子串.join(多字符串组成的序列)

注意：合并列表里面的字符串数据为一个大字符串

• 大小写转换

  • capitalize()：将字符串第一个字符转换成大写。

  注意：capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写。

  • title()：将字符串每个单词首字母转换成大写。

  • lower()：将字符串中大写转小写。

  • upper()：将字符串中小写转大写。

• 删除空白字符

  • lstrip()：删除字符串左侧空白字符。
  • rstrip()：删除字符串右侧空白字符。
  • strip()：删除字符串两侧空白字符。

• 字符串对齐

  • ljust()：返回一个原字符串左对齐，并使用指定字符（默认空格）填充至对应长度的新字符串。（left）

  1.语法

  字符串序列.ljust(长度，填充字符)
  

  • rjust()：返回一个原字符串右对齐，并使用指定字符（默认空格）填充至对应长度的新字符串，语法和ljust()相同。(right)
  • center()：返回一个原字符串居中对齐，并使用指定字符（默认空格）填充至对应长度的新字符串，语法和ljust()相同。

判断

所谓判断即是判断真假，返回的结果是布尔型数据类型：true或false。

• startswith()：检查字符串是否是以指定子串开头，是则返回true，否则返回false。如果设置开始和结束位置下标，则在指定范围内检查。

1.语法

字符串序列.startswith(子串，开始位置下标，结束位置下标)

• endswith()：判断字符串是否以某个子串结尾

• isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回true，否则返回false。

• isdigit()：如果字符串只包含数字则返回true否则返回false。

• isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返回true，否则返回false。

• isspace()：如果字符串中包含空白，则返回true，否则返回false。

列表

列表的格式

[数据1，数据2，数据3，数据4......]

• 列表可以一次性存储多个数据，且可以为不同数据类型。
• 列表数据可改

列表的常用操作

列表的作业是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。

下标

从0开始

• index()：返回指定数据所在位置的下标。

1.语法

列表序列.index(数据，开始位置下标，结束位置下标)

注意：如果查找的数据不存在则报错。

• count()：统计指定数据在当前列表中出现的次数。
• len()：访问列表长度，即列表中数据的个数。

---

判断是否存在

• in:判断指定数据在某个列表序列，如果在返回true，否则返回false
• not in：判断指定数据不在某个列表序列，如果不在返回true，否则返回false

---

列表增加数据

作用：增加指定数据到列表中。

• append()：列表结尾追加数据。

1.语法

列表序列.append(数据)

2.注意

如果append()追加的数据是一个序列，则追加整个序列到列表

• extend()：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表。

1.语法

列表序列.extend(数据)

2.注意

如果是一个序列，会把序列数据拆开追加列表中

• insert()：指定位置新增数据。

1.语法

列表序列.insert(位置下标，数据)

---

列表数据删除

• del

1.语法

del 目标

• pop()：删除指定下标的数据（默认为最后一个），并返回该数据。

1.语法

列表序列.pop(下标)

• remove()：移除列表中某个数据的第一匹配项。

1.语法

列表序列.remove(数据)

• clear()：清空列表

---

列表数据修改

• 修改指定下标数据

• 逆置：reverse()

• 排序：sort()

1.语法

列表序列.sort(key = None,reverse = False)

注意：reverse表示排序规则，reverse = True 降序，reverse = False升序（默认）

---

列表复制数据

函数copy()

name_list = {'TOM','LILY','ROSE'}

list1 = name_list.copy()

print(list1)
print(name_list)

---

列表的循环遍历

需求：依次打印列表中的各个数据。

while

• 代码

name_list = ['TOM','LILY','ROSE']

i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

for

• 代码

name_list = ['Tom','lily','rose']

for i in name_list:
    print(i)

列表嵌套

所谓列表嵌套指的就是一个列表里面包含了其他的子列表。

应用场景：要存储班级一、二、三个班级学生姓名，且每个班级的学生姓名在一个列表。

name_list = [['小明','小红','小绿'],['tom','lily','rose'],['张三','李四','王五']]

思考：如何查找到数据"李四"?

#第一步：按下标查找到李四所在的列表
print(name_list[2])

#第二步：从李四所在的列表里面，再按下标找到数据李四
print(name_list[2][1])

元组

• 元组的应用场景
• 定义元组
• 元组常用操作

元组的应用场景

思考：如果想要存储多个数据，但是这些数据是不能修改的数据，则么办？

答：列表？列表可以一次性存储多个数据，但是列表中的数据允许更改。

num_list = [10,20,30]
num_list[0] = 100

一个元组可以存储多个数据，元组内的数据是不可能修改的。

定义元组

元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型。

#多个数据元组
t1 = (10,20,30)

#单个数据元组
t2 = (10,)

注意：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型

t2 = (10,)
print(type(t2))   #tuple

t3 = (20)
print(type(t3))   #int

t4 = ('hello')
print(type(t4))   #str

元组的常用操作

元组数据不支持修改，只支持查找，具体如下：

• 按下标查找数据

typle1 = ('aa','bb','cc','bb')

• index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同。

typle1 = ('aa','bb','cc','bb')
print(tpple1.index('aa'))

• count()：统计某个数据在当前元组出现的次数。

tuple1 = ('aa','bb','cc','bb')
print(tuple1.count('bb'))

• len()：统计元组中数据的个数。

tuple1 = ('aa','bb','cc','bb')
print(len(tuple1))

元组修改操作

注意：元组内的数据直接修改会报错

t1 = ('aa','bb','cc','bb')
t1[0] = 'aaa'

但是如果元组里面有列表，修改列表里面的数据则是支持的。

t2 = ('aa','bb',['cc','dd'])
print(t2[2])
t2[2][0] = 'ccc'

字典

字典的应用场景

思考1：如果有多个数据，例如：‘TOM’,‘男’，’20‘，如何快速存储？

答：列表

list1 = ['Tom','男','20']

思考2：如何查找到数据’Tom‘ ?

答：查找到下标为0的数据即可。

list1[0]

思考3：如果将来数据顺序发生变化，如下所示，还能用list[0] 访问到数据’Tom’吗？

list1 = ['男'，20，'tom']

答：不能，数据’Tom’此时下标为2.

思考4：数据顺序发生变化，每个数据的下标也会随之变化，如何保证数据顺便变化前后使用同一的标准数据查找数据呢？

答：字典，字典里面的数据是一键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。

创建字典的语法

字典特点：

• 符号为大括号
• 数据为键值对形式出现
• 各个键值对之间用逗号隔开

# 有数据字典
dict1 = {'name':'Tom','age':20,'gender':'男'}

# 空字典
dict2 = {}

dict3 = dict()

字典常见操作

增

写法：字典序列[key] = 值

注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

dict1 = {‘name’:'Tom','age':20,'gender':'男'}

dict1['name'] = 'Rose'
#结果：{'name':'Rose','age':20,'gender':'男'}
print(dict1)

dict1['id'] = 110

#{'name':'Rose','age': 20,'gender':'男','id':110}
print(dict1)

注意：字典为可变类型。

删

• del()/del：删除字典或删除字典中指定键值对。

dict1 = {'name':'Tom','age':20,'gender':"男"}

del dict1['gender']
#结果：{'name':'Tom','age':20}
print(dict1)

• clear()：清空字典

dict1 = {'name':'Tom','age':20,'gender':"男"}
dict1.clear()

改

写法：字典序列[key] = 值

注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

查

key值查找

dict1 = {'name':'Tom','age':20,'gender':'男'}
print(dict1['name'])
print(dict1['id'])

如果当前查找的key存在，则返回对应的值；否则报错。

get()

• 语法

字典序列.get(key,默认值)

注意：如果当前查找的key不存在则返回第二个参数（默认值），如果省略第二个参数，则返回None。

keys()

dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1.keys())  #dict_keys(['name','age','gender'])

values()

dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1.values())  #dict_values(['tom',20,'男'])

items()

dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1.items())  #dict_items(['name','tom'),('age',20),('gender','男'])

字典的循环遍历

遍历字典的key

dict1 = {'name':'tom','age':20,'gender':'男'}
for key in dict1.keys():
    print(key)

遍历字典的value

dict1 = {'name':'tom','age':20,'gender':'男'}
for value in dict1.values():
    print(value)

遍历字典的元素

dict1 = {'name':'tom','age':20,'gender':'男'}
for item in dict1.items():
    print(item)

遍历字典的键值对

dict1 = {'name':'tom','age':20,'gender': '男'}
for key,value in dict1.items():
    print(f'{key} = {value}')

集合

创建集合

创建集合使用{}或set(),但是如果要创建空集合只能使用set(),因为{}创建空字典。

s1 = {10,20,30,40,50}
print(s1)

s2 = {10,30,20,10,30,40,30,50}
print(s2)

s3 = set('abcdefg')
print(s3)

s4 = set()
print(type(s4)) #set

s5 = {}
print(type(s5)) #dict

注意：集合有去重功能

​ 集合数据没有顺序

集合常见操作方法

增加数据

• add()

s1 = {10,20}
s2.add(100)
s1.add(10)
print(s1) #{100,10,20}

因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。

• update(),追加的数据是序列

s1 = {10,20}
#s1.update(100)  #报错
s1.updata([100,200])
s1.updata('abc')

删除数据

• remove(),删除集合中的指定数据，如果数据不存在则报错。

s1 = {10，20}

s1.remove(10)
print(s1)

s1.remove(10)  #报错
print(s1)

• discard()，删除集合中的指定数据，如果数据不存在也不会报错。

s1 = {10,20}

s1.discard(10)
print(s1)

s1.discard(10)
print(s1)

• pop(),随机删除集合中的某个数据，并返回这个数据。

s1 = {10,20,30,40,50}

del_num = s1.pop()
print(del_num)
print(s1)

查找数据

• in:判断数据在集合序列
• not in: 判断数据不在集合序列

s1 = {10,20,30,40,50}

print(10 in s1)
print(10 not in s1)

公共操作

一、运算符

运算符	描述	支持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

二、公共方法

函数	描述
len()	计算容器中元素个数
del 或 del()	删除
max()	返回容器中元素最大值
min()	返回容器中元素最小值
range(start,end,step)	生成从start到end的数字，步长为step，供for循环使用
enumerate()	函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中。

注意：range()生成的序列不包含end数字

enumerate(可遍历对象,start=0)    #start参数用来设置遍历数据的下标的起始值，默认为0.
#返回结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据

list1 = ['a','b','c','d','e']
for i in enumerate(list1):
    print(i)
    
for index,char in enumerate(list1,start=1):
    print(f'下标是{index},对应的字符是{char}')

容器类型转换

tuple()

作用：将某个序列转换成元组

list()

作用：将某个序列转换成列表

set()

作用：将某个序列转换成集合

注意：1.集合可以快速完成列表去重

​ 2.集合不支持下标

推导式

• 列表推导式
• 字典推导式
• 集合推导式

列表推导式

作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。

列表推导式又叫列表生成式。

• while循环实现

# 1.准备一个空列表
list1 = []

# 2.书写循环，依次追加数字到空列表list1中
i = 0
while i < 10:
    list1.append(i)
    i += 1
print(list1)

• for循环实现

list1 = []
for i in range(10):
    list1.append(i)

print(list1)

• 列表推导式实现

list1 = [i for i in range(10)]  # 返回数据 遍历数据
print(list1)

带if的列表推导式

需求：创建0-10的偶数列表

• 方法一：range()步长实现

list1 = [i for i in range(0,10,2)]
print(list1)

• 方法二：if实现

list1 = [i for i in range(10) if i % 2 == 0]
print(list1)

多个for循环实现列表推导式

需求：创建列表如下：

[(1,0),(1,2),(1,2),(2,0),(2,1),(2,2)]

• 代码如下：

list1 = [(i,j) for i in range(1,3) for j in range(3)]
print(list1)

字典推导式

思考：如果有如下两个列表：

list1 = ['name','age','gender']
list2 = ['tom',20,'man']

如何快速合并为一个字典？

字典推导式

字典推导式作用：快速合并列表为字典或提取字典中目标数据，

#创建一个字典：字典key是1-5数字，value是这个数字的2次方
dict1 = {i: i**2 for i in range(1,5)}
print(dict1) #{1:1,2:4,3:9,4:16}

将两个列表合并为一个字典

list1 = ['name','age','gender']
list2 = ['tom',20,'man']

dict1 = {list1[i]:list2[i] for i in range(len(list1))}
print(dict1)

注意：如果两个列表数据个数相同，len统计任何一个列表的长度都可以

​ 如果两个列表数据个数不同，len统计数据多的列表数据个数会报错，len统计数据少的列表数据个数不会报错。

提取字典中目标数据

counts = {'MBP':268,'HP':125,'DELL':201,'Lenovo':199,'acer':99}
#需求;提取上述电脑数量大于等于200的字典数据
count1 ={key : value for key,value in counts.items() if value >= 200 }
print(count1)

集合推导式

需求：创建一个集合，数据为下方列表的2次方

list1 = [1,1,2]
set1 = {i ** 2 for i in list1}
print(set1)

集合有数据去重功能

函数基础

• 函数的作用
• 函数的使用步骤
• 函数的参数作用
• 函数的返回值作用
• 函数的说明文档
• 函数嵌套

函数的作用

需求：用户到ATM机取钱：

1、输入密码后显示"选择功能"界面

2、查询余额后显示“选择功能“界面

3、取2000后显示”选择功能“界面

特点：显示”选择功能“界面需要重复输出给用户，则么实现？

函数的定义：函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。

函数在开发过程中，可以更高效的实现代码重用。

定义函数

def 函数名(参数):
    代码1
    代码2
    ......

调用函数

函数名(参数)

注意:

1.不同的需求，参数可有可无。

2.在python中，函数必须先定义后使用。

案例

1.搭建整体框架(复现需求)

print('密码正确登录成功')

#显示‘选择功能’界面

print('查询余额完毕')

#显示”选择功能“界面

print('取了2000元钱')

#显示”选择功能“界面

2.确定”选择功能“界面

print('查询余额')
print('存款')
print('取款')

3.封装”选择功能“

注意：一定是先定义函数，后调用函数。

#封装ATM机功能选项 -- 定义函数
def select_func():
    print('-----请选择功能-----')
    print('查询余额')
    print('存款')
    print('取款')
    print('-----请选择功能-----')

4.调用函数

在需要显示”选择功能“函数的位置调用函数。

print('密码正确登录成功')
#显示”选择功能“界面 -- 调用函数
select_func()

函数的注意事项

1.不同的需求，参数可有可无。

2.在python中，函数要先定义在使用。

函数的参数作用

思考：完成需求如下：一个函数完成两个数1和2的加法运算，如何书写程序？

# 定义函数
def add_num1():
    result = 1 + 2
    print(result)
    
#调用函数
add_num1()

思考：上述add_num1函数只能完成数字1和2的·加法运算，如果想要这个函数变得更灵活，可以任何用户指定的两个数字的和，如何书写程序？

分析：用户要在调用函数的时候指定具体数字，那么在定义函数的时候就需要接收用户指定的数字，函数调用时候指定的数字和定义函数时候接收的数字即是函数的参数。

#定义函数时同时定义了接收用户数据的参数a和b，a和b是形参
def add_num2(a,b):
    result = a + b
    print(result)
    
#调用函数时传入了真实的数据10和20，真实数据为实参
add_num2(10,20)

函数的返回值作用

例如：我们去超市购物，比如买烟，给钱之后，是不是售货员会返回给我们烟这个商品，在函数中，如果需要返回结果给用户需要使用函数返回值。

def buy():
    return '烟'


#使用变量保存函数返回值
goods = buy()
print(goods)

应用

需求：制作一个计算器，计算任意两数字之和，并保存结果。

def sum_num(a,b):
    return a + b

#用result变量保存函数返回值
result = sum_num(1,2)
print(result)

函数的说明文档

思考：定义一个函数后，程序员如何书写程序能够快速提示这个函数的作用？

答：注释

思考：如果代码多，我们是不是需要在很多代码中找到这个函数定义的位置才能看到注释？如果想更方便的查看函数的作用则么办？

答：函数的说明文档

注意：函数的说明文档也叫函数的文档说明。

语法

help()  #help函数的作用：查看函数的说明文档（函数的解释说明的信息）

def 函数名(参数):                  #表达1
    """说明文档的位置"""
    代码

def 函数名(参数):                #表达2(在多行注释中间打回车自动生成参数说明)
    """
    参数一
    参数二
    说明文档的位置"""
    代码    
help(函数名)

函数嵌套调用

所谓函数嵌套调用指的是一个函数里面又调用了另一个函数

• 示例

def testB():
    print('--- testB start ----')
    print('这里是testB函数执行的代码...(省略)...')
    print('---- testB end----')
        
def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')
    
testA()

打印图形

1.打印一条横线

def print_line():
    print('-' * 20)
    
    
print_line()

2.打印多条横线

def print_line():
    print('-' * 20)
    
def print_lines(num):
    i = 0
    whlie i < num:
        print_line()
        i += 1
print_lines(5)

函数计算

1、求三个数之和

def sum_num(a,b,c):
    return a + b + c


result = sum_num(1,2,3)
print(result)  #6

2、求三个数平均值

def sum(a,b,c):
    return a + b + c
def avg(a,b,c):
    sun = sum(a,b,c)
    return sun / 3
giao = avg(1,2,3)
print(giao)

函数升级

• 变量作用域
• 多函数程序执行流程
• 函数的返回值
• 函数的参数
• 拆包和交换两个变量的值
• 引用
• 可变和不可变类型

变量作用域

变量作用域指的是变量生效的范围，主要分为两类：局部变量和全局变量。

• 局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效。

def testA():
    a = 100
    
    print(a)
    
    
testA()  #100
print(a) #报错：name "a" is not defined

变量a是定义在testA函数内部的变量，在函数外部访问则立即报错。

局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。

• 全局变量

所谓全局变量，指的是在函数体内、外都能生效的变量。

思考：如果有一个数据，在函数A和函数B中都要使用，该则么办？

答：将这个数据存储在一个全局变量里面。

# 定义全局变量a
a = 100


def testA():
    print(a)    #访问全局变量a,并打印变量a存储的数据
    
def testB():
    print(a)  #访问全局变量a,并打印变量a存储的数据
    
    
testA()  #100
testB()  #100

修改全局变量

思考：testB函数需求修改变量a的值为200，如何修改程序？

a = 100

def testA():
    print(a)
    
def testB():
    a = 200
    print(a)
    
testA() #100
testB()  #200
print(f'全局变量a = {a}')  #全局变量a = 100

思考：在testB函数内部的a = 200中的变量a是在修改全局变量a吗？

答：不是。观察上述代码发现，15行得到a的数据是100，任然是定义全局变量a时候的值，而没有返回testB函数内部200.因此：testB函数内部的 a = 200是定义了一个全局变量。

思考：如何在函数体内部修改全局变量？

a = 100

def testA():
    print(a)
    
    
def testB():
    #global 关键字声明a是全局变量
    global a
    a = 200
    print(a)

多函数程序执行流程

一般在实际开发过程中，一个程序往往由多个函数(后面知识中会讲解类)组成，并且多个函数共享某些数据，如下所示:

• 共用全局变量

#1.定义全局变量
glo_num = 0

def test1():
    global glo_num
    #修改全局变量
    glo_num = 100
    
    
def test2():
    #调用test1函数中修改后的全局变量
    print(glo_num)
    
#2.调用test1函数，执行函数内部代码：声明和修改全局变量
test1()
#3.调用test2函数，执行函数内部代码：打印
test2() #100

• 返回值作为参数传递

def test1():
    return 50

def test2(num):
    print(num)
    
#1.保存函数test1的返回值
result =test1()


#2.将函数返回值所在变量作为参数传递到test2函数
test2(result)   #50

函数的返回值

思考：如果一个函数返回两个return（如下所示），程序如何执行？

def return_num():
    return 1
	return 2

result = return_num()
print(result)  #1

答：只执行了第一个return，原因是因为return可以退出当前函数，导致return下方的代码不执行

思考：如果一个函数要有多个返回值，该如何书写代码？

def return_num():
    return 1,2


result = return_num()

注：1.return可以直接返回书写，元组、列表、字典、返回多个值

​ 2.return a,b写法，返回多个·数据的时候，默认是元组类型

函数的参数

位置参数

位置参数：调用函数时根据函数定义的参数位置来传递参数。

def user_info(name,age,gender):
    print(f'您的名字是{name},年龄是{age},性别是{gender}')
    
user_info('TOM',20,'男')

注意：传递和定义参数的顺序及个数必须一致。

关键字参数

函数调用，通过“键=值”形式加以指定。可以让函数更加清晰，容易使用，同时也清楚了参数的顺序需求。

def user_info(name,age,gender):
    print(f'您的名字是{name},年龄是{age}，性别是{gender}')
    
    
user_info('Rose',age=20,gender='女')
user_info('小明',gender='男',age=16)

注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注：所有位置参数必须出现在默认参数前，包括函数定义和调用）

def user_info(name,age,gender='男'):
    print(f'您的名字是{name},年龄是{age}，性别是{gender}')
    
    
user_info('TOM',20)
user_info('Rose',18,'女')

注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值。

不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多个参数(不传参也可以)的场景。此时，可以包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

• 包裹位置传递

def user_info(*args):          #默认*args（底层是这个）但args可以替换
    print(args)
    
#('TOM',)
user_info('TOM')
#('TOM',18)
user_info('TOM',18)

注意;传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple），args是元组类型，这就是包裹位置传递。

• 包裹关键字传递

def user_info(**kwargs):
    print(kwargs)
    
    
    
#('name':'TOM','age':18,'id':110)
user_info('TOM',age=18,id=110)

注意：关键字组包返回是字典类型

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。

拆包和交换变量值

拆包

• 拆包：元组

def return_num():
    return 100,200



num1,num2 = return_num()
print(num1)   #100
print(num2)   #200

• 拆包：字典

dict1 = {'name':'TOM','age':18}
a,b = dict1

#对字典进行拆包，取出来的是字典的key
print(a)   #name
print(b)    #age

print(dict1[a])  #TOM
print(dict1[b])   #18

交换变量值

需求：有变量a = 10 和 b = 20,交换两个变量的值

• 方法一

借助第三变量存储数据。

# 1.定义中间变量
c = 0

#2.将a的数据存储到c
c = a

#3.将b的数据20赋值到a，此时 a = 20
a = b

#4.将之前c的数据10赋值到b，此时b = 10
b = c

print(a)  #20
print(b)  #10

• 方法二

a,b =1,2
a,b = b,a
print(a)
print(b)

引用

在python中，值是靠引用来传递来的。

我们可以用id()来判断两个变量是否为同一个值的引用。我们可以将id值理解为那块内存的地址标识。

• int类型（不可变类型）

#1.int类型(不可变类型) 将独立开辟内存空间存储
a = 1
b = a

print(b) #1

print(id(a))   #140708464157520
print(id(b))   #140708464157520

a = 2
print(b)  #1.说明int类型为不可变类型

• 列表(可变类型)

#2.列表
aa = [10,20]
bb = aa
print(id(aa))  #2500998619656
print(id(bb))  #2500998619656

aa.append(30) 
print(id(aa)) #2500998619656
print(id(bb)) #2500998619656

引用当实参

def test1(a):
    print(a)
    print(id(a))
    
    a += a
    
    print(a)
    print(id(a))
    
#int:计算前后id值不同
b = 100
test1(b)

#列表：计算前后id值相同

c = [11,22]
test1(c)

可变类型和不可变类型

所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能修改那么就是可变，否则是不可变。

• 可变类型
  • 列表
  • 字典
  • 集合
• 不可变类型
  • 整型
  • 浮点型
  • 字符串
  • 元组

函数加强

目标

• 应用：学员管理系统
• 递归
• lambda表达式
• 高阶函数

应用：学员管理系统

系统介绍

需求：进入系统显示系统功能界面，功能如下:

• 添加学员
• 删除学员
• 修改学员信息
• 查询学员信息
• 显示所有学员信息
• 退出系统

系统共6个功能，用户根据自己需求选取。

1.2步骤分析

1.显示功能界面

2.用户输入功能序号

3.根据用户输入的功能序号，执行不同的功能(函数)

​ 3.1 定义函数

​ 3.2 调用函数

总体框架

# 定义功能界面函数
def info_print():
    print('请选择功能.......')
    print('1、添加学员')
    print('2、删除学员')
    print('3、修改学员')
    print('4、查询学员')
    print('5、显示所有学员')
    print('6、退出系统')
    print('-'*20)
# 1.显示界面
while True:
    info_print()
    # 2.按照用户输入的功能
    user_num = int(input('请输入功能序号：'))

    #3、按照用户输入的功能序号，执行不同的功能（函数）
    # 如果用户输入1.执行添加；如果用户输入2.执行删除....
    if user_num == 1:
        print('添加')
    elif user_num == 2:
        print('删除')
    elif user_num == 3:
        print('修改')
    elif user_num == 4:
        print('查询')
    elif user_num == 5:
        print('显示所有学员')
    elif user_num == 6:
        print('退出系统')

1.3需求实现

所有功能函数都是操作学员信息，所有存储所有学员信息应该是一个全局变量，数据类型为列表。

info = []

1.3.1 显示功能界面

定义函数print_info,负责显示系统功能。

# 定义功能界面函数
def info_print():
    print('请选择功能.......')
    print('1、添加学员')
    print('2、删除学员')
    print('3、修改学员')
    print('4、查询学员')
    print('5、显示所有学员')
    print('6、退出系统')
    print('-'*20)
# 1.显示界面
while True:
    info_print()

1.3.2 添加学员

• 需求分析

1、接收用户输入学员信息，并保存

2、判断是否添加学员信息

​ 2.1 如果学员姓名已经存在，则报错提示

​ 2.2如果学员姓名不存在，则准备空字典，将用户输入的数据追加到字典，再列表追加字典数据

3、对应的if条件成立的位置调用该函数

• 代码实现

# 定义添加功能函数
def info_add():
    """添加学员函数"""
    #接收用户输入学员信息
    new_id=input("请输入学号：")
    new_name=input('请输入姓名：')
    new_tel=input("请输入电话：")

    global info   #声明全局变量
    for i in info:      #判断是否重名
        if new_name == i['name']:
            print('此用户存在！')
            return


    info_dict = {}
    info_dict['id'] = new_id
    info_dict['name'] = new_name
    info_dict['tel'] = new_tel

    info.append(info_dict)

1.3.3 删除学员

• 需求分析

按用户输入的学员姓名进行删除

1.用户输入目标学员姓名

2.检查这个学员是否存在

​ 2.1如果存在，则列表删除这个数据

​ 2.2如果不存在，则提示“该用户不存在”

3.对应的if条件成立的位置调用该函数

• 代码实现

#定义删除学员
def info_del():
    """删除学员"""
    del_name = input('请输入要删除的学员的姓名：')

    global info
    for i in info:
        if del_name == i['name']:
            info.remove(i)
            break
    else:
        print('该学员不存在')

    print(info)

1.3.4 修改学员信息

• 需求分析

1.用户输入目标学员姓名

2.检查这个学员是否存在

​ 2.1 如果存在，则修改这位学员信息，例如手机号

​ 2.2 如果不存在，则报错

3.对应的if条件成立的位置调用函数

• 代码实现

#定义修改学员
"""修改学员"""
def info_alt():
    alt_name =input('请输入学员姓名')
    global info
    for i in info:
        if alt_name == i['name']:
            i['tel'] = input("请输入新的手机号")
            break
    else:
        print("该学员不存在")

1.3.5 查询学员信息

• 需求分析

1. 用户输入目标学员姓名

2. 检查学员是否存在

   2.1 如果存在，则显示这个学员的信息

   2.2 如果不存在，则报错提示

3. 对应的if条件成立的位置调用该函数

• 代码实现

#查询学员信息

def info_find():
    """查询学员"""
    find_name = input('请输入要查找的学员姓名：')
    global info
    for i in info:
        if find_name == i["name"]:
            print('查询到的信息如下......')
            print(f"学员的学号是{i['id']},姓名是{i['name']},手机号是{i['tel']}")
            break
    else:
        print('查无此人')    

1.3.6 显示所有学员信息

• 需求分析

打印所有学员信息

• 代码实现

#显示所有学员信息
def info_printall():
    """显示所有学员信息"""
    print('学号\t姓名\t手机号')
    for i in info:
        print(f"{i['id']}\t{i['name']}\t{i['tel']}")

1.3.7 退出系统

在用户输入功能序号6的时候要退出系统，代码如下：

    elif user_num == 6:
        info_exit = input('确定要退出程序吗？yes退出no不退出')
        if info_exit == 'yes':
            break

1.3.8 完整代码

info = []

# 定义功能界面函数
def info_print():
    print('请选择功能.......')
    print('1、添加学员')
    print('2、删除学员')
    print('3、修改学员')
    print('4、查询学员')
    print('5、显示所有学员')
    print('6、退出系统')
    print('-'*20)



# 定义添加功能函数
def info_add():
    """添加学员函数"""
    #接收用户输入学员信息
    new_id=input("请输入学号：")
    new_name=input('请输入姓名：')
    new_tel=input("请输入电话：")

    global info   #声明全局变量
    for i in info:      #判断是否重名
        if new_name == i['name']:
            print('此用户存在！')
            return

    info_dict = {}
    info_dict['id'] = new_id
    info_dict['name'] = new_name
    info_dict['tel'] = new_tel

    info.append(info_dict)


#定义删除学员
def info_del():
    """删除学员"""
    del_name = input('请输入要删除的学员的姓名：')

    global info
    for i in info:
        if del_name == i['name']:
            info.remove(i)
            break
    else:
        print('该学员不存在')

    print(info)

#定义修改学员
"""修改学员"""
def info_alt():
    alt_name =input('请输入学员姓名')
    global info
    for i in info:
        if alt_name == i['name']:
            i['tel'] = input("请输入新的手机号")
            break
    else:
        print("该学员不存在")

#查询学员信息

def info_find():
    """查询学员"""
    find_name = input('请输入要查找的学员姓名：')
    global info
    for i in info:
        if find_name == i["name"]:
            print('查询到的信息如下......')
            print(f"学员的学号是{i['id']},姓名是{i['name']},手机号是{i['tel']}")
            break
    else:
        print('查无此人')

#显示所有学员信息
def info_printall():
    """显示所有学员信息"""
    print('学号\t姓名\t手机号')
    for i in info:
        print(f"{i['id']}\t{i['name']}\t{i['tel']}")

# 1.显示界面
while True:
    info_print()
    # 2.按照用户输入的功能
    user_num = int(input('请输入功能序号：'))

    #3、按照用户输入的功能序号，执行不同的功能（函数）
    # 如果用户输入1.执行添加；如果用户输入2.执行删除....
    if user_num == 1:
        info_add()
    elif user_num == 2:
        info_del()
    elif user_num == 3:
        info_alt()
    elif user_num == 4:
        info_find()
    elif user_num == 5:
        info_printall()
    elif user_num == 6:
        info_exit = input('确定要退出程序吗？yes退出no不退出')
        if info_exit == 'yes':
            break
    else:
        print("输入的功能序号有误")

递归函数和匿名函数

递归

1、递归的应用场景

递归是一种编程思想，应用场景：

1. 在我们日常开发中，如果要遍历一个文件夹下面所有的文件，通常会使用递归来实现；
2. 在后续的算法课程中，很多算法都离不开递归，例如：快速排序。

2、递归的特点

• 函数的内部自己调用自己
• 必须有出口

3、应用：3以内数字累加和

• 代码

# 3 + 2 + 1
def sum_numbers(num):
    # 1.如果是1，直接返回1 -- 出口
    if num == 1:
        return 1     #return的作用：返回值、退出函数
    # 2.如果不是1，重复执行累加并返回结果
    return num + sum_numbers(num-1)

sum_result = sum_numbers(3)
#输出结果为6
print(sum_result)

lambda表达式

lambda的应用场景

如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化。

lambda语法

lambda 参数列表 : 表达式

• lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。
• lambda表达式能接收任何数量的参数但只能返回一个表达式的值。

应用

def fn1():
    return 100

ws =fn1()
print(ws)

wq = lambda:200
print(wq())

注意:直接打印lambda表达式，输出的是此lambda的内存地址

应用：计算a+ b

def add(a,b):
    return a + b
print(add(1,2))


aq =lambda a,b:a+b
print(aq(1,2))

lambda的参数形式

• 无参数

wq =lambda:100
print(wq())

• 一个参数

wq =lambda i : i
print(wq('hello python'))

• 默认参数

wq =lambda a,b,c=100:a+b+c
print(wq(10,20))

• 位置可变参数：*args(返回元组)

wq = lambda *args: args
print(wq(10,20,30))

• 关键字可变参数：**kwargs（返回字典）

wq = lambda **kwargs: kwargs
print(wq(name='python',giao='1234'))

lambda的应用

带判断的lambda

wq = lambda a,b: a if a > b else b
print(fn1(1000,500))

列表数据按字典key的值排序

students =[
    {'name':'TOM','age':20},
    {'name':'giao','age':17},
    {'name':'jack','age':22}
]
#1.name key对应的值进行升序排序
students.sort(key=lambda x:x['name'])

#2.name key对应的值进行降序排序
students.sort(key=lambda x:x['name'],reverse=True)

#3.age key对应的值进行排序
students.sort(key=lambda x:x['age'])

高阶函数

把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式

体验高阶函数

在python中，abs()函数可以完成对数字求绝对值计算。

abs(-10)  #10

round()函数可以完成对数字的四舍五入计算。

round(1.2)  #1
round(1.9)   #2

需求：任意两个数字，按照指定要求整理数字后再进行求和计算。

• 方法1

def add_ num(a,b):
    return abs(a) + abs(b)

result = add_num(-1,2)
print(result)  #3

• 方法2

def sum_num(a,b,f):
    return f(a) +f(b)

result = sum_num(-1,2,abs)
print(result)  #3

注意：两种方法对比之后，发现，方法2的代码会更加简洁，函数灵活性更高。函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。

内置高阶函数

map()

map(func,lst),将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表(python2)/迭代器（python3）返回。

需求：计算list1序列中各个数字的2次方。

list1  = [1,2,3,4,5]


def func(x):
    return x ** 2

result = map(func,list1)

print(result)  #<map object at 0x000001A0FFE8E7F0>
print(list(result))  #[1,4,9,16,25]

reduce()

reduce(func,lst),其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累计计算。

注意：reduce()传入的参数func必须接收2个参数。

需求：计算list1序列中各个数字的累加和。

import functools

list1 = [1,2,3,4,5]

def func(a,b):
    return a + b

result = functools.reduce(func,list1)

print(result) #15

filter()

filter(func,lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list()来转换。

list1 = [1,2,3,4,5,6,7,8,9,10]

def wqw(x):
    return x%2==0

result = filter(wqw,list1)
print(list(result))

文件操作

• 文件操作的作用
• 文件的基本操作
  • 打开
  • 读写
  • 关闭
• 文件备份
• 文件和文件夹的操作

文件操作的作用

总结：文件操作的作用就是把一些内容（数据）存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力。

文件的基本操作

文件操作步骤

1、打开文件

2、读写等操作

3、关闭文件

注意：可以只打开和关闭文件，不进行任何读写操作。

打开

在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件，语法如下：

open(name,mode)

name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。

mode:设置打开文件的模式（访问模式）：只读，写入、追加等。

打开文件模式

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

阶函数

在python中，abs()函数可以完成对数字求绝对值计算。

abs(-10)  #10

round()函数可以完成对数字的四舍五入计算。

round(1.2)  #1
round(1.9)   #2

需求：任意两个数字，按照指定要求整理数字后再进行求和计算。

• 方法1

def add_ num(a,b):
    return abs(a) + abs(b)

result = add_num(-1,2)
print(result)  #3

• 方法2

def sum_num(a,b,f):
    return f(a) +f(b)

result = sum_num(-1,2,abs)
print(result)  #3

注意：两种方法对比之后，发现，方法2的代码会更加简洁，函数灵活性更高。函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。

内置高阶函数

map()

map(func,lst),将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表(python2)/迭代器（python3）返回。

需求：计算list1序列中各个数字的2次方。

list1  = [1,2,3,4,5]


def func(x):
    return x ** 2

result = map(func,list1)

print(result)  #<map object at 0x000001A0FFE8E7F0>
print(list(result))  #[1,4,9,16,25]

reduce()

reduce(func,lst),其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累计计算。

注意：reduce()传入的参数func必须接收2个参数。

需求：计算list1序列中各个数字的累加和。

import functools

list1 = [1,2,3,4,5]

def func(a,b):
    return a + b

result = functools.reduce(func,list1)

print(result) #15

filter()

filter(func,lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list()来转换。

list1 = [1,2,3,4,5,6,7,8,9,10]

def wqw(x):
    return x%2==0

result = filter(wqw,list1)
print(list(result))

文件操作

• 文件操作的作用
• 文件的基本操作
  • 打开
  • 读写
  • 关闭
• 文件备份
• 文件和文件夹的操作

文件操作的作用

总结：文件操作的作用就是把一些内容（数据）存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力。

文件的基本操作

文件操作步骤

1、打开文件

2、读写等操作

3、关闭文件

注意：可以只打开和关闭文件，不进行任何读写操作。

打开

在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件，语法如下：

open(name,mode)

name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。

mode:设置打开文件的模式（访问模式）：只读，写入、追加等。

打开文件模式

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。