wk_02

Python 序列

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['java','C','C++','Python']

列表元素的查看

Python中列表的正数索引是从0开始（表示第一个元素），之后是往后递加，负数索引是-1（最后一个元素），往前递减。若超出列表中定义的索引则报IndexError错误。

In [10]: list[1]
Out[10]: 'C'

In [11]: list[-1]
Out[11]: 'Python'

列表元素的修改

In [13]: list
Out[13]: ['java', 'C', 'C++', 'Python']

In [14]: list[0]='PHP'

In [15]: list
Out[15]: ['PHP', 'C', 'C++', 'Python']

同理索引也可以使用负数，同时在修改元素时不管使用正数或负数索引一旦超过索引的范围也会出现IndexError的错误。

列表的方法

列表元素的添加

append方法

append() 方法用于在列表末尾添加新的对象。

In [22]: list.append('java')

In [23]: list
Out[23]: ['PHP', 'C', 'C++', 'Python', 'java']

append是在列表的最后增加指定的元素，若想在指定的位置添加元素需要使用insert方法。append的方法的返回值是None。

insert方法

insert() 函数用于将指定对象插入列表的指定位置。

In [24]: list.insert(2,'C#')

In [25]: list
Out[25]: ['PHP', 'C', 'C#', 'C++', 'Python', 'java']

In [26]: list.insert(22222,'JavaScirpt')

In [27]: list
Out[27]: ['PHP', 'C', 'C#', 'C++', 'Python', 'java', 'JavaScirpt']

insert方法中若操作的索引超出范围，如果是正索引等效于append，如果是负索引，则等效于insert(0, object)

extend方法

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

In [28]: list.extend(['Perl','Ruby'])

In [29]: list
Out[29]: ['PHP', 'C', 'C#', 'C++', 'Python', 'java', 'JavaScirpt', 'Perl', 'Ruby']

批量在列表最后一个元素添加。

列表元素的删除

pop方法

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

In [30]: list.pop()
Out[30]: 'Ruby'

In [32]: list
Out[32]: ['PHP', 'C', 'C#', 'C++', 'Python', 'java', 'JavaScirpt', 'Perl']

pop后不加索引则删除列表最后一个元素，同时也可以删除指定索引下标的元素，若删除的索引下标超出了列表的范围则会抛出IndexError错误。

remove方法

remove() 函数用于移除列表中某个值的第一个匹配项。

In [38]: list.append('Python')

In [39]: list
Out[39]: ['PHP', 'C', 'C#', 'C++', 'Python', 'java', 'JavaScirpt', 'Perl', 'Python']

In [42]: list.remove('Python')

In [43]: list
Out[43]: ['PHP', 'C', 'C#', 'C++', 'java', 'JavaScirpt', 'Perl', 'Python']

虽然pop和remove都有删除的功能，但是两者还是有一定的区别的。pop 是弹出索引对应的值，remove是删除最左边的一个值。pop针对的是索引，remove针对的是值 。
列表元素的删除除了上面两种方法以外还可以使用del函数进行删除，下面是使用举例。

In [49]: del list[-1]

In [50]: list
Out[50]: ['PHP', 'C', 'C#', 'C++', 'java', 'JavaScirpt', 'Perl']

clear方法

In [54]: list.clear()

In [55]: list
Out[55]: []

使用clear是删除列表中所有的元素，请谨慎使用。

列表元素的查找/统计

index方法

index() 函数用于从列表中找出某个值第一个匹配项的索引位置。

In [33]: list
Out[33]: ['PHP', 'Python', 'C', 'C#', 'C++', 'java', 'JavaScirpt', 'Perl', 'Python']

In [34]: list.index('Python')
Out[34]: 1

In [35]: list.index('Python',1)
Out[35]: 1

In [36]: list.index('Python',2)
Out[36]: 8

In [41]: list.index('Python',2,10)
Out[41]: 8

通过上面的例子看出直接查找元素所对应的索引很容易理解，但是要是在指定的索引位置查找需要说明一下：若后面只是一个数字则以此数字为第一个索引进行查询，返回从此索引之后最近的一个匹配元素索引的索引值。若没有则返回ValueError 的错误。同时我们还可以指定区间，例如list('example',start,stop)，则表示包含start，不包含stop的元素。

count

count() 方法用于统计某个元素在列表中出现的次数。

In [44]: list.count('Python')
Out[44]: 2

In [45]: list.count('C')
Out[45]: 1

In [46]: list.count('c')
Out[46]: 0

count方法是统计元素在列表出现的次数，若统计的元素在列表中没有出现则输出是0.

列表元素的修改

sort

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

In [49]: list
Out[49]: ['PHP', 'Python', 'C', 'C#', 'C++', 'java', 'JavaScirpt', 'Perl', 'Python']

In [50]: list.sort()

In [51]: list
Out[51]: ['C', 'C#', 'C++', 'JavaScirpt', 'PHP', 'Perl', 'Python', 'Python', 'java']

In [53]: list.sort(reverse=True)

In [54]: list
Out[54]: ['java', 'Python', 'Python', 'Perl', 'PHP', 'JavaScirpt', 'C++', 'C#', 'C']

通过sort可以以ASCII码进行正序排序，若想倒序可以用reverse=True参数。

reverse

reverse() 函数用于反向列表中元素。

