【漫漫转码路】Python Day 03

一、字符串格式化

为了使输入与输出实现互动，常常会用到格式化的方法；

1、传统格式化方法

传统格式化方法通过占位符，即“%+特定字符”的方式实现，百分号%后面的不同字符代表不同的作用，常见的有：

字符	作用
%s	字符串（不保留字符串格式符号）
%r	字符串（保留字符串格式符号）
%d / %i	整数占位符
%f	浮点占位符
%c	ASCII码及其字符
%e / %E	科学计数法表示
%o	转换为8进制
%x	转换为16进制
%G	保留6位有效数字，整数超出6位则用科学计数法表示

（1）%s及%r的作用

# 例如：
name = input('请输入您的姓名：')
age = input('请输入您的年龄：')
adres = input('请输入您的住址：')
print('%s,您好，您今年%s岁,家住%s' % (name,age,adres))

# 终端显示
请输入您的姓名：Tom
请输入您的年龄：20
请输入您的住址：广场
Tom,您好，您今年20岁,家住广场

注意：%s与%r的区别：%r和%s都是字符串占位符，但是%r会显示字符串的格式符号：

# 例如：
name= 'Tom'
age = 20
adres = '广场'
print('%s,您好，您今年%s岁,家住%s' % (name,age,adres))
print('%r,您好，您今年%r岁,家住%r' % (name,age,adres))

# 终端显示
Tom,您好，您今年20岁,家住广场     # %s显示
'Tom',您好，您今年20岁,家住'广场' # %r显示

（2）%d / %i及%f的作用

# 例如：
PI = 3.1415926
PI1 = 3.14
print ('pi = %d' % PI)
print ('pi = %i' % PI)
print ('pi = %f' % PI)
print ('pi = %f' % PI1)

# 终端显示
pi = 3         # 第一个
pi = 3         # 第二个
pi = 3.141593  # 第三个
pi = 3.140000  # 第四个

注意：
%d是取小数的整数部分，不涉及四舍五入；
%f默认保留小数点后6位小数，如果不足6位默认用0补齐，会四舍五入；

（3）辅助指令

浮点占位符%f默认保留小数点后6位，如果对保留位数及格式有其他要求，我们可以通过辅助指令来实现；

指令	功能
-	左对齐，默认为右对齐
+	如果结果是正数则显示+号
0	数字前面的填充用‘0’，默认为空格
*	最小显示宽度或小数位数
#	显示进制的前缀
m.n	m表示最小显示宽度，n表示小数点后保留位数或字符串个数

# 例如
PI = 3.1415926
print ('p1 = %f' % PI)
print ('p2 = %+f' % PI)        # '+'表示显示正号
print ('p3 = %.2f' % PI)       # m.n单独使用，.n保留n位小数
print ('p4 = %12f' % PI)       # m.n单独使用，最小显示宽度为m
print ('p5 = %8.2f' % PI)      # m.n使用，最小显示宽度为m,保留n位小数
print ('p6 = %-8.2f' % PI)     # '-'表示左对齐
print ('p7 = %08.2f' % PI)     # 最小显示宽度为m,前面用0补齐
print ('p8 = %.*f' % (5, PI))  # '*'的使用,此处同p3
print ('p9 = %*f' % (12, PI))  # '*'的使用,此处同p4

# 终端显示
p1 = 3.141593
p2 = +3.141593     # '+'表示显示正号
p3 = 3.14          # m.n单独使用，.n保留n位小数
p4 =     3.141593  # m.n单独使用，最小显示宽度为m
p5 =     3.14      # m.n使用，最小显示宽度为m,保留n位小数
p6 = 3.14          # '-'表示左对齐
p7 = 00003.14      # 最小显示宽度为m,前面用0补齐
p8 = 3.14159       # '*'的使用,此处同p3
p9 =     3.141593  # '*'的使用,此处同p4

注意： 如果m

# 例如
print('%o' % 12)
print('%#o' % 12)

# 终端输出
14
0o14  # 0o为8进制前缀

2、format格式化方法

（1）format格式化

