第6章 序列：字符串，列表，元组

序列：成员有序排列，并且可以通过下标偏移量访问到它的一个或几个成员。

　　正向下标：0~N-1

　　反向下标：-N~-1

序列类型操作符：

　　seq[ ind ]                   获得下标为ind 的元素

　　seq[ ind1 : ind2  ]  　获得下标从IND1到ind 2的所有元素的集合

　　seq * expr                  序列重复*次

　　seq1 + seq2

　　obj [ not ]  in seq        判断obj元素是否[ 不在 ]在seq中

直接访问序列元素：

>>>print ('Faye','Leanna','Daylen')[1]

Leanna

一次获得多个序列元素：

seq[ start_index : end_index]                      注：包含start_index 但是不包():含end_index

用步长索引来扩展的切片操作：

>>>s = 'abcdefgh'

>>>s[ : : -1]                                        #翻转操作

'hgfedcba'

>>>s[ : : 2]                                         #隔一个取一个

'aceg'

更多技巧：

用None做索引值

>>>s = 'abcde'

>>>for i in [ None ] + range(-1 , -len(s), -1):                                 #本来是反向输出，步长为-1故改为正向

...    print (s[ : i ])

...

abcde

abcd

abc

ab

a

序列类型转换工厂函数：

list(iter)                                  把 可迭代对象 转换为列表

str(obj)                                   把obj对象转换为字符串

unicode(obj)

basestring()                           抽象工厂函数。不可被调用

tuple(iter)                               把一个可迭代对象转换为一个元组对象

 

序列类型可用的内建函数：

enumerate( iter )                   接受一个可迭代对象作为参数，返回一个enumerate 对象（同时也是一个迭代器）该对象生成由iter每个元素的index值和item值组成的元组

len(seq)

max( iter , key = None)               or          max (arg0 ,arg1..., key = None)            返回最大值，如果指定了key ,则key必须是可传给sort()方法的，用于比较的回调函数

min()

reversed(seq)                        返回逆序访问的迭代器

sorted( iter , func = None ,key = None ,reverse = False)   接受可迭代对象返回有序列表

sum ( seq , init = 0)                          返回seq和可选参数init的总和

zip( [ it0,it1,...itN] )                  返回一个列表，其第一个元素是it0,it1.....这些元素的第一个元素组成一个元组，第二个、、、、以此类推

　　

 

 

字符串：由独立字符组成，可通过切片操作访问，字符串是不可变类型

字符串的创建和赋值：

>>>aString = 'hello world !'

如何访问字符串的值:

aString [ 0 ]

aString [ 1:5 ]             #包左不包右

 

改变一个字符串的值只能新建一个字符串（或者通过拼凑旧串的各个部分也可以）

 

string模块预定义的字符串：

import string

>>>string.uppercase

'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

>>>string.lowercase

‘abcdefghijklmnopqrstuvwxyz’

>>>string.letters

'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

>>>string.digits

'0123456789'

 

 

 

('%s%s' % (s[ : 3] ,s[20])).upper()                  #选定的字符改为大写 

。。。。。。。。。。。.lower()

 

字符串格式化符号：

格式化字符       转换方式

%c             转换成字符(ASCII 码值，或者长度为一的字符串)

%r            优先用 repr()函数进行字符串转换

%s             优先用 str()函数进行字符串转换

%d / %i          转成有符号十进制数

%u              转成无符号十进制数

%o             转成无符号八进制数

%x/%X  (Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大 小写)

%e/%E         转成科学计数法(e/E 控制输出e/E)

%f/%F          转成浮点数(小数部分自然截断)

%g/%G          %e 和%f/%E 和%F 的简写

%%              输出%

 

格式化操作符辅助指令

符号                作用

*            定义宽度或者小数点精度

-            用做左对齐

+              在正数前面显示加号( + )

<sp>          在正数前面显示空格

# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于 用的是'x'还是'X')

0             显示的数字前面填充‘0’而不是默认的空格

%            '%%'输出一个单一的'%' (var)      映射变量(字典参数)

m.n          m 是显示的小总宽度,n 是小数点后的位数(如果可用的话) 

 

