Python Day 3

函数

函数的定义

def 函数名(参数1, 参数2):

    函数体

    return 返回值

示例：

# 定义函数
def add(x, y):
    result = x + y
    return result

# 调用函数
x = int(input("请输入x："))
y = int(input("请输入y："))
r = add(x, y)
print(f"您计算的是{x}与{y}之和，和为{r}")

 运行结果：

如果函数没有return语句，则返回值类型默认为None类型

None是一个特殊的字面量，其类型为<class 'NoneType'>，表示返回空值的意思，用例如下：

# 函数定义
def check(age):
    """
    检查是否成年
    :param age: 年龄
    :return: 是否成年的布尔值
    """
    if age > 18:
        print("已成年")
        return True

Age = int(input("输入年龄："))

# 若Age小于18，check()函数返回None
result = check(Age)

# not取反后结果为真，执行if中的语句
if not result:
    print("未成年")

另外，函数说明文档可以在调用处通过鼠标悬停的方式查看：

变量的作用域

• 局部变量：只在函数内部生效
• 全局变量：函数内外均可生效

这里介绍一个global关键字，可在函数内部声明变量为全局变量，如：

num = 100

def fun1():
    num = 200
    print(f"fun1()中num值为{num}")

def fun2():
    global num
    num = 200
    print(f"fun2()中num值为{num}")

print(f"执行任意函数前全局num值为{num}")

fun1()
print(f"执行fun1()函数后全局num值为{num}")

fun2()
print(f"执行fun2()函数后全局num值为{num}")

结果如下图：

数据容器

什么是数据容器？

Python中的数据容器，是一种可以容纳多份数据的数据类型，容纳的每一份数据（元素）可以是任意类型的数据

list（列表）

基本语法

# 字面量
[元素1, 元素2, ...]

# 定义变量
变量名 = [元素1, 元素2, ...]

# 定义空列表
变量名 = []
变量名 = list()

要注意的是，列表中存储的多个元素可以是不同的数据类型，且支持嵌套

列表支持通过下标访问元素，可参考Java中一维或多维数组的下标使用，此处不再赘述

常用方法

列表常用的方法如下：

方法使用	描述
列表.index(元素)	查找指定元素的下标
列表.insert(下标, 元素)	在指定下标处插入指定元素
列表.append(元素)	在列表末尾追加元素
列表.extend(其他容器)	将其他容器的元素取出，依次追加至列表尾部
del 列表[下标]	删除指定下标的元素
列表.pop(下标)
列表.remove(元素)	删除列表中与参数相同的第一个匹配项
列表.clear()	清空列表
列表.count(元素)	统计某元素在列表中出现的次数
len(列表)	统计容器中共有多少个元素

列表的遍历

while循环遍历：

index = 0
while index < len(列表)
    访问 列表[index]
    index += 1

for循环遍历：

for 临时变量 in 列表
    访问 临时变量

在for循环中，临时变量会依次被赋值为列表中的元素

相比之下，for循环更简单，而while循环更灵活

小结

简单总结一下列表的特点：

• 可容纳多个元素
• 元素之间可以是不同的数据类型
• 有序存储
• 允许有重复数据
• 可以修改

tuple（元组）

基本语法

# 字面量
(元素1, 元素2, ...)

# 变量
变量名 = (元素1, 元素2, ...)

# 空元组
变量名 = ()
变量名 = tuple()

额外要注意的是，即使元组中只有一个元素，也要加上逗号，否则不是元组类型

# 定义单元素的元组
t = (123, )

元组的大部分特性与列表相同，最大的不同点在于元组一旦定义完成就不可修改

常用方法

方法	描述
元组.index(元素)	返回查找元素的下标
元组.count(元素)	统计元素在元组中出现的次数
len(元组)	统计元素个数

元组的遍历

while循环遍历

# 定义元组
t = (1, 2, 3, 4, 5)

# 遍历
index = 0
while index < len(t):
    print(t[index])
    index += 1

for循环遍历

# 定义元组
t = (1, 2, 3, 4, 5)

# 遍历
for i in t:
    print(i)

小结

元组的特点：

• 可以容纳多个元素
• 元素之间可以是不同的数据类型
• 有序存储
• 允许有重复元素
• 不可修改

附加一点：如果元组中有list作为元素，则list的内容可以修改，但不能将其替换为其他list或其他类型

str（字符串）

基本语法

字符串是存放字符（串）的容器，同元组、列表一样，也可通过下标的方式访问元素

常用方法

方法	描述
字符串.index(元素)	查找指定元素的第一个匹配项的下标
字符串.replace(元素1, 元素2)	将字符串中的所有元素1替换为元素2 不修改原字符串，而是生成一个新的
字符串.split(元素)	按照给定元素分割字符串 存入一个新的list对象中
字符串.strip(元素)	移除指定元素（以字符为单位），默认移除首尾的空格
字符串.count(元素)	统计元素出现的次数
len(字符串)	统计字符个数

