菜鸟教程《Python 3 教程》笔记

0 写在前面

笔记带有个人侧重点，不追求面面俱到。

1 基本数据类型

出处： 菜鸟教程 - Python3 基本数据类型

Python 3 的六个标准数据类型中：

• 不可变数据（3 个）： Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）： List（列表）、Dictionary（字典）、Set（集合）。

此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

1.1 Number（数字）

注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0会返回 True，但可以通过 is 来判断类型。

>>> issubclass(bool, int) 
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False

1.2 String（字符串）

Python 使用反斜杠 \转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob

1.3 bool（布尔类型）

• 布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。
• 布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。

a = True
b = False

# 比较运算符
print(2 < 3)   # True
print(2 == 3)  # False

# 逻辑运算符
print(a and b)  # False
print(a or b)   # True
print(not a)    # False

# 类型转换
print(int(a))   # 1
print(float(b)) # 0.0
print(str(a))   # "True"

1.4 List（列表）

list1 = [x for x in range(9)]

print(list1[-1::-2])  # [9]
print(list1[-1:-4])   # []

1.5 Tuple（元组）

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

1.6 Set（集合）

注意： 创建一个空集合必须用 set() 而不是 {}，因为 {} 是用来创建一个空字典。

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)
print(a - b)     # a 和 b 的差集
print(b - a)
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

{'d', 'c', 'r', 'a', 'b'}
{'r', 'd', 'b'}
{'m', 'z', 'l'}
{'m', 'd', 'c', 'r', 'a', 'z', 'b', 'l'}
{'a', 'c'}
{'m', 'r', 'd', 'z', 'b', 'l'}

1.7 Dictionary（字典）

键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。

构造函数 dict() 可以直接从键值对序列中构建字典如下：

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

1.8 bytes 类型

什么是 bytes 类型：

• 在 Python3 中，bytes 类型表示的是不可变的二进制序列（byte sequence）。
• 与字符串类型不同的是，bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。

怎么创建 bytes 类型：

1. 使用 b 前缀；
2. 可以使用 bytes() 函数将其他类型的对象转换为 bytes 类型。

x = bytes("hello", encoding="utf-8")

注意： bytes 类型中的元素是整数值，因此在进行比较操作时需要使用相应的整数值。

x = b"hello"
if x[0] == ord("h"):
    print("The first element is 'h'")

2 数据类型转换

出处：菜鸟教程 - Python3 数据类型转换

Python 数据类型转换可以分为2种：

• 隐式类型转换 - 自动完成；
• 显式类型转换 - 需要使用类型函数来转换。

2.1 隐式类型转换

对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。

2.2 显式类型转换

Column 1	Column 2
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)	将一个整数转换为一个八进制字符串

2.2.1 int() 函数

语法：

class int(x, base=10)

参数：

• x – 字符串或数字。
• base – 进制数，默认十进制。

返回值：
返回整型数据。

实例：

>>>int()               # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12', 16)        # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int('0xa', 16)  
10  
>>> int('10', 8)  
8

int(float("2.3"))

2.2.2 repr() 函数

语法：

repr(object)

参数：

• object – 对象。

返回值：
返回一个对象的 string 格式。

实例：

>>> s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
>>>

str()和repr()的区别：

出处：python3编程基础：str()、repr()的区别

区别 1：字符串再转换为字符串

>>> repr('abd')  #repr转换后是在'abd'的外层又加了一层引号
"'abd'"
>>> str('abd')   #str转换后还是原来的值
'abd'
>>> str('abd') == 'abd'
True
>>> repr('abd') == 'abd'
False
>>> len(repr('abd'))  #repr转换后的字符串和str转换后的字符串个数都是不一样的
5
>>> len(str('abd'))
3

区别 2：命令行下print和直接输出的对比

>>> class A():
...     def __repr__(self):
...         return 'repr'
...     def __str__(self):
...         return 'str'
...
>>> a = A()
>>> a    #直接输出调用的是repr方法
repr
>>> print(a)    #print调用的是str方法
str

repr的使用场景：

>>> s = 'abdcf'
>>> eval('['+','.join([repr(i) for i in s])+']')
['a', 'b', 'd', 'c', 'f']
>>> eval('['+','.join([str(i) for i in s])+']')    #str报错
Traceback (most recent call last):
  File "", line 1, in <module>
  File "", line 1, in <module>
