一、元组
Python的元组与列表类似，不同之处在于元组的元素不能被修改。元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开。
1、元组可通过索引和切片访问，如下：
a = ("a", "b", "c")
print(a)
print(a[0:2])
输出：
('a', 'b', 'c')
('a', 'b')
2、元组中的元素值是不允许修改的，但是我们可以对元组进行连接组合，用"+"
举例：
a = ("a", "b", "c")
b = ("d", "e")
print(a + b)
输出结果：('a', 'b', 'c', 'd', 'e')
3、元组中的元素值是不允许删除的，但是可以使用del语句来删除整个元组
a = ("a", "b", "c")
del a
4、元组计算符
a = ("a", "b", "c")
# 计算元素个数len(tup)
num = len(a)
print("元素个数为：%d" % (num) )
# 复制
print("将元组a复制3次:")
print(a*3)
# 判断元素是否在元组里存在
print("元组a里是否有\"a\":")
print("a" in a)
#迭代
for i in a:
print(i)
输出结果：
元素个数为：3
将元组a复制3次:
('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c')
元组a里是否有"a":
True
a
b
c
5、元组内建函数
a = ("a", "b", "c")
list1 = ["1", "2", "3"]
# 1、计算元素个数len(tuple)
print("元素个数为：%d" % len(a))
# 2、获取元组中元素最大值
print("元素中最大值：%s" % max(a))
# 3、获取元组中元素最小值
print("元素中最小值：%s" % min(a))
# 4、将列表转换为元组
print(list1)
b = tuple(list1)
print(b)
输出结果：
元素个数为：3
元素中最大值：c
元素中最小值：a
['1', '2', '3']
('1', '2', '3')
二、列表
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字(它的位置或索引)，第一个索引是0，第二个索引是1，依此类推。
序列都可以进行的操作包括索引、切片、加、乘、检查成员。此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
1、列表可通过索引和切片访问，如下：
list1 = ["a", "b", "c"]
print(list1[1])
print(list1[1:3])
输出结果：
b
['b', 'c']
2、列表支持更新
可以对列表的数据进行修改或更新；
(1).使用append()方法添加列表项
(2).使用del删除某个元素
list1 = ["a", "b", "c"]
# 1.使用append()方法添加列表项
list1.append("d")
print(list1)
# 2.使用del删除某个元素
del list1[2]
print(list1)
输出结果：
['a', 'b', 'c', 'd']
['a', 'b', 'd']
3、列表的运算符
ist1 = ["a", "b", "c"]
list2 = ["d", "e"]
# 1.获取列表个数len(list)
print("列表list1长度为：%d" % len(list1))
# 2.组合
print(list1+list2)
# 3.元素是否存在于列表中
print("a" in list1)
# 4.重复
print("将list2复制4次:")
print(list2*4)
# 5.迭代
for i in list1:
print("元素为：%s" % i)
输出结果：
列表list1长度为：3
['a', 'b', 'c', 'd', 'e']
True
将list2复制4次:
['d', 'e', 'd', 'e', 'd', 'e', 'd', 'e']
元素为：a
元素为：b
元素为：c
4、列表内建函数
(1) len(list) 获取列表元素个数
(2) max(list) 返回列表元素最大值
(3) min(list) 返回列表元素最小值 min(list)
(4) list(seq) 将元组转换为列表
(5) list.append(obj) 在列表末尾添加新的对象
(6) list.count(obj) 统计某个元素在列表中出现的次数
(7) list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
(8) list.index(obj) 从列表中找出某个值第一个匹配项的所有位置
(9) list.insert(index, obj) 将对象插入列表
(10) list.pop([index=-1]) 要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值
(11) list.remove(obj) 移除列表中某个值的第一个匹配项 (12) list.reverse() 反向列表中的元素
(13) list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序(默认)
list1 = ["a", "b", "c"]
tuple1 = ("d", "e")
# 1.len(list) 获取列表元素个数
print("列表list1元素个数为：%d" % len(list1))
# 2.max(list) 返回列表元素最大值
print("列表list1元素最大值为：%s" % max(list1))
# 3.min(list) 返回列表元素最小值 min(list)
print("列表list1元素最小值为：%s" % min(list1))
# 4.list(seq) 将元组转换为列表
list2 = list(tuple1)
print("将元组tuple1转换为列表list2:", list2)
# 5. list.append(obj) 在列表末尾添加新的对象
list1.append("1")
list1.append(2)
print("list1新增对象后：", list1)
# 6. list.count(obj) 统计某个元素在列表中出现的次数
print("list1里元素\"c\"出现次数：%d" % list1.count("c"))
# 7. list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list2.extend(list1)
print("list2拓展list1元素后：", list2)
# 8. list.index(obj) 从列表中找出某个值第一个匹配项的所有位置
print("从列表list2中于\'a\'第一个匹配的索引值是：", list2.index('a'))
# 9. list.insert(index, obj) 将对象插入列表
print("插入前list1：", list1)
list1.insert(1, 123)
print("将对象123插入到list1索引1位置后，list1:", list1)
# 10. list.pop([index=-1]) 要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值
list_del = list1.pop(1)
print("删除的项为：", list_del)
print("删除后list1列表为：", list1)
# 11. list.remove(obj) 移除列表中某个值的第一个匹配项
list1.remove(2)
print("移除项2后，list1为：", list1)
# 12. list.reverse() 反向列表中的元素
list1.reverse()
print("反向list1元素后：", list1)
# 13. list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
list1.sort()
print("list1升序排列后：", list1)
list1.sort(reverse=True)
print("list1降序排列后：", list1)
list3 = [(1, 2), (3, 1), (3, 3), (2, 5)]
print("list3未排序前：", list3)
#获取列表的第二个元素
def getSecond(elem):
return elem[1]
#指定第二个元素排序
list3.sort(key=getSecond)
print("list3指定第二个元素排序后:", list3)
输出结果：
列表list1元素个数为：3
列表list1元素最大值为：c
列表list1元素最小值为：a
将元组tuple1转换为列表list2: ['d', 'e']
list1新增对象后： ['a', 'b', 'c', '1', 2]
list1里元素"c"出现次数：1
list2拓展list1元素后： ['d', 'e', 'a', 'b', 'c', '1', 2]
从列表list2中于'a'第一个匹配的索引值是： 2
插入前list1： ['a', 'b', 'c', '1', 2]
将对象123插入到list1索引1位置后，list1: ['a', 123, 'b', 'c', '1', 2]
删除的项为： 123
删除后list1列表为： ['a', 'b', 'c', '1', 2]
移除项2后，list1为： ['a', 'b', 'c', '1']
反向list1元素后： ['1', 'c', 'b', 'a']
list1升序排列后： ['1', 'a', 'b', 'c']
list1降序排列后： ['c', 'b', 'a', '1']
list3未排序前： [(1, 2), (3, 1), (3, 3), (2, 5)]
list3指定第二个元素排序后: [(3, 1), (1, 2), (3, 3), (2, 5)]
