1.1 拆箱
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
>>>a,b,c=1,2,3
>>>a,b,c
(1,2,3)
>>>a,b,c=[1,2,3]
>>>a,b,c
(1,2,3)
>>>a,b,c=(2*i+1foriinrange(3))
>>>a,b,c
(1,3,5)
>>>a,(b,c),d=[1,(2,3),4]
>>>a
1
>>>b
2
>>>c
3
>>>d
4
|
1.2 拆箱变量交换
|
1
2
3
4
|
>>>a,b=1,2
>>>a,b=b,a
>>>a,b
(2,1)
|
1.3 扩展拆箱（只兼容python3）
|
1
2
3
4
5
6
7
|
>>>a,*b,c=[1,2,3,4,5]
>>>a
1
>>>b
[2,3,4]
>>>c
5
|
1.4 负数索引
|
1
2
3
4
5
|
>>>a=[0,1,2,3,4,5,6,7,8,9,10]
>>>a[-1]
10
>>>a[-3]
8
|
1.5 切割列表
|
1
2
3
|
>>>a=[0,1,2,3,4,5,6,7,8,9,10]
>>>a[2:8]
[2,3,4,5,6,7]
|
1.6 负数索引切割列表
|
1
2
3
|
>>>a=[0,1,2,3,4,5,6,7,8,9,10]
>>>a[-4:-2]
[7,8]
|
1.7指定步长切割列表
|
1
2
3
4
5
6
7
|
>>>a=[0,1,2,3,4,5,6,7,8,9,10]
>>>a[::2]
[0,2,4,6,8,10]
>>>a[::3]
[0,3,6,9]
>>>a[2:8:2]
[2,4,6]
|
1.8 负数步长切割列表
|
1
2
3
4
5
|
>>>a=[0,1,2,3,4,5,6,7,8,9,10]
>>>a[::-1]
[10,9,8,7,6,5,4,3,2,1,0]
>>>a[::-2]
[10,8,6,4,2,0]
|
1.9 列表切割赋值
|
1
2
3
4
5
6
7
8
9
10
|
>>>a=[1,2,3,4,5]
>>>a[2:3]=[0,0]
>>>a
[1,2,0,0,4,5]
>>>a[1:1]=[8,9]
>>>a
[1,8,9,2,0,0,4,5]
>>>a[1:-1]=[]
>>>a
[1,5]
|
1.10 命名列表切割方式
|
1
2
3
4
5
6
|
>>>a=[0,1,2,3,4,5]
>>>LASTTHREE=slice(-3,None)
>>>LASTTHREE
slice(-3,None,None)
>>>a[LASTTHREE]
[3,4,5]
|
1.11 列表以及迭代器的压缩和解压缩
|
1
2
3
4
5
6
7
|
>>>a=[1,2,3]
>>>b=['a','b','c']
>>>z=zip(a,b)
>>>z
[(1,'a'),(2,'b'),(3,'c')]
>>>zip(*z)
[(1,2,3),('a','b','c')]
|
1.12 列表相邻元素压缩器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
>>>a=[1,2,3,4,5,6]
>>>zip(*([iter(a)]*2))
[(1,2),(3,4),(5,6)]
>>>group_adjacent=lambdaa,k:zip(*([iter(a)]*k))
>>>group_adjacent(a,3)
[(1,2,3),(4,5,6)]
>>>group_adjacent(a,2)
[(1,2),(3,4),(5,6)]
>>>group_adjacent(a,1)
[(1,),(2,),(3,),(4,),(5,),(6,)]
>>>zip(a[::2],a[1::2])
[(1,2),(3,4),(5,6)]
>>>zip(a[::3],a[1::3],a[2::3])
[(1,2,3),(4,5,6)]
>>>group_adjacent=lambdaa,k:zip(*(a[i::k]foriinrange(k)))
>>>group_adjacent(a,3)
[(1,2,3),(4,5,6)]
>>>group_adjacent(a,2)
[(1,2),(3,4),(5,6)]
>>>group_adjacent(a,1)
[(1,),(2,),(3,),(4,),(5,),(6,)]
|
1.13 在列表中用压缩器和迭代器滑动取值窗口
|
1
2
3
4
5
6
7
8
9
10
11
|
>>>defn_grams(a,n):
... z=[iter(a[i:])foriinrange(n)]
... returnzip(*z)
...
>>>a=[1,2,3,4,5,6]
>>>n_grams(a,3)
[(1,2,3),(2,3,4),(3,4,5),(4,5,6)]
>>>n_grams(a,2)
[(1,2),(2,3),(3,4),(4,5),(5,6)]
>>>n_grams(a,4)
[(1,2,3,4),(2,3,4,5),(3,4,5,6)]
|
1.14 用压缩器反转字典
|
1
2
3
4
5
6
7
8
|
>>>m={'a':1,'b':2,'c':3,'d':4}
>>>m.items()
[('a',1),('c',3),('b',2),('d',4)]
>>>zip(m.values(),m.keys())
[(1,'a'),(3,'c'),(2,'b'),(4,'d')]
>>>mi=dict(zip(m.values(),m.keys()))
>>>mi
{1:'a',2:'b',3:'c',4:'d'}
|
1.15 列表展开
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
>>>a=[[1,2],[3,4],[5,6]]
>>>list(itertools.chain.from_iterable(a))
[1,2,3,4,5,6]
>>>sum(a,[])
[1,2,3,4,5,6]
>>>[xforlinaforxinl]
[1,2,3,4,5,6]
>>>a=[[[1,2],[3,4]],[[5,6],[7,8]]]
>>>[xforl1 inaforl2 inl1 forxinl2]
[1,2,3,4,5,6,7,8]
>>>a=[1,2,[3,4],[[5,6],[7,8]]]
>>>flatten=lambdax:[yforlinxforyinflatten(l)]iftype(x)islistelse[x]
>>>flatten(a)
[1,2,3,4,5,6,7,8]
|
1.16 生成器表达式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
>>>g=(x**2forxinxrange(10))
>>>next(g)
0
>>>next(g)
1
>>>next(g)
4
>>>next(g)
9
>>>sum(x**3forxinxrange(10))
2025
>>>sum(x**3forxinxrange(10)ifx%3==1)
408
|
1.17 字典推导
|
1
2
3
4
5
6
7
|
>>>m={x:x**2forxinrange(5)}
>>>m
{0:0,1:1,2:4,3:9,4:16}
>>>m={x:'A'+str(x)forxinrange(10)}
>>>m
{0:'A0',1:'A1',2:'A2',3:'A3',4:'A4',5:'A5',6:'A6',7:'A7',8:'A8',9:'A9'}
|
1.18 用字典推导反转字典
|
1
2
3
4
5
|
>>>m={'a':1,'b':2,'c':3,'d':4}
>>>m
{'d':4,'a':1,'b':2,'c':3}
>>>{v:kfork,vinm.items()}
{1:'a',2:'b',3:'c',4:'d'}
|
1.19 命名元组
|
1
2
3
4
5
6
7
8
|
>>>Point=collections.namedtuple('Point',['x','y'])
>>>p=Point(x=1.0,y=2.0)
>>>p
Point(x=1.0,y=2.0)
>>>p.x
1.0
>>>p.y
2.0
|
1.20 继承命名元组
|
1
2
3
4
5
6
7
8
9
|
>>>classPoint(collections.namedtuple('PointBase',['x','y'])):
... __slots__=()
... def__add__(self,other):
... returnPoint(x=self.x+other.x,y=self.y+other.y)
...
>>>p=Point(x=1.0,y=2.0)
>>>q=Point(x=2.0,y=3.0)
>>>p+q
Point(x=3.0,y=5.0)
|
1.21 操作集合
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
>>>A={1,2,3,3}
>>>A
set([1,2,3])
>>>B={3,4,5,6,7}
>>>B
set([3,4,5,6,7])
>>>A|B
set([1,2,3,4,5,6,7])
>>>A&B
set([3])
>>>A-B
set([1,2])
>>>B-A
set([4,5,6,7])
>>>A^B
set([1,2,4,5,6,7])
>>>(A^B)==((A-B)|(B-A))
True
|
1.22 操作多重集合
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
>>>A=collections.Counter([1,2,2])
>>>B=collections.Counter([2,2,3])
>>>A
Counter({2:2,1:1})
>>>B
Counter({2:2,3:1})
>>>A|B
Counter({2:2,1:1,3:1})
>>>A&B
Counter({2:2})
>>>A+B
Counter({2:4,1:1,3:1})
>>>A-B
Counter({1:1})
>>>B-A
Counter({3:1})
|
1.23 统计在可迭代器中最常出现的元素
|
1
2
3
4
5
6
7
|
>>>A=collections.Counter([1,1,2,2,3,3,3,3,4,5,6,7])
>>>A
Counter({3:4,1:2,2:2,4:1,5:1,6:1,7:1})
>>>A.most_common(1)
[(3,4)]
>>>A.most_common(3)
[(3,4),(1,2),(2,2)]
|
1.24 两端都可操作的队列
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
>>>Q=collections.deque()
>>>Q.append(1)
>>>Q.appendleft(2)
>>>Q.extend([3,4])
>>>Q.extendleft([5,6])
>>>Q
deque([6,5,2,1,3,4])
>>>Q.pop()
4
>>>Q.popleft()
6
>>>Q
deque([5,2,1,3])
>>>Q.rotate(3)
>>>Q
deque([2,1,3,5])
>>>Q.rotate(-3)
>>>Q
deque([5,2,1,3])
|
1.25 有最大长度的双端队列
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
>>>last_three=collections.deque(maxlen=3)
>>>foriinxrange(10):
... last_three.append(i)
... print', '.join(str(x)forxinlast_three)
...
0
0,1
0,1,2
1,2,3
2,3,4
3,4,5
4,5,6
5,6,7
6,7,8
7,8,9
|
1.26 可排序词典
|
1
2
3
4
5
6
7
8
9
|
>>>m=dict((str(x),x)forxinrange(10))
>>>print', '.join(m.keys())
1,0,3,2,5,4,7,6,9,8
>>>m=collections.OrderedDict((str(x),x)forxinrange(10))
>>>print', '.join(m.keys())
0,1,2,3,4,5,6,7,8,9
>>>m=collections.OrderedDict((str(x),x)forxinrange(10,0,-1))
>>>print', '.join(m.keys())
10,9,8,7,6,5,4,3,2,1
|
1.27 默认词典
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
>>>m=dict()
>>>m['a']
Traceback(most recent call last):
File"<stdin>",line1,in<module>
KeyError:'a'
>>>
>>>m=collections.defaultdict(int)
>>>m['a']
0
>>>m['b']
0
>>>m=collections.defaultdict(str)
>>>m['a']
''
>>>m['b']+='a'
>>>m['b']
'a'
>>>m=collections.defaultdict(lambda:'[default value]')
>>>m['a']
'[default value]'
>>>m['b']
'[default value]'
|
1.28 默认字典的简单树状表达
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
>>>importjson
>>>tree=lambda:collections.defaultdict(tree)
>>>root=tree()
>>>root['menu']['id']='file'
>>>root['menu']['value']='File'
>>>root['menu']['menuitems']['new']['value']='New'
>>>root['menu']['menuitems']['new']['onclick']='new();'
>>>root['menu']['menuitems']['open']['value']='Open'
>>>root['menu']['menuitems']['open']['onclick']='open();'
>>>root['menu']['menuitems']['close']['value']='Close'
>>>root['menu']['menuitems']['close']['onclick']='close();'
>>>printjson.dumps(root,sort_keys=True,indent=4,separators=(',',': '))
{
"menu":{
"id":"file",
"menuitems":{
"close":{
"onclick":"close();",
"value":"Close"
},
"new":{
"onclick":"new();",
"value":"New"
},
"open":{
"onclick":"open();",
"value":"Open"
}
},
"value":"File"
}
}
|
1.29 对象到唯一计数的映射
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>>importitertools,collections
>>>value_to_numeric_map=collections.defaultdict(itertools.count().next)
>>>value_to_numeric_map['a']
0
>>>value_to_numeric_map['b']
1
>>>value_to_numeric_map['c']
2
>>>value_to_numeric_map['a']
0
>>>value_to_numeric_map['b']
1
|
1.30 最大和最小的几个列表元素
|
1
2
3
4
5
|
>>>a=[random.randint(0,100)for__ inxrange(100)]
>>>heapq.nsmallest(5,a)
[3,3,5,6,8]
>>>heapq.nlargest(5,a)
[100,100,99,98,98]
|
1.31 两个列表的笛卡尔积
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
>>>forpinitertools.product([1,2,3],[4,5]):
(1,4)
(1,5)
(2,4)
(2,5)
(3,4)
(3,5)
>>>forpinitertools.product([0,1],repeat=4):
... print''.join(str(x)forxinp)
...
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
|
1.32 列表组合和列表元素替代组合
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
>>>forcinitertools.combinations([1,2,3,4,5],3):
... print''.join(str(x)forxinc)
...
123
124
125
134
135
145
234
235
245
345
>>>forcinitertools.combinations_with_replacement([1,2,3],2):
... print''.join(str(x)forxinc)
...
11
12
13
22
23
33
|
1.33 列表元素排列组合
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
>>>forpinitertools.permutations([1,2,3,4]):
... print''.join(str(x)forxinp)
...
1234
1243
1324
1342
1423
1432
2134
2143
2314
2341
2413
2431
3124
3142
3214
3241
3412
3421
4123
4132
4213
4231
4312
4321
|
1.34 可链接迭代器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
>>>a=[1,2,3,4]
>>>forpinitertools.chain(itertools.combinations(a,2),itertools.combinations(a,3)):
... printp
...
(1,2)
(1,3)
(1,4)
(2,3)
(2,4)
(3,4)
(1,2,3)
(1,2,4)
(1,3,4)
(2,3,4)
>>>forsubset initertools.chain.from_iterable(itertools.combinations(a,n)forninrange(len(a)+1))
... printsubset
...
()
(1,)
(2,)
(3,)
(4,)
(1,2)
(1,3)
(1,4)
(2,3)
(2,4)
(3,4)
(1,2,3)
(1,2,4)
(1,3,4)
(2,3,4)
(1,2,3,4)
|
1.35 根据文件指定列类聚
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
>>>importitertools
>>>withopen('contactlenses.csv','r')asinfile:
... data=[line.strip().split(',')forline ininfile]
...
>>>data=data[1:]
>>>defprint_data(rows):
... print'\n'.join('\t'.join('{: <16}'.format(s)forsinrow)forrow inrows)
...
>>>print_data(data)
young myope no reduced none
young myope no normal soft
young myope yes reduced none
young myope yes normal hard
young hypermetrope no reduced none
young hypermetrope no normal soft
young hypermetrope yes reduced none
young hypermetrope yes normal hard
pre-presbyopic myope no reduced none
pre-presbyopic myope no normal soft
pre-presbyopic myope yes reduced none
pre-presbyopic myope yes normal hard
pre-presbyopic hypermetrope no reduced none
pre-presbyopic hypermetrope no normal soft
pre-presbyopic hypermetrope yes reduced none
pre-presbyopic hypermetrope yes normal none
presbyopic myope no reduced none
presbyopic myope no normal none
presbyopic myope yes reduced none
presbyopic myope yes normal hard
presbyopic hypermetrope no reduced none
presbyopic hypermetrope no normal soft
presbyopic hypermetrope yes reduced none
presbyopic hypermetrope yes normal none
>>>data.sort(key=lambdar:r[-1])
>>>forvalue,group initertools.groupby(data,lambdar:r[-1]):
... print'-----------'
... print'Group: '+value
... print_data(group)
...
-----------
Group:hard
young myope yes normal hard
young hypermetrope yes normal hard
pre-presbyopic myope yes normal hard
presbyopic myope yes normal hard
-----------
Group:none
young myope no reduced none
young myope yes reduced none
young hypermetrope no reduced none
young hypermetrope yes reduced none
pre-presbyopic myope no reduced none
pre-presbyopic myope yes reduced none
pre-presbyopic hypermetrope no reduced none
pre-presbyopic hypermetrope yes reduced none
pre-presbyopic hypermetrope yes normal none
presbyopic myope no reduced none
presbyopic myope no normal none
presbyopic myope yes reduced none
presbyopic hypermetrope no reduced none
presbyopic hypermetrope yes reduced none
presbyopic hypermetrope yes normal none
-----------
Group:soft
young myope no normal soft
young hypermetrope no normal soft
pre-presbyopic myope no normal soft
pre-presbyopic hypermetrope no normal soft
presbyopic hypermetrope no normal
|
相关推荐
在这个"Python小游戏大全——30个"的压缩包中，包含了30个使用Python编写的各类游戏源码，旨在帮助学习者通过实践提升Python编程技能，理解编程逻辑，同时增加编程的乐趣。 首先，我们可以从这些游戏类型上学习到...
Python 小技巧集锦是一个旨在帮助 Python 开发者提高编程效率和代码质量的资源。该资源汇总了一系列简洁、实用的 Python 编程技巧和技巧，涵盖了各种常见场景下的用例和解决方案。通过这些技巧，开发者可以更加高效...
在"Python小程序8"中，我们可能会接触到如文件操作、数据处理、网络通信等各种实用的编程技巧。 在描述中提到的"python小程序8"多次重复，暗示这个主题可能深入讲解了Python编程中的某个特定方面，比如可能是关于...
下面是六个Python小技巧，涵盖了字符串格式化、标题化、列表推导式、字符串合并、统计列表元素个数和合并字典等多方面的内容。 1. Python3.6以后版本格式化字符串的新方法 在Python3.6以后版本中，引入了新的字符...
标签“python小程序5”的多次出现进一步确认了这是关于Python编程的一个项目集，可能包含不同阶段或难度级别的代码示例。这些标签可能用于分类小程序的功能、目标受众或它们所教授的编程概念。 在压缩包内的文件...
### Python 编程小技巧详解 #### 一、列表推导式(List Comprehensions) 列表推导式是一种非常高效的方法，用于快速构建新的列表。它不仅简化了代码，还提高了可读性。列表推导式的语法如下： ```python new_list ...
Python具有丰富和强大的库。它常被昵称为胶水语言，能够把用其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。常见的一种应用情形是，使用Python快速生成程序的原型（有时甚至是程序的最终界面），然后对...
描述部分虽然重复了同样的话语，但我们可以推测其可能强调的是Python小程序的学习和实践，可能涵盖了一系列从小白到进阶的Python编程技巧和应用实例。在Python编程中，小程序通常涉及基础语法、数据结构、函数、模块...
首先，Python小游戏通常会基于其内置的`pygame`库，这是一个用于开发2D游戏的开源模块。`pygame`提供了丰富的功能，包括窗口管理、事件处理、图形绘制、音频播放等，使得构建游戏变得更加便捷。 1. **初始化Pygame*...
这个“Python小恐龙快跑小游戏”是基于谷歌浏览器中的经典小游戏Dino Run进行仿制的，它展示了如何利用Python进行2D游戏开发的基本原理和技巧。 **1. Python游戏开发基础** Python中的pygame库是开发2D游戏的首选...
python小技巧，请多多提意见，多对分享经验，谢谢
本教程将介绍18个Python高效编程的小技巧，帮助你更好地掌握Python编程。 首先，我们来看如何在Python中交换变量。在C++等语言中，交换两个变量的值通常需要一个额外的临时变量，但在Python中，这一过程非常简单，...
在本文中，我们将探索一些鲜为人知却非常好用的 Python 小技巧。学习和实现这些技巧，可以帮你节省编码的时间和精力，让代码更加优雅、高效。 现在就让我们深入探寻 Python 语言的这些隐藏宝藏吧！ 1. 三元运算符 ...
【Python小程序样例】是为初学者提供的一种学习资源，旨在通过具体的代码示例帮助他们理解和掌握Python编程语言。这些小程序覆盖了不同的功能和应用场景，能够帮助初学者逐步熟悉Python的基础语法、数据结构、文件...
总的来说，《零基础入门学习Python》结合小甲鱼在B站的视频教程，提供了一个全面且易懂的学习路径，让初学者能够轻松踏入Python的世界，开启编程之旅。无论是为了个人兴趣，还是为了职业发展，这都是一个很好的起点...
在标签中，"python小游戏"和"pathon"再次强调了这是与Python编程相关的游戏代码。虽然"pathon"可能是误拼，但我们可以推断出这些游戏是使用Python语言编写。 根据压缩包子文件的文件名称，我们可以推测其中包含的三...
"30个Python游戏源码"这个压缩包文件显然是一份宝贵的资源，适合初学者和有一定经验的开发者去学习和研究Python编程技巧。下面，我们将深入探讨这些游戏源码可能涉及的知识点。 1. **基础语法**：游戏源码通常会...
"Python实战-32个小程序"这个资源为初学者提供了宝贵的实践机会，涵盖了多个重要的话题，包括网络爬虫、Web服务器的搭建、机器学习中的决策树以及基础算法。让我们逐一深入探讨这些知识点。 首先，Python爬虫是一个...