一、字符串(str)
1.1 字符串的定义
- 字符串 就是 一串字符，是编程语言中表示文本的数据类型
- 在 Python 中可以使用 一对双引号 " 或者 一对单引号 ' 定义一个字符串
- 可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始
- 也可以使用 for 循环遍历 字符串中每一个字符
1
#
!/usr/bin/env python3
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/5/31
7
"""
8
9
str1 =
"
hello python
"
10
11
for
c
in
str1:
12
print
(c, end=
'
\t
'
)
13
14
#
运行结果：h e l l o p y t h o n
1.2 字符串的常用操作
1
#
!/usr/bin/env python3
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/5/31
7
"""
8
9
#
1 * 重复输出字符串
10
print
(
'
hello
'
* 2
)
11
12
#
2 [] ,[:] 通过索引获取字符串中字符
13
print
(
'
helloworld
'
[2
:])
14
15
#
3 in 成员运算符 - 如果字符串中包含给定的字符返回 True
16
print
(
'
el
'
in
'
hello
'
)
17
18
#
4 % 格式字符串
19
print
(
'
alex is a good teacher
'
)
20
print
(
'
%s is a good teacher
'
%
'
alex
'
)
21
22
#
5 + 字符串拼接
23
a =
'
123
'
24
b =
'
abc
'
25
c =
'
789
'
26
d1 = a + b +
c
27
print
(d1)
#
+效率低,该用join
28
29
#
join效率高
30
d2 =
''
.join([a, b, c])
31
print
(d2)
1.3 字符串相关的函数
#
string.upper() 转换 string 中的小写字母为大写
#
string.lower() 转换 string 中所有大写字符为小写
#
string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以obj开头，是则返回True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
#
string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
#
string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
#
string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() 去除空格
#
string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
#
string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
#
string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是ignore或者replace
#
string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式解码 string，如果出错默认报一个ValueError的异常，除非errors指定的是'ignore'或 者'replace'
#
string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
#
string.format() 格式化输出
#
string.capitalize() 把字符串的第一个字符大写
#
string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
#
string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
#
string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是8。
#
string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常.
#
string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
#
string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
#
string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False.
#
string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False.
#
string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
#
string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False
#
string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False.
#
string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False
#
string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
#
string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
#
string.lstrip() 截掉 string 左边的空格
#
string.maketrans(intab, outtab]) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
#
max(str) 返回字符串 str 中最大的字母。
#
min(str) 返回字符串 str 中最小的字母。
#
string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
#
string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找.
#
string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始.
#
string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
#
string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找.
#
string.rstrip() 删除 string 字符串末尾的空格.
#
string.splitlines(num=string.count('\n')) 按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
#
string.swapcase() 翻转 string 中的大小写
#
string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
#
string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
1
#
!/usr/bin/env python3
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/5/31
7
"""
8
9
name =
"
hello world
"
10
#
小写字母变为大写
11
print
(name.upper())
#
HELLO WORLD
12
print
(name)
#
hello world
13
14
#
把大写字母变小写
15
name2 =
"
HELLO WORLD
"
16
print
(name2.lower())
#
hello world
17
print
(name2)
#
HELLO WORLD
18
19
#
判断是否以。。。开头
20
name3 =
"
hello
"
21
print
(name3.startswith(
"
he
"
))
#
True
22
#
检查字符串是否以。。结尾
23
print
(name3.endswith(
"
lo
"
))
#
True
24
25
#
replace 替换
26
name4 =
"
python
"
27
print
(name4.replace(
'
th
'
,
'
aa
'
))
#
pyaaon
28
29
#
去除空格
30
name5 =
"
bbcc
"
31
print
(name5.strip())
#
bbcc
32
33
#
分割
34
str1 =
"
aa|bb|cc|dd
"
35
print
(str1.split(
'
|
'
))
#
['aa', 'bb', 'cc', 'dd']
36
37
#
查找 返回开始的索引值
38
str2 =
"
we are family
"
39
print
(str2.find(
"
are
"
))
#
3
40
41
#
join 拼接
42
lst1 = [
'
aa
'
,
'
bb
'
,
'
cc
'
,
'
dd
'
]
43
print
(
"
-
"
.join(lst1))
#
aa-bb-cc-dd
1.4 字符串切片
- 切片 使用 索引值 来限定范围，根据 步长 从原序列中 取出一部分 元素组成新序列
- 切片 方法适用于 字符串、列表、元组
-
切片的语法表达式为：[start_index : end_index : step]，其中：
- start_index：起始索引
- end_index：结束索引
- step：步长
1
#
!/usr/bin/env python3
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/5/31
7
"""
8
9
str1 =
"
hello world
"
10
11
12
print
(str1[1:6
])
13
#
结果是ello
14
15
print
(str1[1:6:2
])
16
#
结果是el
17
18
print
(str1[2
:])
19
#
结果是llo world
20
#
保留start_index，但省略end_index，这样会从起始索引开始，切到最后一个元素为止
21
22
print
(str1[:5
])
23
#
结果是hello
24
#
省略start_index，保留end_index，这样会从第一个元素开始，切到end_index - 1的元素为止
25
26
print
(str1[-1:-6:-1
])
27
#
结果是dlrow
28
29
print
(str1[1:6:-1
])
30
#
结果为空
31
#
切片时,一定要保证start_index到end_index的方向与步长step的方向同向，否则会切出空的序列
1.5 字符串拼接
Python的字符串格式化有三种方式: 百分号方式、format方式、f-strings方式
1.5.1 百分号方式
格式：%[(name)][flags][width].[precision]typecode
-
(name) 可选，用于选择指定的key
-
flags 可选，可供选择的值有:
-
+ 右对齐；正数前加正好，负数前加负号；
-
- 左对齐；正数前无符号，负数前加负号；
-
空格 右对齐；正数前加空格，负数前加负号；
-
0 右对齐；正数前无符号，负数前加负号；用0填充空白处
-
width 可选，占有宽度
-
precision 可选，小数点后保留的位数
-
typecode 必选
-
s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
-
r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
-
c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
-
o，将整数转换成 八进制表示，并将其格式化到指定位置
-
x，将整数转换成十六进制表示，并将其格式化到指定位置
-
d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
-
e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
-
E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
-
f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
-
F，同上
-
g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
-
G，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
-
%，当字符串中存在格式化标志时，需要用 %%表示一个百分号
注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式
常用的格式化：
1
tpl =
"
i am %s
"
%
"
alex
"
2
3
tpl =
"
i am %s age %d
"
% (
"
alex
"
, 18
)
4
5
tpl =
"
i am %(name)s age %(age)d
"
% {
"
name
"
:
"
alex
"
,
"
age
"
: 18
}
6
7
tpl =
"
percent %.2f
"
% 99.97623
8
9
tpl =
"
i am %(pp).2f
"
% {
"
pp
"
: 123.425556
, }
10
11
tpl =
"
i am %.2f %%
"
% 123.425556
1.5.2 format方式
格式：[[fill]align][sign][#][0][width][,][.precision][type]
-
fill 【可选】空白处填充的字符
-
align 【可选】对齐方式（需配合width使用）
-
<，内容左对齐
-
>，内容右对齐(默认)
-
＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
-
^，内容居中
-
sign 【可选】有无符号数字
-
+，正号加正，负号加负；
-
-，正号不变，负号加负；
-
空格 ，正号空格，负号加负；
-
# 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
-
， 【可选】为数字添加分隔符，如：1,000,000
-
width 【可选】格式化位所占宽度
-
.precision 【可选】小数位保留精度
-
type 【可选】格式化类型
-
传入” 字符串类型 “的参数
-
s，格式化字符串类型数据
-
空白，未指定类型，则默认是None，同s
-
传入“ 整数类型 ”的参数
-
b，将10进制整数自动转换成2进制表示然后格式化
-
c，将10进制整数自动转换为其对应的unicode字符
-
d，十进制整数
-
o，将10进制整数自动转换成8进制表示然后格式化；
-
x，将10进制整数自动转换成16进制表示然后格式化（小写x）
-
X，将10进制整数自动转换成16进制表示然后格式化（大写X）
-
-
- 传入“ 浮点型或小数类型 ”的参数
-
-
-
e， 转换为科学计数法（小写e）表示，然后格式化；
-
E， 转换为科学计数法（大写E）表示，然后格式化;
-
f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
-
F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
-
g， 自动在e和f中切换
-
G， 自动在E和F中切换
-
%，显示百分比（默认显示小数点后6位）
-
常用的格式化：
1
tpl =
"
i am {}, age {}, {}
"
.format(
"
seven
"
, 18,
'
alex
'
)
2
3
tpl =
"
i am {}, age {}, {}
"
.format(*[
"
seven
"
, 18,
'
alex
'
])
4
5
tpl =
"
i am {0}, age {1}, really {0}
"
.format(
"
seven
"
, 18
)
6
7
tpl =
"
i am {0}, age {1}, really {0}
"
.format(*[
"
seven
"
, 18
])
8
9
tpl =
"
i am {name}, age {age}, really {name}
"
.format(name=
"
seven
"
, age=18
)
10
11
tpl =
"
i am {name}, age {age}, really {name}
"
.format(**{
"
name
"
:
"
seven
"
,
"
age
"
: 18
})
12
13
tpl =
"
i am {0[0]}, age {0[1]}, really {0[2]}
"
.format([1, 2, 3], [11, 22, 33
])
14
15
tpl =
"
i am {:s}, age {:d}, money {:f}
"
.format(
"
seven
"
, 18, 88888.1
)
16
17
tpl =
"
i am {:s}, age {:d}
"
.format(*[
"
seven
"
, 18
])
18
19
tpl =
"
i am {name:s}, age {age:d}
"
.format(name=
"
seven
"
, age=18
)
20
21
tpl =
"
i am {name:s}, age {age:d}
"
.format(**{
"
name
"
:
"
seven
"
,
"
age
"
: 18
})
22
23
tpl =
"
numbers: {:b},{:o},{:d},{:x},{:X}, {:%}
"
.format(15, 15, 15, 15, 15, 15.87623, 2
)
24
25
tpl =
"
numbers: {:b},{:o},{:d},{:x},{:X}, {:%}
"
.format(15, 15, 15, 15, 15, 15.87623, 2
)
26
27
tpl =
"
numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}
"
.format(15
)
28
29
tpl =
"
numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}
"
.format(num=15)
1.5.3 f-strings
f-strings 提供一种简洁易读的方式, 可以在字符串中包含 Python 表达式. f-strings 以字母 'f' 或 'F' 为前缀, 格式化字符串使用一对单引号、双引号、三单引号、三双引号. 格式化字符串中。
1
#
!/usr/bin/env python
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/6/5
7
"""
8
name =
'
豪仔
'
9
age = 26
10
format_string1 = f
'
我的名字是 {name}, 我的年龄是 {age}
'
11
print
(format_string1)
#
我的名字是 豪仔, 我的年龄是 26
12
13
format_string2 = f
"
我的名字是 {name}, 我的年龄是 {age}
"
14
print
(format_string2)
#
我的名字是 豪仔, 我的年龄是 26
15
16
format_string3 = F
'''
我的名字是 {name}, 我的年龄是 {age}
'''
17
print
(format_string3)
#
我的名字是 豪仔, 我的年龄是 26
18
19
format_string4 = F
"""
我的名字是 {name}, 我的年龄是 {age}
"""
20
print
(format_string4)
#
我的名字是 豪仔, 我的年龄是 26
21
22
#
花括号中的数字会先运算
23
format_string5 = f
'
3 + 5 = {3 + 5}
'
24
print
(format_string5)
#
3 + 5 = 8
25
26
a = 10
27
b = 20
28
format_string6 = f
'
3 + 5 = {a + b}
'
29
print
(format_string6)
#
3 + 5 = 30
30
31
#
两个花括号会被替换为一个花括号, 注意{{}} 不表示表达式
32
format_string7 = F
'
我的名字是 {{name}}, 我的年龄是 {{age}}
'
33
print
(format_string7)
二、bytes
Python3最重要的新特性之一是对字符串和二进制数据流做了明确的区分。文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python3不会以任意隐式的方式混用str和bytes，你不能拼接字符串和字节流，也无法在字节流里搜索字符串（反之亦然），也不能将字符串传入参数为字节流的函数（反之亦然）。
2.1 回顾编码的发展史
在计算机历史的早期，美国为代表的英语系国家主导了整个计算机行业，26个英文字母组成了多样的英语单词、语句、文章。因此，最早的字符编码规范是ASCII码，一种8位即1个字节的编码规范，它可以涵盖整个英语系的编码需要。
编码是什么？编码就是把一个字符用一个二进制来表示。我们都知道，所有的东西，不管是英文、中文还是符号等等，最终存储在磁盘上都是01010101这类东西。在计算机内部，读取和存储数据归根结底，处理的都是0和1组成的比特流。问题来了，人类看不懂这些比特流，如何让这些010101对人类变得可读呢？于是出现了字符编码，它是个翻译机，在计算机内部某个地方，透明的帮我们将比特流翻译成人类可以直接理解的文字。对于一般用户，不需要知道这个过程是什么原理，是怎么执行的。但是对于程序员却是个必须搞清楚的问题。
以ASCII编码为例，它规定1个字节8个比特位代表1个字符的编码，也就是“00000000”这么宽，一个一个字节的解读。例如：01000001表示大写字母A，有时我们会“偷懒"的用65这个十进制来表示A在ASCII中的编码。8个比特位，可以没有重复的最多表示2的8次方(255)个字符。
后来，计算机得到普及，中文、日文、韩文等等国家的文字需要在计算机内表示，ASCII的255位远远不够，于是标准组织制定出了叫做UNICODE的万国码，它规定任何一个字符（不管哪国的）至少以2个字节表示，可以更多。其中，英文字母就是用2个字节，而汉字是3个字节。这个编码虽然很好，满足了所有人的要求，但是它不兼容ASCII，同时还占用较多的空间和内存。因为，在计算机世界更多的字符是英文字母，明明可以1个字节就能够表示，非要用2个。
于是UTF-8编码应运而生，它规定英文字母系列用1个字节表示，汉字用3个字节表示等等。因此，它兼容ASCII，可以解码早期的文档。UTF-8很快就得到了广泛的应用。
在编码的发展历程中，我国还创造了自己的编码方式，例如GBK，GB2312，BIG5。他们只局限于在国内使用，不被国外认可。在GBK编码中，中文汉字占2个字节。
2.2 bytes和str的异同
回到bytes和str的身上。bytes是一种比特流，它的存在形式是01010001110这种。我们无论是在写代码，还是阅读文章的过程中，肯定不会有人直接阅读这种比特流，它必须有一个编码方式，使得它变成有意义的比特流，而不是一堆晦涩难懂的01组合。因为编码方式的不同，对这个比特流的解读也会不同，对实际使用造成了很大的困扰。下面让我们看看Python是如何处理这一系列编码问题的：
>>> s =
"
中文
"
>>>
s
'
中文
'
>>>
type(s)
<
class
'
str
'
>
>>> b = bytes(s, encoding=
'
utf-8
'
)
>>>
b
b
'
\xe4\xb8\xad\xe6\x96\x87
'
>>>
type(b)
<
class
'
bytes
'
>
从例子可以看出，s是个字符串类型。Python有个内置函数bytes()可以将字符串str类型转换成bytes类型，b实际上是一串01的组合，但为了在ide环境中让我们相对直观的观察，它被表现成了b'\xe4\xb8\xad\xe6\x96\x87'这种形式，开头的b表示这是一个bytes类型。\xe4是十六进制的表示方式，它占用1个字节的长度，因此”中文“被编码成utf-8后，我们可以数得出一共用了6个字节，每个汉字占用3个，这印证了上面的论述。在使用内置函数bytes()的时候，必须明确encoding的参数，不可省略。
我们都知道，字符串类str里有一个encode()方法，它是从字符串向比特流的编码过程。而bytes类型恰好有个decode()方法，它是从比特流向字符串解码的过程。除此之外，我们查看Python源码会发现bytes和str拥有几乎一模一样的方法列表，最大的区别就是encode和decode。
从实质上来说，字符串在磁盘上的保存形式也是01的组合，也需要编码解码。
如果，上面的阐述还不能让你搞清楚两者的区别，那么记住下面两几句话：
- 在将字符串存入磁盘和从磁盘读取字符串的过程中，Python自动地帮你完成了编码和解码的工作，你不需要关心它的过程。
- 使用bytes类型，实质上是告诉Python，不需要它帮你自动地完成编码和解码的工作，而是用户自己手动进行，并指定编码格式。
- Python已经严格区分了bytes和str两种数据类型，你不能在需要bytes类型参数的时候使用str参数，反之亦然。这点在读写磁盘文件时容易碰到。
在bytes和str的互相转换过程中，实际就是编码解码的过程，必须显式地指定编码格式。
1
#
!/usr/bin/env python3
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/5/31
7
"""
8
#
gbk编码的bytes
9
b = bytes(
'
中国
'
, encoding=
'
gbk
'
)
10
print
(b)
#
b'\xd6\xd0\xb9\xfa'
11
print
(type(b))
#
2.3 encode和decode
上面说过了，python3默认的编码时Unicode，用字符串表示，二进制数据由bytes类型表示。
- encode：将str转换为bytes，是一个编码的过程
- decode：将bytes转换为str，是一个解码的过程
1
#
!/usr/bin/env python3
2
#
-*-coding:utf-8-*-
3
4
"""
5
@author:fyh
6
@time:2019/5/31
7
"""
8
9
"""
10
其中decode()与encode()方法可以接受参数， 其声明分别为:
11
bytes.decode(encoding="utf-8", errors="strict")
12
str.encode(encoding="utf-8", errors="strict")
13
14
其中 encoding是指在解码/编码(动词)过程中使用的字符编码(名词)
15
16
errors是指错误的处理方案,errrors参数默认值是strict(严格的)意味着如果编解码出错将会抛出UnicodeError
17
18
如果想忽略编解码错误 可以将errors设置为ignore
19
"""
20
21
22
#
编码 encode
23
str1 =
"
中国
"
24
25
str1_utf8 = str1.encode(encoding=
'
utf8
'
)
26
print
(str1_utf8)
#
b'\xe4\xb8\xad\xe5\x9b\xbd'
27
print
(type(str1_utf8))
#
ps：编码和解码时，对应的编码方式要一致
ps：对数据的编码解码工作是通过返回值查看到最终结果的，前面的数据对象并不受影响
