《Python》3小时期末速成课笔记

BIlibili地址

基本语法

• 变量与数据类型
• 表达式

变量

• 指向对象的值的名称就是变量，也就是一种标识符，是对内存中的存储位置的命名。

• 对于不同的对象，有不同的类型，得到的内存地址也不一样，通过对得到的地址进行命名得到变量名称，我们将数据存入变量，为存储的数据设置不同的数据结构。

• 变量的值是在不断的动态变化的，Python的变量可以不声明直接赋值使用。由于Python采用动态类型（Dynamic Type），变量可以根据赋值类型决定变量的数据类型

• ==在Python中，变量使用等号赋值以后会被创建，定义完成后可以直接使用==，

• 变量命名规则:

  名称第一字符为英文字母或者下划线

  名称不能使用python的关键字或保留字符

  名称第一字符后可以使用英文字母、下划线和数字

  名称区分大小写，单词与单词之间使用下划线连接

数据类型

Python有可以自由的改变变量的数据类型的动态类型和变量事先说明的==静态类型==，特定类型是数值数据存入相应的数据类型的变量中，相比下，动态数据类型更加灵活。

变量的数据类型有多种类型，Python3中有六个标准的数据类型:

• Numbers（数字类型）
• Strings（字符串类型）
• Lists（列表类型）
• Tuples（元组类型）
• Dictionaries（字典类型）
• Sets（集合类型）

Python内置的数字类型有==整型（Integers）、浮点型（Floating point numbers）和复数（Complex numbers）==三种，作为可以进行算术运算等的数据类型。

可以使用type()函数来查看数据类型

>>> type(1)
<class 'int'>
>>> type('11')
<class 'str'>

1. 整型（Integers）
   整数类型(int)简称为整型，表示整数，包括正负的整数，如:0110、-123123456789。

   Python的整型是长整型，能表达的数的范围是无限的，内存足够大，就能表示足够多的数。在使用整型的数还包括其它进制，0b开始的是二进制(binary)，0o开始的是八进制(octonary)，0x开始的十六进制(hexadecimal)，进制之间可以使用函数进行转换，使用时需要注意数值符合进制。

2. 布尔型（Booleans）

   布尔值是整型(Integers)的子类，用于逻辑判断真(True)或假(False)用数值1和0分别代表常量True和False。

   在Python语言中，False可以是数值为0、对象为None或者是序列中的空字符串空列表、空元组。

3. 浮点型（Float）

   浮点型(Float)是含有小数的数值，用于实数表示，由正负号、数字和小数点组成，正号可以省略。如：-3.0、0.13。8个字节一个浮点，范围-1.8308~+1.8308的数均可以表示。

4. 复数型（Complex）

   复数类型(Complex)由实数和虚数组成，用于复数的表示，虚数部分需加上j或J，如：-1j、0j，1.0j。Python的复数类型是其他语言一般没有的。

5. 字符串类型（Strings）

   字符串(Strings)，在Python 中的字符串是一种对象类型，使用str表示，通常单引号’或者双引号””包裹起来。如果不想让反斜杠发生转义，可以在字符串前加个r表示原始字符串，加号+是字符串的连接符，星号*表示复制当前的字符串，紧跟的数字为复制的次数。

   字符串是字符的序列，可以按照单个字符或字符片段进行索引

   字符串包括两种序号体系:

   • 正向递归序列
   • 反向递归序列

   

算数运算符

算术运算符主要是用于数字类型的数据基本运算，Python支持直接进行计算，也就是可以将python shell当计算器来使用。

运算符	说明	表达式	结果
+	加	10 + 24	34
-	减	10 -2	8
*	乘	12 * 2	24
/	除	34/10	3.4
%	取模：余数	34%10	4
**	幂	2 ** 4	16
//	取整数：返回商数整数部分	34 // 10	3

>>> 10 + 24
34
>>> 10 - 2
8
>>> 12 * 2
24
>>> 34 / 10
3.4
>>> 34 % 10
4
>>> 2 ** 4
16
>>> 34 // 10
3

逻辑运算符

