Python期末复习

Python中的字符串格式化的三种方法

1. %操作符格式化

% 运算符的用法:

```python

name = 'Alice'

age = 20

print('%s is %d years old.' % (name, age)) # 输出：Alice is 20 years old.

```

2. str.format()方法格式化

format 函数的用法：

```python

name = 'Bob'

age = 30

print('{} is {} years old.'.format(name, age)) # 输出：Bob is 30 years old.

```

3. f-strings形式的格式化方法

f字符串是Python3.6及以上版本引入的一种字符串格式化的方法，它可以在字符串中直接嵌入Python表达式，并将其结果作为字符串的一部分。使用f字符串可以简化字符串格式化的操作，并使代码更加清晰易读。

f字符串的语法格式为，在字符串前面添加字符"f"或"F"，然后在字符串中使用花括号"{}"包围Python表达式。例如：

```

name = "Alice"

age = 25

print(f"My name is {name} and I'm {age} years old.")

```

在上面的例子中，我们使用f字符串输出了一个包含姓名和年龄的句子。在字符串中，我们使用了花括号"{}"包围了两个Python表达式，分别输出了变量`name`和`age`的值。

f字符串不仅可以嵌入变量，还可以嵌入任意的Python表达式。例如：

```

a = 3

b = 4

print(f"The sum of {a} and {b} is {a+b}.")

```

在上面的例子中，我们使用f字符串输出了两个变量的和。在字符串中，我们使用了花括号"{}"包围了一个Python表达式，该表达式计算了变量`a`和`b`的和。

需要注意的是，f字符串只在Python3.6及以上版本中可用。在低版本的Python中，可以使用其他字符串格式化的方法，例如`format`方法。

可变对象和不可变对象

在Python中，变量可以存储不同类型的对象，这些对象可以是可变的或者不可变的。
可变对象是指在程序运行过程中，其内容可以被修改；
而不可变对象是指在程序运行过程中，其内容不能被修改，只能通过创建新的对象来实现修改。
举例来说，Python中的整数、浮点数、字符串、元组等数据类型是不可变的，而列表、字典、集合等数据类型是可变的。
下面举一些例子来说明可变对象和不可变对象的区别：
1. 字符串是不可变对象，例如：
   ```
   s = "hello"
   s[1] = "a"  # TypeError: 'str' object does not support item assignment
   ```
   在上面的例子中，尝试修改字符串`s`中的一个字符，但是程序报错，提示字符串对象不支持修改。
2. 列表是可变对象，例如：
   ```
   lst = [1, 2, 3]
   lst[1] = 4
   print(lst)  # [1, 4, 3]
   ```
   在上面的例子中，我们先创建一个包含三个整数的列表`lst`，然后修改其中第二个元素的值为4。由于列表是可变对象，因此这个操作是合法的。
3. 在函数中，如果传递的是可变对象，那么函数内部对该对象的修改会影响到外部的变量值。例如：
   ```
   def modify_list(lst):
       lst.append(4)
   lst = [1, 2, 3]
   modify_list(lst)
   print(lst)  # [1, 2, 3, 4]
   ```
   在上面的例子中，我们定义了一个函数`modify_list`，该函数接受一个列表作为参数，然后在列表末尾添加一个元素4。在主程序中，我们先创建一个包含三个整数的列表`lst`，然后调用函数`modify_list`，将该列表作为参数传递进去。由于列表是可变对象，因此函数内部对该列表的修改会影响到外部的变量值。
需要注意的是，某些不可变对象虽然不能直接修改，但可以通过重新创建一个对象来实现修改。例如，对于字符串，可以使用字符串的切片操作来修改其中的一部分内容。例如：
```
s = "hello"
s = s[:1] + "a" + s[2:]
print(s)  # "hallo"
```
在上面的例子中，我们先将字符串`s`的第二个字符替换为字符"a"，实际上是重新创建了一个新的字符串，并将其赋值给`s`变量。

try语句和结构

 `try-except`语句是Python中处理异常的一种机制，它的基本结构如下：

