用单引号或双引号引起来的字符如："a"，"1"，"*"，"abc"，'12#@'等等，是可迭代对象。是不可变的数据类型，因为当一个字符串被定义后，字符串里面任意一个字符都是确定的，我们不能在代码中去修改一个字符串，但我们可以通过拼接和切片的方式得到一个新的字符串。在代码中我们可以使用以下5种方式来表示字符串。

第一种，使用单引号

str1 = 'abc'

给变量str1赋值为'abc'，此时str1的数据类型为字符串，number的值为'abc'。

第二种，使用双引号

str1 = "abc"

给变量str1赋值为'abc'，此时str1的数据类型为字符串，number的值为'abc'。

第三种，使用str函数

str1 = str(123)

给变量str1赋值为'123'，此时str1的数据类型为字符串，number的值为'123'。str函数可以把传入的数据转换为字符串类型，这里我们传入的参数是整型123，str函数把整型123转换为了字符串'123'。

第四种，使用3重单引号的多行字符串

str1 = '''第一行 hello world
第二行 世界你好
第三行 小白轻松学python'''
print(str1)

执行结果：

第五种，使用3重双引号的多行字符串

str1 = """第一行 hello world
第二行 世界你好
第三行 小白轻松学python"""
print(str1)

执行结果：

如何定义字符中存在引号的字符串？

从上面的5种字符串定义方式，我们可以看到，定义字符串需要使用一对单引号或者一对双引号。如果需要我们定义的字符串中存在一个或多个引号怎么办，例如我们要定义这样一个字符串"it's robot"这个字符串中有一个单引号，我们可以使用以下2种方式来定义。

第一种，使用双引号加单引号的方式，如下：

a = "it's robot"
print(a)

执行结果如下：

我们用双引号来定义字符串，在字符串的内部就可以有一个或多个单引号。相反，我们使用单引号来定义字符串，在字符串的内部就可以有一个或多个双引号。

