从我开始学习python的时候，我就开始自己总结一个python小技巧的集合。后来当我什么时候在Stack Overflow或者在某个开源软件里看到一段很酷代码的时候，我就很惊讶：原来还能这么做！当时我会努力的自己尝试一下这段代码，直到我懂了它的整体思路以后，我就把这段代码加到我的集合里。这篇博客其实就是这个集合整理后一部分的公开亮相。如果你已经是个python大牛，那么基本上你应该知道这里面的大多数用法了，但我想你应该也能发现一些你不知道的新技巧。而如果你之前是一个c,c++,java的程序员，同时在学习python，或者干脆就是一个刚刚学习编程的新手，那么你应该会看到很多特别有用能让你感到惊奇的实用技巧，就像我当初一样。
每一个技巧和语言用法都会在一个个实例中展示给大家，也不需要有其他的说明。我已经尽力把每个例子弄的通俗易懂，但是因为读者对python的熟悉程度不同，仍然可能难免有一些晦涩的地方。所以如果这些例子本身无法让你读懂，至少这个例子的标题在你后面去Google搜索的时候会帮到你。
整个集合大概是按照难易程度排序，简单常见的在前面，比较少见的在最后。
1 拆箱
>>> 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 + 1 for i in range(3))
>>> a, b, c
(1, 3, 5)
>>> a, (b, c), d = [1, (2, 3), 4]
>>> a
1
>>> b
2
>>> c
3
>>> d
4
2 拆箱变量交换
>>> a, b = 1, 2
>>> a, b = b, a
>>> a, b
(2, 1)
3 扩展拆箱（只兼容python3）
>>> a, *b, c = [1, 2, 3, 4, 5]
>>> a
1
>>> b
[2, 3, 4]
>>> c
5
4 负数索引
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a[-1]
10
>>> a[-3]
8
5 切割列表
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a[2:8]
[2, 3, 4, 5, 6, 7]
6 负数索引切割列表
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a[-4:-2]
[7, 8]
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]
8 负数步长切割列表
>>> 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]
9 列表切割赋值
>>> 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]
10 命名列表切割方式
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
11 列表以及迭代器的压缩和解压缩
>>> 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')]
12 列表相邻元素压缩器
>>> a = [1, 2, 3, 4, 5, 6]
>>> zip(*([iter(a)] * 2))
[(1, 2), (3, 4), (5, 6)]
>>> group_adjacent = lambda a, 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 = lambda a, k: zip(*(a[i::k] for i in range(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,)]
13 在列表中用压缩器和迭代器滑动取值窗口
>>> def n_grams(a, n):
... z = [iter(a[i:]) for i in range(n)]
... return zip(*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)]
14 用压缩器反转字典
>>> 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'}
15 列表展开
>>> 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]
>>> [x for l in a for x in l]
[1, 2, 3, 4, 5, 6]
>>> a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
>>> [x for l1 in a for l2 in l1 for x in l2]
[1, 2, 3, 4, 5, 6, 7, 8]
>>> a = [1, 2, [3, 4], [[5, 6], [7, 8]]]
>>> flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]
>>> flatten(a)
[1, 2, 3, 4, 5, 6, 7, 8]
16 生成器表达式
>>> g = (x ** 2 for x in xrange(10))
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> sum(x ** 3 for x in xrange(10))
2025
>>> sum(x ** 3 for x in xrange(10) if x % 3 == 1)
408
17 字典推导
>>> m = {x: x ** 2 for x in range(5)}
>>> m
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
>>> m = {x: 'A' + str(x) for x in range(10)}
>>> m
{0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: 'A7', 8: 'A8', 9: 'A9'}
18 用字典推导反转字典
>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> m
{'d': 4, 'a': 1, 'b': 2, 'c': 3}
>>> {v: k for k, v in m.items()}
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
19 命名元组
>>> 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
20 继承命名元组
>>> class Point(collections.namedtuple('PointBase', ['x', 'y'])):
... __slots__ = ()
... def __add__(self, other):
... return Point(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)
21 操作集合
>>> 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
22 操作多重集合
>>> 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})
23 统计在可迭代器中最常出现的元素
>>> 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)]
24 两端都可操作的队列
>>> 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])
25 有最大长度的双端队列
>>> last_three = collections.deque(maxlen=3)
>>> for i in xrange(10):
... last_three.append(i)
... print ', '.join(str(x) for x in last_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
26 可排序词典
>>> m = dict((str(x), x) for x in range(10))
>>> print ', '.join(m.keys())
1, 0, 3, 2, 5, 4, 7, 6, 9, 8
>>> m = collections.OrderedDict((str(x), x) for x in range(10))
>>> print ', '.join(m.keys())
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
>>> m = collections.OrderedDict((str(x), x) for x in range(10, 0, -1))
>>> print ', '.join(m.keys())
10, 9, 8, 7, 6, 5, 4, 3, 2, 1
27 默认词典
>>> m = dict()
>>> m['a']
Traceback (most recent call last):
File "<stdin>", line 1, 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]'
28 默认字典的简单树状表达
>>> import json
>>> 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();'
>>> print json.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"
}
}
29 对象到唯一计数的映射
>>> import itertools, 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
30 最大和最小的几个列表元素
>>> a = [random.randint(0, 100) for __ in xrange(100)]
>>> heapq.nsmallest(5, a)
[3, 3, 5, 6, 8]
>>> heapq.nlargest(5, a)
[100, 100, 99, 98, 98]
31 两个列表的笛卡尔积
>>> for p in itertools.product([1, 2, 3], [4, 5]):
(1, 4)
(1, 5)
(2, 4)
(2, 5)
(3, 4)
(3, 5)
>>> for p in itertools.product([0, 1], repeat=4):
... print ''.join(str(x) for x in p)
...
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
32 列表组合和列表元素替代组合
>>> for c in itertools.combinations([1, 2, 3, 4, 5], 3):
... print ''.join(str(x) for x in c)
...
123
124
125
134
135
145
234
235
245
345
>>> for c in itertools.combinations_with_replacement([1, 2, 3], 2):
... print ''.join(str(x) for x in c)
...
11
12
13
22
23
33
33 列表元素排列组合
>>> for p in itertools.permutations([1, 2, 3, 4]):
... print ''.join(str(x) for x in p)
...
1234
1243
1324
1342
1423
1432
2134
2143
2314
2341
2413
2431
3124
3142
3214
3241
3412
3421
4123
4132
4213
4231
4312
4321
34 可链接迭代器
>>> a = [1, 2, 3, 4]
>>> for p in itertools.chain(itertools.combinations(a, 2), itertools.combinations(a, 3)):
... print p
...
(1, 2)
(1, 3)
(1, 4)
(2, 3)
(2, 4)
(3, 4)
(1, 2, 3)
(1, 2, 4)
(1, 3, 4)
(2, 3, 4)
>>> for subset in itertools.chain.from_iterable(itertools.combinations(a, n) for n in range(len(a) + 1))
... print subset
...
()
(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)
35 根据文件指定列类聚
>>> import itertools
>>> with open('contactlenses.csv', 'r') as infile:
... data = [line.strip().split(',') for line in infile]
...
>>> data = data[1:]
>>> def print_data(rows):
... print '\n'.join('\t'.join('{: <16}'.format(s) for s in row) for row in rows)
...
>>> 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=lambda r: r[-1])
>>> for value, group in itertools.groupby(data, lambda r: 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
原文链接：
sahandsaba 翻译：
伯乐在线 -
Kevin Sun
译文链接：
http://blog.jobbole.com/63320/
您还没有登录,请您登录后再发表评论
17 楼 kingxip 2014-04-07 11:59
初学基础知识。
你用Python吗？你会Python吗？你是什么东西？
Python大牛不会向你这么狂妄，并且我敢肯定你连个Pythoner的不是。
下这种不加任何条件的定论，你这不是找骂是什么？
就你这逻辑思维也配评论人家Pythoner的文字？也好意思出来显摆？
中国就是太多你这种目无一切到处指点江山的废材。
自始至终我反感的就是你上面这条回复，从那个dsjt的回复：
初学基础知识。
中真的看不出丝毫对python不敬的意思，如果说他有一丝不敬也是针对这篇文章本身，结果被你断章取义为dsjt向python挑战似的，欲加之罪，何患无辞？
在你或者你提到的那些外国友人眼里，这或许是了不得的奇淫技巧，但是如果在dsjt的眼里，这的确不算技巧，怎么办？难道你要按着dsjt的头，逼着他承认这是技巧？认识、理解这种思维本身就是很主观的，就好比我说一声米饭不算美食，面条才是，难道就是向广大的南方朋友宣战了？Iteye本身就是一个让技术人员表达自己观点的平台，任何人都有权利如实表达自己的想法，至于正确与否个人心中有杆秤，但是强行把自己的价值观加载到别人头上是不道德的。
至于爆粗口，我提到的“煞笔”的确是我情绪激动导致的，“龟儿子”是复制你的，向你道歉。
To iteye的编辑们：在翻译国外文章的时候，希望能够终于原作，原文“30 Python Language Features and Tricks You May Not Know About”后半部分“You May Not Know About”被你们忽视了？而这句“你可能不知道的”还是比较关键的，一定程度上表示出了原作者的谦虚的心态（这些特性你们可能不知道，但是也可能已经知道了），但是翻译中把这句省掉，就容易造成一种站在python的制高点指点众人一般的感觉，是很容易引起非议的。
最后，To remyzane:加大字号对增加你的气势没有用途，这个帖子我建议到此为止，不想再跟你争下去了。
16 楼 remyzane 2014-04-06 21:15
明明白白的说特性和技巧
文章中也说了“如果你已经是个python大牛，那么基本上你应该知道这里面的大多数用法了，但我想你应该也能发现一些你不知道的新技巧。”
再看看人家老外的评论（原文）：
Thanks、Great content、Great summary、Great article、Great list、...
有讨论技术的，有对作者表示感谢的，就是没看到嗤之以鼻的
说这不能算技巧，只能算初学基础知识，这不是歪曲是什么？
kingxip，我就好奇了：你不懂Python，怎么知道哪些算基础知识（还初学），哪些算技巧？
你绝不是以一种好的心态说这话，你这话的用意和效果也绝不是正面的。
还有 kingxip 你是狗吗？上来就咬。
要说我激动、敏感我承认，但说语言暴力，和你比我差远了。
15 楼 remyzane 2014-04-06 19:08
这种吊儿郎当，满嘴胡言，毫无逻辑能力的IT废材，跑我面前来恶心，没理由不抽它啊
“跑到我面前来恶心”，煞笔，别自作多情了，人说是让你看的吗？感情iteye是你家开的？
看看你的回复，搞的跟python是你爹一样。况且2楼的回复有对python怀有敌意么？
龟儿子别自作多情了，python不是你爷。
2楼的回复歪曲事实是肯定的，一个不懂python的人在那大言不惭的歪曲python。
龟儿子你觉的这是一种友善行为吗？
呵呵，龟儿子，感情你是用p眼看到别人歪曲事实的？
你的狗眼看不出来很正常！
14 楼 kingxip 2014-04-06 15:16
这种吊儿郎当，满嘴胡言，毫无逻辑能力的IT废材，跑我面前来恶心，没理由不抽它啊
“跑到我面前来恶心”，煞笔，别自作多情了，人说是让你看的吗？感情iteye是你家开的？
看看你的回复，搞的跟python是你爹一样。况且2楼的回复有对python怀有敌意么？
龟儿子别自作多情了，python不是你爷。
2楼的回复歪曲事实是肯定的，一个不懂python的人在那大言不惭的歪曲python。
龟儿子你觉的这是一种友善行为吗？
呵呵，龟儿子，感情你是用p眼看到别人歪曲事实的？
13 楼 remyzane 2014-04-04 19:34
这种吊儿郎当，满嘴胡言，毫无逻辑能力的IT废材，跑我面前来恶心，没理由不抽它啊
“跑到我面前来恶心”，煞笔，别自作多情了，人说是让你看的吗？感情iteye是你家开的？
看看你的回复，搞的跟python是你爹一样。况且2楼的回复有对python怀有敌意么？
龟儿子别自作多情了，python不是你爷。
2楼的回复歪曲事实是肯定的，一个不懂python的人在那大言不惭的歪曲python。
龟儿子你觉的这是一种友善行为吗？
12 楼 kingxip 2014-04-04 15:43
这种吊儿郎当，满嘴胡言，毫无逻辑能力的IT废材，跑我面前来恶心，没理由不抽它啊
“跑到我面前来恶心”，煞笔，别自作多情了，人说是让你看的吗？感情iteye是你家开的？
看看你的回复，搞的跟python是你爹一样。况且2楼的回复有对python怀有敌意么？
11 楼 remyzane 2014-04-03 17:43
这种吊儿郎当，满嘴胡言，毫无逻辑能力的IT废材，跑我面前来恶心，没理由不抽它啊
10 楼 remyzane 2014-04-03 17:28
可爱的Python是拿来用的，不是拿来学的
9 楼 remyzane 2014-04-03 17:26
里面是有些基础知识，但大部分是偶尔才会用到的技巧。
也就是说全部会当然更好，只会一部分也不影响使用Python开发。
请大家无视那些对Python怀着敌意的人说的那些危言耸听的话。
还是那句话：可爱的Python是拿来用的，不是拿来学的
8 楼 remyzane 2014-04-03 17:25
你去问 dsjt 这货就知道了
7 楼 yidao620c 2014-04-03 10:18
6 楼 yidao620c 2014-04-03 10:17
初学基础知识。
你用Python吗？你会Python吗？你是什么东西？
Python大牛不会向你这么狂妄，并且我敢肯定你连个Pythoner的不是。
下这种不加任何条件的定论，你这不是找骂是什么？
就你这逻辑思维也配评论人家Pythoner的文字？也好意思出来显摆？
中国就是太多你这种目无一切到处指点江山的废材。
哈哈，你对自己的认识很深刻嘛！！
remyzane有点激动啊！
5 楼 dsjt 2014-04-03 09:47
初学基础知识。
你用Python吗？你会Python吗？你是什么东西？
Python大牛不会向你这么狂妄，并且我敢肯定你连个Pythoner的不是。
下这种不加任何条件的定论，你这不是找骂是什么？
就你这逻辑思维也配评论人家Pythoner的文字？也好意思出来显摆？
中国就是太多你这种目无一切到处指点江山的废材。
哈哈，你对自己的认识很深刻嘛！！
4 楼 remyzane 2014-04-03 03:18
也就是说全部会当然更好，只会一部分也不影响使用Python开发。
请大家无视那些对Python怀着敌意的人说的那些危言耸听的话。
还是那句话：可爱的Python是拿来用的，不是拿来学的
3 楼 remyzane 2014-04-03 03:00
初学基础知识。
你用Python吗？你会Python吗？你是什么东西？
Python大牛不会向你这么狂妄，并且我敢肯定你连个Pythoner的不是。
下这种不加任何条件的定论，你这不是找骂是什么？
就你这逻辑思维也配评论人家Pythoner的文字？也好意思出来显摆？
中国就是太多你这种目无一切到处指点江山的废材。
2 楼 dsjt 2014-04-02 17:23
初学基础知识。
1 楼 remyzane 2014-04-02 16:20