数据类型-字符串

在python中，字符由单引号，双引号，引起来的形式，称之为字符串。python不支持单字符类型，单个字符在python中也被认为是字符串。python字符串是不可变的。在所有编程语言中，字符串几乎无所不在，编程的本质就是对数据的加工处理，对字符串处理的能力是编程最重要的能力之一。

标准序列操作（索引、切片、加法、乘法、成员资格检查、长度、最小值和最大值）都适用于字符串，但别忘了字符串是不可变的，因此所有的元素赋值和切片赋值都是非法的。

#字符串相加
a = '世界'
b = '你好'
print(a + b)
结果:
世界你好
#字符串相乘
a = '坚强'
print(a * 8)
结果:
坚强坚强坚强坚强坚强坚强坚强坚强
#字符串索引
name = 'meet'
# 索引  0123
print(name[0])
结果:
m
name = 'meet'
# 索引 -4-3-2-1
print(name[-1])
结果:
t
#字符串切片
name = 'meet'
# 索引  0123
print(name[0:3])
结果:
mee
name = 'meet'
# 索引  0123
print(name[0:3:2])
结果:
me
#字符串长度、最大值、最小值、成员资格检查
In [1]: len('nihao')                                                                                   
Out[1]: 5
In [3]: max('aznihao')                                                                                 
Out[3]: 'z'
In [4]: min('aznihao')                                                                                 
Out[4]: 'a'
In [8]: 'i' in 'andcisoaqew'                                                                           
Out[8]: True

设置字符串的格式

传统的方式

Python提供了多种字符串格式设置方法。以前，主要的解决方案是使用字符串格式设置运算符——百分号。这个运算符的行为类似于C语言中的经典函数printf：在%左边指定一个字符串（格式字符串），并在右边指定要设置其格式的值。指定要设置其格式的值时，可使用单个值（如字符串或数字），可使用元组（如果要设置多个值的格式），还可使用字典，其中最常见的是元组。

>>> format = "Hello, %s. %s enough for ya?"
>>> values = ('world', 'Hot')
>>> format % values
'Hello, world. Hot enough for ya?'

上述格式字符串中的%s称为转换说明符，指出了要将值插入什么地方。s意味着将值视为字符串进行格式设置。如果指定的值不是字符串，将使用str将其转换为字符串。

name = input('请输入姓名:')
age = input('请输入年龄:')
job = input('请输入职业:')
hobby = input('请输入爱好:')
msg = '''
------------ info of barry Li ----------
Name  : %s
Age   : %s 
job   : %s 
Hobbie: %s 
------------- end ----------------
'''
print(msg%(name,age,job,hobby))

%d或者%i表示数字格式

name = input('>>>')
s1 = '1234%d'%int(name)
s2 = '1234%i'%int(name)
print(s1)
print(s2)
结果:
>>>89
123489
123489
# %d和%i这种格式化只能用数字来填补占位

%f表示浮点数格式

>>> print("this number is %f") % 100.105
this number is 100.105000
>>> print("this number is %.3f") % 100.105
this number is 100.105  #小数点后3位
>>> print("this number is %.2f") % 100.105  #小数点后2位
this number is 100.11

%%

num = input('>>>')
s= '目前学习进度:%s%%'%num
print(s)
结果:
>>>80
目前学习进度:80%
# 如果我们字符串中想要显示单独的%就需要用来个%%来转义,不然程序会认为那是一个占位

新的字符串格式化方法:format

每个值都被插入字符串中，以替换用花括号括起的替换字段。要在最
终结果中包含花括号，可在格式字符串中使用两个花括号（即{{或}}）来指定。

在最简单的情况下，替换字段没有名称或将索引用作名称。

>>> "{}, {} and {}".format("first", "second", "third") 
'first, second and third' 
>>> "{0}, {1} and {2}".format("first", "second", "third") 
'first, second and third'

索引无需像上面这样按顺序排列。

>>> "{3} {0} {2} {1} {3} {0}".format("be", "not", "or", "to") 
'to be or not to be'

