Python学习笔记——部分常用/特殊用法

1、使用*号来展开序列，*是序列展开，每个元素都当做一个参数。
ls = (1, 2, 3);
foo(ls)，这样foo只有一个参数，就是ls这个列表本身
foo(*ls), foo得到3个参数，分别为1 2 3，等价于foo（1，2，3）

2、python 读写文件中 w与wt ; r与rt 有何区别？

't' 表示‘text mode’， 相对应的是"binary mode'

就是说你是以文本模式打开，还是二进制模式打开。因为默认就是文本模式，所以'rt' 等价于'r'

3、int64与int的区别？

1）int是python的基本类型，而int64是numpy中引入的一个类，即 numpy.int64 ；

2）使用numpy模块中的numpy.sum()方法得到的结果是int64，而使用默认的sum()得到结果的int类型；

下面代码中，虽然执行结果a和b的数值都是6，但是类型不同

import numpy as np
# a 的类型是int64
a = np.sum([1,2,3])
# b 的类型是int
b = sum([1,2,3])

3）int64不会报除0的错误（事实上numpy中的其他类型也不会报错，比如float64等）；而int会报除0错误（其他基本类型也会，比如float等）

测试如下：表明numpy 的数据类型（int64、float64等）比python的基本类型（int、float等）功能强大，计算能力更强，可以有nan、inf等结果

import numpy as np
#--------  int 例子 -------------
# 也可以写int(1)，也可不写，因为默认是int类型
a = 1
b = 0
c = 0

#下面都会报 int 不能除0错误
r1 = a / b 
r2 = b / c
#下面都会报 float 不能除0错误
r3 = a *1.0 / b 
r4 = b *1.0 / c

#--------- int64 例子  -----------

a = np.int64(1)
b = np.int64(0)
c = np.int64(0)

#下面语句不会除0报错，会提示，但不报错和中断
# 运行结果： r1 = 0 , r2 = 0
r1 = a / b 
r2 = b / c

#运行结果： r3 = inf ,r4 = nan
#inf 表示无穷大，nan表示not a number ，不是数字
r3 = a *1.0 / b 
r4 = b *1.0 / c

4、type()函数可用于返回某个数据的数据类型；

a = 1
type(a)

5、& 跟 and 的区别？

& 是位运算；and 是逻辑运算。

>>> a = 1
>>> b = 2
>>> #1 的二进制是 01，2的二进制是 10
>>> a&b
0
>>> a and b
2

 &虽然是位运算，但是如果操作数是0或1的话，也类似于逻辑运算；

>>> a=1
>>> b=1
>>> c=0
>>> a & b
1
>>> a & c
0

6、Lambda 表达式有何用处？如何使用？

　　【引言】这是python支持一种有趣的语法，它允许你快速定义单行的最小函数（请记住它本质就是个函数），类似C语言中的宏，可以用在任何需要函数的地方，示例如下：

>>> g = lambda x: x * 2
>>> g(3)
6
>>> (lambda x: x * 2)(3)
6

　　我们也可以把filter map reduce 和lambda结合起来用，函数就可以简单的写成一行。例如

>>>kmpathes = filter(lambda kmpath: kmpath, map(lambda kmpath: string.strip(kmpath), string.split(l, ':')))

　　看起来麻烦，其实就像用语言来描述问题一样，非常优雅。
　　对 l 中的所有元素以':'做分割，得出一个列表。对这个列表的每一个元素做字符串strip，形成一个列表。对这个列表的每一个元素做直接返回操作(这个地方可以加上过滤条件限制)，最终获得一个字符串被':'分割的列表，列表中的每一个字符串都做了strip，并可以对特殊字符串过滤。

著作权归作者所有。
商业转载请联系作者获得授权，非商业转载请注明出处。
作者：涛吴
链接：http://www.zhihu.com/question/20125256/answer/14058285
来源：知乎

简单来说，编程中提到的 lambda 表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。这一用法跟所谓 λ 演算（题目说明里的维基链接）的关系，有点像原子弹和质能方程的关系，差别其实还是挺大的。

不谈形式化的 λ 演算，只说有实际用途的匿名函数。先举一个普通的 Python 例子：将一个 list 里的每个元素都平方：

map( lambda x: x*x, [y for y in range(10)] )

这个写法要好过

def sq(x):
    return x * x

map(sq, [y for y in range(10)])

，因为后者多定义了一个（污染环境的）函数，尤其如果这个函数只会使用一次的话。而且第一种写法实际上更易读，因为那个映射到列表上的函数具体是要做什么，非常一目了然。如果你仔细观察自己的代码，会发现这种场景其实很常见：你在某处就真的只需要一个能做一件事情的函数而已，连它叫什么名字都无关紧要。Lambda 表达式就可以用来做这件事。

进一步讲，匿名函数本质上就是一个函数，它所抽象出来的东西是一组运算。这是什么意思呢？类比

a = [1, 2, 3]

和

f = lambda x : x + 1

，你会发现，等号右边的东西完全可以脱离等号左边的东西而存在，等号左边的名字只是右边之实体的标识符。如果你能习惯 [1, 2, 3] 单独存在，那么 lambda x : x + 1 也能单独存在其实也就不难理解了，它的意义就是给「某个数加一」这一运算本身。

现在回头来看 map() 函数，它可以将一个函数映射到一个可枚举类型上面。沿用上面给出的 a 和 f，可以写：

map(f, a)

也就是将函数 f 依次套用在 a 的每一个元素上面，获得结果 [2, 3, 4]。现在用 lambda 表达式来替换 f，就变成：

