内置函数
截止到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]没有5step: 步长,默认为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,worldcode = '''
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