Python 之内置函数和匿名函数

内置函数

截止到python3.6.2，python一共为我们提供了68个内置函数。它们就是python提供可以直接拿来使用的所有函数

		Built-in Functions
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

上面就是内置函数的表，这个表的顺序是按照首字母的排列顺序来的，你会发现都混乱的堆在一起。比如，oct和bin和hex都是做进制换算的，但是却被写在了三个地方。。。这样非常不利于大家归纳和学习。我把这些函数分成了6大类

作用域相关

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

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

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

迭代器/生成器相关

range() 创建一个整数列表，一般用在 for 循环中。

# 函数语法
range(start, stop[, step])
    start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
    stop:  计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
    step:  步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

# 实例
range(10)        # 从 0 开始到 10,[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(1, 11)     # 从 1 开始到 11,[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
range(0, 30, 5)  # 步长为 5,[0, 5, 10, 15, 20, 25]
range(0, -10, -1) # 负数,[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
range(0)         # []
range(1, 0)      # []

其他

字符串类型代码的执行

eval()   # 将字符串类型的代码执行并返回结果，或者将字符串转化为元组等

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

exec()   # 将自字符串类型的代码执行，无返回值

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

code = '''
print(123)
a = 20
print(a)
'''
a = 10
exec(code,{'print':print},)  # 123 # 20
print(a)                     # 10

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

参数说明：

        source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。
        filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。
        model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为’single’。

# 流程语句使用exec
code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec(compile1)

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

# 交互语句用single
code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')
name            # 执行前name变量不存在
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    name
NameError: name 'name' is not defined
exec(compile3)  # 执行时显示交互命令，提示输入
print(name)     # 执行后name变量有值
please input your name:'pythoner'
"'pythoner'"

输入输出相关：

input()    输入

s = input("请输入内容")   # 输入的内容赋值给s变量
print(s)                 # 输入什么打印什么，数据类型是str

print()   输出

