列表推导式
用来创建list的生成式,，可以快速生成list，可以通过一个list推导出另一个list，而代码却十分优雅，简洁。
语法： [ translate(x) for x in iter if filter(x) ]
def filter(x):
return x % 2 == 0
def translate(x):
return x * x
olist = range(10) rlist = [] for x in olist: #等价于 [x for x in olist] if x % 2 == 0: rlist.append(x * x) print rlist [x * x for x in olist if x % 2 == 0]
>>> olist = range(10) >>> >>> rlist = [] >>> for x in olist: ... if x % 2 == 0: ... rlist.append(x * x) ... >>> print rlist [0, 4, 16, 36, 64] >>> [x * x for x in olist if x % 2 == 0] [0, 4, 16, 36, 64] >>> [(x, x * 2, x * x) for x in olist] [(0, 0, 0), (1, 2, 1), (2, 4, 4), (3, 6, 9), (4, 8, 16), (5, 10, 25), (6, 12, 36), (7, 14, 49), (8, 16, 64), (9, 18, 81)]
labmba匿名函数
通过输入计算后返回函数，当我们在传入函数时，不需要显式地定义函数，直接传入匿名函数更方便。
def add(x, y): return x + y add = lambda x, y: x + y
关键字lambda表示匿名函数，冒号前面的x,y表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
排序函数
排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。
>>> help(list.sort) Help on method_descriptor: sort(...) L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; cmp(x, y) -> -1, 0, 1 >>> help(sorted) Help on built-in function sorted in module __builtin__: sorted(...) sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
list排序
work_list = [(1,4),(5,1),(2,3)] work_list = [2, 3, 6, 4] work_list = [1, 3, 6, 4] work_list = [7, 3, 6, 4] def getlement(x) return x def sort_list(work_list): for j in range(len(work_list) - 1): for i in range(len(work_list) - 1): if getlement(work_list[i]) > getlement(work_list[i + 1]): tmp = work_list[i] work_list[i] = work_list[i + 1] work_list[i + 1] = tmp work_list = [2, 3, 6, 4] sort_list(work_list) print work_list work_list = [1, 3, 6, 4] sort_list(work_list) print work_list work_list = [(1,4),(5,1),(2,3)] def key(x): return x[1] def sort_list2(work_list): for j in range(len(work_list) - 1): for i in range(len(work_list) - 1): if work_list[i][1] > work_list[i + 1][1]: tmp = work_list[i] work_list[i] = work_list[i + 1] work_list[i + 1] = tmp def getmax(x): return max(x) lambda x : max(x) def sort_list_comm(work_list, key): for j in range(len(work_list) - 1): for i in range(len(work_list) - 1): if getmax(work_list[i]) > getmax(work_list[i + 1]): tmp = work_list[i] work_list[i] = work_list[i + 1] work_list[i + 1] = tmp
函数封装
def default_cmp(x, y):
if x > y:
return True
else:
return False
def default_key(x):
return x
def sortlist(listsort, key, cmp):
listsort = listsort[:]
for j in range(len(listsort) -1 ):
for i in range(len(listsort)-1):
#if key(listsort[i])) > key(listsort[i+1]):
ele1 = key(listsort[i])
ele2 = key(listsort[i + 1])
# cmp(key(listsort[i]), key(listsort[i + 1]))
cmp_result = cmp(ele1, ele2)
if cmp_result:
listsort[i],listsort[i+1] = listsort[i+1],listsort[i]
return listsort
if __name__ == '__main__':
sort_list=[(1,4),(5,1),(2,3)]
sort_list = [1, 2, 3]
sort_list = [{'name':'kk'}, {'name':'wn'}, {'name' : 'wd'}]
print sortlist(sort_list, key=lambda x: x['name'], cmp=cmp)模块/包
一堆模块组成的一个文件夹
__init__.py:每一个包目录下面都会有一个init.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。init.py可以是空文件，也可以有Python代码，因为init.py本身就是一个模块.
import hello
from hello import hello_world
作用域
在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过_前缀来实现的。
正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等；
类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名；
类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等；
之所以我们说，private函数和变量“不应该”被直接引用，而不是“不能”被直接引用，是因为Python并没有一种方法可以完全限制访问private函数或变量，但是，从编程习惯上不应该引用private函数或变量。
private函数或变量不应该被别人引用，那它们有什么用呢？请看例子：
def _private_1(name): return 'Hello, %s' % namedef _private_2(name): return 'Hi, %s' % namedef greeting(name): if len(name) > 3: return _private_1(name) else: return _private_2(name)
我们在模块里公开greeting()函数，而把内部逻辑用private函数隐藏起来了，这样，调用greeting()函数不用关心内部的private函数细节，这也是一种非常有用的代码封装和抽象的方法，即：
外部不需要引用的函数全部定义成private，只有外部需要引用的函数才定义为public。
引用自：
