Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

05 python内置函数大全

HongLingLiu 2019-09-11 19:40:00 阅读数:48 评论数:0 点赞数:0 收藏数:0

一、数学运算

abs:返回数字的绝对值

abs(-1) #

round:保留浮点数的小数位数,默认保留整数。四舍五入。

round(1.553,1) #1.6

divmod:计算除数和被除数的结果,并返回一个包含商和余数的元组

divmod(5,2) # (2,1)

pow:求x**y次幂(当有第三参数时,x**y的结果对z取余 )

pow(2,5) #
pow(2,3,5) # 这里为3个参数,2的3次方,结果为8。用8和5做除法,取余为3,最终输出3

sum:对可迭代对象进行求和计算(可设置初始值)

# sum最多只有2个参数
sum([1,2,3,4,5]) #
sum([1,2,3,4,5],100) #
sum(1,2,3,4,5) #报错

min:返回可迭代对象的最小值(可加key,key为函数名,通过函数的规则,返回最小值)。

I. 将iterable的每一个元素当作函数的参数传给函数,字典中,元素是键

II. 按照函数的返回值进行比较大小

III. 返回的是遍历的元素x,即传入函数的参数

min([1,-2,3,-4,5]) #-4
min([1,-2,3,-4,5],key=abs) # 按照绝对值的大小,返回此序列最小值 1
min(1,2,-5,6,-3,key=lambda x:abs(x)) # 可以设置很多参数比较大小
ls=[('spring',100),('summer',18),('winter',500)]
def func(x):
return x[1]
print(min(ls,key=func)) #('summer',18)
dic = {'a': 3, 'b': 2, 'c': 1}
def func1(x):
return dic[x]
print(min(dic,key=func1)) #c
# x为dic的key,lambda的返回值(即dic的值进行比较)返回最小的值对应的键
dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x:dic[x]))

max:返回可迭代对象的最大值(可加key,key为函数名,通过函数的规则,返回最大值)。与min用法相同

 

二.类型转换

进制转化

bin:将十进制转化成二进制

bin(100) #0b1100100

oct:将十进制转化成八进制

oct(100) #0o144

hex:将十进制转化成十六进制

hex(100) #0x64

 

字符串和ASCll编码转换

ord:输入字符,找该字符在unicode编码的位置

ord('a') #97
ord('') #

chr:输入位置数字,找出相对应的字符,与ord相反

chr(97) # a
chr(20320) #

ascii:是ascii码表中的内容返回原值,不是返回\u + 他在Unicode中的位置

ascii('q') #'q'
ascii('') #'\u4f60' 转化成十进制就是 20320

 

数据类型转化相关

int:用于将字符串或数字转化成整型,用于将其他进制数转化成十进制。取整数,不会四舍五入

int(1.543) #
int('') #
int('',base=2) #

float:字符串或整数转化成浮点型

float(1) #1.0
float('') #1.0

bool:用于将给定参数转化为布尔类型

bool(123) #True

complex:用于创建一个值为 real+image*j的复数,当第一个参数为字符串时,不要设置第二个参数。

complex(1,2) #(1+2j)
complex('') #(1+0j)

str:将数据转化成字符串

str(2.3) # 转换为字符串2.3

bytes:用于不同编码之间的转化。将unicode 转为非unicode。只能编码,不能解码

编码转换,将unicode转换为utf-
方法一:
s1 = '小太阳'
s2 = s1.encode('utf-8')
print(s2) # b'\xe5\xb0\x8f\xe5\xa4\xaa\xe9\x98\xb3'
方法二:
s1 = '小太阳'
print(bytes(s1,encoding='utf-8')) # b'\xe5\xb0\x8f\xe5\xa4\xaa\xe9\x98\xb3'