map( lambda x : x + 1, [1, 2, 3] )

会不会觉得现在很一目了然了？尤其是类比

a = [1, 2, 3]
r = []
for each in a:
    r.append(each+1)

这样的写法时，你会发现自己如果能将「遍历列表，给遇到的每个元素都做某种运算」的过程从一个循环里抽象出来成为一个函数 map，然后用 lambda 表达式将这种运算作为参数传给 map 的话，考虑事情的思维层级会高出一些来，需要顾及的细节也少了一点。Python 之中，类似能用到 lambda 表达式的「高级」函数还有 reduce、filter、sorted 等等，很多语言也都有这样的工具（不过这些特性最好不要在 Python 中用太多，原因详见 http://www.zhihu.com/question/19794855/answer/12987428 的评论部分）。这种能够接受一个函数作为参数的函数叫做「高阶函数」（higher-order function），是来自函数式编程（functional programming）的思想。

和其他很多语言相比，Python 的 lambda 限制多多，最严重的当属它只能由一条表达式组成。这个限制主要是为了防止滥用，因为当人们发觉 lambda 很方便，就比较容易滥用，可是用多了会让程序看起来不那么清晰，毕竟每个人对于抽象层级的忍耐 / 理解程度都有所不同。

 

【附高级函数filter、map、reduce等】

首先注意这些函数不只是跟lambda表达式搭配，还可以跟def定义的函数搭配，如下：

filter

filter(function, sequence):

对sequence中的item依次执行function(item)，将执行结果为True的item组成一个List/String/Tuple(取决于sequence类型）返回，示例如下：

>>> def f(x): return x % 2 != 0 and x % 3 != 0
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]
>>> def f(x): return x != 'a'
>>> filter(f, "abcdef")
'bcdef'

map

map(function, sequence):

对sequence中的item依次执行function（item），将执行结果组成一个List返回
另外map也支持多个sequence，当然这也要求function支持相应数量的参数输入，示例如下：

>>> def cube(x): return x*x*x
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
>>> def cube(x) : return x + x

>>> def add(x, y): return x+y
>>> map(add, range(8), range(8))
[0, 2, 4, 6, 8, 10, 12, 14]

reduce（归纳）

reduce（function，sequence，starting_value):

对sequence中的item顺序迭代调用function，如果有starting_value，还可以作为初始值调用，例如可以用来对List求和，示例如下：

>>> def add(x,y): return x + y
 >>> reduce(add, range(1, 11))
（注：1+2+3+4+5+6+7+8+9+10）
>>> reduce(add, range(1, 11), 20)
（注：1+2+3+4+5+6+7+8+9+10+20）

sorted：对sequence进行排序，直接看例子

>>> s = [('a', 3), ('b', 2), ('c', 1)]

>>> sorted(s, key=lambda x:x[1])

s = [('a', 3), ('b', 2), ('c', 1)]

更多例子...

>>> l = ['foo', 'bar', 'far']
>>> map(lambda x: x.upper(), l)
['FOO', 'BAR', 'FAR']
>>> filter(lambda x: 'f' in x, l)
['foo', 'far']
>>> map(lambda x: x.upper(), filter(lambda x: 'f' in x, l))
['FOO', 'FAR']
>>> reduce(lambda a, b: a * b, xrange(1, 5)) # 计算 1*2*3*4 = 24
24

7、字典的排序：(使用lambda)

 python 字典（dict）的特点就是无序的，按照键（key）来提取相应值（value），如果我们需要字典按值排序的话，那可以用下面的方法来进行：

1）下面的是按照value的值从大到小的顺序来排序。

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}
dict= sorted(dic.iteritems(), key=lambda d:d[1], reverse = True)
print dict

输出的结果：
[('aa', 74), ('a', 31), ('bc', 5), ('asd', 4), ('c', 3), ('d', 0)]

下面我们分解下代码
print dic.iteritems() 得到[(键，值)]的列表。
然后用sorted方法，通过key这个参数，指定排序是按照value，也就是第一个元素d[1的值来排序。reverse = True表示是需要翻转的，默认是从小到大，翻转的话，那就是从大到小。

2）对字典按键（key）排序：
dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}
dict= sorted(dic.iteritems(), key=lambda d:d[0]) d[0]表示字典的键
print dict

 8、Python文件夹与文件的操作

参考：【python文件夹与文件的操作】

　　　【python判断文件和文件夹是否存在、创建文件夹】

（1）判断文件夹是否存在

>>> import os

>>> os.path.exists('d:/assist')

True

（2）判断文件是否存在

>>> os.path.exists('d:/assist/getTeacherList.py')

True

（3）判断是否是文件

>>> os.path.isfile('d:/assist')

False

>>> os.path.isfile('d:/assist/getTeacherList.py')

True

（4）创建文件夹

mkdir( path [,mode] ) 
      作用：创建一个目录，可以是相对或者绝对路径，mode的默认模式是0777。 

      如果目录有多级，则创建最后一级。如果最后一级目录的上级目录有不存在的，则会抛出一个OSError。

>>> os.mkdir('d:/assist/set')

 

 makedirs( path [,mode] )
      作用： 创建递归的目录树，可以是相对或者绝对路径，mode的默认模式也是0777。
      如果子目录创建失败或者已经存在，会抛出一个OSError的异常，Windows上Error 183即为目录已经存在的异常错误。如果path只有一级，与mkdir一样。例如：

>>> os.makedirs('d:/assist/set')

>>> os.path.exists('d:/assist/set')

True