还可以使用关键字参数

>>> from math import pi
>>> "{name} is approximately {value}.".format(value=pi, name="π")
'π is approximately 3.141592653589793.'
>>> "{name} is approximately {value:.2f}.".format(value=pi, name="π") 
'π is approximately 3.14.'

在Python 3.6中，如果变量与替换字段同名，还可使用一种简写。在这种情况下，可使用f字符串——在字符串前面加上f。

>>> from math import e 
>>> f"Euler's constant is roughly {e}." 
"Euler's constant is roughly 2.718281828459045."

再看一个例子：

>>> name = "蔡徐坤" 
>>> print(f'篮球天才{name}')
篮球天才蔡徐坤

打印出花括号

In [13]: "{{这将把花括号打印出来}}".format()                                                           
Out[13]: '{这将把花括号打印出来}'

替换字段由如下部分组成，其中每个部分都是可选的。

• 字段名：索引或标识符，指出要设置哪个值的格式并使用结果来替换该字段。除指定值外，还可指定值的特定部分，如列表的元素。
• 转换标志：跟在叹号后面的单个字符。当前支持的字符包括r（表示repr）、s（表示str） 和a（表示ascii）。如果你指定了转换标志，将不使用对象本身的格式设置机制，而是使用指定的函数将对象转换为字符串，再做进一步的格式设置。
• 格式说明符：跟在冒号后面的表达式（这种表达式是使用微型格式指定语言表示的）。格式说明符让我们能够详细地指定最终的格式，包括格式类型（如字符串、浮点数或十六进制数），字段宽度和数的精度，如何显示符号和千位分隔符，以及各种对齐和填充方式。

字段名部分可使用索引，还可使用句点表示法来访问导入的模块中的方法、属性、变量和函数

>>> fullname = ["Alfred", "Smoketoomuch"]
>>> "Mr {name[1]}".format(name=fullname) 
'Mr Smoketoomuch' 
>>> import math 
>>> tmpl = "The {mod.__name__} module defines the value {mod.pi} for π" 
>>> tmpl.format(mod=math) 
'The math module defines the value 3.141592653589793 for π'

转换标志

In [19]: print("{pi!s} {pi!r} {pi!a}".format(pi="π"))                                                  
π 'π' '\u03c0'

上述三个标志（s、r和a）指定分别使用str、repr和ascii进行转换。函数str通常创建外观普通的字符串版本（这里没有对输入字符串做任何处理）。函数repr尝试创建给定值的Python表示（这里是一个字符串字面量）。函数ascii创建只包含ASCII字符的表示。

转换值类型

#将数值转换成浮点数
>>> "The number is {num:f}".format(num=42) 
'The number is 42.000000'
#将数值转换成二进制
>>> "The number is {num:b}".format(num=42) 
'The number is 101010'
#将数值转换成八进制
>>> "The number is {num:o}".format(num=42)
 'The number is 52'
#将数值转换成十六进制
>>> "The number is {num:x}".format(num=42)                                                        
 'The number is 2a'
#将数值表示为百分比值（乘以100，按说明符f设置格式，再在后面加上%）
>>> "The number is {num:%}".format(num=0.42)                                                      
 'The number is 42.000000%'

宽度、精度和千位分隔符

宽度是使用整数指定的:

>>> "{num:10}".format(num=3)
'         3'
>>> "{num:10}".format(num="Bob")
'Bob       '

精度也是使用整数指定的，但需要在它前面加上一个表示小数点的句点。

>>> from math import *
>>> "{pi:10.2f}".format(pi=pi)
'      3.14'
>>> "将其精确到小数点后3位:{:.3f}".format(5.6786)
'将其精确到小数点后3位:5.679'

实际上，对于其他类型也可指定精度，但是这样做的情形不太常见。

>>> "{:.5}".format("Guido van Rossum")
'Guido'

可使用逗号来指出你要添加千位分隔符。

>>> 'One googol is {:,}'.format(2**32)
'One googol is 4,294,967,296'

同时指定其他格式设置元素时，这个逗号应放在宽度和表示精度的句点之间。

