问道python

做好某些领域的研究，做好某些领域的工程。

这是我对自己的要求，研究就是做社交网络挖掘，现在很火，我也跟着凑热闹。一连发了几篇社交圈子挖掘的博客，越来越有心得。这是个好的兆头，再接再厉。 在做社交圈子挖掘的过程中，我需要不断的做实验，试验论文中的想法，自己的想法，要求效果好，而且coding要快。我比较熟悉java，c++也会一些，但是我都没有选择，我选择了我不熟悉的python，一方面，networkx是pyhton写的。另一方面，想见识一下python的魅力。 我目前用得都比较简单，但是也明显感觉开发速度快，方便的特点，使用python我感觉很随意，觉得自己好像触碰到自由的边沿。java也是开源，而且开源更盛，但是我用java却丝毫自由的感觉没有，我想主要还是类型和语法方面的原因吧，省略了分号，让我感到很方便，强制的缩进，让代码看起来就漂亮。 写这篇博客不是为了说自己的感受，而是为了理解python。这会是一个很长的过程，我会坚持。这一篇博客也会不断地更新，直到，我不再使用python的时候。 下面会是一些比较有趣的python的小trick，我会不停地记录，很多是翻译过来的，理解的不好，记录下来，方便加深理解：

1. python操作符

   x << y            #左移
   x >> y            #右移
   x & y               #按位与
   x | y                   #按位或
   x ^ y                   #按位异或 (exclusive or)
   ~x                      #按位翻转
   x + y                   #加
   x - y                   #减
   x * y                   #乘
   x / y                   #常规除
   x // y                  #地板除
   x ** y                  #乘方 (xy )
   x % y                   #取模 (x mod y )
   -x                      #改变操作数的符号位
   +x                      #什么也不做
   ~x                      #~x=-(x+1)
   abs(x )                 #绝对值
   divmod(x ,y )           #返回 (int(x / y ), x % y )
   pow(x ,y [,modulo ])    #返回 (x ** y ) x % modulo
   round(x ,[n])           #四舍五入，n为小数点位数
   x < y                #小于
   x > y                #大于
   x == y                  #等于
   x != y                  #不等于(与<>相同)
   x >= y               #大于等于x

2. python求字符串的逆：

   "hello, world"[::-1]

3. swap value

   a, b = b, a

4. example of unpacking:
   1. l = ['a', 'b', 'c']
   2. a, b, c = l
   3. unpacking 可以应用在for循环中
5. comma is the tuple constructor,括号是可选的，推荐使用括号，comma是必须的
6.  _存储了上一次打印的结果，必须是在交互式环境中，如果上一次的结果为None，则_的值不变
7. 合并子串，不要使用for循环，应该是''.join(substrings)
8. 子串之间以空格分隔

   ' '.join(substrings)

9. 子串之间以逗号分隔

   ','.join(substrings)

10. [:-1] means slice until -1

11. ' '.join(fn(i) for i in items)

12. 逆序并切片:x[::-1] >> [5, 4, 3, 2, 1] x[::-2] >> [5, 3, 1]
13. 使用isinstance，不要type
14. 要写成：def function(x, l=None): 不要写成：def function(x, l=[]):
15. for k in dict:这种方式比较快，不是for k in dict.keys()
16. for key, val in d.iteritems()使用这种方式，lazy call；而不是for key, val in d.items()，这个首先将 d.items()构建完毕之后，再遍历。
17. 当要修改dict内容的时候，需要如下的遍历:for k in dict.keys() 原因是dict.keys()产生了一个临时的列表，否则会抛出异常
18. in还可以作为操作符，判断某个key是否在dict中，为了保证一致性，推荐使用if key in dict:
19. Dictionary的get方法，可以设定key不存在时，返回默认值
20. dict.setdefault(key, default)省去if判断
21. 使用defaultdict，获得比setdefault更好的效率。如果想dict默认是0，则传入参数为int即可。如果默认是列表，则传入list函数即可。
22. dict(zip(keys, values)),根据连个list，构造dict，一一映射
23. 判断list是否为空，if items：即可。当items不为空的时候，条件为True
24. “”,0,0.0,[],{},set(),None出现在条件判断的位置，都是False。
25. __len__:自定义集合类实现这个函数，__nonzero__:自定义非集合类实现这个函数，以用来得到True或者False
26. enumerate函数返回每个元素的index和元素值：那些既需要索引，又需要元素值本身的遍历，就可以使用这个函数
    1. for (index, iterm) in enmuerate(items)
