python的学习笔记

1、无论是 for、while 还是 if 中的变量都是存在于上下文中的， 即如果循环或条件变量跟前面的某个变量同名的话， 那么将会将那个变量重新赋值。 所以循环或条件变量尽量不要取跟前面的变量相同的变量名；

2、&gt 在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@GetRunTimedef test(*args, **kwargs):    print '3:',  args, kwargs    print '4:', '!' * 20test(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 1SyntaxError: can't assign to literal>>> a = 1; b = 2>>> a1>>> b2

注： 最好的方法是使用序列解包（链式赋值）

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 = 1for 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 + 23>>> _3

这只能交互式的模式中使用，在模块中不能支持。

好处是： 如果你想将一个表达式赋值给一个变量， 但是却只写了表达式而忘了赋值给变量， 这样你就可以将 _ 赋值给变量：

>>> a = _>>> a3

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, item0 11 22 33 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' % mydict1, 2

33、”datetime“ 内置库可以将时间处理到纳秒级

34、在pycharm中， 控制台跟 .py 文件中运行出来的结果有些显示会有所差别

# 控制台的输出结果>>> from datetime import date, time>>> time(3, 24)datetime.time(3, 24)

# .py 文件的运行结果from datetime import date, timeprint 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输出结果：ABCD

36、python 的赋值语句没有返回值，所以这是错的： y =( x = x + 1)

但不要括号的话，就可以，这样就变成链式赋值了

37、除可变对象外，如果两个变量指向同一个对象（如一个整型、元组、字符串等）则其内存地址相同，即实际上指向的是同一个对象

38、python 的原地改变指的是，变量指向的对象自己发生了改变，但内存地址却没有发生改变，即没有变成新的对象。如列表的原地排序。