python核心编程（六）— 序列：字符串、列表、元组

朱雀 2022-07-13 04:41 210阅读 0赞

## 序列：字符串、列表、元组 ##

### 序列Sequence ###

有一些Python的类型，它的成员是有序排列的，且可以通过下标偏移量访问它的一个或几个成员，这类Python类型统称为序列。

#### 标准类型操作符 ####

#### 序列类型操作符 ####

操作符是按照优先级从高到底的顺序排列的。

表 6.1 序列类型操作符

<table> 
 <thead> 
  <tr> 
   <th>序列操作符</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>seq[ind]</td> 
   <td>获得下标为 ind 的元素</td> 
  </tr> 
  <tr> 
   <td>seq[ind1:ind2]</td> 
   <td>获得下标从ind1到ind2间的元素集合</td> 
  </tr> 
  <tr> 
   <td>seq * expr</td> 
   <td>序列重复 expr 次</td> 
  </tr> 
  <tr> 
   <td>seq1 + seq2</td> 
   <td>连接序列 seq1 和 seq2</td> 
  </tr> 
  <tr> 
   <td>obj in seq</td> 
   <td>判断 obj 元素是否包含在 seq 中</td> 
  </tr> 
  <tr> 
   <td>obj not in seq</td> 
   <td>判断 obj 元素是否不包含在 seq 中</td> 
  </tr> 
 </tbody> 
</table>

\* 连接操作符( `+` )  
\* 重复操作符 ( `*` )  
\* 切片操作符 ( `[], [:], [::]` )  
1. sequence\[index\]  
2. sequence\[starting\_index:ending\_index\]

#### 内建函数(BIFs) ####

##### 类型转换 #####

序列类型转换工厂函数

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list(iter)</td> 
   <td>把可迭代对象转换为列表</td> 
  </tr> 
  <tr> 
   <td>str(obj)</td> 
   <td>把 obj 对象转换成字符串(对象的字符串表示法)</td> 
  </tr> 
  <tr> 
   <td>unicode(obj)</td> 
   <td>把对象转换成 Unicode 字符串(使用默认编码)</td> 
  </tr> 
  <tr> 
   <td>basestring()</td> 
   <td>抽象工厂函数,其作用仅仅是为 str 和 unicode 函数提供父类,所以不能被实例化,也不能被调用</td> 
  </tr> 
  <tr> 
   <td>tuple(iter)</td> 
   <td>把一个可迭代对象转换成一个元组对象</td> 
  </tr> 
 </tbody> 
</table>

Python 里面不简单地把一个对象转换成另一个对象。一旦一个 Python 的对象被建立,我们就不能更改其身份或类型了.如果你把一个列表对象传给 list()函数,便会创建这个对象的一个浅拷贝, 然后将其插入新的列表中。

copy模块 - Shallow and deep copy operations

1.  copy.copy(x)：Return a shallow copy of x.
2.  copy.deepcopy(x)：Return a deep copy of x.

##### Operational #####

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>enumerate(iter)</code></td> 
   <td>接受一个可迭代对象作为参数,返回一个 enumerate 对象(同时也是一个迭代器),该对象生成由 iter 每个元素的 index 值 和 item 值组成的元组(PEP 279)</td> 
  </tr> 
  <tr> 
   <td>len(seq)</td> 
   <td>返回seq的长度</td> 
  </tr> 
  <tr> 
   <td><code>max(iter,key=None) or max(arg0,arg1...,key=None)</code></td> 
   <td>返回iter或(arg0,arg1,…)中的最大值,如果指定了key,这个 key 必须是一个可以传给 sort()方法的,用于比较的回 调函数.</td> 
  </tr> 
  <tr> 
   <td><code>min(iter, key=None) or min(arg0, arg1.... key=None)</code></td> 
   <td>返回 iter 里面的最小值;或者返回(arg0,arg2,…)里面的最小值;如果指定了 key,这个 key 必须是一个可以传给 sort()方法的,用于比较的回调函数.</td> 
  </tr> 
  <tr> 
   <td><code>reversed(seq)</code></td> 
   <td>接受一个序列作为参数,返回一个以逆序访问的迭代器(PEP 322)</td> 
  </tr> 
  <tr> 
   <td><code>sorted(iter, func=None, key=None, reverse=False)</code></td> 
   <td>接受一个可迭代对象作为参数,返回一个有序的列表;可选参数 func,key 和 reverse 的含义跟 list.sort()内建函数的参数含义一 样.</td> 
  </tr> 
  <tr> 
   <td><code>sum(seq, init=0)</code></td> 
   <td>返 回 seq 和 可 选 参 数 init 的 总 和 , 其 效 果 等 同 于 reduce(operator.add,seq,init)</td> 
  </tr> 
  <tr> 
   <td><code>zip([it0, it1,... itN])</code></td> 
   <td>返回一个列表,其第一个元素是 it0,it1,…这些元素的第 一个元素组成的一个元组,第二个…,类推.</td> 
  </tr> 
 </tbody> 