NameError: name 'b' is not defined

2.2.3 frozenset ()函数

语法：

class frozenset([iterable])

参数：

• iterable – 可迭代的对象，比如列表、字典、元组等等。

返回值：
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。

为什么需要冻结的集合（即不可变的集合）呢？因为在集合的关系中，有集合的中的元素是另一个集合的情况，但是普通集合（set）本身是可变的，那么它的实例就不能放在另一个集合中（set中的元素必须是不可变类型）。
所以，frozenset提供了不可变的集合的功能，当集合不可变时，它就满足了作为集合中的元素的要求，就可以放在另一个集合中了。

3 Python 3 运算符

出处：菜鸟教程 - Python3 运算符

Python 语言支持以下类型的运算符：

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符

3.1 赋值运算符

Python 3.8 新增了，海象运算符 := ，可在表达式内部为变量赋值，目的是避免重复调用，提高运行时间。

示例：

if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

上述代码，避免2次调用 len()，也省去使用中间变量。

扩展阅读：
Python :=海象运算符最简单的解释
What’s New In Python 3.8

3.2 位运算符

#!/usr/bin/python3
 
a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
# 按位与运算符
c = a & b        # 12 = 0000 1100
print ("1 - c 的值为：", c)
# 按位或运算符
c = a | b        # 61 = 0011 1101 
print ("2 - c 的值为：", c)
# 按位异或运算符
c = a ^ b        # 49 = 0011 0001
print ("3 - c 的值为：", c)
# 按位取反运算符
c = ~a           # -61 = 1100 0011
print ("4 - c 的值为：", c)
# 左移动运算符
c = a << 2       # 240 = 1111 0000
print ("5 - c 的值为：", c)
# 右移动运算符
c = a >> 2       # 15 = 0000 1111
print ("6 - c 的值为：", c)

3.3 逻辑运算符

运算符	逻辑表达式	描述
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

实例：

print(10 and 20)  # 20
print(0 and 20)   # 0
print(10 or 20)   # 10
print(0 or 20)    # 20
print(0 or True)  # True
print(not 0)      # True
print(not True)   # False

3.4 身份运算符

is 与 == 的区别：is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值（子对象）是否相等。

补充： is 判断两个对象是否为同一对象，是通过 id 来判断的；当两个基本类型数据(或元组)内容相同时，id 会相同，但并不代表 a 会随 b 的改变而改变。
== 判断两个对象的内容是否相同，是通过调用 __eq__() 来判断的。

实例：

>>>a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

上述代码，b = a 中 b 是 a 的引用，指向同一个内存地址；b = a[:] 中 b 是 a 的浅拷贝，共用相同的子对象。可以参考：Python中直接赋值、浅拷贝和深拷贝的区别

补充内容：

a = 100
b = 100
print(a is b)  # True
print(a == b)  # True

上述代码中，a 和 b 指向了同一个内存地址。这是 Python 的特性，变量以内容为基准。这个特性决定了在 Python 中，数字类型的值是不可变的。当 a 的值改变时，是 a 指向了新的内存地址，而不是内存地址中的值改变了。

3.5 运算符优先级

以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。 运算符均指二元运算，除非特别指出。 相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：

运算符	描述
(expressions…), [expressions…], {key: value…}, {expressions…}	圆括号的表达式
x[index], x[index: index], x(arguments…), x.attribute	读取，切片，调用，属性引用
await x	await 表达式
**	乘方(指数)
+x, -x, ~x	正，负，按位非 NOT
*, @, /, //, %	乘，矩阵乘，除，整除，取余
+, -	加和减
<<, >>	移位
&	按位与 AND
^	按位异或 XOR
|	按位或 OR
in,not in, is,is not, <, <=, >, >=, !=, ==	比较运算，包括成员检测和标识号检测
not x	逻辑非 NOT
and	逻辑与 AND
or	逻辑或 OR
if – else	条件表达式
lambda	lambda 表达式
:=	赋值表达式

注意： and 的优先级比 or 高。

4 数字

出处：菜鸟教程 - Python3 数字(Number)

数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。

4.1 Python 数字运算

注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。

实例：

>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0

4.2 数字函数