字符串的遍历

while循环遍历：

s = "你相信光吗"
index = 0
while index < len(s):
    print(s[index])
    index += 1

for循环遍历：

s = "你相信光吗"
for i in s:
    print(i)

小结

字符串作为容器的特点：

• 只能存储字符（串）类型
• 有序存储
• 允许有重复字符（串）
• 不可修改

序列的切片

什么是序列？

序列是指，内容连续、有序，可使用下标索引的一类数据容器

上述的列表、元组、字符串均可视作序列

切片操作

语法：

序列[起始下标 : 结束下标 : 步长]

• 起始下标到结束下标为左闭右开区间（即结束下标元素取不到）
• 起始下标为空视作从头开始
• 结束下标为空视作直到末尾
• 步长为空视作为1，为负视作从后向前倒序切片

重点注意，切片操作不影响原序列本身，而是得到一个同类型的新序列

示例：

l = [1, 2, 3, 4, 5]
newl = l[1:4]
print(newl)    # 结果：[2, 3, 4]

t = (1, 2, 3, 4, 5)
newt = t[:]
print(newt)    # 结果：(1, 2, 3, 4, 5)

s = "12345"
news = s[3:1:-1]
print(news)    # 结果："43"

set（集合）

集合的主要特点是：去重且无序

基本语法

# 集合定义
变量名 = {元素1, 元素2, ...}

# 空集合
变量名 = set()

常用方法

方法	描述
集合.add(元素)	添加新元素
集合.remove(元素)	移除指定元素
集合.pop()	随机取出一个元素
集合.clear()	清空集合
集合1.difference(集合2)	生成一个新集合，内容为两集合的差集 原有的两集合内容不变
集合1.difference_update(集合2)	在集合1中删除集合2中出现的元素 集合1被修改，集合2不变
集合1.union(集合2)	生成一个新集合，内容为两集合的并集 原有的两集合内容不变
len(集合)	统计集合中元素个数

集合的遍历

由于集合不支持下标索引，故不支持while循环遍历

for循环遍历：

set1 = {1, 2, 3, 4, 5}
for i in set1:
    print(i)

小结

集合的特点：

• 可以容纳多个元素
• 元素之间可以是不同的数据类型
• 无序存储（不支持下标索引）
• 不允许有重复元素
• 可以修改
• 不支持while循环遍历

dict（字典）

生活中的字典可以按字找到对应的含义，同理，python中的字典可以按Key找到对应的Value

通过字典，可以实现用Key值取出Value值的操作（Key值不能重复）

基本语法

# 定义字典变量
# 字典与集合一样使用{}，但其元素为一个一个的键值对
d = {key1: value1, key2: value2, ...}

# 空字典
d = {}
d = dict()

字典数据的获取：

字典变量名[Key]可以得到对应的Value值

字典的Key值和Value值可以是任意数据类型，所以字典也可以嵌套使用

常用方法

方法	描述
字典[Key]	获取指定Key对应的Value值
字典[Key] = Value	添加/更新键值对
字典.pop(Key)	获取指定Key对应的Value值 并在字典中删除此键值对
字典.clear()	清空字典
字典.keys()	获取全部Key值，类型为<class 'dict_keys'>
len(字典)	统计字典内元素个数

字典的遍历

和集合一样，字典不支持下标，因此也不支持while循环遍历

for循环遍历：

# 定义字典
d = {
    "tom": 99,
    "sam": 56,
    "lili": 87
}

# for循环遍历字典的Value值
for i in d.keys():
    print(d[i])

小结

字典的特点：

• 可以容纳多个元素
• 元素之间可以是不同的数据类型
• 每个元素都是Key: Value这样的键值对
• 可以通过Key值获取对应的Value值，Key值不可重复
• 无序存储（不支持下标）
• 可以修改
• 不支持while循环遍历

数据容器的通用操作

遍历

• 五类容器均支持for循环遍历
• 集合、字典不支持while循环遍历，其余支持

统计

• len(容器)，统计容器中元素个数
• max(容器)，统计容器中最大的元素
• min(容器)，统计容器中最小的元素

字符串比较大小实际上是按位比较字符的ASCⅡ码值，只要有一位比出大小，后面就无需比较了

转换

• list(容器)，将给定容器转换为列表类型
• tuple(容器)，将给定容器转换为元组类型
• str(容器)，将给定容器转换为字符串类型
• set(容器)，将给定容器转换为集合类型

排序

• sorted(容器, [reverse = True])，将给定容器进行排序，其中参数reverse = True表示降序，排好序后会得到一个列表对象