python 基础教程 笔记2 列表和元组
目录
复杂：列表，元祖，集合，字典
数字：整型，浮点型
字符：字符串
python 包含6种内建的序列：列表、元组、字符串、Unicode字符串、buffer对象和xrange对象
不同点：
元组中的元素不可修改，列表中的元素可以修改。一般情况下使用列表的多些，使用元组理由通常是技术性，它与python内部的运作方式有关，这也是内建函数可能返回元组的原因。一般来说，在几乎所有的情况下列表都可以替代元组(例外：使用元组作为字典的键，这种情况下，因为键不可以修改，所以不能使用列表)
例如
In [11]: l1 = [1,2,3,4]
In [12]: t1 = (3,4,5,6)
In [13]: l1[2]
Out[13]: 3
In [14]: l1[2] = 7
In [15]: l1
Out[15]: [1, 2, 7, 4]
In [16]: t1[2]
Out[16]: 5
In [17]: t1[2] = 8
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-17-749455d60f3a> in <module>()
----> 1 t1[2] = 8
TypeError: 'tuple' object does not support item assignment
In [18]: t1
Out[18]: (3, 4, 5, 6)
相同点：
列表也元组都可以嵌套，同时列表和元组都是不可变对象
In [15]: t2
Out[15]: (34, 'ad', '34', ('uia', 343, 989))
In [16]: id(t2)
Out[16]: 140233458935352
In [17]: t2 = (t1,34,'a')
In [19]: t2
Out[19]: ((3, 4, 5, 6), 34, 'a')
#t2 的值发生变化了，同时t2的引用也发生变化了
In [20]: id(t2)
Out[20]: 140233470864192
In [21]: l2
Out[21]: [3, 4, 5, [1, 2, 7, 4]]
In [22]: id(l2)
Out[22]: 140233470246024
In [23]: l2 = [l3,l1]
#l2 的值发生变化，同时引用也发生变化了
In [24]: l2
Out[24]: [['a', 2.4, 5, '6', [1, 3, 'er']], [1, 2, 7, 4]]
In [25]: id(l2)
Out[25]: 140233450141192
python 容器：数据结构。容器基本上包含其他对象的任意对象。序列(列表和元组)，映射(字典)是两类主要容器。集合set也是一个容器
2.3.1列表之间的相加和相乘。下面的代码python 3 会报错
python 2
In [21]: l2 = [4,5,6,7]
In [22]: l1
Out[22]: [1, 2, 7, 4]
In [23]: prod = map(lambda (a,b):a*b,zip(l1,l2))
In [24]: print prod
[4, 10, 42, 28]
In [25]: add = map(lambda (a,b):a+b,zip(l1,l2))
In [26]: add
Out[26]: [5, 7, 13, 11]
In [27]: l1 + l2 # 这表示两个列表的相连接
Out[27]: [1, 2, 7, 4, 4, 5, 6, 7]
In [33]: l1 = [1,3,4,5]
In [34]: l2 = [3,4,5,6,9]
In [35]: add = map(lambda (a,b):a+b,zip(l1,l2))
In [36]: add
Out[36]: [4, 7, 9, 11]
In [37]: prod = map(lambda (a,b):a*b,zip(l1,l2))
In [38]: prod
Out[38]: [3, 12, 20, 30]
删除列表中某个元素，需要使用列表的索引
In [1]: l1 = [1,2,3,4,5,6,7]
In [2]: del l1[2]
In [3]: l1
Out[3]: [1, 2, 4, 5, 6, 7]
In [7]: l3 = l1[2:5] #新生成一个列表从列表l1中索引为2的值开始到索引值为5结束(不包含)的所有
In [8]: l3 #元素插入新的列表中)
Out[8]: [4, 5, 6]
In [9]: l1
Out[9]: [1, 2, 4, 5, 6, 7]
In [10]: l4 = l1[2:6] #分片操作可以超过原列表的范围，但是没有什么意义
In [11]: l4
Out[11]: [4, 5, 6, 7]
In [12]: l5 = l1[2:7]
In [13]: l5
Out[13]: [4, 5, 6, 7]
分片如果是需要从索引为2的元素开始直到最后一个元素，可以这样写l1[2:]。
从索引为0的元素开始到索引为4的元素，可以这样写l1[:4]
列表之间的赋值操作l2=l1[:]。如果是l2 = l1 这样l1改变了l2也会随着改变
例如：
In [17]: l5 = l1[:]
In [18]: l5
Out[18]: [1, 2, 4, 5, 6, 7]
In [19]: l1
Out[19]: [1, 2, 4, 5, 6, 7]
In [20]: l1[3] = 2
In [21]: l1
Out[21]: [1, 2, 4, 2, 6, 7]
In [22]: l5
Out[22]: [1, 2, 4, 5, 6, 7] #l1 发生了变化，l5没有发生变化
In [23]: l4 = l1
In [24]: l4
Out[24]: [1, 2, 4, 2, 6, 7]
In [25]: l1
Out[25]: [1, 2, 4, 2, 6, 7]
In [26]: l1[2] = 8
In [27]: l1
Out[27]: [1, 2, 8, 2, 6, 7]
In [28]: l4
Out[28]: [1, 2, 8, 2, 6, 7]
In [29]: l5
Out[29]: [1, 2, 4, 5, 6, 7]
l1 发生变化，l4会跟着变化，l5不随l1的变化而变化
分片操作也可以在不改变列表中任何元素的情况下插入新的元素
In [12]: numbers = [1, 5]
In [13]: numbers
Out[13]: [1, 5]
In [14]: numbers[1]
Out[14]: 5
In [15]: numbers[1:1]
Out[15]: []
In [16]: numbers[1:1] = [2,3,4]
In [17]: numbers
Out[17]: [1, 2, 3, 4, 5]
In [18]: numbers[1]
Out[18]: 2
In [43]: b
Out[43]: [1, 2, 'a', 'b', 'c', 6, 7]
In [44]: b[4:4] = [7,9,5,6] 在索引3和4之间插入7,9,5,6
In [45]: b
Out[45]: [1, 2, 'a', 'b', 7, 9, 5, 6, 'c', 6, 7]
In [19]: name = list('Perl')
In [20]: name
Out[20]: ['P', 'e', 'r', 'l']
In [22]: name[2:] = list('ar')
In [23]: name
Out[23]: ['P', 'e', 'a', 'r']
In [24]: name[1:]
Out[24]: ['e', 'a', 'r']
In [25]: name[1:] = list('ython')
In [26]: name
Out[26]: ['P', 'y', 't', 'h', 'o', 'n']
同样的分片操作还可以删除列表中的某些元素
In [85]: name
Out[85]: ['P', 'y', 't', 'h', 'o', 'n']
In [86]: name[1:4] = []
In [87]: name
Out[87]: ['P', 'o', 'n']
name[1:4] = [] 相当于 del name[1:4]
输出l3 列表中所有的奇数项：l3[::2]。所有偶数项:l3[1::2].
list[index_start:index_end:step]
index_start：起始位置，列表的索引，从0开始
index_end：结束为止，列表的索引。不包含index_end,在index_end 这个索引的前一个
step：步长。前后索引间隔几个。
如果step 为正数，从左往后切，index_start > index_end 为空
如果step 为负数，从右往左切，index_start < index_end 为空
l3[2::3] 输出所有3的倍数
In [98]: l3[10:1:-2]
Out[98]: [11, 9, 7, 5, 3]
l3 = map(lambda x:x,xrange(1,100))
l4 = [x*1 for x in xrange(1,100)]
这两条语句输出的结果一样，生成一个列表从1到99
注意python 3 有所不同
l3 = list(map(lambda x:x,range(1,100)))
l4 = [x*1 for x in range(1,100)]
不同之处有两个地方：
1、python3 没有xrange这个函数，而是使用range这个函数替代，相当于python2 的xrange
2、map 函数返回的结果是map类型不在是python2 的list类型，这里的表达式达到的是列表类型，所以需要使用list() 这个函数转换
方法：和函数类似，只是方法属于某一个特定对象的函数，调用方法需要指定对象名。
调用方法：对象名.方法名(参数)
2.4.1 list.append(x) 在列表的最后追加新的元素x
In [110]: l1
Out[110]: [1, 2, 3, 4]
In [111]: l1.append(3)
In [112]: l1
Out[112]: [1, 2, 3, 4, 3]
2.4.2 list.count(x) 统计x在列表中出现的次数，如果没有出现就返回0，如果出现1次返回1次
In [133]: l1 = [1, 2, 3, 4, 3, 4, 5, 2, 3, 3, 3]
In [134]: l1.count(3)
Out[134]: 5
In [135]: l1.count(4)
Out[135]: 2
In [136]: l1.count(6)
Out[136]: 0
In [129]: l1.count(1)
Out[129]: 1
In [133]: l1
Out[133]: [1, 2, 3, 4, 3, 4, 5, 2, 3, 3, 3, [1, 2, 3], [1, 2, 3]]
In [134]: l1.count([1,2,3])
Out[134]: 2
2.4.3 list.extend(x) 扩展列表，x：一个可迭代的对象，如：字符串，列表，元组，集合，字典等
In [143]: l1 = [1,2,3,4]
In [144]: l1.extend('1bcde')
In [145]: l1
Out[145]: [1, 2, 3, 4, '1', 'b', 'c', 'd', 'e']
In [146]: l1 = [1,2,3,4]
In [147]: l1.extend('1')
In [148]: l1
Out[148]: [1, 2, 3, 4, '1']
In [150]: l1
Out[150]: [1, 2, 3, 4, '1']
In [151]: l2 = ['a','b','c']
In [152]: l1.extend(l2)
In [153]: l1
Out[153]: [1, 2, 3, 4, '1', 'a', 'b', 'c']
In [154]: l2
Out[154]: ['a', 'b', 'c']
In [155]: l1 + l2
Out[155]: [1, 2, 3, 4, '1', 'a', 'b', 'c', 'a', 'b', 'c']
In [156]: l1
Out[156]: [1, 2, 3, 4, '1', 'a', 'b', 'c']
l1 + l2 两个列表之间的连接产生一个新的列表，原来的两个列表保存不变
可以使用l1 = l1 + l2 来实现l1.extend(l2) 的效果，只是效率比l1.extend(l2) 要差
还有种实现方法:l1[len(l1):] = l2 这样虽然没什么问题，但是代码的可读性比较差
In [158]: l1 = [1,2,3,4]
In [159]: t1 = (2,3,4,'a')
In [160]: l1.extend(t1)
In [161]: l1
Out[161]: [1, 2, 3, 4, 2, 3, 4, 'a']
In [163]: l1
Out[163]: [1, 2, 3, 4, 2, 3, 4, 'a']
In [164]: s1 = {2,3,4,3,2,1,4}
In [165]: s1
Out[165]: {1, 2, 3, 4}
In [166]: l1.extend(s1)
In [167]: l1
Out[167]: [1, 2, 3, 4, 2, 3, 4, 'a', 1, 2, 3, 4]
In [168]: type(s1)
Out[168]: set
字典比较特殊，只会将key加入列表中，而values不会将入类别中
In [171]: l1
Out[171]: [1, 2, 3, 4, 2, 3, 4, 'a', 1, 2, 3, 4]
In [173]: d1 = {'key1':1,'key2':2,'key3':3}
In [174]: l1.extend(d1)
In [175]: l1
Out[175]: [1, 2, 3, 4, 2, 3, 4, 'a', 1, 2, 3, 4, 'key3', 'key2', 'key1']
2.4.4 insert 方法：list.insert(index,obj)
index： 插入的位置
obj：出入的内容
In [47]: a
Out[47]: [1, 2, 3, 4, 5, 6]
In [48]: a.insert(3,'abc')
In [49]: a
Out[49]: [1, 2, 3, 'abc', 4, 5, 6]
In [50]: a = [1,2,3,4,5,6]
In [51]: a
Out[51]: [1, 2, 3, 4, 5, 6]
In [52]: a[3:3] = ['abc']
In [53]: a
Out[53]: [1, 2, 3, 'abc', 4, 5, 6]
分片的方式虽然能够实现插入操作，但是这样代码可读性很差
2.4.5 list.pop(index) 如果不给index的值默认是弹出最后一个元素，如果给index的值就弹出指定的值
In [193]: a
Out[193]: [1, 2, 3, 'abc', 4]
In [194]: a[3]
Out[194]: 'abc'
In [195]: a.pop(3)
Out[195]: 'abc'
In [196]: a
Out[196]: [1, 2, 3, 4]
In [197]: a.pop()
Out[197]: 4
In [198]: a
Out[198]: [1, 2, 3]
pop 方法是唯一一个既能修改列表又能返回元素的值的列表(除了None)方法
append和pop这个两个方法可以构建后进先出队列LIFO
insert(0,..) 和pop这两个方法可以构建先进先出队列FIFO。也可以使用append和pop(0)
2.4.6 list.remove(value) 删除列表中的某个元素，如果这个值有重复的，删除最左边的一个
In [201]: a = [1,2,3,4,4,3,2,1,1,4,3]
In [202]: a.remove(2)
In [203]: a
Out[203]: [1, 3, 4, 4, 3, 2, 1, 1, 4, 3]
In [204]: a.remove(3)
In [205]: a
Out[205]: [1, 4, 4, 3, 2, 1, 1, 4, 3]
In [210]: a.remove(6)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-210-04e5183e7d1a> in <module>()
----> 1 a.remove(6)
ValueError: list.remove(x): x not in list
删除不存在的元素会报语法错误
if 6 in a:
a.remove(6)
remove方法修改了列表的元素，但没有返回值
2.4.7 list.reverse() 将列表的元素反向存放
In [214]: a = [1,2,3,4,5,6,7]
In [215]: a.reverse()
In [216]: a
Out[216]: [7, 6, 5, 4, 3, 2, 1]
如果需要对一个序列进行反向迭代可以使用reversed() 函数，此函数并不返回一个list类型的值，而是返回一个迭代器，可以使用list()函数将其转换为列表
In [222]: list(reversed(a))
Out[222]: [1, 2, 3, 4, 5, 6, 7]
In [223]: a
Out[223]: [7, 6, 5, 4, 3, 2, 1]
2.4.8 list.sort 和 sorted() 内置函数的区别
1、list.sort 只能对列表进行排序；而sorted()函数可以对任意可迭代对象进行排序。
2、list.sort 是在原地对列表进行排序，原列表发生变化，没有返回值；而sorted() 内置函数不改变原列表，返回一个新的列表
list.sort() 对列表在原地进行排序，排完序后将结果存储在原列表中，并返回一个空列表
In [225]: l1
Out[225]: [1, 2, 3, 4, 2, 3, 4]
In [227]: l1.sort()
In [228]: l1
Out[228]: [1, 1, 2, 2, 2, 3, 3, 3, 4, 4]
例子：先对l1列表进行排序并输出结果，同时又想保留原有的列表
l2 = l1.sort() 这样做l1排好序没有问题，但是l2为空
In [230]: l1 = [5,3,6,1,6,7]
In [231]: l2 = l1.sort()
In [232]: l1
Out[232]: [1, 3, 5, 6, 6, 7]
In [233]: l2
即想保留原列表，又想对改列表进行排序。可以先将列表l1切片赋值给另一个列表l2，然后对列表l1进行排序
n [235]: l1 = [5,3,6,1,6,7]
In [236]: l2=l1[:]
In [237]: l1.sort()
Out[238]: [1, 3, 5, 6, 6, 7]
In [239]: l2
Out[239]: [5, 3, 6, 1, 6, 7]
从python2.3以后sort() 使用固定的排序算法
另一种实现方法，使用sorted() 函数实现
In [242]: l2
Out[242]: [5, 3, 6, 1, 6, 7]
In [243]: l3 = sorted(l2)
In [244]: l3
Out[244]: [1, 3, 5, 6, 6, 7]
sorted(x) x：任意一个可迭代对象
list.sort().reverse() 返回的值为空。正确的做法:sorted(x).reverse()
list.sort(key,reverse) 其中key和reverse 这两个参数可选
key=function 系统自带的函数，改变sort()默认的排序规则
In [1]: x = ['abcdes','ab','dferserte','ces','ersf']
In [2]: x
Out[2]: ['abcdes', 'ab', 'dferserte', 'ces', 'ersf']
In [3]: x.sort(key=len)
key=len 表示按照列表中所有元素的长度进行排序
reverse 这个参数控制是否逆序输出
复制类型的排序。python 2
In [28]: c = [['b', 'B', 10],['A','e',1], ['a', 'a', 11], ['B', 'b', 8],['A','B',2]]
In [29]: sorted(c,key=lambda c:c[0])
Out[29]: [['A', 'e', 1], ['A', 'B', 2], ['B', 'b', 8], ['a', 'a', 11], ['b', 'B', 10]]
按内环列表的第一个元素排序，第一个元素是字符，大写的字母排在小写的字母的前面，按字母表的顺序排列。如果内环列表中第一个元素相同，那么就按原顺序排列
例子
s = ['Chr1-10.txt','Chr1-1.txt','Chr1-2.txt','Chr1-14.txt','Chr1-3.txt','Chr1-20.txt','Chr1-5.txt']
以"-" 后面的数字进行排序
sorted(s,key=lambda d:d.split('-')[-1].split('.')[0])
['Chr1-1.txt','Chr1-10.txt', 'Chr1-14.txt', 'Chr1-2.txt', 'Chr1-20.txt', 'Chr1-3.txt', 'Chr1-5.txt']
将后面的数字当做字符处理，这个排序不是我想要的
sorted(s,key=lambda d:int(d.split('-')[-1].split('.')[0]))
['Chr1-1.txt', 'Chr1-2.txt', 'Chr1-3.txt', 'Chr1-5.txt', 'Chr1-10.txt', 'Chr1-14.txt', 'Chr1-20.txt']
使用int() 内置函数将此数字转换为整型，如果不确定是什么类型最好使用强制类型转换
下面这种方法和上面的方法类似。性能差不多
In [23]: L = [('b',2),('a',1),('c',3),('d',4)]
In [24]: import operator
In [25]: L.sort(key=operator.itemgetter(1))
In [27]: L
Out[27]: [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
第3种方法，这种方法比上述两种方法效率要差些。简称DSU:Decorate-Sort-Undercorate
In [36]: L = [('b',2),('a',1),('c',3),('d',4)]
In [37]: A = [(x[1],i,x) for i,x in enumerate(L)]
In [38]: A
Out[38]: [(2, 0, ('b', 2)), (1, 1, ('a', 1)), (3, 2, ('c', 3)), (4, 3, ('d', 4))]
In [39]: A.sort()
In [40]: A
Out[40]: [(1, 1, ('a', 1)), (2, 0, ('b', 2)), (3, 2, ('c', 3)), (4, 3, ('d', 4))]
In [41]: s
Out[41]: (4, 3, ('d', 4))
In [42]: L = [s[2] for s in A]
In [43]: L
Out[43]: [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
enumerate 系统内置函数。作用：在列表中的元素之前输入索引值，然后将索引值和元素的值并列输出。用于同时输出元素和此元素在列表中的索引
In [52]: for index,l2 in enumerate(l1):
....: print index,l2
....:
0 a
1 b
2 c
In [53]: for index,l2 in enumerate(l1,1):
print index,l2
....:
1 a
2 b
3 c
先对第一个关键字进行排序，然后对第二个关键字进行排序
import operator
l1 = [('dave','R',13),('python','A',23),('hello','E',44),('mark','A',15),('world','E',66)]
class Student:
def __init__(self, name, grade, age):
self.name = name
self.grade = grade
self.age = age
def __repr__(self):
return repr((self.name, self.grade, self.age))
student_objects = [Student('john', 'A', 15),Student('jane', 'B', 32),Student('dave', 'C', 20),]
print sorted(student_objects, key=lambda student: student.age)
print sorted(student_objects,key=operator.attrgetter('grade','age'))
print sorted(student_objects,key=operator.attrgetter('grade','age'),reverse=False)
print sorted(student_objects,key=operator.attrgetter('grade','age'),reverse=True)
print sorted(l1,key=operator.itemgetter(1,2))
程序输出结果
[('john', 'A', 15), ('dave', 'C', 20), ('jane', 'B', 32)]
[('john', 'A', 15), ('jane', 'B', 32), ('dave', 'C', 20)]
[('john', 'A', 15), ('jane', 'B', 32), ('dave', 'C', 20)]
[('dave', 'C', 20), ('jane', 'B', 32), ('john', 'A', 15)]
[('mark', 'A', 15), ('python', 'A', 23), ('hello', 'E', 44), ('world', 'E', 66), ('dave', 'R', 13)]
operator 模块中的itemgetter 函数：获取序列中某一区域的值，该函数有个参数，参数是索引值
In [1]: import operator
In [2]: a = [1,2,3]
In [3]: b = operator.itemgetter(1)
In [4]: type(b)
Out[4]: operator.itemgetter
In [5]: b(a)
Out[5]: 2
In [35]: d= operator.itemgetter(1,2)
In [36]: d(c)
Out[36]: ((2, 'python', 34), (3, 'mark', 32))
In [37]: c
Out[37]: [(1, 'hello', 23), (2, 'python', 34), (3, 'mark', 32)]
reverse=True 表示逆序排序，默认reverse=False 表示正常的顺序排序
operator 模块中的 attrgetter函数和itemgetter 函数功能类似，只是itemgetter的参数是index，是整型，而attrgetter函数的参数是字符串类型，类似于bash里的字符数组。而且attrgetter函数的参数还可以是某个类的对象。例如：h = attrgetter('name.first', 'name.last')
返回的结果是r.name.first 和 r.name.last
cmp 函数比较两个数的大小。cmp(x,y) 如果 x<y 返回负数，一般是-1，如果 x>y 返回正数，一般是1，如果x=y 返回0
In [1]: cmp(10,30)
Out[1]: -1
In [2]: cmp(40,30)
Out[2]: 1
In [3]: cmp(30,30)
Out[3]: 0
In [8]: numbers = [5,2,9,7]
In [9]: numbers.sort(cmp)
In [10]: numbers
Out[10]: [2, 5, 7, 9]
python3 不在支持cmp 函数。sorted() 和list.sort() 这两个函数使用cmp的情况很少，可以使用其他的方法代替
python中的sorted排序，真的是高大上，用的Timsort算法。
关于Timsort 算法的介绍http://blog.csdn.net/yangzhongblog/article/details/8184707
2.4.9 判断某个元素在列表是否存在，字符串需要使用引号扩起来。存在返回True，不存在返回False
In [8]: l1 = [2,3,9,'q',3,3.2]
In [9]: 2 in l1
Out[9]: True
In [10]: 5 in l1
Out[10]: False
In [11]: q in l1
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-11-a4bdd5ee1d71> in <module>()
----> 1 q in l1
NameError: name 'q' is not defined
In [12]: 'q' in l1
Out[12]: True
In [13]: 3.2 in l1
Out[13]: True
2.5.1 元组的定义
使用小括号括起来，元素之间使用逗号分隔，即使只有一个元组后面也要跟逗号，否则就是一个整型值，不是元组类型。
元组是不可变序列
In [33]: t = (23,)
In [34]: t
Out[34]: (23,)
In [35]: t1 = ()
In [36]: type(t1)
Out[36]: tuple
In [37]: type(t)
Out[37]: tuple
In [38]: t2 = (23)
In [39]: type(t2)
Out[39]: int
In [40]: 3*(40+2)
Out[40]: 126
In [41]: 3*(40+2,)
Out[41]: (42, 42, 42)
t3 = ([(1,2),(3,4)])
type(t3)
list
注意这样赋值t3是列表，因为中括号后面没有逗号
In [56]: t3 = tuple([(1,2),(3,4)],)
In [57]: type(t3)
Out[57]: tuple
这样t3就是元组了
In [54]: t2 = tuple(([(1,2),(3,4)],[(3,4),(5,6)]))
In [55]: t2
Out[55]: ([(1, 2), (3, 4)], [(3, 4), (5, 6)])
如果本身是元组使用内置函数tuple强制将其转换还是元组，这样做一般是保险起见，降低程序出错的可能性，实际上没有多大的意义
元组还有一种特殊的赋值方式
In [58]: x = 1,2,3
In [59]: type(x)
Out[59]: tuple
2.5.2元组也有分片操作，分片所得到的值还是元组
In [60]: x[1]
Out[60]: 2
In [61]: x[0:2]
Out[61]: (1, 2)
元组只有这两类操作，创建元组和访问元组中的元素(统计元素出现的次数，计算元素在元组的索引值)
tuple.count() tuple.index()
In [65]: t1 = (2,3,4,2,3,6,5,3,3,4,5)
In [66]: t.count(3)
Out[66]: 0
In [67]: t1.count(3)
Out[67]: 4
In [68]: t1.
t1.count t1.index
In [68]: t1.index(3)
Out[68]: 1
tuple.index(x) 当x在此元组中出现多次，求索引的时候返回第一次出现的索引值
元组不可变
In [69]: t1
Out[69]: (2, 3, 4, 2, 3, 6, 5, 3, 3, 4, 5)
In [70]: t1[3]
Out[70]: 2
In [71]: t1[3] = 3
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-71-eba13a68586c> in <module>()
----> 1 t1[3] = 3
TypeError: 'tuple' object does not support item assignment
如果将字典强制转换为元组，字典的value会丢失，只有key 添加至元组。而且key的顺序被打乱，从下面的例子没有发现key的排序规则
In [73]: t1 = tuple({'key1':2,'key2':3,'key3':4})
In [74]: t1
Out[74]: ('key3', 'key2', 'key1')
In [75]: t1 = tuple({'uae':2,'name':3,'iuay':4})
In [76]: t1
Out[76]: ('iuay', 'uae', 'name')
In [77]: t1 = tuple({'abc':2,'abd':3,'iuay':4})
In [78]: t1 = tuple({'abc':2,'abd':3,'abe':4})
In [79]: t1
Out[79]: ('abc', 'abd', 'abe')
In [80]: t1 = tuple({'abc':2,'def':3,'ghi':4})
In [81]: t1
Out[81]: ('abc', 'ghi', 'def')
2.5.3 元组的方法
count(x)
index(x)
2.5.3.1 count(x) 统计元组x出现的次数，如果没有出现就是0
In [33]: t2
Out[33]: ([(1, 2), (3, 4)], [(3, 4), (5, 6)])
In [35]: t2.count([1,2])
Out[35]: 0
In [36]: t2
Out[36]: ([(1, 2), (3, 4)], [(3, 4), (5, 6)])
In [37]: t2.count((1,2))
Out[37]: 0
In [38]: t2.count([(1,2),(3,4)])
Out[38]: 1
2.5.4 index(x) 计算x在元组的中的索引值，索引从0开始。如果x存在多个，计算所得到的值是x出现的第一次的索引。如果x不存在元组中就会报语法错误。所以计算索引之前最好先判断下元素是否存在
In [1]: t1 = (2,3,4,2,6,3,6,3)
In [2]: t1.index(3)
Out[2]: 1
In [7]: t1.index(4)
Out[7]: 2
In [6]: t1.index(8)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-6-a648f09528f2> in <module>()
----> 1 t1.index(8)
ValueError: tuple.index(x): x not in tuple
2.5.4 元组成员关系判断
In [7]: t2 = (3,4,3,'2','a',3.5)
In [8]: 3.5 in t2
Out[8]: True
In [9]: 'a' in t2
Out[9]: True
In [10]: '2' in t2
Out[10]: True
In [12]: 'q' in t2
Out[12]: False
684
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