逻辑运算符为and（与）、or（或）、not（非）用于逻辑运算判断表达式的True或者False，通常与流程控制一起使用

• and：表达式一边有False 就会返回False，当两边都是True时返True .
• or：表达式一边True 就会返回 True，当两边都是False 时返回 False。
• not：表达式取反，返回值与原值相反。

复合赋值运算符

复合赋值运算符时将一个变量参与运算的运算结果赋值给改变量，即a参加了该运算，运算完成后结果赋值给a

运算符	说明	表达式	等效表达式
=	直接赋值	x = y + z	x = y + z
+=	加法赋值	x += y	x = x + y
-=	减法赋值	x -= y	x = x - y
*=	乘法赋值	x *= y	x = x * y
/=	除法赋值	x /= y	x = x / y
%=	取模赋值	x %= y	x = x % y
**=	幂赋值	x **= y	x = x ** y
//=	整除赋值	x //= y	x = x // y

算数运算符优先级

由数值、变量、运算符组合的表达式和数学上相同，是有运算符优先级的，优先级高的运算符先进行运算同级运算符，**自左向右运算，遵从小括号优先原则。等号的同级运算时例外，一般都是自右向左进行运算**。

组合数组类型

• 列表
• 元组
• 字符串
• 字典
• 集合

组合数据类型

• 序列类型
  • 列表 list
  • 元组 tuple
  • 字符串 string
  • **序列类型**是一个元素向量，元素之间存在先后关系，通过索引访问，元素之间不排他
• 集合类型：集合 set
  • **集合类型**是一个元素集合，元素之间无序，相同元素在集合中唯一
• 映射类型：字典dict
  • **映射类型**是“键-值”数据项的组合，每个元素是一个键值对

**组合数据类型能够将多个同类型或不同类型的数据组织起，通过单一的表示使数据操作更有序、更容易**。

序列

Python中“序列”的概念

• 在Python中，序列是最基本的数据结构;
• 序列中的每个元素都被分配一个数字，以表明它的位置，并称之为==索引==。其中，第一个索引值为0，第二个索引值为1，依此类推。
• Python中的序列都可以进行==索引、切片、加、乘、检查成员==等操作。为了使用方便Python还内建了确定序列的长度len()以及确定最大max()和最小min()元素的方法。
• Python中最常用的序列是==列表、元组和字符串==。

列表

列表的概念

• List用来存储任意大小的数据集合。
• 一个列表中可以包含任意个数据，每个数据称为元素。
• 列表是Python中使用最频繁的数据类型，它是放在方括号([])内、用逗号分隔的一系列元素。
• 列表中元素的==类型可以不同==，它支持数字、字符串甚至可以包含列表。换言之，列表允许嵌套。

list1  # 创建一个空列表
list2 = [1,2,3,4,5]  # 创建带有初始值的列表
list3 = ['a', 'b', 'c', 'd']
list4 = [0] * 10   # 长度为10,每个元素为0
list5 = [1,3.14, 'hi']  # 列表可以包括不同类型的元素,但不推荐这种写法
list6 = [float('inf')] * len(nums)

# 使用 list类的构造函数来创建
lsit1 = list()
list2 = list([1,2,3,4,5]) # 创建带有初始值的列表

# 可以使用len()函数 来获取长度
length = len(list2)

# list() 可以将任何可迭代的数据转换成列表
lst = list('python')

# 控制台
>>> lst = list('python')
>>> lst
['p', 'y', 't', 'h', 'o', 'n']
>>> lst = list(range(5))
>>> lst
[0, 1, 2, 3, 4]

# 列表的访问
list2 = lsit([1,2,3])
var = list2[0] + list2[2]
# 一般地，负数下标的有效范围介于-1和-len(列表变量)之间
var = list2[0] + list2[-1] # 负数下标

