python的学习笔记

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 的原地改变指的是，变量指向的对象自己发生了改变，但内存地址却没有发生改变，即没有变成新的对象。如列表的原地排序。