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

参考链接： Python程序使用匿名函数显示2的幂

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

  匿名函数

  如果函数值使用一次，并且结构结单（需要一行表达式），就可以使用匿名函数。匿名函数的好处：

  程序一次行使用，所以不需要定义函数名，节省内存中变量定义空间让程序更加简洁

  普通函数：

  def test(x,y):

    return x+y

print(test(1,2))

  匿名函数：

  test = lambda x,y:x+y

print(test(1,2))

  lambda：定义一个匿名函数

  冒号（:）：分隔符

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

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

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

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

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

  再举个求最大值的例子：

  f = (lambda x,y:x if x>y else y)

print(f(2,3))

print(f(6,4))

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

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

print(list(a))

  嵌套使用

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

  def func(n):

    return lambda x:n**x

f = func(3)

print(f(2),f(3),f(4))

  内置函数

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

  abs()取绝对值

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

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

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

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

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

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

print(any([0,'',False,None]))  # False

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

  print(type(123),type(ascii(123)),ascii(123))  # int类型通过ascii()变成了str类型

print(ascii("你好"))  # 中文字还会转码

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

  print(bin(8))  # 0b1000

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

  print(bool(1))

print(bool([]))

print(bool([1,2,3]))

print(bool("你好"))

print(bool(None))

  bytearray()变成一个bytearray格式

  bytes()变成一个bytes格式

  a = bytes("abcde",encoding="utf-8")

b = bytearray("abcde",encoding="utf-8")

print(type(a),type(b))

#a[1] = 99  # bytes类型是不可以修改的，str类型也是

b[1] = 99  # 这个可以修改

print(a,b)

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

  a = []

print(callable(a))  # Fales，列表不能被调用

def b():

    pass

print(callable(b))  # True，函数可以被调用

c = ( i for i in range(10) )

print(callable(c.__next__))  # True，生成器c可以用next方法调用下一个元素

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

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

  print(chr(100))

print(ord("d"))

print(chr(8364))  # 是这个符号

print(chr(7))  # 这个会发出“嘟”的一声

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

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

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

  # 把你的代码转成字符串存在变量里

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()生成复数

  a = complex("1+2j")  # 字符串转为复数

print(type(a),a)

b = complex(1,2)  # 两个参数都是数字，第一个为实部，第二个为虚部

print(type(b),b)

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

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

  a = dict()  # 创建一个空字典

print(type(a),a)

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

  a = {}

print(dir(a))

b = "123"

print(dir(b))

c = 123

print(dir(c))

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

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

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

print(divmod(10,4))  # (2,2)

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

  list1 = ['a','b','c','d','e']

for i,j in enumerate(list1):

    print(i,j)

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

  a = "{'a':1,'b':2,'c':3}"

print(type(a),a)

b = eval(a)

print(type(b),b)

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

  comm = """

a = [1,2,3,4,5]

for i in a:

    print(i)

"""

exec(comm)

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

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

  res1 = filter(lambda n:n>6,range(10))

for i in res1:

    print(i)

res2 = map(lambda n:n*2,range(10))

for j in res2:

    print(j)

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

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

a.pop()  # set可以从中增加或者删除元素

print(type(a),a)

b = frozenset([1,2,3,4,5])

#b.pop()  # frozenset无法改变里面的元素

print(type(b),b)

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

  print(globals())

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

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

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

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

  print(hash(123))

print(hash('123'))

print(hash('test'))

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

  help()，查看帮助

  help('hash')  # 查看hash函数的帮助

a = []  # a现在是一个列表

help(a)  # 查看列表的帮助

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

  print(hex(15))

print(hex(1023))

print(hex(-256))

  id()，返回内存地址

  def a():

    pass

print(a)  # 这里直接打印函数的内存地址

print(hex(id(a)))  # id默认是10进制，转成16进制和上面一样

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

  a = input("输入任意字符串：")

print(a)

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

  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的类型

  print(isinstance(1,str))  # False

print(isinstance('1',str))  # True

print(isinstance([],(set,dict)))  # False，是否是元祖中的其中一个类型

print(isinstance([],(list,dict)))  # True

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

  iter()，装换成迭代器

  from collections import Iterator

a = [1,2,3,4,5,6]  # a是列表

print(isinstance(a,Iterator))  # Fales，现在a还不是一个迭代器

b = iter(a)  # 把a变成成迭代器

print(isinstance(b,Iterator))  # True，现在b是一个迭代器了

print(b.__next__())  # 可以用next

print(b.__next__())

print(b.__next__())

  len()，返回长度

  print(len('123'))

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

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

  a = (1,2,3)

b = list(a)

print(type(a),a)

print(type(b),b)

print(range(10))

print(list(range(10)))  # range()也可以转

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

  def test():

    local_var = 123

    print(locals())  # 打印局部变量，只有一个local_var

    print(globals())  # 打印的依然是全局变量，没有当前位置的局部变量

test()

print(locals())  # 这个位置打印的就是全局变量

print(globals())  # 打印的还是全局变量

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

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

print(list(a))

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

  print(max(1,2,3))  # 可以是好几个变量

print(min([1,2,3]))  # 也可以是一个列表

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

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

  a = ( (lambda x:x**2)(i) for i in range(2,10) )  # 构造一个迭代器

print(next(a))  # 打印出迭代器中的下一项

print(next(a))

print(next(a))

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

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

  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的情况下求余数。

  print(pow(2,10,3))  # 2**10除以3的余数

print(pow(2,10))  # 求2的10次幂

  print()，略

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

  range()，直接看例子

  print(list(range(10)))  # 1个参数，从0开始

print(list(range(2,10)))  # 2个参数：指定开始和结束

print(list(range(2,10,2)))  # 3个参数：再加上步长

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

  a = [1,2,3,4,5]

b = repr(a)

print(type(a),a)  # a是列表

print(type(b),b)  # b是字符串

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

  a = (1,2,3,4,5)

b = reversed(a)

print(next(b))

print(next(b))

print(list(b))

c = ['a','b','c','d','e']

d = reversed(c)

print(list(d))

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

  print(round(0.1234,2))

num = 0.1234567

for i in range(3,7):

    print(round(num,i))

  set()，创建集合

  a = [1,2,3,4,5,2,3]

b = set(a)

print(type(b),b)

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

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

  arr = range(10)

print(arr[slice(2,8,2)])

print(arr[2:8:2])  # 和上面效果一样

  sorted()，

  a = {'c':5,'z':2,'a':4,'o':9,'f':8}

b = sorted(a.items())  # 按字典的key来排序

c = 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()，查看数据类型

  print(type(1))

print(type('1'))

print(type(True))

print(type({}))

print(type([]))

print(type(()))

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

  class Runoob:

    a = 1

def test():

    a = 1

    print(vars())

    print(locals())

print("在函数内部，2个效果一样")

test()

print("作用于全局，2个效果还是一样")

print(vars())

print(locals())

print("vars可以带参数，指定一个class，主要是这个作用")

print(vars(Runoob))

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

  a = [1,2,3,4]

b = ['a','b','c','d']

for i in zip(a,b):  # 把两个可迭代对象组合起来

    print(i)

c = ['A','B','C','D','E']

for i in zip(a,c):  # 如果长度不一样，按短的来

    print(i)

for i in zip(a,b,c):  # 参数的数量不定

    print(i)

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

转载于:https://blog.51cto.com/steed/1980315