Python3.5修炼手册6-duyuheng

(^o^)/~完美

　　通用序列操作
　　
　　python中所有的序列都可以进行一些特定的操作。包括索引（indexing）、分片（slicing）、序列相加（adding）、乘法（multiplying）、成员资格、长度、最小值和最大值。
　　索引
　　序列是python中最基本的数据结构。序列中的每个元素都分配一个数字，代表他在序列中的位置（索引），第一个索引是0，第二个是1，以此类推。
　　序列中所有元素都是有编号的，从0开始递增。可以通过编号分别对序列的元素进行访问。
　　例如：
>>> greeting = 'Hello'　　
>>> greeting[0]
　　
'H'
　　
>>> greeting[1]
　　
'e'
　　
>>> greeting[2]
　　
'l'
　　序列中的元素是从0开始，从左到右依自然顺序编号，元素可以通过编号访问。
　　获取元素的方式：在变量后面加中括号，在括号中输入所取元素的值。
　　注意；字符串是有字符组成的序列。所以0指向的第一个元素。例如上面例子，0指向了H,以此类推。
　　从右往左反方向通过编号获取元素。
　　例如：
>>> greeting = 'Hello'　　
>>> greeting[-1]
　　
'o'
　　
>>> greeting[-2]
　　
'l'
　　
>>> greeting[-3]
　　
'l'
　　
>>> greeting[-4]
　　
'e'
　　最右边的元素值为-1，从右向左递减  千万注意没有-0。
　　在Pyhon中从左向右索引称为正数索引，从右向左称为负数索引。
　　进行字符串的索引时，不定义变量也是可以的。
　　例如：
>>> 'Hello'[0]　　
'H'
　　
>>> 'Hello'[1]
　　
'e'
　　
>>> 'Hello'[-1]
　　
'o'
　　直接使用索引的效果和定义变量的效果是一样的。
　　使用函数返回一个序列，使用交互模式
>>> thirdth=input()[0]　　
happy
　　
>>> thirdth
　　
'h'
　　由输出结果可以看到，对函数的返回结果进行了索引操作。
　　索引既可以对变量的引用操作，也可以直接操作序列，还可以操作函数的返回序列。
　　分片
　　分片可以对一定范围内的元素进行访问，分片通过冒号相隔的两个索引实现。
　　例如：
>>> number=[1,2,3,4,5,6,7,8,9,10]　　
>>> #取索引为第一个和第二个的元素
　　
... number[1:3]
　　
[2, 3]
　　
>>> #取倒数第三个和倒数第二个的元素
　　
... number[-3:-1]
　　
[8, 9]
　　由操作结果可以看出，分片操作既支持正数索引，也可以支持负数索引。
　　分片操作的实现需要提供两索引作为边界，第一个索引的元素包涵在分片内，第二索引的元素不包涵在分片内。
　　例如：
>>> number=[1,2,3,4,5,6,7,8,9,10]　　
>>> #取最后三个元素
　　
... number[7:10]
　　
[8, 9, 10]
　　number的编号最大为9，编号10指向的是第11元素，是一个不存在的元素，但是在最后一个元素之后，，因此能得到最后一个元素
　　例如：
>>> number=[1,2,3,4,5,6,7,8,9,10]　　
>>> number[7:11]
　　
[8, 9, 10]
　　
>>> number[7:12]
　　
[8, 9, 10]
　　小实验：想想下面为什么输出结果为空呢
>>> number=[1,2,3,4,5,6,7,8,9,10]　　
>>> number[-3:0]
　　
[]
　　解答：只要分片中最左边的索引比右边的索引晚出现在序列中，结果就是一个空序列
　　比如小实验中-3代表倒数第3元素，0代表第一个元素倒数第3个元素比第一个元素晚出现，即排到第一个元素后面，所以取得的结果是空序列。
　　如果需要从列表的结尾开始，取到最后一个值该怎么办
　　例如：
>>> number=[1,2,3,4,5,6,7,8,9,10]　　
>>> number[-3:]
　　
[8, 9, 10]
　　需要取得分片包括序列结尾的元素，只需要将第二个索引设置为空如上
　　如果使用正数索引能不能达到上例效果
　　例如：
>>> number=[1,2,3,4,5,6,7,8,9,10]　　
>>> #从第一元素开始输出，输出全部结果
　　
... number[0:]
　　
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
　　
>>> #最后一个元素为第一个，输出为空
　　
>>> number[:0]
　　
[]
　　
>>> #取得前3个元素
　　
>>> number[:3]
　　
[1, 2, 3]
　　
如果输出整个列，则将两个索引都设为空
　　
例如：
　　
>>> number=[1,2,3,4,5,6,7,8,9,10]
　　
>>> number[:]
　　
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
　　步长
　　python还提供了另外一个参数步长（step length）该参数通常是隐式设计，在普通分片中，步长是1。分片操作就是按照这个步长逐个遍历序列的元素，遍历后返回开始和结束点之间的所有元素，也可以理解为默认步长为1，即使没有设置步长时，步长隐式设置值为1；
　　例如：
>>> number=[1,2,3,4,5,6,7,8,9,10]　　
>>> number[0:10:1]
　　
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
　　将步长设置为比1大的数
>>> number[0:10:2]　　
[1, 3, 5, 7, 9]
　　由上例可以看出步长设置为2可以得到奇数序列。
　　步长设置为大于1的时，会得到一个跳过某些元素的序列
　　灵活使用步长
　　例如：
>>> number[0:10:3]　　
[1, 4, 7, 10]
　　
>>> number[2:6:3]
　　
[3, 6]
　　
>>> number[2:5:3]
　　
[3]
　　
>>> number[1:5:3]
　　
[2, 5]
　　也可以设置前面两个索引为空的捷径
　　例如：
>>> number[::3]　　
[1, 4, 7, 10]
　　千万注意：步长不能为0
　　步长也是可以为负数的
　　例如：
>>> number[10:0:-2]　　
[10, 8, 6, 4, 2]
　　
>>> number[0:10:-2]
　　
[]
　　
>>> number[::-2]
　　
[10, 8, 6, 4, 2]
　　
>>> number[5::-2]
　　
[6, 4, 2]
　　
>>> number[::-1]
　　
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
　　
>>> #第二个索引为0，取不到序列中的第1个元素
　　
... number[10:0:-1]
　　
>>> #设置第二个索引为空，可以取到序列的第一个元素
　　
... number[10::-1]
　　
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
　　
>>> #设置第二个索引为空，可以取到序列的第一个元素
　　
... number[2::-1]
　　
[3, 2, 1]
　　
>>> #第二个索引为0，取不到序列中的第1个元素
　　
... number[2:0:-1]
　　
[3, 2]
　　注意：使用负数步长时，设置第二个索引为空才能取到序列的第一个元素。
　　由上例可以看出负数步长和正数步长的结果相反。
　　步长小总结：对于正数步长，python会从序列的头部开始向右提取，直到最后一个元素。
　　对于负数步长，则是从序列的尾部开始向左提取元素，直到第一个元素。
　　正数步长必须让开始点小于结束点。
　　负数步长必须让开始点大于结束点。
　　序列相加
　　使用+号可以进行序列的连接操作
　　例如：
>>> [1,2,3] + [3,4,5]　　
[1, 2, 3, 3, 4, 5]
　　
>>> print(a+b)
　　
[1, 2, 8, 9]
　　
>>> c='du'
　　
>>> d='yu'
　　
>>> e='heng'
　　
>>> print(c+d+e)
　　
duyuheng
　　千万注意；只有类型相同的序列才能通过+号进行序列连接操作，不同类型的序列不能通过+号进行序列连接操作。
　　乘法
　　用一个数字n乘以一个序列会生成行的序列。在新额序列中，原来的序列将重复n次
　　例如：
>>> 'duyuheng'*5　　
'duyuhengduyuhengduyuhengduyuhengduyuheng'
　　
>>> [5]*5
　　
[5, 5, 5, 5, 5]
　　从上例可以看，序列被重复了对应的次数，而不是乘法运算
　　初始化一个长度为x的序列，就需让每个编码的位置上都是空值，此时需要一个值代表空值，即里面没有任何元素
　　例如：
>>> #初始化5个为空的序列　　
... sq=[None]*5
　　
>>> print(sq)
　　
[None, None, None, None, None]
　　None代表python的内建值，代表什么都没有
　　乘法小总结：python中的序列乘法可以快速做一些初始化操作。
　　成员资格
　　in运算符用于检验某个条件是否为真，并返回检验结果，检验结果为真返回True，结果为假返回False。
　　例如：
>>> name='duyuheng'　　
>>> #检测字符串h是否早字符串中
　　
... 'h' in name
　　
True
　　
>>> #检测s是否在字符串内
　　
... 's' in  name
　　
False
　　
>>> user=['duyuheng','duzhaoli','changting']
　　
>>> #检测字符串是否在字符串列表中
　　
... 'changting' in user
　　
True
　　
>>> 'xuwei' in user
　　
False
　　
>>> numbers=[1,2,3,4,5]
　　
>>> #检测数字是否在数字列表中
　　
... 1 in numbers
　　
True
　　
>>> 7 in numbers
　　
False
　　
>>> eng='& wo ai ni * mei li de gu niang'
　　
>>> #检测特殊符号是否在字符串中
　　
>>> '*' in eng
　　
True
　　
>>> '$' in eng
　　
False
　　
>>> 'a' in numbers
　　
False
　　
>>> 3 in name
　　
Traceback (most recent call last):
　　
  File "<stdin>", line 1, in <module>
　　
TypeError: 'in <string>' requires string as left operand, not int
　　
>>> type(name)
　　
<class 'str'>
　　成员资格小总结：用in可以很好的检测字符或数字是否在对应的列表中。
　　但是从上例看出数字类型不能在字符串类型中通过in进行成员资格检测，
　　而字符串类型可以在数字类型中通过用in进行成员资格检测
　　长度、最小值和最大值
　　python提供了长度、最小值和最大值的内建函数，对应的内建函数分别是len、min和max.
　　使用方法
　　例如：
>>> numbenrs=[300,200,100,800,500]　　
>>> len(numbenrs)
　　
5
　　
>>> max(numbenrs)
　　
800
　　
>>> min(numbenrs)
　　
100
　　也可以这样使用
>>> max(5,3,10,7)　　
10
　　
>>> min(5,3,10,-7)
　　
-7
　　长度、最小值和最大值小总结：
　　len函数返回序列中所包涵元素的数量。
　　max函数和min函数分别返回序列中的最大值和最小值。
　　max和min虚函数的参数不是一个序列，而是以多个数字直接作为参数，直接求多个数字的最大值和最小值。