</table>

max举例：

a = [1, 2, 3, 4, 50, -1]
        c = max(a, key=lambda x: abs(x))
        print c

### 字符串 ###

Python 里面单引号和双引号的作用是相同的。字符串是不可变类型,就是说改变一个字符串的元素需要新建一个新的字符串.字符串是由 独立的字符组成的,并且这些字符可以通过切片操作顺序地访问。

### 字符串和操作符 ###

#### 序列操作符 ####

切片( \[ \] 和 \[ : \] )

*  正向索引
 *  反向索引
 *  默认索引

#### 成员操作符(in ,not in) ####

#### 连接符( + ) ####

1.  运行时刻字符串连接
2.  编译时字符串连接

#### 普通字符串转化为 Unicode 字符串 ####

#### 重复操作符( \* ) ####

### 只适用于字符串的操作符 ###

#### 格式化操作符( % ) ####

<table> 
 <thead> 
  <tr> 
   <th>格式化字符</th> 
   <th>转换方式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>%c</code></td> 
   <td>转换成字符</td> 
  </tr> 
  <tr> 
   <td><code>%r</code></td> 
   <td>优先用 repr()函数进行字符串转换</td> 
  </tr> 
  <tr> 
   <td><code>%s</code></td> 
   <td>优先用 str()函数进行字符串转换</td> 
  </tr> 
  <tr> 
   <td><code>%d/%i</code></td> 
   <td>转成有符号十进制数</td> 
  </tr> 
  <tr> 
   <td><code>%u</code></td> 
   <td>转成无符号十进制数</td> 
  </tr> 
  <tr> 
   <td><code>%o</code></td> 
   <td>转成无符号八进制数</td> 
  </tr> 
  <tr> 
   <td><code>%x/%X</code></td> 
   <td>(Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大小写)</td> 
  </tr> 
  <tr> 
   <td><code>%e/%E</code></td> 
   <td>转成科学计数法(e/E 控制输出 e/E)</td> 
  </tr> 
  <tr> 
   <td><code>%f/%F</code></td> 
   <td>转成浮点数(小数部分自然截断)</td> 
  </tr> 
  <tr> 
   <td><code>%g/%G</code></td> 
   <td>%e 和%f/%E 和%F 的简写</td> 
  </tr> 
  <tr> 
   <td><code>%%</code></td> 
   <td>输出%</td> 
  </tr> 
 </tbody> 
</table>

格式化操作符辅助指令

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>*</td> 
   <td>定义宽度或者小数点精度</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>用做左对齐</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>在正数前面显示加号( + )</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>在正数前面显示空格</td> 
  </tr> 
  <tr> 
   <td>#</td> 
   <td>在八进制数前面显示零(‘0’),在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)</td> 
  </tr> 
  <tr> 
   <td>0</td> 
   <td>显示的数字前面填充‘0’而不是默认的空格</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>‘%%’输出一个单一的’%’</td> 
  </tr> 
  <tr> 
   <td>(var)</td> 
   <td>映射变量(字典参数)</td> 
  </tr> 
  <tr> 
   <td>m.n</td> 
   <td>m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)</td> 
  </tr> 
 </tbody> 
</table>

#### 原始字符串操作符( r/R ) ####

#### Unicode字符串操作符(u/U) ####

