Python自动化开发学习3-2-匿名函数、内置函数

下面这部分内容计划应该是第三周讲的,但是应该是当时来不及,第四周上来的内容又比较重要,就放到了第四周讲完后才讲了。

匿名函数

如果函数值使用一次,并且结构结单(需要一行表达式),就可以使用匿名函数。匿名函数的好处:

  1. 程序一次行使用,所以不需要定义函数名,节省内存中变量定义空间

  2. 让程序更加简洁

普通函数:

1
2
3
def test(x,y):
    return x+y
print(test(1,2))

匿名函数:

1
2
test = lambda x,y:x+y
print(test(1,2))

lambda:定义一个匿名函数

冒号(:):分隔符

冒号之前的部分:函数的参数,可以无参数,但是冒号不能省

冒号之后的部分:函数的返回值。lambda没有return,后面的就是返回值

上面的列子我们还是定了一个变量名,因为方便后面给参数赋值,这样函数用完后并没有释放空间。把整个函数括起来,后面再写个括号写入参数。

1
print((lambda x,y:x+y)(1,2))

最终变成了一行,这就很像函数式编程了。

再举个求最大值的例子:

1
2
3
= (lambda x,y:x if x>y else y)
print(f(2,3))
print(f(6,4))

但是上面的例子平时根本不用这么写。平时不用这么用,因为一般匿名函数是配合别的函数一起使用的,如reduce、filter。

1
2
= filter(lambda x:x>3,[1,2,3,4,5,6,7,8,9])  # 通过lambda函数来过滤列表中的元素
print(list(a))

嵌套使用

匿名函数可以嵌套在普通函数中,匿名函数本身作为return的返回值。

1
2
3
4
def func(n):
    return lambda x:n**x
= func(3)
print(f(2),f(3),f(4))

内置函数

然后是把所有的内置函数都讲了一遍,也不是所有,很多关于对象的类的都先跳过了。

abs()取绝对值

1
print(abs(3),abs(0),abs(-4))

all()一个可迭代对象如果所有的值都为True则返回True

1
2
print(all([0,1,2,3,4,5]))  # False
print(all([1,2,3,4,5]))  # True

any()一个可迭代对象只有其中有一个的值都为True就返回True

1
2
print(any([0,1,2,3,4,5]))  # True
print(any([0,'',False,None]))  # False

ascii()把一个对象变成一个可打印的字符串的形式,没什么用。

1
2
print(type(123),type(ascii(123)),ascii(123))  # int类型通过ascii()变成了str类型
print(ascii("你好"))  # 中文字还会转码

bin()把一个整数转换成二进制

1
print(bin(8))  # 0b1000

bool()布尔,判断True还是False

1
2
3
4
5
print(bool(1))
print(bool([]))
print(bool([1,2,3]))
print(bool("你好"))
print(bool(None))

bytearray()变成一个bytearray格式

bytes()变成一个bytes格式

