Python元组创建与操作：从基础到高级技巧全解析

元组，由一组逗号分隔值创建

a = 3,4,5
print a
#所以明显print加上逗号隔开的值并不是元组，而只是打印分隔符
print 3,4,5```
#创建元组的元组

Nested_tup =（1,2,3），（4,6）

打印Nested_tup

调用Tuple（）函数将所有序列或迭代器转换为元组

打印元组（[[3,4,2]）

打印元组（'strings'）````````''

索引元组

print nested_tup[1][1]
#元组是不可变的，但是如果在元组插槽中的元素是可变的，也可以修改其中的可变对象，比如这样
tup = tuple(['foo',[1,2],True])
print tup
#第2个元素是个列表可变，所以可以修改列表中的元素，比如这样
tup[1].append(3)
print tup```
#元组通过加号进行产生更长的元组

对于只有一个元素的元组，必须在元素之后添加逗号，以清楚地表明它是元组，否则可以根据自己的数据类型对其进行处理。

打印（3，无，'foo'）+（6,0）+（'bar'，）

将元组乘以整数等同于加入元组的多个副本

打印（3，无，'foo'）*3“”

元组拆箱

tup = (4,5,6)
a,b,c=tup
print a,b,c
#嵌套元组也能解包
tup = (4,5,(6,7))
a,b,(c,d)=tup
print a,b,c,d
#利用解包实现数据交换
a = 5;b = 4;print a,b
a,b = b,a;print a,b
#利用解包进行迭代,对由元组或者列表组成的序列进行迭代
seq = ((1,2,3),(4,5,6),(7,8,9))
for a,b,c in seq:
    print a,b,c
#元组方法，count(),计算参数的出现次数,只能统计第一层元素出现多少次，不能具体到底层
print seq.count(1)```
#列表，序列包括，列表，元组，还有字符串，只有列表是可变的

list（）函数将序列类型转换为列表

a_list = [2,3,4，无]

打印A_LIST，列表（TUP），列表（“ Strings”）

append（）方法

a_list.append（“爱”）

插入（）方法将元素插入指定位置

a_list.insert（4，“ i”）

POP（）方法删除并返回指定索引的元素

a_list.pop（3）

remove（）方法找到满足要求并将其从列表中删除的第一个值

a_list.remove（4）

在操作员中确定列表是否包含某个值

在A_LIST中打印4

打印a_list````

合并 +和扩展（）列表方法

b_list = [7,8,(2,3)]
x = [4,None,'foo']
#a.extend()调用后返回值是一个None，所以必须调用a才能显示extend()方法执行后的效果
a_list.extend([4,None,'foo'])
print a_list + b_list,a_list
#+代表的列表合并是新建一个新列表然后赋值的操作，而extend()方法是原地进行操作的，效率会好一点
#排序，sort()方法
a = [1,4,3,5,(8,6)]
#利用reverse参数，指明反向排序
a.sort(reverse=True)
#sort()方法是原地排序操作，直接改变原始的序列
print a
b = ["love","i",'you']
b.sort(key=len)
print b```
#序列的切片操作

确定收入的开始和停止[]

seq = [7,2,4,5,32,6,4,7]

如果没有开始或停止，则序列默认情况下启动或结束。

打印seq [1：3]，seq [：5]，seq [3：]

打印seq [-4：]，seq [-6：-2]

如果左元元素出现的时间晚于右元素，请返回到空序列

打印seq [-4：-5]

添加步长以实现反顺序

打印seq [:: - 1]，seq [3 ::-1]````

内置序列功能

#enumerate()函数返回序列的索引和对应索引的值
some = ["a","b","c"]
for i,value in enumerate(some):
    print "It's ",str(i),"and the value is ",value
#enumerate()还可以求取一个将序列值映射到其所在位置的字典(假定序列值是唯一的，这样字典的键才能是唯一的)
some_list = ["foo","bar","baz"]
#一个推导式
mapping = dict((v,i) for i,v in enumerate(some_list))
print mapping```
#sorted()函数

将任何序列返回到新的有序列表中，但是原始列表不会更改，但是列表的sort（）方法将对列表进行排序

sort_some_list = sorted（some_list）

打印sort_some_list，some_list，分类（“赛马”）

使用sorted（）函数并将其设置为序列中唯一元素的有序列表

打印排序（set（“这只是一个字符串”）````

多个序列的zip（）函数对元素以产生新序列

seq1 = ['foo','bar','baz']
seq2 = ['one','two','three']
print zip(seq1,seq2)
#zip()可以接受任意数量的序列，最终得到的元组数量由最短的序列决定
#常见用法是同时迭代多个序列，结合enumerate()函数使用,典型的序列解包的应用
for i,(a,b) in enumerate(zip(seq1,seq2)):
    print ('%d: %s %s' %(i,a,b))
#对已经压缩的序列，zip()对该序列进行解压，其实是将一组行转换为一组列
pitcher = zip(seq1,seq2)
#*说明参数要传入一个元组，元组包含两个元素，因此就是把pitcher[1]作为参数传入zip了，然后zip的作用是结合产生新序列，与first和last相对应
first,last = zip(*pitcher)
print first,last```
#reversed()函数用于得到一个序列的逆序，返回一个迭代器

使用list（）函数将迭代器类型转换为列表

