1、无论是 for、while 还是 if 中的变量都是存在于上下文中的, 即如果循环或条件变量跟前面的某个变量同名的话, 那么将会将那个变量重新赋值。 所以循环或条件变量尽量不要取跟前面的变量相同的变量名;
2、> 在python中不可以用, 会报语法错误;
3、当n较小时生成器表达式跟列表推导式效率差不多, 但当n较大时, 则会比较明显;
4、使用zip()函数一次处理两个或多个列表中的元素
aList = [1, 2, 3, 4, 5, 6, 7,8 ,9 , 10]
bList = [1, 3, 4, 7, 5, 8]
cList = []
for a, b in zip(aList, bList):
if a == b:
print a, b
cList.append([a, b])
# 1 1
# 5 5
可以看出: 即使 aList 和 bList 长度不一样也可以
5、在同一个程序中函数名跟类名不可以相同, 否则会被覆盖
6、int、list等类型的变量没有__name__属性, 但是函数跟类有
7、当一个函数使用修饰器进行修饰后, 我们运行该函数时, 实际上是先运行修饰器的, 当修饰器中调用到该函数时才会再运行该函数, 反之则不会
def GetRunTime(func):
def check(*args, **args2):
print '1:', args, args2
startTime = datetime.datetime.now()
print '2:', '@@@@@@'
#f = func(*args, **args2)
endTime = datetime.datetime.now()
print(endTime - startTime)
#return f
return check
@GetRunTime
def test(*args, **kwargs):
print '3:', args, kwargs
print '4:', '!' * 20
test(1, 2, 3, 4, a=5, b=6, c=7, d=8)
# 当调用 test 函数时, 结果如下:
# 1: (1, 2, 3, 4) {'a': 5, 'c': 7, 'b': 6, 'd': 8}
# 2: @@@@@@
# 3: (1, 2, 3, 4) {'a': 5, 'c': 7, 'b': 6, 'd': 8}
# 4: !!!!!!!!!!!!!!!!!!!!
# 0:00:00
# 当不调用 test 函数时, 结果如下:
# 1: (1, 2, 3, 4) {'a': 5, 'c': 7, 'b': 6, 'd': 8}
# 2: @@@@@@
# 0:00:00
8、类也可以作为修饰器
9、复制列表时为了避免出现浅复制的问题, 可以使用如下这个方法:
>>> a = [1, 2, 3]
>>> b = a[:]
>>> a.append(4)
>>> b
[1, 2, 3]
>>> a
[1, 2, 3, 4]
# 以下内容来自 http://www.iteye.com/magazines/12-Python 的总结
10、将相邻的字符串进行连接的做法:
>>> print 'o' 'n' 'e'
one
虽然字符之间的空格不是必需的,但是这样有助于可读性。
11、注意:使用字符串变量名无法通过以上方式进行连接。
>>> a = 'three'
>>> b = 'four'
>>> a b
File "<stdin>", line 1
a b
^
SyntaxError: invalid syntax
这是因为自动连接是由Python解析器/编译器来处理的,因为其无法在编译时对变量值进行"翻译",所以就这种必须在运行时使用“+“运算符来连接变量。
12、如果想在同一行对不同的变量进行赋值, 可以使用如下的方法:
>>> a = 1, b = 2
File "<input>", line 1
SyntaxError: can't assign to literal
>>> a = 1; b = 2
>>> a
1
>>> b
2
注: 最好的方法是使用序列解包(链式赋值)
a, b = 1, 2
13、即使函数或类的注释仅有一行, 也应该使用三引号, 而不是单引号, 原因是为了以后更好地扩展
14、文档注释 = 用于解释如何使用代码
文档注释公约:http://www.python.org/dev/peps/pep-0257/
注释 = 为什么 (理由) & 代码如何工作的如:
# !!! BUG: ...
# !!! FIX: This is a hack
# ??? Why is this here?
15、*a 的形式只能用作函数参数
>>> a, b, *c = (5, 6, 7, 8)
File "<input>", line 1
a, b, *c = (5, 6, 7, 8)
^
SyntaxError: invalid syntax
>>> def test(a, *b):
print a, b
>>> test(1, 2, 3, 4)
1 (2, 3, 4)
16、如果有一个两行三列的二维列表, 我们想要把每一行都赋值给不同的变量, 我们可以怎么做?
mydict = {}
i = 1
for j in mylist: # 也可以写成 for (a, b, c) in mylist: #<span style="font-family: Arial, Helvetica, sans-serif;">写成这样的形式的好处是</span><span style="font-family: Arial, Helvetica, sans-serif;">可以直接</span>
mydict[i] = j # 读取mylist的第一行的值分别给a, b, c, 这样如果需要对a, b, c的值进行操作的话就会非常方便
i += 1
>>> mydict
{1: [1, 2, 3], 2: [4, 5, 6]}
但是这样做非常麻烦, 而且还并没有实现我们的目的, 如果要实现我们的目的还要再加上如下的代码:
>>> d = mydict[1]
>>> d
[1, 2, 3]
>>> e = mydict[2]
>>> e
[4, 5, 6]
但是有没有更好的方法呢?当然有!
>>> f, g = mylist
>>> f
[1, 2, 3]
>>> g
[4, 5, 6]
17、在只有一个元素的元组,尾随逗号是必须的,在2 + 元素的元组,尾随逗号是可选的:
>>> (1, 2,)
(1, 2)
如果建立空元组则只需要一对括号即可:
>>> ()
()
18、当你在交互式模式下(如 IDEL)计算一个表达式或调用一个函数后,其结果必然是一个临时名称,_(下划线):
>>> 1 + 2
3
>>> _
3
这只能交互式的模式中使用,在模块中不能支持。
好处是: 如果你想将一个表达式赋值给一个变量, 但是却只写了表达式而忘了赋值给变量, 这样你就可以将 _ 赋值给变量:
>>> a = _
>>> a
3
19、从列表中创建字符串:
colors = ['red', 'blue', 'green', 'yellow']
当我们需要将上面的列表连接成一个字符串。尤其当 list 是一个很大的列表时....不要这样做:
result = ''
for s in colors:
result += s
而应该这样写:
result = ''.join(colors)
当你只有几十或几百个string项连接时,它们效率上并不会太大的差别。但你要在养成写高效代码的习惯,因为当字符串数千时,join 比起 for 连接性能会能有所提升。
如果你需要使用一个函数来生成一个字符串列表,同样可以使用:
result = ''.join(fn(i) for i in items)
20、如果你需要一个列表,这里有一个可爱的方式来节省你的输入:
>>> items = 'zero one two three'.split()
>>> print items
['zero', 'one', 'two', 'three']
注: 不过并不建议这样做, 因为这样的代码并不直观, 会降低代码的可读性
21、如果我们需要遍历这个 list ,而且需要 index 和 item:
>>> for i, item in enumerate(mylist1):
print i, item
0 1
1 2
2 3
3 4
22、判断True:
# do this: # not this:
if x: if x == True:
pass pass
#以上内容引用结束
#以下内容引用自 http://www.iteye.com/news/25125
23、使用iteritems而不是items
iteritems 使用generators ,因此当通过非常大的列表进行迭代时,iteritems 更好一些。
d = {1: "1", 2: "2", 3: "3"}
for key, val in d.items() # 当调用时构建完整的列表
for key, val in d.iteritems() # 当请求时只调用值
24、使用isinstance ,而不是type
# 不要这样做
if type(s) == type(""): ...
if type(seq) == list or \
type(seq) == tuple: ...
# 应该这样
if isinstance(s, basestring): ...
if isinstance(seq, (list, tuple)): ...
注意我使用的是basestring 而不是str,因为如果一个unicode对象是字符串的话,可能会试图进行检查。例如:
>>> a=u'aaaa'
>>> print isinstance(a, basestring)
True
>>> print isinstance(a, str)
False
这是因为在Python 3.0以下版本中,有两个字符串类型str 和unicode。25、Python有各种容器数据类型,在特定的情况下,相比内置容器(如list 和dict ),这是更好的选择。
from collections import defaultdict
freqs = defaultdict(int)
for c in "abracadabra":
freqs[c] += 1
26、
namedtuple() # 工厂函数,用于创建带命名字段的元组子类
deque # 类似列表的容器,允许任意端快速附加和取出
Counter # dict子类,用于哈希对象计数
OrderedDict # dict子类,用于存储添加的命令记录
defaultdict # dict子类,用于调用工厂函数,以补充缺失的值
27、必要时使用Ellipsis(省略号“...”)Ellipsis 是用来对高维数据结构进行切片的。作为切片(:)插入,来扩展多维切片到所有的维度。例如:
>>> from numpy import arange
>>> a = arange(16).reshape(2,2,2,2)
# 现在,有了一个4维矩阵2x2x2x2,如果选择4维矩阵中所有的首元素,你可以使用ellipsis符号。
>>> a[..., 0].flatten()
array([ 0, 2, 4, 6, 8, 10, 12, 14])
# 这相当于
>>> a[:,:,:,0].flatten()
array([ 0, 2, 4, 6, 8, 10, 12, 14])
#以上引用结束
28、列表相邻元素压缩器
>>> 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,)]
29、在列表中用压缩器和迭代器滑动取值窗口
>>> 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)]
30、命名元组
>>> 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
31、继承命名元组
>>> 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)
32、当需要将字典中的值输出时, 可以这么做:
>>> mydict
{'a': 1, 'b': 2}
>>> print '%(a)s, %(b)s' % mydict
1, 2
33、”datetime“ 内置库可以将时间处理到纳秒级
34、在pycharm中, 控制台跟 .py 文件中运行出来的结果有些显示会有所差别
# 控制台的输出结果
>>> from datetime import date, time
>>> time(3, 24)
datetime.time(3, 24)
# .py 文件的运行结果
from datetime import date, time
print time(3, 24) # 3时24分
# 输出的结果
03:24:00
35、可以迭代一个函数中的函数:
def test():
def A():
print "A"
def B():
print "B"
def C():
print "C"
def D():
print "D"
return A(), B(), C(), D()
for i in test():
i
输出结果:
A
B
C
D
36、python 的赋值语句没有返回值,所以这是错的: y =( x = x + 1)
但不要括号的话,就可以,这样就变成链式赋值了
37、除可变对象外,如果两个变量指向同一个对象(如一个整型、元组、字符串等)则其内存地址相同,即实际上指向的是同一个对象
38、python 的原地改变指的是,变量指向的对象自己发生了改变,但内存地址却没有发生改变,即没有变成新的对象。如列表的原地排序。