```
try:
    # 可能会抛出异常的代码块
except ExceptionType1:
    # 处理类型为ExceptionType1的异常
except ExceptionType2:
    # 处理类型为ExceptionType2的异常
...
else:
    # 如果try块中没有抛出异常，则执行else块
finally:
    # 不管有没有抛出异常，都执行finally块中的代码
```
`try`语句中的代码块是可能会抛出异常的代码块。当程序执行到`try`语句时，如果该代码块中没有抛出异常，则直接跳过`except`和`finally`块，执行`else`块中的代码。如果该代码块中抛出了异常，则会根据异常类型选择相应的`except`块进行处理。如果没有找到匹配的`except`块，则将异常继续向上抛出，直到找到处理该异常的代码块或者程序崩溃。
`finally`块中的代码不管有没有抛出异常都会执行。这个块通常被用来释放资源或者进行一些清理工作，例如关闭文件或者释放锁等。
下面是一个简单的例子，演示了`try-except`语句的用法：
```
try:
    x = int(input("请输入一个整数："))
    print(f"输入的整数为：{x}")
except ValueError:
    print("输入的不是整数！")
else:
    print(f"{x}的平方是：{x**2}")
finally:
    print("程序结束！")
```
在上面的例子中，我们使用`try-except`语句来处理用户输入的整数。如果用户输入的不是整数，则会抛出`ValueError`异常，程序会跳转到`except`块中进行处理。如果用户输入的是整数，则程序会跳转到`else`块中进行计算，并输出结果。不管有没有抛出异常，程序最终都会执行`finally`块中的代码。

numpy的属性

Numpy中，每个数组都有五种重要的属性：

1. `ndarray.ndim`: 数组的维数（即秩）。例如，一个一维数组的`ndim`属性为1，一个二维数组的`ndim`属性为2。

2. `ndarray.shape`: 数组的形状。例如，一个形状为（3，4）的数组表示它有3行4列，共12个元素。

3. `ndarray.size`: 数组的元素总数。例如，一个形状为（3，4）的数组的`size`属性为12。

4. `ndarray.dtype`: 数组的元素类型。例如，一个包含整数的数组的`dtype`属性为`int`，一个包含浮点数的数组的`dtype`属性为`float`。

5. `ndarray.itemsize`: 数组中每个元素的大小（以字节为单位）。例如，一个包含整数的数组的`itemsize`属性为4（如果该数组的元素类型为32位整数）。

这些属性提供了有关数组的基本信息，可以帮助我们理解和操作数组。例如，可以使用`ndim`属性来检查一个数组的维数，使用`shape`属性来获取数组的形状，使用`dtype`属性来确定数组中元素的类型等等。

Python 可视化常见的图形和对应的应用场景，以及Matplotlib对应的绘制函数

Python 是一门强大的数据分析和可视化工具，它拥有很多常见的图形类型以及对应的应用场景。在 Python 中，最常用的可视化库是 Matplotlib。

以下是常见的图形类型以及对应的应用场景：

1. 折线图：用于展示数据随时间的变化趋势，比如股票价格、气温等。Matplotlib 对应的绘制函数是 plot()。

2. 散点图：用于展示两个变量之间的关系，比如汽车牌照费用和车辆重量之间的关系。Matplotlib 对应的绘制函数是 scatter()。

3. 条形图：用于比较多个项目的数量或大小，比如不同城市的人口数量。Matplotlib 对应的绘制函数是 bar()。

4. 饼图：用于展示各个类别占总体的百分比，比如销售额占比。Matplotlib 对应的绘制函数是 pie()。

5. 直方图：用于展示连续变量的数据分布情况，比如考试成绩的分布情况。Matplotlib 对应的绘制函数是 hist()。

6. 箱线图：用于展示数据的离散程度和异常值情况，比如不同品牌的汽车售价。Matplotlib 对应的绘制函数是 boxplot()。

7. 热力图：用于展示矩阵数据每个单元格的值，比如天气预报中各个城市的温度。Matplotlib 对应的绘制函数是 heatmap()。