字符串模板：替代品

Template对象的两个方法：substitute()和safe_substitute() 前者严谨，在key丢失时会报错:

 1 >>> from string import Template 
 2 >>> s = Template('There are ${howmany} ${lang} Quotation Symbol s') 
 3 >>> 
 4 >>> print s.substitute(lang='Python', howmany=3) There are 3 Py thon Quotation Symbols 
 5 >>> 
 6 >>> print s.substitute(lang='Python') Traceback (most recent ca ll last): 
 7     File "<stdin>", line 1, in ? 
 8     File "/usr/local/lib/python2.4/string.py", line 172, in substit ute         
 9          return self.pattern.sub(convert, self.template) 
10     F i l e " / u s r / l o c a l / l i b / p y t h o n 2 . 4 / s t r i n g . p y " , l i n e 1 6 2 , i n c o n v e r t v a l = mapping[named]
11  KeyError: 'howmany' 
12 >>>
13  >>> print s.safe_substitute(lang='Python') There are ${howmany} Python Quotation Symbols

 

原始字符串操作符：（ r/R ）

内建函数：

 

标准类型函数：

cmp()

序列类型函数：

len()

max()    and    min()

enumerate()

zip()

 

字符串类型函数：

input()

str()     

chr()          and        ord()                       #整数为参数返回对于字符

　　　　　　　　　　　　　　　　　#字符为参数返回整数

大量的字符串内建函数          见书本P121

 

Unicode     概论：             书本P127

 

 

 

字符串关键点总结：

 

一些引号分隔的字符

你可以把字符串看成是Python的一种数据类型,在Python单引号或者双引号之间的字符数 组或者是连续的字符集合.在 Python 中常用两个引号是单引号（'）和双引号（"）。