# 列表的切片 lsit[start:end]  左闭右开
# 起始下标和结束下标可以省略。
# 如果省略起始下标，则起始下标默认为0;如果省略结束下标，则结束下标默认为列表长度，即截取到列表的最后一个元素
list1 = [1,2,3,4,5]
list2 = [:2]  # [0:2]
list3 = [3:]   # [3:5]
>>> list1 = [1,2,True,4,5]
>>> list1[2]
True
>>> list1[2:3]  # 注意,2:3 是返回一个数组,并里面只有一个内容
[True]

# 带步长的切片 list[start:end:step]
'''
step:正负数均可，其绝对值大小决定了切取数据时的“步长”，而正负号决定了“切取方向”正表示“从左往右”取值，负表示“从右往左”取值。当step省略时，默认为1，即从左往右以增量1取值。
'''
>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[1:6]   # step=1,从左往右取值
[1, 2, 3, 4, 5]
>>> a[2:6:2]   # step=2,从左往右取值
[2, 4]
>>> a[6:2:2]  # step=2,从左往右取值
[]
>>> a[-2:-6:-2]  # step=-2,从右往左取值
[8, 6]

列表的内置函数

函数	说明
len(listname)	返回列表的元素数量
max(listname)	返回列表中元素的最大值
min(listname)	返回列表中元素的最小值
list(tuple)	将元素转换为列表

函数	说明
lsit.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列的多个值
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index,obj)	将对象插入列表
list.pop(obj=list[-1])	移除列表中的一个元素（默认是最后一个），并返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	将列表中的元素反向
lsit.sort([func])	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表

元组

Python 的元组与列表相似，不同之处在于==元组的元素是不能修改的==。

当创建不同类型的数据时，推荐使用元组来创建

元组的创建

# 在括号中添加元素,并用逗号分隔元素
tup1 = ('Google', 'Runoob', 1997, 2017)
tup2 = (1,2,3,4,5)
tup3 = ('a','b','c','d')
# 创建空元组
tup = ()
# 创建只包含一个元组时,需要在元组后面添加逗号
tup = (50,)

# 使用 Tuple类的构造函数 tuple()
tup1 = tuple()
tup2 = tuple((1,2,3,4,5))
# 元组的下标索引也从0开始,而且也可以进行截取、组合等操作

元组的访问

使用下标索引来访问元组中的值

>>> tup1 = ('Google', 'Runoob', 1997, 2017)
>>> tup2 = (1,2,3,4,5)
>>> print('put1[0]: ', tup1[0])
put1[0]:  Google
>>> print('put2[1:5]: ', tup2[1:5])
put2[1:5]:  (2, 3, 4, 5)

元组的修改

元素中的元素值是**不允许修改**的，但可以对元组进行连接拼接组合

>>> tup1 = (12,34.55)
>>> tup1[0] = 100
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

元组的删除

元素中的元素值是**不允许删除**的，但可以使用del语句删除整个元组

