478 lines
14 KiB
Markdown
478 lines
14 KiB
Markdown
---
|
||
id: 函数、字符串和常用数据结构
|
||
title: 函数、字符串和常用数据结构
|
||
sidebar_position: 3
|
||
data: 2022年1月27日
|
||
---
|
||
|
||
## 函数
|
||
|
||
通过白盒/黑盒封装多行代码的实现，一般情况下拥有输入和输出，用来**简化代码**、**重复调用**和**模块化编程**。
|
||
|
||
### 函数定义
|
||
|
||
在 Python 中可以使用`def`关键字来定义函数，和变量一样每个函数也有一个响亮的名字，而且命名规则跟变量的命名规则是一致的。在函数名后面的圆括号中可以放置传递给函数的参数，这一点和数学上的函数非常相似，程序中函数的参数就相当于是数学上说的函数的自变量，而函数执行完成后我们可以通过`return`关键字来返回一个值，这相当于数学上说的函数的因变量。
|
||
|
||
### 函数的参数
|
||
|
||
在 Python 中，函数的参数可以有默认值，也支持使用可变参数，所以 Python 并不需要像其他语言一样支持[函数的重载](https://zh.wikipedia.org/wiki/函数重载)，因为我们在定义一个函数的时候可以让它有多种不同的使用方式。
|
||
|
||
```python
|
||
from random import randint
|
||
|
||
|
||
def roll_dice(n=2):
|
||
"""摇色子"""
|
||
total = 0
|
||
for _ in range(n):
|
||
total += randint(1, 6)
|
||
return total
|
||
|
||
|
||
def add(a=0, b=0, c=0):
|
||
"""三个数相加"""
|
||
return a + b + c
|
||
|
||
# 在参数名前面的*表示args是一个可变参数
|
||
def add2(*args):
|
||
total = 0
|
||
for val in args:
|
||
total += val
|
||
return total
|
||
|
||
|
||
# 如果没有指定参数那么使用默认值摇两颗色子
|
||
print(roll_dice())
|
||
# 摇三颗色子
|
||
print(roll_dice(3))
|
||
print(add())
|
||
print(add(1))
|
||
print(add(1, 2))
|
||
print(add(1, 2, 3))
|
||
# 传递参数时可以不按照设定的顺序进行传递
|
||
print(add(c=50, a=100, b=200))
|
||
|
||
# 在调用add函数时可以传入0个或多个参数
|
||
print(add2())
|
||
print(add2(1))
|
||
print(add2(1, 2))
|
||
print(add2(1, 2, 3))
|
||
print(add2(1, 3, 5, 7, 9))
|
||
```
|
||
|
||
### 用模块管理函数
|
||
|
||
由于 Python 没有函数重载的概念，那么后面的定义会覆盖之前的定义，也就意味着两个函数同名函数实际上只有一个是存在的。
|
||
|
||
```python
|
||
def foo():
|
||
print('hello, world!')
|
||
|
||
def foo():
|
||
print('goodbye, world!')
|
||
|
||
下面的代码会输出什么呢？
|
||
|
||
foo()
|
||
```
|
||
|
||
Python中每个文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过`import`关键字导入指定的模块就可以区分到底要使用的是哪个模块中的`foo`函数，代码如下所示。
|
||
|
||
`module1.py`
|
||
|
||
```python
|
||
def foo():
|
||
print('hello, world!')
|
||
```
|
||
|
||
`module2.py`
|
||
|
||
```python
|
||
def foo():
|
||
print('goodbye, world!')
|
||
```
|
||
|
||
`test.py`
|
||
|
||
```python
|
||
from module1 import foo
|
||
|
||
# 输出hello, world!
|
||
foo()
|
||
|
||
from module2 import foo
|
||
|
||
# 输出goodbye, world!
|
||
foo()
|
||
```
|
||
|
||
也可以按照如下所示的方式来区分到底要使用哪一个`foo`函数。
|
||
|
||
```python
|
||
import module1 as m1
|
||
import module2 as m2
|
||
|
||
m1.foo()
|
||
m2.foo()
|
||
```
|
||
|
||
## 字符串和常用数据结构
|
||
|
||
### 字符串
|
||
|
||
所谓**字符串**，就是由零个或多个字符组成的有限序列。在Python程序中，如果我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。
|
||
|
||
```python
|
||
s1 = 'hello, world!'
|
||
s2 = "hello, world!"
|
||
# 以三个双引号或单引号开头的字符串可以折行
|
||
s3 = """
|
||
hello,
|
||
world!
|
||
"""
|
||
print(s1, s2, s3, end='')
|
||
```
|
||
|
||
在字符串中使用`\`（反斜杠）来表示转义，例如常见的：`\n`、`\t`、`\141`、`\u9a86\u660a`
|
||
|
||
在字符串开头使用`r`来取消转义，例如：`s2 = r'\n\\hello, world!\\\n'`将输出`\n\\hello, world!\\\n`
|
||
|
||
Python 为字符串类型提供了非常丰富的运算符，我们可以使用`+`运算符来实现字符串的拼接，可以使用`*`运算符来重复一个字符串的内容，可以使用`in`和`not in`来判断一个字符串是否包含另外一个字符串（成员运算），我们也可以用`[]`和`[:]`运算符从字符串取出某个字符或某些字符（切片运算），代码如下所示：
|
||
|
||
```python
|
||
s1 = 'hello ' * 3
|
||
print(s1) # hello hello hello
|
||
s2 = 'world'
|
||
s1 += s2
|
||
print(s1) # hello hello hello world
|
||
print('ll' in s1) # True
|
||
print('good' in s1) # False
|
||
str2 = 'abc123456'
|
||
# 从字符串中取出指定位置的字符(下标运算)
|
||
print(str2[2]) # c
|
||
# 字符串切片(从指定的开始索引到指定的结束索引)
|
||
print(str2[2:5]) # c12
|
||
print(str2[2:]) # c123456
|
||
print(str2[2::2]) # c246
|
||
print(str2[::2]) # ac246
|
||
print(str2[::-1]) # 654321cba
|
||
print(str2[-3:-1]) # 45
|
||
```
|
||
|
||
### 常用字符串函数
|
||
|
||
```python
|
||
str1 = 'hello, world!'
|
||
# 通过内置函数len计算字符串的长度
|
||
print(len(str1)) # 13
|
||
# 获得字符串首字母大写的拷贝
|
||
print(str1.capitalize()) # Hello, world!
|
||
# 获得字符串每个单词首字母大写的拷贝
|
||
print(str1.title()) # Hello, World!
|
||
# 获得字符串变大写后的拷贝
|
||
print(str1.upper()) # HELLO, WORLD!
|
||
# 从字符串中查找子串所在位置
|
||
print(str1.find('or')) # 8
|
||
print(str1.find('shit')) # -1
|
||
# 与find类似但找不到子串时会引发异常
|
||
# print(str1.index('or'))
|
||
# print(str1.index('shit'))
|
||
# 检查字符串是否以指定的字符串开头
|
||
print(str1.startswith('He')) # False
|
||
print(str1.startswith('hel')) # True
|
||
# 检查字符串是否以指定的字符串结尾
|
||
print(str1.endswith('!')) # True
|
||
# 将字符串以指定的宽度居中并在两侧填充指定的字符
|
||
print(str1.center(50, '*'))
|
||
# 将字符串以指定的宽度靠右放置左侧填充指定的字符
|
||
print(str1.rjust(50, ' '))
|
||
str2 = 'abc123456'
|
||
# 检查字符串是否由数字构成
|
||
print(str2.isdigit()) # False
|
||
# 检查字符串是否以字母构成
|
||
print(str2.isalpha()) # False
|
||
# 检查字符串是否以数字和字母构成
|
||
print(str2.isalnum()) # True
|
||
str3 = ' jackfrued@126.com '
|
||
print(str3)
|
||
# 获得字符串修剪左右两侧空格之后的拷贝
|
||
print(str3.strip())
|
||
```
|
||
|
||
### 字符串拼接函数
|
||
|
||
Python 3.6 以后，格式化字符串还有更为简洁的书写方式，就是在字符串前加上字母`f`，我们可以使用下面的语法糖来简化上面的代码。
|
||
|
||
```python
|
||
a, b = 5, 10
|
||
print(f'{a} * {b} = {a * b}')
|
||
```
|
||
|
||
## 列表（List）
|
||
|
||
数值类型是标量类型，也就是说这种类型的对象没有可以访问的内部结构；而字符串类型是一种结构化的、非标量类型，所以才会有一系列的属性和方法。接下来我们要介绍的列表（`list`），也是一种结构化的、非标量类型，它是值的有序序列，每个值都可以通过索引进行标识，定义列表可以将列表的元素放在`[]`中，多个元素用`,`进行分隔，可以使用`for`循环对列表元素进行遍历，也可以使用`[]`或`[:]`运算符取出列表中的一个或多个元素。
|
||
|
||
### 列表的定义和操作
|
||
|
||
```python
|
||
list1 = [1, 3, 5, 7, 100]
|
||
print(list1) # [1, 3, 5, 7, 100]
|
||
# 乘号表示列表元素的重复
|
||
list2 = ['hello'] * 3
|
||
print(list2) # ['hello', 'hello', 'hello']
|
||
# 计算列表长度(元素个数)
|
||
print(len(list1)) # 5
|
||
# 下标(索引)运算
|
||
print(list1[0]) # 1
|
||
print(list1[4]) # 100
|
||
# print(list1[5]) # IndexError: list index out of range
|
||
print(list1[-1]) # 100
|
||
print(list1[-3]) # 5
|
||
list1[2] = 300
|
||
print(list1) # [1, 3, 300, 7, 100]
|
||
# 通过循环用下标遍历列表元素
|
||
for index in range(len(list1)):
|
||
print(list1[index])
|
||
# 通过for循环遍历列表元素
|
||
for elem in list1:
|
||
print(elem)
|
||
# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
|
||
for index, elem in enumerate(list1):
|
||
print(index, elem)
|
||
```
|
||
|
||
### 列表元素的移除
|
||
|
||
```python
|
||
list1 = [1, 3, 5, 7, 100]
|
||
# 添加元素
|
||
list1.append(200)
|
||
list1.insert(1, 400)
|
||
# 合并两个列表
|
||
# list1.extend([1000, 2000])
|
||
list1 += [1000, 2000]
|
||
print(list1) # [1, 400, 3, 5, 7, 100, 200, 1000, 2000]
|
||
print(len(list1)) # 9
|
||
# 先通过成员运算判断元素是否在列表中，如果存在就删除该元素
|
||
if 3 in list1:
|
||
list1.remove(3)
|
||
if 1234 in list1:
|
||
list1.remove(1234)
|
||
print(list1) # [1, 400, 5, 7, 100, 200, 1000, 2000]
|
||
# 从指定的位置删除元素
|
||
list1.pop(0)
|
||
list1.pop(len(list1) - 1)
|
||
print(list1) # [400, 5, 7, 100, 200, 1000]
|
||
# 清空列表元素
|
||
list1.clear()
|
||
print(list1) # []
|
||
```
|
||
|
||
### 切片
|
||
|
||
```python
|
||
fruits = ['grape', 'apple', 'strawberry', 'waxberry']
|
||
fruits += ['pitaya', 'pear', 'mango']
|
||
# 列表切片
|
||
fruits2 = fruits[1:4]
|
||
print(fruits2) # apple strawberry waxberry
|
||
# 可以通过完整切片操作来复制列表
|
||
fruits3 = fruits[:]
|
||
print(fruits3) # ['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
|
||
fruits4 = fruits[-3:-1]
|
||
print(fruits4) # ['pitaya', 'pear']
|
||
# 可以通过反向切片操作来获得倒转后的列表的拷贝
|
||
fruits5 = fruits[::-1]
|
||
print(fruits5) # ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']
|
||
```
|
||
|
||
### 排序
|
||
|
||
```python
|
||
list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
|
||
list2 = sorted(list1)
|
||
# sorted函数返回列表排序后的拷贝不会修改传入的列表
|
||
# 函数的设计就应该像sorted函数一样尽可能不产生副作用
|
||
list3 = sorted(list1, reverse=True)
|
||
# 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
|
||
list4 = sorted(list1, key=len)
|
||
print(list1)
|
||
print(list2)
|
||
print(list3)
|
||
print(list4)
|
||
# 给列表对象发出排序消息直接在列表对象上进行排序
|
||
list1.sort(reverse=True)
|
||
print(list1)
|
||
```
|
||
|
||
## 生成式和生成器
|
||
|
||
```python
|
||
f = [x for x in range(1, 10)]
|
||
print(f)
|
||
f = [x + y for x in 'ABCDE' for y in '1234567']
|
||
print(f)
|
||
# 用列表的生成表达式语法创建列表容器
|
||
# 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
|
||
f = [x ** 2 for x in range(1, 1000)]
|
||
print(sys.getsizeof(f)) # 查看对象占用内存的字节数
|
||
print(f)
|
||
# 请注意下面的代码创建的不是一个列表而是一个生成器对象
|
||
# 通过生成器可以获取到数据但它不占用额外的空间存储数据
|
||
# 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
|
||
f = (x ** 2 for x in range(1, 1000))
|
||
print(sys.getsizeof(f)) # 相比生成式生成器不占用存储数据的空间
|
||
print(f)
|
||
for val in f:
|
||
print(val)
|
||
```
|
||
|
||
Python中还有另外一种定义生成器的方式，就是通过`yield`关键字将一个普通函数改造成生成器函数。
|
||
|
||
```python
|
||
def fib(n):
|
||
a, b = 0, 1
|
||
for _ in range(n):
|
||
a, b = b, a + b
|
||
yield a
|
||
|
||
|
||
def main():
|
||
for val in fib(20):
|
||
print(val)
|
||
|
||
|
||
if __name__ == '__main__':
|
||
main()
|
||
```
|
||
|
||
## 元组
|
||
|
||
Python 中的元组与列表类似也是一种容器数据类型，可以用一个变量（对象）来存储多个数据，不同之处在于元组的元素不能修改，在前面的代码中我们已经不止一次使用过元组了。顾名思义，我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。
|
||
|
||
```python
|
||
# 定义元组
|
||
t = ('骆昊', 38, True, '四川成都')
|
||
print(t)
|
||
# 获取元组中的元素
|
||
print(t[0])
|
||
print(t[3])
|
||
# 遍历元组中的值
|
||
for member in t:
|
||
print(member)
|
||
# 重新给元组赋值
|
||
# t[0] = '王大锤' # TypeError
|
||
# 变量t重新引用了新的元组原来的元组将被垃圾回收
|
||
t = ('王大锤', 20, True, '云南昆明')
|
||
print(t)
|
||
# 将元组转换成列表
|
||
person = list(t)
|
||
print(person)
|
||
# 列表是可以修改它的元素的
|
||
person[0] = '李小龙'
|
||
person[1] = 25
|
||
print(person)
|
||
# 将列表转换成元组
|
||
fruits_list = ['apple', 'banana', 'orange']
|
||
fruits_tuple = tuple(fruits_list)
|
||
print(fruits_tuple)
|
||
```
|
||
|
||
## 集合
|
||
|
||
Python 中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。
|
||
|
||
### 创建和使用
|
||
|
||
```python
|
||
# 创建集合的字面量语法
|
||
set1 = {1, 2, 3, 3, 3, 2}
|
||
print(set1)
|
||
print('Length =', len(set1))
|
||
# 创建集合的构造器语法(面向对象部分会进行详细讲解)
|
||
set2 = set(range(1, 10))
|
||
set3 = set((1, 2, 3, 3, 2, 1))
|
||
print(set2, set3)
|
||
# 创建集合的推导式语法(推导式也可以用于推导集合)
|
||
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
|
||
print(set4)
|
||
```
|
||
|
||
### 添加和删除
|
||
|
||
```python
|
||
set1.add(4)
|
||
set1.add(5)
|
||
set2.update([11, 12])
|
||
set2.discard(5)
|
||
if 4 in set2:
|
||
set2.remove(4)
|
||
print(set1, set2)
|
||
print(set3.pop())
|
||
print(set3)
|
||
```
|
||
|
||
### 交集、并集、差集运算
|
||
|
||
```python
|
||
# 集合的交集、并集、差集、对称差运算
|
||
print(set1 & set2)
|
||
# print(set1.intersection(set2))
|
||
print(set1 | set2)
|
||
# print(set1.union(set2))
|
||
print(set1 - set2)
|
||
# print(set1.difference(set2))
|
||
print(set1 ^ set2)
|
||
# print(set1.symmetric_difference(set2))
|
||
# 判断子集和超集
|
||
print(set2 <= set1)
|
||
# print(set2.issubset(set1))
|
||
print(set3 <= set1)
|
||
# print(set3.issubset(set1))
|
||
print(set1 >= set2)
|
||
# print(set1.issuperset(set2))
|
||
print(set1 >= set3)
|
||
# print(set1.issuperset(set3))
|
||
```
|
||
|
||
## 字典
|
||
|
||
字典是另一种可变容器模型，Python 中的字典跟我们生活中使用的字典是一样一样的，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。
|
||
|
||
```python
|
||
# 创建字典的字面量语法
|
||
scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
|
||
print(scores)
|
||
# 创建字典的构造器语法
|
||
items1 = dict(one=1, two=2, three=3, four=4)
|
||
# 通过zip函数将两个序列压成字典
|
||
items2 = dict(zip(['a', 'b', 'c'], '123'))
|
||
# 创建字典的推导式语法
|
||
items3 = {num: num ** 2 for num in range(1, 10)}
|
||
print(items1, items2, items3)
|
||
# 通过键可以获取字典中对应的值
|
||
print(scores['骆昊'])
|
||
print(scores['狄仁杰'])
|
||
# 对字典中所有键值对进行遍历
|
||
for key in scores:
|
||
print(f'{key}: {scores[key]}')
|
||
# 更新字典中的元素
|
||
scores['白元芳'] = 65
|
||
scores['诸葛王朗'] = 71
|
||
scores.update(冷面=67, 方启鹤=85)
|
||
print(scores)
|
||
if '武则天' in scores:
|
||
print(scores['武则天'])
|
||
print(scores.get('武则天'))
|
||
# get方法也是通过键获取对应的值但是可以设置默认值
|
||
print(scores.get('武则天', 60))
|
||
# 删除字典中的元素
|
||
print(scores.popitem())
|
||
print(scores.popitem())
|
||
print(scores.pop('骆昊', 100))
|
||
# 清空字典
|
||
scores.clear()
|
||
print(scores)
|
||
```
|
||
|