以上是常见的图形类型和对应的应用场景。Matplotlib 作为 Python 中最常用的数据可视化工具，它提供了大量的绘制函数，包括 plot()、scatter()、bar()、pie()、hist()、boxplot() 和 heatmap() 等。

除了 Matplotlib，Python 还有其他常用的可视化库，比如 Seaborn、Plotly 和 Bokeh 等，它们各自有着不同的优点和适用范围，需要根据实际需求选择合适的库。

Python创建数组的函数和方法

在Python中，我们可以使用NumPy库来创建和操作数组。NumPy是Python中用于科学计算和数据分析的重要库，提供了众多数组处理函数和方法。在使用NumPy库创建数组时，我们通常使用以下七个函数：array，zeros，ones，arange，full，eye和identity。下面分别详细介绍这些函数。

1. array函数

array函数用于从常规Python列表或元组中创建数组。它接收一个序列作为参数，并返回一个新的包含给定序列的NumPy数组。例如，我们可以使用以下代码创建一个一维数组：

```python

import numpy as np

a = np.array([1, 2, 3, 4, 5])

print(a)

```

输出结果为：[1 2 3 4 5]

我们还可以使用array函数创建二维数组，例如：

```python

b = np.array([[1, 2, 3], [4, 5, 6]])

print(b)

```

输出结果为：

```

[[1 2 3]

 [4 5 6]]

```

2. zeros函数

zeros函数用于创建指定大小的数组，并将数组的元素全部初始化为0。它接受一个形状作为参数，并返回一个新的具有指定形状的数组。例如，我们可以使用以下代码创建一个三行四列的二维数组：

```python

c = np.zeros((3, 4))

print(c)

```

输出结果为：

```

[[0. 0. 0. 0.]

 [0. 0. 0. 0.]

 [0. 0. 0. 0.]]

```

3. ones函数

ones函数用于创建指定大小的数组，并将数组的元素全部初始化为1。它接受一个形状作为参数，并返回一个新的具有指定形状的数组。例如，我们可以使用以下代码创建一个两行三列的二维数组：

```python

d = np.ones((2, 3))

print(d)

```

输出结果为：

```

[[1. 1. 1.]

 [1. 1. 1.]]

```

4. arange函数

arange函数用于创建一个包含指定区间内所有整数的数组。它接收一个起始值、一个终止值和一个步长作为参数，并返回一个新的包含指定区间内所有整数的一维数组。例如，我们可以使用以下代码创建一个包含指定区间内的所有整数的一维数组：

```python

e = np.arange(1, 10, 2)

print(e)

```

输出结果为：[1 3 5 7 9]

5. full函数

full函数用于创建指定大小的数组，并将数组的所有元素初始化为指定的值。它接受一个形状和一个值作为参数，并返回一个新的具有指定形状和值的数组。例如，我们可以使用以下代码创建一个三行三列的二维数组，初始化所有元素为2.5：

```python

f = np.full((3, 3), 2.5)

print(f)

```

输出结果为：

```

[[2.5 2.5 2.5]

 [2.5 2.5 2.5]

 [2.5 2.5 2.5]]

```

6. eye函数

eye函数用于创建一个单位矩阵。单位矩阵是一个对角线上所有元素为1，其他元素为0的方阵。它接受一个大小作为参数，并返回一个新的指定大小的单位矩阵。

```python
numpy.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
```

其中，N表示行数，M表示列数，默认为N。k表示对角线偏移量，为0表示主对角线，正数表示上方的对角线，负数表示下方的对角线。dtype表示数据类型，默认为float。

例如，我们可以使用以下代码创建一个3x3的单位矩阵：

```python

g = np.eye(3)

print(g)

```

输出结果为：

```

[[1. 0. 0.]

 [0. 1. 0.]

 [0. 0. 1.]]

```

7. identity函数