XITER =反向（范围（10））

因为我在XITER中：

打印“是”，str（i）

打印类型（XITER）

为什么它在迭代后成为空列表？迭代器的功能是延迟值的产生。迭代器已被迭代，因此，如果您以后使用此迭代器，List（），它将为空。

打印列表（XITER）``````''

字典

#创建字典
d1 = {'a':'some value','b':[1,2,3,4]}
#使用键来索引字典对应的值
d1[7] = 'use integer as key'
print d1,d1['a'],d1['b'],d1[7]
#判断字典中是否存在某个键
print 'b' in d1,d1.has_key('b')
#使用del关键字或者pop方法(删除指定值后把值返回)
d1['dummy'] = "it's fun"
del(d1['dummy'])
d1['pop'] = 'testing pop'
ret = d1.pop('pop')
print d1,ret
#keys()和values()方法分别按对应顺序返回键和值
print d1.keys()," and ",d1.values()
#使用update()方法将一个字典合并到另外一个字典上,原来如果有相同的键将其覆盖，若没有建立新的键值对
d1.update({'b':'it is b','c':"it is c"})
print d1```
#从序列类型创建字典

映射= {}

对于键，zip中的值（范围（10），反向（范围（10）））：

映射[键] =值

打印映射

使用更简单的方法创建字典，dict（）函数，接受二进制列表或元组作为键值对

映射= dict（zip（范围（5），反向（范围（5）））））））

打印映射````

字典的get（）方法和pop（）方法

#如果可以得到key为a的值，则返回该值，否则返回None这个自定义默认值
value = mapping.get("a",None)
popvalue = mapping.pop("a",None)
print value,popvalue
#根据首字母对一组单词进行分类并且最终产生一个由列表组成的字典
words = ['apple','bat','bar','atom','book']
by_letter = {}
for word in words:
    letter = word[0]
    #如果by_letter中含有Letter这个键
    if letter in by_letter:
        by_letter[letter].append(word)
    else:
        #每个键对应的是一个列表
        by_letter[letter] = [word]
print by_letter```
#上述程序代码可以使用setdefault()方法实现

by_letters = {}

＃这是不可能的。您必须提供出现默认列表的第一个密钥。否则，您将无法为单词中的单词提供附加（）：by_letters [word [0]]。附录（word）print by_letters，以便您可以执行此操作。创建新密钥时，给出默认列表，然后使用Word and Append（）in。如果它是已经存在的键，则将返回相应的值，这也是列表。使用append（）到最新单词。

用单词词：

by_letters.setDefault（word [0]，[]）。append（word）

打印单词

字典的键必须是不可变的对象，以及是否可以将它们视为是否可以将其视为字典的钥匙。

哈希（“字符串”）＃Hashable，成功

哈希（[1,2,3]）＃无法进行哈希，失败。如果要将列表视为钥匙，则可以将其转换为元组

by_letters [元组（[1,3,2]）] =“列表转移到元组”

打印by_letters“”

集合是由唯一元素组成的无序集

#创建方法
a = set("strings is a sequence")
# or a = set([1,2,3,4])
b = {1,2,3,4,5}
print a,b
#判断是否子集或者超集
print {1,3,4}.issubset(b), "and ",b.issuperset({1,3,4})
#如果两个集合的内容相等，那么集合就是相等的
print {1,3,4} == {1,4,3}```
#列表推导式

一个经典的例子

strings = ['a'，'as'，'蝙蝠'，'car'，'dove'，'python']

如果len（string）> 2，在字符串中打印[string.upper（）的字符串]

设置派生公式，建立一组上述字符串的字符串长度

在字符串中打印{len（string）的字符串}

字典派生，建立字符串与其列表索引位置的映射关系

打印{val：索引索引，枚举（字符串）中的val}}

在另一个实现版本中，dict（）函数接受一个键值对，带有（键，值）的参数，无论是元组，列表还是字典

打印dict（（val，idx）for idx，枚举（字符串）中的val）````````````

嵌套列表理解

all_data = [['Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'],
            ['Susie','Casey','Jill','Ana','Eva','Jennifer','Stephanie']]
#将名字中含有两个e的名字找出来
#初始化存储找到名字的列表
name_interested = []
for names in all_data:
    #因为是嵌套列表，所以嵌套循环，分别处理两个列表
    for name in names:
        if name.count('e') >= 2:
            name_interested.append(name)
print name_interested
#使用一个列表推导式
name_interested = []
for names in all_data:
    need_name = [name for name in names if name.count('e') >= 2]
    # name_interested.append(need_name)
    #使用extend而不是append是因为extend扩展列表去掉嵌套列表，从而使生成的列表扁平化
    name_interested.extend(need_name)
print name_interested
#使用嵌套的列表推导式
#太精简了！
result = [name for names in all_data for name in names if name.count('e') >= 2]
print result
#扁平化一个嵌套的元组列表
some_tuples = [(1,2,3),(4,5,6),(7,8,9)]
flattened = [x for tuple in some_tuples for x in tuple]
print flattened
flattened = []
for tup in some_tuples:
    result = [x for x in tup]
    flattened.extend(result)
print flattened
#下面这种写法只能是把嵌套的元组变成了嵌套的列表
print [[x for x in tup] for tup in some_tuples]```