In [76]: list
Out[76]: ['java', 'Python', 'Python', 'Perl', 'PHP', 'JavaScirpt', 'C++', 'C#', 'C']

In [77]: list.reverse()

In [78]: list
Out[78]: ['C', 'C#', 'C++', 'JavaScirpt', 'PHP', 'Perl', 'Python', 'Python', 'java']

In [79]: list.reverse()

In [80]: list
Out[80]: ['java', 'Python', 'Python', 'Perl', 'PHP', 'JavaScirpt', 'C++', 'C#', 'C']

reverse只是反向修改列表的内容，并不进行排序，这个需要注意。

其他方法

copy

In [87]: lst = [2,4,5,2,4,5]

In [88]: lst2 = lst

In [89]: lst2.remove(2)

In [90]: lst2
Out[90]: [4, 5, 2, 4, 5]

In [91]: lst
Out[91]: [4, 5, 2, 4, 5]

In [92]: id(lst)
Out[92]: 140691016809864

In [93]: id(lst2)
Out[93]: 140691016809864

直接通过赋值的方法将列表的值复制到新列表中这么操作由于两个指向同一个内存所以两者其实就像是Linux系统中硬链接一样。若想得到不同的内存空间可以使用copy方法。

In [99]: lst
Out[99]: [4, 5, 2, 4, 5]

In [100]: lst3 = lst.copy()

In [101]: lst3
Out[101]: [4, 5, 2, 4, 5]

In [102]: lst3.remove(5)

In [103]: lst3
Out[103]: [4, 2, 4, 5]

In [104]: lst
Out[104]: [4, 5, 2, 4, 5]

In [105]: id(lst3)
Out[105]: 140691016808904

In [106]: id(lst)
Out[106]: 140691016809864

列表函数

len()

len() 方法返回列表元素个数。

In [116]: list
Out[116]: ['java', 'Python', 'Perl', 'PHP', 'JavaScirpt', 'Python', 'C++', 'C#']

In [117]: len(list)
Out[117]: 8

max()

max() 方法返回列表元素中的最大值。

In [118]: max(list)
Out[118]: 'java'

min()

min() 方法返回列表元素中的最小值。

In [119]: min(list)
Out[119]: 'C#'

列表的切片

常规使用

Python的切片非常灵活，使用的格式是lst[start:end:step]，其中start是起始的索引，包含此索引的元素，end是最后一个索引，不包含此元素，step是跳过的索引下标。下面就具体使用进行举例：

In [2]: lst1
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: lst1[2:5]
Out[3]: [2, 3, 4]

In [4]: lst1[5:2]
Out[4]: []

In [5]: lst1[-4:-2]
Out[5]: [6, 7]

In [6]: lst1[-2:-4]
Out[6]: []

上面可以看出step是可以省略的，默认是1，同时若从左往右切片， start要小于end。若start大于end则返回一个空列表。

In [7]: lst1[4:2222]
Out[7]: [4, 5, 6, 7, 8, 9]

In [8]: lst1[-11111:2]
Out[8]: [0, 1]

In [9]: lst1[-11111:222222]
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [10]: lst1[-11111:]
Out[10]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [11]: lst1[:22222]
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [12]: lst1[:]
Out[12]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [13]: lst1[4:len(lst1)]
Out[13]: [4, 5, 6, 7, 8, 9]

从上面可以看出，start 超出索引范围从0开始，end 超出索引范围到len(lst) 结束。同时省略start则索引也是从0开始，省略end则索引到en(lst) 结束。若全部省略则返回整个列表。

In [15]: lst1[2:10:2]
Out[15]: [2, 4, 6, 8]

In [18]: lst1[-2:-10:-2]
Out[18]: [8, 6, 4, 2]

当step是正数时从前往后数则start小于end，当step是负数时候从后往前数则start大于end。否则会返回空列表。

In [32]: lst1
Out[32]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [33]: lst1[::2]
Out[33]: [0, 2, 4, 6, 8]

In [34]: lst1[::-2]
Out[34]: [9, 7, 5, 3, 1]

In [36]: lst1[2::-2]
Out[36]: [2, 0]

In [37]: lst1[:2:-2]
Out[37]: [9, 7, 5, 3]

上面是通过省略start、end、step中任意一个得到的结果，可以发现切片使用很灵活，需要多练习才能掌握好这个强大的功能。

深入学习

In [55]: lst1
Out[55]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [56]: lst1[::2][::-1]
Out[56]: [8, 6, 4, 2, 0]

上面过对切片后的列表在进行一次切片也是一个小技巧。

In [61]: lst1
Out[61]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [62]: lst1[3:5]=['x','y']

In [63]: lst1
Out[63]: [0, 1, 2, 'x', 'y', 5, 6, 7, 8, 9]

In [64]: lst1=list(range(0,10))

In [66]: lst1[3:5]=['x','y','z']

In [67]: lst1
Out[67]: [0, 1, 2, 'x', 'y', 'z', 5, 6, 7, 8, 9]

In [68]: lst1=list(range(0,10))

In [69]: lst1[3:5]=['x']

In [70]: lst1
Out[70]: [0, 1, 2, 'x', 5, 6, 7, 8, 9]

对切片复制，会替换切片原来的元素。

