python负数索引
‘壹’ python 通用的序列操作
序列 （sequence）是Python最基本的一种数据结构。
序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，依此类推。Python的序列索引支持负数，-1表示序列的最后一个元素，这是Python不同其他很多种语言不同的地方。
Python内置了多种序列，列表、元组、字符串是其中最常用的三种，本文为你描述各种序列的通用操作。
索引从0开始，索引号为0的元素为1，greeting的索引号为0的元素为'H'。
你可能注意到'Hello'和'H'都用单引号包围，这是Python不同于其他语言的另一个地方。Python并没有专门用于表示字符的数据类型，因此一个字符就是一个只包含一个元素的字符串。
Python的序列索引支持负数，-1表示倒数第一个元素。
切片 （slicing）操作用于访问序列特定 范围 内的元素。在一对方括号内使用两个索引，并用冒号隔开：
注意到，返回的序列并未包含愿序列的第6个元素7，就相当于数学集合中的 左闭右开区间 操作。
换言之，你提供两个索引来指定切片的边界，其中第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内。
保留冒号，省略羡运备第一个索引，表示从序列起始位置开始切片；省略第二个索引，表示切片到序列末尾，包含最后一个元素：
这个操作的效果是：在指定的区间内间隔取元素，语法格式为：
例如：
步长为正数时，它从起点移到终点，而步长为负数时，它从终点移到起点。
可以使用加法运算（+运算符）拼接两个序列：
从错误消息兄毁可知，不能拼接列表和字符串，虽然它们都是序列。一般而言，不悄配能拼接不同类型的序列。
将序列与数x 相乘时，将重复这个序列x 次来创建一个新序列：
初始化一个长度为10的空列表：
成员资格检查判定一个元素是否存在于集合中，如存在返回True，否则返回False，实际上是一个布尔表达式。
语法：
例如：
内置函数 len 返回序列包含的元素个数，而 min 和 max 分别返回序列中最小和最大的元素。
Python通用的序列操作有：索引、切片、乘法、成员资格检查、长度、最小值和最大值。
‘贰’ python之序列
Python 中的序列是一块可存放多个值的连续内存空间，所有值按一定顺序排列，每个值所在位置都有一个编号，称其为索引，我们可以通过索引访问其对应值。
其实字符串就是序列结构，除此之外常见的序列结构还包括列表、元组等。
序列索引支持非负数和负数， 索引为非负数弊改，从 0 开始 ，如下所示：
以字符串为例，如下所示：
输出结果租老判：
从结果来看，我们使用非负数索引与负数索引得到的结果一致。
切片操作可以访问一定范围内的元素，语法如下所示：
以字符串为例，如下所示：
输出结果：
Python 支持类型相同的序列使用 + 作相加操作，该操作不会去除重复的元素。以字符串为例，如下所示：
输出结果：
Python 中，使用数字 n 乘以一个序列会生成新的序列，内容为原来序列被重复 n 次的结果。以字符串为例，如下所示：
输出结果：
Python 使用 in 关键字检查某元素是否为序列的成员，语法如下：
val in seq
以字符串为例，如下所示：
输出结果：
True
2.6 内置函数
len()—— 计算序列的长度
max()——找出序列中的最大元素
min()——找出序列中的最小元素
list() ——将序列转换含档为列表
str() ——将序列转换为字符串
sum()——计算元素的和
sorted()——对元素进行排序
enumerate()——将序列组合为一个索引序列，多用在 for 循环中
举例，如下所示：
输出结果：
‘叁’ 如何在python列表中查找某个元素的索引
1、方法一： 利用数组自身的特性 a.index(target), 其中a是目标list，target是需要的下标对应的值。代码如下：
2、分片：
分片用于截取某个范围内的元素，通过:来指定起始区间（左闭右开区间，包含左侧索引值对应的元素，但不包含右测索引值对应的元素）。
分片包括起始索引对应的元素，但不包括终止索引对应的元素，索引为正值时可以发生越界但只会取到最后一个元素。如果索引值为负值，则表示从最右边元素开始，此时需避免索引越界。
‘肆’ Python内置函数range
range 类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。
range 构造器的参数必须为整数（可以是内置的 int 或任何实现了 __index__ 特殊方法的对象）。 如果省略 step 参数，其默认值为 1 。 如果省略 start 参数，其默认值为 0 ，如果 step 为零则会引发 ValueError。
如果 step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop 。
如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i ，但限制条件改为 i >= 0 且 r[i] > stop .
如果 r[0] 不符合值的限制条件，则该 range 对象为空。 range 对象确实支持负索引，但是会将其解戚颤读为从正索引所确定的序列的末尾开始索引。
元素绝对值大于 sys.maxsize 的 range 对象是被允许的，但某些特性 (例如 len()) 可能引发 OverflowError。
一些 range 对象的例子:
range 对象实现了 一般 序列的所有操作，但拼接和重复除外（这是由于 range 对象只能表示符合严格模式的序列，而重复和拼接通常都会违反这样的模式）。
start
start 形参的值 (如果该形参未提供则为 0 )
stop
stop 形参的值
step
step 形参的值 (如果该形参未提供则为 1 )
range 类型相比常规 list 或 tuple 的优势在于一个 range 对象总是占用固定数量的（较小）内存，不论其所表示的范围有多大（因为它只保存了 start , stop 和 step 值，并会根据需要计算具体单项或子范围的值）。
range 对象实现了 collections.abc.Sequence ABC，提供如包含检测、元素索引查找、切片等特性，并支持负索引
使用 == 和 != 检测 range 对象是否相等是将其作为序列来比较。 也就是说，如果两个 range 对象表示相同的值序列就认誉困为它们是相等的。 （请注意比较结果相等的两个 range 对象可能会具有不同的 start, stop 和 step 属性，例如 range(0) == range(2, 1, 3) 而 range(0, 3, 2) == range(0, 4, 2) 。）庆仔念
在 3.2 版更改: 实现 Sequence ABC。 支持切片和负数索引。 使用 int 对象在固定时间内进行成员检测，而不是逐一迭代所有项。
在 3.3 版更改: 定义 '==' 和 '!=' 以根据 range 对象所定义的值序列来进行比较（而不是根据对象的标识）。
3.3 新版功能: start, stop 和 step 属性。
‘伍’ Python中[::-1]这个代码是什么意思
[::-1]是对字符串的截取操作，str[a：b]表示截取字符串的a开始的位置，b表示结束位置。b是负数，表示去除后几位。
由于Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。
取前3个元素，利用切片操作就是“L[0:3]”。如果第一个索引是0，还可以省略“L[:3]”。
也可以从索引1开始，取出2个元素出来，L[1:3]，显示的结果就是“['Sarah', 'Tracy']”。
类似的，既然Python支持L[-1]取倒数第一个元素，那么同样支持倒数切片，试试“L[-2:]”，返回的就是“['Bob', 'Jack']”，记住倒数第一个元素的索引是-1。
(5)python负数索引扩展阅读：
对于具有序列结构的数据来说，切片操作的方法是：consequence[start_index: end_index: step]。
1、start_index：表示是第一个元素对象，正索引位置默认为0；负索引位置默认为 -len(consequence)
2、end_index：表示是最后一个元素对象，正索引位置默认为 len(consequence)－1；负索引位置默认为 -1。
3、step：表示取值的步长，默认为1，步长值不能为0。
‘陆’ Python中的几种数据类型
大体上把Python中的数据类型分为如下几类：
Number(数字) 包括int,long,float,complex
String(字符串) 例如：hello,hello,hello
List(列表) 例如：[1,2,3],[1,2,3,[1,2,3],4]
Dictionary(字典) 例如：{1:nihao,2:hello}
Tuple(元组) 例如：(1,2,3,abc)
Bool(布尔) 包括True、False
由于Python中认为所有的东西都是对象，所以Python不用像其它一些高级语言那样主动声缺慎竖明一个变量的类型。
例如我要给一个变量i赋值100，python的实现 ：
i=100
C#的实现：
int i = 100;
下面一一简单介绍这几种数据类型
数字类型
int和long
之所以要把int和long放在一起的原因是python3.x之后已经不区分int和long,统一用int。python2.x还是区分的。下面我以Python2.7为例：
i = 10
type(i)
i=10000000000
type(i)
那么为什么10就是int,10000000000就是long呢，当然这就和int的最大值有关了，int类孝毁型的最大值为231-1，即2147483647，也可以用sys.maxint。
2**31-1
2147483647L
sys.maxint
2147483647
为什么用上面的方法求的值就是long型的呢(数字后面加‘L’表示是long型)，因为2**31的值为2147483648,这个值是一个long型，用一个long型减去1，结果还是一个long,但实际上int型的最大值就是2147483647
type(2147483647)
type(2147483648)
float类型
float类型和其它语言的float基本一致，浮点数，说白了，就是带小数点的数，精度与机器相关。例如：
i = 10000.1212
type(i)
complex：复数类型，具体含义及用法可自行查看相关文档。
字符串类型
字符串的声明有三种方式：单引号、双引号和三引号(包括三个单引号或三个双引号)。例如：
str1 = hello world
str2 = hello world
str3 = hello world
str4 = hello world
print str1
hello world
print str2
hello world
print str3
hello world
print str4
hello world
Python中的字符串有两种数据类型：str类型和unicode类型。str类型采用的ASCII编码，也就是说它无法表示中文。unicode类型采用unicode编码，能够表示任意字符，包括中文及其它语言。并且python中不存在像c语言中的char类型，就算是单个字符也是字符串类型。字符串默认采用的ASCII编码，如果要显示声明为unicode类型的话，需要在字伏大符串前面加上u或者U。例如：
str1 = hello
print str1
hello
str2 = u中国
print str2
中国
由于项目中经常出现对字符串的操作，而且由于字符串编码问题出现的问题很多，下面，来说一下关于字符串的编码问题。在与python打交道的过程中经常会碰到ASCII、Unicode和UTF-8三种编码。具体的介绍请参见这篇文章。我简单的理解就是，ASCII编码适用英文字符，Unicode适用于非英文字符(例如中文、韩文等)，而utf-8则是一种储存和传送的格式，是对Uncode字符的再编码(以8位为单位编码)。例如：
u = u汉
print repr(u) # uu6c49
s = u.encode(UTF-8)
print repr(s) # xe6xb1x89
u2 = s.decode(UTF-8)
print repr(u2) # uu6c49
解释：声明unicode字符串”汉“，它的unicode编码为”u6c49“，经过utf-8编码转换后，它的编码变成”xe6xb1x89“。
对于编码的经验总结：
1.在python文件头声明编码格式 ;
#-*- coding: utf-8 -*-
2.将字符串统一声明为unicode类型，即在字符串前加u或者U;
3.对于文件读写的操作，建议适用codecs.open()代替内置的open()，遵循一个原则，用哪种格式写，就用哪种格式读;
假设在一个以ANSI格式保存的文本文件中有“中国汉字”几个字，如果直接用以下代码，并且要在GUI上或者在一个IDE中打印出来(例如在sublime text中，或者在pydev中打印)，就会出现乱码或者异常，因为codecs会依据文本本身的编码格式读取内容：
f = codecs.open(d:/test.txt)
content = f.read()
f.close()
print content
改用如下方法即可(只对中文起作用)：
# -*- coding: utf-8 -*-
import codecs
f = codecs.open(d:/test.txt)
content = f.read()
f.close()
if isinstance(content,unicode):
print content.encode(utf-8)
print utf-8
else:
print content.decode(gbk).encode(utf-8)
列表类型
列表是一种可修改的集合类型，其元素可以是数字、string等基本类型，也可以是列表、元组、字典等集合对象，甚至可以是自定义的类型。其定义方式如下：
nums = [1,2,3,4]
type(nums)
print nums
[1, 2, 3, 4]
strs = [hello,world]
print strs
[hello, world]
lst = [1,hello,False,nums,strs]
type(lst)
print lst
[1, hello, False, [1, 2, 3, 4], [hello, world]]
用索引的方式访问列表元素，索引从0开始,支持负数索引，-1为最后一个.
lst = [1,2,3,4,5]
print lst[0]
1
print lst[-1]
5
print lst[-2]
4
支持分片操作，可访问一个区间内的元素，支持不同的步长，可利用分片进行数据插入与复制操作
nums = [1,2,3,4,5]
print nums[0:3] #[1, 2, 3] #前三个元素
print nums[3:] #[4, 5] #后两个元素
print nums[-3:] #[3, 4, 5] #后三个元素 不支持nums[-3:0]
numsclone = nums[:]
print numsclone #[1, 2, 3, 4, 5] 复制操作
print nums[0:4:2] #[1, 3] 步长为2
nums[3:3] = [three,four] #[1, 2, 3, three, four, 4, 5] 在3和4之间插入
nums[3:5] = [] #[1, 2, 3, 4, 5] 将第4和第5个元素替换为[] 即删除[three,four]
支持加法和乘法操作
lst1 = [hello,world]
lst2 = [good,time]
print lst1+lst2 #[hello, world, good, time]
print lst1*5 #[hello, world, hello, world, hello, world, hello, world, hello, world]
列表所支持的方法，可以用如下方式查看列表支持的公共方法：
[x for x in dir([]) if not x.startswith(__)]
[append, count, extend, index, insert, pop, remove, reverse, sort]
def compare(x,y):
return 1 if xy else -1
#【append】 在列表末尾插入元素
lst = [1,2,3,4,5]
lst.append(6)
print lst #[1, 2, 3, 4, 5, 6]
lst.append(hello)
print lst #[1, 2, 3, 4, 5, 6]
#【pop】 删除一个元素，并返回此元素的值 支持索引 默认为最后一个
x = lst.pop()
print x,lst #hello [1, 2, 3, 4, 5, 6] #默认删除最后一个元素
x = lst.pop(0)
print x,lst #1 [2, 3, 4, 5, 6] 删除第一个元素
#【count】 返回一个元素出现的次数
print lst.count(2) #1
#【extend】 扩展列表 此方法与“+”操作的不同在于此方法改变原有列表，而“+”操作会产生一个新列表
lstextend = [hello,world]
lst.extend(lstextend)
print lst #[2, 3, 4, 5, 6, hello, world] 在lst的基础上扩展了lstextend进来
#【index】 返回某个值第一次出现的索引位置，如果未找到会抛出异常
print lst.index(hello) #5
#print lst.index(kitty) #ValueError: kitty is not in list 出现异常
#【remove】 移除列表中的某个元素，如果待移除的项不存在，会抛出异常 无返回值
lst.remove(hello)
print lst #[2, 3, 4, 5, 6, world] hello 被移除
#lst.remove(kitty) #ValueError: list.remove(x): x not in list
#【reverse】 意为反转 没错 就是将列表元素倒序排列,无返回值
print lst #[2, 3, 4, 5, 6, world]
lst.reverse()
print lst #[2, 3, 4, 5, 6, world]
#【sort】 排序
print lst #由于上面的反转 目前排序为 [world, 6, 5, 4, 3, 2]
lst.sort()
print lst #排序后 [2, 3, 4, 5, 6, world]
nums = [10,5,4,2,3]
print nums #[10,5,4,2,3]
nums.sort(compare)
print nums #[2, 3, 4, 5, 10]
列表转换为迭代器。
所谓的迭代器就是具有next方法(这个方法在调用时不需要任何参数)的对象。在调用next方法时，迭代器会返回它的下一个值。如果next方法被调用，但迭代器没有值可以返回，就会引发一个StopIteration异常。迭代器相对于列表的优势在于，使用迭代器不必一次性将列表加入内存，而可以依次访问列表的数据。
依然用上面的方法查看迭代器的公共方法：
lst = [1,2,3,4,5]
lstiter = iter(lst)
print [x for x in dir(numiter) if not x.startswith(__)]
[next]
没错，只有next一个方法，对于一个迭代器，可以这样操作：
lst = [1,2,3,4,5]
lstiter = iter(lst)
for i in range(len(lst)):
print lstiter.next() #依次打印
1
2
3
4
5
元组类型
元组类型和列表一样，也是一种序列，与列表不同的是，元组是不可修改的。元组的声明如下：
lst = (0,1,2,2,2)
lst1=(hello,)
lst2 = (hello)
print type(lst1) # 只有一个元素的情况下后面要加逗号 否则就是str类型
print type(lst2) #
字典类型
字典类型是一种键值对的集合，类似于C#中的Dictionary
dict1 = {}
print type(dict1) # 声明一个空字典
dict2 = {name:kitty,age:18} #直接声明字典类型
dict3 = dict([(name,kitty),(age,18)]) #利用dict函数将列表转换成字典
dict4 = dict(name=kitty,age=18) #利用dict函数通过关键字参数转换为字典
dict5 = {}.fromkeys([name,age]) #利用fromkeys函数将key值列表生成字典，对应的值为None {age: None, name: None}
字典基本的操作方法：
#【添加元素】
dict1 = {}
dict1[mykey] = hello world #直接给一个不存在的键值对赋值 即时添加新元素
dict1[(my,key)] = this key is a tuple #字典的键可以是任何一中不可变类型，例如数字、字符串、元组等
#【键值对个数】
print len(dict1)
#【检查是否含有键】
print mykey in dict1 #True 检查是否含有键为mykey的键值对
print hello in dict1 #False
#【删除】
del dict1[mykey] #删除键为mykey的键值对
继续利用上面的方法查看字典的所有公共方法：
[x for x in dir({}) if not x.startswith(__)]
[clear, , fromkeys, get, has_key, items, iteritems, iterkeys, itervalues,
keys, pop, popitem, setdefault, update, values, viewitems, viewkeys, viewvalues]
dict.clear() 删除字典中所有元素
dict.() 返回字典(浅复制)的一个副本
dict.get(key,default=None) 对字典dict 中的键key,返回它对应的值value，如果字典中不存在此键，则返回default 的值(注意，参数default 的默认值为None)
dict.has_key(key) 如果键(key)在字典中存在，返回True，否则返回False. 在Python2.2版本引入in 和not in 后，此方法几乎已废弃不用了，但仍提供一个 可工作的接口。
dict.items() 返回一个包含字典中(键, 值)对元组的列表
dict.keys() 返回一个包含字典中键的列表
dict.values() 返回一个包含字典中所有值的列表
dict.iter() 方法iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代器，而不是一个列表。
dict.pop(key[, default]) 和方法get()相似，如果字典中key 键存在，删除并返回dict[key]，如果key 键不存在，且没有给出default 的值，引发KeyError 异常。
dict.setdefault(key,default=None) 和方法set()相似，如果字典中不存在key 键，由dict[key]=default 为它赋值。
dict.setdefault(key,default=None) 和方法set()相似，如果字典中不存在key 键，由dict[key]=default 为它赋值。
布尔类型
布尔类型即True和False,和其它语言中的布尔类型基本一致。下面列出典型的布尔值
print bool(0) #False
print bool(1) #True
print bool(-1) #True
print bool([]) #False
print bool(()) #False
print bool({}) #False
print bool() #False
print bool(None) #False
‘柒’ Python中，tuple的优势是什么
一、首先，看看三者最基本的区别：
List是顺序的，可变的。
Dictrionary是无顺序的，可变的。Dictionary是内置数据类型之一，它定义了键和值之间一对一的关系。每一个元素都是一个 key-value 对, 整个元素集合用大括号括起来。
Tuple 是顺序的，不可变 list。 一旦创建了一个 tuple 就不能以任何方式改变它。
定义 tuple 与定义 list 的方式相同, 除了整个元素集是用小括号包围的而不是方括号
你说的对，Tuple 是不可变 list。 一旦创建了一个 tuple 就不能以任何方式改变它。
二、Tuple 与 list 的相同之处
定义 tuple 与定义 list 的方式相同, 除了整个元素集是用小括号包围的而不是方括号。
Tuple 的元素与 list 一样按定义的次序进行排序。 Tuples 的索引与 list 一样从 0 开始, 所以一个非空 tuple 的第一个元素总是t[0]。
负数索引与 list 一样从 tuple 的尾部开始计数。
与 list 一样分片 (slice) 也可以使用。注意当分割一个 list 时, 会得到一个新的 list ；当分割一个 tuple 时, 会得到一个新的 tuple。
三、Tuple 不存在的方法
您不能向 tuple 增加元素。Tuple 没有 append 或 extend 方法。
您不能从 tuple 删除元素。Tuple 没有 remove 或 pop 方法。
您不能在 tuple 中查找元素。Tuple 没有 index 方法。
然而, 您可以使用 in 来查看一个元素是否存在于 tuple 中。
四、用 Tuple 的好处
Tuple 比 list 操作速度快。如果您定义了一个值的常量集，并且唯一要用它做的是不断地遍历它，请使用 tuple 代替 list。
如果对不需要修改的数据进行 “写保护”，可以使代码更安全。使用 tuple 而不是 list 如同拥有一个隐含的 assert 语句，说明这一数据是常量。如果必须要改变这些值，则需要执行 tuple 到 list 的转换。
五、Tuple 与 list 的转换
Tuple 可以转换成 list，反之亦然。内置的 tuple 函数接收一个 list，并返回一个有着相同元素的 tuple
而 list 函数接收一个 tuple 返回一个 list。从效果上看，tuple 冻结一个 list，而 list 解冻一个 tuple。
六、Tuple 的其他应用
一次赋多值
>>> v = ('a', 'b', 'e')
>>> (x, y, z) = v