Python期末速成课笔记

于 2024-12-02 16:50:12 发布
阅读量1k 收藏 30
点赞数 15
文章标签： python 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_56679246/article/details/144192338
版权

《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 + 2434
-减10 -28
*乘12 * 224
/除34/103.4
%取模：余数34%104
**幂2 ** 416
//取整数：返回商数整数部分34 // 103
>>> 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 + zx = y + z
+=加法赋值x += yx = x + y
-=减法赋值x -= yx = x - y
*=乘法赋值x *= yx = x * y
/=除法赋值x /= yx = x / y
%=取模赋值x %= yx = x % y
**=幂赋值x **= yx = x ** y
//=整除赋值x //= yx = 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}')

在文件读写过程中，可能会出现异常，例如文件不存在或权限错误。
数名导入模块中所有的函数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}')

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

Taichi呀
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值