# 例如
print('他叫{}，今年{}岁，住在{}。'.format('Tom',21,'大桥下'))
print('他叫{2}，今年{1}岁，住在{0}。'.format('大桥下',21,'Tom'))
print('他叫{a3}，今年{a2}岁，住在{a1}。'.format(a1 = '大桥下',a2 = 21,a3 = 'Tom'))
print('他叫{2}，今年{1}岁，住在{0},有个表妹也是{1}岁。'.format('大桥下',21,'Tom'))

# 终端输出
他叫Tom，今年21岁，住在大桥下。  # {}占位
他叫Tom，今年21岁，住在大桥下。  # 支持索引赋值
他叫Tom，今年21岁，住在大桥下。  # 支持关键字赋值 
他叫Tom，今年21岁，住在大桥下,有个表妹也是21岁。  # 支持重复使用

（2）辅助指令

指令	意义
<	左对齐 （后面附带宽度限定）
>	右对齐（后面附带宽度限定）
^	居中（后面附带宽度限定）
:	附带要填充的字符
b	转化为2进制
d	转化为10进制
o	转化为8进制
x	转化为16进制
,	千位分隔符

# 例如
print('{:<8}'.format('1'))
print('{:>8}'.format('1'))
print('{:^8}'.format('1'))
print('{:0^8}'.format('1'))
print('{:b}'.format(10))
print('{:o}'.format(10))
print('{:x}'.format(10))
print('{:.2f}'.format(3.1415926))
print('{:8.2f}'.format(3.1415926))
print('{:<8.2f}'.format(3.1415926))
print('{:a<8.2f}'.format(3.1415926))
print('{:,}'.format(123456789))

# 终端输出
1         # 左对齐，最大长度为8
       1  # 右对齐，最大长度为8
   1      # 居中，最大长度为8
00010000  # 居中，最大长度为8，用0填充
1010      # 将10转换为2进制
12        # 将10转换为8进制
a         # 将10转换为16进制
3.14      # 保留两位小数
    3.14  # 保留两位小数，最大长度为8，默认右对齐
3.14      # 保留两位小数，最大长度为8，左对齐
3.14aaaa  # 保留两位小数，最大长度为8,左对齐，填充为a
123,456,789  # 千位分隔符

3、f-string格式化方法

采用{}占位，并在{}中直接填入替换内容；

# 例如
name = input('请输入您的姓名：')
age = input('请输入您的年龄：')
adres = input('请输入您的住址：')
print(f'他叫{name}，今年{age}岁，家住{adres}。')

# 终端输出
请输入您的姓名：Alex
请输入您的年龄：25
请输入您的住址：终南山
他叫Alex，今年25岁，家住终南山。

注意： f-string格式化方法与format格式化方法的辅助函数用法相同；

二、字符串对象方法

1、str.replace()

str.replace(old,new[,count])：将str中的old替换为new，其中：

参数	意义
old	准备被替换的参数
new	准备替换的参数
count	要替换的最大次数，默认-1，即全部替换

# 例如
str1 = 'hello world'
print(str1.replace('l','x'))

# 终端输出
hexxo worxd

2、str.strip()

str.strip([chars])：将字符串str左右两边删除指定字符串chars；
str.lstrip([chars])：将字符串str从左边开始删除指定字符串chars；
str.rstrip([chars])：将字符串str从右边开始删除指定字符串chars；

# 例如
str1 = 'hello world'
str2 = ' \t hello world \n '
print(str1.strip('h'))
print(str1.strip('hd eol'))
print(str2.strip())
print(str3.lstrip('h'))
print(str3.rstrip('h'))

# 终端输出
ello world
wor
hello world
ello worldh
hello world

注意：
chars如果为字符串，则将字符串中每个字符单独考虑；
如果不传chars，则默认移除l两端/左端/右端空白符（空格，换行，制表）

3、str.center（）

str.center(width[,fillchars])：将指定长度width的字符串中，居中填充str，其余位置填充fillchars：
str.ljust(width[,fillchars])：str居左填充；
str.rjust(width[,fillchars])：str居右填充；

