Python 提供的几种序列：字符串、 列表、元组
序列通用操作：
1. 索引
Python 从 0 开始计数，从左至右索引依次是 0，1，...，n。从右至左计数来存取元素称为负数索引，依次是 -1，-2，...，-n 。
li[-n] == li[len(list) - n]
2. 切片
序列切片是指使用序列序号对截取序列中的任何部分，从而得到一个新序列。切片操作符是在 [ ] 内提供一对可选数字，用 “ : ” 分隔。冒号前的数字表示切片的开始位置，冒号后的数字表示切片截至（但不包括）位置。
3. 加
对于两个序列，加法表示连接操作，进行操作的两个序列必须是相同的类型（字符串、列表、元组）才可以连接。
a_list = [1, 1, 'x', 'z']
b_list = ["hello"]
a_list + b_list # [1, 1, 'x', 'z', 'hello']
4. 乘
a = 'la'
a * 3 # 'lalala'
```
##### 5. 检查某个元素是否属于序列 ：`in` 和 `not in `
##### 6. 其他一些函数的使用：
1. len()
2. min()
3. max()
4. sum(seq[index1,index2])
### 1. 列表
列表（list）是一组有序项目的数据结构。Python 在创建列表时，解释器在内存中生成一个类似数组的数据结构存储数据，数据项自上而下存储：
##### 1.1 列表举例：
```python
[10, 20, 30, 40]
['frog', 'dog', 'cat']
['learned', 3.2, 5, ['a', 8], True]
1.2 列表操作：
1. 创建列表：
a_list = ['a', 'b', 'c']
```
##### 2. 读取元素：
```python
a_list = ['a', 'b', 'c']
a_list[0]
3. 修改 list 中的元素: 只需直接给元素赋值
a_list = ['a', 'b', 'c']
a_list[0] = 123
print a_list # [123, 'b', 'c']
```
##### 4. 增加元素
（1）"+"：
```python
a_list = [1]
a_list = a_list + ['George', 2.0]
a_list # [1, 'George', 2.0]
```
（2）append():
```python
a_list = [1, 'Geroge', 2.0]
a_list.append(['HAH'])
a_list # [1, 'Geroge', 2.0, ['HAH']]
```
（3）extend():
```python
a_list = [1, 'Geroge', 2.0, ['HAH']]
a_list.extend(['x', 'y'])
a_list # [1, 'Geroge', 2.0, ['HAH'], 'x', 'y']
```
（4）insert(): 将一个元素插入到任意位置 [list.insert(index, obj)](http://www.runoob.com/python/att-list-insert.html)
```python
a_list = [1, 'Geroge', 2.0, ['HAH'], 'x', 'y']
a_list.insert(0, 'bb')
a_list # ['bb', 1, 'Geroge', 2.0, ['HAH'], 'x', 'y']
a_list.insert(3,True)
a_list # ['bb', 1, 'Geroge', True, 2.0, ['HAH'], 'x', 'y']
```
##### 5. 检索元素
（1）count() 方法计算列表中某个元素出现次数
```python
a_list = [1, 2, 3, 1, 3]
a_list.count(1) # 2
```
（2）in 运算符返回某个元素是否在该列表中
```python
a_list = [1, 2, 3, 1, 3]
3 in a_list # True
3 not in a_list # False
'x' in a_list # False
```
##### 6. 删除元素
（1）使用 del 语句删除某个特定位置的元素
```python
a_list = [1, 2, 3, 1, 3]
del a_list[1]
a_list # [1, 3, 1, 3]
```
（2）remove() 删除列表中第一个匹配项
```python
a_list = [1, 3, 1, 3]
a_list.remove(3)
a_list # [1, 1, 3]
```
（3）pop() 弹出指定位置的元素，缺省参数时弹出最后一个元素
```python
a_list = [1, 1, 3]
a_list.pop() # 3
a_list.extend(['x','y','z'])
a_list # [1, 1, 'x', 'y', 'z']
a_list.pop(3) # 'y'
a_list # [1, 1, 'x', 'z']
```
##### 7. 列表的方法还有：
> * list.reverse() 原地反转列表元素顺序
> * list.sort(obj) 为列表排序
### 2. 元组
元组一旦创建就不能改变。
##### 元组操作
（1）建立元组
```python
tup = (1,2,'a','b','c')
tup # (1, 2, 'a', 'b', 'c')
```
（2）访问元组
```python
tup = (1, 2, 'a', 'b', 'c')
tup[1:3] # (2, 'a')
（3）元组连接
tup1 = (1, 2, 3, 4, 5)
tup2 = ('a', 'b', 'c')
tup1 + tup2 # (1, 2, 3, 4, 5, 'a', 'b', 'c')
tup1 = tup2
tup1 # ('a', 'b', 'c')
（4）删除元组: 元组中的元素值不允许删除，但可使用 del 删除整个元组
tup1 = ('a', 'b', 'c')
del tup1
3. 字符串
字符串操作
（1）index: string.index(str, beg=0, end=len(string))
s = 'Python'
s.index('P') # 0
s.index('h', 1, 4) # 3
s.index('h', 4, 5)
#Traceback (most recent call last):
#File "<stdin>", line 1, in <module>
#ValueError: substring not found
（2）find: string.find(str, beg=0, end=len(string))
s = 'Python'
s.find('w') # -1
s.find('t', 1) # 2
s.find('t', 3, 4) # -1
（3）replace: string.replace(str1, str2, num=string.count(str1))
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
s = 'lalala'
s.replace('a', 'o') # 'lololo'
s.replace('l', 'h', 2) # 'hahala'
（4）count: string.count(str, beg=0, end=len(string))
s = 'alienalien'
s.count('a') # 2
s.count('a', 0, 3) # 1
（5）split: string.split(str="", num=string.count(str))
split 默认以字符串中的空格作为分隔符进行分割
s = 'Python'
s.split() # ['Python']
s = 'hello Python I love it .'
s.split() # ['hello', 'Python', 'I', 'love', 'it', '.']
s.split(‘ ‘, 2) # ['hello', 'Python', 'I love it .']
```
（6）join: **[string.join(seq)](http://www.runoob.com/python/att-string-join.html)**
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
```python
c = ['hello', 'Python', 'I love it .']
s = ' '.join(c)
s # 'hello Python I love it .'
字符串、列表、 元组转换
（1）字符串 >>> 列表：list()
str = '123.45'
list(str) # [ '1', '2', '3', '.', '4', '5']
（2）字符串 >>> 元组： tuple()
str = '123.45'
tuple(str) # ('1', '2', '3', '.', '4', '5')
（3）列表、元组 >>> 字符串：join()
s = ('a', 'n', 'c', 'h', 'o', 'r')
''.join(s) # 'anchor'
a = ['a', 'b', 'c', 'd']
''.join(a) # 'abcd'