identity函数用于创建一个指定大小的单位矩阵。它接受一个大小作为参数，并返回一个新的指定大小的单位矩阵。例如，我们可以使用以下代码创建一个4x4的单位矩阵：

```python

h = np.identity(4)

print(h)

```

输出结果为：

```

[[1. 0. 0. 0.]

 [0. 1. 0. 0.]

 [0. 0. 1. 0.]

 [0. 0. 0. 1.]]

```

下面是使用eye和identity函数创建对角线为1的矩阵的示例代码：

```python
import numpy as np

# 创建3x5的对角线为1的矩阵
a = np.eye(3, 5)
print(a)

# 创建4x4的对角线为1的方阵
b = np.identity(4)
print(b)
```

输出结果为：

```
[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]]
[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]
```

可以看到，使用eye函数创建的矩阵是一个3x5的矩阵，对角线为1，其它元素为0。而使用identity函数创建的矩阵是一个4x4的方阵，对角线为1，其它元素为0。因此，eye函数可以创建非方形的对角线为1的矩阵，而identity函数只能创建方形的对角线为1的矩阵。

这些函数提供了一个强大的工具集，使我们可以更快速、有效地创建和操作数组。在实际应用中，我们常常需要使用这些函数来初始化数组，并对数组进行各种运算和操作。

数组重塑reshape()：

在 numpy 中，可以使用 reshape() 方法将数组重塑。例如，将一个数组从一维数组重塑为二维数组：

``` python

import numpy as np

# 创建元素为 0 到 19 的一维数组

arr= np.arange(20)

arr1=np.reshape(arr,(4,5))

arr2=arr.reshape(4,5)

print(arr)

print(arr1)

print(arr2)

```

输出结果：

```

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

索引和切片：

在 Python 的数组中，索引从 0 开始。可以使用方括号 [] 访问数组中的元素。例如，在一个一维数组中获取第 4 个元素的值：0

```python

import numpy as np

array_a = np.array([1, 2, 3, 4, 5])

elem = array_a[3]

print(elem)

```

输出结果：

```

4

```

在多维数组中，可以使用逗号分隔索引，在每个维度上单独指定索引。例如，在一个二维数组中获取第 3 行第 2 列的元素：

```python

import numpy as np

array_a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

elem = array_a[2, 1]

print(elem)

```

输出结果：

```

8

```

使用切片方法可以获取多个元素。可以使用冒号 : 分隔切片的开始和结束索引。例如，在一个一维数组中获取前 3 个元素和后 2 个元素：

```python

import numpy as np

array_a = np.array([1, 2, 3, 4, 5])

slice_a = array_a[:3] + array_a[-2:]

print(slice_a)

```

输出结果：

```

[1 2 3 4 5]

```

在多维数组中，切片可以在多个维度上一起使用。例如，在一个二维数组中获取前 2 行和前 2 列的元素：

```python

import numpy as np

array_a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

slice_a = array_a[:2, :2]

print(slice_a)

```

输出结果：

```

[[1 2]

 [4 5]]

```

这些是 Python 数组的基本索引和切片方法。可以在 numpy 或其他库的文档中查找更多有关创建和操作数组的方法。

Q: array_a[:2, :2]和array_a[:2][:2]一样吗

A: 不一样。array_a[:2, :2]表示取array_a的前两行和前两列，返回一个2x2的子数组；而array_a[:2][:2]表示先取array_a的前两行，然后再取前两行的前两个元素，返回一个1x2的子数组

三种类型的计算

Python 中常用的三种类型的计算是数组统计运算、数组排序和数组算数运算。

1. 数组统计运算：

数组统计运算主要是对数组中的元素进行求和、求平均值、求方差、求标准差等操作。在 numpy 模块中提供了很多数组统计运算的函数，下面以一维数组为例进行演示。

```python

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

# 求和

print(np.sum(arr)) # 输出：15

# 求平均值

print(np.mean(arr)) # 输出：3.0

# 求方差

print(np.var(arr)) # 输出：2.0

# 求标准差

print(np.std(arr)) # 输出：1.41421356

