3.3 String（字符串）

 3.3.1 字符串索引（下标）

字符串下标是从0开始，也就是说下标为0的那个位置代表第一个字符串的第一个字母。也可以下标为负值，如果下标为-1，则代表字符串倒数的第一个字符，下标为-2则为字符串倒数的第二个字符，其他的以此类推。注意，空格也代表一个字符。

s = "学习Python语言"
print(s[0]) # 结果为学
print(s[-3]) # 结果为n

3.3.2 字符串切片

切片，就是获取当前字符串的某个字符、某一串字符（子串）或者某一些字符。字符串切片的语法格式：

1. str[开始:结尾]，取值结果：取左不取右。步长默认为1
2. str[开始:结尾:步长]，取值结果：取左不取右。在确定开始和结尾位置时，步长用来间隔取确定范围内的字符。

s = "学习Python语言"
print(s[0:3]) #结果为学习P
print(s[:3]) #结果也为学习P
print(s[:])  #切片整个字符串，结果为学习Python语言
#注意负值的存在
print(s[-1:-3])  #没有结果
print(s[-3:-1])  #结果为n语
print(s[-3:]) #结果为n语言
#加上步长，s[开始:结束:步长]
"""
s[0:6]也就是开始和结尾确定的字符串是：学习Pyth，对应下标为0 1 2 3 4 5
步长为2的意思就是间隔2步取字符，对应取到的下标为：0 2 4
"""
print(s[0:6:2]) #所以结果为：学Pt
#负值和步长
print(s[-6:-1]) #结果为thon语，下标为：-6 -5 -4 -3 -2
print(s[-6:-1:2]) #结果：to语，步长为2，间隔2步取字符，对应下标为：-6 -4 -2
print(s[::-1]) #结果为:言语nohtyP习学,反转字符串

3.3.3 字符串的拼接

• 利用加号（+）直接拼接。

a = "name:" + "Emily"
print(a) #结果为name:Emily
b = "100" + "1"
print(b) #结果为1001

•  join()函数，语法规则： ‘sep’.join(sequence)，sep是间隔符，可以为空。sequence作为要连接的元素序列、字符串、元组、字典。返回值：返回一个以分隔符sep连接各个元素后生成的字符串。