list:将一个可迭代对象转化成列表(如果是字典,默认将key作为列表的元素

l1 = list((1,2,3)) # [1, 2, 3]
l2 = list({1,2,3}) # [1, 2, 3]
l3 = list({'name':'xiaoming','age':13}) # ['name', 'age']

tuple将一个可迭代对象转化成元组(如果是字典,默认将key作为元组的元素

tup1 = tuple([1,2,3]) # (1, 2, 3)
tup2 = tuple({'name':'xiaoming','age':13}) # ('name', 'age')

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:创建一个集合

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

 

其他

bytearry:返回一个新字节数组。数组中元素可变,并且每个元素的值范围: 0 <= x < 256。(很少用)

ret = bytearray('hello',encoding='utf-8')
print(ret) #bytearray(b'hello')
print(id(ret)) #1979800230744
print(ret[]) # h在ascii码中的位置
ret[] =  #将第一位改为a
print(ret) #bytearray(b'aello')
print(id(ret)) #1979800230744 id是相同的
bytearray('中文','utf-8') # bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

memoryview:返回对象obj的内存查看对象。所谓内存查看对象,就是对象符合缓冲区协议的对象,为了给别的代码使用缓冲区里的数据,而不必拷贝,就可以直接使用。(没啥用)

ret = memoryview(bytes('你好',encoding='utf-8'))
print(ret) #<memory at 0x000001DA89DDB408>
print(len(ret)) # 
print(bytes(ret[:]).decode('utf-8')) #你
print(bytes(ret[:]).decode('utf-8')) #好
ret = memoryview(b'abcefg')
print(ret[]) # 
print(ret[-]) # 

frozenset:返回一个冻集合(新的不可变集合),冻结后的集合不能再添加或删除任何元素

a = frozenset(range())
print(a) # frozenset({, , , , , , , , , })

enumerate:枚举,返回一个枚举对象。 (0, seq[0]), (1, seq[1]), (2, seq[2])

li = ['spring', 'summer', 'autumn', 'winter']
print(enumerate(li)) # <enumerate object at 0x02E3D558>
print('__iter__' in dir(enumerate(li))) # True
print('__next__' in dir(enumerate(li))) # True

enumerate是一个迭代器, 返回结果为:列表元素的索引以及对应的值

li = ['spring', 'summer', 'autumn', 'winter']
for i in enumerate(li):
print(i)

执行输出:
(0, 'spring')
(1, 'summer')
(2, 'autumn')
(3, 'winter')

li = ['spring', 'summer', 'autumn', 'winter']
for k,v in enumerate(li):
print(k,v)

执行输出:

0 spring

1 summer

2 autumn

3 winter

enumerate的第2个参数,表示从多少开始。默认从1开始

li = ['spring', 'summer', 'autumn', 'winter']
for k,v in enumerate(li,):
print(k,v)

执行输出:
10 spring
11 summer
12 autumn
13 winter

li = ['spring', 'summer', 'autumn', 'winter']
print(list(enumerate(li))) # [(, 'spring'), (, 'summer'), (, 'autumn'), (, 'winter')]
print(list(enumerate(li, start=))) #指定起始值,[(, 'spring'), (, 'summer'), (, 'autumn'), (, 'winter')]

range:根据传入的参数创建一个新的range对象,一般用在for循环中

a = range()
b = range(,)
c = range(,,)
print(a,list(a)) # range(, ) [, , , , , , , , , ]
print(b,list(b)) # range(, ) [, , , , , , , , ]
print(c,list(c)) # range(, , ) [, , ]

三、序列操作

slice:构建一个切片对象,用于列表的切片

l1 = [i for i in range()]
l2 = l1[::]
print(l2) #[, , ],按照普通切片方法

reversed:将一个序列反转,并返回此反转序列的迭代器,字典不能反转。

l1 = [,,,]
print(reversed(l1)) #<list_reverseiterator object at 0x0000026B679FA4E0>
for i in reversed(l1):
print(i) #  
s = 'asdf'
for i in reversed(s):
print(i) # f d s a
dic = {'name':'xiaoming','age':}
for i in reversed(dic):
print(i) #字典不能反转 TypeError: 'dict' object is not reversible

Sorted:对可迭代对象进行排序,只能列表使用. 可加key,key为函数名,通过函数的规则进行  排序。默认从小到大,加入reverse = True时按照从大到小。与 li.sort()相比,原列表不发生改变

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

key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序

reverse :是否是倒叙,True 倒叙 False 正序

默认升序
li = [,,,,,,]
print(sorted(li)) # [, , , , , , ]
按照绝对值排序
li = [,-,-,,,-,]
print(sorted(li,reverse=True,key=abs)) # [, -, , -, , -, ]
原列表改变
l1 = [,,,,]
l1.sort()
print(l1) #[, , , , ]
原列表不发生改变
l2 = [,,,,,]
print(sorted(l2)) #[, , , , , ]
print(l2) #[, , , , , ]
l3 = [(,),(,),(,),(,)]
def func1(x):
return x[]
print(sorted(l3,key=func1)) #[(, ), (, ), (, ), (, )]
字典使用sorted排序, 字典排序返回的就是排序后的key
dic = {:'a',:'c',:'b'}
print(sorted(dic)) # [,,]

和函数组合使用
定义一个列表,然后根据一元素的长度排序
lst = ['天龙八部','西游记','红楼梦','三国演义']
def func(s):
return len(s)
print(sorted(lst,key=func)) # ['西游记', '红楼梦', '天龙八部', '三国演义']
和lambda组合使用
lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst,key=lambda s:len(s))) # ['西游记', '红楼梦', '天龙八部', '三国演义']
lst = [{'id':,'name':'alex','age':},
{'id':,'name':'wusir','age':},
{'id':,'name':'taibai','age':},]
# 按照年龄对学生信息进行排序
print(sorted(lst,key=lambda e:e['age']))
结果:[{'id': , 'name': 'taibai', 'age': }, {'id': , 'name': 'wusir', 'age': }, {'id': , 'name': 'alex', 'age': }]

