zhouzhongping/wiki
1
0
Fork 0
Code

Python：文档修订

Browse Source
This commit is contained in:
周中平 2022-11-20 19:10:55 +08:00
parent 2495ebf0cb
commit dac396d0e8
No known key found for this signature in database
GPG Key ID: B1DF9DD42D8E00DC
4 changed files with 544 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
wiki/programming-language/Python/入门/函数方法.md
View File

@ -5,11 +5,20 @@ sidebar_position: 5
data: 2022年2月10日 data: 2022年2月10日
--- ---
## 函数
通过白盒/黑盒封装多行代码的实现，一般情况下拥有输入和输出，用来**简化代码**、**重复调用**和**模块化编程**。 通过白盒/黑盒封装多行代码的实现，一般情况下拥有输入和输出，用来**简化代码**、**重复调用**和**模块化编程**。
在 Python 中可以使用`def`关键字来定义函数，和变量一样每个函数也有一个响亮的名字，而且命名规则跟变量的命名规则是一致的。函数内的第一条语句是字符串时，该字符串就是**文档字符串**，也称为 docstring。 在 Python 中可以使用`def`关键字来定义函数，和变量一样每个函数也有一个响亮的名字，而且命名规则跟变量的命名规则是一致的。函数内的第一条语句是字符串时，该字符串就是**文档字符串**，也称为 docstring。
![img](https://static.7wate.com/img/2022/11/20/10cf11ddd3b18.png)
```python ```python
# 语法
def 函数名（参数列表）:
函数体
# 实例
def fib(n): def fib(n):
"""输出限定数值内的斐波那契数列函数""" """输出限定数值内的斐波那契数列函数"""
a, b = 0, 1 a, b = 0, 1
@ -19,7 +28,23 @@ def fib(n):
print() print()
``` ```
## 默认值参数 ### 参数传递
python 中类型属于对象，对象有不同类型的区分，变量是没有类型的。**python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象**。
#### 可更改与不可更改对象
在 python 中 strings,、tuples 和 numbers 是不可更改的对象，而 list、dict 等则是可以修改的对象。
- **不可变类型：**变量赋值 **a=5** 后再赋值 **a=10**，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
- **可变类型：**变量赋值 **la=[1,2,3,4]** 后再赋值 **la[2]=5** 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
#### 参数传递
- **不可变类型：**类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
- **可变类型：**类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响
### 默认值参数
在 Python 中，函数的参数可以有默认值，也支持使用可变参数，所以 Python 并不需要像其他语言一样支持函数的重载，因为我们在定义一个函数的时候可以让它有多种不同的使用方式。 在 Python 中，函数的参数可以有默认值，也支持使用可变参数，所以 Python 并不需要像其他语言一样支持函数的重载，因为我们在定义一个函数的时候可以让它有多种不同的使用方式。
@ -31,7 +56,7 @@ add(1,2)
# 3 # 3
``` ```
## 键值参数 ### 键值参数
`kwarg=value` 形式的 关键字参数 也可以用于调用函数。函数示例如下： `kwarg=value` 形式的 关键字参数 也可以用于调用函数。函数示例如下：
@ -51,9 +76,9 @@ parrot("halo",type="test")
# -- It's a stiff ! # -- It's a stiff !
``` ```
## 特殊参数 ### 特殊参数
### 可变参数 * #### 可变参数 *
在参数名前面的 * 表示 args 是一个可变参数，可以输入多个参数。 在参数名前面的 * 表示 args 是一个可变参数，可以输入多个参数。
@ -68,7 +93,7 @@ add2(1,2,3)
# 6 # 6
``` ```
### 键值参数 ** #### 键值参数 **
在参数名前面的 ** 表示 args 是一个可变参数，可以输入键值对。 在参数名前面的 ** 表示 args 是一个可变参数，可以输入键值对。
@ -80,7 +105,7 @@ add2(name="halo")
# {'name': 'halo'} # {'name': 'halo'}
``` ```
### 限位置参数 / #### 限位置参数 /
`/`必须放在形参后面表示限制位置参数，实参必须按照形参位置输入。 `/`必须放在形参后面表示限制位置参数，实参必须按照形参位置输入。
@ -89,7 +114,7 @@ def pos_only_arg(arg, /):
print(arg) print(arg)
``` ```
### 限关键字参数 * #### 限关键字参数 *
`*`必须放在形参前面表示限关键字参数，实参必须按键值参数输入。 `*`必须放在形参前面表示限关键字参数，实参必须按键值参数输入。
@ -124,11 +149,37 @@ Traceback (most recent call last):
TypeError: combined_example() got some positional-only arguments passed as keyword arguments: 'pos_only' TypeError: combined_example() got some positional-only arguments passed as keyword arguments: 'pos_only'
``` ```
## Lambda 表达式 ### return
lambda 关键字用于创建小巧的匿名函数。lambda a, b: a+b 函数返回两个参数的和。Lambda 函数可用于任何需要函数对象的地方。在语法上，匿名函数只能是单个表达式。在语义上，它只是常规函数定义的语法糖。与嵌套函数定义一样，lambda 函数可以引用包含作用域中的变量： **return [表达式]** 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。
```python ```python
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print ("函数内 : ", total)
return total
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)
```
## Lambda
lambda 关键字用于创建小巧的匿名函数。Lambda 函数可用于任何需要函数对象的地方。在语法上，匿名函数只能是单个表达式。在语义上，它只是常规函数定义的语法糖。与嵌套函数定义一样，lambda 函数可以引用包含作用域中的变量：
- **lambda** 只是一个表达式，函数体比 **def** 简单很多。
- lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
- lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
- 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
```python
# 语法
lambda [arg1 [,arg2,.....argn]]:expression
# 实例
>>> def make_incrementor(n): >>> def make_incrementor(n):
... return lambda x: x + n ... return lambda x: x + n
... ...
@ -138,3 +189,141 @@ lambda 关键字用于创建小巧的匿名函数。lambda a, b: a+b 函数返
>>> f(1) >>> f(1)
43 43
``` ```
## 迭代器
迭代器的使用非常普遍并使得 Python 成为一个统一的整体。 在幕后，for 语句会在容器对象上调用 `iter()`。 该函数返回一个定义了 `__next__()` 方法的迭代器对象，此方法将逐一访问容器中的元素。 当元素用尽时，`__next__()` 将引发 `StopIteration` 异常来通知终止 `for` 循环。 可以使用 `next()` 内置函数来调用 __next__() 方法；
- **iter()**：创建迭代器。
- **next()**：输出迭代器的下一个元素。
```python
s = 'abc'
it = iter(s)
print(it) # <str_iterator object at 0x10c90e650>
next(it) # 'a'
next(it) # 'b'
next(it) # 'c'
next(it)
# 抛出异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
next(it)
StopIteration
```
```python
# 为类添加迭代器
class Reverse:
"""Iterator for looping over a sequence backwards."""
def __init__(self, data):
self.data = data
self.index = len(data)
def __iter__(self):
return self
def __next__(self):
if self.index == 0:
raise StopIteration
self.index = self.index - 1
return self.data[self.index]
```
## yield 生成器
Python 中还有另外一种定义生成器的方式，就是通过`yield`关键字将一个普通函数改造成生成器函数。它们的写法类似于标准的函数，但当它们要返回数据时会使用 `yield` 语句。
```python
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
for i in fibonacci(10):
print(i,end=" ")
```
## 推导生成式
Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
### 列表
```python
# 语法
[out_exp_res for out_exp in input_list]
[out_exp_res for out_exp in input_list if condition]
# 实例
multiples = [i for i in range(30) if i % 3 == 0]
print(multiples) # [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
```
### 字典
```python
# 语法
{ key_expr: value_expr for value in collection }
{ key_expr: value_expr for value in collection if condition }
# 实例
dic = {x: x**2 for x in (2, 4, 6)}
print(dic) # {2: 4, 4: 16, 6: 36}
```
### 集合
```python
# 语法
{ expression for item in Sequence }
{ expression for item in Sequence if conditional }
# 实例
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a) # {'d', 'r'}
```
### 元组
```python
# 语法
(expression for item in Sequence )
(expression for item in Sequence if conditional )
# 实例
a = (x for x in range(1,10))
print(a) # 返回的是生成器对象
tuple(a) # 使用 tuple() 函数，可以直接将生成器对象转换成元组
```
### 其他
```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)
```