### 内建函数 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>string.capitalize()</td> 
   <td>把字符串的第一个字符大写</td> 
  </tr> 
  <tr> 
   <td>string.center(width)</td> 
   <td>返回一个原字符串居中，并使用空格填充至长度width的新字符串</td> 
  </tr> 
  <tr> 
   <td>string.count（str,beg=0,end=len(string))</td> 
   <td>返回str在string里面出现的次数，如果beg或者cmd指定则返回指定范围内str出现的次数</td> 
  </tr> 
  <tr> 
   <td>string.decode(encoding=’UTF-8’,errors=’strict’)</td> 
   <td>以dncoding指定的编码格式解码string，如果出错默认报一个ValueError的异常，除非errors指定是‘ignore’或者‘replace’</td> 
  </tr> 
  <tr> 
   <td>string.encode(encoding=’UTF-8’,errors=’strict’)</td> 
   <td>以encoding置顶的编码格式编码string，如果出错默认报一个ValueError的异常，除非errors指定的是‘ignore’或者‘replace’</td> 
  </tr> 
  <tr> 
   <td>string.endswith(obj,beg=0,end=len(string))</td> 
   <td>检查字符创是否以obj结束，如果beg或者end指定则检查指定的范围内是否以obj结束，如果是，返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.expandtabs(tabsize=8)</td> 
   <td>把字符串string中的tab符号转为空格，默认的空格数tabsize是8</td> 
  </tr> 
  <tr> 
   <td>string.find(str,beg=0,end=len(string))</td> 
   <td>检查str是否包含在string中，如果beg和end指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1</td> 
  </tr> 
  <tr> 
   <td>string.index(str,beg=0,end=len(string))</td> 
   <td>same as find，如果str不在string中会报一个异常</td> 
  </tr> 
  <tr> 
   <td>string.isalnum()</td> 
   <td>如果string至少有一个字符并且所有字符都是字母或数字则返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.isalpha()</td> 
   <td>如果string至少有一个字符并且所有字符都是字母则返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.isdecimal()</td> 
   <td>如果string只包含十进制数字则返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.isdigit()</td> 
   <td>如果string只包含数字则返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.islower()</td> 
   <td>如果string中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是小写，则返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.isnumeric()</td> 
   <td>如果string中只含有数字字符，则返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.isspace()</td> 
   <td>如果string中只含有空格，则返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.istitle()</td> 
   <td>如果string是标题化的则返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.isupper()</td> 
   <td>如果string中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是大写，则返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.join(seq)</td> 
   <td>以string作为分隔符，将seq中的所有元素（字符串表示）合并为一个新的字符串</td> 
  </tr> 
  <tr> 
   <td>stirng.ljust(width)</td> 
   <td>返回一个原字符串左对齐，并使用空格填充至长度width的新字符串</td> 
  </tr> 
  <tr> 
   <td>string.lower()</td> 
   <td>转换string中所有大写字符为小写</td> 
  </tr> 
  <tr> 
   <td>string.lstrip()</td> 
   <td>截掉string左边的空格</td> 
  </tr> 
  <tr> 
   <td>string.partition(str)</td> 
   <td>从str出现的第一个位置起，把字符串string分成一个3元祖(string_pre_str,str,_string_post_str)，如果string中不包含str则string_pre_str==string</td> 
  </tr> 
  <tr> 
   <td>strig.replace(str1,str2,num=string.count(str1))</td> 
   <td>吧string中的str替换成str2，如果num指定，则替换不超过num次</td> 
  </tr> 
  <tr> 
   <td>string.rfind(str,beg=0,end=len(string))</td> 
   <td>类似find，从右边开始查找</td> 
  </tr> 
  <tr> 
   <td>string.rindex(str,beg=0,end=len(string))</td> 
   <td>类似index，从右边开始</td> 
  </tr> 
  <tr> 
   <td>string.rjust(width)</td> 
   <td>返回一个原字符串右对齐，并使用空格填充至长度width的新字符串</td> 
  </tr> 
  <tr> 
   <td>string.rpartition(str)</td> 
   <td>类似partiton()，从右边开始查找</td> 
  </tr> 
  <tr> 
   <td>string.rstrip()</td> 
   <td>删除string字符串末尾的空格</td> 
  </tr> 
  <tr> 
   <td>string.split(str=”“,num=string.count(str))</td> 
   <td>以str为分隔符切片string，如果num有指定值，则仅分隔num个子字符串</td> 
  </tr> 
  <tr> 
   <td>string.splitlines(num-string.count(‘\n’))</td> 
   <td>按照行分隔，返回一个包含各行作为元素的列表，如果num指定则仅切片num行</td> 
  </tr> 
  <tr> 
   <td>string.startwith(obj,beg=0,end=len(string))</td> 
   <td>检查字符串是否以obj开头，是则返回True，否则False</td> 
  </tr> 
  <tr> 
   <td>string.strip([obj])</td> 
   <td>在string上执行lstrip()和rstrip()</td> 
  </tr> 
  <tr> 
   <td>string.swapcase()</td> 
   <td>翻转string中的大小写</td> 
  </tr> 
  <tr> 
   <td>string.title()</td> 
   <td>返回“标题化”的string，就是说所有单词都是以大写开始，其余字母均为小写</td> 
  </tr> 
  <tr> 
   <td>string.translate(str,del=”“)</td> 
   <td>根据str给出的表转换string的字符，要过滤掉的字符放到得了参数中</td> 
  </tr> 
  <tr> 
   <td>string.upper()</td> 
   <td>转换string中的小写字母为大写</td> 
  </tr> 
  <tr> 
   <td>string.zfile(width)</td> 
   <td>返回长度为width的字符串，原字符串string右对齐，前面填充0</td> 
  </tr> 
 </tbody> 