27. 函数默认参数求值是在函数定义的时候，就完成了，不是在每次调用的时候。
28. 所使用pprint模块
29. use List Comprehentions: [ i ** 2 for i in range(10) if i % 2 == 0]
30. Generator  expressions are the same with List Comprehentions except that List Comprehention is greedy, but Generator Expression is lazy which only compute when needed.
31. list comprehention : total = sum([num * num for num in range(1, 101)])
32. generator expression: total = sum(num * num for num in range(1, 101))
33. dict((fn(i + 1), code) for i, code in enumerate('FGHJMNQUVXZ') for fn in (str, int))
34. 使用yield关键字，将一个函数转化为generator。例如，我们从一个文件中按行读取数据，要过滤掉空行，就可以使用yield定义一个函数，这样这个函数就会返回一个generator，相当于一个lazy的list会会提高处理的效率，而不是一次性全部处理完毕
35. 推荐直接使用str(your_var), 而不是isinstance(x, str)
36. never use bare except clause
37. never use from module import *
38. 一些类的magic methods：

    __eq__(self, other)      # 定义 == 运算符的行为  
    __ne__(self, other)      # 定义 != 运算符的行为  
    __lt__(self, other)      # 定义 < 运算符的行为   
    __gt__(self, other)      # 定义 > 运算符的行为  
    __le__(self, other)      # 定义 = 运算符的行为

39. pyhton中比较有用的容器：

        
        namedtuple()    # 工厂函数，用于创建带命名字段的元组子类  
        deque           # 类似列表的容器，允许任意端快速附加和取出  
        Counter   # dict子类，用于哈希对象计数  
        OrderedDict   # dict子类，用于存储添加的命令记录  
        defaultdict   # dict子类，用于调用工厂函数，以补充缺失的值

40. 序列操作

    操作                      描述
    s + r                   #序列连接
    s * n , n * s           #s的 n 次拷贝,n为整数
    s % d                   #字符串格式化(仅字符串)
    s[i]                    #索引
    s[i :j ]                #切片
    x in s , x not in s     #从属关系
    for x in s :            #迭代
    len(s)                  #长度
    min(s)                  #最小元素
    max(s)                  #最大元素
    s[i ] = x               #为s[i]重新赋值
    s[i :j ] = r            #将列表片段重新赋值
    del s[i ]               #删除列表中一个元素
    del s[i :j ]            #删除列表中一个片段

41. 类型转换

    函数                      描述
    int(x [,base ])         #将x转换为一个整数
    long(x [,base ])        #将x转换为一个长整数
    float(x )               #将x转换到一个浮点数
    complex(real [,imag ])  #创建一个复数
    str(x )                 #将对象 x 转换为字符串
    repr(x )                #将对象 x 转换为表达式字符串
    eval(str )              #用来计算在字符串中的有效Python表达式,并返回一个对象
    tuple(s )               #将序列 s 转换为一个元组
    list(s )                #将序列 s 转换为一个列表
    chr(x )                 #将一个整数转换为一个字符
    unichr(x )              #将一个整数转换为Unicode字符
    ord(x )                 #将一个字符转换为它的整数值
    hex(x )                 #将一个整数转换为一个十六进制字符串
    oct(x )                 #将一个整数转换为一个八进制字符串

我也希望大家能够一起讨论，一起分享。 [引用]

http://canofy.iteye.com/blog/298263

转载于:https://www.cnblogs.com/sing1ee/archive/2012/03/03/2765027.html