# 例如
str1 = 'hello'
str2 = 'hell'
print(str1.center(10,'0'))
print(str2.center(9,'0'))
print(str2.ljust(9,'0'))
print(str2.rjust(9,'0'))

# 终端输出
00hello000
000hell00
hell00000
00000hell

注意： 如果str为奇数，左边填充更少，如果str为偶数，左边填充更多；

4、str.partition（）

str.partition（sep）:将str以首次出现的sep为间隔，分开形成三部分，三部分组成一个元组（从左往右）；
str.rpartition（sep）:将str以首次出现的sep为间隔，分开形成三部分，三部分组成一个元组（从右往左）；

# 例如
str1 = 'hello world'
print(str1.partition('l'))
print(str1.partition('h'))
print(str1.rpartition('l'))
print(str1.rpartition('rl'))
print(str1.partition('rl'))
print(str1.rpartition('ro'))
print(str1.partition('ro'))

# 终端输出
('he', 'l', 'lo world')
('', 'h', 'ello world')  # 左侧第一个字母，结果出现空字符串
('hello wor', 'l', 'd')  # 从右往左
('hello wo', 'rl', 'd')  # 从右往左，存在的字符串
('hello wo', 'rl', 'd')  # 从左往右，存在的字符串
('', '', 'hello world')  # 从右往左，不存在的字符串
('hello world', '', '')  # 从左往右，不存在的字符串

5、str.startswith（）