字符串 的实际内容是这些单引号(')或者双引号(")之间的字符,不包括引号本身. 可以用两种引号来创建字符串是很有益处的，因为是当你的字符串中包含单引号时,如果 用单引号创建字符串,那么字符串中的双引号就不需要转义。反之亦然.


不可分字符类型

字符串是唯一的字面上的字符序列类型.不过,字符本身并不是一种类型,所以,字符串是字 符存储操作的基本单位.字符应该视为长度为 1 的字符串.

字符串格式化操作符

( % )提供类似于 printf()那样的功能. 字符串格式化操作符(见 6.4.1 节)提供了一种基于多种输入类型的创建自定义字符串的灵 活方式.它也提供了类似于 C/C++世界里的格式化操作的接口.

三引号

在 6.7.2 节里面,我们介绍了三引号,在三引号字符串中可以包含诸如换行回车或者 tab 键 这样的特殊字符.三引号字符串是用两边各三个单引号(''')或者两边各三个双引号(""")来定 义的. 

                          
原始字符串对每个特殊字符串都使用它的原意 第 6.4.2 节中,我们讲述了原始字符串,并且讨论了它们并不通过反斜线转义特殊字符的特 性.这个特性使得原始字符串非常适用于那些需要字符串原意的场合,比如在定义一个正则表达 式时.

Python 字符串不是通过 NUL 或者'\0'来结束的 C 编程的一个主要问题是你访问了一个字符串后面的本不属于你的空间,这种情况发生在你 没有在字符串末尾添加终结符,NUL或者'\0'(ASCII值为0)的时候.Python不仅为你自动管理内 存,而且也把 C 的这个负担或者说是小麻烦去掉了.Python 中的字符串不是以 NUL 结束的,所以 你不需要为是否已经添加终结符担心.字符串中只包含你所定义的东西,没有别的.

 

列表：可执行pop empt sort reverse等操作，还可以对单独某个元素insert update remove 操作

创建列表并赋值

aList = [123,'abc']

 

访问列表元素

aList [ 0 ]

 

更新列表

aList[ 2 ] = 'float replacer'

 

如何删除列表中的元素或者列表本身（ 知道索引用del 不知道索引用remove）

del aList[ 1 ]

aList.remove(123) 

 

 

操作符

 

标准类型操作符:

序列类型操作符：

　　注意：对列表的的切片操作返回的是对象

成员关系操作符：

>>> mixup_list [4.0, [1, 'x'], 'beef', (-1.9+6j)]

>>>

>>> 'beef' in mixup_list

True

>>>

>>> 'x' in mixup_list

False

>>>

>>> 'x' in mixup_list[1]

True

>>> num_list

[[65535L, 2e+030, (76.45-1.3j)], -1.23, 16.0, -49]

>>>

>>> -49 in num_list

True

>>>

>>> 34 in num_list

False

>>>

>>> [65535L, 2e+030, (76.45-1.3j)] in num_list

True

注意,'x'并不属于 mixup_list,因为'x'本身并不是 mixup_list 的一个成员,而是 mixup_list[1]的,mixup_list[1]也是一个列表类型.成员关系操作运算同样适用于元组类型.

连接操作符(+)：（不可用于向列表中加入新元素，应该用append()方法）

　　　　　　　　>>>num_list.append("new item")

　　允许将多个列表连接在一起但是不能将两个不同类型的对象连接在一起，即使他们都是序列类型也不行

一般用extend()方法来代替' + '来将一个列表的内容加到另一个中去

 

 内建函数：

　　序列类型函数：

　　　　len()

　　　　max()                   and        min()

　　　　sort()                    and        reversed()

　　　   enumerate()         and       zip()

　　　　sum()

　　　　list()                     and          tuple()

　　

 

 

　　列表类型的内建函数：

List Method                                                                Operation

list.append(obj)                                向列表中添加一个对象 obj

list.count(obj)                                   返回一个对象 obj 在列表中出现的次数

list.extend(seq)                                把序列 seq 的内容添加到列表中

list.index(obj, i=0, j=len(list))            返回 list[k] == obj 的 k 值,并且 k 的范围在 i<=k<j;否则 引发 ValueError 异常.

list.insert(index, obj)                        在索引量为 index 的位置插入对象 obj.

list.pop(index=-1)                            删除并返回指定位置的对象,默认是后一个对象

list.remove(obj)                               从列表中删除对象 obj

list.reverse()                                    原地翻转列表

list.sort(func=None,key=None, reverse=False)              以指定的方式排序列表中的成员,如果 func 和 key 参数指定, 则按照指定的方式比较各个元素,如果 reverse 标志被置为 True,则列表以反序排列.

　　　　　　　　　　　　　　　reverse为TRUE            则反向

 

 

关于列表的特殊性质：     用列表构建其他数据结构（栈和队列）         书本P145

 

元组：是不可变类型——————元组能做而列表不能做的事：成为一个字典的KEY

元组的创建：只有一个元素的元组需要在这个元素后面加个“,”

　　aTuple = (123,'abc',4.56,['inner','tuple'],7-9i)

　　atuple = (1234567,)

单独删除一个元组的元素是不可行的

元组的的切片操作是只读的，不能用于修改

所有函数返回的多对象（不包括有符号封装的）都是元组

键值必须是可hash的对象元组变量符合这个标准但是元组标量就不行。

 

与序列类型相关的模块：

array                                  一种受限制的可变序列类型,要求所有的元素必须都是相同的类型。

copy                                 提供浅拷贝和深拷贝的能力(详见 6.20)

operator                           包含函数调用形式的序列操作符，比如 operator.concat(m,n)就相当于连 接操作(m+n)。

re                                     Perl 风格的正则表达式查找(和匹配);见第 15 章

StringIO/ cStringIO         把长字符串作为文件来操作，比如 read(),seek()函数等,C 版的更快一些, 但是它不能被继承. 

Textwrap                        用作包裹/填充文本的函数，也有一个类

types                               包含 Python 支持的所有类型

collections                      高性能容器数据类型

 

 

 

python对象：浅拷贝与深拷贝

copy模块:copy()

　　　　deepcopy()

对一个对象进行浅拷贝其实是新建了一个类型和原对象一样内容是原来对象元素的引用，换句话说这个拷贝的对象本身是新的，但是他的内容不是。

 

标签：obj,seq,python,list,列表,____,part5,字符串,元组
来源： https://www.cnblogs.com/stuwu79/p/11718649.html