当前位置：&>&&>&&>&
python列出多个列表元素构成的排列组合的方法
发布时间：编辑：
python列出多个列表元素构成的排列组合：一个算法，给出多个列表，然后从每个列表中取一个元素，构成一个元组，列出所有这样的元组。
列出多个列表元素构成的排列组合：
一个算法，给出多个列表，然后从每个列表中取一个元素，构成一个元组，列出所有这样的元组。
两个方法，一个需要循环嵌套，一个不用。
复制代码 代码如下:
#!/usr/bin/python
#Two method for generate a list whose item is all possible permutation and combination come from every item of many list.
A = ['1', '2']
B = ['a', 'b', 'c']
C = ['A', 'B', 'C', 'D']
retList = []
for a in A:
&&& for b in B:
&&&&&&& for c in C:
&&&&&&&&&&& retList.append((a,b,c))
print retList
print '*' * 40
def myfunc(*lists):
&&& #list all possible composition from many list, each item is a tuple.
&&& #Here lists is [list1, list2, list3], return a list of [(item1,item2,item3),...]
&&& #len of result list and result list.
&&& total = reduce(lambda x, y: x * y, map(len, lists))
&&& retList = []
&&& #every item of result list.
&&& for i in range(0, total):
&&&&&&& step = total
&&&&&&& tempItem = []
&&&&&&& for l in lists:
&&&&&&&&&&& step /= len(l)
&&&&&&&&&&& tempItem.append(l[i/step % len(l)])
&&&&&&& retList.append(tuple(tempItem))
&&& return retList
print myfunc(A,B,C)
输出结果：
[('1', 'a', 'A'), ('1', 'a', 'B'), ('1', 'a', 'C'), ('1', 'a', 'D'), ('1', 'b', 'A'), ('1', 'b', 'B'), ('1', 'b', 'C'), ('1', 'b', 'D'), ('1', 'c', 'A'), ('1', 'c', 'B'), ('1', 'c', 'C'), ('1', 'c', 'D'), ('2', 'a', 'A'), ('2', 'a', 'B'), ('2', 'a', 'C'), ('2', 'a', 'D'), ('2', 'b', 'A'), ('2', 'b', 'B'), ('2', 'b', 'C'), ('2', 'b', 'D'), ('2', 'c', 'A'), ('2', 'c', 'B'), ('2', 'c', 'C'), ('2', 'c', 'D')]
****************************************
[('1', 'a', 'A'), ('1', 'a', 'B'), ('1', 'a', 'C'), ('1', 'a', 'D'), ('1', 'b', 'A'), ('1', 'b', 'B'), ('1', 'b', 'C'), ('1', 'b', 'D'), ('1', 'c', 'A'), ('1', 'c', 'B'), ('1', 'c', 'C'), ('1', 'c', 'D'), ('2', 'a', 'A'), ('2', 'a', 'B'), ('2', 'a', 'C'), ('2', 'a', 'D'), ('2', 'b', 'A'), ('2', 'b', 'B'), ('2', 'b', 'C'), ('2', 'b', 'D'), ('2', 'c', 'A'), ('2', 'c', 'B'), ('2', 'c', 'C'), ('2', 'c', 'D')]
与 python列出多个列表元素构成的排列组合的方法 有关的文章
本文标题：
本页链接：
12345678910
12345678910Learn Python The Hard Way学习(34) - 访问列表中的元素
List是非常有用的，前提是要知道怎么用，那么我们怎么访问列表中的元素呢？下面看看我们怎么访问列表的第一个元素的：
animals = ['bear', 'tiger', 'penguin', 'zebra']
bear = animals[0]
我们使用0去获得第一个元素？这是怎么工作的呢？因为python开始一个list是从0开始的，看上去很奇怪，但是有很多好处，暂且认为这是一个规定吧。
这就提现了我们用数字和程序用数字的不同。
想象一下，我们让这四个动物进行竞速比赛，然后按照他们的名次在list排列。如果你的朋友想知道谁赢了，那么他会说：&谁是第0名？&，当然不会，他会说：&谁是第一名？&
这里也说明了排序的重要性，没有第一就没有第二的说法，没有第二就没有第三。而且第0名也是不可能存在的，0就表示没有。我们怎么让没有去赢得比赛？这不合常理。我们把这些数字叫做有序的数字，因为它们有序的区别了一些东西。
当然，程序员不会想这些，因为他们可以从list中取出元素，对于程序员来说，上面的list就想一叠卡片。如果他们想要老虎，就取出老虎，想要斑马就取得斑马。想要随机的取得任何元素的话，就要给每个元素一个地址，或者说是一个索引，最好的办法是从0开始，然后按照顺序排列，这样我们就能随便取元素了，即使是第0个元素。
比如说，你想要第三个动物，那么你就可以用3减去1，得出索引2，那么就可以得到第三个动物了。
记住：序号==顺序1，基数==0
让我们做一个练习，通过我提供的序号和基数值写出相应的动物。记住，说第一，第二的时候表示序号，单单给出一个数字的时候表示基数。
animals = ['bear', 'python', 'peacock', 'kangaroo', 'whale', 'platypus']
The animal at 1.
The 3rd animal.
The 1st animal.
The animal at 3.
The 5th animal.
The animal at 2.
The 6th animal.
The animal at 4.
回答的格式像这样：第一个动物是在0号，它是bear。
1. 上网了解一下序号和基数。
2. 你怎么区别序号和基数呢？你怎么解释为什么&&表示的是2010年而不是2009年呢？（提示：你不能随机挑选年份）
3. 写一下list，算出它们的索引值。
4. 使用python确认你的答案。
作者：lixiang0522请问为什么不能一边遍历列表一边删除列表中的元素？_python吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：36,953贴子：
请问为什么不能一边遍历列表一边删除列表中的元素？收藏
遍历的时候，“下标”问题不好弄吧？
Python的List的底层是实现是一个PyObject*数组。如果每次增加一个元素都扩张内存的话效率太低，在增加元素的时候所以会有预申请内存。同理删除元素的时候也不是马上就减小内存空间，他会按照一定的策略减小。而这种减小不太好预测。再加上删除后索引如何调整并没有明确定义。比如一个长度为3的List你删除了第2个那么第三个下标应该是2还是3，等等可能会引发歧义。如果这个时候内存达到了需要减小的条件，迭代器就不太好判断新的索引究竟是多少。所以Python为了通用性和安全性考虑就禁止在遍历时删除元素了。
迭代器基本都这样吧
所以你要反过来想，遍历时把所有不想删除的元素全都保留在新的list里面。然后删掉原来的list。
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或Python中列表和元组的相关语句和方法讲解_python_脚本之家
正文内容 Python中的列表和元组
Python中列表和元组的相关语句和方法讲解
作者：一线涯 字体：[] 类型：转载 时间：
这篇文章主要介绍了Python中列表和元组的相关语句和方法讲解,是Python入门学习中的基础知识,需要的朋友可以参考下列表(list):首先，列表属于序列，那么序列类型可用如下内建函数——list(iter)：把可迭代对象转换为列表。str(obj)：把obj对象转换为字符串，即用字符串来表示这个对象。tuple(iter)：把一个可迭代对象转换为一个元组。unicode(obj)：把对象转换成Unicode字符串。basestring()：抽象工厂函数，其作用仅仅是为str和unicode函数提供父类，所以不能被实例化，也不能被调用。enumerate(iter)：接受一个可迭代对象作为参数，返回一个enumerate对象，该对象生成由iter每个元素的index值和item值组成的元组。len(seq)：返回seq的长度。max(iter,key=None)、max(arg0,arg1...,key=None)：返回iter或(arg0,arg1...)的最大值，如果指定了key，这个key必须是一个可以传给sort()方法的，用于比较的回调函数。min(iter,key=None)、min(arg0,arg1...,key=None)：返回iter或(arg0,arg1...)的最小值，如果指定了key，这个key必须是一个可以传给sort()方法的，用于比较的回调函数。reversed(seq)：接受一个序列作为参数，返回一个以逆序访问的迭代器。sorted(iter,cmp=None,key=None,reverse=False)：接受一个可迭代对象作为参数，返回一个有序的列表，可选参数cmp、key和reverse和list.sort()内建函数含义一样。sum(seq,init=0)：返回seq和可选参数init的总和，其效果等同于reduce(operator.add,seq,init)。zip([it0,it1...])：返回一个列表，其第一个元素是it0、it1...这些元素的第一个元素组成的一个元组，其它元素依次类推。列表就像一个线性容器，但是比C++的 lis t扩展多得多列表里的元素可以是相同类型，也可以包含各种类型，比如列表里嵌套另一个列表列表示例：123456789&&& L1 =[1,2,3] &&& type(L1) &class&list&& &&& L1 =[1,&a&,2,1.4] &&& L1 [1, &a&, 2, 1.4] &&& L1 =[ [&sub&],1,&n&] &&& L1 [[&sub&], 1, &n&] list的索引是也是从0开始，但也可以从后访问，L1[-1] 表示L1中的最后一个元素123456&&& L1 [[&sub&], 1, &n&] &&& L1[0] [&sub&] &&& L1[-1] &n&对列表可以进行切片，切片的操作类似于对函数的调用，返回值一个新的列表切片 L1[ x : y : z ] 是半开闭区间（z通常不用写），如L1[1:3] 返回的是一个从 L1[1] 开始到 L1[2] 结束的列表，不包含L1[3]x 不写表示从头开始，y 不写表示直到列表结束，z 用于表示步长， 默认是1， 可以认为是在这个区间里每 z 个元素取一个（取第一个），可以是负数，表示从后到前遍历12345678910111213141516&&& L1 =[1,2,3,4,5,6] &&& L1[1:3] [2, 3] &&& L1[:3] [1, 2, 3] &&& L1[1:] [2, 3, 4, 5, 6] &&& L1[-3:-1] [4, 5] &&& L2 =L1[:] &&& L2 [1, 2, 3, 4, 5, 6] &&& L1[::2] [1, 3, 5] &&& L1[::-1] [6, 5, 4, 3, 2, 1] 列表可以做加法，做乘法，字符串也可以看做一个字符的列表123456&&& L1 =[1,2] &&& L2 =[3,4] &&& L1 +L2 [1, 2, 3, 4] &&& 5*L1 [1, 2, 1, 2, 1, 2, 1, 2, 1, 2] in语句，判断一个对象是否在一个字符串/列表/元组里not 语句表示对后面的否定len
可以检测字符串/列表/元祖/字典的元素个数max 可以返回最大元素，min 返回最小元素12345678910111213141516&&& L1 [1, 2, 3, 4, 2] &&& 3inL1 True&&& 5inL1 False&&& 3notinL1 False&&& 5notinL1 True&&& len(L1) 5&&& max(L1) 4&&& min(L1) 1操作：123456789101112131415&&& &&& L1[1] =5&&& L1 [1, 5, 3, 4, 2] &&& &&& delL1[1] &&& L1 [1, 3, 4, 2] &&& &&& L1[2:] =[6,7,8] &&& L1 [1, 3, 6, 7, 8] &&& L1[1:3] =[] &&& L1 [1, 7, 8] list 的函数：append( x ) 是将 x 作为一个元素添加到列表的末尾，即使 x 是一个列表12345678910&&& L1 [1, 2, 7, 8] &&& L1.append(3) &&& L1 [1, 2, 7, 8, 3] &&& L1.append([4,5]) &&& L1 [1, 2, 7, 8, 3, [4, 5]] &&& 4inL1 Falsecount( x) 统计 x 在列表中出现的次数12345&&& L1 =[1, 2, 7, 8] &&& L1.count(2) 1&&& L1.count(3) 0extend( x ) 将x 作为一个列表与原列表合并，添加到末尾。若不是列表，则编译器尝试将 x 转换为列表然后执行操作，不成功就会报错1234567&&& L1 [1, 2, 7, 8] &&& L1.extend([4,5]) &&& L1 [1, 2, 7, 8, 4, 5] &&& 4inL1 Trueindex ( x ) 返回 x 在列表中的坐标，若 x 不在列表中会出错12&&& L1.index(2) 1insert( i , x) 在位置i 插入元素x12345678&&& L1 [1, 2, 7, 8, 4, 5] &&& L1.insert(0,&a&) &&& L1 [&a&, 1, 2, 7, 8, 4, 5] &&& L1.insert(-1,&b&) &&& L1 [&a&, 1, 2, 7, 8, 4, &b&, 5] pop( i ) 删除位置 i 的元素并将它返回，默认可以不写 i ，删除最后一个元素，不存在会出错123456789&&& L1 =[1, 2, 7, 8] &&& L1.pop(1) 2&&& L1 [1, 7, 8] &&& L1.pop() 8&&& L1 [1, 7] remove( x ) 移除在 列表中 x 的第一个匹配项，x 不存在会出错123&&& L1.remove(2) &&& L1 [1, 7, 8] reverse() 将列表逆序1234&&& L1 =[1, 2, 7, 8] &&& L1.reverse() &&& L1 [8, 7, 2, 1] sort 将原列表排序，返回None，有两个可选参数，key 和 reverse，默认为升序排列1234567891011121314&&& L1 [8, 7, 2, 1] &&& L1.sort() &&& L1 [1, 2, 7, 8] &&& L1.sort(reverse =True) &&& L1 [8, 7, 2, 1] &&& L1 =[&a&,&ccc&,&abcd&,&bc&,&cd&,&abc&] &&& L1.sort(key =len) &&& L1 [&a&, &bc&, &cd&, &ccc&, &abc&, &abcd&] 元组(tuple)元组也属于序列，但元组为不可修改的列表。所以元组没有以上序列通用方法可用！一个元素的元组表示为 ( 1 , )123456&&& x =(1,) &&& type(x) &class&tuple&& &&& x =(1) &&& type(x) &class&int&& 元组可转换成列表，反之亦然。内建的 tuple() 函数接受一个列表参数，并返回一个包含同样元素的元组，而 list() 函数接受一个元组参数并返回一个列表。从效果上看， tuple() 冻结列表，而 list() 融化元组。123456789101112&&& x =[1,2,4,3,1] &&& y =(1,2,4,3,1) &&& type(x) &class&list&& &&& type(y) &class&tuple&& &&& z =tuple(x) &&& z (1, 2, 4, 3, 1) &&& z =list(y) &&& z [1, 2, 4, 3, 1] 可以用列表 或 元组 进行一次多赋值：1234567891011121314151617&&& L1 =(1,2,4) &&& (x, y, z) =L1 &&& x 1&&& y 2&&& z 4&&& L1 =[1,2,4] &&& (x,y,z) =L1 &&& x 1&&& y 2&&& z 4[] ，和 () 在布尔值中表示 False您可能感兴趣的文章:
┃&相关文章
┃&文章评论
友情提醒：本站文件的解压密码：www.jb51.net (请使用最新的winrar)
┃&最 近 更 新
┃&热 点 排 行
┃&Js与CSS工具
┃&代码转换工具Python中避免在给多维数组赋值之前判断key是否存在的方法 - 为程序员服务
Python中避免在给多维数组赋值之前判断key是否存在的方法
Python在使用二维及多维数组（dict）时，每次赋值之前都需要判断一维及较小维度上的key是否存在。本文将介绍对于这种问题的解决方案
Python中可以使用dict数据类型来实现二维及多维数组。但是在对dict类型的多维数组赋值时，相较其他语言需要预先额外判断一次低维度的key是否存在的操作。否则就会报KeyException（这种功能称为），具体见下例：
#初始化一个数组，对[1,1]这个点赋值为0
two_dimensional_dict = {1: {1: 0}}
#此时如果我们想要对[2,2]这个点也赋值为0
#那么需要额外进行一次 if 2 in two_dimensional_dict的操作
#否则Python会raise KeyException
#以下语句会报错
two_dimensional_dict = {2: {2: 0}}
#需要使用如下方式
if 2 in two_dimensional_dict:
two_dimensional_dict = {2: {2: 0}}
two_dimensional_dict{2} = {}
two_dimensional_dict = {2: {2: 0}}
用colletions.defaultdict来实现二维数组
作为一个类库丰富的语言不应该接受有如此冗余代码存在的场景。于是求助google，果然在。具体的方法就是用collections.defaultdict来替代dict两者的使用方法一致，除了前者在初始化时需要告知：当低维度key不存在时的default值。具体的使用方法如下：
from collections import defaultdict
#创建一个二维数组
#如果低维度key未初始化时的默认值是0
my_dict = defaultdict(defaultdict)
my_dict[1][1] += 1
#output: 1
print my_dict[1][1]
为多维数组配置一个非0的默认值
此外我们还可以创建默认值为非0的多维数组，只需在实例化时稍作改写。具体如下例：
from collections import defaultdict
#创建一个二维数组
#如果低维度key未初始化时的默认值是2
my_dict = defaultdict(lambda: defaultdict(lambda: 2))
my_dict[1][1] += 1
#output: 1
print my_dict[1][1]
Collection of everythings I want to record down especially for tech
原文地址：, 感谢原作者分享。
您可能感兴趣的代码