符号、对齐和用 0 填充

在指定宽度和精度的数前面，可添加一个标志。这个标志可以是零、加号、减号或空格，其中零表示使用0来填充数字。

>>> from math import pi
>>> '{:010.2f}'.format(pi)
'0000003.14'

要指定左对齐、右对齐和居中，可分别使用<、>和^。

#左对齐
>>> '{:<10.2f}'.format(pi)
'3.14      '
#居中对齐
>>> '{:^10.2f}'.format(pi)
'   3.14   '
#右对齐
>>> '{:>10.2f}'.format(pi)
'      3.14'

可以使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充。

#用*号字符填充，并左对齐
>>> '{:*>20.2f}'.format(pi)
'****************3.14'
#用*号字符填充，并居中对齐
>>> '{:*^20.2f}'.format(pi)
'********3.14********'
#用*号字符填充，并右对齐
>>> '{:*<20.2f}'.format(pi)
'3.14****************'

总结如图：

字符串格式设置实例

# 根据指定的宽度打印格式良好的价格列表
width = int(input('Please enter width: ')) 
price_width = 10 
item_width = width - price_width 
header_fmt = '{{:{}}}{{:>{}}}'.format(item_width, price_width) 
fmt = '{{:{}}}{{:>{}.2f}}'.format(item_width, price_width) 
print('=' * width) 
print(header_fmt.format('Item', 'Price')) 
print('-' * width) 
print(fmt.format('Apples', 0.4)) 
print(fmt.format('Pears', 0.5)) 
print(fmt.format('Cantaloupes', 1.92)) 
print(fmt.format('Dried Apricots (16 oz.)', 8)) 
print(fmt.format('Prunes (4 lbs.)', 12)) 
print('=' * width)

这个程序的运行情况类似于下面这样：

Please enter width: 50
==================================================
Item                                         Price
--------------------------------------------------
Apples                                        0.40
Pears                                         0.50
Cantaloupes                                   1.92
Dried Apricots (16 oz.)                       8.00
Prunes (4 lbs.)                              12.00
==================================================

字符串方法

字符串的方法太多了，这里只介绍一些最有用的。

1. center

方法center通过在两边添加填充字符（默认为空格）让字符串居中。

>>> '中华人民共和国万岁'.center(40)
'               中华人民共和国万岁                '
>>> '中华人民共和国万岁'.center(40,'*')
'***************中华人民共和国万岁****************'

2. find

方法find在字符串中查找子串。如果找到，就返回子串的第一个字符的索引，否则返回-1。

>>> 'With a moo-moo here, and a moo-moo there'.find('moo')
7
>>> title = "Monty Python's Flying Circus"
>>> title.find('Monty')
0
>>> title.find('Python')
6
>>> title.find('Flying')
15
>>> title.find('Zirquss')
-1

还可指定搜索的起点和终点（它们都是可选的）。

>>> subject = '$$$ Get rich now!!! $$$'
>>> subject.find('$$$')
0
>>> subject.find('$$$',1) #规定起点为1
20
>>> subject.find('!!!')
16
>>> subject.find('!!!',0,16) #指定起点和终点
-1

3. join

join是一个非常重要的字符串方法，其作用与split相反，用于合并序列的元素。

>>> seq = [1,2,3,4,5]
>>> sep = '+'
>>> sep.join(seq)  #尝试合并一个数字列表
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found
>>> seq = ['1','2','3','4','5']
>>> sep.join(seq) #合并一个字符串列表
'1+2+3+4+5'
>>> dirs = '', 'usr','bin','env'
>>> dirs
('', 'usr', 'bin', 'env')
>>> '/'.join(dirs)   #Linux的目录格式
'/usr/bin/env'
>>> print('C:' + '\\'.join(dirs))  #Windows的目录格式
C:\usr\bin\env

所合并序列的元素必须都是字符串。

4. lower和upper

方法lower返回字符串的小写版本

>>> 'Trondheim Hammer Dance'.lower()
'trondheim hammer dance'