第二种，使用转义字符(\'或者\")，如下：

a = 'it\'s robot'
print(a)

执行结果如下：

转义字符(\')，表示输出字符（'）转义字符(\")，表示输出字符（"）。如果我们想在字符串中输出单引号或者双引号，但又不能与用来定义字符串的单引号或双引号冲突时，我们就可以使用转义字符（\'或者\"）。

使用转义字符(\'或者\")我们就可以定义出更加复杂的字符串，例如单引号双引号交叉出现的字符串。如下：

a = '一个单引号\' "一对双引号里面有个单引号 \' "'
print(a)

执行结果如下：

字符串之间的拼接方式

字符串与字符串使用+号进行连接，如下所示：

a = "hello"
b = "world"
c = a + " " + b
print(c)  # c = 'hello world'

我们可以把一个复杂的字符串拆分成多个简单的字符串，分别定义后再通过字符串拼接的方式，组合成复杂的字符串。

字符串重复操作符（*）

*号可以把字符串重复多次后变成一个新的字符串，如下所示：

str1 = 'abc@' * 3
print(str1)

执行结果如下：

*号把字符串'abc@'重复3次后变成了一个新的字符串'abc@abc@abc@'。

字符串的索引和切片

因为字符串是可迭代的，所以字符串具有被索引和切片的功能。

索引

索引就是通过下标的方式去获取可迭代对象中的其中一个元素，需要注意的是下标的值(整形)不能超出可迭代对象的范围。举个例子，请看下面的代码：

str1 = 'hello'
print(str1[0])

执行结果如下：

索引分为正序索引和逆序索引。正序索引是从第一个字符开始，第一个字符的下标为0，向后数，每个字符的下标依次递增1。逆序索引是从最后一个字符开始，最后一个字符的下标为-1，向前数，每个字符的下标依次递减1。对于字符串'hello'来举例，我们可以得到如下的索引：

字符串中有5个字符，也就是字符串的长度为5。正序索引的下标范围是0~4，逆序索引的下标范围是-1~-5，所以str1[0]和str1[-5]都是获取str1的第一个字符h。我们不能用超出索引范围的下标来索引，会报错。如下：

str1 = 'hello'
print(str1[5])

执行结果如下：

执行结果就报错了，说pythonBase.py文件的第二行print(str1[5])出错了，对字符串的索引超出了范围。 str1[5]是获取str1的第6个字符，但str1只有5个字符，根本就没有第6个字符，所以python会报错。

切片

切片就是索引的高级应用，索引只能获取一个元素，但切片可以获取一个或多个元素，切片的本质就是多次使用索引去获取多个元素。在切片中下标的值可以超出可迭代对象的索引范围，超出范围部分虽然不会报错，但也获取不到任何值。举个例子，请看下面的代码：

str1 = 'hello'
print(str1[0:2])

执行结果如下：

切片和索引一样，也是使用中括号。索引只需要在中括号中写一个下标，但切片是一个范围需要两个下标，并且两个下标之间用冒号隔开，表示从第一个下标到第二个下标范围内的元素。切片的范围是一个半开半闭区间(前闭后开)，所以切片范围[0:2]在数学中的范围表示是[0,2)，能取到的整数值有0和1。因此str1[0:2]表示获取str1中的第一个和第二个字符，所以执行结果为'he'。

切片中的下标也可以不写，但冒号一定要写。当我们不写第一个下标时，python默认第一个下标为0；当我们不写第二个下标时，python默认第二个下标为可迭代对象的长度。如下：

str1 = 'hello'
print(str1[:])

执行结果如下：

我们两个下标都没写，所以python默认的切片范围是[0:5]，在数学中的范围表示是[0,5)，能取到的整数值有0、1、2、3、4。获取到了str1中的所有字符，所以执行结果为'hello'。

当切片的范围超出索引范围时，python不会报错，没有超出范围部分可以正常的获取到值，超出范围的部分没有任何的值。如下：

str1 = 'hello'
print(str1[4:10])

执行结果如下：

切片范围[4:10]，在数学中的范围表示是[4,10)，能取到的整数值有4、5、6、7、8、9。str1[4]的值是o，str1[5]、str1[6]、str1[7]、str1[8]、str1[9]都是超出索引范围的，超出范围是没有任何值的。所以执行结果为'o'。

在切片中，我们可以使用步长的方式来间歇性获取可迭代对象中的元素。举个例子，请看下面的代码：

str1 = '0123456789'
print(str1[0:10:2])

执行结果如下：

切片[0:10:2]中，0和10我们都知道表示的是切片范围[0:10]。那最后面这个2表示的就是切片的步长了，步长也是用冒号来跟第二个下标隔开的。当我们不写切片步长时，python默认切片步长为1。我们知道，切片的本质就是多次使用索引去获取多个元素。在切片中就需要不断的改变索引的下标去获取元素，步长的意义就是每次索引下标需要递增的值，步长为1时，每获取一次元素下标加1。上面的例子中步长为2，所以是每获取一次元素，下标加2。切片多次使用索引的结果为str1[0]、str1[2]、str1[4]、str1[6]、str1[8]，所以执行的结果为'02468'。

步长为正数时，切片为正序索引。步长为负数时，切片为逆序索引。举个例子，请看下面的代码：

str1 = '0123456789'
print(str1[::-1])

执行结果如下：

切片[::-1]中两个下标都没写，表示的切片范围是[0:10]，会获取到str1中的所有字符。步长为-1，表示逆序索引，也就是从最后一个字符开始索引取值，并且每索引一次下标加-1。切片多次使用索引的结果为str1[-1]、str1[-2]、str1[-3]、str1[-4]、str1[-5]、str1[-6]、str1[-7]、str1[-8]、str1[-9]、str1[-10]，所以执行的结果为'9876543210'。

字符串的格式化输出

字符串的格式化输出可以把python中的对象转换成字符串，有3中方式分别是格式化操作符（%）、字符串内置函数format、f-string。

格式化操作符（%）

格式化操作符（%），可以格式化字符串。在使用格式化操作符时，需要在字符串中放置格式化符号来占据位置。因此格式化符号，也可以叫占位符。它就相当于帮一个python对象在字符串中占据一个位置，只不过不同的占位符对应不同类型的python对象。占位符只帮自己接受的对象占位，如果帮它不接受的对象占位就会报错，而且对象要根据占位符的格式来输出。常用的格式化符号有如下几种：

%c	把ASCⅡ值转换为对应的字符，范围是[0, 127]的整数
%r	使用repr()函数转换为字符串
%s	使用str()函数转换为字符串
%d或者%i	转换为有符号十进制数
%u	转换为无符号十进制数
%o	转换为无符号八进制数
%x或者%X	转换为无符号十六进制数
%e或者%E	转换为科学计数法
%f或者%F	转换为浮点数
%g或者%G	可代替%e或者%E和%f或者%F
%%	输出%

格式化符号（%c）

%c可以把ASCⅡ表中的值[0, 127]的整数转换为对应的字符，举个例子，请看如下代码：

str1 = "字符：%c" % 97
print(str1)  # 字符：a

在ASCⅡ表中值97对应的字符为a，所以%c把整数97转换为a。注意范围[0, 127]才是有效转换。

格式化符号（%r）

%r是使用repr函数来输出被转换对象的描述字符串，被转换对象所对应的类中必须已经自定义了__reper__函数，才能使用repr函数来输出描述字符串。如果没有自定义，就会使用object类中定义的__reper__函数。初学者看不懂前面的描述没关系，这些属于高阶知识，后面我们讲到怎样去定义一个类的时候会解释__reper__函数。我们只需要知道%r能把一个对象转换为字符串就行，如果输出的是对象信息，说明这个对象所对应的类中没有定义__reper__函数。举个例子，请看如下代码：

str1 = "对象的字符串形式：%r" % 100
print(str1)  # 对象的字符串形式：100

整型100的字符串描述就是'100'。

格式化符号（%s）

%s是优先使用str函数来输出被转换对象的描述字符串，被转换对象所对应的类中必须已经自定义了__str__函数，才能使用str函数来输出描述字符串。如果没有定义，就会使用输出对象信息。举个例子，请看如下代码：

str1 = "对象的字符串形式：%s" % 100
print(str1)  # 对象的字符串形式：100

整型100的字符串描述就是'100'。

格式化符号（%d或者%i）

%d或者%i是把一个数转换为有符号的10进制数，当然转换出来的有符号的10进制数是字符串，不是整型。这里的有符号是说10进制数转换为2进制的时候，在CPU中表现为有符号，即最高位为符号位（在整型的位运算符中，我给大家解释过有符号2进制数）。对于初学者来说，我们不需要关注有符号的问题，有没有符号对我们没什么影响。我们只需要知道%d或者%i能把一个数转换为十进制数就行了。举个例子，请看如下代码：

str1 = "十进制数：%d" % 100.34567
print(str1)  # 十进制数：100
str2 = "十进制数：%i" % 3.4567e5
print(str2)  # 十进制数：345670

%d把小数100.34567转换为了10进制数'100'，%i把用科学计数法表示的小数3.4567e5转换为了10进制数'345670'。

格式化符号（%u）

%u是把一个数转换为无符号的10进制数，当然转换出来的无符号的10进制数是字符串，不是整型。这里的无符号是说10进制数转换为2进制的时候，在CPU中表现为无符号，即没有符号位。举个例子，请看如下代码：

str1 = "十进制数：%u" % 100.34567
print(str1)  # 十进制数：100

%u把小数100.34567转换为了10进制数'100'。

格式化符号（%o）

%o是把一个数转换为无符号的8进制数，当然转换出来的无符号的8进制数是字符串，不是整型。举个例子，请看如下代码：

str1 = "八进制数：%o" % 100
print(str1)  # 八进制数：144

%o把10进制的100转换为了8进制数'144'。

格式化符号（%x或者%X）

%x或者%X是把一个数转换为无符号的16进制数，当然转换出来的无符号的16进制数是字符串，不是整型。举个例子，请看如下代码：

str1 = "十六进制数：%x" % 200
print(str1)  # 十六进制数：c8
str2 = "十六进制数：%X" % 200
print(str2)  # 十六进制数：C8

%x把10进制的200转换为了16进制数'c8'，%X把10进制的200转换为了16进制数'C8'。%x和%X的区别就是转换后的16进制数字母部分，一个是小写一个是大写。

格式化符号（%e或者%E）

%e或者%E是把一个数转换为科学计数法的形式，当然转换出来的数是字符串，不是浮点型。举个例子，请看如下代码：

str1 = "科学计数法：%e" % 200
print(str1)  # 科学计数法：2.000000e+02
str2 = "科学计数法：%E" % 200
print(str2)  # 科学计数法：2.000000E+02

%e把10进制的200转换为了科学计数法'2.000000e+02'，%E把10进制的200转换为了16进制数'2.000000E+02'。%e和%E的区别就是转换后的科学计数法的e，一个是小写一个是大写。

格式化符号（%f或者%F）

%f或者%F是把一个数转换为浮点数，当然转换出来的数是字符串，不是浮点型。举个例子，请看如下代码：

str1 = "浮点数：%f" % 200
print(str1)  # 浮点数：200.000000
str2 = "浮点数：%F" % 200
print(str2)  # 浮点数：200.000000

%f或者%F把10进制的200转换为了浮点数'200.000000'。

格式化符号（%g或者%G）

%g会根据数值的大小来自动选择%f或者%e，%G会根据数值的大小来自动选择%F或者%E。当一个数，它的整数位超过6位就会用科学计数法显示，它的整数位刚好6位时就只显示整数部分，它的整数位小于6位又存在小数时会显示所有整数和部分小数。举个例子，请看如下代码：

str1 = "科学计数：%g" % 2000000
print(str1)  # 科学计数：2e+06
str2 = "整数：%g" % 200000
print(str2)  # 整数：200000
str3 = "浮点数：%g" % 20000.123
print(str3)  # 浮点数：20000.1
str4 = "科学计数：%G" % 2000000.123
print(str4)  # 科学计数：2E+06

发现了没，%g或者%G最多只能转换出6位数字。

格式化符号（%%）

使用%%的场景主要是在使用格式化操作符的时候，想要输出一些百分数，例如输出10%。

str1 = "百分数：%d%%" % 10
print(str1)  # 百分数：10%

%d的位置输出的是10，%%输出的是%，所以%d%%整体输出10%。

同时操作多个对象

%是可以同时操作多个对象的，请看如下代码：

str1 = "整数：%d 小数：%f 字符串：%s 科学计数法：%e 百分数：%g%%" % (100, 1.2345, "hello", 0.000001, 99.9)
print(str1)  # 整数：100 小数：1.234500 字符串：hello 科学计数法：1.000000e-06 百分数：99.9%

当我们需要操作多个对象时，就使用圆括号把多个对象括起来，括号中对象的顺序要和占位符一一对应。

辅助（控制占位宽度）

我们可以控制占位符在字符串中占据n个字符的宽度，这里的占位宽度指的是最小位置宽度。当对象的宽度大于占位宽度时，会以对象的宽度为准；当对象的宽度小于占位宽度时，会在对象的前方填充空格补位。占位的方式有如下两种：

第一种：%后跟整数n表示占据n个位置

str1 = '%10s' % "abcdefg"
print(str1)

执行结果如下：

字符串'abcdefg'的宽度是7，占位符占位宽度是10，所以在字符串'abcdefg'前面加了3个空格，来保证位置的宽度是10。当对象宽度大于占位宽度时，以对象的宽度为准，请看如下代码：

str1 = '%5s' % "abcdefg"
print(str1)

执行结果如下：

占位宽度为5，对象宽度为7，以对象宽度为准。

第二种：%*

str1 = '%*d' % (10, 100000)
print(str1)

执行结果如下：

这种方式就相当于用*号给括号中的10占了一个位置，所以%*d占了两个位置，需要传入两个对象。第一个10给*，第二个100000给%d。虽然这种写法看起来比第一种要麻烦一些，但它有个好处就是没有把占位宽度写死，我们可以通过改变对象的值来随时改变占位宽度。这在一两行代码中无法体现出来，在一个连续运行的程序中就可以体现出它的好处。

辅助（控制左对齐）

当我们控制了占位宽度时，字符都是靠右对齐的（因为对象宽度不够时，在前面加空格补齐）。此时我们想要左对齐，就需要在%后跟-号，用来补齐宽度的空格就会放到对象后面。请看如下代码：

str1 = '%*dhahaha' % (10, 100000)
print(str1)
str2 = '%-*dhahaha' % (10, 100000)
print(str2)

执行结果如下：

看出两个字符串的区别了吗，这就是%后跟-号的作用，变成左对齐。

辅助（数字前面显示0）

当我们控制了占位宽度时，对象宽度不够时，在前面加空格补齐。对象是一个数字时，我们可以把它前面的空格换成0。只需要在%号后跟0，请看如下代码：

str1 = '%0*d' % (10, 100000)
print(str1)
str2 = '%0*f' % (10, 1.234567)
print(str2)

执行结果如下：

数字前方的空格全换成了0。

辅助（在正数前面显示正号）

负数前面会显示负号，让我们知道它是负数。但正数前面却没有正号，我们依然认为它是正数。如果我们想在格式化输出时正数前面显示正号，就需要在%后跟+号。请看如下代码：

str1 = '%+d' % 100000
print(str1)

执行结果如下：

辅助（8进制数前显示0o，16进制数前显示0x）

当我们把一个10进制数换成8进制数或16进制数时，想跟10进制做区别，就要在8进制前加0o，在16进制前加0x。只需要在%后跟#号就能做到，请看如下代码：

str1 = '%#o' % 100
print(str1)
str2 = '%#x' % 100
print(str2)
str3 = '%#X' % 100
print(str3)

执行结果如下：

辅助（控制小数精度）

当我们格式化输出一个小数，想要控制小数的位数时（四舍五入）。只需要在%后跟.nf，表示保留n位小数。请看如下代码：

str1 = '%.2f' % 1.234567
print(str1)  # 1.23

当然我们还可以使用*号

str1 = '%.*f' % (3, 1.234567)
print(str1)  # 1.235

这些辅助符号可以根据我们的需求随意搭配，互相组合。

format函数

format函数是python字符串类的实例函数，它是内置在python解释器中的。format使用起来比%更简单，使用范围也更广。

基本使用方式（有序）

format函数是对格式化操作符（%）的优化，在format中不再需要格式化符号来占位，而是使用{}来占位。{}可以接受python中的任意对象，{}不对对象做任何输出限制，完全输出对象本身。举个例子，请看如下代码：

str1 = '整数：{} 小数：{} 字符串：{}'.format(100, 1.23, "hello world!")
print(str1)  # 整数：100 小数：1.23 字符串：hello world!

format中的第一个参数被放在了第一个{}的位置，第二个参数放在第二个{}的位置。占位符和参数的位置是一一对应的，这种是有序使用参数，参数的数量必须和占位符{}的数量一致。我们还可以无序使用参数。

位置参数使用方式（无序）

当我们需要把一个对象放在一个字符串中的多个位置时，我们可以在占位符{}中加一个序号（正整数），来表示此占位符{n}使用的是format函数中的第n+1个参数。举个例子，请看如下代码：

str1 = '{0} world，{0} 爆笑蛙，{0} 大家，一起学{1}'.format("hello", "python")
print(str1)  # hello world，hello 爆笑蛙，hello 大家，一起学python

format的第一个参数是'hello'，我们用{0}来表示要放置'hello'的位置。第二个参数是'python'，我们用{1}来表示要放置'python'的位置。这种方式可以无序使用参数，参数的数量和占位符{}的数量可以不同。因为{n}表示使用第n+1个参数，所以我们可以把{n}放在字符串中的任意位置，也可以准确的知道该位置放置的是第n+1个参数。

关键字参数使用方式（无序）

前面两中format的使用方式，我们给format函数传参都是使用的普通传参的方式。我们还可以使用关键字传参的方式来给format传参（key=value），请看如下代码：

str1 = '{name}今年{age}岁了，{name}喜欢学python'.format(name="小明", age=23)
print(str1)  # 小明今年23岁了，小明喜欢学python

当我们使用关键字传参时，我们就可以把关键字放到{}中。{name}使用的对象就是关键字name所对应的值'小明'，{age}使用的对象就是age所对应的值23。这种方式也可以无序使用参数。

下标参数使用方式（无序）

当我们给format传入的参数是一个可迭代的对象时，我们可以使用下标的方式去索引这个对象的某个元素来放置在该位置。python中常见的可迭代对象有字符串、列表、元组、字典等，我们目前只介绍了字符串，所以这里只用字符串给大家举例，请看如下代码：

str1 = "字符'{0[2]}'是字符串'{0}'中的元素".format("abcdefg")
print(str1)  # 字符'c'是字符串'abcdefg'中的元素

我们先用位置参数{0}把字符串放在了两个位置上，第一个{0}中我们又使用了下标索引[2]来获取出字符’c‘。其他可迭代对象的使用方式相似，只是它们中的某个元素不一定是字符。

控制占位宽度

{:n}可以在字符串中占据宽度为n个字符的位置，这里的占位宽度指的是最小位置宽度。当对象的宽度大于占位宽度时，会以对象的宽度为准；当对象的宽度小于占位宽度时，会在对象的后方填充空格补位。举个例子，请看如下代码：

str1 = "{:10}aaa".format("abcdefg")
print(str1)

执行结果如下：

{:10}表示占据10个字符宽度的位置，所以在字符串'abcdefg'后填充了3个空格来补齐10个字符。

对齐与填充

对齐和填充都是在控制占位宽度时才会用到。对齐有3中方式居左（默认）、居中、居右。

居左对齐：{:<n}

居左对齐是format默认的对齐方式，所以{:n}和{:<n}的效果是一样的。举个例子，请看如下代码：

str1 = "{:10}aaa".format("abcdefg")
print(str1)
str2 = "{:<10}aaa".format("abcdefg")
print(str2)

执行结果如下：

居右对齐：{:>n}

居右对齐会把填充的空格放到对象前面，使对象靠右空格靠左。请看如下代码：

str1 = "{:>10}aaa".format("abcdefg")
print(str1)

执行结果如下：

居中对齐：{:^n}

居中对齐会把对象放在中间位置，两边使用空格填充。请看如下代码：

str1 = "{:^10}aaa".format("abcdefg")
print(str1)

执行结果如下：

填充是为了把默认使用的空格填充换成其他字符填充，填充的字符放在:号之后对齐符号之前，必须和对齐符号一起使用。举个例子，请看如下代码：

my_str = "abcdefg"
str1 = "{:0<12}".format(my_str)
print(str1)
str2 = "{:0>12}".format(my_str)
print(str2)
str3 = "{:0^12}".format(my_str)
print(str3)

执行结果如下：

我们把默认的空格换成了字符'0'来填充。

控制小数精度

当我们格式化输出一个小数，想要控制小数的位数时（四舍五入）。只需要在:号后跟.nf，表示保留n位小数。请看如下代码：

str1 = "{:.3f}".format(1.23456)
print(str1)  # 1.235
str2 = "{:0<10.3f}".format(1.23456)
print(str2)  # 1.235000000

进制转换

二进制：{:b}、{:#b}

在:号后面跟b表示输出2进制数字，在:号后面跟#b表示输出以0b开头的2进制数字。请看如下代码：

str1 = "{:b}".format(100)
print(str1)  # 1100100
str2 = "{:#b}".format(100)
print(str2)  # 0b1100100

八进制：{:o}、{:#o}

在:号后面跟o表示输出8进制数字，在:号后面跟#o表示输出以0o开头的8进制数字。请看如下代码：

str1 = "{:o}".format(100)
print(str1)  # 144
str2 = "{:#o}".format(100)
print(str2)  # 0o144

十进制：{:d}

在:号后面跟d表示输出10进制数字，其实这种写法没什么必要。请看如下代码：

str1 = "{:d}".format(100)
print(str1)  # 100

十六进制：{:x}、{:#x}、{:#X}

在:号后面跟x表示输出16进制数字，在:号后面跟#x表示输出以0x开头的16进制数字，在:号后面跟#X表示输出以0X开头的16进制数字。请看如下代码：

str1 = "{:x}".format(100)
print(str1)  # 64
str2 = "{:#x}".format(100)
print(str2)  # 0x64
str3 = "{:#X}".format(100)
print(str3)  # 0X64

科学计数法

在:号后面跟e表示用科学计数法来表示数字，请看如下代码：

str1 = "{:e}".format(100)
print(str1)  # 1.000000e+02
str2 = "{:E}".format(100)
print(str2)  # 1.000000E+02

千位分隔符

在:号后面跟,或者_可以每3位分隔较大的整数，请看如下代码：

str1 = "{:,}".format(10000000)
print(str1)  # 10,000,000
str2 = "{:_}".format(10000000)
print(str2)  # 10_000_000

百分数

在:号后面跟%会将传入的数值乘以100，再以百分数的形式输出，请看如下代码：

str1 = "{:%}".format(0.98)
print(str1)  # 98.000000%
str2 = "{:.2%}".format(0.98)
print(str2)  # 98.00%

f-string

f-string是对format的进一步优化，f-string不再需要占位符来占位了，而是采用自己给自己占位。而且不仅限于把python对象放入字符串，还可以把能运算的表达式放入字符串。

基本使用方式

f-string是在定义字符串时，在引号的左边加一个字符f，表示为f''。同样是用{}在字符串中标出对象的位置，然后把对象或表达式直接放到{}中。举个例子，请看如下代码：

str1 = f"整数：{100} 小数：{1.23} 字符串：{'hello world'} 表达式运算结果：{1 + 1}"
print(str1)  # 整数：100 小数：1.23 字符串：hello world 表达式运算结果：2

控制占位宽度

写法： {对象:n}，n表示占据n个字符的宽度。这里的占位宽度指的是最小位置宽度。当对象的宽度大于占位宽度时，会以对象的宽度为准；当对象的宽度小于占位宽度时，会在对象的前方填充空格补位。请看如下代码：

str1 = f"{100:10}"
print(str1)

执行结果如下：

对齐与填充

对齐和填充都是在控制占位宽度时才会用到。对齐有3中方式居左、居中、居右（默认）。

居左对齐：{对象:<n}

居左对齐会把填充的空格放到对象后面，使对象靠左空格靠右。请看如下代码：

str1 = f"{100:<10}---"
print(str1)

执行结果如下：

居右对齐：{对象:>n}

居右对齐是f-string的默认的对齐方式，所以{对象:n}和{对象:>n}的效果是一样的。举个例子，请看如下代码：

str1 = f"{100:10}---"
print(str1)
str2 = f"{100:>10}---"
print(str2)

执行结果如下：

居中对齐：{对象:^n}

居中对齐会把对象放在中间位置，两边使用空格填充。请看如下代码：

str1 = f"{100:^10}---"
print(str1)

执行结果如下：

填充是为了把默认使用的空格填充换成其他字符填充，填充的字符放在:号之后对齐符号之前，必须和对齐符号一起使用。举个例子，请看如下代码：

number = 100
str1 = f"{number:a<10}---"
print(str1)
str2 = f"{number:a>10}---"
print(str2)
str3 = f"{number:a^10}---"
print(str3)

执行结果如下：

我们把默认的空格换成了字符'a'来填充。

控制小数精度

当我们格式化输出一个小数，想要控制小数的位数时（四舍五入）。只需要在:号后跟.nf，表示保留n位小数。请看如下代码：

str1 = f"{1.234567:.3f}"
print(str1)  # 1.235

进制转换

二进制：{对象:b}、{对象:#b}

在:号后面跟b表示输出2进制数字，在:号后面跟#b表示输出以0b开头的2进制数字。请看如下代码：

str1 = f"{100:b}"
print(str1)  # 1100100
str2 = f"{100:#b}"
print(str2)  # 0b1100100

八进制：{对象:o}、{对象:#o}

在:号后面跟o表示输出8进制数字，在:号后面跟#o表示输出以0o开头的8进制数字。请看如下代码：

str1 = f"{100:o}"
print(str1)  # 144
str2 = f"{100:#o}"
print(str2)  # 0o144

十进制：{对象:d}

在:号后面跟d表示输出10进制数字，其实这种写法没什么必要。请看如下代码：

str1 = f"{100:d}"
print(str1)  # 100

十六进制：{对象:x}、{对象:#x}、{对象:#X}

在:号后面跟x表示输出16进制数字，在:号后面跟#x表示输出以0x开头的16进制数字，在:号后面跟#X表示输出以0X开头的16进制数字。请看如下代码：

number = 100
str1 = f"{number:x}"
print(str1)  # 64
str2 = f"{number:#x}"
print(str2)  # 0x64
str3 = f"{number:#X}"
print(str3)  # 0X64

科学计数法

在:号后面跟e表示用科学计数法来表示数字，请看如下代码：

str1 = f"{100:e}"
print(str1)  # 1.000000e+02
str2 = f"{100:E}"
print(str2)  # 1.000000E+02

千位分隔符

在:号后面跟,或者_可以每3位分隔较大的整数，请看如下代码：

number = 10000000
str1 = f"{number:,}"
print(str1)  # 10,000,000
str2 = f"{number:_}"
print(str2)  # 10_000_000

百分数

在:号后面跟%会将传入的数值乘以100，再以百分数的形式输出，请看如下代码：

number = 0.98
str1 = f"{number:%}"
print(str1)  # 98.000000%
str2 = f"{number:.2%}"
print(str2)  # 98.00%
str3 = f"{98}%"
print(str3)  # 98%

字符串的格式化输出就讲到这，我们需要开动我们的大脑，把上面这些方法灵活运用起来。我们可以随意的去组合它们，弄错了也没关系，就像做实验一样，而且做写代码的实验需要付出的只有时间成本。

常用的转义字符

\'	输出字符'
\"	输出字符"
\	续行符，当一行代码太长，需要分成两行来写，中间敲一个\
\\	输出字符\
\b	退格符，光标向前回退一个位置
\n	换行符，把光标放到下一行行首
\r	回车符，把光标放到本行行首
\t	横向制表符

转义字符（\'和\"）

\'和\"在前面介绍如何定义存在引号的字符串时就已经说过了，这里就不在细说了。它们的作用就是在字符串中输出单引号和双引号，并且不和定义字符串的单引号和双引号起冲突。

转义字符（\）

续航符，当一行代码中具有很复杂的运算逻辑时，这行代码可能会变得很长。而一行代码的长度最好控制在120个字符以内，因为把一行代码写的太长不利于我们在编辑器（Pycharm）中观察它的逻辑。这时我们就需要用到续航符，把一行代码分成多行显示，利于我们观察。利用续航符显示为多行的代码在python解释器看来还是一行代码，不会影响代码的运算逻辑。举个例子，请看如下代码：

number = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 \
         + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25
print(number)  # 325

上面的代码中出现了一个很长的连加逻辑，用一行来显示的话这个窗口装不下，需要滑动滚动条才能看完。这是我们就可以在合适的位置敲一个续航符，再点一下回车把后面的代码换到下一行显示，这并不影响代码的逻辑python解释器还是能正常翻译。当然这里只是为了给大家举例子才写了这么长一个连加逻辑，在正常情况下我是不会这样写的。

转义字符（\\）

\\就是在字符串中输出字符\，举个例子，请看如下代码：

str1 = 'file\\path'
print(str1)

执行结果如下：

转义字符（\b）

退格符，在字符串中使光标向前回退一个位置，相当于把\b前面一个字符给删除掉了。举个例子，请看如下代码：

str1 = "大家\b好"
print(str1)  # 大好

打印的结果中，大家好的家就被删除掉了。

转义字符（\n）

换行符，在字符串中使\n后面的字符放到下一行。把一个一行字符串变成一个两行字符串。请看如下代码：

str1 = 'hello world\nhello 爆笑蛙'
print(str1)

执行结果如下：

转义字符（\r）

回车符，在字符串中使光标移动到本行行首，相当于把\r前面的所有字符都删除掉了。请看如下代码：

str1 = 'hello world\rhello 爆笑蛙'
print(str1)  # hello 爆笑蛙

\r前面的hello world就被删除掉了。

我们可以利用\r的特性跟print函数联合使用，在python执行终端打印出动态进度条的效果。请看如下代码：

import time


for i in range(101):
    print(f'\r下载进度：{"."*i:<100}{i:>3}%', end="")
    time.sleep(0.1)

执行结果如下：

首先导入time函数库，time函数库是python自带的函数库。我们使用time函数库中的sleep函数，sleep函数的作用就是停顿一段时间。for循环我们还没将，这个for循环的意思就是，在循环的过程中给变量i赋值，赋值范围是从0到100的整数，然后执行print函数和sleep函数。循环一次i的值就会加1，然后print打印sleep停顿再进入下一个循环，直到i的值为100，打印停顿后结束循环。print函数中的代码全都是上面讲过的知识点组合起来的。

转义字符（\t）

横向制表符，在字符串中给它前面的字符留出4的n倍个字符宽度。当\t前面的字符数量小于4时，\t会给前面留出4个字符的位置来放置它前面的字符；当\t前面的字符数量大于4小于8时，\t会给前面留出8个字符的位置来放置它前面的字符。举个例子，请看如下代码：

str1 = '1\t5'
print(str1)
str2 = '12345\t9'
print(str2)

执行结果如下：

原始字符串（r/R）

原始字符串就是字符串中所有的字符都以普通字符来定义，转义字符和占位符也会被当做普通字符处理。原始字符串需要在定义字符串的引号前面加r或者R，类似于f-string的写法。举个例子，请看如下代码：

str1 = r'换行\n回车\r斜杠\\制表\t占位%d{}'
print(str1)  # 换行\n回车\r斜杠\\制表\t占位%d{}

执行结果如下：

这些转义字符和占位符全部都失去了原有的作用，被当成普通字符来使用。

python内置函数

len()	返回字符串的长度（字符个数）
min()	返回字符串中ASCⅡ编码值最小的字符
max()	返回字符串中ASCⅡ编码值最大的字符
chr()	返回ASCⅡ编码值对应的字符
ord()	返回字符对应的ASCⅡ编码值

内置函数len

我们向len函数传入一个字符串，它会返回这个字符串的长度（整型）。

str1 = 'hello'
number = len(str1)
print(number)  # 5

内置函数min

我们向min函数传入一个字符串，它会返回这个字符串中ASCⅡ编码值最小的字符。

str1 = 'hello'
string = min(str1)
print(string)  # e

内置函数max

我们向max函数传入一个字符串，它会返回这个字符串中ASCⅡ编码值最大的字符。

str1 = 'hello'
string = max(str1)
print(string)  # o

内置函数chr

我们向chr函数传入一个整数（范围0~127），它会返回这个整数在ASCⅡ表中对应的字符。

string = chr(65)
print(string)  # A

内置函数ord

我们向ord函数传入一个字符，它会返回这个字符在ASCⅡ表中对应的数值。

string = ord('?')
print(string)  # 63

字符串类内置函数

字符串类内置函数是在字符串这个类型中定义的函数，所以想要使用这些函数，前提是使用的对象必须是一个字符串。使用的方式为string.xxx()，也可以用这种方式str.xxx(string)，但前面一种写法更简单。string表示一个字符串，它属于字符串类型，它是由字符串这个类实例化出来的实例，它可以使用字符串类中定义的所有方法。xxx就是字符串类中所定义的任意方法，str是python中的字符串类，我们要使用字符串类中的方法本该写成str.xxx(string)。但是python允许一个类的实例直接使用类中的方法，所以我们可以写成string.xxx()，而且这种写法更简单。

字母大小写变换

内置函数lower

lower函数，它会把这个字符串中的所有大写字母变成小写字母得到一个新的字符串，再把变换后的新字符串返回。

str1 = 'HELLO'
print(str1.lower())  # hello

内置函数upper

upper函数，它会把这个字符串中的所有小写字母变成大写字母得到一个新的字符串，再把变换后的新字符串返回。

str1 = 'hello'
print(str1.upper())  # HELLO

内置函数swapcase

swapcase，它会把这个字符串中的小写字母变成大写字母、大写字母变成小写字母，得到一个新的字符串，再把变换后的新字符串返回。

str1 = 'hello WORLD'
print(str1.swapcase())  # HELLO world

内置函数title

title函数，它会把这个字符串中所有单词变成首字母大写的形式得到一个新的字符串，再把变换后的新字符串返回。

str1 = 'hello WORLD'
print(str1.title())  # Hello World

内置函数capitalize

capitalize函数，它会把这个字符串中第一个单词首字母大写其余字母小写得到一个新的字符串，再把变换后的新字符串返回。

str1 = 'hello WORLD'
print(str1.capitalize())  # Hello world

对齐与填充

内置函数ljust

我们给ljust函数传入一个整数n，n表示新字符的最小字符个数。当字旧符串的宽度大于n时，会以旧字符串的宽度为准；当对象的宽度小于n时，会在旧字符串的后方填充空格补位，变成靠左对齐。再把变换后的新字符串返回。

str1 = 'hello world'
print(f"{str1.ljust(5)}!")  # hello world!
str2 = 'hello world'
print(f"{str2.ljust(15)}!")  # hello world    !

内置函数rjust

我们给rjust函数传入一个整数n，n表示新字符的最小字符个数。当字旧符串的宽度大于n时，会以旧字符串的宽度为准；当对象的宽度小于n时，会在旧字符串的前方填充空格补位，变成靠右对齐。再把变换后的新字符串返回。

str1 = 'hello world'
print(f"{str1.rjust(5)}!")
str2 = 'hello world'
print(f"{str2.rjust(15)}!")

执行结果如下：

内置函数center

我们给center函数传入一个整数n，n表示新字符的最小字符个数。当字旧符串的宽度大于n时，会以旧字符串的宽度为准；当对象的宽度小于n时，会在旧字符串的两边填充空格补位，变成居中对齐。再把变换后的新字符串返回。

str1 = 'hello world'
print(f"{str1.center(5)}!")
str2 = 'hello world'
print(f"{str2.center(15)}!")

执行结果如下：

内置函数zfill

我们给zfill函数传入一个整数n，n表示新字符的最小字符个数。当字旧符串的宽度大于n时，会以旧字符串的宽度为准；当对象的宽度小于n时，会在旧字符串的前方填充字符'0'补位，变成居右对齐。再把变换后的新字符串返回。

str1 = 'hello world'
print(f"{str1.zfill(5)}!")  # hello world!
str2 = 'hello world'
print(f"{str2.zfill(15)}!")  # 0000hello world!

替换与插入

内置函数replace

函数replace能接收3个参数，第一个参数为要被替换的字符，第二个参数为替换字符，第三个参数为替换字符的个数。它能把字符串中的一些相同的字符替换成其他字符。再把替换后的新字符串返回。

str1 = 'aaaaaaaabb'
print(str1.replace('a', 'x', 3))  # xxxaaaaabb

如果不传入第三个参数时，会默认把所有需要替换的字符都替换了。

str1 = 'aaaaaaaabb'
print(str1.replace('a', 'x'))  # xxxxxxxxbb

内置函数join

我们给join函数传入一个字符串，它能把旧字符串插入到传入的字符串每个字符之间，从而组合成一个新的字符串，并返回新字符串。

str1 = 'aaaaaaaa'
print(str1.join('xxx'))  # xaaaaaaaaxaaaaaaaax

字符串转列表

内置函数split

函数split接收两个参数，第一个参数为分割字符串，第二个参数为分割次数。它能把一个字符串分割成多个字符串，并把这些字符串组合成一个列表，最后返回这个列表。

str1 = 'axaxaxaxaxaxaxa'
print(str1.split('x', 3))  # ['a', 'a', 'a', 'axaxaxaxa']

split函数把str1中的前3个'x'作为分隔符，把str1分割成了4个字符串'a'、'a'、'a'和'axaxaxaxa'。最后返回这4个字符串组合成的列表。如果不传入第二个参数时，会默认把所有的分割字符都作用与字符串。字符串中包含n个分割字符就把字符串分割成n+1个字符。

str1 = 'axaxaxaxaxaxaxa'
print(str1.split('x'))  # ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']

内置函数rsplit

rsplit函数的用法跟split差不多，唯一的区别就是：split找分割字符是从左到右找，rsplit找分割字符是从右往左找。

str1 = 'axaxaxaxaxaxaxa'
print(str1.rsplit('x', 3))  # ['axaxaxaxa', 'a', 'a', 'a']

rsplit函数先使用的是右边的3个'x'作为分隔符来分割字符串的。

内置函数splitlines

函数splitlines接收一个参数，参数类型为bool值（True或者Fasle）。splitlines的作用是在一个含有换行符（\n）的字符串中，会把换行符作为分隔符把一个字符串分成多个字符串，并把这些字符串组合成一个列表，最后返回这个列表。

当给splitlines传入True时，被分割的后的字符串中会保留换行符。

str1 = 'hello world\nhello 爆笑蛙\nhello all'
print(str1.splitlines(True))  # ['hello world\n', 'hello 爆笑蛙\n', 'hello all']

当给splitlines传入Fasle或不传入参数时，被分割的后的字符串中不会保留换行符。

str1 = 'hello world\nhello 爆笑蛙\nhello all'
print(str1.splitlines())  # ['hello world', 'hello 爆笑蛙', 'hello all']
str2 = 'hello world\nhello 爆笑蛙\nhello all'
print(str2.splitlines(False))  # ['hello world', 'hello 爆笑蛙', 'hello all']

字符串转三元组

内置函数partition

函数partition接收一个参数，我们给partition传入一个字符串string。当字符串中存在string时，它会从第一个string处把字符串分成3个字符串，第一个字符串为string的前面部分字符，第二个字符串为string，第三个字符串为string后面部分字符。然后把这3个字符串放入一个元组中，组成一个拥有3个元素的元组。最后返回这个三元组。元组也是python中的基本数据类型，我们后面会介绍。

str1 = 'hello666world666'
print(str1.partition('666'))  # ('hello', '666', 'world666')

当字符串中不存在string时，返回的三元组中第一个字符串为字符串本身，第二个字符串为空字符串，第三个字符串为空字符串。

str1 = 'hello666world666'
print(str1.partition('1'))  # ('hello666world666', '', '')

去除某种字符串

内置函数strip

函数strip可以接收一个参数，我们给strip函数传入一个字符串string，它会把旧字符串中左边和右边的string都去掉变成一个新的字符串。最后返回新字符串。

str1 = 'xxhello worldxx'
print(str1.strip('x'))  # hello world

当我们不给strip函数传入参数时，strip函数会去掉字符串左右两边的空格和换行符。

str1 = ' \nhello world \n'
print(str1.strip())  # hello world

执行结果如下：

内置函数lstrip

函数lstrip可以接收一个参数，我们给lstrip函数传入一个字符串string，它会把旧字符串中左边的string都去掉变成一个新的字符串。最后返回新字符串。

str1 = 'xxhello worldxx'
print(str1.lstrip('x'))  # hello worldxx

当我们不给lstrip函数传入参数时，lstrip函数会去掉字符串左边的空格和换行符。

str1 = ' \nhello world \n'
print(str1.lstrip())

执行结果如下：

内置函数rstrip

函数rstrip可以接收一个参数，我们给rstrip函数传入一个字符串string，它会把旧字符串中右边的string都去掉变成一个新的字符串。最后返回新字符串。

str1 = 'abhello worldabab'
print(str1.rstrip('ab'))  # abhello world

当我们不给rstrip函数传入参数时，rstrip函数会去掉字符串右边的空格和换行符。

str1 = ' \nhello world \n'
print(str1.rstrip())

执行结果如下：

查找某种字符串位置

内置函数find

函数find可以接收3个参数，第一个参数为要查找的字符串string，第二个参数为切片起始位置，第三个参数为切片结束位置。所以后面两个参数合起来就是一个切片范围，find函数就在这个切片范围中去查找string，能找到时返回第一个字符的正序索引下标，找不到时返回整型-1。后面两个参数也可以不传入，当不传入时第二个参数默认为0第三个参数默认为字符串长度，就是在整个字符串中去查找string。

str1 = 'hello_world'
print(str1.find('o_'))  # 4
str2 = 'hello_world'
print(str2.find('o_', 0, 4))  # -1

内置函数rfind

函数rfind的使用方式与函数find相似，只不过rfind是从右往左查找，如果右边先出现string，则返回右边第一个字符的正序索引下标。

str1 = 'hello_world_o_'
print(str1.rfind('o_'))  # 11
str2 = 'hello_world_o_'
print(str2.rfind('o_', 5, 11))  # -1

内置函数index

函数index的使用方式和函数find相似，作用也一样，都是返回第一个字符正序索引下标。只不过函数index在找不到字符串时会报错。

str1 = 'hello_world'
print(str1.index('o_', 0, 4))

执行结果如下：

当index找不到字符串时就会抛出异常。

内置函数rindex

函数rindex的使用方式与函数index相似，只不过rindex是从右往左查找，如果右边先出现string，则返回右边第一个字符的正序索引下标。

str1 = 'hello_world_o_'
print(str1.rindex('o_'))  # 11

统计某种字符串个数

内置函数count

函数count可以接收3个参数，第一个参数为要统计个数的字符串string，第二个参数为切片起始位置，第三个参数为切片结束位置。所以后面两个参数合起来就是一个切片范围，count函数就在这个切片范围中去查找string，能找到时返回string的个数，找不到时返回0。后面两个参数也可以不传入，当不传入时第二个参数默认为0第三个参数默认为字符串长度，就是在整个字符串中去统计string的个数。

str1 = 'hello_word hello world!'
print(str1.count('hello'))  # 2
str2 = 'hello_word hello world!'
print(str2.count('hello', 0, 3))  # 0

检测字符串中字符的类型

内置函数isalnum

函数isalnum是用来检测字符串中是否只存在字母或数字，只存在字母或数字时返回True，存在除字母和数字以外的字符时返回False。

str1 = 'hello222'
print(str1.isalnum())  # True
str2 = 'hello'
print(str2.isalnum())  # True
str3 = '123456'
print(str3.isalnum())  # True
str4 = '33hello_!'
print(str4.isalnum())  # False

内置函数isalpha

函数isalpha是用来检测字符串中是否只存在字母，只存在字母时返回True，存在除字母以外的字符时返回False。

str1 = 'hello222'
print(str1.isalpha())  # False
str2 = 'hello'
print(str2.isalpha())  # True
str3 = 'hello_!'
print(str3.isalpha())  # False

内置函数islower

函数islower是用来检测字符串中的字母是否都是小写字母，字母都是小写字母时返回True，存在大写字母或没有小写字母时返回False。

str1 = 'hello222_!'
print(str1.islower())  # True
str2 = '123456'
print(str2.islower())  # False
str3 = 'ABCabc'
print(str3.islower())  # False

内置函数isupper

函数isupper是用来检测字符串中的字母是否都是大写字母，字母都是大写字母时返回True，存在小写字母或没有大写字母时返回False。

str1 = 'HELLO222_!'
print(str1.isupper())  # True
str2 = '123456'
print(str2.isupper())  # False
str3 = 'ABCabc'
print(str3.isupper())  # False

内置函数istitle

函数istitle是用来检测字符串中的单词是否都是首字母大写的形式，单词都是首字母大写的形式时返回True，存在单词不是首字母大写的形式或没有单词时返回False。

str1 = 'Hello_World!'
print(str1.istitle())  # True
str2 = '123456'
print(str2.istitle())  # False
str3 = 'Hello WORLD'
print(str3.istitle())  # False

内置函数isdigit

函数isdigit是用来检测字符串中是否只存在数字，只存在数字时返回True，存在除数字以外的字符时返回False。

str1 = 'hello222'
print(str1.isdigit())  # False
str2 = '123456'
print(str2.isdigit())  # True
str3 = '123_!'
print(str3.isdigit())  # False

内置函数startswith

函数startswith可以接收3个参数，第一个参数为字符串string，第二个参数为切片起始位置，第三个参数为切片结束位置。所以后面两个参数合起来就是一个切片范围，startswith函数就在这个切片范围中去查看是否以string开头，是以string开头时返回True，不是以string开头时返回False。后面两个参数也可以不传入，当不传入时第二个参数默认为0第三个参数默认为字符串长度，就是在整个字符串中去查看是否以string开头。

str1 = 'Hello_World!'
print(str1.startswith('H'))  # True
str2 = '123456'
print(str2.startswith('2'))  # False
str3 = 'Hello WORLD'
print(str3.startswith('llo', 2, 8))  # True

内置函数endswith

函数endswith与函数stratswith使用方式差不多，子不过endswith是在字符串中查看是否以某个字符串结尾。

str1 = 'Hello_World!'
print(str1.endswith('!'))  # True
str2 = '123456'
print(str2.endswith('3'))  # False
str3 = 'Hello WORLD'
print(str3.endswith('llo', 0, 5))  # True

字符串比较运算符

由于字符串并不像整型或浮点型一样具备真正意义上的数值大小，所以字符串之间的比较是通过字符对应的ASCⅡ值的大小来判定的。两个字符串比较大小，先判断谁的第一个字符ASCⅡ值大，第一个字符大的就大。如果第一个字符一样，则判断谁的第二个字符ASCⅡ值大，第二个字符大的就大。如果第二个字符一样，则判断第三个...依此类推。

ASCⅡ码值对照表

ASCⅡ值	对应字符	ASCⅡ值	对应字符	ASCⅡ值	对应字符	ASCⅡ值	对应字符
0	NUT	32	(space)	64	@	96	`
1	SOH	33	!	65	A	97	a
2	STX	34	"	66	B	98	b
3	ETX	35	#	67	C	99	c
4	EOT	36	$	68	D	100	d
5	ENQ	37	%	69	E	101	e
6	ACK	38	&	70	F	102	f
7	BEL	39	'	71	G	103	g
8	BS	40	(	72	H	104	h
9	HT	41	)	73	I	105	i
10	LF	42	*	74	J	106	j
11	VT	43	+	75	K	107	k
12	FF	44	,	76	L	108	l
13	CR	45	-	77	M	109	m
14	SO	46	.	78	N	110	n
15	SI	47	/	79	O	111	o
16	DLE	48	0	80	P	112	p
17	DC1	49	1	81	Q	113	q
18	DC2	50	2	82	R	114	r
19	DC3	51	3	83	S	115	s
20	DC4	52	4	84	T	116	t
21	NAK	53	5	85	U	117	u
22	SYN	54	6	86	V	118	v
23	TB	55	7	87	W	119	w
24	CAN	56	8	88	X	120	x
25	EM	57	9	89	Y	121	y
26	SUB	58	:	90	Z	122	z
27	ESC	59	;	91	[	123	{
28	FS	60	<	92	\	124	\|
29	GS	61	=	93	]	125	}
30	RS	62	>	94	^	126	~
31	US	63	?	95	_	127	DEL

比较运算符（==）

==用于判断两个字符串是否相等，如果相等返回True，不相等返回False。

str1 = 'Hello_World!'
str2 = 'Hello_World!'
print(str1 == str2)  # True
str3 = 'ab'
str4 = 'bc'
print(str3 == str4)  # False

比较运算符（!=）

!=用于判断两个字符串是否不相等，如果不相等返回True，相等返回False。

str1 = 'Hello_World!'
str2 = 'Hello_World!'
print(str1 != str2)  # False
str3 = 'ab'
str4 = 'bc'
print(str3 != str4)  # True

比较运算符（<）

<用于判断左边的字符串是否小于右边的字符串，如果小于返回True，大于或等于返回False。

str1 = 'ac'
str2 = 'ab'
print(str1 < str2)  # False
str3 = 'ab'
str4 = 'ba'
print(str3 < str4)  # True
str5 = 'aa'
str6 = 'aa'
print(str5 < str6)  # False

比较运算符（>）

>用于判断左边的字符串是否大于右边的字符串，如果大于返回True，小于或等于返回False。

str1 = 'ac'
str2 = 'ab'
print(str1 > str2)  # True
str3 = 'ab'
str4 = 'ba'
print(str3 > str4)  # False
str5 = 'aa'
str6 = 'aa'
print(str5 > str6)  # False

比较运算符（<=）

<=用于判断左边的字符串是否小于等于右边的字符串，如果小于或等于返回True，不小于且不等于（大于）返回False。

str1 = 'ac'
str2 = 'ab'
print(str1 <= str2)  # False
str3 = 'ab'
str4 = 'ba'
print(str3 <= str4)  # True
str5 = 'aa'
str6 = 'aa'
print(str5 <= str6)  # True

比较运算符（>=）

>=用于判断左边的字符串是否大于等于右边的字符串，如果大于或等于返回True，不大于且不等于（小于）返回False。

str1 = 'ac'
str2 = 'ab'
print(str1 >= str2)  # True
str3 = 'ab'
str4 = 'ba'
print(str3 >= str4)  # False
str5 = 'aa'
str6 = 'aa'
print(str5 >= str6)  # True

字符串成员运算符

in	判断某个字符串是否在另一个字符串中，在则返回True，不在则返回False
not in	判断某个字符串是否不在另一个字符串中，不在则返回True，在则返回False

成员运算符（in）

当某个字符串跟另一个字符串中的一段字符串相同时，返回True；找不到一段相同的字符串时，返回False。

str1 = 'hello123world'
str2 = '123'
print(str2 in str1)  # True
str3 = 'abcdefg'
str4 = 'zz'
print(str4 in str3)  # False
str5 = 'aaa'
str6 = 'aaa'
print(str6 in str5)  # True

成员运算符（not in）

当某个字符串在另一个字符串中找不到一段相同的字符串时，返回True；找到相同的字符串时，返回False。

str1 = 'hello123world'
str2 = '1'
print(str2 not in str1)  # False
str3 = 'abcdefg'
str4 = 'z'
print(str4 not in str3)  # True
str5 = 'a'
str6 = 'a'
print(str6 not in str5)  # False

字符串身份运算符

其实不太需要身份运算符来判断两个字符串的内存地址是否一致。因为字符串具有不可变的特性，这就导致了只要两个字符串的值相等，它们的内存地址就是一样的。所以我们完全可以使用==和!=来代替身份运算符在字符串中的作用，但我们不要把==和!=与身份运算符搞混了。==和!=判断的是值是否相等，而身份运算符判断的是内存地址是否相同。对于可变的数据类型来说，即使它们的值相等，它们的内存地址也是不同的。

is	判断左右两边的内存地址是否相同，相同返回True，否则返回False
is not	判断左右两边的内存地址是否不同，不同返回True，否则返回False

身份运算符（is）

is用于判断左右两个对象的内存地址是否相同，如果相同返回True，不同返回False。举个例子，请看下面的代码：

str1 = 'hello_world'
str2 = 'hello_world'
print(id(str1))  # 2126643180976
print(id(str2))  # 2126643180976
print(str1 is str2)  # True

str1和str2都是字符串'hello_world'，因为字符串是不可变的数据类型，所以两个相同的字符串一定取自同一个地方。我们可以使用id函数来查看python中任意对象的内存地址，使用id函数后我们发现str1和str2的内存地址确实是相同的。str1和str2所代表的字符串'hello_world'取自内存中的同一个地方，所以str1 is str2返回True。

str1 = 'hello_world'
str2 = 'abcdefg'
print(id(str1))  # 2177863497392
print(id(str2))  # 2177863497648
print(str1 is str2)  # False

str1是字符串'hello_world'，str2是字符串'abcdefg'。因为字符串str1和str2存放在内存中不同的地方，所以str1 is str2返回False。

身份运算符（is not）

is not用于判断左右两个对象的内存地址是否不同，如果不同返回True，相同返回False。举个例子，请看下面的代码：

str1 = 'hello_world'
str2 = 'hello_world'
print(id(str1))  # 1714277627504
print(id(str2))  # 1714277627504
print(str1 is not str2)  # False

str1和str2都是字符串'hello_world'。因为字符串str1和str2存放在内存中的同一个地方，所以str1 is not str2返回False。

str1 = 'hello_world'
str2 = 'abcdefg'
print(id(str1))  # 2657889138352
print(id(str2))  # 2657889138608
print(str1 is not str2)  # True

str1是字符串'hello_world'，str2是字符串'abcdefg'。因为字符串str1和str2存放在内存中不同的地方，所以str1 is not str2返回True。

GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

[转载]在Windows环境下安装GNU Radio

转自：在Windows环境下安装GNURadio_恐弱智_新浪博客GNU Radio是用Python开发的，大部分开源的工程能够在Linux环境下运行良好，而Windows下却运行的很勉强，而且安装配置都很复杂。GNU Radio算是个例外了，不光提供了Windows的二进制安装，还有比较详细的说明。我是Python小白，所以折腾了好久才弄好，特意记录下来，免得以后再装还折腾。GNU Radio的

GitCode 开源社区

centOS 8 使用dnf安装Docker

DNF是什么？CentOS 8使用YUM软件包管理器版本v4.0.4。现在，该版本使用DNF(已删除YUM)。DNF是软件包管理器。它会在Linux发行版上安装，执行更新并删除软件包。使用DNF安装Docker跳过具有损坏依赖性的程序包一个有效的解决方案是使您的CentOS 8系统使用以下--nobest命令安装最符合条件的版本：sudo dnf install docker...

GitCode 开源社区

定时同步数据库表(mysql+linux+crontab)

sync.sh里面的参数需要改变，ip/username/password/database/tablesync.sh#!/bin/sh# Please change the IP and password of the data source db.# Then change the table name.filename=/home/nington/db/$(date +%Y-%m