1
2
3
4
5
6
= bytes("abcde",encoding="utf-8")
= bytearray("abcde",encoding="utf-8")
print(type(a),type(b))
#a[1] = 99  # bytes类型是不可以修改的,str类型也是
b[1= 99  # 这个可以修改
print(a,b)

callable() 判断一个对象是否可以被调用。函数名后面可以加(),加了()就是调用。是否可以被调用,就是是否可以后面加()

1
2
3
4
5
6
7
= []
print(callable(a))  # Fales,列表不能被调用
def b():
    pass
print(callable(b))  # True,函数可以被调用
= ( i for in range(10) )
print(callable(c.__next__))  # True,生成器c可以用next方法调用下一个元素

chr()返回这个整数对应的字符

ord()返回这个字符对应的字符的编码

1
2
3
4
print(chr(100))
print(ord("d"))
print(chr(8364))  # 是这个符号
print(chr(7))  # 这个会发出“嘟”的一声

classmethod(function)类方法,以后会讲

compile()把代码进行编译,大概是这样。我们用不到,给个了可以执行的演示。

把字符串形式的代码编译执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 把你的代码转成字符串存在变量里
code = """
def fib(n):
    i,a,b = 0,0,1
    while i < n:
        #print(b)
        yield b
        a,b = b,a+b
        i += 1
    return "结束"
f = fib(10)
while 1:
    try:
        x = next(f)  # x = f.__next__()
        print(x)
    except StopIteration as e:
        print("返回值是:",e.value)
        break
"""
#exec(code)  # 其实这里直接exec也是可以执行的
py_obj = compile(code,"","exec")  # 编译你的代码,第二个参数是文件名存放编译过程中出错的信息
exec(py_obj)  # 上面是用exec编辑的,这里用exec执行

这个例子并不是很好,把上面的那句注释掉的语句直接执行也是可以的,不需要经过compile的编译。但是也没有别的例子了,总之就是用不到

这里为啥是exec,什么是exec,还能不能是别的,暂时不知道。

complex()生成复数

1
2
3
4
= complex("1+2j")  # 字符串转为复数
print(type(a),a)
= complex(1,2)  # 两个参数都是数字,第一个为实部,第二个为虚部
print(type(b),b)

delattr()被略过了,以后会讲

dict()创建字典,其实可以用来生成很复杂的字典,比如用列表来构造

1
2
= dict()  # 创建一个空字典
print(type(a),a)

dir()查看对象有什么方法

1
2
3
4
5
6
= {}
print(dir(a))
= "123"
print(dir(b))
= 123
print(dir(c))

不同的数据类型,能使用的方法是不用的。两个__下划线的是内部方法,一般都不能用,也有能用的,比如迭代器的__next__。

divmod(a,b),a除以b,得到商和余数

1
2
print(divmod(9,5))  # (1,4)
print(divmod(10,4))  # (2,2)

enumerate()可以为元组或列表等生产索引序列

1
2
3
list1 = ['a','b','c','d','e']
for i,j in enumerate(list1):
    print(i,j)

eval()把字符串形式的字典、列表等等,转换成对应的数据类型

1
2
3
4
= "{'a':1,'b':2,'c':3}"
print(type(a),a)
= eval(a)
print(type(b),b)

exec(),可以执行字符串形式的代码

1
2
3
4
5
6
comm = """
a = [1,2,3,4,5]
for i in a:
    print(i)
"""
exec(comm)

filter(),根据参数1的函数对参数2进行过滤

map(),根据参数1的函数对参数2进行处理

1
2
3
4
5
6
res1 = filter(lambda n:n>6,range(10))
for in res1:
    print(i)
res2 = map(lambda n:n*2,range(10))
for in res2:
    print(j)

frozenset(),创建一个不可变的集合

1
2
3
4
5
6
= set([1,2,3,4,5])
a.pop()  # set可以从中增加或者删除元素
print(type(a),a)
= frozenset([1,2,3,4,5])
#b.pop()  # frozenset无法改变里面的元素
print(type(b),b)

globals(),返回全局变量的变量名和值,字典的形式。局部变量可以用locals()

1
print(globals())

getattr(),返回对象属性值,关于对象还没讲到,以后会讲,应该是很重要的内容

hasattr(),判断对象是否包含这个属性

setattr(),设置对象属性值,和上面的getattr相对应。

hash(),获取一个字符串或数值的哈希值

1
2
3
4
print(hash(123))
print(hash('123'))
print(hash('test'))
print(hash(str([1,2,3])))  # 列表不可以,需要转成字符串

help(),查看帮助

1
2
3
help('hash')  # 查看hash函数的帮助
= []  # a现在是一个列表
help(a)  # 查看列表的帮助

hex(),把数字转成16进制

1
2
3
print(hex(15))
print(hex(1023))
print(hex(-256))

id(),返回内存地址

1
2
3
4
def a():
    pass
print(a)  # 这里直接打印函数的内存地址
print(hex(id(a)))  # id默认是10进制,转成16进制和上面一样

input(),获取输入的字符串

1
2
= input("输入任意字符串:")
print(a)

int(),转成10进制,默认输入的数据是10进制,或者用第二个参数指定

1
2
3
4
5
6
7
print(int('15'))  # 默认10进制
print(int('10',16))  # 16进制的10就是10进制的16
print(int('0x10',16))  # 即时字符串前有0x,后面的16进制也不能省略
print(int('ff',16))
print(int('0b100',2))
print(int('100',5))  # 还可以有奇怪的进制,5进制
print(int('1gg',17))  # 17进制

isinstance(),判断参数1是否是参数2的类型

1
2
3
4
print(isinstance(1,str))  # False
print(isinstance('1',str))  # True
print(isinstance([],(set,dict)))  # False,是否是元祖中的其中一个类型
print(isinstance([],(list,dict)))  # True

issubclass(),是不是一个子类。啥是类,还没学

iter(),装换成迭代器

1
2
3
4
5
6
7
8
from collections import Iterator
= [1,2,3,4,5,6]  # a是列表
print(isinstance(a,Iterator))  # Fales,现在a还不是一个迭代器
= iter(a)  # 把a变成成迭代器
print(isinstance(b,Iterator))  # True,现在b是一个迭代器了
print(b.__next__())  # 可以用next
print(b.__next__())
print(b.__next__())

len(),返回长度

1
2
print(len('123'))
print(len([1,2,3]))

list(),可以将元祖转换成列表。只要是可迭代对象应该都可以

1
2
3
4
5
6
= (1,2,3)
= list(a)
print(type(a),a)
print(type(b),b)
print(range(10))
print(list(range(10)))  # range()也可以转

locals(),打印当前位置的局部变量,字典的形式,变量名和值

1
2
3
4
5
6
7
def test():
    local_var = 123
    print(locals())  # 打印局部变量,只有一个local_var
    print(globals())  # 打印的依然是全局变量,没有当前位置的局部变量
test()
print(locals())  # 这个位置打印的就是全局变量
print(globals())  # 打印的还是全局变量

map(),根据提供的函数,对指定的对象做映射

1
2
= map(lambda x:x**2,[1,2,3,4,5])  # 列表中的每个元素都用lambda的方法计算一次
print(list(a))

max()和min(),返回最大值和最小值

1
2
print(max(1,2,3))  # 可以是好几个变量
print(min([1,2,3]))  # 也可以是一个列表

memoryview(),返回给定对象的内存查看对象(Momory view)。不懂,也用不到。

next(),通过__next__()调用迭代器的下一项

1
2
3
4
= ( (lambda x:x**2)(i) for in range(2,10) )  # 构造一个迭代器
print(next(a))  # 打印出迭代器中的下一项
print(next(a))
print(next(a))

object,Python里,一切皆对象。至于这里有什么用,不知道

oct(),将整数转为8进制

1
2
3
4
print(oct(1))
print(oct(8))
print(oct(9))
print(oct(0xa))  # 这个是16进制的写法

open(),打开文件。之前用过很多了,略。

ord(),前面chr()一起讲了

pow(),求幂。其实可以有3个参数pow(x,y,z),就是计算(x**y)%z,有z的情况下求余数。

1
2
print(pow(2,10,3))  # 2**10除以3的余数
print(pow(2,10))  # 求2的10次幂

print(),略

property(),返回新式类属性,以后会讲。

range(),直接看例子

1
2
3
print(list(range(10)))  # 1个参数,从0开始
print(list(range(2,10)))  # 2个参数:指定开始和结束
print(list(range(2,10,2)))  # 3个参数:再加上步长

repr(),把对象转为字符串

1
2
3
4
= [1,2,3,4,5]
= repr(a)
print(type(a),a)  # a是列表
print(type(b),b)  # b是字符串

reversed(),对对象进行反转,返回的是一个迭代器

1
2
3
4
5
6
7
8
= (1,2,3,4,5)
= reversed(a)
print(next(b))
print(next(b))
print(list(b))
= ['a','b','c','d','e']
= reversed(c)
print(list(d))

round(),格式化浮点数。第一个参数是数值,第二个参数是小数位数。用字符串格式化的%f应该更方便,但是如果要用参数控制小数位数,应该只能靠round()

1
2
3
4
print(round(0.1234,2))
num = 0.1234567
for in range(3,7):
    print(round(num,i))

set(),创建集合

1
2
3
= [1,2,3,4,5,2,3]
= set(a)
print(type(b),b)

setattr(),设置对象属性值,和上面的getattr相对应。这个非常重要,以后会讲

slice(),切片。一般用[x:y:z],所以没用

1
2
3
arr = range(10)
print(arr[slice(2,8,2)])
print(arr[2:8:2])  # 和上面效果一样

sorted(),

1
2
3
4
5
6
= {'c':5,'z':2,'a':4,'o':9,'f':8}
= sorted(a.items())  # 按字典的key来排序
= sorted(a.items(),key=lambda x:x[1])  # 按字典的value排序比较复杂
print(a)  # 原来的字典
print(b)  # 排序后,但是这里是列表了,因为字典是无序的
print(c)  # 排序后,按照原来字典的value输出了

b=sorted(a.items(),key=lambda x:x[1])这句解释一下。sorted的第二个参数是指定排序的关键字。这里的key=是sorted函数的关键参数(不是字典的key),就是按lambda x:x[1]的值进行排序。这里已经把字典的每一个元素变成一个元组了,参考b的输出。这里的x[1]就是元组的第二个元素,也就是字典的value值。所以就是按字典的value来进行排序了。

staticmethod(),是一个方法,以后会讲。

str(),转换成字符串。

sum(),求和

super(),非常重要的面向对象里的继承的概念,也要以后讲了。

tuple(),生成一个元组

type(),查看数据类型

1
2
3
4
5
6
print(type(1))
print(type('1'))
print(type(True))
print(type({}))
print(type([]))
print(type(()))

vars(),返回一个对象的所有的属性名和值,缺省参数就和locals()一样了。要加上对象才有别的效果。但是:1、对象还没学;2、还是用不到

1
2
3
4
5
6
7
8
9
10
11
12
13
class Runoob:
    = 1
def test():
    = 1
    print(vars())
    print(locals())
print("在函数内部,2个效果一样")
test()
print("作用于全局,2个效果还是一样")
print(vars())
print(locals())
print("vars可以带参数,指定一个class,主要是这个作用")
print(vars(Runoob))

zip(),把几个可迭代对象组合起来

1
2
3
4
5
6
7
8
9
= [1,2,3,4]
= ['a','b','c','d']
for in zip(a,b):  # 把两个可迭代对象组合起来
    print(i)
= ['A','B','C','D','E']
for in zip(a,c):  # 如果长度不一样,按短的来
    print(i)
for in zip(a,b,c):  # 参数的数量不定
    print(i)

__import__(),动态加载。一般用import加载模块就好了。如果一个模块经常变化就要使用 __import__() 来动态载入。以后可能会用到。暂时知道就行了。这个忘记它吧,这不出官方的推荐用法也没给出例子。












本文转自骑士救兵51CTO博客,原文链接:http://blog.51cto.com/steed/1980315,如需转载请自行联系原作者

上一篇:Ckeditor一种很方便的文本编辑器


下一篇:直播系统源代码,用户在点击图片时,通过淡入淡出的方式放大图片的两种方法