Python学习第七天——列表推导式、labmba匿名函数、排序函数、模块/包、作用域

列表推导式

用来创建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),可以被直接引用,比如:abcx123PI等;

类似__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。

引用自:

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431845183474e20ee7e7828b47f7b7607f2dc1e90dbb000


anzhihe安志合个人博客,版权所有丨 如未注明,均为原创 丨转载请注明转自:https://chegva.com/2524.html | ☆★★每天进步一点点,加油!★★☆

您可能还感兴趣的文章!

发表评论

电子邮件地址不会被公开。 必填项已用*标注