In [73]: lst1
Out[73]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [74]: lst1[3:7:2]
Out[74]: [3, 5]

In [76]: lst1[3:7:2]=['x','y']

In [77]: lst1
Out[77]: [0, 1, 2, 'x', 4, 'y', 6, 7, 8, 9]

对于切片后连续的元素我们进行赋值时没有强制的语法，而多切片后的元素不是连续的则我们进行赋值时赋值的个数必须和切片后的元素个数一致，若不一致则报ValueError的错误。

列表的封包和解包

In [1]: head,*tail=list(range(0,10))

In [2]: head
Out[2]: 0

In [3]: tail
Out[3]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

上面是基本的解包操作，head是取得第一个元素，剩下的元素全部分给tail。

In [12]: head,*tail=[2]

In [13]: tail
Out[13]: []

我们的解包变量有两个而列表中数据只有一个的时候，第二个会是一个空列表。

In [16]: head,*min,tail=list(range(0,10))

In [17]: min
Out[17]: [1, 2, 3, 4, 5, 6, 7, 8]

例子。

In [20]: lst1
Out[20]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [21]: a,b,_,_,c,*_,d=lst1

In [22]: a
Out[22]: 0

In [23]: b
Out[23]: 1

In [24]: c
Out[24]: 4

In [25]: d
Out[25]: 9

_符号是丢弃一个元素，而*_符号是丢弃多个元素。

In [28]: lst2=[1,[2,3,4,5],6]

In [29]: _,(a,*_,c),d=lst2

In [30]: a
Out[30]: 2

In [31]: c
Out[31]: 5

In [32]: d
Out[32]: 6

In [42]: lst3=(1,2,[3,4,5],6,7)

In [43]: _,a,(b,*_,),*_,c=lst3

In [44]: a
Out[44]: 2

In [45]: b
Out[45]: 3

In [46]: c

针对复杂的列表我们也可以解包进行操作。

列表的成员运算

通过下面的一个例子说明一下列表成员运算符的使用：

In [41]: lst2
Out[41]: [3, 4, 5, 3, 6, 3, 4, 8, 5]

In [42]: new_list=[]

In [44]: for i in lst2:
                if i not in new_list:
                    new_list.append(i)

In [45]: new_list
Out[45]: [3, 4, 5, 6, 8]

In [48]: 2 in lst2
Out[48]: False

In [49]: 3 in lst2
Out[49]: True

通过上面的例子可以将一个列表中重复的元素给去除，注意if 语句中使用的in是成员运算，而for 语句中的in 不是成员运算。同是成员运算取得的结果是布尔值这个需要注意。

元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

初始化元组

In [8]: tup1 = ('C','java','Python')

In [9]: tup1
Out[9]: ('C', 'java', 'Python')

创建空元组

In [11]: tup3 = tuple()

In [11]: tup3 = tuple()

元组中只包含一个元素时，需要在元素后面添加逗号。

In [12]: tup4 = ('PHP')

In [13]: tup4
Out[13]: 'PHP'

In [14]: tup4 = ('PHP',)

In [15]: tup4
Out[15]: ('PHP',)

要是不在后面添加一个逗号，则会被认为是一个字符串，这个需要注意。

元组的引用

In [21]: tup1
Out[21]: ('C', 'java', 'Python')

In [22]: tup1[0]
Out[22]: 'C'

In [23]: tup1[-1]
Out[23]: 'Python'

引用时要用[]来指定索引，而列表是()。这个也是区别。同时若索引超出范围则会报IndexError的错误。同时我们要是修改元组的值则会报TypeError的错误。由于元组的限制很多所以其所带的方法就只有index和count两个方法，下面就介绍这两个方法的使用。

元组的方法

index方法

查找某值的第一个索引，可以指定索引的开始和结束位置。（包含start，不包含stop）如果值没有找到，则抛出ValueError。

In [34]: tup6
Out[34]: ('C', 'java', 'Python', 'PHP', 'C', 'java', 'Python', 'PHP')

In [36]: tup6.index('C')
Out[36]: 0

In [37]: tup6.index('C',1)
Out[37]: 4

In [40]: tup6.index('C',1,5)
Out[40]: 4

使用在指定的区间进行查找时，若该区间没有指定的元素则会报ValueError的错误。

count方法

计数，返回指定值的出现次数。

In [41]: tup6.count('Python')
Out[41]: 2

元组的函数

len()

Python 元组 len() 函数计算元组元素个数。

In [46]: tup6
Out[46]: ('C', 'java', 'Python', 'PHP', 'C', 'java', 'Python', 'PHP')

In [47]: len(tup6)
Out[47]: 8

max()

Python 元组 max() 函数返回元组中元素最大值。

In [50]: max(tup6)
Out[50]: 'java'

min()

Python 元组 min() 函数返回元组中元素最小值。

In [51]: min(tup6)
Out[51]: 'C'

tuple()

Python 元组 tuple() 函数将列表转换为元组。

In [53]: list = [2,3,4,1,3,4]

In [54]: tup6 = tuple(list)

In [55]: tup6
Out[55]: (2, 3, 4, 1, 3, 4)

字符串

