前言
这是一篇由中国广东潮汕地区浪险猴同学写的笔记。
- 本人学习很多东西整理的笔记个人认为比较直观，用词刺眼，如有冒犯，多多原谅。
作者：：水月by黄俊伟
- 初学任何技能不要一上来就各种买买买视频、囤课、计划等不会进步的操作，建议先学习，并请多使用搜索引擎。
- 搜：Python怎么学？学习不是小马过河问如何过河，而是搜：Python3基础语法。
- 找官方文档，或基础操作教程等，从基础去出发，我写笔记之前看的比较杂，用的最多的还只是那些基础操作。
- 请牢记：掌握方法和原理与熟练的使用是两个不同的阶段，先大致看一遍，然后打开有关 Markdown 语言相关的笔记软件开始整理与思考。
- 不知道怎么使用 Markdown 相关笔记软件建议阅读我的《Markdown语法快速入门》。
- 用简单的一句话就是：掌握Python建议先学习。
-
学：满足日常学习和提升需求，用简练的语言说清楚问题。
-
习：摆脱基础、语法，重点关注算法、架构、性能，乃至内部实现。
-
以上均以思想为支撑，超脱语言老套路，构建并完善为中心。
- 学：通过阅读、听讲、观察、思考、理解等途径获得知识。
- 习：探索、研究、实验、实践技能的过程。
- 本文耗费了一周的通宵时间整理，搜索引擎查询约2000余次，格式与句子改动不少于30次，原因本人也只有初中文凭毕业，在外浑浑噩噩过了10年，如果你觉得本笔记对你有帮助，动动你的手指头点个赞，谢谢~为了尊重他人成果，转载请注明源处……
- 数值类型(3种)：整数(int)、浮点数(float)、复数(complex)。
- 字节类型（2种）：字符串(string)、字节串(bytes)。
- 组合类型（4种）：集合(set)、元组(tuple)、列表(list)、字典(dict)。
- 不可变数据（3 个）：
Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：
List（列表）、Dictionary（字典）、Set（集合）。
Ps：以下内容没有特别声明的情况下，用的符号都是英文输入符号。
一、数值类型（3种）
- 数值类型(3种)：整数(int)、浮点数(float)、复数(complex)。
- 整数类型：整型、二进制/八进制/十进制/十六进制。
- 浮点数类型：有取值范围、计算机中存在不确定尾数问题；能作为科学计数法、大精确浮点运算。
- 复数类型：与数学中复数概念一致，由实数部分和虚数部分构成。
1.1 整数类型 Int（2种）
1.1.1 进制
- 进制之间是可以进行比较，先转换为同个进制，位值相等返回
True，否则是False 。
- 二进制：以
0b或0B开头，不区分大小写。
- 二进制顾名思义，满2进1，没有2、3、4、5...9这些整数，也没有浮点数。
# 错误示范：0b123
0b1101,-0B10
# 进制运算示范：
>>>bin(0b1 + 0b1)
0b10
- 八进制：以
0o或0O开头，不区分大小写。
- 八进制顾名思义，满8进1，没有8、9的整数，也没有浮点数。
# 错误示范：0o789
0o456,-0O777
- 十进制：（满十进一，满二十进二，个十百千万）
- 十进制是我们生活实用的进制，例如：人民币1元，10元等。
0,1,2,345,-1,-2
- 十六进制：以
0x或0X开头，不区分大小写。
- 一般用数字0到9和字母A到F（或af）表示，其中:AF表示10~15，这些称作十六进制数字。
0x1A,-0X2B
1.2 浮点型 Float
- 浮点型由整数部分+小数部分组成，浮点型也可以使用科学计数法表示。
- 浮点数并不一定等于小数，定点数也并不一定就是整数。
- 所谓浮点数就是小数点在逻辑上是不固定的，而定点数只能表示小数点固定的数值，具用浮点数或定点数表示某哪一种数要看用户赋予了这个数的意义是什么。
-
科学计数法
- 科学记数法的形式是由两个数的乘积组成。
- 公式：a×e**b（a乘以e的b次方，e以10为基数，不分大小写）。
>>> 1.2e-3
0.0012
>>> 9.8E7
98000000.0
-
浮点型精度
- 浮点数直接运算，可能产生不确定尾数的精度问题。
- 浮点数无法精确表示十进制数，广泛于计算机编程语言中。
>>> print(0.1+0.2)
0.30000000000000004
# 常数：0.1
# 二进制:0.00011001100110011001……
# 十进制:0.10000000000000000555……
>>> round(0.1 + 0.2,1)
0.3
# round(x[,n])方法返回浮点数x的四舍五入值。
# x -- 数值表达式。
# n -- 数值表达式，表示从小数点位数。
# 返回值：四舍五入。
-
大精确浮点运算
- 需求：浮点数的科学运算、精度需求更多、数据运算范围更大。
- 方案：将浮点数运算转换为整数运算，格式为：数值整数 和 小数位整数。
# 例如：1.4e-3 + 0.01
14,4 + 1,2
# 将小数位数对齐：
14,4 + 100,4
# 运算结果：
114,4
# 即 0.0114 / 114e-4
1.3 复数 Complex
z = a + bj
# 获取复数 z 的实部
z.real
# 获取复数z的虚部
z.imag
二、数值操作、函数
-
算数运算符(7个)：+、-、*、/、//、%、**。
-
比较运算符(6个)：==、!=、>、<、>=、<=。
-
赋值运算符(9个)：=、+=、-=、*=、/=、%=、**=、//=、:=。
-
位运算符(6个)：&、|、^、~、<<、>>。
-
逻辑运算符(3个)：and、or、not。
-
成员运算符(2个)：in、not in。
-
身份运算符(2个)：is、is not。
-
运算符优先级。
-
数据类型混合运算。
-
数值运算常用函数(8个)：abs()、divmod()、pow()、round()、max()、min()、hex()、oct()。
-
random常用随机函数(7个)：random.random()、random.uniform()、random.randint()、random.randrange()、random.sample()、random.shuffle()、random.choice()。
-
数据类型转换函数(3个)：int、float()、complex()。
-
数值运算方法介绍。
2.1 算术运算符(7个)
| 语法 |
描述 |
| x + y |
加。 |
| x - y |
减；负数。例：x - y ；-0.1。 |
| x * y |
乘。 |
| x / y |
除，x 除以 y 。 |
| x // y |
取整除，向下取接近商的整数。()<br />例：9//2 结果是4；-9//2 结果是-5。 |
| x % y |
取模，数学中的取余。 |
| x ** y |
幂，x 的 y 次幂，也可以使用pow()进行幂运算。 |
>>> 3 / 3
1.0
>>> 4 / 2
2.0
- 如果只需要整数结果，去除小数部分，可以使用运算符
//。
>>> 3 // 2
1
>>> 4 // 2
2
- 得到的数字虽然是整除结果，但不一定是整数类型的数字。
>>> 3.0 // 3
1.0
>>> 4 // 2.0
2.0
- 取整除，向下取接近商的整数（即向负无穷方向取最接近精确值的整数）。
>>> 7 // -4
-2
# 7/-4 = -1.75
>>> 7 // 4
1
# 7/4 = 1.75
>>> 9 % 3
0
>>> -22 % 10
8
>>> 3 % 2
1
# 9 % 3 取模运算解析
9 // 3 = 3
9 - 3 * 3 = 0
# -22 % 10 取模运算解析
-22 // 10 = -3
-22 + 3 * 10 = 8
# 3 % 2 取模运算解析
3 // 2 = 1
3 - 2 * 1 = 1
2.2 比较运算符(6个)
| 语法 |
描述 |
| x == y |
等于；x、y是否相等。 |
| x != y |
不等于；x、y是否不相等。 |
| x > y |
大于；x 是否大于y。 |
| x < y |
小于；x 是否小于y。 |
| x >= y |
大于等于；x 是否大于等于y。 |
| x <= y |
小于等于；x 是否小于等于y。 |
>>> 1 == 1
True
>>> 1 != 1
False
>>> 1 > 1
False
>>> 1 < 1
False
>>> 1 >= 1
True
>>> 1 <= 1
True
2.3 赋值运算符(9个)
| 语法 |
描述 |
| 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 之整数商赋值给 x 。 |
| x := y |
Python 3.8海象运算符：赋值表达式；可在表达式内部为变量赋值。 |
- x := y 海象运算，可在表达式内部为变量赋值。
# 这是Python 3.8前的表达式
while True:
p = input("Enter the password: ")
if p == "youpassword":
break
# 这是用海象运算符的表达式
while (p := input("Enter the password: ")) != "youpassword":
continue
2.4 位运算符(6个)
- 不同进制之间比较，程序先将非二进制的整数转换为二进制。
- 二进制顾名思义，满2进1，没有2、3、4、5...9这些整数，也没有浮点数。
- 二进制以0b开头，后面都是0和1，0 和 1 通常在程序语言也表示为
False和True。
-
&与操作
- 与操作相当于生活中说的“并且”：两个条件都同时成立的情况下“逻辑与”的运算结果才为“真”。
- 按位与操作两个长度相同的二进制数，两个相应的二进位都为1，该位的结果值才为1，否则为0。
| 语法 |
描述 |
| x & y |
与，x 与 y 的与操作(处理)。 |
>>> bin(0b1100 & 0b1011)
0b1000
# 从0b后开始逐位与对比，1和1为True，返回1，0和1为False，返回0。
>>>'w'&'c'
'wc'
-
|或操作
- 条件都满足或其中一个满足返回
True，即：1；都不满足返回False，即：0。
| 语法 |
描述 |
| x | y |
或，x 与 y 的或操作(处理)。 |
- 按位或处理两个长度相同的二进制数，逐位或操作，两个相应的二进位都为
1或有一个为1，该位返回值为1，两个相应位值都为0，返回0。
>>> bin(0b1100 | 0b1011)
'0b1111'
-
~非操作
- 按位取反操作，对数据的每个二进制位取反,即把1变为0,把0变为1。
>>> bin(~0b1111)
'-0b10000'
-
^异或操作
- 异或操作和或操作逻辑的运算条件不同。
- 异或运算法则是：
0 + 0 = 0，1 + 1 = 0，1 + 0 = 1，0 + 1 = 1，所以异或常被认作不进位加法。
| 语法 |
描述 |
| x ^ y |
异或，x 与 y 的异或操作。 |
>>> bin(1)
>>> bin(2)
>>> bin(1 ^ 2)
'0b1'
'0b10'
'0b11'
>>> bin(2)
>>> bin(2 + 2)
'0b0'
-
<<左移、>>右移
- 左移和右移比较简单，左移时最低位补0，右移时最高位补0的移位操作，按照n计算补0的数量。
| 语法 |
描述 |
| x << n |
左移，将 x 按n位左移。 |
| x >> n |
右移，将 x 按n位右移。 |
>>> bin(0b11 << 1)
'0b110'
>>> bin(0b11 >> 1)
'0b1'
2.5 逻辑运算符(3个)
- 逻辑运算也是布尔运算，通常用来测试真假值(
TrueorFalse)。最常见到的逻辑运算就是循环的处理，用来判断是否该离开循环或继续执行循环内的指令。
| 语法 |
描述 |
| x and y |
逻辑与运算符；规则：有假取假False，全真取真True。 |
>>> True and False
False
>>> True and True
True
>>> False and False
False
| 语法 |
描述 |
| x or y |
逻辑或运算符；规则：有真取真True，全假取假False。 |
>>> True or False
True
>>> False or False
False
>>> True and True
True
| 语法 |
描述 |
| not x |
逻辑非运算符；规则：是真True返回假False，是假False返回真True。 |
>>> not True
False
>>> not False
True
2.6 成员运算符(2个)
| 语法 |
描述 |
| x in y |
如果在指定的序列中找到值返回True，否则返回False。 |
| x not in y |
如果在指定的序列中没找到值返回True，否则返回False。 |
>>> 'a' in 'abc'
True
>>> 'a' not in 'abc'
False
成员运算可以用于字符串、列表、元组、字典、集合。
2.7 身份运算符(2个)
| 语法 |
描述 |
| is |
判断两个标识符是不是引用自一个对象；本质上是判断两个对象的内存地址是否相同。 |
| is not |
判断两个标识符是不是引用自不同对象；本质上是判断两个对象的内存地址是否不相同。 |
-
==比较运算判断两个对象的值是否相等，is比较两个对象的内存地址，示例中，列表的值虽然相等，但由于是不同赋值语句中创建的，所以内存（id）地址不同。
>>> x = [4,5,6]
>>> y = [4,5,6]
>>> print(x == y)
>>> print(x is y)
>>> print(id(x),id(y))
True
False
2289209948424 2289209955272
-
Python内存管理问题：设计者认为[-5:257]这个范围的整数，是经常被使用的对象，因此，没有必要经常性创建与释放，所以[-5:257]这个范围的整数被建立在一个内存池，当你使用这个范围的整数值时，会从内存提取，并没有重新创建。
>>> x = 256
>>> x = 256
>>> x is y
True
>>> a = 257
>>> b = 257
>>> a is b
False
2.8 运算符优先级
| 序号 |
运算符 |
描述 |
| 1 |
** |
幂运算，指数最高。 |
| 2 |
~、+、-
|
取反运算，一元加号和减号(一元加减号通常所正负值)。 |
| 3 |
*、/、%、//
|
乘、除、求余和取整除运算。 |
| 4 |
+、-
|
加法、减法。 |
| 5 |
<<、>>
|
左移、右移运算符。 |
| 6 |
& |
与运算。 |
| 7 |
^、|
|
异或、或运算。 |
| 8 |
<=、<、>、>=
|
小于等于、小于、大于、大于等于。 |
| 9 |
==、!=
|
等于、不等于运算符。 |
| 10 |
=、%=、/=、//=、-=、+=、*=、**=
|
赋值运算符。 |
| 11 |
is、is not
|
身份运算符。 |
| 12 |
in、not in
|
成员运算符。 |
| 13 |
not、and、or
|
逻辑运算符。 |
2.9 数据类型混合运算
-
三种类型逐渐 “扩展” 或 “变宽” 的关系：
整数 int -> 浮点数 float -> 复数 complex
# 整数 + 浮点数 = 浮点数
>>> 123 + 4.0
127.0
2.10 数值运算常用函数(8个)
| 语法 |
参数 |
返回值 |
| abs(x) |
x：数值变量，可以是整数、浮点数、复数。 |
函数返回x(数字)的绝对值，如果是复数，返回它的大小。 |
>>> print(abs(-39))
39
>>> print(abs(99.70))
99.7
| 语法 |
参数 |
返回值 |
| divmod( x , y ) |
Python2.3前x和y不能是非复数的数字。 |
返回(x//y,x%y)的(商,余)。 |
>>> divmod(9,4)
(2, 1)
>>> divmod(-9,4)
(-3, 3)
>>> divmod(9,3.5)
(2.0, 2.0)
| 语法 |
参数 |
返回值 |
| pow(x, y[, z]) |
x、y、z都是数值表达式。 |
幂余，返回(x**y)%z，[,z]省略返回x、y的幂。 |
>>> pow(8,2)
64
>>> pow(8,2,3)
1
| 语法 |
参数 |
返回值 |
| round(x[, n]) |
按照n设定，用四舍五入保留小数点位数，n默认为0。 |
返回浮点数x的四舍五入值。 |
>>> round(4.5)
4
>>> round(4.5,2)
4.5
>>> round(-4.5432,2)
-4.54
| 语法 |
参数 |
返回值 |
| max(x,y,z,...,n) |
x、y、z是数值表达式，n是序列。 |
返回最大值，返回x,y,z,n中的最大值，n序列不限。 |
>>> max(1,2,4,5,89)
89
| 语法 |
参数 |
返回值 |
| min(x,y,z,...,n) |
x、y、z是数值表达式，n是序列。 |
返回最小值，返回x,y,z,n中的最小值，n序列不限。 |
>>> min(1,2,4,5,89)
1
| 语法 |
参数 |
返回值 |
| hex(x) |
x必须是整数 |
返回x的16进制数。 |
>>> hex(3)
'0x3'
| 语法 |
参数 |
返回值 |
| oct(x) |
x必须是整数 |
返回x的8进制数。 |
>>> oct(3)
'0o3'
2.11 random常用随机函数(7个)
- 使用随机数 random 函数需要先
import random。
| 语法 |
参数 |
返回值 |
| random.random() |
不需要设置参数 |
随机生成0和1之间的浮点数float。 |
>>> import random
>>> x = random.random()
>>> print(x)
0.4460552344223293
| 语法 |
参数 |
返回值 |
| random.uniform(x,y) |
x参数下限，含x，y参数上限，不含y；可以是浮点数。 |
随机生成一个浮点数a，如果x<y，取x <= a <= y的值；如果x>y，取x >= a >= y的值。 |
>>> import random
>>> random.uniform(7,20)
15.108212490098165
>>> random.uniform(7,20)
10.232521349922035
| 语法 |
参数 |
返回值 |
| random.randint(x,y) |
x参数下限，含x，y参数上限，含y；x<y；x、y必须都是整数int。 |
随机生成一个整数a，取x <= a <=y的值。 |
>>> import random
>>> random.randint(9,11)
11
>>> random.randint(9,11)
9
| 语法 |
参数 |
返回值 |
| random.randrange(x,y[,z]) |
x参数下限，含x，y参数上限，不含y，z步长；x<y，x、y、z必须都是整数int。 |
随机生成一个整数a，取x <= a < y。 |
>>> import random
>>> random.randrange(8,10)
9
>>>random.randrange(8,10)
8
- 注意，x、y设置的范围比较短，步长可能失效，或每次只能输出一个固定数值。
>>> import random
>>> random.randrange(8,10,2)
8
>>> random.randrange(8,10,1)
9
| 语法 |
参数 |
返回值 |
| random.sample(seq,y) |
seq:sequence泛指一系列的有序类型(字符串、列表、字典)；y必须是整数，y < x的字符长。 |
从seq序列中随机提取y数量的字符，以列表list形式返回。注意：sample不会改变原有序列。 |
>>> import random
>>> random.sample('abc',2)
['b','a']
| 语法 |
参数 |
返回值 |
| random.shuffle(list) |
list列表 |
无返回值(None)，需要配合已赋值的变量操作，变量的值必须是列表list。 |
>>> import random
>>> list1 = [1,3,5,7,9]
>>> random.shuffle(list1)
>>> print(list1)
[5, 7, 1, 9, 3]
| 语法 |
参数 |
返回值 |
| random.choice(seq) |
seq:sequence表示泛指一系列的有序类型(字符串、列表、字典)。 |
随机返回x中的一个的元素，当seq为空序列直接报错。 |
>>> import random
>>> xc = [1,'abc',9,30,29]
>>> random.choice(xc)
30
>>> random.choice(xc)
'abc'
2.12 数据类型转换函数(3个)
| 语法 |
描述 |
| int(x) |
将x变成整数，舍弃小数部分。 |
| float(x) |
将x变成浮点数，增加小数部分。 |
| complex(x) |
将x变成复数，增加虚数部分。 |
| complex(x,y) |
将x和y转换到一个复数，实数为x，虚数为y。x、y是数字表达式 |
2.13 数值运算方法介绍
- Python 解释器处理所有数据类型都是以面向对象 - 类（
class）的形式体现。
- 类中的功能用方法来体现。
- 方法本身可以对整数、浮点数、复数等数值进行操作。
三、字符串类型 String
- 字符串是字符的有序集合,，在
Python中属于最常用的数据类型。
- 字符串介绍
- 访问字符串：字符串索引、字符串切片。
- 常用转义字符(14个)：
\续行符、\\反斜杠符号、\'单引号、\"双引号、\b退格、\000空、\n换行、\v纵向制表符、\t横向制表符、\r回车、\f换页、\yyy八进制数、\xyy十六进制数。
- 原始字符串：
r'字符串'。
3.1 字符串介绍
- 由成对单/双引号或成对的三个单/双引号组成，内部有0个或多个有序字符序列
sequence。
'abc'、'123'、'Hello World！'、'这是一个字符串'
"abc"、"123"、"Hello World！"、"这是一个字符串"
'''
这是一个多行字符串
'''
"""
这个是一个多行字符串
"""
3.2 访问字符串
- 访问字符串需要根据字符串序号体系，使用
[]对字符串进行索引或切片。
3.2.1 字符串索引
| 字符串： |
O |
一 |
二 |
三 |
四 |
五 |
六 |
七 |
八 |
九 |
十 |
|
正向递增序号： |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
| 反向递增序号： |
-11 |
-10 |
-9 |
-8 |
-7 |
-6 |
-5 |
-4 |
-3 |
-2 |
-1 |
>>> 'O一二三四五六七八九十'[2]
'二'
>>> 'O一二三四五六七八九十'[-2]
'九'
3.2.2 字符串切片
- 返回字符串中的字符子串：'字符串'[M:N]（不含N）
>>> 'O一二三四五六七八九十'[1:5]
'一二三四'
>>> 'O一二三四五六七八九十'[-5:-1]
'六七八九'
- '字符串'[M:N] 参数M值缺失默认序号0，N值缺失默认到最后一个序号
# M值缺失
>>> 'O一二三四五六七八九十'[:3]
'O一二'
# N值缺失
>>> 'O一二三四五六七八九十'[3:]
'三四五六七八九十'
- 切片高级用法：'字符串'[M:N:k]，k代表步长参数。
>>> 'O一二三四五六七八九十'[1:8:2]
'一三五七'
>>> 'O一二三四五六七八九十'[2::2]
'二四六八十'
# 反向切片（反向递减）
>>> 'O一二三四五六七八九十'[::-1]
'十九八七六五四三二一O'
3.3 常用转义字符(14个)
- 转义字符也称字符实体，组合表达函数不可操作的含义。
-
\代码的续行符。
>>> print('第一行'\
... '第二行'\
... '第三行')
第一行第二行第三行
-
\\反斜杠符号。
>>> print('\\')
\
-
\'单引号。
>>> print('\'')
'
-
\"双引号。
>>> print('\"')
"
-
\b退格：将当前位置移到前一列。
>>> print('Hello \bWorld')
HelloWorld
-
\000空：空字符NUL。
>>> print('hello\000world')
hello world
-
\n换行：将当前位置移到下一行开头。
>>> print('Hello\nWorld')
Hello
World
-
\v纵向制表符：垂直制表VT。
>>> print('Hello\vWorld')
Hello
World
-
\t横向制表符：水平制表HT （相当于Tab键）。
>>> print('Hello\tWorld!')
Hello World!
-
\r回车：将当前位置移到本行开头。
>>> print('Hello\rWorld!')
World!
-
\f换页：将当前位置移到下页开头。
>>> print("Hello \f World!")
Hello
World!
-
\yyy八进制数，每个y各自代表0 ~ 7内的字符。
>>> print("\110\145\154\154\157\40\127\157\162\154\144\41")
Hello World!
-
\xyy十六进制数，以\x开头，yy代表十六进制字符(0 ~ 9,a ~ f)。
>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")
Hello World!
-
\other其它的字符以普通格式输出
3.4 原始字符串
-
Python中比较特殊的字符串，以字母r开始，不区分大小写。
- 原始字符串中，转义字符
\ 不转义。
- 原始字符串是为正则表达式设计，可以用来表示Windows系统路径，但路径以
\结尾将报错。
>>> print( r'\n' )
\n
>>> print(r'c:\python')
c:\python
四、字符串操作、函数与方法
- 字符串运算操作符(4个)：
+、*、in、not in。
- 字符串格式化：
- 格式化操作符(13个)：
%c、%o、%x、%X、%d 、%f、%e、%E、%g、%G、%s 、%r、%R。
- 格式化操作辅助指令(4个)：
m.n、-、#、0。
-
.format()映射。
- 格式化字符串常量：
f-string。
- 字符串操作函数：
4.1 字符串运算操作符(4个)
>>> print('Hello' + ' ' + 'World' + '!')
Hello World!
| 语法 |
描述 |
| 'x' * n / n * 'x' |
复制n次字符串x |
>>> print('a' * 6)
aaaaaa
>>> print(-1 * 'a')
| 语法 |
描述 |
| 'x' in 'y' |
成员运算符；判断y是否包含x，成立返回True，否则返回False。 |
>>> a = 'hello'
>>> print('h' in a)
True
| 语法 |
描述 |
| 'x' not in 'y' |
成员运算符；判断y是否不包含x，成立返回True，否则返回False。 |
>>> a = 'hello'
>>> print('h' not in a)
False
4.2 字符串格式化
- 字符串格式化与
C语言中的sprintf函数一样用法：
- 主要功能是把格式化后的数据写入某个字符串中，也称为转换说明符。
- 由于该用法与
str.format()近似，也可以称为填坑操作。
- 转换说明符是一个占位符，会被后面表达式(变量、常量、数字、字符串、加减乘除等)的值代替。
- 转换说明符与待输出的数据位置必须一一对应，数据类型必须与格式符相匹配。
4.2.1 格式化操作符(13个)
>>> print('%c' % 98)
b
>>> print('%d 的八进制是 %o' % (99,99))
99 的八进制是 143
>>> print('%d 的十六进制是 %x' % (99,99))
99 的十六进制是 63
>>> print('0减去3的值是%d' % (0-3))
0减去3的值是-3
| 符号 |
描述 |
%f |
转换成十进制浮点数，可指定小数点后的精度。(默认精确到小数点后 6 位，超出四舍五入) |
>>> print('0减去3的值是%f' % (-3))
0减去3的值是-3.000000
| 符号 |
描述 |
%e、%E
|
转换成科学计算法的浮点数。 |
>>> print('9.8万的科学计数法是%e' % 98000)
9.8万的科学计数法是9.800000e+04
| 符号 |
描述 |
%g、%G
|
智能选择使用%f和%e的格式。 |
>>> print('Python,这个数字你怎么显示？%g' % 3.1415926)
Python,这个数字你怎么显示？3.14159
>>> print('Python,这个数字你怎么显示？%g' % 31415926)
Python,这个数字你怎么显示？3.14159e+07
| 符号 |
描述 |
%s |
使用str()转换为字符串(str()将对象转化为适于人阅读的形式)。 |
>>> name = '小明'
>>> age = 18
>>> addr = '深圳'
>>> print('%s今年%d岁，常年居住在%s。'% (name,age,addr))
小明今年18岁，常年居住在深圳。
| 符号 |
描述 |
%r、%R
|
使用repr()转换为字符串(repr()将对象转化为供解释器读取的形式。)。 |
>>> a = repr(10/7.0)
>>> print('10除以7的值是多少？%r' % a)
10除以7的值是多少？'1.4285714285714286'
4.2.2 格式化操作辅助指令(4个)
| 符号 |
描述 |
| m.n |
m代表显示的最小总宽度(小数点也算一位)；总长度大于m，按原样式输出。<br />n代表小数点后位数。 |
>>> a = 3.141592653
>>> print('0123456789 = 位数参考序列')
>>> print('%5.3f' % a)
>>> print('%6.3f' % a)
>>> print('%6.4e' % a)
>>> print('%7.4e' % a)
0123456789 = 位数参考序列
3.142
3.142
3.1416e+00
3.1416e+00
>>> a = 3.141592653
>>> print('0123456789 = 位数参考序列')
>>> print('%.3f' % a)
>>> print('%.4e' % a)
0123456789 = 位数参考序列
3.142
3.1416e+00
>>> a = 3.141592653
>>> print('0123456789 = 位数参考序列')
>>> print('%7.4f' % a)
>>> print('%7.f' % a)
>>> print('%.4e' % a)
0123456789 = 位数参考序列
3.1416
3
3.1416e+00
>>> a = 3.141592653
>>> print('0123456789 = 位数参考序列')
>>> print('%7.4f^' % a)
>>> print('%-7.4f^' % a)
0123456789 = 位数参考序列
3.1416^
3.1416 ^
| 符号 |
描述 |
# |
增加进制符号(八进制前面加0o，十六进制前加0x)。 |
>>> print('%x' % 678)
>>> print('%#x' % 678)
>>> print('%o' % 567)
>>> print('%#o' % 567)
2a6
0x2a6
1067
0o1067
>>> print('0123456789 = 位数参考序列')
>>> print('%6d' % 3.1)
>>> print('%06d' % 3.1)
>>> print('%06f' % 3.1)
>>> print('%06.f' % 3.1)
>>> print('%06.2f' % 3.1)
>>> print('%06s' % 3.1)
0123456789 = 位数参考序列
3
000003
3.100000
000003
003.10
3.1
4.2.3 .format()映射
-
.format()映射也是字符串格式化处理的一种方法。
-
.format()格式化语法是通过 {}和 : 来代替以前的 %。
>>> a = "{}:计算机{}的网速是{}MB".format("2020-1-1","D",15)
>>> print(a)
2020-1-1:计算机D的网速是15MB
>>> a = "{1}:计算机{0}的网速是{2}MB".format("2020-1-1","D",15)
>>> print(a)
D:计算机2020-1-1的网速是15MB
- 槽格式化配置1：有宽度，才有对齐的发生，长度不够，就有了填充的问题。
# 宽度：'{0:19}'表示从字符串序号0开始，总长19，不足长度默认空格填充。
>>> a = '{0:19}'.format('Hello')
>>> print(a)
'Hello '
-
对齐
- 左对齐
<。
>>> a = '{0:=<19}'.format('Hello')
>>> print(a)
'Hello=============='
- 居中
^。
>>> a = '{0:*^19}'.format('Hello')
>>> print(a)
'*******Hello*******'
- 右对齐
>。
>>> a = '{0:->19}'.format('Hello')
>>> print(a)
'--------------Hello'
-
槽格式化配置2：千分位,、数值.精度、类型type。
- 千分位
,:对输出的数值进行千位分割。
>>> a = '{0:,}'.format(19999)
>>> print(a)
'19,999'
- 数值
.精度。
>>> a = '{0:,.3f}'.format(1999.456789)
>>> print(a)
'1,999.457'
- 类型
type：变量以指定类型输出。
- 整型：
b(二进制)、c(chr字符)、d(十进制)、o(八进制)、x(十六进制)。
- 浮点型：
e(科学计数法)、f(浮点数常规)、%(百分比)。
>>> a = '{0:b},{0:c},{0:d},{0:o},{0:x}'.format(365)
>>> print(a)
'101101101,ŭ,365,555,16d'
>>> b = '{0:e},{0:f},{0:%}'.format(3.1415926)
>>> print(b)
'3.141593e+00,3.141593,314.159260%'
4.2.4 格式化字符串常量
-
Python 3.6之后的版本加入的，主要目的是使格式化字符串的操作更加简便。
-
f-string格式化字符串以f开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，替换变量或表达式计算后的值。
-
f-string不逊色于传统的%-formatting语句和str.format函数，性能又优于二者，使用简洁方便。
>>> str = {'name':'小明', 'age': 18, 'addr':'深圳'}
>>> print(f"{str['name']}今年{str['age']}岁，常年居住在{str['addr']}。")
小明今年18岁，常年居住在深圳。
-
f-string的{}可以填入函数或表达式，Python会将结果返回赋值给字符串内
name = 'xiaoming'
>>> print(f'His name is {name.capitalize()}.')
His name is Xiaoming.
>>> print()
-
Python 3.8之后的版本可以使用=来拼接运算表达式与结果：
# Python 3.6
>>> x = 1
>>> print(f'{x+1}')
2
# Python 3.8
>>> x = 1
>>> print(f'{x+1=}')
x+1=2
4.3 字符串操作函数与方法(32个)
| 语法 |
参数 |
返回值 |
| len(seq) |
seq:sequence泛指一系列的有序类型(字符串、列表、字典)。 |
返回sequence长度或项目个数。 |
>>> len('123')
3
| 语法 |
参数 |
返回值 |
| str(object=' ') |
seq:sequence泛指一系列的有序类型(字符串、列表、字典)。 |
将seq转换成适于人阅读的形式。 |
>>> str('123')
'123'
| 语法 |
参数 |
返回值 |
| chr(i) |
i必须是整数。 |
返回Character字符。 |
>>> chr(0)
'\x00'
| 语法 |
参数 |
返回值 |
| ord(c) |
c是Character字符。 |
返回对应的Unicode编码。 |
>>> ord('!')
33
| 语法 |
参数 |
返回值 |
| str.find(str, beg=0, end=len(string)) |
str需要查找的字符串；beg是索引左边开头，默认为0；end结束索引位置，默认为字符串的长度。 |
如果包含str值，返回str索引值，否则返回-1。 |
>>> x = 'banana'
>>> print(x.find('c'))
-1
>>> print(x.find('a'))
1
>>> print(x.find('na'))
2
| 语法 |
参数 |
返回值 |
| str.rfind(str, beg=0 end=len(string)) |
str需要查找的字符串；beg是索引右边开头，默认为0；end结束索引位置，默认为字符串的长度。 |
如果包含str值，返回str索引值，否则返回-1 |
>>> x = 'banana'
>>> print(x.rfind('a'))
5
>>> print(x.rfind('na'))
4
| 语法 |
参数 |
返回值 |
| str.index(str, beg=0, end=len(string)) |
str需要查找的字符串；beg是索引左边开头，默认为0；end结束索引位置，默认为字符串的长度。 |
如果包含str值，返回str索引值，否则程序报错。 |
>>> x = 'banana'
>>> print(x.index('a'))
1
>>> print(x.index('c'))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> x = 'banana'
>>> count = x.count('c')
>>> if count > 0:
... y = x.index('a')
... print(y)
...
| 语法 |
参数 |
返回值 |
| str.rindex(str, beg=0 end=len(string)) |
str需要查找的字符串；beg是索引右边开头，默认为0；end结束索引位置，默认为字符串的长度。 |
如果包含str值，返回str索引值，否则程序报错。 |
>>> x = 'banana'
>>> print(x.rindex('a'))
5
| 语法 |
参数 |
返回值 |
| str.count(sub, start= 0,end=len(string)) |
sub需要搜索对象字符，start是str索引开头，默认为0；end结束索引位置，默认str字符串最后一个位置。 |
返回搜索对象字符在str字符串出现的次数。 |
>>> b = 'cccdfghc'
>>> b.count('c')
4
| 语法 |
参数 |
返回值 |
| str.replace(old, new[, max]) |
new字符串替换old字符串子串；[,max]可选参数，替换次数不超过max次。 |
返回替换之后的新字符串；如果指定了max参数，替换次数不超过max次。 |
# replace 基本操作
>>> a = 'abcdefg'
>>> b = a.replace('a','x')
>>> print(b)
xbcdefg
# replace 高级操作
>>> a = 'acabadaf'
>>> b = a.replace('a','x',2)
>>> c = a.replace('a','x')
>>> print(a)
>>> print(b)
>>> print(c)
acabadaf
xcxbadaf
xcxbxdxf
| 语法 |
参数 |
返回值 |
| str.split(str="", num=string.count(str)) |
指定分隔符str=""；string.count(str)返回子字符在字符串的次数赋值给num；num分割次数可更改。 |
将分割后的字符串以列表形式返回。 |
# split 基本操作
>>> x = 'banana'
>>> b = x.split('a')
>>> print(b)
['b', 'n', 'n', '']
# split 高级操作
>>> c = x.split('a',2)
>>> print(c)
['b', 'n', 'na']
| 语法 |
参数 |
返回值 |
| str.capitalize() |
无 |
改变一个字符串样式：首字符转换成大写，其余字符转换成小写；首字符非字母，第一个字母不会转换成大写，后面继续转换成小写。 |
>>> x = 'banana'
>>> y = x.capitalize()
>>> print(y)
Banana
>>> a = '1BaNaNa'
>>> b = a.capitalize()
>>> print(b)
1banana
| 语法 |
参数 |
返回值 |
| str.title() |
无。 |
返回"标题化"的字符串：所有单词的首字母都转化为大写。 |
>>> x = 'i love you haha.'
>>> y = x.title()
>>> print(y)
I Love You Haha.
| 语法 |
参数 |
返回值 |
| str.startswith(substr, beg=0,end=len(string)) |
substr指定检测子字符串；beg可选参数，用于设置检测起始位置；end可选参数，用于设置检测结束位置。 |
检查字符串是否是以substr子字符串开头，成立返回True，否则返回False。 |
>>> x = 'banana'
>>> y = x.startswith('b')
>>> print(y)
>>> z = x.startswith('a',-1)
# 字符串反向索引位置
>>> print(z)
True
True
| 语法 |
参数 |
返回值 |
| str.endswith(suffix[, start[, end]]) |
suffix该参数可以是一个字符串或元素；start字符串开始位置；end字符串结束位置(start、end可选)。 |
检查str是否以suffix后缀结尾，成立返回True，否则返回False。 |
>>> x = 'banana'
>>> y = x.endswith('a')
>>> print(y)
>>> z = x.endswith('b',-1)
# 注意该用法是以后缀为前提！
>>> print(z)
True
True
| 语法 |
参数 |
返回值 |
| str.lower() |
无 |
将字符串改为全部小写字母的形式。 |
>>> x = 'BaNaNa'
>>> y = x.lower()
>>> print(y)
banana
| 语法 |
参数 |
返回值 |
| str.upper() |
无 |
将字符串改为全部大写字母的形式。 |
>>> x = 'banana'
>>> y = x.upper()
>>> print(y)
BANANA
| 语法 |
参数 |
返回值 |
| str.ljust(width[, fillchar]) |
width指定字符串总长度位数；<br />fillchar填充字符，默认值：空格。 |
向左对齐，不够指定长度位数用fillchar填充。 |
>>> x = 'Hello World'
>>> y = x.ljust(20,'!')
>>> print(y)
Hello World!!!!!!!!!
| 语法 |
参数 |
返回值 |
| str.rjust(width[, fillchar]) |
width指定字符串总长度位数；<br />fillchar填充字符，默认值：空格。 |
向右对齐，不够指定长度位数用fillchar填充。 |
>>> x = 'Hello World'
>>> y = x.rjust(20,'!')
>>> print(y)
!!!!!!!!!Hello World
| 语法 |
参数 |
返回值 |
| str.center(width[, fillchar]) |
width指定字符串总长度位数；<br />fillchar填充字符，默认值：空格。 |
居中，不够指定长度位数用fillchar填充。 |
>>> x = 'Hello World'
>>> y = x.center(20)
>>> print(y)
>>> z = x.center(20,'~')
>>> print(z)
Hello World
~~~~Hello World~~~~~
| 语法 |
参数 |
返回值 |
| str.lstrip([chars]) |
chars指定删除的符号，默认空值。 |
删除左边空值或指定值。 |
>>> x = 'Hello World'
>>> z = x.center(20,'~')
>>> y = z.lstrip('~')
>>> print(z)
>>> print(y)
~~~~Hello World~~~~~
Hello World~~~~~
| 语法 |
参数 |
返回值 |
| str.rstrip([chars]) |
chars指定删除的符号，默认空值。 |
删除右边空值或指定值。 |
>>> x = 'Hello World'
>>> z = x.center(20,'~')
>>> q = z.rstrip('~')
>>> print(z)
>>> print(q)
~~~~Hello World~~~~~
~~~~Hello World
| 语法 |
参数 |
返回值 |
| str.strip([chars]); |
chars指定删除的符号，默认空值。 |
删除左右两边空值或指定值。 |
>>> x = 'Hello World'
>>> z = x.center(20,'~')
>>> a = z.strip('~')
>>> print(a)
Hello World
| 语法 |
参数 |
返回值 |
| str.partition(str) |
str指定的分隔符对字符串进行分割。 |
把字符串从左到右分割为三个部分：第一部分分隔符左边部分；第二部分分隔符；第三部分分隔符右边部分。 |
>>> a = "acbdf"
>>> b = a.partition("a")
>>> print(b)
('', 'a', 'cbdf')
| 语法 |
参数 |
返回值 |
| str.rpartition(str) |
str指定的分隔符对字符串进行分割。 |
把字符串从右到左分割为三个部分：第一部分分隔符左边部分；第二部分分隔符；第三部分分隔符右边部分。 |
>>> a = "acbdf"
>>> b = a.rpartition("a")
>>> print(b)
('', 'a', 'cbdf')
| 语法 |
参数 |
返回值 |
| str.splitlines([keepends]) |
keepends默认False不保留换行符(\r、\r\n、\n)，如果设置为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']
| 语法 |
参数 |
返回值 |
| str.isalpha() |
无 |
判断字符串是否只由字母或文字组成，成立返回True，否则返回False。 |
>>> x = 'abcdefG'
>>> x.isalpha()
True
>>> y = 'abcdef G'
>>> y.isalpha()
False
| 语法 |
参数 |
返回值 |
| str.isdigit() |
无 |
判断字符串是否只由数字组成，成立返回True，否则返回False。 |
>>> x = '4567abcd'
>>> x.isdigit()
False
>>> y = '4567'
>>> y.isdigit()
True
| 语法 |
参数 |
返回值 |
| str.isalnum() |
无 |
判断字符串是否由字母、数字或字母数字混合组成，成立返回True，否则返回False。 |
>>> x = '4567abcd'
>>> x.isalnum()
True
| 语法 |
参数 |
返回值 |
| str.isspace() |
无 |
判断字符串是只由空格组成，成立返回True，否则返回False。 |
>>> x = '4567ab cd'
>>> x.isspace()
False
| 语法 |
参数 |
返回值 |
| str.join(sequence) |
sequence -- 要连接的元素序列。 |
指定字符将元素序列连接生成新的字符串。 |
>>> x = ''
>>> y = '+'
>>> seq = ('a','b','c','d','e')
>>> print(x.join(seq))
>>> print(y.join(seq))
abcde
a+b+c+d+e
网友评论