python 匿名函数&内置函数

匿名函数：

为了解决那些功能很简单的需求而设计的一句话函数
怎么定义匿名函数：

cal = lambda x : x*x # cal是函数名，lambda是定义匿名函数的关键字  冒号前面的额x是参数即函数的形参，x*x是返回值
print(cal(10))

函数名 = lambda 参数 ：返回值

参数可以有多个，用逗号隔开
匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
返回值和正常的函数一样可以是任意数据类型

func = lambda x, y, z : x+y+z       # 匿名函数实现多个参数相加
print(func(1,2,3))

func = lambda x, y, z : x*y*z       # 匿名函数实现多个参数相乘
print(func(1,2,3))

一般我们在和其他功能的函数合作的时候使用。

内置函数

内置函数是python提供给你直接可以拿来使用的所有函数。

到 python3.6.2 python一共提供了68个内置函数，我们可以分成6大类方便理解：

 1、作用域相关

基于字典的形式获取局部变量和全局变量

globals()——获取全局变量的字典

locals()——获取执行本方法所在命名空间内的局部变量的字典

2、其他

eval() 将字符串中的代码还原成原始的数据类型

print(eval('{"name": "zhangsan"}'))     # 会将字符串类型的'{'name': 'zhangsan'}'还原成字典{'name': 'zhangsan'}输出

exec()将字符串中的代码执行

exec("print('hello,world')")        # 会将字符串代码执行，并输出结果
print(exec('print("1+2+3+4")'))          # 会将字符串代码执行输出结果,并打印出exec函数返回值None

compile  将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。

参数说明：　　　

1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。　　

2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。　　

3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。

c = "for i in range(10):     print(i)"
comp = compile(c, "", "exec")         # 流程语句用exce
exec(comp)

c1 = "1+2+3+4"
comp1 = compile(c1, "", "eval")      # 求值用eval
print(eval(comp1))

c2 = 'name = input("username:")'
comp2 = compile(c2, "", "single")         # 交互式命令用single
exec(comp2)                               # 会执行交互式命令
print(eval("name"))                       # 因为指定name，执行完交互式输入后name才存在，所有可以用eval去转换字符串”name“去输出输入的name的值

输入输出：

input() 交互式命令输入

print() 打印输出结果

内存相关：

hash() 返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错。

a = (1, 2, 3)
b = {1, 2, 3}
c = [1, 2, 3]
print(hash(a))     # 元祖式不可变类型会返回一个int
print(hash(b))     # 集合式可变类型，不可hash会报错
print(hash(c))     # 列表式可变类型，不可hash会报错 

id() 获取变量内存地址

文件操作：

open()  打开一个文件，返回一个文件操作符(文件句柄)

操作文件的模式有r,w,a,r+,w+,a+ 共6种，每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)

可以用encoding指定编码.

模块操作相关：

__import__导入一个模块

import time              # 导入时间模块
for i in range(10):
    time.sleep(1)        # 延迟程序运行时间
    print("*", end="", flush=True)   # flush 屏幕刷新

帮助：

help()

在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型。输入q退出

或者直接执行help(o)，o是参数，查看和变量o有关的操作。。。

 调用相关：

callable() 判断一个变量是不是函数

def cal():
    print(1)

print(callable(cal))  # 是函数返回True

查看参数所属类型的所有内置方法

dir() 默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量

print(dir(list))  #查看列表的内置方法
print(dir(int))  #查看整数的内置方法

和数字相关

数字——数据类型相关：bool，int，float，complex

bool ()判断传入的参数的bool值

int() 将传入的全部由数字组成的字符串转换成数字

float()将传入的数字或者全部又数字组成的字符串转换成浮点数

complex()将传入的数字或者全部又数字组成的字符串转换成复数的形式

数字——进制转换相关：bin，oct，hex

bin() 十进制转二进制

oct() 十进制转八进制

hex() 十进制转十六进制

数字——数学运算：abs，divmod，min，max，sum，round，pow

abs() 取绝对值

divmod() 把除数和余数运算结果结合起来，返回一个包含商和余数的元组

min() 在一个数列中取最小值

max() 在一个数列中取最大值

sum() 在一个数列中求和

round( x [, n] ) 以n为位数，返回x的四舍五入的值

pow(x,y,z) 返回x的y次方，如果z存在则对结果取模

和数据结构相关

列表和元祖：

list() 将一个变量的值转换成列表

tuple() 将一个变量的值转换成原则

相关内置函数

reversed() 序列反转

li = [1, 2, 3, 4, 5, 7, 888]
print(list(reversed(li))) # 将列表顺序反转输出

slice()定义一个索引的格式

li = [1, 2, 3, 4, 5, 7, 888]
s = slice(1, 3, 2)
print(li[s])

字符串：

str() 将一个变量的值转换成字符串

format() 格式化输出

bytes() 将字符串以指定的格式转换成bytes字节码

bytearry() 叫做字节数组，是可变的，有序的

ret = bytearray('alex',encoding='utf-8')
print(id(ret))
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))

memoryview()函数返回给定参数的内存查看对象

ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret))
print(bytes(ret[:3]).decode('utf-8'))
print(bytes(ret[3:]).decode('utf-8'))

ord() 返回对应的 ASCII 数值

chr() 返回值是当前整数对应的 ASCII 字符，数字范围（0，255）

ascii() 返回一个可打印的对象字符串方式表示，如果是非ascii字符就会输出\x，\u或\U等字符来表示

repr() 函数将对象转化为供解释器读取的形式。

数据集合——字典和集合：

dict()  创建一个字典

print(dict())                        # 创建空字典

print(dict(a='a', b='b', t='t'))     # 传入关键字

print(dict(zip(['one', 'two', 'three'], [1, 2, 3])))   # 映射函数方式来构造字典

print( dict([('one', 1), ('two', 2), ('three', 3)]))   # 可迭代对象方式来构造字典

set() 创建一个集合

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

数据集合

len() 计算变量的长度

sorted() 给一个数列排序

enumerate() 枚举，打印一个数列的索引

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。

any()函数用于判断给定的可迭代参数 iterable 中的所有元素又一个为True则为 True

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

num = [1, 2, 3]
nums = ['flower','flow','flight']
print(list(zip(num, nums)))   # zip 相当于压缩，会对应把两个参数列表中的对应位置的元素，放在一起组成一个元祖
for i in zip(*nums):       # 与 zip 相反，给变量加上*可理解为解压，返回二维矩阵式

    print(i)

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

def cal(x):
    return x % 2 == 0      # 定义一个函数，判断X是否能被2整除

print(list(filter(cal, range(100))))  # 利用filter筛选出能被2整除的数

import math
def cal1(x):
    return math.sqrt(x) % 1 == 0     # 定义一个函数，判断x的平方根是不是整数，这里用到math模块的sqrt方法

print(list(filter(cal1, range(100)))) # 利用filter筛选出平方根是整数的数列表

map() map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

print(list(map(lambda x: x*x, range(10))))              # 同时利用map函数和匿名函数，得到0-9中所有元素的平方