all:可迭代对象中,全是True才是True

print(all([,,,])) #False
print(all([,,,])) #True

any:可迭代对象中,有一个是True就是True

print(any([,[],{},,()])) #True

zip:将可迭代对象作为参数,将对象中的元素打包成一个元组,返回由这些元组组成的迭代器。

        如果可迭代对象中元素的数量不一致,则返回元组个与最短的对象相同。zip结果取决于最短的一个,返回的数据是元组。

        拉链方法:将多个iter纵向组成一个个的元组

l = [,,]
tu = ('china','america','japan','korean')
dic = {'name':,'age':,'hobby':}
for i in zip(l,tu,dic):
print(i)
输出结果:
(, 'china', 'name')
(, 'america', 'age')
(, 'japan', 'hobby')
lst1 = [,,]
lst2 = ['a','b','c','d']
lst3 = (,,,,)
for i in zip(lst1,lst2,lst3):
print(i)
​
输出结果:
(, 'a', )
(, 'b', )
(, 'c', )

filter:通过函数过滤可迭代对象,函数中return的是一个条件,返回一个迭代器。相当于生成器表达 式的筛选模式。类似于[i for i in range(10) if i > 3]

filter(function,iterable)

function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据

iterable:可迭代对象

l = [i for i in range()]
def func1(x):
return x>
for i in filter(func1,l):
print(i)
lst = [{'id': , 'name': 'Joe', 'age': },
{'id': , 'name': 'Paul', 'age': },
{'id': , 'name': 'May', 'age': }, ]
ls = filter(lambda e: e['age'] > , lst)
print(list(ls)) # [{'id': , 'name': 'Joe', 'age': }, {'id': , 'name': 'Paul', 'age': }]
取列表中的偶数
def func(x):
return x % == 
ret = filter(func,[,,,,,,])
print(ret)
for i in ret:
print(i)
执行输出:
<filter object at 0x0000021325A4B6D8>
使用列表生成式完成
li = [i for i in [,,,,,,] if i % == ]
print(li) 

map:根据提供的函数对指定的序列做映射,返回一个迭代器,相当于生成器表达式中的循环模式

map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别执行function

计算列表各个元素的平方
def square(x):
return x ** 
ret = map(square,[,,,,])
for i in ret:
print(i)
执行输出:

改写成lambda
lst = [,,,,]
print(list(map(lambda s:s*s,lst)))
map也是迭代器
l = [i for i in range()]
def func(x):
return x**
for i in map(func,l):
print(i) 
计算两个列表中相同位置的数据的和
lst1 = [, , , , ]
lst2 = [, , , , ]
print(list(map(lambda x, y: x+y, lst1, lst2))) # [, , , , ]

四、对象操作

hash:获取一个对象(可哈希对象:int,str,Bool,tuple)的哈希值

print(hash('')) #6154395912723147770
print(hash()) #,数字不变

id:获取对象的内存地址

print(id()) #1785819168

dir:查看对象或者当前作用域内的属性列表。函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。

print(dir(list)) # ['__add__', '__class__', '__contains__'...]
print(dir()) # ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
print(dir('hello')) # ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__ne...........
print('__iter__' in dir(iter)) # False

help:返回对象的帮助信息,主要用于查看函数或模块用途的详细说明。

help(abs)
help(str)

len:返回一个对象中元素的个数

print(len('abcd')) #  字符串
print(len(bytes('abcd','utf-8'))) #  字节数组
print(len((,,,))) #  元组
print(len([,,,])) #  列表
print(len(range(,))) #  range对象
print(len({'a':,'b':,'c':,'d':})) #  字典
print(len({'a','b','c','d'})) #  集合
print(len(frozenset('abcd'))) # 不可变集合

type:返回对象的类型,或者根据传入的参数创建一个新的类型

type() # <class 'int'>