```

2. 数组排序：

数组排序主要是对数组中的元素进行排序操作，numpy 模块中提供了 sort 函数进行数组排序，也可以使用 argsort 函数获取排序的索引。

```python

import numpy as np

arr = np.array([6, 2, 4, 1, 5])

# 原数组

print(arr) # 输出：[6 2 4 1 5]

# 升序排序

print(np.sort(arr)) # 输出：[1 2 4 5 6]

# 获取排序后的索引

print(np.argsort(arr)) # 输出：[3 1 2 4 0]

```

3. 数组算数运算：

数组算数运算主要是对数组中的元素进行加、减、乘、除等算数运算，numpy 模块中提供了常见的数组算数运算函数。

```python

import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([2, 3, 4])

# 元素加

print(np.add(arr1, arr2)) # 输出：[3 5 7]

# 元素减

print(np.subtract(arr1, arr2)) # 输出：[-1 -1 -1]

# 元素乘

print(np.multiply(arr1, arr2)) # 输出：[ 2 6 12]

# 元素除

print(np.divide(arr1, arr2)) # 输出：[0.5 0.66666667 0.75 ]

```

要点提醒

在 numpy 模块中，sum 函数和 mean 函数的 axis 参数常用于对多维数组进行统计计算。

1. sum 函数的 axis 参数的用法

sum 函数主要用于对数组中的元素进行求和操作，axis 参数用于指定对数组的哪个轴进行求和计算。下面通过一个示例进行解释。

```python

import numpy as np

# 二维数组

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 对整个数组进行求和

print(np.sum(a)) # 输出：45

# 对每一行进行求和

print(np.sum(a, axis=1)) # 输出：[ 6 15 24]

# 对每一列进行求和

print(np.sum(a, axis=0)) # 输出：[12 15 18]

```

2. mean 函数的 axis 参数的用法

mean 函数主要用于求取数组中元素的平均值，axis 参数用于指定对数组的哪个轴进行求平均值计算。下面通过一个示例进行解释。

```python

import numpy as np

# 二维数组

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 对整个数组进行求平均值

print(np.mean(a)) # 输出：5.0

# 对每一行进行求平均值

print(np.mean(a, axis=1)) # 输出：[2. 5. 8.]

# 对每一列进行求平均值

print(np.mean(a, axis=0)) # 输出：[4. 5. 6.]

```

可以看出，当对二维数组进行 sum 和 mean 运算时，指定不同的 axis 参数可以计算行或列的总和或平均值。在处理多维数组时，axis 参数的使用则更加普遍，可以适用于任何维数的数组。

3. sort函数的axist参数的用法

```python
import numpy as np
# 创建一个3x3的随机二维数组
arr = np.random.randint(1, 10, size=(3, 3))

print("原始数组：")
print(arr)

# 沿着行的方向进行排序
arr_sort_row = np.sort(arr, axis=0)

print("按行排序后的数组：")
print(arr_sort_row)

# 沿着列的方向进行排序
arr_sort_col = np.sort(arr, axis=1)

print("按列排序后的数组：")
print(arr_sort_col)
```
输出结果为：
```
原始数组：
[[5 1 9]
 [9 3 9]
 [7 3 2]]
按行排序后的数组：
[[5 1 2]
 [7 3 9]
 [9 3 9]]
按列排序后的数组：
[[1 5 9]
 [3 9 9]
 [2 3 7]]
```

4.Numpy 库中常用的随机数生成函数

1. rand() 函数
rand() 函数返回一个给定形状的随机值，生成的随机值在 [0, 1) 之间，不包括1。
```python
import numpy as np
# 生成形状为 (2, 3) 的随机矩阵
x = np.random.rand(2, 3)
print(x)
```
输出：
```
[[0.81344097 0.90250322 0.07210593]
 [0.62093769 0.60349543 0.9849736 ]]
