系列文章目录
Python数据科学家养成计划（Python学习指南）前言
随着人工智能的不断发展，数据科学相关技术也越来越重要，很多人都开启了学习数据科学相关知识体系的学习之旅，本文就介绍了数据科学中 Python 的基础内容。
一、语句与注释
1. 语句
语句：程序进行编写，执行的每一行代码，叫做语句。
print("hello world")
2. 注释
注释：对代码的解释和说明，可以提高代码的可读性。
- 注释分为单行注释和多行注释；
- 单行注释以 # 开始
- 多行注释，可以使用三对双引号 “”" “”" 或者三对单引号 ‘’’ ‘’’
# 单行注释
# 输出 hello world 语句
print("hello world")
# 定义字符串变量
name = "貂蝉"
'''
我是多行注释
我是多行注释
我是多行注释
'''
age = 18
"""
我也是多行注释
我也是多行注释
我也是多行注释
"""
sex = "女"
二、变量与赋值
1. 变量的定义
变量：通俗理解就是存储程序数据的容器。
变量定义的格式：
变量名 = 数据（变量名尽量有含义，见名知意，方便理解）
name = "貂蝉"
skill = 450
money = 1.98
is_ok = True
可以通过 Python 内置的 type() 函数查看变量的类型。
type(name) # str
type(skill) # int
type(money) # float
type(is_ok) # bool
常用的数据类型： int、str、float、bool
2. 变量的命名规则
变量名：是由数字、字母、下划线组成，注意是只有这三种，但是不能以数字开头。
错误的使用：报错 "SyntaxError: invalid syntax"
3name = "貂蝉" # 以数字开头
name!age = 108 # 出现了 数字、字母、下划线 之外的字符 "感叹号"
变量命名方式：驼峰命名法和下划线命名法
- 驼峰命名法：小驼峰和大驼峰
- 小驼峰命名法：第一个单词首字母要小写，其他单词首字母都大写。
- 大驼峰命名法：每个单词首字母都大写。
- 划线命名法：单词小写，单词之间使用下划线进行分割。
hero_name = "寒冰射手" # 下划线命名法 -> 推荐使用
heroName = "德玛西亚之力" # 小驼峰命名法
HeroName = "诺克萨斯之手" # 大驼峰命名法
3. 关键字
关键字：在 Python 里面具有特殊功能的标识符（理解成变量名、函数名），关键字不能作为变量名使用。
关键字如下：
‘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’
如何查看 Python 的关键字：
(1) 方法一
a. win+r打开运行窗口输入cmd，打开命令提示符窗口。
b. 打开 Python Shell，输入
import keyword
keyword.kwlist
即可。
(2) 方法二
打开 Pycharm，输入
import keyword
print(keyword.kwlist)
即可。
4. 数据类型转换
| 函数 | 函数说明 |
|---|---|
| int(x [,base ]) | 将 x 转换为一个整数 |
| float(x) | 将 x 转换为一个浮点数 |
| str(x) | 将对象 x 转换为字符串 |
| complex(real [,imag ]) | 创建一个复数，real 为实部，imag 为虚部 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | 计算在字符串中有效 Python 表达式，并返回一个对象 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| chr(x) | 将一个整数转换为一个 Unicode 字符串 |
| ord(x) | 将一个字符转换为它的 ASCII 整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |
| bin(x) | 将一个整数转换为一个二进制字符串 |
错误的使用：报错 "TypeError: unsupported operand type(s) for +: ‘int’ and ‘str’"
a = 100
b = "200"
result = a + b
print(result)
正确的使用：
a = 100
b = "200"
result = a + int(b)
print(result) # 300
三、输入与输出
1. Python 中的输入
input：用来获取用户输入的数据。
# 接收用户输入的数据
name = input("请输入你的名字：")
# 输出用户输入的名字
print(name)
注：当你运行完毕 name = input(“请输入你的名字：”) 代码并将鼠标光标移动到控制台，Python 交互式命令就等待输入，可以输入任意字符，然后按回车完成输入。
重点：不论输入框中输入任何数据类型的数据，等号左边的变量接收到的输入值都为 str 类型。
2. Python 中的输出
print：用于打印输出。
print() 函数语法如下：
print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
参数
- objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
- sep – 用来间隔多个对象，默认值是一个空格。
- end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
- file – 要写入的文件对象。
- flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。
(1) 输出字符串和数字
print("Hello World") # 输出字符串 Hello World
print(100) # 输出数字 100
str = "Hello World"
print(str) # 输出变量 Hello World
l = [1, 2, "a"] # 列表 [1, 2, 'a']
print(l)
t = (1, 2, "a") # 元组 (1, 2, 'a')
print(t)
d = {"a": 1, "b": 2} # 字典 {'a': 1, 'b': 2}
print(d)
(2) 格式化输出整数
支持参数格式化，与 C 语言的 printf 类似。
str = "%s的平均薪资是%d元人民币。" % ("数据科学家", 30000)
print(str) # 数据科学家的平均薪资是30000元人民币。
Python 字符串格式化符号：
| 符 号 | 描 述 |
|---|---|
| %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 是小数点后的位数(如果可用的话) |
(3) 格式化输出 16 进制，10 进制，8 进制
#%x – hex 十六进制
#%d – dec 十进制
#%o – oct 八进制
nHex = 0xFF
print("nHex = %x, nDec = %d, nOct = %o" %(nHex, nHex, nHex))
# nHex = ff, nDec = 255, nOct = 377
(4) 格式化输出浮点数(float)
pi = 3.141592653
print("%10.3f" % pi) # 字段宽 10，精度 3 3.142(注意整数3的前面有5个空格)
print("pi = %.*f" % (3, pi)) # 用 * 从后面的元组中读取字段宽度或精度 pi = 3.142
pi = 3.142
print("%010.3f" % pi) # 用 0 填充空白 000003.142
print("%-10.3f" % pi) # 左对齐 3.142
print("%+f" % pi) # 显示正负号 +3.142000
(5) 自动换行
print() 函数会自动在行末加上回车，如果不需回车，只需在 print 语句的结尾添加一个英文逗号，并设置分隔符参数 end，就可以改变它的行为。
自动在行末加上回车：
for i in range(0, 6):
print(i)
0
1
2
3
4
5
不需回车：
for i in range(0, 6):
print(i, end=" ")
0 1 2 3 4 5
(6) print 不换行
在 Python 中 print() 函数默认是换行的：
for i in range(0, 3):
print(i)
0
1
2
要想不换行，应该写成 print(i, end = " ")
for i in range(0, 3):
print(i, end=" ")
0 1 2
四、运算符
什么是运算符？
答：举个简单的例子 4 + 5 = 9 。例子中，4 和 5 被称为 操作数 ，" + " 称为运算符。
Python 语言支持的运算符：
- 算术运算符
- 比较（关系）运算符
- 赋值运算符
- 逻辑运算符
- 位运算符
- 成员运算符
- 身份运算符
1. Python 算术运算符
Python 支持以下几种算术运算符：x=10, y=20, z=25
| 运算符 | 描 述 | 实例 |
|---|---|---|
| + | 加 – 两个对象相加 | x + y 输出结果 30 |
| - | 减 – 得到负数或是一个数减去另一个数 | x - y 输出结果 -10 |
| * | 乘 – 两个数相乘或是返回一个被重复若干次的字符串 | x * y 输出结果 200 |
| / | 除 – x 除以 y | y / x 输出结果 2 |
| % | 取模 – 返回除法的余数 | y % x 输出结果 0 |
| ** | 幂 – 返回 x 的 y 次幂 | x**y 为 10 的 20 次方，输出结果 100000000000000000000 |
| // | 取整除 – 返回商的整数部分（向下取整） | 9 // 2 >> 4 -9 // 2 >> -5 |
x, y, z =10, 20, 25
# 加法
sum = x + y
print("{} + {} = {}".format(x, y, sum)) # 30
# 减法
difference = x - y
print("{} - {} = {}".format(x, y, difference)) # -10
# 乘法
product = x * y
print("{} * {} = {}".format(x, y, product)) # 200
# 除法
quotient = y / x
print("{} / {} = {}".format(y, x, quotient)) # 2.0
# 取模
modulus = y % x
print("{} % {} = {}".format(y, x, modulus)) # 0
# 幂运算
power = x ** y
print("{} ** {} = {}".format(x, y, power)) # 100000000000000000000
# 取整数（向下取整）
round_numbers = 9 // 2
print("9 // 2 = {}".format(round_numbers)) # 4
2. Python 比较运算符
Python 支持以下几种比较运算符：x=10, y=20
| 运算符 | 描 述 | 实例 |
|---|---|---|
| == | 等于 – 比较对象是否相等 | (x == y) 返回 False |
| != | 不等于 – 比较对象是否不相等 | (x ！= y) 返回 True |
| > | 大于 – 返回 x 是否大于 y | (x > y) 返回 False |
| < | 小于 – 返回 x 是否小于 y | (x < y) 返回 True |
| >= | 大于等于 – 返回 x 是否大于等于 y | (x >= y) 返回 False |
| <= | 小于等于 – 返回 x 是否小于等于 y | (x <= y) 返回 True |
注：所有比较运算返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。
x, y =10, 20
# 等于
print("{} == {}: {}".format(x, y, x == y)) # 10 == 20: False
# 不等于
print("{} != {}: {}".format(x, y, x != y)) # 10 != 20: True
# 大于
print("{} > {}: {}".format(x, y, x > y)) # 10 > 20: False
# 小于
print("{} < {}: {}".format(x, y, x < y)) # 10 < 20: True
# 大于等于
print("{} >= {}: {}".format(x, y, x >= y)) # 10 >= 20: False
# 小于等于
print("{} <= {}: {}".format(x, y, x <= y)) # 10 <= 20: True
3. Python 赋值运算符
Python 支持以下几种赋值运算符：x=10, y=20
| 运算符 | 描 述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | 把 = 号右边的结果 赋给 左边的变量，如 sum = x + y 将 x + y 的结果赋值给变量 sum |
| += | 加法赋值运算符 | x += y 等效于 x = x + y |
| -= | 减法赋值运算符 | x -= y 等效于 x = x - y |
| *= | 乘法赋值运算符 | x *= y 等效于 x = x * y |
| /= | 除法赋值运算符 | x /= y 等效于 x = x / y |
| %= | 取模赋值运算符 | x %= y 等效于 x = x % y |
| **= | 幂赋值运算符 | x **= y 等效于 x = x ** y |
| //= | 取整除赋值运算符 | x //= y 等效于 x = x // y |
# 简单赋值运算符
x, y =10, 20
sum = x + y
print("{} + {} 的值为：{}".format(x, y, sum)) # 10 + 20 的值为：30
# 加法赋值运算符
x, y =10, 20
sum = x + y
x += y
print(sum == x) # True
print("10 + 20 的值为：{}".format(x)) # 10 + 20 的值为：30
# 减法赋值运算符
x, y =10, 20
difference = x - y
x -= y
print(difference == x) # True
print("10 - 20 的值为：{}".format(x)) # 10 - 20 的值为：-10
# 乘法赋值运算符
x, y =10, 20
product = x * y
x *= y
print(product == x) # True
print("10 * 20 的值为：{}".format(x)) # 10 * 20 的值为：200
# 除法赋值运算符
x, y =10, 20
quotient = x / y
x /= y
print(quotient == x) # True
print("10 / 20 的值为：{}".format(x)) # 10 / 20 的值为：0.5
# 取模赋值运算符
x, y =10, 20
modulus = x % y
x %= y
print(modulus == x) # True
print("10 %= 20 的值为：{}".format(x)) # 10 % 20 的值为：10
# 幂运算赋值运算符
x, y =10, 20
power = x ** y
x **= y
print(power == x) # True
print("10 ** 20 的值为：{}".format(x)) # 10 ** 20 的值为：100000000000000000000
# 取整数（向下取整）赋值运算符
x, y =9, 2
round_numbers = x // y
x //= y
print(round_numbers == x) # True
print("10 // 20 的值为：{}".format(x)) # 9 // 2 的值为：4
4. Python 位运算符
按位运算符是把数字看作二进制来进行计算的。
下表中 x=60, y=13，二进制格式如下：
| x = 0011 1100 y = 0000 1101 |
|---|
| x & y = 0000 1100 |
| x | y = 0011 1101 |
| x ^ y = 0011 0001 |
| ~x = 1100 0011 |
| x<<2 = 1111 0000 |
| x>>2 = 0000 1111 |
| 运算符 | 描 述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值，如果两个相应位都为 1，则该位的结果为 1，否则为 0 | (x & y) 的输出结果 12，二进制解释：0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为 1 时，结果位就为1 | (x | y) 的输出结果 61，二进制解释：0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为 1 | (x ^ y) 的输出结果 49，二进制解释：0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制为取反，即把 1 变为 0，把 0 变为 1。~x 类似于 -x - 1 | (~x) 的输出结果 -61，二进制解释：1100 0011，在一个有符号二进制数的补码形式 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补 0 | (x << 2) 的输出结果 240，二进制解释：1111 0000 |
| >> | 右移动运算符：把 “>>” 左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 | (x >> 2) 的输出结果 15，二进制解释：0000 1111 |
(1) 按位与运算符：参与运算的两个值，如果两个相应位都为 1，则该位的结果为 1，否则为 0。
x, y = 60, 13
# 按位与运算符
z = x & y # 12 = 0000 1100
print("{} & {} 的值为：{}".format(x, y, z)) # 60 & 13 的值为：12
(2) 按位或运算符：只要对应的二个二进位有一个为 1 时，结果位就为1。
x, y = 60, 13
# 按位或运算符
z = x | y # 61 = 0011 1101
print("{} | {} 的值为：{}".format(x, y, z)) # 60 | 13 的值为：61
(3) 按位异或运算符：当两对应的二进位相异时，结果为 1。
x, y = 60, 13
# 按位异或运算符
z = x ^ y # 49 = 0011 0001
print("{} ^ {} 的值为：{}".format(x, y, z)) # 60 ^ 13 的值为：49
(4) 按位取反运算符：对数据的每个二进制为取反，即把 1 变为 0，把 0 变为 1。~x 类似于 -x - 1。
x, y = 60, 13
# 按位取反运算符
z = ~x # 49 = 1100 0011
print("~{} 的值为：{}".format(x, z)) # ~60 的值为：-61
(5) 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补 0。
x, y = 60, 13
# 左移动运算符
z = x << 2 # 240 = 1111 0000
print("{} << 2 的值为：{}".format(x, z)) # 60 << 2 的值为：240
(6) 右移动运算符：把 “>>” 左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数。
x, y = 60, 13
# 右移动运算符
z = x >> 2 # 15 = 0000 1111
print("{} >> 2 的值为：{}".format(x, z)) # 60 >> 2 的值为：15
5. Python 逻辑运算符
Python 支持以下几种逻辑运算符：x=10, y=20
| 运算符 | 逻辑表达式 | 描 述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔 “与” — 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值 | (x and y) 返回 20 |
| or | x or y | 布尔 “或” — 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值 | (x or y) 返回 10 |
| not | not x | 布尔 “非” — 如果 x 为 True，返回 False。如果 x 为 False，返回 True | not (x and y) 返回 False |
x, y = 10, 20
# 布尔 "与" 运算符
z = x and y
print("{} and {} 的值为：{}".format(x, y, z)) # 10 and 20 的值为：20
# 布尔 "或" 运算符
z = x or y
print("{} or {} 的值为：{}".format(x, y, z)) # 10 or 20 的值为：10
# 布尔 "非" 运算符
z = not (x and y)
print("not ({} and {}) 的值为：{}".format(x, y, z)) # not (10 and 20) 的值为：False
6. Python 成员运算符
Python 支持以下几种成员运算符：x=10, y=20
| 运算符 | 描 述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False | x 在 y 序列中，如果 x 在 y 序列中返回 True |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False | x 不在 y 序列中，如果 x 不在 y 序列中返回 True |
x, y = 10, 20
list = [1, 2, 3, 4, 5]
# 在指定序列中
z = x in list
print("{} 在序列 {} 中：{}".format(x, list, z)) # 10 在序列 [1, 2, 3, 4, 5] 中：False
# 不在指定序列中
z = x not in list
print("{} 不在在序列 {} 中：{}".format(x, list, z)) # 10 不在在序列 [1, 2, 3, 4, 5] 中：True
7. Python 身份运算符
身份运算符用于比较两个对象的存储单元。
Python 支持以下几种身份运算符：
| 运算符 | 描 述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y，类似 id(x) == id(y)，如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y，类似 id(x) != id(y)，如果引用的不是同一个对象则返回 True，否则返回 False |
注：id() 函数用于获取对象内存地址。
(1) 有相同标识符，id(x) == id(y)：x=20, y=20
x, y = 20, 20
# is 身份运算符
if (x is y): # 20 和 20 有相同的的标识
print("{} 和 {} 有相同的的标识".format(x, y))
else:
print("{} 和 {} 没有相同的的标识".format(x, y))
# is not 身份运算符
if (x is not y): # 20 和 20 有相同的的标识
print("{} 和 {} 没有相同的的标识".format(x, y))
else:
print("{} 和 {} 有相同的的标识".format(x, y))
(2) 没有相同标识符，id(x) == id(y)：x=20, y=30
x, y = 20, 30
# is 身份运算符
if (x is y): # 20 和 30 没有相同的的标识
print("{} 和 {} 有相同的的标识".format(x, y))
else:
print("{} 和 {} 没有相同的的标识".format(x, y))
# is not 身份运算符
if (x is not y): # 20 和 30 没有相同的的标识
print("{} 和 {} 没有相同的的标识".format(x, y))
else:
print("{} 和 {} 有相同的的标识".format(x, y))
is 和 == 区别：
is 用于判断两个变量引用的对象是否为同一个（同一块内存空间），== 用于判断引用变量的值是否相等。
x = [1, 2, 3]
y = x
print(y is x) # True
print(y == x) # True
y = x[:]
print(y is x) # False
print(y == x) # True
8. Python 运算符优先级
以下表格列出了从高到低优先级的所有运算符：
| 运算符 | 描 述 |
|---|---|
| ** | 指数（最高优先级） |
| ~ + - | 按位翻转，一元加号和减号（最后两个的方法名为 +@ 和 -@） |
| * / % // | 乘，除，取模，取整除 |
| + - | 加法，减法 |
| >> << | 右移运算符，左移运算符 |
| & | 位 “AND” |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not and or | 逻辑运算符 |
五、条件语句
Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。
可以通过下图来简单了解条件语句的执行过程：
代码执行过程：
1. if 语句
Python 中 if 语句的一般形式如下所示：
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
- 如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
- 如果 "condition_1"为 False，将判断 “condition_2”
- 如果 “condition_2” 为 True 将执行 “statement_block_2” 块语句
- 如果 “condition_2” 为 False，将执行 “statement_block_3” 块语句
Python 中用 elif 代替了 else if，所以 if 语句的关键字为： if – elif – else。
注意：
- 1、每个条件后面要使用英文冒号 :，表示接下来是满足条件后要执行的语句块。
- 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
- 3、在 Python 中没有 switch – case 语句。
一个简单的 if 实例：
age = 18
if age:
print("if 条件表达式为 True")
print(age)
age = 0
if age:
print("if 条件表达式为 True")
print("Good bye!")
if 条件表达式为 True
18
Good bye!
从结果上可以看到当变量 age 为 0 时，所对应的 if 内的语句没有执行。
一个计算判断人的年龄段的例子：
- 0（初生）-6岁：婴幼儿
- 7-12岁：少儿
- 13-17岁：青少年
- 18-45岁：青年
- 46-69岁：中年
- > 69岁：老年
# 0（初生）-6岁为婴幼儿；7-12岁为少儿；13-17岁为青少年；18-45岁为青年；46-69岁为中年；>69岁为老年
age = int(input("请输入年龄："))
if age > 69:
print("老年")
elif age >= 46:
print("中年")
elif age >= 18:
print("青年")
elif age >= 13:
print("青少年")
elif age >=7:
print("少儿")
elif age >= 0:
print("婴幼儿")
else:
print("错误的年龄输入！")
# 退出提示
print("条件语句结束啦！")
>>请输入年龄：20
>>青年
>>条件语句结束啦！
以下为 if 中常用的操作运算符：
| 操作符 | 描 述 |
|---|---|
| < | 小于 |
| <= | 小于等于 |
| > | 大于 |
| >= | 大于等于 |
| == | 等于，比较两个值是否相等 |
| != | 不等于 |
一个数字比较运算的例子：
# 该实例演示了数字猜谜游戏
number = 20
guess = -1
print("数字猜谜游戏！")
while guess != number:
guess = int(input("请输入你猜的数字："))
if guess == number:
print("恭喜，您猜对了！")
elif guess < number:
print("对不起，您猜的数字小了...")
elif guess > number:
print("对不起，您猜的数字大了...")
数字猜谜游戏！
请输入你猜的数字：21
对不起，您猜的数字大了...
请输入你猜的数字：10
对不起，您猜的数字小了...
请输入你猜的数字：20
恭喜，您猜对了
2. if 嵌套
在嵌套 if 语句中，可以把 if – elif – if 结构放在 if – elif – else 结构中。
if 表达式1:
语句
if 表达式2:
语句
elif 表达式3:
语句
else:
语句
elif 表达式4:
语句
else:
语句
num = int(input("请输入一个数字："))
if num % 2 == 0:
if num % 3 == 0:
print("您输入的数字可以整除 2 和 3")
else:
print("您输入的数字可以整除 2，但不能整除 3")
else:
if num % 3 == 0:
print("您输入的数字可以整除 3，但不能整除 2")
else:
print("您输入的数字不能整除 2 和 3")
请输入一个数字：6
您输入的数字可以整除 2 和 3
六、循环语句
思考：如何在控制台输出 100 条 “Hello World” ？
本质上，我们写 100 条 print(“Hello World”) 输出语句就可以了。但如果是 1000条 / 10000条 呢？
这就要用到循环语句了。
1. while 循环
Python 中 while 语句的一般形式：
while 判断条件(condition):
执行语句(statements)…
执行流程图如下：
需要注意冒号和缩进。
输出 100 条 “Hello World”：
# 输出 100 条 "Hello World"
i= 1 # 循环初始值
while i <= 100: # 循环条件
print("Hello World") # 循环执行语句体
# i = i + 1
i += 1 # 循环变化量
计算 1 到 100 的总和：
# 计算 1 到 100 的总和
counter, n, sum = 1, 100, 0
while counter <= n:
# sum = sum + counter
sum += counter
# counter = counter + 1
counter += 1
print("{} 到 {} 之和为：{}".format(1, n, sum)) # 1 到 100 之和为：5050
(1) 无限循环
可以通过设置条件表达式永远不为 False 来实现无限循环，实例如下：
# 无限循环
i = 1
while i == 1: # 表达式永远为 True
num = int(input("请输入一个数字："))
print("您输入的数字是：{}".format(num))
请输入一个数字：5
您输入的数字是：5
请输入一个数字：
我们可以使用 Ctrl + C 来退出当前的无限循环。
无限循环在服务器上客户端的实时请求非常有用。但死循环容易造成内存溢出。
(2) while 循环使用 else 语句
如果 while 后面的条件语句为 False 时，则执行 else 的语句块。
语法格式如下：
while <expr>:
<statement(s)>
else:
<additional_statement(s)>
expr 条件语句为 True 则执行 statement(s) 语句块，如果为 False，则执行 additional_statement(s) 语句块。
循环输出数字，并判断大小：
# while -- else
count = 0
while count < 5:
print("{} 小于 5".format(count))
# count= count + 1
count += 1
else:
print("{} 大于或等于 5".format(count))
0 小于 5
1 小于 5
2 小于 5
3 小于 5
4 小于 5
5 大于或等于 5
(3) 简单语句组
类似 if 语句的语法，如果我们的 while 循环体中只有一条语句，我们可以将该语句与 while 写在同一行中，示例如下：
# 简单语句组
flag = 1
while (flag): print("学习 Python 使我充满快乐！")
print("Good bye!")
学习 Python 使我充满快乐！
学习 Python 使我充满快乐！
学习 Python 使我充满快乐！
学习 Python 使我充满快乐！
学习 Python 使我充满快乐！
........................
注意：以上的无限循环可以使用 Ctrl + C 来中断循环。
2. for 循环
Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。
for 循环的一般格式如下：
for <variable> in <sequence>:
<statements>
执行流程图如下：
顺序输出序列 [“C++”, “Java”, “Python”, “Go”] 中的每个元素：
# 顺序输出序列 ["C++", "Java", "Python", "Go"] 中的每个元素
languages = ["C++", "Java", "Python", "Go"]
for x in languages:
print(x)
C++
Java
Python
Go
输出 100 条 “Hello World”：
# 输出 100 条 "Hello World"
for i in range(100):
print("Hello World")
计算 1 到 100 的总和：
# 计算 1 到 100 的总和
sum = 0
for i in range(1, 101):
# sum = sum + i
sum += i
print("{} 到 {} 之和为：{}".format(1, 100, sum)) # 1 到 100 之和为：5050
(1) for 循环使用 else 语句
如果 for 后面的序列遍历穷尽时，则执行 else 的语句块。
语法格式如下：
for <variable> in <sequence>:
<statements>
else:
<statements>
# for -- else
languages = ["C++", "Java", "Python", "Go"]
for x in languages:
print(x)
else:
print("JavaScript")
C++
Java
Python
Go
JavaScript
3. range() 函数
Python3 range() 函数返回一个可迭代对象（类型是对象）。
Python3 list() 函数是对象迭代器，可以把 range() 返回的可迭代对象转为一个列表，返回的变量类型为列表。
函数语法：
range(stop)
range(start, stop[, step])
参数说明：
- start：计数从 start 开始。默认是从 0 开始。例如 range(5) 等价于 range(0, 5)。
- stop：计数到 stop 结束，但不包括 stop。例如：range(0, 5) 是 [0, 1, 2, 3, 4] 没有 5。
- step：步长，默认为 1。例如：range(0, 5) 等价于 range(0, 5, 1)。
如果我们需要遍历数字序列，可以使用 Python 内置的 range() 函数。它会生成数列。
实例：
print(range(5)) # range(0, 5)
for i in range(5):
print(i)
0
1
2
3
4
有两个参数或三个参数的情况（第二种构造方法）：
# 有两个或三个参数的情况
print(list(range(0, 30, 5))) # [0, 5, 10, 15, 20, 25]
print(list(range(0, 10, 2))) # [0, 2, 4, 6, 8]
print(list(range(0, -10, -1))) # [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
print(list(range(1, 0))) # []
4. break 语句
break 语句可以跳出 for 和 while 的循环体。如果我们从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
break 执行流程图：
实例：判断 10 以内的数是质数还是合数
while 中使用 break：
# while 中使用 break
n = 2
while n < 10:
x = 2
while x < n:
if n % x == 0:
# 是合数，执行 break 语句
print("{} 是合数，等于 {} * {}".format(n, x, n // x))
break
# break 语句会跳出内层 while 循环体，同时对应的循环 else 块将不执行
x += 1
else:
print("{} 是质数".format(n))
n += 1
2 是质数
3 是质数
4 是合数，等于 2 * 2
5 是质数
6 是合数，等于 2 * 3
7 是质数
8 是合数，等于 2 * 4
9 是合数，等于 3 * 3
for 中使用 break：
# for 中使用 break
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
# 是合数，执行 break 语句
print("{} 是合数，等于 {} * {}".format(n, x, n // x))
break
# break 语句会跳出内层 for 循环体，同时对应的循环 else 块将不执行
else:
print("{} 是质数".format(n))
2 是质数
3 是质数
4 是合数，等于 2 * 2
5 是质数
6 是合数，等于 2 * 3
7 是质数
8 是合数，等于 2 * 4
9 是合数，等于 3 * 3
5. continue 语句
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
continue 执行流程图：
实例：获取 10 以内的奇数
while 中使用 continue：
# while 中使用 conitnue
n = 0
while n < 10:
n += 1
if n % 2 == 0:
# 如果 n 是偶数，执行 continue 语句
continue
# continue 语句会直接继续下一轮循环，后续 print() 语句不会执行
print(n)
1
3
5
7
9
for 中使用 continue：
# for 中使用 conitnue
for i in range(10):
if i % 2 == 0:
# 如果 n 是偶数，执行 continue 语句
continue
# continue 语句会直接继续下一轮循环，后续 print() 语句不会执行
print(i)
1
3
5
7
9
6. pass 语句
Python pass 是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。
实例：
while True:
pass # 等待键盘中断（Ctrl + C）
最小的类：
class MyEmptyClass:
pass
当 language==“Python” 时执行 pass 语句块：
languages = ["C++", "Java", "Python", "Go"]
for language in languages:
if language == "Python":
pass
print("执行 pass 块")
print("当前语言：{}".format(language))
print("Good bye!")
当前语言：C++
当前语言：Java
执行 pass 块
当前语言：Python
当前语言：Go
Good bye!
七、Python 数据容器
1. 字符串
字符串是 Python 中最常用的数据类型。我们可以使用英文单引号、英文双引号 或 英文三引号（’ ’ 或 " " 或 ’ ’ ’ ’ ’ ’ 或 " " " " " "）来创建字符串。
实例：
str1 = 'Hello World'
str2 = "Hello World"
str3 = '''Hello World'''
str4 = """Hello World"""
(1) Python 访问字符串中的值
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号 [ ] 来截取字符串，字符串的截取的语法格式如下：
变量[ 头下标: 尾下标 : 步长]
下标索引：即编号，我们可以根据下标找到对应元素。索引值以 0 为开始，-1 为从末尾的开始位置。
切片：对操作的对象截取其中一部分的操作。
索引切片实例图：
索引切片实例代码：
str1 = "Hello World"
str2 = "Python"
print("str1[0]: {}".format(str1[0])) # str1[0]: H
print("str2[1:5]: {}".format(str2[1:5])) # str2[1:5]: ytho
str1[0]: H
str2[1:5]: ytho
(2) Python 字符串更新
我们可以截取字符串的一部分并与其他字段拼接。
str1 = "Hello World"
print("已更新字符串：{}".format(str1[:6] + "Python"))
已更新字符串：Hello Python
(3) Python 转义字符
在需要在字符串中使用特殊字符时，Python 用反斜杠 \ 转义字符。
| 转义字符 | 描 述 |
|---|---|
| \ (在行尾时) | 续行符 |
| \ \ | 反斜杠符号 |
| \ ’ | 单引号 |
| \ " | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至 \r 后面的内容完全替换完成。 |
| \f | 换页 |
| \yyy | 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 |
| \xyy | 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行。 |
| \other | 其它的字符以普通格式输出 |
实例：
| (在行尾时) | 续行符 |
# \（在行尾） 续行符
print("line1 \
line2 \
line3")
line1 line2 line3
| \\ | 反斜杠符号 |
# \\ 反斜杠符号
print("\\")
\
| \’ | 单引号 |
# \' 单引号
print("\'")
'
| \" | 双引号 |
# \" 双引号
print('\"')
"
| \a | 响铃 |
# \a 响铃
print("\a") # 执行后电脑有响声
| \b | 退格(Backspace) |
# \b 退格(Backspace)
print("Hello World")
print("Hello \b World")
Hello World
Hello World
| \000 | 空 |
# \000 空
print("\000Hello World")
Hello World
| \n | 换行 |
# \n 换行
print("Hello \n World")
Hello
World
| \v | 纵向制表符 |
# \v 纵向制表符
print("Hello \v World")
Hello
World
| \t | 横向制表符 |
# \t 横向制表符
print("Hello World")
print("Hello \t World")
Hello World
Hello World
| \r | 回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至 \r 后面的内容完全替换完成。 |
# \r 将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至 \r 后面的内容完全替换完成
print("Hello\rWorld")
print("google baidu taobao jindong\r12345678")
World
12345678aidu taobao jindong
| \f | 换页 |
# \f 换页
print("Hello \f World")
Hello
World
| \yyy | 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 |
# \yyy 八进制数，y 代表 0~7 的字符，例如：\012 代表换行
print("\110\145\154\154\157\40\127\157\162\154\144")
Hello World
| \xyy | 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行。 |
# \xyy 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行
print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64")
Hello World
(4) Python 字符串运算符
下表实例变量 x 值为字符串 “Hello”，y 变量值为 “World”：
| 操作符 | 描 述 | 实例 |
|---|---|---|
| + | 字符串连接 | x + y 输出结果：HelloWorld |
| * | 重复输出字符串 | x * 2 输出结果：HelloHello |
| [] | 通过索引获取字符串中字符 | x[1] 输出结果：e |
| [:] | 截取字符串中的一部分，遵循 左闭右开 原则，str[0:2] 是不包含第 3 个字符的。 | x[1:4] 输出结果：ell |
| in | 成员运算符 — 如果字符串中包含给定的字符返回 True | “H” in x 输出结果：True |
| not in | 成员运算符 — 如果字符串中不包含给定的字符返回 True | “M” not in x 输出结果：True |
| r/R | 原始字符串 — 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | print(r"\n") 输出结果： \n print(R"\n") 输出结果： \n |
| % | 格式字符串 | print(“我叫 %s 今年 %d 岁！” % (“小明”, 18)) 输出结果：我叫 小明 今年 18 岁！ |
(5) Python 字符串格式化
Python 支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符中。
print("我叫 %s 今年 %d 岁！" % ("小明", 18))
我叫 小明 今年 18 岁！
Python 字符串格式化符号：
| 符 号 | 描 述 |
|---|---|
| %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 是小数点后的位数(如果可用的话) |
(6) Python 三引号
Python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符和其他特殊字符。
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的 WYSIWYG（所见即所得）格式的。
一个典型的用例是，当我们需要一块 HTML 或者 SQL 时，这时用字符串组合，特殊字符串转义将会非常的频繁。
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')
(7) f-string
f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
使用百分号（%）格式化字符串：
print("Hello %s" % "World")
Hello World
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去。
使用 f-string 格式化字符串：
name = "World"
print(f"Hello {name}")
Hello World
data = {"name": "Baidu", "url": "www.baidu.com"}
print(f'{data["name"]}: {data["url"]}')
Baidu: www.baidu.com
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果。
使用 = 符号来拼接运算表达式与结果：
x = 1
print(f"{x+1}") # Python 3.6
2
x = 1
print(f"{x+1=}") # Python 3.8
x+1=2
(8) Python 字符串的内建函数
a. 内建函数 — 增：
| 方法 | 方法说明 |
|---|---|
| join(seq) | 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| join(seq) |
| join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串 |
函数语法：
str.join(sequence)
参数说明：
- sequence：要连接的元素序列。
# join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
s1 = "-"
s2 = ""
seq = ("b", "a", "i", "d", "u") # 字符串序列
print(s1.join(seq))
print(s2.join(seq))
b-a-i-d-u
baidu
c. 内建函数 — 删：
| 方法 | 方法说明 |
|---|---|
| lstrip() | 截掉字符串左边的空格或指定字符 |
| rstrip() | 删除字符串末尾的空格或指定字符 |
| strip() | 移除字符串头尾指定的字符（默认为空格）或字符序列 |
| lstrip() |
| lstrip() 方法用于截掉字符串左边的空格或指定字符 |
函数语法：
str.lstrip([chars])
参数说明：
- chars：指定截取的字符。
# lstrip() 方法用于截掉字符串左边的空格或指定字符
str1 = " this is string example "
print(str1.lstrip())
str2 = "88888888this is string example8888888"
print(str2.lstrip("8"))
this is string example
this is string example8888888
| rstrip() |
| rstrip() 删除 string 字符串末尾的指定字符（默认为空格） |
函数语法：
str.rstrip([chars])
参数说明：
- chars：指定删除的字符（默认为空格）。
# rstrip() 删除 string 字符串末尾的指定字符（默认为空格）
str1 = " this is string example "
print(str1.rstrip())
str2 = "88888888this is string example8888888"
print(str2.rstrip("8"))
this is string example
88888888this is string example
| strip([chars]) |
| strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列）|
注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
函数语法：
str.strip([chars])
参数说明：
- chars：移除字符串头尾指定的字符序列。
# strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列
str1 = "*****this is **string** example*****"
print(str1.strip("*")) # 指定字符串 *
str2 = "123baidu321"
print(str2.strip("12")) # 字符序列为 12
this is **string** example
3baidu3
a. 内建函数 — 查：
| 方法 | 方法说明 |
|---|---|
| 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 出现的次数 |
| startswith(substr, beg=0,end=len(string)) | 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查 |
| endswith(suffix, beg=0, end=len(string)) | 检查字符串是否以 obj 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True，否则返回 False |
| rfind(str, beg=0,end=len(string)) | 类似于 find()函数，不过是从右边开始查找 |
| rindex( str, beg=0, end=len(string)) | 类似于 index()，不过是从右边开始 |
| find(str, beg=0, end=len(string)) |
| 检测字符串中是否包含子字符串 str ，如果指定 beg(开始) 和 end(结束) 范围，则检查是否包含在指定范围内，如果指定范围内包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1 |
函数语法：
str.find(str, beg=0, end=len(string))
参数说明：
- str：指定检索的字符串。
- beg：开始索引，默认为 0。
- end：结束索引，默认为字符串的长度。
# find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内。
# 如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
print ("Hello World".find("o"))
print ("Hello World".find("o", 1))
print ("Hello World".find("o", 8))
4
4
-1
| index(str, beg=0, end=len(string)) |
| index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常 |
函数语法：
str.index(str, beg=0, end=len(string))
参数说明：
- str：指定检索的字符串。
- beg：开始索引，默认为0。
- end：结束索引，默认为字符串的长度。
# index() 方法检测字符串中是否包含子字符串 str，如果指定 beg(开始) 和 end(结束) 范围，则检查是否包含在指定范围内.
# 该方法与 Python find()方法一样，只不过如果 str 不在 string 中会报一个异常。
print ("Hello World".index("o"))
print ("Hello World".index("o", 1))
print ("Hello World".index("o", 8))
4
4
Traceback (most recent call last):
File "test.py", line 8, in <module>
print (str1.index(str2, 10))
ValueError: substring not found
| count(str, beg= 0,end=len(string)) |
| count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置 |
函数语法：
str.count(sub, start= 0, end=len(string))
参数说明：
- sub：搜索的子字符串。
- start：字符串开始搜索的位置。默认为第一个字符，第一个字符索引值为 0。
- end：字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
# count() 方法用于统计字符串里某个字符出现的次数
str="www.baidu.com"
sub="o"
print('str.count("o"): {}'.format(str.count(sub)))
sub="baidu"
print('str.count("baidu", 0, 10): {}'.format(str.count(sub, 0, 10)))
str.count("o"): 1
str.count("baidu", 0, 10): 1
| startswith(substr, beg=0,end=len(string)) |
| startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查 |
函数语法：
str.startswith(substr, beg=0, end=len(string))
参数说明：
- str：检测的字符串。
- substr：指定的子字符串。
- strbeg：可选参数用于设置字符串检测的起始位置。
- strend：可选参数用于设置字符串检测的结束位置。
# startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False
# 如果参数 beg 和 end 指定值，则在指定范围内检查
str = "this is string example....wow!!!"
print(str.startswith("this")) # 字符串是否以 this 开头
print(str.startswith("string", 8 )) # 从第 9 个字符开始的字符串是否以 string 开头
print(str.startswith("this", 2, 4 )) # 从第 2 个字符开始到第 4 个字符结束的字符串是否以 this 开头
True
True
False
| str.endswith(suffix[, start[, end]]) |
| endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 “start” 与 “end” 为检索字符串的开始与结束位置 |
函数语法：
str.endswith(suffix[, start[, end]])
参数说明：
- suffix：该参数可以是一个字符串或者是一个元素。
- start：字符串中的开始位置。
- end：字符中结束位置。
# endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False
# 可选参数 "start" 与 "end" 为检索字符串的开始与结束位置
data_str="Baidu example....wow!!!"
suffix="!!"
print (data_str.endswith(suffix))
print (data_str.endswith(suffix, 20))
suffix="Bai"
print (data_str.endswith(suffix))
print (data_str.endswith(suffix, 0, 19))
True
True
False
False
| rfind(str, beg=0,end=len(string)) |
| rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1 |
函数语法：
str.rfind(str, beg=0 end=len(string))
参数说明：
- str：查找的字符串。
- beg：开始查找的位置，默认为 0 。
- end：结束查找位置，默认为字符串的长度。
# rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1
str1 = "this is really a string example....wow!!!"
str2 = "is"
print(str1.rfind(str2))
print(str1.rfind(str2, 0, 10))
print(str1.rfind(str2, 10, 0))
print(str1.find(str2))
print(str1.find(str2, 0, 10))
print(str1.find(str2, 10, 0))
5
5
-1
2
2
-1
| rindex( str, beg=0, end=len(string)) |
| rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，我们可以指定可选参数 [beg:end] 设置查找的区间 |
函数语法：
str.rindex(str, beg=0 end=len(string))
参数说明：
- str：查找的字符串。
- beg：开始查找的位置，默认为 0。
- end：结束查找位置，默认为字符串的长度。
# rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，
# 我们可以指定可选参数 [beg:end] 设置查找的区间
str1 = "this is really a string example....wow!!!"
str2 = "is"
print (str1.rindex(str2))
print (str1.rindex(str2,10))
5
Traceback (most recent call last):
File "test.py", line 6, in <module>
print (str1.rindex(str2,10))
ValueError: substring not found
d. 内建函数 — 改：
| 方法 | 方法说明 |
|---|---|
| replace(old, new [, max]) | 将字符串中的 old 替换成 new，如果 max 指定，则替换不超过 max 次 |
| split(str="", num=string.count(str)) | 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num + 1 个子字符串 |
| capitalize() | 将字符串的第一个字符转换为大写 |
| title() | 返回 “标题化” 的字符串，就是说所有单词都是以大写开始，其余字母均为小写 |
| lower() | 转换字符串中所有大写字符为小写 |
| upper() | 转换字符串中的小写字母为大写 |
| swapcase() | 将字符串中大写转换为小写，小写转换为大写 |
| ljust(width[, fillchar]) | 返回一个原字符串左对齐，并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格 |
| rjust(width,[, fillchar]) | 返回一个原字符串右对齐，并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格 |
| center(width, fillchar) | 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格 |
| partition(str) | 根据指定的分隔符将字符串进行分割。将字符串分为 str 前、str 中 和 str 后 三部分 |
| rpartition(str) | 类似于 partition() 方法，只是该方法是从目标字符串的末尾也就是右边开始搜索分割符 |
| splitlines([keepends]) | 按照行("\r", “\r\n”, “\n”)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符 |
| zfill (width) | 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| replace(old, new [, max]) |
| replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数 max，则替换不超过 max 次 |
函数语法：
str.replace(old, new[, max])
参数说明：
- old：将被替换的子字符串。
- new：新字符串，用于替换 old 字符串。
- max：可选字符串, 替换不超过 max 次
# replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数 max，则替换不超过 max 次
data_str = "www.baidu.cn"
print ("百度旧地址：{}".format(data_str))
print ("百度新地址：{}".format(data_str.replace(".cn", ".com")))
data_str = "this is string example....wow!"
print (data_str.replace("is", "ere", 1))
百度旧地址：www.baidu.cn
百度新地址：www.baidu.com
there is string example....wow!
| split(str="", num=string.count(str)) |
| split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串 |
函数语法：
str.split(str="", num=string.count(str))
参数说明：
- str：分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
- num：分割次数。默认为 -1, 即分隔所有。
# split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串
data_str = "this is string example"
print(data_str.split()) # 以空格为分隔符
print(data_str.split("i", 1)) # 以 i 为分隔符
print(data_str.split("a")) # 以 a 为分隔符
['this', 'is', 'string', 'example']
['th', 's is string example']
['this is string ex', 'mple']
# 以 # 号为分隔符，指定第二个参数为 1，返回两个参数列表。
txt = "Google#Baidu#Taobao#Facebook"
# 第二个参数为 1，返回两个参数列表
x = txt.split("#", 1)
print(x)
['Google', 'Baidu#Taobao#Facebook']
| capitalize() |
| capitalize() 将字符串的第一个字母变成大写，其他字母变小写 |
函数语法：
str.capitalize()
参数说明：
- 无。
# capitalize() 将字符串的第一个字母变成大写，其他字母变小写
data_str = "this is string example."
print("data_str.capitalize(): {}".format(data_str.capitalize()))
data_str.capitalize(): This is string example.
| title() |
| title() 方法返回 “标题化” 的字符串，就是说所有单词的首个字母转化为大写，其余字母均为小 |
函数语法：
str.title()
参数说明：
- 无。
# title() 方法返回 "标题化" 的字符串，就是说所有单词的首个字母转化为大写，其余字母均为小
data_str = "this is string example."
print("data_str.title(): {}".format(data_str.title()))
data_str.title(): This Is String Example.
| lower() |
| lower() 方法转换字符串中所有大写字符为小写 |
函数语法：
str.lower()
参数说明：
- 无。
# lower() 方法转换字符串中所有大写字符为小写
data_str = "This Is String Example."
print("data_str.lower(): {}".format(data_str.lower()))
data_str.lower(): this is string example.
| upper() |
| upper() 方法将字符串中的小写字母转为大写字母 |
函数语法：
str.upper()
参数说明：
- 无。
# upper()方法将字符串中的小写字母转为大写字母
data_str = "this is string example."
print("data_str.upper(): {}".format(data_str.upper()))
data_str.upper(): THIS IS STRING EXAMPLE.
| swapcase() |
| swapcase() 方法用于对字符串的大小写字母进行转换 |
函数语法：
str.swapcase()
参数说明：
- 无。
# swapcase() 方法用于对字符串的大小写字母进行转换
str1 = "this is string example"
print(str1.swapcase())
str2 = "This Is String Example"
print(str2.swapcase())
THIS IS STRING EXAMPLE
tHIS iS sTRING eXAMPLE
| ljust(width[, fillchar]) |
| ljust() 方法返回一个原字符串左对齐，并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串 |
函数语法：
str.ljust(width[, fillchar])
参数说明：
- width：指定字符串长度。
- fillchar：填充字符，默认为空格。
# ljust() 方法返回一个原字符串左对齐，并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串
data_str = "Baidu example..."
print (data_str.ljust(20, "*"))
Baidu example...****
| rjust(width,[, fillchar]) |
| rjust() 返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串 |
函数语法：
str.rjust(width[, fillchar])
参数说明：
- width：指定填充指定字符后中字符串的总长度。
- fillchar：填充的字符，默认为空格。
# rjust() 返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
data_str = "Baidu example..."
print (data_str.rjust(20, "*"))
****Baidu example...
| center(width, fillchar) |
| center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格 |
函数语法：
str.center(width[, fillchar])
参数说明：
- width：字符串的总宽度。
- fillchar：填充字符。
# center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格
data_str = "Baidu example..."
print (data_str.center(20, "*"))
**Baidu example...**
| partition(str) |
| partition() 方法用来根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符，则返回一个 3 元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串 |
函数语法：
str.partition(str)
参数说明：
- str：指定的分隔符。
# partition() 方法用来根据指定的分隔符将字符串进行分割
data_str = "www.baidu.com"
print(data_str.partition("."))
('www', '.', 'baidu.com')
| rpartition(str) |
| rpartition() 方法类似于 partition() 方法，只是该方法是从目标字符串的末尾也就是右边开始搜索分割符。如果字符串包含指定的分隔符，则返回一个 3 元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串 |
函数语法：
str.rpartition(str)
参数说明：
- str：指定的分隔符。
# rpartition() 方法用来根据指定的分隔符将字符串进行分割，从目标字符串的末尾也就是右边开始搜索分割符
data_str = "www.baidu.com"
print(data_str.rpartition("."))
('www.baidu', '.', 'com')
| splitlines([keepends]) |
| splitlines() 按照行("\r", “\r\n”, “\n”)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符 |
函数语法：
str.splitlines([keepends])
参数说明：
- keepends：在输出结果里是否去掉换行符("\r", “\r\n”, “\n”)，默认为 False，不包含换行符，如果为 True，则保留换行符。
# splitlines() 按照行("\r", "\r\n", "\n")分隔，返回一个包含各行作为元素的列表
# 如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符
str1 = "ab c\n\nde fg\rkl\r\n"
print(str1.splitlines())
str2 = "ab c\n\nde fg\rkl\r\n"
print(str2.splitlines(True))
['ab c', '', 'de fg', 'kl']
['ab c\n', '\n', 'de fg\r', 'kl\r\n']
| zfill (width) |
| zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充 0 |
函数语法：
str.zfill(width)
参数说明：
- width：指定字符串的长度。原字符串右对齐，前面填充 0。
# zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充 0
data_str = "this is string example"
print ("data_str.zfill: {}".format(data_str.zfill(22)))
print ("data_str.zfill: {}".format(data_str.zfill(25)))
data_str.zfill: this is string example
data_str.zfill: 000this is string example
e. 内建函数 — 字符校验：
| 方法 | 方法说明 |
|---|---|
| isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
| isdigit() | 如果字符串只包含数字则返回 True 否则返回 False |
| islower() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| isnumeric() | 如果字符串中只包含数字字符，则返回 True，否则返回 False |
| isspace() | 如果字符串中只包含空白，则返回 True，否则返回 False |
| istitle() | 如果字符串是标题化的则返回 True，否则返回 False |
| isupper() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| isdecimal() | 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false |
f. 内建函数 — 最大最小字母：
| 方法 | 方法说明 |
|---|---|
| max(str) | 返回字符串 str 中最大的字母 |
| min(str) | 返回字符串 str 中最小的字母 |
2. 列表
Python 有 6 个序列的内置类型，但最常见的是列表和元组。
序列：序列是 Python 中最基本的数据结构。序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，以此类推。
列表：Python 内置的一种数据类型，是一种有序的集合。
列表的格式：写在方括号之间，用英文逗号隔开。
列表可以进行的操作：索引、切片、加、乘、检查成员。
注意：列表的数据项不需要具有相同的类型。
(1) 创建列表
list1 = ["Google", "张三", 2500, 99.99, True]
list2 = [1, 2, 3, 4, 5, 6]
list3 = ["a", "b", "c", "d", "e", "f"]
list4 = ["red", "green", "blue", "yellow", "white", "black"]
(2) 访问列表中的值
正向索引：
与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依次类推。
通过索引列表可以进行截取、组合等操作。
# 正向索引
list = ["red", "green", "blue", "yellow", "white", "black"]
print(list[0]) # red
print(list[1]) # green
print(list[2]) # blue
反向索引：
索引也可以从尾部开始，最后一个元素索引为 -1 ，往前一位为 -2 ，以此类推。
# 反向索引
list = ["red", "green", "blue", "yellow", "white", "black"]
print(list[-1]) # black
print(list[-2]) # white
print(list[-3]) # yellow
切片：
使用方括号 [] 的形式截取字符串。
# list 切片
list = ["Google", "Baidu", "Zhihu", "Taobao", "Wiki"]
# 读取第 2 位
print(f"list[1]: {list[1]}") # list[1]: Baidu
# 从第 2 位开始（包含）截取到倒数第 2 位（不包含）
print(f"list[1:-2]: {list[1:-2]}") # list[1:-2]: ['Baidu', 'Zhihu']
(3) 更新列表
使用 append() 方法添加列表项，对列表的数据项进行修改或更新。
a. List append() 方法：
append() 方法用于在列表末尾添加新的对象。该方法无返回值，但是会修改原来的列表。
函数语法：
list.append(obj)
参数说明：
- obj：添加到列表末尾的对象。
示例：
# 更新列表
list = ["Google", "Baidu", 1997, 2000]
print(f"第 3 个元素为：{list[2]}")
list[2] = 2001
print(f"更新后的第 3 个元素为：{list[2]}\n")
list1 = ["Google", "Baidu", "Taobao"]
list1.append("Zhihu")
print(f"更新后的列表：{list1}")
第 3 个元素为：1997
更新后的第 3 个元素为：2001
更新后的列表：['Google', 'Baidu', 'Taobao', 'Zhihu']
注意：
- 列表可包含任何数据类型的元素，单个列表中的元素无需全为同一类型。
- append() 方法向列表的尾部添加一个新的元素。
- List extend() 方法只接受一个列表作为参数，并将该参数的每个元素都添加到原有的列表中。
b. List append() 与深拷贝、浅拷贝：
在 Python 中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，Python 并没有拷贝这个对象，而只是拷贝了这个对象的引用，我们称之为 浅拷贝。
在 Python 中，为了使当进行赋值操作时，两个变量互不影响，可以使用 copy 模块中的 deepcopy 方法，称之为 深拷贝。
当 list 类型的对象进行 append 操作时，实际上追加的是该对象的引用。
id() 函数：返回对象的唯一标识，可以类比成该对象在内存中的地址。
alist = []
num = [2]
alist.append(num)
print(num) # [2]
print(alist) # [[2]]
id(num) == id(alist[0]) # True
num.append(3)
print(num) # [2, 3]
print(alist) # [[2, 3]]
id(num) == id(alist[0]) # True
如上例所示，当 num 发生变化时（前提是 id(num) 不发生变化），alist 的内容随之会发生变化。往往会带来意想不到的后果，想要避免这种情况，可以采用深拷贝解决：
alist.append(copy.deepcopy(num))
import copy
alist = []
num = [2]
alist.append(copy.deepcopy(num))
print(num) # [2]
print(alist) # [[2]]
id(num) == id(alist[0]) # False
num.append(3)
print(num) # [2, 3]
print(alist) # [[2]]
id(num) == id(alist[0]) # False
c. 直接赋值、浅拷贝、深拷贝：
- 直接赋值： 其实就是对象的引用（别名）。
- 浅拷贝（copy）： 拷贝父对象，不会拷贝对象的内部的子对象。
- 深拷贝（deepcopy）： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
# 字典浅拷贝
import copy
a = {1: [1, 2, 3]}
# b = copy.copy(a) # 使用 copy 模块的 copy() 方法
b = a.copy()
print(a) # {1: [1, 2, 3]}
print(b) # {1: [1, 2, 3]}
a[1].append(4)
print(a) # {1: [1, 2, 3, 4]}
print(b) # {1: [1, 2, 3, 4]}
# 深度拷贝需要引入 copy 模块
import copy
a = {1: [1, 2, 3]}
b = copy.deepcopy(a)
print(a) # {1: [1, 2, 3]}
print(b) # {1: [1, 2, 3]}
a[1].append(4)
print(a) # {1: [1, 2, 3, 4]}
print(b) # {1: [1, 2, 3]}
b = a：赋值引用，a 和 b 都指向同一对象。
b = a.copy()：浅拷贝，a 和 b 是一个独立的对象，但它们的子对象还是指向同一对象（是引用）。
b = copy.deepcopy(a)：深度拷贝，a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。
(4) 删除列表元素
可以使用 del 语句来删除列表的元素。
# 使用 del 语句删除列表中的元素
list = ["Google", "Baidu", 1997, 2000]
print(f"原始列表：{list}")
del list[2]
print(f"删除第 3 个元素：{list}")
原始列表：['Google', 'Baidu', 1997, 2000]
删除第 3 个元素：['Google', 'Baidu', 2000]
(5) Python 列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| [“Hi”] * 4 | [“Hi”, “Hi”, “Hi”, “Hi”] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
(6) Python 列表截取与拼接
Python 的列表截取与字符串操作类似，如下所示：
L = ["Google", "Baidu", "Taobao"]
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| L[2] | “Taobao” | 读取第 3 个元素 |
| L[-2] | “Baidu” | 从右侧开始读取倒数第 2 个元素 |
| L[1:] | [“Baidu”, “Taobao”] | 输出从第 2 个元素开始后的所有元素 |
列表的拼接操作：
# 列表的拼接操作
squares = [1, 2, 3, 4, 5]
squares += [10, 20, 30, 40, 50]
print(squares) # [1, 2, 3, 4, 5, 10, 20, 30, 40, 50]
(7) 嵌套列表
嵌套列表：在列表里创建其它列表。
# 嵌套列表
a = ["a", "b", "c"]
n = [1, 2, 3]
x = [a, n]
print(x) # [['a', 'b', 'c'], [1, 2, 3]]
print(x[0]) # ['a', 'b', 'c']
print(x[0][1]) # 'b'
(8) Python 列表函数 & 方法
Python 包含以下函数：
| 序号 | 函数 | 说明 |
|---|---|---|
| 1 | len(list) | 返回列表元素个数 |
| 2 | max(list) | 返回列表元素最大值 |
| 3 | min(list) | 返回列表元素最小值 |
| 4 | list(seq) | 将元组转换为列表 |
| len(list) |
| lenl() 方法返回列表元素个数 |
函数语法：
len(list)
参数说明：
- list：要计算元素个数的列表。
# len() 方法返回列表元素个数
list1 = ["Google", "Baidu", "Taobao"]
print(len(list1)) # 3
list2 = list(range(5)) # 创建一个 0-4 的列表
print(len(list2)) # 5
3
5
| max(list) |
| max() 方法返回列表元素中的最大值 |
函数语法：
max(list)
参数说明：
- list：要返回最大值的列表。
# max() 方法返回列表元素中的最大值
list1, list2 = ["Google", "Baidu", "Taobao"], [456, 700, 200]
print(f"list1 最大元素值：{max(list1)}")
print(f"list2 最大元素值：{max(list2)}")
list1 最大元素值：Taobao
list2 最大元素值：700
使用 max 函数比较容器类型中的列表或者元组数据类型的比较原理：
当其中的元素全部为数字类型时，直接根据值的大小比较。
当其中的元素全部为字符串类型（string）时，比较的是每个字符串元素的第一个字符的 ASCII 的大小。
当其中的元素为数字类型和字符串类型的混杂时，无法比较。
| min(list) |
| min() 方法返回列表元素中的最小值 |
函数语法：
min(list)
参数说明：
- list：要返回最小值的列表。
# min() 方法返回列表元素中的最小值
list1, list2 = ["Google", "Baidu", "Taobao"], [456, 700, 200]
print(f"list1 最小元素值：{min(list1)}")
print(f"list2 最小元素值：{min(list2)}")
list1 最小元素值：Baidu
list2 最小元素值：200
使用 min 函数比较容器类型中的列表或者元组数据类型的比较原理：
当其中的元素全部为数字类型时，直接根据值的大小比较。
当其中的元素全部为字符串类型（string）时，比较的是每个字符串元素的第一个字符的 ASCII 的大小。
当其中的元素为数字类型和字符串类型的混杂时，无法比较。
| list(seq) |
| list() 方法用于将元组或字符串转换为列表 |
函数语法：
list(seq)
参数说明：
- seq：要转换为列表的元组或字符串。
# list() 方法用于将元组或字符串转换为列表
seq = (123, "Google", 456, "Taobao")
list1 = list(seq)
print(f"list1 列表元素：{list1}")
seq = "Hello World"
list2 = list(seq)
print(f"list2 列表元素：{list2}")
list1 列表元素：[123, 'Google', 456, 'Taobao']
list2 列表元素：['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
Python 包含以下方法：
| 序号 | 方法 | 说明 |
|---|---|---|
| 1 | list.append(obj) | 在列表末尾添加新的对象 |
| 2 | list.count(obj) | 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) | 在列表尾部一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) | 将对象插入列表 |
| 6 | list.pop([index=-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) | 移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() | 反向列表中元素 |
| 9 | list.sort(key=None, reverse=False) | 对原列表进行排序 |
| 10 | list.clear() | 清空列表 |
| 11 | list.copy() | 复制列表 |
| list.append(obj) |
| append() 方法用于在列表末尾添加新的对象 |
函数语法：
list.append(obj)
参数说明：
- obj：添加到列表末尾的对象。
# append() 方法用于在列表末尾添加新的对象
list1 = ["Google", "Baidu", "Taobao"]
list1.append("Zhihu")
print(f"更新后的列表：{list1}")
更新后的列表：['Google', 'Baidu', 'Taobao', 'Zhihu']
| list.count(obj) |
| count() 方法用于统计某个元素在列表中出现的次数 |
函数语法：
list.count(obj)
参数说明：
- obj：列表中统计的对象。
# count() 方法用于统计某个元素在列表中出现的次数
list1 = [123, "Google", "Baidu", "Taobao", 123]
print (f"123 元素个数: {list1.count(123)}")
print (f"Baidu 元素个数 : {list1.count('Baidu')}")
123 元素个数: 2
Baidu 元素个数 : 1
| list.extend(seq) |
| extend() 方法用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
函数语法：
list.extend(seq)
参数说明：
- seq：元素列表，可以是列表、元组、集合、字典，若为字典，则仅会将键(key)作为元素依次添加至原列表的末尾。
相同数据类型：
# extend() 方法用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list1 = ["Google", "Baidu", "Taobao"]
list2 = list(range(5)) # 创建 0-4 的列表
list1.extend(list2) # 扩展列表
print(f"扩展后的列表：{list1}")
扩展后的列表：['Google', 'Baidu', 'Taobao', 0, 1, 2, 3, 4]
不同数据类型：
# extend() 方法用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
# 语言列表
language = ["French", "English", "German"]
# 元组
language_tuple = ("Spanish", "Portuguese")
# 集合
language_set = {"Chinese", "Japanese"}
# 字典
language_dict = {"England": "English", "Russia": "Russian"}
# 添加元组元素到列表末尾
language.extend(language_tuple)
print(f"新列表：{language}")
# 添加集合元素到列表末尾
language.extend(language_set)
print(f"新列表：{language}")
# 添加字典元素到列表末尾
language.extend(language_dict)
print(f"新列表：{language}")
新列表：['French', 'English', 'German', 'Spanish', 'Portuguese']
新列表：['French', 'English', 'German', 'Spanish', 'Portuguese', 'Chinese', 'Japanese']
新列表：['French', 'English', 'German', 'Spanish', 'Portuguese', 'Chinese', 'Japanese', 'England', 'Russia']
| list.index(obj) |
| index() 函数用于从列表中找出某个值第一个匹配项的索引位置，如果没有找到对象则抛出异常 |
函数语法：
list.index(x[, start[, end]])
参数说明：
- x：查找的对象。
- start：可选，查找的起始位置。
- end：可选，查找的结束位置。
# index() 函数用于从列表中找出某个值第一个匹配项的索引位置，如果没有找到对象则抛出异常
list1 = ["Google", "Baidu", "Taobao"]
print(f"Baidu 索引值为：{list1.index('Baidu')}")
print(f"Taobao 索引值为：{list1.index('Taobao')}")
Baidu 索引值为：1
Taobao 索引值为：2
从指定位置开始搜索：
# index() 函数用于从列表中找出某个值第一个匹配项的索引位置，如果没有找到对象则抛出异常
list1 = ["Google", "Baidu", "Taobao", "Facebook", "QQ"]
# 从指定位置开始搜索
print(f"Baidu 索引值为：{list1.index('Baidu', 1)}")
# 搜索列表中没有的元素
print(f"Jingdong 索引值为：{list1.index('Jingdong')}")
Baidu 索引值为：1
ValueError: 'Jingdong' is not in list
| list.insert(index, obj) |
| insert() 函数用于将指定对象插入列表的指定位置 |
函数语法：
list.insert(index, obj)
参数说明：
- index：对象 obj 需要插入的索引位置。
- obj：要插入列表中的对象。
# insert() 函数用于将指定对象插入列表的指定位置
list1 = ["Google", "Baidu", "Taobao"]
list1.insert(1, "Jingdong")
print(f"列表插入元素后：{list1}")
列表插入元素后：['Google', 'Jingdong', 'Baidu', 'Taobao']
| list.pop([index=-1]) |
| pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
函数语法：
list.pop([index=-1])
参数说明：
- index：可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。
# pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list1 = ["Google", "Baidu", "Taobao", "Jingdong"]
list1.pop()
print(f"移除元素后的列表：{list1}")
list1.pop(1)
print(f"移除元素后的列表：{list1}")
移除元素后的列表：['Google', 'Baidu', 'Taobao']
移除元素后的列表：['Google', 'Taobao']
| list.remove(obj) |
| remove() 函数用于移除列表中某个值的第一个匹配项 |
函数语法：
list.remove(obj)
参数说明：
- obj：列表中要移除的对象。
# remove() 函数用于移除列表中某个值的第一个匹配项
list1 = ["Google", "Baidu", "Taobao", "Jingdong"]
list1.remove("Taobao")
print(f"移除元素后的列表：{list1}")
list1.remove("Baidu")
print(f"移除元素后的列表：{list1}")
list1.remove("Facebook") # 要移除的元素不在列表中
print(f"移除元素后的列表：{list1}")
移除元素后的列表：['Google', 'Baidu', 'Jingdong']
移除元素后的列表：['Google', 'Jingdong']
ValueError: list.remove(x): x not in list
| list.reverse() |
| reverse() 函数用于反向列表中元素 |
函数语法：
list.reverse()
参数说明：
- NA。
# reverse() 函数用于反向列表中元素
list1 = ["Google", "Baidu", "Taobao", "Jingdong"]
list1.reverse()
print(f"列表反转后：{list1}")
列表反转后：['Jingdong', 'Taobao', 'Baidu', 'Google']
| list.sort( key=None, reverse=False) |
| sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数 |
函数语法：
list.sort( key=None, reverse=False)
参数说明：
- key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
- reverse：排序规则，reverse=True 降序，reverse=False 升序（默认）。
# sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
list1 = ["Google", "Baidu", "Taobao", "Jingdong", "Facebook"]
list1.sort() # 升序，默认 reverse=False
print(f"List: {list1}") # List: ['Baidu', 'Facebook', 'Google', 'Jingdong', 'Taobao']
list1.sort(reverse=True) # 降序
print(f"List: {list1}") # List: ['Taobao', 'Jingdong', 'Google', 'Facebook', 'Baidu']
# sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
def takeSecond(element):
"""通过指定列表中的元素排序来输出列表"""
return element[1]
random = [(2, 2), (3, 4), (4, 1), (1, 3)] # 列表
random.sort(key=takeSecond) # 指定第二个元素排序，升序，默认 reverse=False
print(f"排序列表：{random}") # 排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]
random.sort(key=takeSecond, reverse=True) # 指定第二个元素排序，降序
print(f"排序列表：{random}") # 排序列表：[(3, 4), (1, 3), (2, 2), (4, 1)]
1195
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