方法upper返回字符串的大写版本

>>> 'Trondheim Hammer Dance'.upper()
'TRONDHEIM HAMMER DANCE'

在你编写代码时，如果不想区分字符串的大小写（即忽略大小写的差别），这将很有用。

>>> name = 'Gumby'
>>> names = ['gumby','smith','jones']
>>> if name.lower() in names: print('Found it!')
... 
Found it!

一个与lower相关的方法是title。它将字符串转换为词首大写，即所有单词的首字母都大写，其他字母都小写。

>>> "that's all, folks".title()
"That'S All, Folks"

再看一个具体例子：

# 字符串大小写做验证码
y_z_m = 'O98k'
y_z_m_input = input("请输入验证码(O98k)")
user = input('请输入账号:')
pwd = input('请输入密码:')
if y_z_m == y_z_m_input:
    if user == 'barry' and pwd == '8520':
        print('登陆成功!')
    else:
        print('登录失败')
else:
    print('验证码错误!')

5. replace

方法replace将指定子串都替换为另一个字符串，并返回替换后的结果。

>>> test = 'This is a test'
>>> new_test = test.replace('is','eez')
>>> test
'This is a test'
>>> new_test
'Theez eez a test'
>>> test.replace('is','eez',1) #还可以执行替换的次数
'Theez is a test'

6. split

split是一个非常重要的字符串方法，其作用与join相反，用于将字符串拆分为序列。

>>> str1 = '1+2+3+4+5'
>>> str1.split('+')
['1', '2', '3', '4', '5']
>>> str1
'1+2+3+4+5'
>>> '/usr/bin/env'.split('/')
['', 'usr', 'bin', 'env']
>>> 'Using the default'.split()
['Using', 'the', 'default']

注意，如果没有指定分隔符，将默认在单个或多个连续的空白字符（空格、制表符、换行符等）处进行拆分。

7. strip

方法strip将字符串开头和末尾的空白（但不包括中间的空白）删除，并返回删除后的结果。

>>> ' internal whitespace is kept '.strip()
'internal whitespace is kept'

与lower一样，需要将输入与存储的值进行比较时，strip很有用。假定用户输入用户名时不小心在末尾加上了一个空格。

>>> names = ['gumby', 'smith', 'jones'] 
>>> name = 'gumby ' 
>>> if name in names: print('Found it!') 
... 
>>> if name.strip() in names: print('Found it!') 
... 
Found it! 
>>>

还可在一个字符串参数中指定要删除哪些字符。

>>> '*** SPAM * for * everyone!!! ***'.strip(' *!')
'SPAM * for * everyone'
>>>

这个方法只删除开头或末尾的指定字符，因此中间的星号未被删除。

8. translate

方法translate与replace一样替换字符串的特定部分，但不同的是它只能进行单字符替换。这个方法的优势在于能够同时替换多个字符，因此效率比replace高。这个方法的用途很多（如替换换行符或其他随平台而异的特殊字符）。

使用translate前必须创建一个转换表。要创建转换表，可对字符串类型str调用方法maketrans，这个方法接受两个参数：两个长度相同的字符串，它们指定要将第一个字符串中的每个字符都替换为第二个字符串中的相应字符。

>>> table = str.maketrans('1234','ABCD')
>>> '1234 and 1234 end 1234'.translate(table)
'ABCD and ABCD end ABCD'

调用方法maketrans时，还可提供可选的第三个参数，指定要将哪些字母删除。

>>> table = str.maketrans('1234','ABCD',' ')
>>> '1234 and 1234 end 1234'.translate(table)
'ABCDandABCDendABCD'

判断字符串是否满足特定的条件

很多字符串方法都以is打头，如isspace、isdigit和isupper，它们判断字符串是否具有特定的性质（如包含的字符全为空白、数字或大写）。如果字符串具备特定的性质，这些方法就返回True，否则返回False。

>>> ' 123  '.isspace()
False
>>> 'liudehua'.isdigit()
False
>>> 'liudehua'.isupper()
False
>>> 'Liudehua'.isupper()
False