``
2. randn() 函数
randn() 函数返回一个给定形状的随机值，生成的随机值符合标准正态分布（均值为0，标准差为1）。
```python
import numpy as np

# 生成形状为 (2, 3) 的随机矩阵
x = np.random.randn(2, 3)
print(x)
```
输出：
```
[[ 0.49858236  0.32201294 -1.15378551]
 [-1.34922145 -0.07832679  0.19399717]]
```
3. randint() 函数
randint() 函数返回一个给定形状的随机整数，生成的随机整数范围在 [low, high) 之间，不包括 high。
```python
import numpy as np

# 生成形状为 (2, 3) 的随机整数矩阵，范围在 [0, 10) 之间
x = np.random.randint(low=0, high=10, size=(2, 3))
print(x)
```
输出：
```
[[5 3 8]
 [9 4 7]]
```
4. random() 函数
random() 函数返回一个随机值，生成的随机值在 [0, 1) 之间，不包括1。
```python
import numpy as np

# 生成一个随机值
x = np.random.random()
print(x)
```
输出：
```
0.5139695617902735
```

基本控制结构

Python 中的基本控制结构包括条件语句和循环语句。条件语句包括 if、elif 和 else，用于根据不同的条件执行不同的动作。循环语句包括 for 和 while，用于重复执行一段代码。

if 语句的用法：

```python

x = 10

if x > 5:

    print('x is greater than 5')

elif x == 5:

    print('x is equal to 5')

else:

    print('x is less than 5')

```

for 循环的用法：

```python

fruits = ['apple', 'banana', 'cherry']

for fruit in fruits:

    print(fruit)

```

while 循环的用法：

```python

i = 0

while i < 5:

    print(i)

    i += 1

```

元组、列表、字典

1. 元组
元组是一种不可变的序列，用小括号（）括起来，其中的元素可以是任意类型的，也可以包含其他的元组。
a = (1, 2, 3)
b = ("apple", "banana", "cherry")
c = (1, "hello", (2, 3))
元组的元素可以通过索引来访问，索引从0开始。
print(a[0]) # 输出1
print(b[1]) # 输出"banana"
print(c[2][0]) # 输出2
元组的切片也和列表一样。
print(a[1:]) # 输出(2, 3)
print(b[:2]) # 输出("apple", "banana")
元组不支持修改和删除操作，但是可以进行连接、重复、比较等操作。
print(a + b) # 输出(1, 2, 3, "apple", "banana", "cherry")
print(b * 2) # 输出("apple", "banana", "cherry", "apple", "banana", "cherry")
print(a == (1, 2, 3)) # 输出True
2. 列表
列表是一种可变的序列，用方括号[]括起来，其中的元素也可以是任意类型的，也可以包含其他的列表。
a = [1, 2, 3]
b = ["apple", "banana", "cherry"]
c = [1, "hello", [2, 3]]
列表的元素也可以通过索引来访问，索引从0开始。
print(a[0]) # 输出1
print(b[1]) # 输出"banana"
print(c[2][0]) # 输出2
列表的切片也和元组一样。
print(a[1:]) # 输出[2, 3]
print(b[:2]) # 输出["apple", "banana"]
列表支持修改、删除和新增元素的操作。
a[0] = 4 # 修改第一个元素为4
print(a) # 输出[4, 2, 3]
del b[1] # 删除第二个元素
print(b) # 输出["apple", "cherry"]
a.append(5) # 在末尾添加一个元素5
print(a) # 输出[4, 2, 3, 5]
3. 字典
字典是一种映射类型的数据结构，用花括号{}括起来，其中的元素是由键值对组成的，每个键值对之间用逗号隔开。
a = {"name": "Alice", "age": 20, "gender": "female"}
可以通过键来访问对应的值。
print(a["name"]) # 输出"Alice"
print(a["age"]) # 输出20
字典也支持新增、修改和删除元素的操作。
a["name"] = "Bob" # 修改name对应的值为"Bob"
print(a) # 输出{"name": "Bob", "age": 20, "gender": "female"}
del a["gender"] # 删除gender对应的键值对
print(a) # 输出{"name": "Bob", "age": 20}
a["height"] = 170 # 新增键值对"height": 170
print(a) # 输出{"name": "Bob", "age": 20, "height": 170}
字典也有一些常用的方法，比如keys()、values()、items()等。
print(a.keys()) # 输出dict_keys(["name", "age", "height"])
print(a.values()) # 输出dict_values(["Bob", 20, 170])
print(a.items()) # 输出dict_items([("name", "Bob"), ("age", 20), ("height", 170)])