#利用join()函数
a = "Emily"
b = "我叫"
c = "很高心认识你"
d = ','.join((a,b,c) #输出结果为：我叫,Emily,很高心认识你

 3.3.4 字符串的格式化

format()作为Python的的格式字符串函数，主要通过字符串中的花括号{}，来识别替换字段，从而完成字符串的格式化。 

'{position/key:fill,align,sign,width,precision,type}'.format(str)

• position/key就是一个萝卜一个坑，指定从占位符处从format函数的参数调用相应的值
• fill参：数用于指定填充符,默认值为空格，实际经验是，很少有场景会用到这个参数，除非是按照国际通用的三位一个逗号分隔数字等场景。
• align参数：对齐方式 >（右对齐） <（左对齐） ^（居中对齐）
• sign参数：是否保留正负号，+（正数保留正号）、-（负数保留负号）、空格（正号留空，负号保留负数）。
• width参数：width参数控制输出的长度，该长度为最小长度，即当设定的width参数小于format中调用的值时，不生效；而当设定值大时，会用空格（默认）或零进行填补，如果想要用0进行填补，那么需要在width前添加0。
• precision参数：和%方法中一样，如%.3f表示保留小数点三位小数，用【.保留有效数字位数（f）】表示数据的精确度，如果添加f，则表明保留的为小数点后位数，如果不加，则表示保留的是有效数字位数。

# --------1.position/key
print('我的名字叫{}，今年{}岁。'.format('Emily','18'))
#也可以利用键值对表示如下
print('我的名字叫{a}，今年{b}岁。'.format(a='Emily',b='18'))
dic = {'name':'Emily','age':'18'} #字典
print('我的叫{name}，今年{age}岁。'.format(**dic))
# --------2.fill
print('{:,}'.format(123456789)) #结果为123,456,789
# --------3.align
print('{:<20}'.format('123')) #结果为：123                 
print('{:>20}'.format('123')) #结果为：                 123
# --------4.sign
print('{0:+} {0:-} {0: }'.format(123)) #结果为：+123 123  123
print('{0:+} {0:-} {0: }'.format(-123)) #结果为：-123 -123 -123
# --------5.width
print('{0:10} {0:04} {0:3}'.format(123)) #依次为10位宽空格填补、4位宽0填补、3位宽
# 结果为：        123 0123 123
print('{0:<010},{0:>010},{0:^010} '.format(123)) #结果为：1230000000,0000000123,0001230000 
# --------6.precision
print('{:.1f}'.format(123.456789)) #结果为123.5（自动四舍五入）
print('{0:.1f},{0:.6f},{0:.3},{0:.4%} '.format(123.456789)) 
#结果为：123.4,123.456789,1.23e+02,12345.6789% 
#上述结果分别对应的是：小数点后保留1位，小数点后保留6位，科学计数法表示，百分比形式保留4位

 注意：在s1.format(s2)这个格式中，如果s1只有一个{}（坑）、s2有1个或多个元素（萝卜），s1可以写成'{:.1f}'冒号前面可以不写0，但如果s1有多个{}（坑），那就需要写0，不然会报错。如果s2有多个元素，s1有权选择哪个萝卜进坑。例：'我想要第二个萝卜{1:.2f}'.format(123.45,456.78)此时，打印输出的结果为：我想要第二个萝卜456.78。（s2中下标从0开始）

在 precision参数中，利用了比较传统的格式化输出：%，所以在这里简单列出一些格式化表示方法

% 百分号格式化	含义	例子
%c	输出Ascii码对应的字符	print('%c' %80)（结果为：P）
%s	字符占位符	print('%s' %Emily)
%d	数值类型占位符	print('%d' %40)
%f	浮点类型占位符	print('%f' %1.23)（默认输出六位小数）              print('.2f' %1.234)（保留2位小数）
%o	八进制	print('%o' %40) 结果为：50
%x	十六进制	print('%x' %12) 结果为：c
%X	十六进制（大写字母）	print('%X' %12) 结果为：C
%e	浮点数科学计数法	print('%e' %123.456) 结果为：1.234560e+02
%E	浮点数科学计数法（大写E）	print('%E' %123.456) 结果为：1.234560E+02

3.4.5 F/f表达式

F/f表达式可以解析任意类型的数据。

#------变量类型
name = 'Emily'
age = '18'
s1 ='我的名字叫{}，今年{}岁。'.format(name,age)
print(s1)
s2 = F'我的名字叫{name}，今年{age}岁。'
print(s2) #结果都为：我的名字叫Emily，今年18岁。

#------浮点类型
a = 1
b = 7
s3 = F"a/b浮点数为：{'%.3f' %(a/b)}"
print(s3) #结果为：a/b浮点数为：0.143、

#------列表类型
str_list = [1, 2, 3, 'a', ['b', 'c', 'd']]
str1 = F"列表值：{str_list[0]}、{str_list[3]}、{str_list[4][0]}"
print(str1) #结果为：列表值：1、a、b

#------元组类型
str_tuple = (1, 2, 3, 'a')
str2 = F"元组值：{str_tuple[1]}、{str_tuple[3]}"
print(str2) #结果为：元组值：2、a

#------字典类型
str_dict = {'name': 'zhangs', 'age': 18, 'sex': '女'}
str3 = F"姓名:{str_dict['name']}\n年龄:{str_dict['age']}\nsex:{str_dict['sex']}"
print(str3)
"""
结果为：
姓名:zhangs
年龄:18
sex:女
"""

3.4.6 字符串的一些常用方法

• find('要找的字符串片段',起始点,终止位置)：查找规则为从左往右查询字符或字符串在字符串中第一次出现的位置起始点、终止位置不写默认从0开始到字符串最后位置结束。如果查找字符串存在多个，查找结果为第一个出现的字符串下标，找不到返回-1。
• rfind('要找的字符串片段',起始点,终止位置) ：查找规则从右往左查询字符或字符串在字符串中第一次出现的位置，如果没有则会返回-1。
• count()：统计子串在字符串中出现的次数，找不到返回0。
• replace(old_str,new_str,[替换次数])： 用新的字符代替旧的字符。从前往后替换（不写次数默认替换所有的）。
• upper()：将字符全部转换为大写
• lower()：将字符全部转换为小写
• split(['分割点'],分割次数) ：将字符串按照特定的格式进行分割，返回值是一个列表。默认找到所有的分割点进行分割。
• strip([str]) ：清除字符串两侧指定字符串（默认为清除首尾空格）。以及lstrip()清除字符串左边字符串和rstrip() 清除字符串右边字符串。
• capitalize() ：将字符串的首字母转换为大写
• len(str)：字符串的长度（注意是str.len而是len(str)）

# ------find()
s1 = "ab1def123"
#下标：0 1 2 3 4 5 6 7 8
print(s1.find("1")) #结果为：2
print(s1.rfind("1")) 结果为：6
print(s1.rfind("1",0,5)) #结果为：2
# ------count()
s2 = "shhhakojhhw"
print(s2.count("h")) #结果为：5
# ------replace()
s3 = "hello,Python!"
rp = s3.replace('o','O')
print(rp) #结果为：hellO,PythOn!
print(s3.replace('0','O',1)) #结果为：hellO,Python!
# ------upper()
print(s3.upper()) #结果为：HELLO,PYTHON!
# ------lower()
print("HELLO,PYTHON!".lower()) #结果为：hello,python!
# ------split()
s4 = "abc1hjhh1dkq1hhh"
print(s4.split('1')) #结果为：['abc', 'hjhh', 'dkq', 'hhh']
print(s4.split('h')) #结果为：['abc1', 'j', '', '1dkq1', '', '', '']
print(s4.split('1',2)) #结果为：['abc', 'hjhh', 'dkq1hhh']
# ------strip()
s5 = "   sddsjkld   "
print(s5.strip()) #结果为：sddsjkld
print(s5.lstrip()) #结果为：sddsjkld   (右边有空格)
print(s5.rstrip()) #结果为：   sddsjkld(左边有空格)
# -------capitalize()
s6 = 'emily'
print(s6.capitalize()) #结果为：Emily
# -------len()
print(len(s6)) #结果为：5