3
wiki/programming-language/Python/入门/控制语句.md
View File

@ -18,6 +18,7 @@ date: 2022-11-19
在Python中，要构造分支结构可以使用`if`、`elif`和`else`关键字。 在Python中，要构造分支结构可以使用`if`、`elif`和`else`关键字。
```python ```python
# 示例
>>> x = int(input("Please enter an integer: ")) >>> x = int(input("Please enter an integer: "))
Please enter an integer: 42 Please enter an integer: 42
>>> if x < 0: >>> if x < 0:
@ -156,6 +157,8 @@ for n in range(2, 10):
### try、except、finally ### try、except、finally
![img](https://static.7wate.com/img/2022/11/20/9a4509b47ebe3.png)
1. `except`语句不是必须的，`finally`语句也不是必须的，但是二者必须要有一个，否则就没有`try`的意义了。 1. `except`语句不是必须的，`finally`语句也不是必须的，但是二者必须要有一个，否则就没有`try`的意义了。
2. `except`语句可以有多个，Python会按`except`语句的顺序依次匹配你指定的异常，如果异常已经处理就不会再进入后面的`except`语句。 2. `except`语句可以有多个，Python会按`except`语句的顺序依次匹配你指定的异常，如果异常已经处理就不会再进入后面的`except`语句。
3. `except`语句可以以元组形式同时指定多个异常，参见实例代码。 3. `except`语句可以以元组形式同时指定多个异常，参见实例代码。

73
wiki/programming-language/Python/入门/数据类型.md
View File

@ -15,28 +15,48 @@ date: 2022-11-19
**Python 3 内置类型**如下，除了各种数据类型，Python 解释器内建了还有很多其他类型，比如上下文管理器类型，模块、方法、代码对象、类型对象、内部对象等类型。 **Python 3 内置类型**如下，除了各种数据类型，Python 解释器内建了还有很多其他类型，比如上下文管理器类型，模块、方法、代码对象、类型对象、内部对象等类型。
| 类型 | 可变性 | 描述 | 语法例子 | | 类型 | 可变性 | 描述 | 语法例子 |
| :------------------------: | :----: | :----------------------------------------------------------: | :----------------------------------------------------------: | | :------------------------: | :------: | :----------------------------------------------------------: | :----------------------------------------------------------: |
| `bool` | 不可变 | 布尔值 | `True` `False` | | `bool` | 不可变 | 布尔值 | `True` `False` |
| `int` | 不可变 | 理论上无限制大小的整数 | `42` | | `int` | 不可变 | 理论上无限制大小的整数 | `42` |
| `float` | 不可变 | 双精度浮点数。精度是机器依赖的但实际上一般实现为 64 位IEEE 754 数而带有 53 位的精度 | `1.414` | | `float` | 不可变 | 双精度浮点数。精度是机器依赖的但实际上一般实现为 64 位IEEE 754 数而带有 53 位的精度 | `1.414` |
| `complex` | 不可变 | 复数，具有实部和虚部 | `3+2.7j` | | `complex` | 不可变 | 复数，具有实部和虚部 | `3+2.7j` |
| `range` | 不可变 | 通常用在循环中的数的序列，规定在 for 循环中的次数 | `range(1, 10)` `range(10, -5, -2)` | | `range` | 不可变 | 通常用在循环中的数的序列，规定在 for 循环中的次数 | `range(1, 10)` `range(10, -5, -2)` |
| `str` | 不可变 | 字符串，Unicode 代码点序列 | `'Wikipedia'` `"Wikipedia"` `"""Spanning multiple lines"""` | | `str` | 不可变 | 字符串，Unicode 代码点序列 | `'Wikipedia'` `"Wikipedia"` `"""Spanning multiple lines"""` |
| `bytes` | 不可变 | 字节序列 | `b'Some ASCII'` `b"Some ASCII"` `bytes([119, 105, 107, 105])` | | `bytes` | 不可变 | 字节序列 | `b'Some ASCII'` `b"Some ASCII"` `bytes([119, 105, 107, 105])` |
| `bytearray` | 可变 | 字节序列 | `bytearray(b'Some ASCII')` `bytearray(b"Some ASCII")` `bytearray([119, 105, 107, 105])` | | `bytearray` | **可变** | 字节序列 | `bytearray(b'Some ASCII')` `bytearray(b"Some ASCII")` `bytearray([119, 105, 107, 105])` |
| `list` | 可变 | 列表，可以包含混合的类型 | `[4.0, 'string', True]` `[]` | | `list` | **可变** | 列表，可以包含混合的类型 | `[4.0, 'string', True]` `[]` |
| `tuple` | 不可变 | 元组，可以包含混合的类型 | `(4.0, 'string', True)` `('single element',)` `()` | | `tuple` | 不可变 | 元组，可以包含混合的类型 | `(4.0, 'string', True)` `('single element',)` `()` |
| `dict` | 可变 | 键-值对的关联数组（或称字典）；可以包含混合的类型（键和值），键必须是可散列的类型 | `{'key1': 1.0, 3: False}` `{}` | | `dict` | **可变** | 键-值对的关联数组（或称字典）；可以包含混合的类型（键和值），键必须是可散列的类型 | `{'key1': 1.0, 3: False}` `{}` |
| `set` | 可变 | 无序集合，不包含重复项；可以包含混合的类型，如果可散列的话 | `{4.0, 'string', True}` `set()` | | `set` | **可变** | 无序集合，不包含重复项；可以包含混合的类型，如果可散列的话 | `{4.0, 'string', True}` `set()` |
| `frozenset` | 不可变 | 无序集合，不包含重复项；可以包含混合的类型，如果可散列的话 | `frozenset([4.0, 'string', True])` | | `frozenset` | 不可变 | 无序集合，不包含重复项；可以包含混合的类型，如果可散列的话 | `frozenset([4.0, 'string', True])` |
| `types.EllipsisType` | 不可变 | 省略号占位符，用作 NumPy 数组的索引 | `...` `Ellipsis` | | `types.EllipsisType` | 不可变 | 省略号占位符，用作 NumPy 数组的索引 | `...` `Ellipsis` |
| `types.NoneType` | 不可变 | 表示值缺席的对象，在其他语言中经常叫做 null | `None` | | `types.NoneType` | 不可变 | 表示值缺席的对象，在其他语言中经常叫做 null | `None` |
| `types.NotImplementedType` | 不可变 | 可从重载运算符返回的占位符，用来指示未支持的运算数（operand）类型 | `NotImplemented` | | `types.NotImplementedType` | 不可变 | 可从重载运算符返回的占位符，用来指示未支持的运算数（operand）类型 | `NotImplemented` |
## 类型转换
| 函数 | 描述 |
| :-------------------- | :-------------------------------------------------- |
| int(x [,base]) | 将x转换为一个整数 |
| float(x) | 将x转换到一个浮点数 |
| complex(real [,imag]) | 创建一个复数 |
| str(x) | 将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| set(s) | 转换为可变集合 |
| dict(d) | 创建一个字典。d 必须是一个 (key, value)元组序列。 |
| frozenset(s) | 转换为不可变集合 |
| chr(x) | 将一个整数转换为一个字符 |
| ord(x) | 将一个字符转换为它的整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |
## 运算符 ## 运算符
在实际开发中，如果搞不清楚运算符的优先级，可以使用括号来确保运算的执行顺序。 在实际开发中，如果搞不清楚运算符的优先级，可以**使用括号来确保运算的执行顺序**。
| 运算符 | 描述 | | 运算符 | 描述 |
| ------------------------------------------------------------ | ------------------------------ | | ------------------------------------------------------------ | ------------------------------ |
@ -53,18 +73,17 @@ date: 2022-11-19
| `is` `is not` | 身份运算符 | | `is` `is not` | 身份运算符 |
| `in` `not in` | 成员运算符 | | `in` `not in` | 成员运算符 |
| `not` `or` `and` | 逻辑运算符 | | `not` `or` `and` | 逻辑运算符 |
| `=` `+=` `-=` `*=` `/=` `%=` `//=` `**=` `&=` `| =` `^=` `>>=` `<<=` | | | `=` `+=` `-=` `*=` `/=` `%=` `//=` `**=` `&=` `| =` `^=` `>>=` `<<=` | 赋值运算符 |
## 关键字 ## 关键字
Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：
```python ```python
False await else import pass $ import keyword
None break except in raise $ print(keyword.kwlist)
True class finally is return
and continue for lambda try ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
as def from nonlocal while
assert del global not with
async elif if or yield
``` ```
## 声明 ## 声明

547
wiki/programming-language/Python/入门/数据结构.md
View File

@ -1,15 +1,67 @@
--- ---
id: 数据结构
title: 数据结构 title: 数据结构
description: Python 数据结构
keywords:
- Python
- 数据结构
tags:
- Python
sidebar_position: 4 sidebar_position: 4
data: 2022年2月11日 author: 7Wate
date: 2022-11-20
--- ---
## 数字
Python 数字数据类型用于存储数值。数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。Python 支持三种不同的数值类型：
- **整型(int)** - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔（bool）是整型的子类型。
- **浮点型(float)** - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- **复数( (complex))** - 复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
```python
num1 = -100 # 整数
num2 = 200.01 # 浮点数
num3 = 0xA0F # 十六进制
num4 = 0o37 # 八进制
# 数学常量 PI 和 e
pi
e
# 绝对值
abs(num1)
# 向上取整
ceil(num2)
# 返回最大数
max(num1, num2)
# x**y 运算后的值
pow(num1, num2)
# 随机数
random.random()
# x弧度的正弦值。
sin(x)
```
## 字符串 ## 字符串
所谓**字符串**，就是由零个或多个字符组成的有限序列。在Python程序中，如果我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。 所谓**字符串**，就是由零个或多个字符组成的有限序列。在Python程序中，如果我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。
- 单引号 **'** 和双引号 **"** 使用完全相同。
- 三引号(**'''** 或 **"""**)可以指定一个多行字符串。
- 反斜杠 **\\** 可以用来转义，使用 **r** 可以让反斜杠不发生转义。
- 字面意义级联字符串：如 **"this " "is " "string"** 会被自动转换为 **this is string**。
- 字符串有两种索引方式，从左往右以 **0** 开始，从右往左以 **-1** 开始。
- 字符串不能改变，一个字符就是长度为 1 的字符串。
- 字符串的截取的语法格式如下：**变量[头下标:尾下标:步长]**
![img](https://static.7wate.com/img/2022/11/20/7158615419c61.png)
```python ```python
# 单引号、双引号字符串 # 单引号、双引号字符串
s1 = 'hello, world!' s1 = 'hello, world!'
@ -21,52 +73,127 @@ hello,
world! world!
""" """
#在字符串中使用 \（反斜杠）来表示转义 # 在字符串中使用 \（反斜杠）来表示转义
s4 = '\n\t\141\u9a86\u660a' s4 = '\n\t\141\u9a86\u660a'
#字符串开头使用 r 来取消转义 # 字符串开头使用 r 来取消转义
s5 = r'\n\\hello, world!\\\n' s5 = r'\n\\hello, world!\\\n'
#输出：\n\\hello, world!\\\n # 输出：\n\\hello, world!\\\n
print(s1, s2, s3, s4, s5 end='') # 级联字符串
s6 = "this " "is " "string"
# 输出：this is string
# 字符串无法改变
s6[2] = "c"
# 输出：错误！
``` ```
### 字符串运算 ### 转义
- 使用`+`运算符来实现字符串的拼接 | 转义字符 | 描述 | 实例 |
- 使用`*`运算符来重复一个字符串的内容 | :---------- | :----------------------------------------------------------- | :----------------------------------------------------------- |
- 使用`in`和`not in`来判断一个字符串是否包含另外一个字符串（成员运算） | \(在行尾时) | 续行符 | `>>> print("line1 \ ... line2 \ ... line3") line1 line2 line3 >>> ` |
- 使用`[]`和`[:]`运算符从字符串取出某个字符或某些字符（切片运算） | \\ | 反斜杠符号 | `>>> print("\\") \` |
| \' | 单引号 | `>>> print('\'') '` |
| \" | 双引号 | `>>> print("\"") "` |
| \a | 响铃 | `>>> print("\a")`执行后电脑有响声。 |
| \b | 退格(Backspace) | `>>> print("Hello \b World!") Hello World!` |
| \000 | 空 | `>>> print("\000") >>> ` |
| \n | 换行 | `>>> print("\n") >>>` |
| \v | 纵向制表符 | `>>> print("Hello \v World!") Hello World! >>>` |
| \t | 横向制表符 | `>>> print("Hello \t World!") Hello World! >>>` |
| \r | 回车，将 **\r** 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 **\r** 后面的内容完全替换完成。 | `>>> print("Hello\rWorld!") World! >>> print('google runoob taobao\r123456') 123456 runoob taobao` |
| \f | 换页 | `>>> print("Hello \f World!") Hello World! >>> ` |
| \yyy | 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 | `>>> print("\110\145\154\154\157\40\127\157\162\154\144\41") Hello World!` |
| \xyy | 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行 | `>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21") Hello World!` |
| \other | 其它的字符以普通格式输出 | |
### 运算
| 操作符 | 描述 | 实例 |
| :----- | :----------------------------------------------------------- | :------------------------------ |
| + | 字符串连接 | a + b 输出结果： HelloPython |
| * | 重复输出字符串 | a*2 输出结果：HelloHello |
| [] | 通过索引获取字符串中字符 | a[1] 输出结果 **e** |
| [ : ] | 截取字符串中的一部分，遵循**左闭右开**原则，str[0:2] 是不包含第 3 个字符的。 | a[1:4] 输出结果 **ell** |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | **'H' in a** 输出结果 True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | **'M' not in a** 输出结果 True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 **r**（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | `print( r'\n' ) print( R'\n' )` |
```python ```python
# 字符串 * 运算 a = "Hello"
s1 = 'hello ' * 3 b = "Python"
# hello hello hello
print("a + b 输出结果：", a + b) # a + b 输出结果： HelloPython
# 字符串相加 print("a * 2 输出结果：", a * 2) # a * 2 输出结果： HelloHello
s2 = 'world' print("a[1] 输出结果：", a[1]) # a[1] 输出结果： e
s1 += s2 print("a[1:4] 输出结果：", a[1:4]) # a[1:4] 输出结果： ell
# hello hello hello world
if( "H" in a) : # H 在变量 a 中
# 字符串 in、not in运算 print("H 在变量 a 中")
print('ll' in s1) # True else :
print('good' in s1) # False print("H 不在变量 a 中")
if( "M" not in a) : # M 不在变量 a 中
str2 = 'abc123456' print("M 不在变量 a 中")
# 从字符串中取出指定位置的字符(下标运算) else :
print(str2[2]) # c print("M 在变量 a 中")
# 字符串切片(从指定的开始索引到指定的结束索引) print (r'\n') # \n
print(str2[2:5]) # c12 print (R'\n') # \n
print(str2[2:]) # c123456
print(str2[2::2]) # c246
print(str2[::2]) # ac246
print(str2[::-1]) # 654321cba
print(str2[-3:-1]) # 45
``` ```
### 常用字符串函数 ### 格式化
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
```python
print ("我叫 %s 今年 %d 岁!" % ('小明', 10)) # 我叫 小明 今年 10 岁!
```
#### 符号
| 符 号 | 描述 |
| :----- | :----------------------------------- |
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
#### 辅助指令
| 符号 | 功能 |
| :---- | :----------------------------------------------------------- |
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| <sp> | 在正数前面显示空格 |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
### `f`格式化输出
**Python 3.6** 以后，格式化字符串还有更为简洁的书写方式，就是在字符串前加上字母`f`，我们可以使用下面的语法糖来简化上面的代码。其可以通过变量后 冒号+数字 指定输出宽度，例如 {a:10} 将占用 10 个字符宽度。
```python
a, b = 5, 10
print(f'{a:10} * {b:10} = {a * b}')
```
### 常用函数
```python ```python
str1 = 'hello, world!' str1 = 'hello, world!'
@ -119,60 +246,38 @@ str3 = ' jackfrued@126.com '
str3.strip() str3.strip()
``` ```
### 字符串`f`格式化输出
**Python 3.6** 以后，格式化字符串还有更为简洁的书写方式，就是在字符串前加上字母`f`，我们可以使用下面的语法糖来简化上面的代码。
```python
a, b = 5, 10
print(f'{a} * {b} = {a * b}')
```
## 列表（List） ## 列表（List）
数值类型是标量类型，也就是说这种类型的对象没有可以访问的内部结构；而字符串类型是一种结构化的、非标量类型，所以才会有一系列的属性和方法。接下来我们要介绍的列表（`list`），也是一种结构化的、非标量类型，它是值的有序序列，每个值都可以通过索引进行标识，定义列表可以将列表的元素放在`[]`中，多个元素用`,`进行分隔，可以使用`for`循环对列表元素进行遍历，也可以使用`[]`或`[:]`运算符取出列表中的一个或多个元素。 列表（`list`）是一种结构化的、非标量类型，它是值的有序序列，每个值都可以通过索引进行标识，定义列表可以将列表的元素放在`[]`中，多个元素用`,`进行分隔，可以使用`for`循环对列表元素进行遍历，也可以使用`[]`或`[:]`运算符取出列表中的一个或多个元素。
### 定义和操作 ### 操作
```python ```python
list1 = [1, 3, 5, 7, 100] # 列表定义
print(list1) # [1, 3, 5, 7, 100] list1 = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
# 乘号表示列表元素的重复 print (list1) # 输出完整列表
list2 = ['hello'] * 3 print (list1[0]) # 输出列表第一个元素
print(list2) # ['hello', 'hello', 'hello'] print (list1[1:3]) # 从第二个开始输出到第三个元素
print (list1[2:]) # 输出从第三个元素开始的所有元素
# 计算列表长度(元素个数) print (tinylist * 2) # 输出两次列表
print(len(list1)) # 5 print (list1 + tinylist) # 连接列表
# 下标(索引)运算
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)): for index in range(len(list1)):
print(list1[index]) print(list1[index])
# 通过for循环遍历列表元素 # 通过for 循环遍历列表元素
for elem in list1: for elem in list1:
print(elem) print(elem)
# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值 # 通过 enumerate 函数处理列表之后再遍历可以同时获得元素索引和值
for index, elem in enumerate(list1): for index, elem in enumerate(list1):
print(index, elem) print(index, elem)
```
### 元素移除
```python
list1 = [1, 3, 5, 7, 100]
# 添加元素 # 添加元素
list1.append(200) list1.append(200)
list1.insert(1, 400) list1.insert(1, 400)
@ -180,28 +285,37 @@ list1.insert(1, 400)
# 合并两个列表 # 合并两个列表
# list1.extend([1000, 2000]) # list1.extend([1000, 2000])
list1 += [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.insert(2,700)
list1.remove(3)
if 1234 in list1:
list1.remove(1234)
print(list1) # [1, 400, 5, 7, 100, 200, 1000, 2000]
# 从指定的位置删除元素 # 删除元素
list1.remove(700)
# 指定位置删除元素
list1.pop(0) list1.pop(0)
list1.pop(len(list1) - 1) list1.pop(len(list1) - 1)
print(list1) # [400, 5, 7, 100, 200, 1000]
# 清空列表元素 # 删除列表所有元素
list1.clear() list1.clear()
print(list1) # []
# 返回元素索引
list1.index(700)
# 返回元素出现次数
list1.count(700)
# 翻转列表中的元素
list1.reverse()
# 返回列表的浅拷贝
list1.copy()
``` ```
### 切片 ### 切片
![img](https://static.7wate.com/img/2022/11/20/03b82ae504a58.png)
```python ```python
fruits = ['grape', 'apple', 'strawberry', 'waxberry'] fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango'] fruits += ['pitaya', 'pear', 'mango']
@ -212,49 +326,32 @@ print(fruits2) # apple strawberry waxberry
# 可以通过完整切片操作来复制列表 # 可以通过完整切片操作来复制列表
fruits3 = fruits[:] fruits3 = fruits[:]
print(fruits3) # ['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
fruits4 = fruits[-3:-1] fruits4 = fruits[-3:-1]
print(fruits4) # ['pitaya', 'pear'] print(fruits4) # ['pitaya', 'pear']
# 可以通过反向切片操作来获得倒转后的列表的拷贝 # 通过反向切片操作来获得倒转后的列表的拷贝
fruits5 = fruits[::-1] fruits5 = fruits[::-1]
print(fruits5) # ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape'] 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 中的元组与列表类似也是一种容器数据类型，可以用一个变量（对象）来存储多个数据，不同之处在于元组的元素不能修改，在前面的代码中我们已经不止一次使用过元组了。顾名思义，我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。 Python 中的元组与列表类似也是一种容器数据类型，元组使用小括号 **( )**，列表使用方括号 **[ ]**；元组可以用一个变量（对象）来存储多个数据，不同之处在于**元组的元素不能修改**。
![img](https://static.7wate.com/img/2022/11/20/49dc8db289c04.png)
### 操作
```python ```python
# 定义元组 # 定义元组
t = ('骆昊', 38, True, '四川成都') t = ('骆昊', 38, True, '四川成都')
print(t)
# 获取元组中的元素 # 定义空元组
print(t[0]) t1 = ()
print(t[3])
# 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用。
tup1 = (50) # 不加逗号，类型为整型
tup1 = (50,) # 加上逗号，类型为元组
# 遍历元组中的值 # 遍历元组中的值
for member in t: for member in t:
@ -264,141 +361,135 @@ for member in t:
# t[0] = '王大锤' # TypeError # t[0] = '王大锤' # TypeError
# 变量t重新引用了新的元组原来的元组将被垃圾回收 # 变量t重新引用了新的元组原来的元组将被垃圾回收
t = ('王大锤', 20, True, '云南昆明') t = ('王大锤', 20, True, '云南昆明')
print(t)
# 将元组转换成列表 # 将元组转换成列表
person = list(t) person = list(t)
print(person)
# 列表是可以修改它的元素的
person[0] = '李小龙'
person[1] = 25
print(person)
# 将列表转换成元组 # 将列表转换成元组
fruits_list = ['apple', 'banana', 'orange'] fruits_list = ['apple', 'banana', 'orange']
fruits_tuple = tuple(fruits_list) fruits_tuple = tuple(fruits_list)
print(fruits_tuple)
# 创建一个新的元组
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2
# 删除元组
tup = ('Google', 'Runoob', 1997, 2000)
del tup
``` ```
### 切片
![img](https://static.7wate.com/img/2022/11/20/62a764ad48690.png)
```python
tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
```
| Python 表达式 | 结果 | 描述 |
| :------------ | :---------------------------------------------- | :----------------------------------------------- |
| tup[1] | 'Runoob' | 读取第二个元素 |
| tup[-2] | 'Weibo' | 反向读取，读取倒数第二个元素 |
| tup[1:] | ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin') | 截取元素，从第二个开始后的所有元素。 |
| tup[1:4] | ('Runoob', 'Taobao', 'Wiki') | 截取元素，从第二个开始到第四个元素（索引为 3）。 |
## 集合 ## 集合
集合是由不重复元素组成的无序容器。基本用法包括成员检测、消除重复元素。集合对象支持合集、交集、差集、对称差分等数学运算。 集合（set）是由不重复元素组成的无序容器。基本用法包括成员检测、消除重复元素。集合对象支持合集、交集、差集、对称差分等数学运算。
创建集合用花括号或 set() 函数。注意，创建空集合只能用 set()，不能用 {}，{} 创建的是空字典 创建集合用花括号或 set() 函数。注意，创建空集合只能用 set()，不能用 {}，{} 创建的是空字典
### 创建和使用 ### 操作
```python ```python
# 创建集合的字面量语法 # 演示去重功能
set1 = {1, 2, 3, 3, 3, 2} basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(set1) print(basket) # 输出 {'orange', 'banana', 'pear', 'apple'}
print('Length =', len(set1))
# 创建集合的构造器语法(面向对象部分会进行详细讲解) # 判断元素是否在集合内
set2 = set(range(1, 10)) 'orange' in basket # True
set3 = set((1, 2, 3, 3, 2, 1)) 'crabgrass' in basket # Flase
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) basket.add(400)
set1.add(5) basket.add(500)
# 更新
set2.update([11, 12])
# 删除 # 删除
set2.discard(5) basket.remove('apple')
if 4 in set2: basket.discard('orange')
set2.remove(4)
# 元素个数
print(set1, set2) len(basket)
print(set3.pop())
print(set3) # 清空
basket.clear()
``` ```
### 交集、并集、差集运算 ### 运算
```python ```python
# 集合的交集、并集、差集、对称差运算 # 交集
print(set1 & set2) print(set1 & set2)
# print(set1.intersection(set2)) # 并集
print(set1 | set2) print(set1 | set2)
# print(set1.union(set2)) # 差集
print(set1 - set2) print(set1 - set2)
# print(set1.difference(set2)) # 对称差运算
print(set1 ^ set2) print(set1 ^ set2)
# print(set1.symmetric_difference(set2))
# 判断子集和超集 # 判断子集和超集
print(set2 <= set1) print(set2 <= set1)
# print(set2.issubset(set1))
print(set3 <= set1) print(set3 <= set1)
# print(set3.issubset(set1))
print(set1 >= set2) print(set1 >= set2)
# print(set1.issuperset(set2))
print(set1 >= set3) print(set1 >= set3)
# print(set1.issuperset(set3))
``` ```
## 字典 ## 字典
字典是另一种可变容器模型，Python 中的字典跟我们生活中使用的字典是一样一样的，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。 字典是另一种可变容器模型，且**可存储任意类型对象**。字典与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的**键值对**，键和值通过冒号分开。键必须是唯一的，但值则不必。
![img](https://static.7wate.com/img/2022/11/20/6f5d818eb8092.png)
![img](https://static.7wate.com/img/2022/11/20/0e8264c5acc5a.png)
字典实例：
```python ```python
# 创建字典的字面量语法 tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
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)
``` ```
## 循环技巧 ### 操作
```python
# 使用大括号 {} 来创建空字典
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 使用内建函数 dict() 创建字典
emptyDict = dict()
# 打印字典
print(tinydict)
# 查看字典的数量
print("Length:", len(tinydict))
# 查看类型
print(type(tinydict))
# 访问字典里的值
print ("tinydict['Name']: ", tinydict['Name'])
# 修改字典
tinydict['Age'] = 8 # 更新 Age
tinydict['School'] = "菜鸟教程" # 添加信息
# 删除字典元素
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典
```
### 循环
在字典中循环时，用 `items()` 方法可同时取出键和对应的值： 在字典中循环时，用 `items()` 方法可同时取出键和对应的值：
@ -435,47 +526,3 @@ for q, a in zip(questions, answers):
# What is your favorite color? It is blue. # What is your favorite color? It is blue.
``` ```
## 生成式
```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()
```