字典的用法：

```python

dict1 = {'name': 'Alice', 'age': 20, 'city': 'Beijing'}

# 访问键值对

print(dict1['name']) # 输出：Alice

# 新增键值对和修改键值对

dict1['name'] = 'Bob'

dict1['gender'] = 'female'

# 删除键值对

del dict1['city']

# 遍历字典

for key, value in dict1.items():

    print(key, value)

```

 字符串的常用方法

字符串的常用方法

1. title()

将字符串中每个单词的首字母大写。

a = "hello world"

print(a.title()) # 输出"Hello World"

2. join()

将一个列表中的元素按照指定的分隔符连接成一个字符串。

a = ["apple", "banana", "cherry"]

b = ", ".join(a)

print(b) # 输出"apple, banana, cherry"

3. split()

将一个字符串按照指定的分隔符分割成一个列表。

a = "apple, banana, cherry"

b = a.split(", ")

print(b) # 输出["apple", "banana", "cherry"]

split()和join()方法可以组合使用，实现字符串的分割和连接。

a = "apple, banana, cherry"

b = a.split(", ")

c = "-".join(b)

print(c) # 输出"apple-banana-cherry"

函数基本用法

函数是代码复用的一种常见方式，在 Python 中定义函数使用 def 关键字。

函数的定义和调用：

```python

def add(x, y):

    return x + y

print(add(1, 2)) # 输出：3

```

Python 中的函数也支持设置默认值，可以减少函数调用时的参数输入：

```python

def greet(name='world'):

    print('Hello, {}!'.format(name))

greet() # 输出：Hello, world!

greet('Alice') # 输出：Hello, Alice!

```

文件操作

Python 中可以使用 open 函数来打开文件，使用 read 和 write 方法来读写文件。

下面是一个简单的例子，演示了如何使用open函数打开一个文件，并读取文件中的内容：

```python
# 打开文件，以只读模式打开
f = open('i.txt', 'r')

# 读取文件内容
content = f.read()

# 输出文件内容
print(content)

# 关闭文件
f.close()
```

在这个例子中，我们使用open函数打开一个名为i.txt的文件，并以只读模式打开。然后使用read方法读取文件中的内容，并将其赋给变量content。最后，我们输出content的值，并使用close方法关闭文件。

需要注意的是，在使用open函数打开文件后，一定要在使用完文件后记得使用close方法关闭文件。如果不关闭文件，可能会导致文件句柄泄漏，进而导致资源的浪费和一些其他的问题。另外，我们也可以使用with语句来自动关闭文件，这样可以更加简洁和安全。

write()是Python文件对象的一个方法，用于将指定的字符串或字节序列写入文件中。下面是一个简单的例子，演示了如何使用write方法向文件中写入内容：

```python
# 打开文件，以只写模式打开
f = open('o.txt', 'w')

# 向文件中写入内容
f.write('Hello, world!')

# 关闭文件
f.close()
```

在这个例子中，我们使用open函数打开一个名为o.txt的文件，并以只写模式打开。然后使用write方法向文件中写入了字符串'Hello, world!'。最后，我们使用close方法关闭文件。

需要注意的是，在使用write方法向文件中写入内容时，如果文件不存在，Python会自动创建该文件。如果文件已经存在，Python会覆盖文件中原有的内容。如果想要在文件中追加内容，可以使用以追加模式打开文件的方式：

```python
# 打开文件，以追加模式打开
f = open('o.txt', 'a')

# 向文件中追加内容
f.write('Hello, again!')

# 关闭文件
f.close()
```