>>> tup1 = ('Google', 'Runoob', 1997, 2017)
>>> del tup1
>>> print(tup1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'tup1' is not defined

元组的内置函数

方法	说明
len(tuple)	个数
max(tuple)	最大值
min(tuple)	最小值
tuple(seq)	将列表转换为元组

元组和列表都属于序列

列表为==可变序列==，可以**随意修改列表汇总的元素值，增加、删除**元素;

元组为==不可变序列==，元组中的元素**一旦定义就不允许进行增、删和替换操作。元组的访问和处理速度比列表更快。如果所需要定义的序列内容不会进行修改**，那么最好使用元组。另外，使用元组也可以使元素无法被修改，从而使代码更安全。

字符串

字符串的创建

var1 = 'hello'
var2 = "hello python"
var3 = str('hello')  # 使用str类的构造函数
# Python的三引号(三个单引号或三个双引号均可)用于字符串跨多行，字符串中可以包含换行符、制表符以及其它特殊字符。
para_str = '''
多行字符串
可以使用制表位
TAB(\t)
也可以使用换行符[\n]。
'''

字符串中值的访问

Python不支持字符类型。即使是单个字符，Python也将其视为一个字符串来使用访问子串，实际上就是用方括号来截取字符串，有的文献称之为“切片运算”

str1 = '0123456789'
str1[0:3]  # 0~2, 012
str1[:]    # all,全部
str1[6:]   # 获取6之后的 6789
str1[:-3]  # 从后面数第三个 之前的所有字符串,0~6
str1[2]    # 单个字符串 2
str1[-1]   # 最后一位
str1[::-1]  # 反序 9~0
str1[-3:-1] # 倒数第三与数第一前一个字符 78 
str1[-3:]   # 倒数第三到最后 789
str1[:-5:-3] # 96  逆序截取

python中的转义字符

当字符串中需要使用特殊字符时，可在特殊字符前冠以反斜杠()，形成转义字符。Python的转义字符如下表所示。

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\b	退格
\000	空
\n	换行
\r	回车

字符串内置函数

方法	描述
capitalize()	将字符串的第一个字符转换为大写
center(width,fillchar)	返回一个指定的宽度width居中的字符串,fillchar为填充的字符串，默认是空格
lower()	转换字符串中所有大写字母为小写
upper()	转换字符串中所有小写字母为大写
swapcase()	将字符串中大写转换为小写，小写转换为大写
find(str, beg=0,end=len(string))	检测str是否包含在字符串中，如果用beg和end指定范围，则检查是否包含在指定的范围内，如果是，则返回开始的索引值，否则返回-1
index(str,beg=0,end=len(string))	跟find()方法一样，只不过如果str不在字符串中，则会报一个异常。
count(str,beg=0,end=len(string))	返回 str 在 string 里面出现的次数，如果指定 beg 或者 end，则返回指定范围内 str 出现的次数。
len(string)	返回字符串长度
rstrip()	删除字符串末尾的空格
lstrip()	截掉字符串左边的空格

字典

字典的观念

允许查找与任意键相关联的信息的集合称为“映射”。Python的字典是映射。

Python的字典是一种可变容器模型，且可以存储任意类型对象。

字典的创建

字典中的每个项都是“==键/值对==”,“键”与“值”之间用冒号(==:==)分割，而每个“对”之间用逗号(==,==)分割，整个字典放在花括号({})中。

d = {key1: value1, key2: value2, key3: value3}

对每个键/值对而言，==键必须是唯一的，且不可变==，如字符串、数字或元组均可作为键，但列表不可以。值可以取任何数据类型，但值可以改变。

使用dict类的构造函数dict()创造

dict1 = dict({"Tom": '123456789', 'Amy': '23456789'})

字典元素的访问

以“键”通过下表来返回“值”

dict2 = {'香蕉':20, '苹果':50}
print(dict2["香蕉"])  # 20

元素在字典中的排列顺序是随机的，与输入的顺序不一定相同，所以不能用位置作为下标。

访问字典元素时，如果输入的“键”不存在，也会产生错误。

字典元素的添加与修改

dict1 = {'Name': 'Taichi', 'Age': 7, 'Class': 'First'}
dict1['Age'] = 8   # 更新 Age
dict1['School'] = 'XG'  # 添加信息

字典的遍历

使用for循环可以遍历一个字典。遍历得到的是字典的==关键字==。

为遍历出整个字典对象，在for循环体中，使用==以“关键字”作为下标来返回“值”==。

dict1 = {'Name': 'Taichi', 'Age': 7, 'Class': 'First'}
for key in dict1:
	print(key, ': ', dict1[key])

字典键的特性

字典的“**值”可以取任何Python对象，没有任何限制，它既可以是标准对象，也可以是用户自己定义的对象，但“键**”不行。

关于字典的键，有两点必须牢记:

1. 同一个键不得出现两次。创建字典时如果一个值被赋值两次，则后一个值被记住
2. 键必须不可变。可以用数字、字符串或元组做键，用列表则不行

字典的内置函数

• len(dict)

  # 计算字典元素个数,即键的总数
  dict1 = {'Name': 'Taichi', 'Age': 7, 'Class': 'First'}
  len(dict1)  # 3

• str(dict)

  dict2 = {'Name': 'Taichi', 'Age': 7, 'Class': 'First'}
  str(dict2)  # 输出字典,以可打印的字符串表示
  "{'Name': 'Taichi', 'Age': 7, 'Class': 'First'}"

• type(variable)

  # 返回输入的遍历类型,如果变量是字典就返回字典类型
  dict1 = {'Name': 'Taichi', 'Age': 7, 'Class': 'First'}
  type(dict1) # <class 'dict'>

函数	描述
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict.fromkeys(seq[,value])	创建一个新字典，以序列seq中的元素作为字典的键，value为字典所有键对应的初始值
def.get(key, default=None)	反之指定键的值，如果值不存在字典返回 default
key in dict (in 操作数)	如果键在字典dict里，则返回 True，否则返回 False
dict.items()	以列表返回可遍历的（键，值）元组数组
dict.keys()	返回所有的键
dict.values()	返回一个迭代器，可以使用list() 来转换为列表，列表为字典中的所有值
dict.update(dict2)	把字典dict的键/值对 更新到dict里

集合

集合的概念

集合(set)是Python的基本数据类型，把==不同的元素==组合在一起便形成了集合。组成一个集合的成员称作该集合的元素(element)。

集合分为两类:**可变集合(set)，不可变集合(frozenset)**。

可变集合(set)可添加和删除元素，是非可哈希的，不能用作字典的键，也不能做其他集合的元素。
不可变集合(frozenset)与之相反。

创建

可变集合的创建

set1 = {'apple', 'banana', 'orange'}
# 创建空集合
set2 = set()
# 使用set函数将列表、元组、字符串转为集合
set3 = set([1,2,3])

==在一个集合中不能有相同的元素。相同的元素会被自动删除==

不可变集合创建

创建不可变集合应使用 frozenset()函数，不能使用大括号

不可变集合不能被修改

集合的遍历

因集合是无序的，不能使用索引来访问集合中的元素。可使用for循环可以遍历一个集合。

set1 = {'apple', 'banana', 'orange'}
for var in set1:
    print(var)

• 元素访问的顺序依赖于它们在内部是如何存储的。输出中元素的顺序与创建集合时的顺序是不同的
• 无序使得可以实现高效的集合操作

增加和删除集合元素

• 如果要增加的元素**没包含在集合中，它会被增加到集合中并且集合的大小加1;**
• 如果要增加的元素**包含在集合中，则添加操作不会有效果**，集合没有被修改。
• 如果元素存在，discard 方法会删除它，但是如果元素不是集合成员时，则不会有效果。
• clear方法删除集合中的所有元素，留下一个空集合

set1 = {'apple', 'banana', 'orange'}
set1.add('pear')      # 添加 pear
set1.discard('apple') # 删除 apple
set1.clear()          # 清空

集合运算

交集操作符“&”有一个与之等价的方法intersection()

并集操作符“|”有一个与之等价的方法union()

差集操作符“-”与之等价的方法是difference()

a.difference(b): 返回一个包含那些属于集合a但不属于集合b的元素的新集合

>>> set1 = set([1,2,3,4])
>>> set1
{1, 2, 3, 4}
>>> set2 = {3,4,5,6}
>>> set1 | set2
{1, 2, 3, 4, 5, 6}
>>> set1 & set2
{3, 4}

>>> set2 = {2,3}
>>> set1
{1, 2, 3, 4}
>>> set1 - set2
{1, 4}

内置函数

1. len()：返回集合元素的个数
2. set()、frozenset()：创建集合
3. 适合所有集合的方法（见下表）

方法	操作
s.issubset(t)	如果s是t的子集，则返回True，否则返回False
s.issuperset(t)	如果s是t的超集，则返回True，否则返回False
s.union(t)	返回s和t的并集
s.intersection(t)	返回s和t的交集
s.difference(t)	s - t，把s中所有的t减去
s.symmetric_difference(t)	s和t并集，然后删除交集
s.copy()	s的浅复制

仅适合可变集合的方法

方法名称	操作
s.update(t)	用t中的元素修改s，即s现在包含s或t的成员。
s.intersection_updata(t)	s中的成员是共同属于s和t中的元素。
s.difference_updata(t)	s中的成员是属于s但不包含在t中的元素。
s.symmetric_difference_updata(t)	s中的成员更新为那些包含在s或t中，但不是s和t共有的元素。
s.add(obj)	在集合s中添加对象obj
s.remove(obj)	从集合s中删除对象obj，如果obj不是集合s中的元素(obj not in s)将引发KeyError错误。
s.discard(obj)	如果obj是集合s中的元素，从集合s中删除对象obj。
s.pop()	删除集合s中的任意一个对象，并返回它。
s.clear()	删除集合s中的所有元素。

集合和列表都可以存储多个元素，两者不同:

• 集合**不能存储重复的元素**
• 集合中的元素是**无序的，不能通过下标**运算符来访问元素
• 集合还支持如何判断集合关系以及四种集合运算
• **列表的存储方式为顺序存储，而集合采用的存储方式更加复杂。这使得在执行查找元素和删除元素的操作时，使用集合比使用列表的效率高**。

【例】编写程序，统计文本中只出现一次的单词（不考虑文本中的特殊字符，默认英文单词均为小写）

text = input('Please input a text here:')
words = text.split()  # 默认空格分割
word_count = set()
word_dis = set()  # 多次出现的单词
for word in words:
    if word in word_count:
        word_dis.add(word) # 删除多次出现的
    else:
        word_count.add(word)  # 保存第一次出现的单词
wordss = word_count - word_dis  # 把出现多次的单词清理掉
for word in wordss:
    print(word)

控制流程

• 选择结构控制
• 循环结构控制

选择结构-if语句

单分支

if bool:
    pass

双分支

if bool:
    pass
else:
    pass

多分支

if bool1:
    pass
elif bool2:
    pass
elif bool3:
    pass
else:
    pass

练习题

例:体型判断。按“体指数”对肥胖程度进行划分

体指数t=体重w/(身高h)2

(w 单位为公斤，h单位为米)

# BMI=体重÷身高的平方
width = eval(input('请输入你的体重:'))  # 公斤
height = eval(input('请输入你的身高:')) # 米

bmi = width / (height * height)
print("BMI: ", format(bmi, '.2f'))
if bmi < 18:
	print('太瘦了')
elif bmi <= 25:
	print('正常')
elif bmi <= 27:
	print('超重了')
else:
	print('肥胖')

if三元运算符

X if bool else Y，当bool为True的时候，返回X，False 返回 Y

x,y = 4,6
bigger = x if x > y else y
print(bigger)

循环结构控制

while语句

while True:
    pass

# while 中的 else 语句
cou = 0
while con <= 3:
    print(cou, '小于或等于3')
else:
    print(cou,'大于3')

for语句

# 1~100 累加和
x = 0
for i in range(101):  # 左闭右开
    x += i
print(x)

break和continue

break 退出循环（终止循环）

continue 退出本次循环

return 函数体结束

函数与模块

• 函数的概述
• 函数的参数和返回值
• 函数的调用
• 模块

函数的定义

一个程序可以按不同功能实现拆分成不同模块，而函数就是能实现某一部分功能的代码块。

Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号内参数和冒号(:)，然后在缩进块中编写函数体，函数的返回值用return语句返回。

注意：==Python是靠缩进块来标明函数的作用域范围的，缩进块内是函数体，这和其它高级编程语言是有区别的，比如:C/C++/iavaR语言大括号{}内的是函数体==。

def max(num1: int, num2: int) -> int:
    return num1 if num1 > num2 else num2  # 三元表达式,返回最大值

全局变量

在函数外面定义的变量称为全局变量。全局变量的作用域在整个代码段(文件、块)，在整个程序代码中都能被访问到。在函数内部可以去访问全局变量。如下所示代码:

global_var = 30

def modify_var():
    # 这里定义了一个局部变量，与全局变量同名
    global_var = 40
    print("Inside function:", global_var)  # 输出：Inside function: 40

modify_var()
print("Outside function:", global_var)  # 输出：Outside function: 30

如果要在**函数内部去修改全局变量的值**，并使之在整个程序生效，采用关键字global即可。

局部变量

在函数内部定义的参数和变量称为局部变量，超出了这个函数的作用域局部变量是无效的，它的作用域仅在函数内部。如下所示代码:

# 定义一个全局变量
total_score = 0

def add_score(score):
    # 定义一个局部变量
    local_score = score
    print(f"Local score: {local_score}")
    
    # 修改全局变量
    global total_score
    total_score += local_score
    print(f"Total score: {total_score}")

# 调用函数，传入分数
add_score(85)  # 输出：Local score: 85, Total score: 85
add_score(90)  # 输出：Local score: 90, Total score: 175

# 在函数外部访问全局变量
print(f"Final total score: {total_score}")  # 输出：Final totalscore: 175

一个python表达式可以访问局部命名空间和全局命名空间里的变量。如果**一个局部变量和一个全局变量==重名==，则局部变量会覆盖全局变量**。

x = 1  # 全局变量
def fun():
    x = 2  # 局部变量
    print(x)  # 2
fun()
print(x)   # 1

函数的参数和返回值

参数传递的方式

在Python中，将函数参数分为三类:位置参数、**可变参数、关键字参数**。

1. 位置参数

   直接传入**参数数据即可**，如果有多个参数，位置先后顺序不能改变

2. 可变参数

   有2种传递方式:

   1是直接传入参数值;

   2是先封装成列表(list)或元组(tuple)，再在封装后的列表或元组前面添加一个星号“*”传入。

3. (3)关键字参数

   有2种传递方式:

   1是直接传入参数值;

   2是可以先将参数封装成字典(dict)，再在封装后的字典前添加2个星号“**”传入

# 位置参数和关键字参数
def Sub(x,y):
    return x-y
Sub(20,10)  # 位置参数
Sub(x=20, y=10) # 关键字参数

# 默认值参数
def fun(num1=99, num2=50):
    return (num1-num2)
fun()  # 使用默认参数 返回49
fun(55)  # x=55,y是默认50,返回 5
fun(20,10)  # 10

# 可变参数
'''当在定义函数参数的时候，我们不知道究竟需要多少个参数的时候，只要在参数前面加上星“*”即可，这样的参数称为可变参数。如下所示代码:'''
def var_par(*param):
    print('第三个参数是:', param[2]) # 10
    print('可变长度是:', len(param))  # 5
var_par('taichi', 23, 6, 10,7, 'python')

函数返回值

没有return指定返回值，则返回的是一个None对象

return ['taichi', 10]，返回一个数组

return 'taichi',10，返回的是一个 tuple

函数的调用

函数的调用方法

要调用一个函数，需要知道**函数的名称和参数**。

函数分为**自定义函数和内置函数**。

自定义函数需要先定义再调用，内置函数直接调用，有的内置函数是在特定的模块下，这时需要用import命令导入模块后再调用

调用函数的时候，如果传入的**参数数量不对，会报TypeError的错误，同时Python会明确地告诉你参数的个数。如果传入的参数数量是对的，但参数类型不能被函数所接受**，也会报TypeError的错误，同时给出错误信息。

函数名其实就是指向一个函数对象的引用，可以把函数名赋给一个变量。

嵌套调用

**允许在函数内部创建另一个函数，这种函数叫内嵌函数或者内部函数。**内嵌函数的作用域在其内部，如果内嵌函数的作用域超出了这个范围就不起作用。如下所示代码:

def outer_function():
    print("这是外部函数")

    def inner_function():
        print("这是内部函数")
 
    inner_function() # 这是内部函数

# 调用外部函数
outer_function()
# 调用内函数, 报错, 函数名未定义
inner_function()

递归调用

函数调用自身的行为是递归。

递归的2个条件：调用函数自身，设置了正确的返回条件。递归即是有进去必须有回来

Python默认递归深度100层(Python限制)。

设置递归的深度的系统函数是：sys.setrecursionlimit(stepcoun)。参数：stepcount设置递归的深度。

递归有危险性：消耗时间和空间，因为递归是基于弹栈和出栈操作。递归忘掉返回使程序崩溃，消耗掉所有内存。

lambda 函数（匿名函数）

lambda函数是一个只用一行就能解决问题的函数。

lambda arg1,arg2,...ageN : experssion
#	   参数列表,可以多个参数     表达式

• arg1、arg2等参数是可选的，如果使用参数的话，参数通常也会在表达式之中出现。
• 匿名函数的参数规则、作用域关系与有名函数是一样的。
• 表达式该表达式必须要有一个返回值，该值直接返回，**无需return**语句
• ==表达式不能包含循环、return，可以包含if… else …==

练习

# 自定义函数1
sum = lambda arg1,arg2 : arg1 + arg2
# 调用自定义函数
print('相加的值: ', sum(10,20))  # 30

# 自定义函数2
power = lambda x,y: x ** y
print(power(2,10))  # 1024

lambda的特点

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，**而不是一个代码块，因而仅仅能在lambda表达式中封装有限的逻辑**。
• lambda函数拥有自己的命名空间，且==不能访问自有参数列表之外或全局命名空间里的参数==。

map()函数

map()函数是一个内置的高阶函数。

map(function, iterable,...)

• 参数1:传入**一个函数**，这个函数可以是内置的，也可 以是自己定义，也可以是匿名函数
• 参数2:是**可迭代对象**，如列表，字符串等等。
• 该函数返回一个map对象，是个迭代器。
• 注意：不是列表==不能直接输出，可以通过for循环或者Iist()来显示==。

map函数==将iterable中的每一个元素执行一遍 function==，结果以map对象的形式返回。注意，iterable后面还有省略号，即可以传多个iterable ，如果有额外的iterable参数，并行的从这些参数中取元素，并调用fnction。

def square(x):
	return x * x
a = map(square, [1,2,3,4])
print(a)	# <map object at 0x0000025B49C1F8E0>
print(list(a))  # [1, 4, 9, 16]

# 也可以使用for循环来取出内容
ls = []
a = map(square, [1,2,3,4])
for i in a:
	ls.append(i)
print(ls) # [1, 4, 9, 16]

# 也可以使用推导式
a = map(square, [1,2,3,4])
ls = [item for item in a]
print(ls) # [1, 4, 9, 16]

模块

模块与程序

我们写的代码保存的以.py结尾的Python文件就是一个独立的模块，模块包含了对象定义和语句。

模块导入方法

要导入系统模块或者已经定义好的模块，有三种方法：

1. import 模块名
2. from 模块名 import 函数名 导入模块中所有的函数 from 模块名 import *
3. import 模块名 as 别名

==注意事项==

1. 不管你执行了多少次 import，一个模块只会被导入一次
2. 导入模块后，我们就可以用模块名称这个变量访问模块的函数所有功能

异常与文件操作

• Python的文件操作
• Python异常处理机制

文件操作

打开文件

Python使用内置函数open()打开文件，创建file对象。在系统中，只有存在file对象后，用户才能对文件进行相应的操作。

file object = open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• 文件名(name)为必选参数，

• 模式(mode)和缓冲(buffering)参数是可选的。

• 该函数返回一个文件对象。

• file：要打开的文件的路径。

• mode：文件打开模式，默认为读模式（‘r’）。常见模式包括：

  • 'r'：只读模式。文件必须存在。
  • 'w'：写入模式。如果文件不存在则创建文件，如果文件存在则**清空文件内容**。
  • 'a'：追加模式。如果文件不存在则创建文件，如果文件存在则在文件**末尾追加内容**。
  • 'b'：二进制模式。可以与其他模式结合使用（如 'rb' 表示二进制读）。
  • 't'：文本模式。默认模式。
  • '+'：读写模式。可以与其他模式结合使用（如 'r+' 表示读写模式）。

异常处理

try: 
    with open('example.txt', 'r') as file: 
        content = file.read() 
        print(content) 
except FileNotFoundError: 
    print('文件不存在！') 
except PermissionError: 
    print('无权限访问文件！') 
except Exception as e: 
    print(f'发生未知错误：{e}')

在文件读写过程中，可能会出现异常，例如文件不存在或权限错误。