函数五--内置函数和匿名函数

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

内置函数大致分为六大类：反射相关、基础数据类型相关、作用域相关、面向对象相关、迭代器/生成器相关、其他。

作用域相关（2）：locals，globals

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

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

globals() ------获取当前所有的全局变量

 

迭代器/生成器相关(3) :  range、next、iter

 

其他（12）：

字符串类型代码的执行：eval、exec、compile

eval()将字符串类型的代码执行并返回结果（有返回值 —— 有结果的简单计算）eval只能用在你明确知道你要执行的代码是什么

print(eval('1+2+3+4'))   # 10
eval('print(123)')       # 123

exec()将字符串类型的代码执行（没有返回值 —— 简单流程控制）

print(exec('1+2+3+4'))  # None
exec("print('hello world')") # hello world

code = '''
for i in range(3):
    print('*'*i)
'''
exec(code)

# *
# **

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

　　参数1：source  字符串或者AST对象。即需要动态执行的代码块

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

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

#流程语句使用exec
codel = 'for i in range(4): print(i)'
compile1 = compile(codel,'','exec')
exec(compile1)
0
1
2
3

#简单求值表达式用eval
code2 = '1 + 2 + 3'
compile2 = compile(code2,'','eval')
print(eval(compile2))  # 6

#交互语句用single
code3 = 'name = input("please input your name : ")'
compile3 = compile(code3,'','single')
# name
exec(compile3)
print(name)

 　　

输入输出相关：

input()输入

s = input('请输入内容 ：')
print(s)

print()输出

 

数据类型相关：

type(变量)   #返回变量的数据类型

 

内存相关：

id(o)  o是参数，返回一个变量的内存地址

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

t = (1,2,3)
li = [1,2,3]
print(hash(t))  #不可变类型可哈希，不会报错
print(hash(li))  #可变类型不可哈希，会报错

hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。

每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。

　　　

文件操作相关：

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

 

模块操作相关：

__import__导入一个模块

 

和调用相关：

callable(o),o是参数，查看这个变量是不是可以调用

如果o是一个函数名，就会返回True

def func():
    pass
print(callable(func))   # True
print(callable(123))    # False

 

帮助方法：

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

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

 

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

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

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

 

基础数据类型相关：

和数字相关：

数据类型：bool、int、float、complex

进制转换：bin、oct、hex

数学运算：abs、divmod、round、pow、sum、min、max

 

print(bin(10))  #0b1010   转二进制
print(oct(10))  #0o12   转八进制
print(hex(10))  #0xa  转十六进制

print(abs(-5))  # 绝对值
print(abs(5))

print(divmod(7,2))   # (3,1) div出发 mod取余
print(divmod(9,5))   # (1,4) 除余

print(round(3.14159,3))  # 3.142  四舍五入
print(round(3.14159,1))  # 3.1
print(pow(2,3))   # 8  pow幂运算  == 2**3
print(pow(3,2))    # 9
print(pow(2,3,3)) # 2  幂运算之后再取余
print(pow(3,2,1))  # 0

ret = sum([1,2,3])  # 求和
print(ret)   # 6

ret = sum([1,2,3],10)  # 第二个参数表示起点从10开始，然后在10的基础上再加上列表中的各项的和
print(ret)  # 16

print(min([1,2,3,4]))  # 1   计算最小值
print(min(1,2,3,4))    # 1
print(min(1,2,3,-4))   # -4
print(min(1,2,3,-4,key = abs)) # 1   后面可加修饰参数，如abs，表示前面几个值的绝对值后比较最小值，但返回的还是最初的那个值

print(max([1,2,3,4]))  # 4  计算最大值
print(max(1,2,3,4))   # 4
print(max(1,2,3,-4))  # 3
print(max(1,2,3,-4,key = abs))  # -4  后面可加修饰参数，如abs，表示前面几个值的绝对值后比较最大值，但返回的还是最初的那个值

 

和数据结构相关（24）

列表和元组（2）：list、tuple

相关内置函数 (2)  : reversed、 slice

l = [1,2,3,4,5]
l2 = reversed(l)
print(list(l2))  # [5, 4, 3, 2, 1]
print(l)   # [1, 2, 3, 4, 5]
# 保留原列表，返回一个反向的迭代器

l = (1,2,23,213,5612,342,43)
sli = slice(1,5,2)
print(l[sli])  # 2 213
print(l[1:5:2])  #(2, 213)

 