</table>

#### Python的Unicode支持 ####

##### 内建的 unicode()函数 #####

Unicode 的工厂方法,同 Unicode 字符串操作符(u / U)的工作方式很类似,它接受一个 string 做参数,返回一个 Unicode 字符串.

##### 内建的 decode()/encode()方法 #####

decode()和 encode()内建函数接受一个字符串做参数返回该字符串对应的解码后/编码后 的字符串.decode()和 encode()都可以应用于常规字符串和 Unicode 字串.decode()方法是在 Python2.2 以后加入的.

### 集合 ###

元组：()  
列表：\[\]  
字典：\{\}

### 列表 ###

列表类型内建函数

<table> 
 <thead> 
  <tr> 
   <th>List Method</th> 
   <th>Operation</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list.append(obj)</td> 
   <td>向列表中添加一个对象 obj</td> 
  </tr> 
  <tr> 
   <td>list.count(obj)</td> 
   <td>返回一个对象 obj 在列表中出现的次数</td> 
  </tr> 
  <tr> 
   <td>list.extend(seq)</td> 
   <td>把序列 seq 的内容添加到列表中</td> 
  </tr> 
  <tr> 
   <td>list.index(obj, i=0, j=len(list))</td> 
   <td>返回 list[k] == obj 的 k 值,并且 k 的范围在 i&lt;=k</td> 
  </tr> 
  <tr> 
   <td>list.insert(index, obj)</td> 
   <td>在索引量为 index 的位置插入对象 obj.</td> 
  </tr> 
  <tr> 
   <td>list.pop(index=-1)</td> 
   <td>删除并返回指定位置的对象,默认是最后一个对象</td> 
  </tr> 
  <tr> 
   <td>list.remove(obj)</td> 
   <td>从列表中删除对象 obj</td> 
  </tr> 
  <tr> 
   <td>list.reverse()</td> 
   <td>原地翻转列表</td> 
  </tr> 
  <tr> 
   <td>list.sort(func=None,key=None,reverse=False)</td> 
   <td>以指定的方式排序列表中的成员,如果 func 和 key 参数指定, 则按照指定的方式比较各个元素,如果 reverse 标志被置为True,则列表以反序排列.</td> 
  </tr> 
 </tbody> 
</table>

### 元组 ###

单元素元组

创建一个只有一个元素的元组，需要在元素后面加上逗号。圆括号被重载了,它也被用作分组操作符。由圆括号包裹的一个单一元素首 先被作为分组操作,而不是作为元组的分界符。一个变通的方法是在第一个元素后面添一个逗 号(,)来表明这是一个元组而不是在做分组操作.

--------------------

参考资料：  
Python核心编程  
备注：  
转载请注明出处：[http://blog.csdn.net/wsyw126/article/details/53869751][http_blog.csdn.net_wsyw126_article_details_53869751]  
作者：WSYW126

[http_blog.csdn.net_wsyw126_article_details_53869751]: http://blog.csdn.net/wsyw126/article/details/53869751