4.2.1 abs() 函数

描述：

abs() 函数返回数字的绝对值。

语法：

abs(x)

参数：

• x – 数值表达式，可以是整数，浮点数，复数。

返回值：

函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。

>>>v = Vecter(3, 4)
>>>abs(v)
5.0

fabs() 与 abs() 的区别：

1. abs() 是一个内置函数，而 fabs() 在 math 模块中定义的；
2. fabs() 函数只适用于 float 和 integer 类型，而 abs() 也适用于复数；
3. abs() 的返回值可以是整数也可以是浮点数，视输入而定，fabs() 的返回值总是浮点数。

4.2.2 ceil() 函数

描述：

ceil() 函数返回一个大于或等于 x 的的最小整数。（向上取整）

语法：

import math
math.ceil(x)

参数：

• x – 数值表达式。

返回值：

返回一个大于或等于 x 的的最小整数。

4.2.3 cmp() 函数（Python 3 已废弃）

描述：

如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

注意： Python 3 已废弃，使用 (x>y)-(x

4.2.4 floor() 函数

描述：

floor() 返回数字的下舍整数，小于或等于 x。（向下取整）

语法：

import math
math.floor(x)

参数：

• x – 数值表达式。

返回值：

返回小于或等于 x 的整数。

4.2.5 max() 函数

描述：

max() 方法返回给定参数的最大值，参数可以为序列。

注意： 入参类型不能混入，要么全是数字，要么全是序列。入参是序列的话： 单序列入参，返回序列中最大的一个数值。多序列入参, 按索引顺序，逐一对比各序列的当前索引位的 “值”，直到遇见最大值立即停止对比，并返回最大值所在的序列

>>> max(0, True)
True
>>> max([1,2,3])
3
>>> max([2,4], [3,6])
[3, 6]
>>> max([2,4], [1,5])
[2, 4]
>>> max((1,-1,0), (True,False,2,0),(1, 0, 0, 2))
(True, False, 2, 0)
>>> max((1,-1,0), (True,),(1,))
(1, -1, 0)
>>> max([1,3,2],3,4) #非法入参
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: '>' not supported between instances of 'int' and 'list'
>>> max((1,2,3), [2,4,1]) #非法入参
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: '>' not supported between instances of 'list' and 'tuple'

4.2.6 modf() 函数

描述：

modf() 方法返回 x 的整数部分与小数部分，两部分的数值符号与 x 相同，整数部分以浮点型表示。

语法：

import math
math.modf(x)

参数：

• x – 数值表达式。

返回值：

返回x的整数部分与小数部分。

实例：

>>> import math
>>> math.modf(3.2)
(0.20000000000000018, 3.0)
>>> math.modf(-0.01)
(-0.01, -0.0)
>>> type(math.modf(-3.2))
<class 'tuple'>

4.2.7 pow() 函数

描述：

pow() 方法返回 x^y（x的y次方） 的值。

语法：

import math
math.pow(x, y)

pow(x, y[, z])

注意： pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

参数：

• x – 数值表达式。
• y – 数值表达式。
• z – 数值表达式。

返回值：

返回 x^y（x的y次方） 的值。

4.2.8 round() 函数

描述：

round() 方法返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端（四舍六入）。精度要求高的，不建议使用该函数。

语法：

round( x [, n]  )

参数：

• x – 数字表达式。
• n – 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。

返回值：

返回浮点数x的四舍五入值。

注意： round() 保留值将保留到离上一位更近的一端（四舍六入）。如果距离两边一样远，会保留到偶数的一边。比如 round(0.5) 和 round(-0.5) 都会保留到 0，而 round(1.5) 会保留到 2。同时，受浮点数精度影响，结果不一定复合预期。

参考：python中关于round函数的小坑

4.3 随机数函数

4.3.1 choice() 函数

描述：

choice() 方法返回一个列表，元组或字符串的随机项。

语法：

import random
random.choice(seq)

参数：

• seq – 可以是一个列表，元组或字符串。

返回值：

返回随机项。

实例：

random.choice(range(100))
random.choice([1, 2, 3, 5, 9])
random.choice('Runoob')

4.3.2 randrange() 函数

描述：

randrange() 方法返回指定递增基数集合中的一个随机数，基数默认值为1。

语法：

import random
random.randrange ([start,] stop [,step])

参数：

• start – 指定范围内的开始值，包含在范围内；
• stop – 指定范围内的结束值，不包含在范围内；
• step – 指定递增基数。

返回值：

从给定的范围返回随机项。

实例：

random.randrange(1, 100, 2)
random.randrange(100)

4.3.3 shuffle() 函数

描述：

shuffle() 方法将序列的所有元素随机排序。

语法：

import random
random.shuffle(lst)

参数：

• lst – 列表。

返回值：

返回 None。

4.3.4 uniform() 函数

描述：

uniform() 方法将随机生成下一个实数，它在 [x,y] 范围内。

语法：

import random
random.uniform(x, y)

参数：

• x – 随机数的最小值，包含该值；
• y – 随机数的最大值，包含该值。

返回值：

返回一个浮点数 N，取值范围为如果 x

5 字符串

出处：菜鸟教程 - Python3 字符串

5.1 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("\"")
"
>>> print("\a")
# 执行后电脑有响声。
>>> print("Hello \b World!")
Hello World!
>>> print("\000")

>>> print("\n")


>>> print("Hello \v World!")
Hello 
       World!
>>> print("Hello\rWorld!")
World!
>>> print('google runoob taobao\r123456')
123456 runoob taobao
>>> print("Hello \f World!")
Hello 
       World!
>>> print("\110\145\154\154\157\40\127\157\162\154\144\41")
Hello World!
>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")
Hello World!

一段有趣的代码：

import time

for i in range(101):
    print("\r{:3}%".format(i),end=' ')
    time.sleep(0.05)

5.2 Python 字符串格式化

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%0	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

格式化操作符辅助指令：

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
	在正数前面显示空格
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格
%	‘%%‘输出一个单一的’%’
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

5.3 f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

在 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

5.4 Unicode 字符串

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在Python3中，所有的字符串都是Unicode字符串。

5.5 Python 的字符串方法

5.5.1 capitalize()

描述：

capitalize() 将字符串的第一个字母变成大写，其他字母变小写。

语法：

str.capitalize()

5.5.2 center()、ljust()、rjust()、zfill()

描述：

center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。zfill(width) 作用同 rjust(width, "0")。

语法：

str.center(width[, fillchar])

参数：

• width – 字符串的总宽度。
• fillchar – 填充字符。

返回值：

返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。

实例：

str = "[runoob]"
print ("str.center(40, '*') : ", str.center(40, '*'))
print ("str.center(40, '*') : ", str.ljust(40, '*'))
print ("str.center(40, '*') : ", str.rjust(40, '*'))

str.center(40, '*') :  ****************[runoob]****************
str.center(40, '*') :  [runoob]********************************
str.center(40, '*') :  ********************************[runoob]

注意：

1. width 小于字符串长度时，返回字符串，不会截断；
2. fillchar 只能接收单个字符；
3. 奇数个字符时，优先补充右边；偶数个字符时，优先补充左边。

>>> str = "[www.runoob.com]"
>>> print ("str.center(4, '*') : ", str.center(4, '*'))
str.center(4, '*') :  [www.runoob.com]         // width 小于字符串宽度

>>> str = "[www.runoob.com]"
>>> print ("str.center(40, '?!') : ", str.center(40, '?!'))
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: The fill character must be exactly one character long

>>> print('123'.center(4, '*'))     # 奇数个字符时优先向右边补*
123*
>>> print('1234'.center(5, '*'))    # 偶数个字符时优先向左边补*
*1234
>>> print('1234'.center(7, '*'))
**1234*

5.5.3 count()

描述：

count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

语法：

str.count(sub, start= 0,end=len(string))

参数：

• sub – 搜索的子字符串；
• start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0；
• end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

返回值：

该方法返回子字符串在字符串中出现的次数。

实例：

str="www.runoob.com"
sub='o'
print ("str.count('o') : ", str.count(sub))
sub='run'
print ("str.count('run', 0, 10) : ", str.count(sub,0,10))
# 输出
str.count('o') :  3
str.count('run', 0, 10) :  1

注意： 已统计过的字符不重复统计。

>>> str1,str2,str3 = 'aaaa','aaaaa','aaaaaa'
>>> print(str2.count('aa'))
2
>>> print(str2.count('aa'))
2
>>> print(str3.count('aa'))
3

5.5.4 endswith()、startswith()

描述：

endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 “start” 与 “end” 为检索字符串的开始与结束位置。

语法：

str.endswith(suffix[, start[, end]])

参数：

• suffix – 该参数可以是一个字符串或者是一个元素；
• start – 字符串中的开始位置；
• end – 字符中结束位置。

返回值：

如果字符串含有指定的后缀返回 True，否则返回 False。

注意： 判断范围为 [start, end) 。

5.5.5 expandtabs()

描述：

expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16…等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。

语法：

str.expandtabs(tabsize=8)

参数：

• tabsize – 指定转换字符串中的 tab 符号 \t 转为空格的字符数。

返回值：

该方法返回字符串中的 tab 符号 \t 转为空格后生成的新字符串。

实例：

str = "this is\tstring example....wow!!!"    # \t 前面的字符串长度为 7

print("替换 \\t 符号: " + str.expandtabs(0))  # 删除\t
print("替换 \\t 符号: " + str.expandtabs(1))  # 补充1个
print("替换 \\t 符号: " + str.expandtabs(2))  # 补充1个
print("替换 \\t 符号: " + str.expandtabs(3))  # 补充2个
print("替换 \\t 符号: " + str.expandtabs(7))  # 补充7个
# 输出
替换 \t 符号: this isstring example....wow!!!
替换 \t 符号: this is string example....wow!!!
替换 \t 符号: this is string example....wow!!!
替换 \t 符号: this is  string example....wow!!!
替换 \t 符号: this is       string example....wow!!!

5.5.6 find()、rfind()、index()和rindex()

语法：

str.find(str, beg=0, end=len(string))
str.index(str, beg=0, end=len(string))

注意： 寻值范围为 [beg, end) 。

两者的区别：

未找到子字符串时，find() 返回 -1，index() 抛出异常。

5.5.7 isalnum() 等方法

方法	描述	True	False
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False	a-z，A-Z，0-9，中文	标点符号
isalpha()	如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False	a-z，A-Z，中文	0-9，标点符号
isdigit()	如果字符串只包含数字则返回 True 否则返回 False	0-9，byte数字（单字节），全角数字（双字节）	汉字数字，罗马数字
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False	Unicode 数字，全角数字（双字节），汉字数字	罗马数字
isdecimal()	检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false	0-9，全角数字（双字节）	罗马数字，汉字数字
isspace()	如果字符串中只包含空白，则返回 True，否则返回 False	空格、制表符(\t)、换行(\n)、回车(\r）
isupper()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False	A-Z + 其他	a-z + 其他
islower()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False	a-z + 其他	A-Z + 其他
istitle()	如果字符串是标题化的(见 5.5.12 title())则返回 True，否则返回 False	大写字母开头，后接小写字母或中文

实例：

num = "\u0030"  #unicode 0
num.isdigit()   # True
num.isdecimal() # True
num.isnumeric() # True

num = "\u00B2"  #unicode ²
num.isdigit()   # True
num.isdecimal() # False
num.isnumeric() # True

num = "\u00B2"  #unicode ½
num.isdigit()   # False
num.isdecimal() # False
num.isnumeric() # True

num = "1" # 全角
num.isdigit()   # True
num.isdecimal() # True
num.isnumeric() # True

num = b"1" # byte
num.isdigit()   # True
num.isdecimal() # AttributeError 'bytes' object has no attribute 'isdecimal'
num.isnumeric() # AttributeError 'bytes' object has no attribute 'isnumeric'

num = "IV" # 罗马数字
num.isdigit()   # False
num.isdecimal() # False
num.isnumeric() # False

num = "四" # 汉字
num.isdigit()   # False
num.isdecimal() # False
num.isnumeric() # True

5.5.8 maketrans()、translate()

描述：

maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同，为一一对应的关系。

注意： Python3.4 已经没有 string.maketrans() 了，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans() 。

语法：

string.maketrans(x[, y[, z]])

参数：

• x – 必需，字符串中要替代的字符组成的字符串；
• y – 可选，相应的映射字符的字符串；
• z – 可选，要删除的字符。

返回值：

返回字符串转换后生成的新字符串。

实例：

# 一个参数，该参数必须为字典
>>> d = {'a':'1','b':'2','c':'3','d':'4','e':'5','s':'6'}
>>> trantab = str.maketrans(d)
>>> st='just do it'
>>> print(st.translate(trantab))
ju6t 4o it

# 两个参数 x 和 y，x、y 必须是长度相等的字符串，并且 x 中每个字符映射到 y 中相同位置的字符
>>> x = 'abcdefs'
>>> y = '1234567'
>>> st='just do it'
>>> trantab = str.maketrans(x,y)
>>> print(st.translate(trantab))
ju7t 4o it

# 三个参数 x、y、z，第三个参数 z 必须是字符串，先删除，再替换
>>> x = 'abcdefs'
>>> y='1234567'
>>> z='ot'
>>> st='just do it'
>>> trantab = str.maketrans(x,y,z)
>>> print(st.translate(trantab))
ju7 4 i

5.5.9 rstrip()、lstrip()、strip()

描述：

rstrip() 删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。

语法：

str.rstrip([chars])

注意： chars 是一个包含需要删除的字符的字符串。从 str 的末尾开始删除，直到末尾的字符不在 chars 中。

参数：

• chars – 指定删除的字符（默认为空白符）

返回值：

返回删除 string 字符串末尾的指定字符后生成的新字符串。

实例：

>>> random_string = "this is good    "
# 字符串末尾的空格会被删除
>>> print(random_string.rstrip())
this is good
# 'si oo' 不是尾随字符，因此不会删除任何内容
>>> print(random_string.rstrip('si oo'))
this is good
# 在 'sid oo' 中 'd oo' 是尾随字符，'ood' 从字符串中删除
>>> print(random_string.rstrip('sid oo')) 
this is g
# 移除逗号(,)、点号(.)、字母 s、q 或 w，这几个都是尾随字符
>>> txt = "banana,,,,,ssqqqww....."
>>> print(txt.rstrip(",.qsw"))
banana

5.5.10 split()

描述：

split() 方法通过指定分隔符对字符串进行切片，该方法将字符串分割成子字符串并返回一个由这些子字符串组成的列表。

语法：

str.split(str="", num=string.count(str))

参数：

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等；
• num – 分割次数，如果设置了这个参数，则最多分割成 maxsplit+1 个子字符串。默认为 -1, 即分隔所有。

返回值：

返回分割后的字符串列表。

5.5.11 splitlines()

描述：

splitlines() 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

语法：

str.splitlines([keepends])

参数：

• keepends – 在输出结果里是否去掉换行符(‘\r’, ‘\r\n’, \n’)，默认为 False，不包含换行符，如果为 True，则保留换行符。

返回值：

返回一个包含各行作为元素的列表。

实例：

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

5.5.12 title()

描述：

title() 方法返回"标题化"的字符串，就是说所有单词的首个字母转化为大写，其余字母均为小写。

注意： 单词是指以a-zA-Z之外符号分割的字母。例如：ab12cd中ab、cd是单词。

语法：

str.title()

参数：

• NA

返回值：

返回"标题化"的字符串，就是说所有单词的首字母都转化为大写。

实例：

>>> txt = "hello b2b2b2 and 3g3g3g"
>>> print(txt.title())
Hello B2B2B2 And 3G3G3G

6 列表

出处： 菜鸟教程 - Python3 列表

6.1 删除列表元素

>>> list = ['Google', 'Runoob', 1997, 2000]
>>> print ("原始列表 : ", list)
原始列表 :  ['Google', 'Runoob', 1997, 2000]
>>> del list[2]
>>> print ("删除第三个元素 : ", list)
删除第三个元素 :  ['Google', 'Runoob', 2000]

6.2 列表函数和方法

6.2.1 max()、min()

注意：

1. 使用 max() 和 min() 时，列表中的元素需要是同一种类型，否则无法比较；
2. 当列表的元素为 list[int] 整型列表时，优先比较整型列表第一个元素，如果相同会继续比较下去；
3. 当列表的元素为 string 字符串时，会比较每个字符串元素的第一个字符的 ASCII 的大小。

实例：

>>> list1 = [[1, 4], [2, 3], [1, 5]]
>>> max(list1)
[2, 3]
>>> list1 = [[1, 4], [1, 3], [1, 5]]
>>> max(list1)
[1, 5]

>>> list1 = ['我最', '爱学习', 'python']
>>> max(list1)
'爱学习'
# ord('我') >>> 25105
# ord('爱') >>> 29233
# ord('p') >>> 112

6.2.2 reverse()

描述：

reverse() 函数用于反向列表中元素。

语法：

list.reverse()

6.2.3 sort()

描述：

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

语法：

list.sort(key=None, reverse=False)

参数：

• key – 一个函数，入参为可迭代对象的元素，根据函数的返回值继续排序；
• reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

返回值：

该方法没有返回值，但是会对列表的对象进行排序。

实例：

>>> list1 = ["apple", "watermelon", "banana"]
>>> list1.sort(key = lambda ele: len(ele))
>>> list1
['apple', 'banana', 'watermelon']

7 元组

出处： 菜鸟教程 - Python3 元组

注意： tuple1 = (50,) 带 , 是元组，否则是整型。

8 字典

出处： 菜鸟教程 - Python3 字典

8.1 字典内置函数和方法

8.1.1 fromkeys()

描述：

fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

语法：

dict.fromkeys(seq[, value])

参数：

• seq – 字典键值列表；
• value – 可选参数, 设置键序列（seq）对应的值，默认为 None。

返回值：

该方法返回一个新字典。

实例：

>>> seq = ('name', 'age', 'sex')
>>> dict.fromkeys(seq)
{'age': None, 'name': None, 'sex': None}
>>> dict.fromkeys(seq, 10)
{'age': 10, 'name': 10, 'sex': 10}

8.1.2 get()、setdefault()

描述：

get() 函数返回指定键的值。
setdefault() 方法和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

语法：

dict.get(key[, value]) 
dict.setdefault(key, default=None)

参数：

• key – 字典中要查找的键；
• value – 可选，如果指定键的值不存在时，返回该默认值；
• default – 键不存在时，设置的默认键值。

返回值：

返回指定键的值，如果键不在字典中返回默认值，如果不指定默认值，则返回 None。
如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。

8.1.3 popitem()

描述：

popitem() 方法随机返回并删除字典中的最后一对键和值。如果字典已经为空，却调用了此方法，就报出 KeyError 异常。

9 集合

出处： 菜鸟教程 - Python3 集合

集合是一组无序排列的可哈希的值。

9.1 集合的基本操作

# 集合间的运算
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b  # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b  # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b  # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b  # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

9.2 集合内置方法

9.2.1 add()、update()

add() 只接受可哈希的值，即不可变数据，数、字符串、元组。
update 可以接受数、字符串、元组、列表、集合。

9.2.2 pop()、remove()、discard()

pop 不具名地移除集合中的元素；
remove 移除集合中的指定元素，如果元素不存在，则会发生错误 KeyError；
discard 移除集合中的指定元素，如果元素不存在也不会报错。

9.2.3 difference()、differece_update()等

>>> x = {"apple", "banana", "cherry"}
>>> y = {"google", "microsoft", "apple"}
>>> x.difference(y)
{'cherry', 'banana'}                         # 返回值 x - y
>>> x.intersection(y)
{'apple'}                                    # 返回值 x & y
>>> x.symmetric_difference(y)
{'microsoft', 'google', 'cherry', 'banana'}  # 返回值 x ^ y
>>> x.union(y)                               # 返回值 a | b
{'microsoft', 'google', 'cherry', 'banana', 'apple'}


>>> x.difference_update(y)                   # 没有返回值
>>> x
{'banana', 'cherry'}
>>> x.add('apple')
>>> x.intersection_update(y)                 # 没有返回值
>>> x
{'apple'}
>>> x.add({'banana', 'cherry'})
>>> x.symmetric_difference_update(y)         # 没有返回值
>>> x
{'microsoft', 'google', 'cherry', 'banana'}
>>> x.update({apple})                        # 没有返回值
>>> x
{'microsoft', 'google', 'cherry', 'banana', 'apple'}

9.2.4 isdisjoint()

描述：

isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。即两者是否有交集。

9.2.5 issubset()、issuperset()

issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。即：A ⊆ B。
issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。即：A ⊇ B。

========== 更新日期 2023年8月27日 ==========