<!DOCTYPE html>
内置函数
内置函数
python启动，就已经可以使用的方法
- abs(x)取绝对值
- all(iterable)如果可迭代对象里的元素都为真（0或False为假），则返回True，否则返回False
- any(iterable)若果可迭代对象里的元素有一个为真，则返回True，否则返回False,可迭代对象为空也为False
ascii(object)将对象变成字符串形式，type类型为str
a=ascii([1,2,"一二三四五六七"])
print(type(a),[a])#输出<class 'str'> ["[1, 2, '\u4e00\u4e8c\u4e09\u56db\u4e94\u516d\u4e03']"]- bin(x)将10进制数字转成二进制
- bool([x])判断真假
bytearray([source[, encoding[, errors]]])字符串不可以修改，二进制的字符是可以修改的
a=bytes('abcde',encoding='utf-8')
b=bytearray('abcde',encoding='utf-8')
print(b[1])
b[1]=200
print(b)#输出98 bytearray(b'a\xc8cde')
bytes([source[,encoding[,errors]]])把字符串转换成字节
b=bytes('12345',encoding='utf-8')
b #输出b'12345'
b[0] #输出49
b[0]=97#报错，不可以修改里面的值- callable(object)判断一个对象是否可以被调用，函数，类。其余，列表，字典等数据类型全为False
chr(i) 通过ascii的值，找到对应的ascii的值
chr(49)#输出'1'- ord(c) 根据字符找到对应的ascii值
- classmethod(function)类方法，后面会讲，现在没学类
compile(source,filename,mode,flags=0,dontinherit=False,optimize=-1)用于编译一段字符串代码，
code=""" print("I'am the king of the world") """
pyo=compile(code,'','eval')
eval(py_o)#输出I'am the king of the world
complex([real[,imag]]) 返回一个复数
complex(1, 2)
(1 + 2j)#数字
complex(1)
(1 + 0j)#当做字符串处理
complex("1")
(1 + 0j)#注意：这个地方在“+”号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
complex("1+2j")#输出(1 + 2j)
- delattr(object,name）学习类时使用
dict(kwargs),dict(mappint,kwarg),dict(iterable,**kwarg)返回一个字典
dict() #第一个字典 输出{}
dict(1=2)#报错keyword can't be an expression 关键字不能是表达式
dict
dict(a=1)#输出{'a':1}
dict([('a',1)])#输出{'a':1}
dict([(1,1)])#这样也可以
dict([['a',1]])#输出{'a':1}
dir([object]) 看一个对象有哪些方法
name=[]
dir(name)#输出
['add','class','contains','delattr',
'delitem','dir','doc','eq',
'format','ge','getattribute',
'getitem','gt','hash','iadd',
'imul','init','initsubclass',
'iter','le','len','lt',
'mul','ne','new','reduce',
'reduceex','repr','reversed',
'rmul','setattr','setitem',
'sizeof','str','subclasshook',
'append','clear','copy','count','extend',
'index','insert','pop','remove','reverse',
'sort']
divmode(a,b) 结果得到一个元组，第一个是商，第二个是余数
divmod(10,3)#输出(3,1)
enumerate(iterable,start=0),获取一个列表，列表中的每一个元素都是元组，元组的第一个数是iterable的索引,第二个数是iterable的元素,enumerate方法里第一个参数为可迭代对象iterable，第二个参数为新生成的列表里的第一个元组的索引，往后一次加一
a=('j','w','l','t')
list(enumerate(a)) #输出[(0, 'j'), (1, 'w'), (2, 'l'), (3, 't')]
list(enumerate(a，2)) #输出[(2, 'j'), (3, 'w'), (4, 'l'), (5, 't')]
eval(expression, globals=None, locals=None),
- 计算字符串中有效的表达式，并返回结果
eval('pow(2,2)')#输出4
eval("2+4")#输出6 - 将字符串转成相应的对象（如list,tuple,dict和string之间的转换)
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
b = eval(a)
b#输出[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
a = "{1:'xx',2:'yy'}"
c = eval(a)
c#输出{1: 'xx', 2: 'yy'}
a = "(1,2,3,4)"
d = eval(a)
d#输出(1, 2, 3, 4) - eval这个函数有风险
eval("import('os').system('e:\12.txt')")#输出文件信息
open('信息.txt').read()#输出文件内容，如果是删除命令，则进行删除很危险的函数
使用eval怎么避免安全问题： - 自行写检查函数
- 使用ast.literal_eval
eval函数在Python中做数据类型的转换还是很有用的。它的作用就是把数据还原成它本身或者是能够转化成的数据类型。
那么eval和ast.literal_val()的区别是什么呢？
eval在做计算前并不知道需要转化的内容是不是合法的（安全的）python数据类型。只是在调用函数的时候去计算。如果被计算的内容不是合法的python类型就会抛出异常。
ast.literal则会判断需要计算的内容计算后是不是合法的python类型，如果是则进行运算，否则就不进行运算。
exec(object[,globals[,locals]])将字符串转换成表达式
s="wj say hello world!"
exec(s)#输出wj say hello world!
filter(function,iterable)通过函数function过滤条件，去获取可迭代对象iterable中你想要的数据。
def afun(n):
print("输出",n)
a=filter(afun,range(10))
for i in a:
print(i)#输出输出 0
输出 1
输出 2
输出 3
输出 4
输出 5
输出 6
输出 7
输出 8
输出 9- map(function,iterable)对可迭代函数'iterable'中的每一个元素应用‘function’方法，将结果作为list返回。
reduce(function,iterable)必须引入才能使用from functools import reduce把一组可迭代序列通过function函数操作，元素之间相加或者相乘操作
from functools import reduce
res=reduce(lambda x,y:x+y,range(10))#将x+y赋值给x，将range（10）赋值给y
res#输出45
float([x])把一个浮点类型的字符串转换为浮点类型的数据。
float(' 232.54525 ')#输出232.54525
format是格式化字符串的函数 “映射”示例 1.通过位置
'{0},{1}'.format('wj',100)#输出'wj,100'
'{},{}'.format('wj',1)#输出'wj,1'
'{1},{0},{1}'.format('wj',1)#输出'1,wj,1'字符串的format函数可以接受不限个参数，位置可以不按顺序，可以不用或者用多次
通过关键字参数
'{name},{no}'.format(name='wj',no=1)#输出'wj,1'主要是根据参数来寻找位置，跟参数的先后顺序没有关系
通过下标
p=['wj',1]
'{0[0]},{0[1]}'.format(p)#输出'wj,1'
frozenset([iterable])把集合变成一个不可变的集合,frozenset与set的却别在于没有add，update，remove等修改集合的方法
frozenset('wjwjwjwjwjjwjwjwjw')#输出frozenset({'j','w'}) frozen冰冻的，冻结的意思- getattr(object,name[,default])讲类的时候再讲
- globals()在当前作用域下,查看全局变量
hash(object)反射出一个对象的对应的hash值
hash('wj')#输出2887912120156523068- help([object])显示对象的帮助信息
hex(x)讲一个数转成16进制
hex(10)#输出'0xa'
hex(256)#输出'0x100'
id(object)返回对象的内存地址
a=100
id(a)#输出1397212720
input([prompt])输入字符串
s=input('你想输入什么')#输出你想输入什么
int(x)将其他数据类型强制转成int
int(0x100)#输出256
int('a')#报错
int('1')#输出1
isinstance(object,classinfo)判断一个对象是否是Iterable可迭代对象,首先需导入Iterable，from collections import Iterable
才能使用，列表，元组，字典，字符串都是True，整型数字是False
a=[1,2,3,4,5,6]
isinstance(a,Iterable)#输出True- issubclass(class,classinfo)判断是否是一个子类，
iter(object[,sentinel])把普通序列转成迭代器
a=[1,2,3,4,5,6]
b=iter(a)
type(b)#输出listiterable
a=(1,2,3,4,5)
b=iter(a)
type(b)#输出tupleiterator
a='abc'
b=iter(a)
type(b)#输出str_iterator
len(s)计算机序列或者字符串的长度
len('wj')#输出长度2
len([1,2,3,4,5])#输出长度5
list([ierable])把可迭代对象变成列表
a=list('abc')
type(a)#输出list
a#输出['a','b','c']
locals()打印局部变量与locals()差不多
def test():
a=1
b=2
print(locals())#打印局部变量
test()#输出{'a':1,'b':2}
max(iterable,[,key,default])返回最大值，必须是个可迭代对象
max((1,2,3,4,5,11))#输出11
max('abc')#输出c
max([1,3,4,5,2,3,11])#输出11- min(iterable,[,key,default])返回最小值，可迭代对象
- memoryview(obj)暂时不用
next(iteraor[,default])返回迭代器的下一个值，与next()相同，如果迭代最后一个数据之后没有值了，则会抛出一个StopIteration异常
In [34]: a=iter([1,2,3,4])
In [35]: next(a)
Out[35]: 1
In [36]: next(a)
Out[36]: 2
In [37]: next(a)
Out[37]: 3
In [38]: next(a)
Out[38]: 4
In [39]: next(a)
StopIteration Traceback (most recent call last)
<ipython-input-39-3f6e2eea332d> in ()
----> 1 next(a)- object对象
- oct(x)把数转成八进制
- open(file,mode='r',buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)文件操作
pow(x,y[,z])计算幂
pow(2,3)#2的3次幂,输出8- print(objects,sep='',end='\n',file=sys.stdout,flush=False)打印
- property(fget=None,fset=None,fdel=None,doc=None)到类再说
range(stop),range(start,stop[,step])生成一个迭代器
range(5)#输出range(0,5)- repr(object)把代码转成字符串对象
- reversed(seq)反转一个序列，跟表中的reversed方法一样
round(number[,ndigits])保留float数据类型几位
round(1.234567,3)#不好使会输出1.235
round(1.5421,3)#1.542
round(1.234567,2)#输出1.23- set([iterable])集合
- setattr(object,name,value)类时用
slice(stop),slice(start,stop[,step])序列的切片
a=[1,2,3,4,5]
a[slice(1,3)]#输出[2,3]
sorted(iterable[,key],[,reverse])对一个序列进行排序
sorted([5,5,23,4,52,2])#输出[2, 4, 5, 5, 23, 52]
str(object)把其他数据类型转换为字符串
str(1)#输出'1'
sum(iterable[,start])求一个列表的和
sum([1,2,3,4,5,6])#输出21- super([type[,object-or-type]])类
- tuple([iterable])#把可迭代对象转成元组
- type(object),type(name,bases,dict)查看对象数据类型
- vars([object])返回对象的所有属性
zip(iterables)zip中文意思是拉链的意思，把两个序列一一对应起来。如果a的元素比b的多,则按照元素最少的那个来
In [57]: a=['a','b','c','d','e']
In [58]: b=[1,2,3,4,5,6]
In [59]: zip(a,b)
Out[59]: <zip at 0x49b0688>
In [60]: for i in zip(a,b):
...: print(i)
...:
('a', 1)
('b', 2)
('c', 3)
('d', 4)
('e', 5)
import(name,globals=None,locals=None,fromlist=(),level=0)导入的模块是一个字符串时，用import()
import os
import('os')
扫一扫
929
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
