Python 内置函数和匿名函数

一、内置函数

　　内置函数就是python提供给你直接可以拿来使用的所有函数。截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。这次将介绍Python常用内置函数,本文罗列了数学相关 、功能相关、类型转换、字符串处理、序列处理函数等常用内置函数。

1、迭代器、生成器相关（3个）

range

next

iter

 

range：根据传入的参数创建一个新的range对象

根据需要生成一个指定范围的数字，可以提供你需要的控制来迭代指定的次数

        用于创建包含连续算术值的列表(list)。常用于for循环。参数必须是普通整数。

        参数step默认值为1，参数start的默认值为0。

        全参数调用该函数将返回一个普通整数列表。

        step 可以是正整数或者负整数。不可以为0，否则将触发ValueError异常。

 a = range(10)
 b = range(1,10)
c = range(1,10,3)
 list(a),list(b),list(c) # 分别输出a,b,c的元素

# ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])

iter：根据传入的参数创建一个新的可迭代对象

>>> a = iter('abcd') #字符串序列
>>> a
<str_iterator object at 0x03FB4FB0>
>>> next(a)
'a'
>>> next(a)
'b'
>>> next(a)
'c'
>>> next(a)
'd'
>>> next(a)
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    next(a)
StopIteration

next()：返回一个可迭代数据结构（如列表）中的下一项

2、和数字相关（14个）

数据类型	bool（）、int（）、float()、complex()
进制转换	bin()、oct()、hex（）
数学运算	abs（）、divmod()、round()、pow()、min()、max()、sum()

类型转换

1、int(x)
2、long(x)
3、float(x)
4、complex(x) //复数
5、str(x)
6、list(x)
7、tuple(x) //元组
8、hex(x)
9、oct(x)
10、chr(x)//返回x对应的字符，如chr(65)返回‘A'
11、ord(x)//返回字符对应的ASC码数字编号，如ord('A')返回65

abs：求数值的绝对值

>>> abs(-2)
2

divmod：返回两个数值的商和余数

print(divmod(10,3)) 
#(3, 1)

max：返回可迭代对象中的元素中的最大值或者所有参数的最大值