五、反射操作

hasattr(obj, attr): 用于检查obj是否有一个名为attr的值的属性,返回一个布尔值。

getattr(obj, attr): 返回obj中名为attr值的属性的值

setattr(obj, attr, val): 给obj的attr属性赋值为val。例如attr为'bar',则相当于obj.bar = val

delattr(obj, name)该函数删除该obj的一个由string指定的属性。delattr(x, 'foobar')=del x.foobar

class Test:
f = '类的静态变量'
def __init__(self,name,age):
self.name=name
self.age=age
def say_hi(self):
print('hi,%s'%self.name)
obj=Test('Joe',)
#检测是否含有某属性
print(hasattr(obj,'name')) # True
print(hasattr(obj,'say_hi')) # True

#获取属性
n=getattr(obj,'name')
func=getattr(obj,'say_hi')
print(n,func) # Joe <bound method Test.say_hi of <__main__.Test object at 0x0000000009F69128>>
#设置属性
setattr(obj,'self.hobby','paiting')
setattr(obj,'show_hobby',lambda self:self.name+' like paiting')
print(obj.__dict__) # {'name': 'Joe', 'age': , 'self.hobby': 'paiting', 'show_hobby': <function <lambda> at 0x00000000029947B8>}
print(obj.show_hobby(obj)) # Joe like paiting
#删除属性
delattr(obj,'age')
delattr(obj,'show_hobby')
print(obj.__dict__) # {'name': 'Joe', 'self.hobby': 'paiting'}

isinstance(a,b):判断a是否是b类(或者b类的基类)实例化的对象

issubclass(a,b): 判断a类是否是b类(或者b的基类)的派生类

class A:
pass
class B(A):
pass
class C(B):
pass
obj = B()
print(isinstance(obj,B)) # True
print(isinstance(obj,A)) # True
print(issubclass(B,A)) # True
print(issubclass(C,A)) # True

callable:检测对象是否可被调用。如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。callable其实就是判断一个对象是否是函数,是就返回True,其他类型直接返回False

name = 'summer'
print(callable(name)) #False,不可调用
def func1():
pass
print(callable(func1)) #True,可以调用
class A: # 定义类B
def __call__(self):
print('instances are callable now.')
print(callable(A)) # 类A是可调用对象,True
a = A() # 实例
print(a) # <__main__.A object at 0x02A6C490>
a() # 调用实例a成功,instances are callable now.

 

六、装饰器

property:标示属性的装饰器。property是一个装饰器函数,可以将一个方法伪装成属性,调用的时候可以不用加()

例如:BMI指数

class Person(object):
def __init__(self,name,weight,height):
self.name = name
self.__weight = weight
self.__height = height
@property
def bmi(self):
return self.__weight / self.__height **

classmethod:标示方法为类方法的装饰器。必须通过类的调用,而且此方法的意义:就是对类里面的变量或者方法进行修改添加

class Goods:
__discount = 0.8 # 折扣
def __init__(self,name,origin_price):
self.name = name
self.__price = origin_price # 原价
@property
def price(self): # 价格
return self.__price * Goods.__discount
@classmethod
def change_discount(self,new_discount):
# 类方法 可以直接被类调用 不需要默认传对象参数 只需要传一个类参数就可以了
Goods.__discount = new_discount
Goods.change_discount() # 不依赖对象的方法 就应该定义成类方法 类方法可以任意的操作类中的静态变量
apple = Goods('apple',)
banana = Goods('banana',)
print(apple.price) # 
print(banana.price) # 

staticmethod:标示方法为静态方法的装饰器。不依赖类以及对象。 

class Student:
def __init__(self,name):pass
@staticmethod
def login(a): # login就是一个类中的静态方法 静态方法没有默认参数 就当成普通的函数使用即可
user = input('user :')
if user == 'alex':
print('success')
else:
print('faild')
Student.login() 

七、变量作用域相关

globals:返回一个字典,包含全部的全局变量

locals:返回一个字典,包含当前作用域的全部变量

vars:返回当前作用域内的局部变量和其值组成的字典,或者返回对象的属性列表

class Test:
f = '类的静态变量'
def __init__(self,name,age):
self.name=name
self.age=age
def variation(self):
hobby = 'paiting'
print(globals())
print(locals())
obj = Test('Joe', )
obj.variation()
print(obj.__dict__) # {'name': 'Joe', 'age': }
print(vars(obj)) # {'name': 'Joe', 'age': }

globals()的输出:

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DEC208>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/Python/test.py', '__cached__': None, 'Test': <class '__main__.Test'>, 'obj': <__main__.Test object at 0x0000000001F50A20>}