字符串(9): str、format、bytes、bytearray、memoryview、ord、chr、ascii、repr

　　

#bytes 转换成bytes类型
print(bytes('你好',encoding='GBK'))     # unicode转换成GBK的bytes
print(bytes('你好',encoding='utf-8'))   # unicode转换成utf-8的bytes

 

b_array = bytearray('你好',encoding='utf-8')
print(b_array)  # bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
print(b_array[0])  #228

print(ord('好'))  # 22909 字符按照unicode转数字
print(ord('1'))    # 49
print(chr(97))     # a  数字按照unicode转字符

print(ascii('好'))  # '\u597d'
print(ascii('1'))   # '1'

name = 'egg'
print('你好%r'%name)  # 你好'egg'
print(repr('1'))  # '1'  用于%r格式化输出
print(repr(1))      # 1

数据集合（3）：    字典（1）-- dict         集合（2）-- set、frozenset

相关内置函数（8）： len、enumerate、all、any、zip、filter、map、sorted

# 判断是否有bool值为False的值
print(all(['a','',123]))  # False
print(all(['a',123]))      # True
print(all([0,123]))        # False

# 判断是否有bool值为True的值
print(any(['',True,0,[]]))   # True

#返回一个迭代器
l = [1,2,3,4,5]
l2 = ['a','b','c','d']
l3 = ('*','**',[1,2])
d = {'k1':1,'k2':2}
for i in zip(l,l2,l3,d):
    print(i)
# (1, 'a', '*', 'k2')
# (2, 'b', '**', 'k1')

 

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

# 例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：
def is_odd(x):
    return x % 2 == 1
ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
# for i in ret:
#     print(i)
print(list(ret))  # [1, 7, 9, 17]

# 利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：
def is_not_empty(s):
    return s and len(s.strip()) > 0
ret = filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])
print(list(ret))   # ['test', 'str', 'END']

# 注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。
# 当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下：
a = ' 123'
a.strip()
print(a)  # '123'

# 请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：
from math import sqrt
def func(num):
    res = sqrt(num)
    return res % 1 == 0
ret = filter(func,range(1,101))
# for i in ret:
#     print(i)
print(list(ret))  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 

 

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

ret = map(abs,[1,-4,6,-8])
# for i in ret:
#     print(i)
print(list(ret))  # [1, 4, 6, 8]

# 有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理。
L = [1,2,3,4,]
def pow2(x):
    return x*x

# filter 执行了filter之后的结果集合 <= 执行之前的个数
        # filter只管筛选，不会改变原来的值
# map 执行前后元素个数不变
        # 值可能发生改变

对List、Dict进行排序，Python提供了两个方法
对给定的List L进行排序，
方法1.用List的成员函数sort进行排序，在本地进行排序，不返回副本
方法2.用built-in函数sorted进行排序（从2.4开始），返回副本，原始输入不变

l = [1,-4,6,5,-10]
l.sort(key = abs)   # 在原列表的基础上进行排序
print(l)   # [1, -4, 5, 6, -10]

#列表按照其中每一个值的绝对值排序
l = [1,-4,6,5,-10]
print(sorted(l,key=abs))      # [1, -4, 5, 6, -10]生成了一个新列表 不改变原列表 占内存
print(l)  # [1, -4, 6, 5, -10]

# 列表按照每一个元素的len排序
l = ['   ',[1,2],'hello world']
new_l = sorted(l,key=len)
print(new_l)   # [[1, 2], '   ', 'hello world']

 

匿名函数：

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

def calc(n):
    return n ** n
print(calc(3))

# 换成匿名函数
calc = lambda n: n ** n
print(calc(3))

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

dic={'k1':10,'k2':100,'k3':30}
def func(key):
    return dic[key]
print(max(dic,key=func))   # k2  根据返回值判断最大值，返回值最大的那个参数是结果
print(max(dic,key=lambda key:dic[key]))  # k2

def func(x):
    return x**2
ret = map(func,[-1,2,-3,4])
for i in ret:
    print(i)

ret = map(lambda x:x**2,[-1,2,-3,4])
print(list(ret))  #  [1, 4, 9, 16]

def func(x):
    return x>10

res = filter(func,[5,8,11,9,15])
for i in res:
    print(i)   #[11,15]

min max filter map sorted —— 这五个函数都有key,都可以和lambda组合在一起