str.startswith(prefix[,start[,end]]）：判断str是否以prefix开头，如果是，返回True，否则返回False；
str.endtswith(prefix[,start[,end]]）：判断str是否以prefix结尾，如果是，返回True，否则返回False；

# 例如
str = ' abcdef123'
print(str.startswith('a'))
print(str.startswith(' '))
print(str.endswith('3'))
print(str.endswith('f3d'))
print(str.endswith(('f','3','d')))
print(str.endswith('1',-6,-2))

# 终端输出
False
True
True
False
True
True

注意：
如果start和end不上传，则默认整个字符串；
prefix可以是字符，字符串，元组，如果是元组，则认为元组中任意元素满足均返回True；

6 、str.isalnum（）

str.isalnum（）：判断是否由字母、文字、数字组成
str.isalpha（）：判断是否由文字、字母组成
str.isdigit（）：判断是否由数字组成
str.isspace（）：判断是否由空白符组成

# 例如
str = 'sbj456你好'
str1 = 'sbj 456你好'
str2 = 'nia文字'
str3 = '45685'
str4 = '\t    \n'
str5 = '''
'''
print(str.isalnum())
print(str1.isalnum())
print(str1.isalpha())
print(str2.isalpha())
print(str3.isdigit())
print(str4.isspace())
print(str5.isspace())

# 终端输出
True
False
False
True
True
True
True

7 、str.join（）

str.join（iterable）：将str插入到可迭代对象iterable中，返回一个字符串（字符串、元组，列表、集合、字典均为可迭代对象，数字不是可迭代对象）

# 例如
str = 'F'
str1 = ' '
str2 = '3'
print(str.join('hello'))
print(str1.join(['h','e','l','l','o']))
print(str2.join({'h','e','l','l','o'}))
print(str2.join(('hello')))
print(str2.join(set("China")))

# 终端输出
hFeFlFlFo  # 字符串
h e l l o  # 列表
e3o3h3l    # 字典
h3e3l3l3o  # 元组
i3h3C3a3n  # 集合

8 、str.count（）

str.count(sub,start,end)：sub在str中出现的非重叠次数；

# 例如
str = 'shauebdlaaaaa'
print(str.count('a'))
print(str.count('aa'))
print(str.count('aa',-5,-3))

# 终端输出
6  # a出现的次数
2  # 非重叠次数
1  # 指定切片中sub的出现次数

9 、str.find（）

str.find（sub[,start[,end]]）:从左往右，在str中查找sub在str中第一次出现的索引，如果没有找到，则返回-1；
str.rfind（sub[,start[,end]]）:从右往左find；
str.index（sub[,start[,end]]）:从左往右，在str中查找sub在str中第一次出现的索引，如果没有找到，则报错；
str.rindex（sub[,start[,end]]）:从右往左index；

# 例如
str = 'sha  u354ebdlaa  aa\t4628\n12 354'
print(str.find('a'))
print(str.find('a',2,10))
print(str.find('354'))
print(str.rfind('354'))
print(str.find('9'))
print(str.index('354'))
print(str.rindex('354'))
print(str.index('9'))

# 终端输出
2
2
6
28
-1
6
28
ValueError: substring not found

10 、str.capitalize（）

str.capitalize():首字母大写，其余小写；
str.title():每个单词首字母大写，其余小写（根据空格判断是否一个单词）；
str.upper():所有字符大写；
str.lower():所有字符小写；
str.swapcase():大写变为小写，小写变为大写；

# 例如
str = 'abcd efg h ij k123'
str1 = 'aBcd eFg h iJ k123'
print(str.capitalize())
print(str.title())
print(str.upper())
print(str1.lower())
print(str1.swapcase())

# 终端输出
Abcd efg h ij k123
Abcd Efg H Ij K123
ABCD EFG H IJ K123
abcd efg h ij k123
AbCD EfG H Ij K123

11 、str.split（）

str.split(sep = None,maxsplit=-1):将str用sep分隔，并且形成列表，maxsplit是最大分隔次数，如果不传，默认全部；
str.rsplit(sep = None,maxsplit=-1):将str用sep从右往左分隔；

# 例如
str = 'ajkh slzsi\t1a2z54\n sjalz'
print(str.split('a'))
print(str.split('a',1))
print(str.split())
print(str.rsplit('a'))
print(str.rsplit('a',1))
print(str.rsplit())

# 终端显示
['', 'jkh slzsi\t1', '2z54\n sj', 'lz']
['', 'jkh slzsi\t1a2z54\n sjalz']
['ajkh', 'slzsi', '1a2z54', 'sjalz']
['', 'jkh slzsi\t1', '2z54\n sj', 'lz']
['ajkh slzsi\t1a2z54\n sj', 'lz']
['ajkh', 'slzsi', '1a2z54', 'sjalz']

注意： 如果不传sep，则按所有空白符考虑，即丢弃结果中的所有空白符；

三、列表

列表是序列，用[]表示，是可变的，即在列表中可以直接修改数据，字符串是不可变的；
list([iterable]):用可迭代对象中元素构成一个新的列表，如果不传则返回一个空的列表；

# 例如
print(list()) 
print(list("China")) 
print(list((1, 2, 3))) 
print(list({1: 2, 3: 4})) 
print(list({1, 2, 3, 4})) 

# 终端输出
[]
['C', 'h', 'i', 'n', 'a']
[1, 2, 3]
[1, 3]
[1, 2, 3, 4]

list增删改查

# 例如
list1 = [1,2,3,4,5,6,78,9]
list1[5] = 99  # 索引替换单个
print(list1)
list1[2:4] = [11,12]  # 切片替换多个
print(list1)
list1[6:] = '文','字'  # 切片替换多个
print(list1)
list1[8:] = 'yi'  # 切片增加多个，字符串中每个元素单独成为列表的元素，增加前列表总长度为8
print(list1)
list1[8:] = 'y'  # 多对一，可以删除列表数据
print(list1)
list1[0] = 'ab'  # 一对一，插入字符串
print(list1)
list1[0] = 33,44 # 一对多，插入元组
print(list1)
list1[0:1] = 'abcd'  # 切片一对多，插入多个字符
print(list1)

# 终端显示
[1, 2, 3, 4, 5, 99, 78, 9]
[1, 2, 11, 12, 5, 99, 78, 9]
[1, 2, 11, 12, 5, 99, '文', '字']
[1, 2, 11, 12, 5, 99, '文', '字', 'y', 'i']
[1, 2, 11, 12, 5, 99, '文', '字', 'y']
['ab', 2, 11, 12, 5, 99, '文', '字', 'y']
[(33, 44), 2, 11, 12, 5, 99, '文', '字', 'y']
['a', 'b', 'c', 'd', 2, 11, 12, 5, 99, '文', '字', 'y']