def print(self, *args, sep=' ', end='\n', file=None): 
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
    """
f = open('tmp_file','w')
print(123,456,sep=',',file = f,flush=True)

# 用 % 表示完成度
import time
for i in range(0,101,2):  
     time.sleep(0.1)
     char_num = i//2                     # 打印多少个'*'
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)   # \r 可以把光标移动到行首但不换行

数据类型相关：

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

内存相关：

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

hash(o)   

# o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错。TypeError: unhashable type: ‘list’
# hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。
# 每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。

文件操作相关

open()    # 打开一个文件，返回一个文件操作符(文件句柄),操作文件的模式有r,w,a,r+,w+,a+ 共6种，每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+),可以用encoding指定编码.

模块操作相关

import   # 导入一个模块

os = __import__('os')    # impore os 效果相同

帮助方法

在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型。输入q退出。或者直接执行help(o)，o是参数，查看和变量o有关的操作。。。

调用相关

callable(o)      # o是参数，看这个变量是不是可调用。如果o是一个函数名，就会返回True

def func():pass
print(callable(func))  # 参数是函数名，可调用，返回True
print(callable(123))   # 参数是数字，不可调用，返回False

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

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

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

基础类型相关

和数字相关

数据类型相关：

bool()        # 用于将给定参数转换为布尔类型，如果没有参数，返回 False，bool 是 int 的子类。

bool()         # False
bool(0)        # False
bool(1)        # True
bool(2)        # True
issubclass(bool, int) # bool 是 int 子类 True

int(x, base=10)      # 将一个字符串或数字转换为整型。（x-字符串或数字，base-进制数，默认十进制。）返回整型数据。

int()             # 不传入参数时，得到结果0
int(3)            # 3
int(3.6)          # 3
int('12',16)      # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制 18
int('0xa',16)     # 10

float(x)             # 函数用于将整数和字符串转换成浮点数，x — 整数或字符串，返回浮点数。

float(1)         # 1.0 
float(112)       # 112.0 
float(-123.6)    # -123.6 
float('123')     # 字符串 123.0

complex([real[, imag]])   # 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数

real — int, long, float或字符串；
imag — int, long, float；

complex(1, 2)   # (1 + 2j) 
complex(1)      # 数字 (1 + 0j)
complex("1")    # 当做字符串处理 (1 + 0j)
complex("1+2j") # (1 + 2j),注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错

进制转换：

bin(x)    # (x-int 或者 long int 数字)将一个整数 int 或者长整数 long int 转化为二进制表示，返回值为字符串

bin(10)        # '0b1010'
bin(20)        # '0b10100'

oct(x)      # (x-整数)将一个整数转换成8进制字符串。

oct(10)        # '012'
oct(20)        # '024'

hex()       # (x-10进制整数)将10进制整数转换成16进制，以字符串形式表示

hen(255)       # '0xff''
hen(-42)       # '-0x2a'

数学运算：

round(a,n)  # 对a保留n位小数

round(2.355, 2)   # 2.35

abs(x)            # 返回数字x的绝对值。

abs(-45)          # 45

divmod(a, b) # 把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a//b, a%b)。

divmod(7,2)       # (3,1)
divmod(8,2)       # (4,0)

min(iterable,key=func)  # 返回给定参数的最小值，iterable可以为序列和可迭代对象，key跟要使用的函数

max(iterable,key=func)  # 返回给定参数的最大值，iterable可以为序列和可迭代对象，key跟要使用的函数

sum(iterable[, start])      # 对可迭代对象进行求和计算，必须为可迭代对象

iterable — 可迭代对象，如：列表、元组、集合。
start — 指定相加的参数，如果没有设置这个值，默认为0

sum([0,1,2])      # 3  
sum((2, 3, 4), 1) # 元组计算总和后再加，1结果10

pow(x,y,[,z])       # 返回 xy（x的y次方）的值，如果有z，则返回xy（x的y次方）%z

import math       # 导入 math 模块
print("math.pow(100, 2)") # 10000.0

和数据结构相关

列表和元组相关的

list(tup)       # (tup要转化为列表的元组) 用于将元组转换为列表

tuple(list)    # (list要转化为元组的列表) 用于将元组转换为列表

字符串相关的

bytearry，memoryview，ord，chr，ascii暂不介绍

str(x)          # 将对象x转化为字符串

bytes(s,encoding=’utf-8′) # 返回一个新的 bytes 对象

repr()           # 将对象转化为供解释器读取的形式。不会去除引号

s = 'RUNOOB'
print(repr(s))    # "'RUNOOB'"

format()       # 格式化输出，函数功能将一个数值进行格式化显示。 如果参数format_spec未提供，则和调用str(value)效果相同，转换成字符串格式化。

format(3.1415936)     # '3.1415936'
str(3.1415926)        # '3.1415926'

对于不同的类型，参数format_spec可提供的值都不一样

# 字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('test', '<20'))  # test                
print(format('test', '>20'))  #                 test
print(format('test', '^20'))  #         test        

# 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
format(3,'b')   # 转换成二进制  '11'
format(97,'c')  # 转换unicode成字符  'a'
format(11,'d')  # 转换成10进制  '11'
format(11,'o')  # 转换成8进制  '13'
format(11,'x')  # 转换成16进制 小写字母表示  'b'
format(11,'X')  # 转换成16进制 大写字母表示  'B'
format(11,'n')  # 和d一样  '11'
format(11)      # 默认和d一样  '11'
# 浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
format(314159267,'e')        # 科学计数法，默认保留6位小数 '3.141593e+08'
format(314159267,'0.2e')     # 科学计数法，指定保留2位小数 '3.14e+08'
format(314159267,'0.2E')     # 科学计数法，指定保留2位小数，采用大写E表示 '3.14E+08'
format(314159267,'f')        # 小数点计数法，默认保留6位小数 '314159267.000000'
format(3.14159267000,'f')    # 小数点计数法，默认保留6位小数 '3.141593'
format(3.14159267000,'0.8f') # 小数点计数法，指定保留8位小数 '3.14159267'
format(3.14159267000,'0.10f')# 小数点计数法，指定保留10位小数 '3.1415926700'
format(3.14e+1000000,'F')    # 小数点计数法，无穷大转换成大小字母 'INF'

# g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
>>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
'3e-05'
>>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
'3.1e-05'
>>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
'3.14e-05'
>>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
'3.14E-05'
>>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
'3'
>>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
'3.1'
>>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
'3.14'
>>> format(0.00003141566,'.1n') #和g相同
'3e-05'
>>> format(0.00003141566,'.3n') #和g相同
'3.14e-05'
>>> format(0.00003141566) #和g相同
'3.141566e-05'

序列

reversed(seq)    # 返回一个反转的迭代器。(seq 要转换的序列,可以是 tuple, string, list 或 range)

l = (1,2,23,213,5612,342,43)
print(reversed(l))          # <reversed object at 0x00000189156A9860>
print(list(reversed(l)))    # [43, 342, 5612, 213, 23, 2, 1]

slice()                # 实现切片对象，主要用在切片操作函数里的参数传递,不常用

sli = slice(1,5,2)
print(l[sli])

字典和集合：

dict()    # 函数用于创建一个字典。

set()     # 函数用于创建一个集合。

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

相关内置函数

len，sorted，enumerate，all，any，zip，filter，map

len(x)                 # 返回x长度

any(iterable)     # 用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE。Python 2.5 以上版本可用。

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

sorted(iterable, key=None, reverse=False)

对List、Dict进行排序，Python提供了两个方法
       用List的成员函数sort进行排序，在本地进行排序，不返回副本，修改原始数据
       用built-in函数sorted进行排序（从2.4开始），返回副本，原始数据不变

参数：

        iterable：是可迭代类型;
        key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序;
        reverse：排序规则. reverse = True  降序 或者 reverse = False 升序，有默认值。

返回值：有序列表

# 列表按照其中每一个值的绝对值排序
l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l1)          # [1, 3, 5, -2, -4, -6]
print(l2)          # [1, -2, 3, -4, 5, -6]

# 列表按照每一个元素的len排序
l = [[1,2],[3,4,5,6],(7,),'123']
print(sorted(l,key=len))   # [(7,), [1, 2], '123', [3, 4, 5, 6]]

enumerate(sequence, [start=0])  # 用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

参数：

    sequence — 一个序列、迭代器或其他支持迭代对象。
    start — 下标起始位置。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))    # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

zip(iterable,…)     # (zip,翻译拉链)用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

list1 = [1,2]
list2 = ['a','b','c']
list3 = ['A','B','C','D']
print(zip(list1,list2,list3))          # <zip object at 0x103abc288>
print(list(zip(list1,list2,list3)))    # [(1,'a','A'),(2,'b','B')]

注：Python 2.x 返回列表。
Python 3.x 返回迭代器。需用list（）调用

filter(key=func,iterables)     # 用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。filter接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

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

利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：

def is_not_empty(s):
    return s and len(s.strip()) > 0
print(list(filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])))  #['test', 'str', 'END']

注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。

当rm为空时，默认删除空白符（包括’\n’, ‘\r’, ‘\t’, ‘ ‘)，如下：

a = ' 123'
a.strip()    # '123'
a = '\t\t123\r\n'
a.strip()    # '123'

请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
print(list(filter(is_sqr, range(1, 101))))       # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

map(key=func,iterables,….)    # map函数应用于每一个可迭代的项，把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，

# L = [1,2,3,4,]，将f(x)=x^2作用于list上
L = [1,2,3,4,] 
def pow2(x): 
    return x*x 

list(map(pow2,L))     # [1, 4, 9, 16]

注：Python 2.x 返回列表。
Python 3.x 返回迭代器。需用list（）调用

匿名函数

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

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

上面是我们对calc这个匿名函数的分析，下面给出了一个关于匿名函数格式的说明

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

我们可以看出，匿名函数并不是真的不能有名字。匿名函数的调用和正常的调用也没有什么分别。 就是 函数名(参数) 就可以了～～～
上面是匿名函数的函数用法。除此之外，匿名函数也不是浪得虚名，它真的可以匿名。在和其他功能函数合作的时候

l = [3,2,100,999,213,1111,31121,333]
print(max(l))
dic={'k1':10,'k2':100,'k3':30}
print(max(dic))
print(dic[max(dic,key=lambda k:dic[k])])

res = map(lambda x:x**2,[1,5,7,4])
for i in res:
    print(i)

输出
1
25
49
16

res = filter(lambda x:x>10,[5,8,11,9,15])
for i in res:
    print(i)

输出
11
15

现有两个元组((‘a’),(‘b’)),((‘c’),(‘d’))，请使用python中匿名函数生成列表[{‘a’:’c’},{‘b’:’d’}]

# 答案一
test = lambda t1,t2 :[{i:j} for i,j in zip(t1,t2)]
print(test(t1,t2))
# 答案二
print(list(map(lambda t:{t[0]:t[1]},zip(t1,t2))))
# 还可以这样写
print([{i:j} for i,j in zip(t1,t2)])

注：max(), min(), map(), filter() , sort() 中都有key，都可以和匿名函数结合使用

重点掌握：

其他：input,print,type,hash,open,import,dir
str类型代码执行：eval,exec
数字：bool,int,float,abs,divmod,min,max,sum,round,pow
序列——列表和元组相关的：list和tuple
序列——字符串相关的：str，bytes，repr
序列：reversed，slice
数据集合——字典和集合：dict，set，frozenset
数据集合：len，sorted，enumerate，zip，filter，map