在这个例子中，我们使用以追加模式打开文件的方式打开了同一个文件，并使用write方法向文件中追加了字符串'Hello, again!'。

生成器

Python 中的生成器可以用来迭代大量数据或者动态生成数据。生成器的主要特点是使用 yield 关键字来控制迭代过程，使得迭代对象只有在需要时才被计算、保存和生成。

生成器的示例：

```python

def my_range(n):

    i = 0

    while i < n:

        yield i

        i += 1

for num in my_range(5):

    print(num)

```

类的实例与类方法

Python类的实例方法是在类的实例上调用的方法，
第一个参数默认为self。
它可以访问类的实例变量和实例方法，并且可以通过self参数修改它们的值。例如：

```python
class MyClass:
    def __init__(self, value):
        self.value = value
        
    def increment(self):
        self.value += 1
        
my_obj = MyClass(10)
my_obj.increment()  # 等价于 MyClass.increment(my_obj)
print(my_obj.value)  # 输出 11
```

类方法是在类上调用的方法，第一个参数默认为cls。它可以访问类变量和类方法，并且可以通过cls参数修改它们的值。类方法使用@classmethod装饰器进行定义。例如：

```python
class MyClass:
    class_var = 0
    
    def __init__(self, value):
        self.value = value
    
    @classmethod
    def increment_class_var(cls):
        cls.class_var += 1
        
my_obj = MyClass(10)
MyClass.increment_class_var()  # 等价于 my_obj.increment_class_var()
print(MyClass.class_var)  # 输出 1
```

需要注意的是，在类方法中不能直接访问实例变量和实例方法，因为类方法是在类上调用的，而不是在类的实例上调用的。如果需要访问实例变量或方法，可以通过传入一个实例参数的方式来实现。例如：

```python
class MyClass:
    def __init__(self, value):
        self.value = value
    
    @classmethod
    def increment_instance_var(cls, obj):
        obj.value += 1
        
my_obj = MyClass(10)
MyClass.increment_instance_var(my_obj)
print(my_obj.value)  # 输出 11
```

单次随机漫步

单次随机漫步的目的是计算一系列随机步长的累计位移。具体实现过程如下：

```python

import random

position = 0

walk = [position]

steps = 1000

for i in range(steps):

    step = 1 if random.randint(0, 1) else -1

    position += step

    walk.append(position)

```

折线图的绘制和标注

在 Python 中，可以使用 matplotlib 模块来进行数据可视化的绘制，下面是折线图的绘制和标注的示例代码：

绘制折线图时，我们通常需要添加图片标题、x轴名称、y轴名称、图例、线的标记和类型等元素，这些元素可以通过matplotlib库中的各种函数和类来实现。

首先，我们需要导入matplotlib库中的pyplot模块。在Python中，pyplot模块通常起到画图的作用，包括画线、散点图、条形图等等。

```python

import matplotlib.pyplot as plt

```

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

y=[2,4,6,8,10]

接下来，我们可以使用plot函数来绘制折线图，plot函数接收两个参数，第一个参数是x轴上的数据，第二个参数是y轴上的数据。我们可以使用marker参数来指定线的标记，使用linestyle参数来指定线的类型，使用color参数来指定线的颜色。

plt.plot(x,y,color='k',linewidth=2,linestyle='-',marker='o')

我们还可以使用title、xlabel和ylabel函数来设置折线图的标题，x轴名称和y轴名称。

plt.title('auihfguiahrie')

plt.xlabel('x')

plt.ylabel('y')

plt.xticks([0,0.2,1])

plt.yticks([0,0.2,1.0])

# 添加图例
plt.legend(['line 1'],loc='upper left')

# 显示图像
plt.show()

在这个示例代码中，我们绘制了两条曲线，并指定了每一条曲线的标记和线型。我们还使用legend函数添加了图例。此外，还使用了subplots_adjust函数调整子图的位置和大小，使用title、xlabel和ylabel函数来设置折线图的标题，x轴名称和y轴名称。

在最后，我们使用show函数来将画出的图像显示出来。