笔记带有个人侧重点,不追求面面俱到。
出处: 菜鸟教程 - Python3 基本数据类型
Python 3 的六个标准数据类型中:
此外还有一些高级的数据类型,如: 字节数组类型(bytes)。
注意: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
Python 使用反斜杠 \
转义特殊字符,如果你不想让反斜杠发生转义,可以在字符串前面添加一个 r
,表示原始字符串:
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
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"
list1 = [x for x in range(9)]
print(list1[-1::-2]) # [9]
print(list1[-1:-4]) # []
虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:
tup1 = () # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号
注意: 创建一个空集合必须用
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'}
键(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}
什么是 bytes 类型:
怎么创建 bytes 类型:
bytes()
函数将其他类型的对象转换为 bytes 类型。x = bytes("hello", encoding="utf-8")
注意: bytes 类型中的元素是整数值,因此在进行比较操作时需要使用相应的整数值。
x = b"hello"
if x[0] == ord("h"):
print("The first element is 'h'")
出处:菜鸟教程 - Python3 数据类型转换
Python 数据类型转换可以分为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) | 将一个整数转换为一个八进制字符串 |
语法:
class int(x, base=10)
参数:
返回值:
返回整型数据。
实例:
>>>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"))
语法:
repr(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
语法:
class frozenset([iterable])
参数:
返回值:
返回新的 frozenset 对象,如果不提供任何参数,默认会生成空集合。
为什么需要冻结的集合(即不可变的集合)呢?因为在集合的关系中,有集合的中的元素是另一个集合的情况,但是普通集合(set)本身是可变的,那么它的实例就不能放在另一个集合中(set中的元素必须是不可变类型)。
所以,frozenset提供了不可变的集合的功能,当集合不可变时,它就满足了作为集合中的元素的要求,就可以放在另一个集合中了。
出处:菜鸟教程 - Python3 运算符
Python 语言支持以下类型的运算符:
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
#!/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)
运算符 | 逻辑表达式 | 描述 |
---|---|---|
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
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
指向了新的内存地址,而不是内存地址中的值改变了。
以下表格列出了从最高到最低优先级的所有运算符, 相同单元格内的运算符具有相同优先级。 运算符均指二元运算,除非特别指出。 相同单元格内的运算符从左至右分组(除了幂运算是从右至左分组):
运算符 | 描述 |
---|---|
(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
高。
出处:菜鸟教程 - Python3 数字(Number)
数据类型是不允许改变的,这就意味着如果改变数字数据类型的值,将重新分配内存空间。
注意:
//
得到的并不一定是整数类型的数,它与分母分子的数据类型有关系。
实例:
>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
描述:
abs() 函数返回数字的绝对值。
语法:
abs(x)
参数:
返回值:
函数返回 x(数字)的绝对值,如果参数是一个复数,则返回它的大小。
>>>v = Vecter(3, 4)
>>>abs(v)
5.0
fabs() 与 abs() 的区别:
abs()
是一个内置函数,而 fabs() 在 math 模块中定义的;fabs()
函数只适用于 float 和 integer 类型,而 abs() 也适用于复数;abs()
的返回值可以是整数也可以是浮点数,视输入而定,fabs()
的返回值总是浮点数。描述:
ceil()
函数返回一个大于或等于 x 的的最小整数。(向上取整)
语法:
import math
math.ceil(x)
参数:
返回值:
返回一个大于或等于 x 的的最小整数。
描述:
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
注意: Python 3 已废弃,使用 (x>y)-(x
描述:
floor() 返回数字的下舍整数,小于或等于 x。(向下取整)
语法:
import math
math.floor(x)
参数:
返回值:
返回小于或等于 x 的整数。
描述:
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'
描述:
modf() 方法返回 x 的整数部分与小数部分,两部分的数值符号与 x 相同,整数部分以浮点型表示。
语法:
import math
math.modf(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'>
描述:
pow() 方法返回 xy(x的y次方) 的值。
语法:
import math
math.pow(x, y)
pow(x, y[, z])
注意:
pow()
通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为 float。
参数:
返回值:
返回 xy(x的y次方) 的值。
描述:
round() 方法返回浮点数 x 的四舍五入值,准确的说保留值将保留到离上一位更近的一端(四舍六入)。精度要求高的,不建议使用该函数。
语法:
round( x [, n] )
参数:
返回值:
返回浮点数x的四舍五入值。
注意:
round()
保留值将保留到离上一位更近的一端(四舍六入)。如果距离两边一样远,会保留到偶数的一边。比如 round(0.5) 和 round(-0.5) 都会保留到 0,而 round(1.5) 会保留到 2。同时,受浮点数精度影响,结果不一定复合预期。
参考:python中关于round函数的小坑
描述:
choice() 方法返回一个列表,元组或字符串的随机项。
语法:
import random
random.choice(seq)
参数:
返回值:
返回随机项。
实例:
random.choice(range(100))
random.choice([1, 2, 3, 5, 9])
random.choice('Runoob')
描述:
randrange() 方法返回指定递增基数集合中的一个随机数,基数默认值为1。
语法:
import random
random.randrange ([start,] stop [,step])
参数:
返回值:
从给定的范围返回随机项。
实例:
random.randrange(1, 100, 2)
random.randrange(100)
描述:
shuffle() 方法将序列的所有元素随机排序。
语法:
import random
random.shuffle(lst)
参数:
返回值:
返回 None。
描述:
uniform() 方法将随机生成下一个实数,它在 [x,y] 范围内。
语法:
import random
random.uniform(x, y)
参数:
返回值:
返回一个浮点数 N,取值范围为如果 x 出处:菜鸟教程 - Python3 字符串 在需要在字符中使用特殊字符时,python 用反斜杠 实例: 一段有趣的代码: 在 Python 中,字符串格式化使用与 C 中 格式化操作符辅助指令: f-string 是 python3.6 之后版本添加的,称之为字面量格式化字符串,是新的格式化字符串的语法。 在 Python 3.8 的版本中可以使用 在Python2中,普通字符串是以8位ASCII码进行存储的,而Unicode字符串则存储为16位unicode字符串,这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。 在Python3中,所有的字符串都是Unicode字符串。 描述: capitalize() 将字符串的第一个字母变成大写,其他字母变小写。 语法: 描述: center() 方法返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。 语法: 参数: 返回值: 返回一个指定的宽度 width 居中的字符串,如果 width 小于字符串宽度直接返回字符串,否则使用 fillchar 去填充。 实例: 注意: 描述: count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。 语法: 参数: 返回值: 该方法返回子字符串在字符串中出现的次数。 实例: 注意: 已统计过的字符不重复统计。 描述: endswith() 方法用于判断字符串是否以指定后缀结尾,如果以指定后缀结尾返回 True,否则返回 False。可选参数 “start” 与 “end” 为检索字符串的开始与结束位置。 语法: 参数: 返回值: 如果字符串含有指定的后缀返回 True,否则返回 False。 注意: 判断范围为 [start, end) 。 描述: expandtabs() 方法把字符串中的 tab 符号 语法: 参数: 返回值: 该方法返回字符串中的 tab 符号 实例: 语法: 注意: 寻值范围为 [beg, end) 。 两者的区别: 未找到子字符串时,find() 返回 -1,index() 抛出异常。 实例: 描述: maketrans() 方法用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同,为一一对应的关系。 注意: Python3.4 已经没有 string.maketrans() 了,取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans() 。 语法: 参数: 返回值: 返回字符串转换后生成的新字符串。 实例: 描述: rstrip() 删除 string 字符串末尾的指定字符,默认为空白符,包括空格、换行符、回车符、制表符。 语法: 注意: 参数: 返回值: 返回删除 string 字符串末尾的指定字符后生成的新字符串。 实例: 描述: split() 方法通过指定分隔符对字符串进行切片,该方法将字符串分割成子字符串并返回一个由这些子字符串组成的列表。 语法: 参数: 返回值: 返回分割后的字符串列表。 描述: splitlines() 按照行(‘\r’, ‘\r\n’, \n’)分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。 语法: 参数: 返回值: 返回一个包含各行作为元素的列表。 实例: 描述: title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写,其余字母均为小写。 注意: 单词是指以a-zA-Z之外符号分割的字母。例如:ab12cd中ab、cd是单词。 语法: 参数: 返回值: 返回"标题化"的字符串,就是说所有单词的首字母都转化为大写。 实例: 出处: 菜鸟教程 - Python3 列表 注意: 实例: 描述: reverse() 函数用于反向列表中元素。 语法: 描述: sort() 函数用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数。 语法: 参数: 返回值: 该方法没有返回值,但是会对列表的对象进行排序。 实例: 出处: 菜鸟教程 - Python3 元组 注意: tuple1 = (50,) 带 出处: 菜鸟教程 - Python3 字典 描述: fromkeys() 函数用于创建一个新字典,以序列 seq 中元素做字典的键,value 为字典所有键对应的初始值。 语法: 参数: 返回值: 该方法返回一个新字典。 实例: 描述: get() 函数返回指定键的值。 语法: 参数: 返回值: 返回指定键的值,如果键不在字典中返回默认值,如果不指定默认值,则返回 None。 描述: popitem() 方法随机返回并删除字典中的最后一对键和值。如果字典已经为空,却调用了此方法,就报出 KeyError 异常。 出处: 菜鸟教程 - Python3 集合 集合是一组无序排列的可哈希的值。 描述: ========== 更新日期 2023年8月27日 ==========5 字符串
5.1 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 字符串格式化
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
=
符号来拼接运算表达式与结果:>>> 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 字符串
5.5 Python 的字符串方法
5.5.1 capitalize()
str.capitalize()
5.5.2 center()、ljust()、rjust()、zfill()
ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
zfill() 方法返回指定长度的字符串,原字符串右对齐,前面填充0。zfill(width)
作用同 rjust(width, "0")
。str.center(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]
width
小于字符串长度时,返回字符串,不会截断;fillchar
只能接收单个字符;>>> 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 "
5.5.3 count()
str.count(sub, start= 0,end=len(string))
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()
str.endswith(suffix[, start[, end]])
5.5.5 expandtabs()
\t
转为空格,tab 符号 \t
默认的空格数是 8,在第 0、8、16…等处给出制表符位置,如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。str.expandtabs(tabsize=8)
\t
转为空格的字符数。\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))
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()
string.maketrans(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()
str.rstrip([chars])
chars
是一个包含需要删除的字符的字符串。从 str
的末尾开始删除,直到末尾的字符不在 chars
中。
>>> 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()
str.split(str="", num=string.count(str))
5.5.11 splitlines()
str.splitlines([keepends])
>>> '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()
str.title()
>>> txt = "hello b2b2b2 and 3g3g3g"
>>> print(txt.title())
Hello B2B2B2 And 3G3G3G
6 列表
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()
max()
和 min()
时,列表中的元素需要是同一种类型,否则无法比较;list[int]
整型列表时,优先比较整型列表第一个元素,如果相同会继续比较下去;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()
list.reverse()
6.2.3 sort()
list.sort(key=None, reverse=False)
>>> list1 = ["apple", "watermelon", "banana"]
>>> list1.sort(key = lambda ele: len(ele))
>>> list1
['apple', 'banana', 'watermelon']
7 元组
,
是元组,否则是整型。8 字典
8.1 字典内置函数和方法
8.1.1 fromkeys()
dict.fromkeys(seq[, value])
>>> 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()
setdefault() 方法和 get()方法 类似, 如果键不存在于字典中,将会添加键并将值设为默认值。dict.get(key[, value])
dict.setdefault(key, default=None)
如果 key 在 字典中,返回对应的值。如果不在字典中,则插入 key 及设置的默认值 default,并返回 default ,default 默认值为 None。8.1.3 popitem()
9 集合
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。