locals()的输出:

{'hobby': 'paiting', 'self': <__main__.Test object at 0x0000000001F50A20>}

八、字符串类型代码的执行

eval:执行字符串类型的代码,并返回最终结果。相当于拨开字符串2边的引号,执行里面的代码

print(eval('3+4')) # 
ret = eval('{"name":"summer"}')
print(ret) # {'name': 'summer'}

exec:执行字符串类型的代码,不返回结果

print(exec('3+4')) # None
ret1 = '''
li = [,,]
for i in li:
print(i)
'''
print(exec(ret1))
执行输出:


None

val和exec 功能是类似的, 区别:

eval有返回值,exec没有没有值

exec适用于有流程控制的,比如for循环。eval只能做一些简单的。

compile:将字符串类型的代码编译,代码对象能够通过exec语句执行或eval()求值。(了解即可)

code1 = 'for i in range(0,3): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1)
执行输出:

repr:返回一个对象的string形式(原形毕露)。

#%r 原封不动的写出来
name = 'Joe'
print('我叫%r' % name) # 我叫'Joe'
print(repr('{"name":"Joe"}')) # '{"name":"Joe"}'
print('{"name":"Joe"}') # {"name":"Joe"}

 

九、输入输出相关

input:函数接收一个标准输入数据,返回str类型

print(self,*args,sep=' ',end='\n',file=None, flush=False)

sep:打印多个内容的分隔符,默认是空格

end:默认是换行符

file:默认是None,默认输出到屏幕,设置文件句柄可输出到文件

flush: 立即把内容输出到流文件,不作缓存

sep默认是用空格拼接
print(, , ) # 
sep 指定分隔符 |
print(, , , sep = '|') # ||
end结尾符
print(,end=' ')
print() # 
print(,end='')
print(,) #333666
print(,end='**')
print(,) # **

file写入文件

with open('log.txt',encoding='utf-8',mode='w') as f1:
print('',file=f1) # 执行程序,查看log.txt文件内容为: 
f = open('t1',encoding='utf-8',mode='w')
print(,'',file=f) # 执行程序,查看t1文件内容为: 
f = open('tmp_file','w')
print(,,sep=',',file = f,flush=True)

打印进度条

import time
for i in range(,,):
time.sleep(0.1)
char_num = i//2 #打印多少个'*'
per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == else '\r%s%% : %s'%(i,'*'*char_num)
print(per_str,end='', flush=True)

十、迭代器、生成器相关

iter:函数用来生成迭代器(将一个可迭代对象,生成迭代器)

from collections import Iterable
from collections import Iterator
l = [,,]
print(isinstance(l,Iterable)) # 判断是否可迭代 True
print(isinstance(l,Iterator)) # 判断是否为迭代器 False
from collections import Iterable
from collections import Iterator
l = [,,]
l1 = iter(l) #生成迭代器
print(isinstance(l1,Iterable)) # True
print(isinstance(l1,Iterator)) # True
print(l1) # <list_iterator object at 0x031D3690>
print(next(l1)) # 
print(next(l1)) # 
print(next(l1)) # 
print(next(l1)) # 报错 StopIteration

next:内部实际使用了__next__方法,返回迭代器的下一个项目。

# 首先获得Iterator对象:
it = iter([, , , , ])
while True:
try:
# 获得下一个值:
x = next(it) #next内部封装了__next__方法,都是求下一个值
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break
执行输出:

十一、其他

文件操作相关

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

 

format:1、提供参数,指定对其方式,<是左对齐,>是右对齐,^是居中

2、将整数转化成二进制’b‘、’n‘、unicode ’c‘、八进制’o‘、十六进制’x’、’X‘等

3、将浮点数用科学计数法或小数点计数法表示

print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))
执行输出:
test
test
test 

super:根据传入的参数创建一个新的子类和父类关系的代理对象

class A(object):
def __init__(self):
print('A.__init__')
class B(A):
def __init__(self):
print('B.__init__')
super().__init__()
#super调用父类方法
b = B()
结果输出:
B.__init__
A.__init__

__import__:动态导入模块

index = __import__('index')
index.sayHello()

 

 参考链接:

        https://www.cnblogs.com/sesshoumaru/p/6140987.html

        https://www.cnblogs.com/vamei/archive/2012/11/09/2762224.html

        https://www.cnblogs.com/pyyu/p/6702896.html

版权声明
本文为[Tammy~]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/Summer-skr--blog/p/11503602.html