>>> max(1,2,3) # 传入3个参数 取3个中较大者
3
>>> max('1234') # 传入1个可迭代对象，取其最大元素值
'4'
>>> max(-1,0) # 数值默认去数值较大者
0
>>> max(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取较大者
-1

min：返回可迭代对象中的元素中的最小值或者所有参数的最小值

>>> min(1,2,3) # 传入3个参数 取3个中较小者
1
>>> min('1234') # 传入1个可迭代对象，取其最小元素值
'1'
>>> min(-1,-2) # 数值默认去数值较小者
-2
>>> min(-1,-2,key = abs)  # 传入了求绝对值函数，则参数都会进行求绝对值后再取较小者
-1

pow：返回两个数值的幂运算值或其与指定整数的模值

print(pow(2,3))
#8

print(pow(2,3,5))   #2**3 对5取余
#3
print(pow(2,3)%5)    #2**3 对5取余
#3

round：对浮点数进行四舍五入求值

>>> round(1.1314926,1)
1.1
>>> round(1.1314926,5)
1.13149

sum：对元素类型是数值的可迭代对象中的每个元素求和

# 传入可迭代对象
>>> sum((1,2,3,4))
10
# 元素类型必须是数值型
>>> sum((1.5,2.5,3.5,4.5))
12.0
>>> sum((1,2,3,4),-10)
0

3、和数据结构相关：

序列（13）：列表和元组（2）

tuple：根据传入的参数创建一个新的元组

>>> tuple() #不传入参数，创建空元组
()
>>> tuple('121') #传入可迭代对象。使用其元素创建新的元组
('1', '2', '1')

list：根据传入的参数创建一个新的列表

>>>list() # 不传入参数，创建空列表
[] 
>>> list('abcd') # 传入可迭代对象，使用其元素创建新的列表
['a', 'b', 'c', 'd']

x相关内置函数（2）

reversed：反转序列生成新的可迭代对象

>>> a = reversed(range(10)) # 传入range对象
>>> a # 类型变成迭代器
<range_iterator object at 0x035634E8>
>>> list(a)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

slice：根据传入的参数创建一个新的切片对象

>>> c1 = slice(5) # 定义c1
>>> c1
slice(None, 5, None)
>>> c2 = slice(2,5) # 定义c2
>>> c2
slice(2, 5, None)
>>> c3 = slice(1,10,3) # 定义c3
>>> c3
slice(1, 10, 3)

字符串（9）

str：返回一个对象的字符串表现形式(给用户)

>>> str()
''
>>> str(None)
'None'
>>> str('abc')
'abc'
>>> str(123)
'123'

format：格式化显示值

print(format('test', '<40'))#以40个字符左对齐
print(format('test', '>40'))#右对齐
print(format('test', '^40'))#居中

#字符串可以提供的参数 's' None
>>> format('some string','s')
'some string'
>>> format('some string')
'some string'

#整形数值可以提供的参数有 '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'

bytearray：根据传入的参数创建一个新的字节数组

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

memoryview：根据传入的参数创建一个新的内存查看对象

bytes：根据传入的参数创建一个新的不可变字节数组

#bytes 转换成bytes类型
# 我拿到的是gbk编码的，我想转成utf-8编码
 print(bytes('你好',encoding='GBK'))     # unicode转换成GBK的bytes
 print(bytes('你好',encoding='utf-8'))   # unicode转换成utf-8的bytes

ord：返回Unicode字符对应的整数

print(ord('好'))     #22909
print(ord('1'))     #49
print(chr(97))      #a

chr：返回整数所对应的Unicode字符

repe：

print(ascii('好'))
print(ascii('1'))
name = 'egg'
print('你好%r'%name)
print(repr('1'))
print(repr(1))

#打印内容
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
228
'\u597d'
'1'
你好'egg'
'1'
1

 

数据集合（3）

字典：

dict：根据传入的参数创建一个新的字典

>>> dict() # 不传入任何参数时，返回空字典。
{}
>>> dict(a = 1,b = 2) #  可以传入键值对创建字典。
{'b': 2, 'a': 1}
>>> dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。
{'b': 2, 'a': 1}
>>> dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。
{'b': 2, 'a': 1}

集合：

set：根据传入的参数创建一个新的集合

>>>set() # 不传入参数，创建空集合
set()
>>> a = set(range(10)) # 传入可迭代对象，创建集合
>>> a
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

frozenset：根据传入的参数创建一个新的不可变集合

>>> a = frozenset(range(10))
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

相关内置函数（8）

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

len():计算长度、

enumerate：根据可迭代对象创建枚举对象

 

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
for k,v in enumerate(seasons):
    print(k,v)
#结果：
#0 Spring
# 1 Summer
# 2 Fall
# 3 Winter

 

 

 

all():判断可迭代对象的元素是否都为True值的元素

 

print(all(['a','',123]))
print(all(['a',123]))
print(all([0,123]))

#结果：
False
True
False

 

any():判断可迭代对象的元素是否有为True值的元素

print(any(['',True,0,[]]))
#True

 

 

>>> any([0,1,2]) #列表元素有一个为True，则返回True
True
>>> any([0,0]) #列表元素全部为False，则返回False
False
>>> any([]) #空列表
False
>>> any({}) #空字典
False

 

 

 

sorted：对可迭代对象进行排序，返回一个新的列表

l = [1,-4,6,5,-10]
l.sort(key = abs)   # 在原列表的基础上进行排序
print(l)
#
print(sorted(l,key=abs,reverse=True))      # 生成了一个新列表 不改变原列表 占内存
print(l)

l = ['   ',[1,2],'hello world']
new_l = sorted(l,key=len)
print(new_l)

>>> a = ['a','b','d','c','B','A']
>>> a
['a', 'b', 'd', 'c', 'B', 'A']

>>> sorted(a) # 默认按字符ascii码排序
['A', 'B', 'a', 'b', 'c', 'd']

>>> sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样
['a', 'A', 'b', 'B', 'c', 'd']

map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

对[1,-4,6,-8]取绝对值
ret = map(abs,[1,-4,6,-8])
print(ret)
for i in ret:
    print(i)

filter：使用指定方法过滤可迭代对象的元素

过滤偶数：
def is_odd(x):
    return x % 2 == 1
ret = filter(is_odd, [1,  6, 7, 12, 17])
for i in ret:
    print(i)

过滤None和空字符串
def is_str(s):
    return s and str(s).strip()
 ret = filter(is_str, [1, 'hello','','  ',None,[], 6, 7, 'world', 12, 17])
for i in ret:
    print(i)

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

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

zip（）：拉链函数

Zip中有字典的时候，只能取字典的key

t1=(('a'),('b'))
t2=(('c'),('d'))
for i in zip(t1,t2):
    print(i)
#
('a', 'c')
('b', 'd')

4、作用域相关

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

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

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

5、其他

字符串代码的执行：

eval：执行动态表达式求值

>>> eval('1+2+3+4')
10

exec：执行动态语句块

>>> exec('a=1+2') #执行语句
>>> a
3

exec('print(123)')
eval('print(123)')
print(eval('1+2+3+4'))   # 有返回值
print(exec('1+2+3+4'))   #没有返回值
#结果：
#123
# 123
# 10
# None

exec和eval都可以执行 字符串类型的代码
eval有返回值  —— 有结果的简单计算
exec没有返回值   —— 简单流程控制
eval只能用在你明确知道你要执行的代码是什么

compile：将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值

code2 = '1 + 2 + 3 + 4'
compile2 = compile(code2,'','eval')
print(eval(compile2))   #10

code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')
exec(compile3) #执行时显示交互命令，提示输入
print(name)
# name #执行后name变量有值
# "'pythoner'

输入输出相关：

input() 输入

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

print() 输出

#print源码分析
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
    """
file关键字说明：
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 可以把光标移动到行首但不换行

print('我们的祖国是花园',end='')  #指定输出的结束符
print('我们的祖国是花园',end='')
print(1,2,3,4,5,sep='|') #指定输出多个值之间的分隔符

内存相关：id、hash

id：返回对象的唯一标识符

>>> a = 'some text'
>>> id(a)
69228568

hash：获取对象的哈希值

>>> hash('good good study')
1032709256

t = (1,2,3)
l = [1,2,3]
print(hash(t))  #可hash
print(hash(l))  #会报错

'''
结果：
TypeError: unhashable type: 'list'
'''

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

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

文件操作相关：open

f = open('file','w')
print('aaaa',file=f)
f.close()

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

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

可以用encoding指定编码.

模块相关：import（）导入模块

import time

os = __import__('os')
print(os.path.abspath('.'))

调用相关：callable

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

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

# 变量
print(callable(print))
a = 1
print(callable(a))
print(callable(globals))
def func():pass
print(callable(func))
#结果
True
False
True
True

帮助：help

help   #查看所有内置函数的使用方法
help(str) #查看str的使用方法

查看内置属性：dir

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

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

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