Python中字符串是内建的序列，我们可以使用引号('或")来创建字符串。所有标准的序列操作（索引、分片、乘法、判断成员资格、求长度、取最小值和最大值）对字符串同样适用。但是请注意字符串是不可变的！

字符串和操作符

• 字符串的创建和赋值

In [1]: str1 = 'Hello world!'

In [4]: str1
Out[4]: 'Hello world!'

In [3]: print(str1)
Hello world!

Python中字符串是不区分'和"的，这个和别的脚本语言有一定区别。

• 访问字符串的值

In [15]: str1
Out[15]: 'Hello world!'

In [16]: str1[-1]
Out[16]: '!'

In [17]: str1[2:4]
Out[17]: 'll'

In [18]: str1[2:5]
Out[18]: 'llo'

In [19]: str1[7:]
Out[19]: 'orld!'

In [20]: str1[:3]
Out[20]: 'Hel'

• 字符串的改变

我们可以通过给一个变量赋值或者重赋值的方式“更新”一个已有的字符串。新的值可能与原有的值差不多，也有可能跟原有串完全不同。

In [21]: str1
Out[21]: 'Hello world!'

In [22]: str1 = str1[:6] + 'Python'

In [23]: str1
Out[23]: 'Hello Python'

In [24]: str1 = 'Hello world!'

In [25]: str1
Out[25]: 'Hello world!'

和数字类型一样，字符串类型也是不可变的，所以你要改变一个字符串就必须通过创建一个新串的方式来实现。也就是说你不能只改变一个字符串中的一个字符或者一个子串，然而通过拼凑一个旧串的各个部分来得到一个新串是被允许的。

• 删除字符和字符串

注意：字符串是不可变的，所以你不能仅仅删除一个字符串里的某个字符，你能做的是清空一个空字符串，或者是把剔除了不需要的部分后的字符串组合起来形成一个新的字符串。

In [41]: str1
Out[41]: 'Hello Python'

In [42]: str1 = str1[:3] + str1[4:]

In [43]: str1
Out[43]: 'Helo Python'

清空和删除一个字符串：

In [44]: str1 = ''

In [45]: str1
Out[45]: ''

In [46]: del str1

In [47]: str1

在大部分的应用程序里，没有必要显示的删除字符串。定义这个字符串的代码最终会结束，那时Python会自动释放这些字符串。

• 切片

Python中切片使用很灵活，常用在列表和字符串中。在切片的三个数字中一个月是起始的下标（包含此下标的值），第二个是最终下标（不包含此下标的值），最后一个是步进。三个数字都可以省略，下标就看其如何使用。

In [53]: str2 = '0123456789'

In [54]: str2
Out[54]: '0123456789'

In [55]: str2[2:5]
Out[55]: '234'

In [56]: str2[2:]
Out[56]: '23456789'

In [57]: str2[:5]
Out[57]: '01234'

In [58]: str2[::2]
Out[58]: '02468'

In [59]: str2[-1:]
Out[59]: '9'

In [60]: str2[:-5]
Out[60]: '01234'

In [61]: str2[-2:-5]
Out[61]: ''

In [62]: str2[-7:-5]
Out[62]: '34'

正是由于切片的灵活所以这个还是多做练习，请找出其中的规律。代码是需要练习写出来的光看书和视频不练习还是等于没有学。

• 成员操作符

成员操作符用于判断一个字符或者一个子串中的字符是否出现在另一个字符串中。出现则返回True。否则返回False。注意，成员操作符不是用来判断一个字符串是否包含另一个字符串的，这样的功能可以使用find()或者index()方法完成。

In [63]: 'bc' in 'abcd'
Out[63]: True

In [64]: 'bc' in 'abd'
Out[64]: False

In [65]: 'bd' in 'abcd'
Out[65]: False

• 连接符

我们可以通过连接操作符来从原有字符串获得一个新的字符串，下面举例。

In [1]: Str = 'Defence ' + 'of ' + 'the ' + 'Ancients.'

In [2]: Str
Out[2]: 'Defence of the Ancients.'

• 封包和解包

In [1]: str1='0123456789'

In [2]: a,_,b,*_,c=str1

In [3]: a
Out[3]: '0'

In [4]: b
Out[4]: '2'

In [5]: c
Out[5]: '9'

字符串的方法

• join

格式

string.join(seq)

以string作为分隔符，将seq中所有的元素（字符串表示）合并成为一个新的字符串。

In [6]: str2=['Defence','of','the','Ancients']

In [7]: ' '.join(str2)
Out[7]: 'Defence of the Ancients'

• split

格式

string.spilt(str='',num=string.count(str))

以str为分隔符切片string，如果num有指定值，则仅分隔num个字符串。分隔从左边开始。

In [32]: str2
Out[32]: 'Defence of the Ancients is DOTA!'

In [33]: str2.split()
Out[33]: ['Defence', 'of', 'the', 'Ancients', 'is', 'DOTA!']

In [35]: str2.split('is',1)
Out[35]: ['Defence of the Ancients ', ' DOTA!']

In [36]: str2.split('is',2)
Out[36]: ['Defence of the Ancients ', ' DOTA!']

In [46]: str2.split(' ',-1)
Out[46]: ['Defence', 'of', 'the', 'Ancients', 'is', 'DOTA!']

In [47]: str2.split(' ',1)
Out[47]: ['Defence', 'of the Ancients is DOTA!']

In [48]: str2.split(' ',2)
Out[48]: ['Defence', 'of', 'the Ancients is DOTA!']

In [49]: str2.split(' ',-2)
Out[49]: ['Defence', 'of', 'the', 'Ancients', 'is', 'DOTA!']

• rsplit

格式

string.rspilt(str='',num=string.count(str))

以str为分隔符切片string，如果num有指定值，则仅分隔num个字符串。分隔从右边开始。

In [54]: str2.rsplit(' ',1)
Out[54]: ['Defence of the Ancients is', 'DOTA!']

In [55]: str2.split(' ',1)
Out[55]: ['Defence', 'of the Ancients is DOTA!']

• splitlines

格式

splitlines(num=string.count('\n')

按照行分隔，返回一个包含各行作为元素的列表，如果num指定则仅切片num行。

In [58]: str3
Out[58]: 'Defence of the\nAncients is\nDOTA!'

In [59]: str3.splitlines()
Out[59]: ['Defence of the', 'Ancients is', 'DOTA!']

In [61]: str3.splitlines(True)
Out[61]: ['Defence of the\n', 'Ancients is\n', 'DOTA!']

In [62]: str3.splitlines(1)
Out[62]: ['Defence of the\n', 'Ancients is\n', 'DOTA!']

In [63]: str3.splitlines(2)
Out[63]: ['Defence of the\n', 'Ancients is\n', 'DOTA!']

In [65]: str3.splitlines(-1)
Out[65]: ['Defence of the\n', 'Ancients is\n', 'DOTA!']

• partition

格式

string.partition(str)

有点像find()和split()的结合体，从str出现的第一个位置起，把字符串string分成一个3元组(string_pre_str,str,string_post_str)，如果string中不包含str则string_pre_str==string。

In [75]: str2
Out[75]: 'Defence of the Ancients is DOTA!'

In [78]: str2.partition(' ')
Out[78]: ('Defence', ' ', 'of the Ancients is DOTA!')

In [79]: str2
Out[79]: 'Defence of the Ancients is DOTA!'

In [80]: str2.partition(' ')
Out[80]: ('Defence', ' ', 'of the Ancients is DOTA!')

In [81]: D,_,OTA=str2.partition(' ')

In [82]: D
Out[82]: 'Defence'

In [83]: OTA
Out[83]: 'of the Ancients is DOTA!'

• capitalize

格式

string.capitatize()

把字符串的第一个字符大写。

In [88]: str2
Out[88]: 'Defence of the Ancients is DOTA!'

In [89]: str2.capitalize()
Out[89]: 'Defence of the ancients is dota!'

• title

格式

string.title()

返回“标题化”的string，就是说所有单词都是以大写开始，其余字母均为小写。

In [90]: str2.title()
Out[90]: 'Defence Of The Ancients Is Dota!'

• istitle

格式

string.istitle()

如果string是标题化的则返回True，否则返回False。

In [91]: str2.istitle()
Out[91]: False

In [92]: str4=str2.title()

In [93]: str4.istitle()
Out[93]: True

• lower

格式

string.lower()

转换string中所有大写字符为小写。

In [95]: str2
Out[95]: 'Defence of the Ancients is DOTA!'

In [96]: str2.lower()
Out[96]: 'defence of the ancients is dota!'

• islower

格式

string.islower()

如果string中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是小写，则返回True，否则返回False。

In [97]: str2.islower()
Out[97]: False

• upper

格式

string.upper()

转换string中的小写字母为大写。

In [105]: str2
Out[105]: 'Defence of the Ancients is DOTA!'

In [106]: str2.upper()
Out[106]: 'DEFENCE OF THE ANCIENTS IS DOTA!'

• isupper

格式

string.isupper()

如果string中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是大写，则返回True，否则返回False。

In [107]: str2.isupper()
Out[107]: False

扩展
大小写转化通常用在做比较得时候，当我们需要忽略大小写比较时， 通常统一转化为全部大写或者全部小写再做比较。

In [108]: str2.lower().upper()
Out[108]: 'DEFENCE OF THE ANCIENTS IS DOTA!'

In [109]: str2.upper().lower()
Out[109]: 'defence of the ancients is dota!'

• swapcase

格式

string.swapcase()

翻转string中的大小写字母。

In [110]: str2.swapcase()
Out[110]: 'dEFENCE OF THE aNCIENTS IS dota!'

• center

格式

string.center(width)

返回一个原字符串居中，并使用空格填充至长度width的新字符串。

In [111]: str2.center(88)
Out[111]: '                            Defence of the Ancients is DOTA!                            '

In [113]: str2.center(88,'#')
Out[113]: '############################Defence of the Ancients is DOTA!############################'

• ljust

格式

string.ljust(width)

返回一个原字符串左对齐，并使用空格填充至长度width的新字符串。可以指定填充符号，指定的填充符号必须是单个字符或数字。

In [117]: str2.ljust(88)
Out[117]: 'Defence of the Ancients is DOTA!                                                        '

In [119]: str2.ljust(88,'$')
Out[119]: 'Defence of the Ancients is DOTA!$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$'

• rjust

格式

string.rjust(width)

返回一个原字符串右对齐，默认使用空格填充至长度width的新字符串。可以指定填充符号，指定的填充符号必须是单个字符或数字。

In [124]: str2.rjust(88)
Out[124]: '                                                        Defence of the Ancients is DOTA!'

In [125]: str2.rjust(88,'&')
Out[125]: '&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&Defence of the Ancients is DOTA!'

• zfill

格式

string.zfill(width)

返回长度为width的字符串，原字符串string右对齐，前面填充0.

In [126]: str2.zfill(88)
Out[126]: '00000000000000000000000000000000000000000000000000000000Defence of the Ancients is DOTA!'

• strip

格式

string.strip([chars])

出去string字符串中最左边和最右边chars字符，不写chars则清楚空格、\n、\r、\r\n、\v or \x0b、\f or \x0c、\x1c、\x1d、\x1e、\x85、\u2028、\u2029，若填写字符则清楚指定的字符，填写字符可以为多个。

In [28]: str1='\f  \x1e    ####  DOTA   ## ****  \n   \t  \r   \x1c    '

In [29]: str1.strip()
Out[29]: '####  DOTA   ## ****'

In [21]: str1='####  DOTA   \n   \t  ###****'

In [22]: str1.strip('*#')
Out[22]: '  DOTA   \n   \t  '

In [31]: str1.strip('*#D')
Out[31]: '  DOTA   \n   \t  '

In [32]: str1.strip('*# ')
Out[32]: 'DOTA   \n   \t'

• lstrip

格式

string.lstrip([chars])

去除string中左边指定的字符，和strip格式一样，但是只是去除左边的。

In [34]: str1='\f    ####  DOTA   \n   \t  ###****'

In [35]: str1.lstrip()
Out[35]: '####  DOTA   \n   \t  ###****'

In [36]: str1='####  DOTA   \n   \t  ###****'

In [37]: str1.lstrip(' #')
Out[37]: 'DOTA   \n   \t  ###****'

• rstrip

格式

string.rstrip([chars])

去除string中右边指定的字符，和strip格式一样，但是只是去除右边的。

In [40]: str1
Out[40]: '####  DOTA   \n   \t  ###****'

In [41]: str1.rstrip('* #')
Out[41]: '####  DOTA   \n   \t'

• startswith

格式

startswith(obj,beg=0,end=len(string))

检查字符串是否是以obj开头，是则返回True，否则返回False。如果beg和end指定值，则在指定范围内检查。

In [42]: str1
Out[42]: '####  DOTA   \n   \t  ###****'

In [43]: str1.startswith('#')
Out[43]: True

In [44]: str1.startswith('####')
Out[44]: True

In [45]: str1.startswith('#####')
Out[45]: False

In [52]: str1.startswith('DOTA',6)
Out[52]: True

• endswith

格式

endswith(obj,beg=0,end=len(string))

检查字符串是否是以obj结束，是则返回True，否则返回False。如果beg和end指定值，则在指定范围内检查。

In [59]: str1
Out[59]: '####  DOTA   \n   \t  ###****'

In [67]: len(str1)
Out[67]: 27

In [74]: str1.endswith('***',22)
Out[74]: True

In [75]: str1.endswith('***',21)
Out[75]: True

In [80]: str1.endswith('###',1,24)
Out[80]: False

In [81]: str1.endswith('###',1,23)
Out[81]: True

• isdigit()

语法

string.isdigit()

如果string只包含数字则返回True，否则返回False。

In [85]: str2
Out[85]: '012345678'

In [86]: str2.isdigit()
Out[86]: True

In [87]: str3='012345abc'

In [88]: str3.isdigit()
Out[88]: False

• isalnum

语法

string.isalnum()

如果string中至少有一个字符并且所有字符都是字母或数字则返回True，否则返回Fales。

In [91]: str3
Out[91]: '012345abc'

In [92]: str3.isalnum()
Out[92]: True

In [93]: str1
Out[93]: '####  DOTA   \n   \t  ###****'

In [94]: str1.isalnum()
Out[94]: False

• isalpha

格式

string.isalpha()

如果string中至少有一个字符并且所有字符都是字母则返回True，否则返回False。

In [97]: str3
Out[97]: '012345abc'

In [98]: str3.isalpha()
Out[98]: False

In [99]: str4='DOTA'

In [100]: str4.isalpha()
Out[100]: True

• isdecimal

格式

string.isdecimal()

如果string只包含十进制数字则返回True，否则返回False。

In [101]: str2
Out[101]: '012345678'

In [102]: str2.isdecimal()
Out[102]: True

In [103]: str3
Out[103]: '012345abc'

In [104]: str3.isdecimal()
Out[104]: False

• count

格式

string.count(str,beg=0,end=len(string))

返回str在string里面出现的次数，如果beg或者end指定则在指定的范围查找str出现的次数。

In [110]: str4='*****   DOTA  dota #####'

In [111]: str4.count('*')
Out[111]: 5

In [112]: str4.count('**')
Out[112]: 2

In [113]: str4.count('**',3)
Out[113]: 1

In [114]: str4.count('**',2)
Out[114]: 1

• find

格式

string.fing(str,beg=0,end=len(string))

检测str是否包含在string中，如果beg和end指定了范围，则检测是否包含在指定范围内，如果是返回开始的索引值，否则返回-1.

In [115]: str4
Out[115]: '*****   DOTA  dota #####'

In [116]: str4.find('dota')
Out[116]: 14

In [4]: str4.find('dotaer')
Out[4]: -1

In [117]: str4.lower().find('dota')
Out[117]: 8

• rfind

格式

string.rfind(str,beg=0,end=len(strint))

类是find()方法，不过是从右开始查找。

In [118]: str4
Out[118]: '*****   DOTA  dota #####'

In [119]: str4.rfind('DOTA')
Out[119]: 8

In [120]: str4.upper().rfind('DOTA')
Out[120]: 14

In [6]: str4.rfind('DOTAER')
Out[6]: -1

• index

格式

string.index(str,beg=0,end=len(string))

和find方法差不多，只不过如果str不在string中报一个ValueError异常。

In [9]: str4
Out[9]: '*****   DOTA  dota #####'

In [10]: str4.index('dota')
Out[10]: 14

• rindex

格式

string.rindex(str,beg=0,end=len(string))

类似于index()方法，不过是从右边开始查找。

• replace

格式

string.replace(str1,str2,num)

把string中的str1替换成str2，如果num指定则替换不超过num次。

In [14]: str4
Out[14]: '*****   DOTA  dota #####'

In [21]: str4.replace('#','*',1)
Out[21]: '*****   DOTA  dota *####'

In [22]: str4.replace('#','*',2)
Out[22]: '*****   DOTA  dota **###'

格式化操作符%

Python风格的字符串格式化操作法只适用于字符串类型，类是于C语言的printf()函数字符串格式化，下面是字符串格式化的符号。

• 字符串格式化符号

格式化字符	转换方式
%c	转换成字符（ASCII码值，或者长度为一的字符串）
%r	优先使用repr()函数进行字符串转换
%s	优先使用str()函数进行字符串转换
%a	优先使用 ascii()函数进行字符串转换
%d/%i	转成有符号十进制数
%u	转成无符号十进制数
%o	转成无符号八进制数
%x%X	转换成无符号十六进制数(x/X代表转换后的十六进制字符的大小写)
%e%E	转换成科学计数法(e/E控制输出e/E)
%f%F	转换成浮点型(小数部分自然截断)
%g%G	%e和%f%E和%F的简写
%%

• 格式化操作符辅组指令

符号	作用
*	定义宽度或者小数点精度
-	用左对齐
+	在正数前面显示加号（+）
<sp>	在正数前面显示空格
#	在八进制数前面显示'0'，在十六进制前面显示'0x' 或者'0X'
0	显示的数字前面填充'0'而不是默认的空格
%	'%%'输出一个单一的'%'
(var)	映射变量(字典参数)
m.n	m是显示最小总宽度，n是小数点后的位数（好像不能使用）

Python支持两种格式的输入参数。第一种是元组，这基本上是一种的printf()风格的转换参数集。Python支持的第二种形式是字典形式，这种形式里面键是做为格式字符串的出现，相对应的值做为参数在进行转换时提供给格式字符串。总之第二种使用字典形式是出现在反复出现多次，而第二种是需要格式化的内容很多的时候。

使用举例

• 元组格式举例：

In [2]: 'Defence of the Ancients is %s' %('DOTA',)
Out[2]: 'Defence of the Ancients is DOTA'

In [3]: 'Defence of the Ancients is %s' %'DOTA'
Out[3]: 'Defence of the Ancients is DOTA'

In [4]: 'Defence of the Ancients is %s' %('DOTA')
Out[4]: 'Defence of the Ancients is DOTA'

上面三中方式使用中建议使用第一个，这种方式能够很容易看出格式化的的输入参数是个元组，而下面两种其实也是元组只是由解释器进行操作转换的。

• 字典格式举例：

In [8]: 'Defence of the Ancients is %s.I like %s' %('DOTA','DOTA')
Out[8]: 'Defence of the Ancients is DOTA.I like DOTA'

In [9]: 'Defence of the Ancients is %(name)s.I like %(name)s' %{'name':'DOTA'}
Out[9]: 'Defence of the Ancients is DOTA.I like DOTA'

• 十六进制输出：

In [11]: '%x' %108
Out[11]: '6c'

In [12]: '%X' %108
Out[12]: '6C'

In [13]: '%#x' %108
Out[13]: '0x6c'

In [14]: '%#X' %108
Out[14]: '0X6C'

• 整型、浮点和科学计数法形式输出

In [26]: '%f' %1234.123456789
Out[26]: '1234.123457'

In [28]: '%0.9f' %1234.123456789
Out[28]: '1234.123456789'

In [30]: '%e' %1234.123456789
Out[30]: '1.234123e+03'

In [31]: '%E' %1234.123456789
Out[31]: '1.234123E+03'

In [36]: '%d' %1234.123456789
Out[36]: '1234'

In [37]: '%10d' %1234.123456789
Out[37]: '      1234'

In [38]: '%10.10d' %1234.123456789
Out[38]: '0000001234'

In [39]: '%-10d' %1234.123456789
Out[39]: '1234      '

In [40]: '%+10d' %1234.123456789
Out[40]: '     +1234'

format方法

上面对于字符串格式化输出使用的是格式化操作符，而Python又有一种使用更灵活的格式化方式，就是format方法。

In [45]: 'Defence of the Ancients is {}.'.format('DOTA')
Out[45]: 'Defence of the Ancients is DOTA.'

In [46]: 'Defence of the Ancients is {}.I like {}.2016 begin {}'.format('DOTA','DOTA','TI6')
Out[46]: 'Defence of the Ancients is DOTA.I like DOTA.2016 begin TI6'

In [47]: 'Defence of the Ancients is {1}.I like {2}.2016 begin {0}'.format('TI6','DOTA','DOTA','TI6')
Out[47]: 'Defence of the Ancients is DOTA.I like DOTA.2016 begin TI6'

In [48]: 'Defence of the Ancients is {1}.I like {2}.2016 begin {0}'.format('DOTA','DOTA','TI6')
Out[48]: 'Defence of the Ancients is DOTA.I like TI6.2016 begin DOTA'

In [49]: 'Defence of the Ancients is {0}.I like {0}.2016 begin {1}'.format('DOTA','TI6')
Out[49]: 'Defence of the Ancients is DOTA.I like DOTA.2016 begin TI6'

In [50]: 'Defence of the Ancients is {name}.I like {name}.2016 begin {time}'.format(name='DOTA',time='TI6')
Out[50]: 'Defence of the Ancients is DOTA.I like DOTA.2016 begin TI6'

在使用数字下标定义的时候注意数字不能多于后面字符串的个数，一旦多于会报IndexError的错误。而后面字符串的个数是可以多于前面数字下标的个数的。Python计数是从0开始的，这个需要注意。

• 混合使用

In [55]: '{} {} {}'.format(1,2,3)
Out[55]: '1 2 3'

In [56]: '{} {} {name}'.format(1,2,name='DOTA')
Out[56]: '1 2 DOTA'

In [70]: '{} {name} {}'.format(1,2,3,name='DOTA')
Out[70]: '1 DOTA 2'

In [63]: '{1} {0} {name}'.format(1,2,name='DOTA')
Out[63]: '2 1 DOTA'

In [67]: '{name} {0} {2}'.format(1,2,3,name='DOTA')
Out[67]: 'DOTA 1 3'

• 扩展学习类的操作

In [72]: class A:
   ....:     def __init__(self):
   ....:         self.x=1
   ....:         self.y=2
   ....:         

In [73]: a = A()

In [74]: a.x
Out[74]: 1

In [75]: a.y
Out[75]: 2

In [76]: '{0.x},{0.y}'.format(a)
Out[76]: '1,2'

In [87]: '{inst.x}'.format(inst=a)
Out[87]: '1'

In [88]: '{inst.y}'.format(inst=a)
Out[88]: '2'

• 扩展学习二列表的操作

In [89]: lst
Out[89]: [1, 2, 3, 4]

In [90]: '{0[0]}'.format(lst)
Out[90]: '1'

In [91]: '{0[3]}'.format(lst)
Out[91]: '4'

In [92]: '{lst1[1]}'.format(lst1=lst)
Out[92]: '2'

In [93]: '{lst1[2]}'.format(lst1=lst)
Out[93]: '3'

bytes

bytes是Python 3中特有的，Python 2 里不区分bytes和str。

• Python 2中

>>> type(b'xxxxx')
<type 'str'>
>>> type('xxxxx')
<type 'str'>

• Python 3中

>>> type(b'xxxxx')
<class 'bytes'>
>>> type('xxxxx')
<class 'str'>

区别

• bytes是byte的序列，而str是unicode的序列。

• str 使用encode方法转化为 bytes

• bytes通过decode转化为str
  str转换成bytes：

In [9]: str1='人生苦短，我用Python!'

In [10]: type(str1)
Out[10]: str

In [11]: b=str1.encode()

In [12]: b
Out[12]: b'\xe4\xba\xba\xe7\x94\x9f\xe8\x8b\xa6\xe7\x9f\xad\xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8Python!'

In [13]: type(str1.encode())
Out[13]: bytes

bytes转换成str：

In [22]: b
Out[22]: b'\xe4\xba\xba\xe7\x94\x9f\xe8\x8b\xa6\xe7\x9f\xad\xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8Python!'

In [23]: type(b)
Out[23]: bytes

In [24]: b.decode()
Out[24]: '人生苦短，我用Python!'

In [25]: type(b.decode())
Out[25]: str

在Python 2中由于不区分str和bytes所以可以直接通过encode()和decode
()方法进行编码解码。而在Python 3中把两者给分开了这个在使用中需要注意。实际应用中在互联网上是通过二进制进行传输，所以就需要将str转换成bytes进行传输，而在接收中通过decode()解码成我们需要的编码进行处理数据这样不管对方是什么编码而本地是我们使用的编码这样就不会乱码。

bytearray

bytearray和bytes不一样的地方在于，bytearray是可变的。

In [26]: str1
Out[26]: '人生苦短，我用Python!'

In [28]: b1=bytearray(str1.encode())

In [29]: b1
Out[29]: bytearray(b'\xe4\xba\xba\xe7\x94\x9f\xe8\x8b\xa6\xe7\x9f\xad\xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8Python!')

In [30]: b1.decode()
Out[30]: '人生苦短，我用Python!'

In [31]: b1[:6]=bytearray('生命'.encode())

In [32]: b1
Out[32]: bytearray(b'\xe7\x94\x9f\xe5\x91\xbd\xe8\x8b\xa6\xe7\x9f\xad\xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8Python!')

In [33]: b1.decode()
Out[33]: '生命苦短，我用Python!'