欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Python3.6.x中内置函数总结及讲解

程序员文章站 2022-03-18 11:57:29
python3.6.x中内置函数总结 # -*- coding:utf-8 -*- """ abs() dict() help()...

python3.6.x中内置函数总结

# -*- coding:utf-8 -*-
"""
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()
"""
from collections import iterator,iterable
# abs(x)
# 求绝对值
print(abs(-1),abs(1))
# all(iterable)
# 如果iterable的所有元素都为真,则返回true(iterable为空,返回true)
print(all([1,'a',[2]])) # true
print(all([0,'a',[]])) # false
print(all(''))     # true
# any(iterable)
# 只要iterable中有一个元素为真,则返回true(iterable为空,返回false)
print(any([1,[],'']))    # true
print(any([0,0.0,'',[],{},set()]))  # false
print(any([]))       # false
# ascii(s)
# 只在python3中支持,用于在不支持unicode的平台查看unicode字符串
# 就像repr()那样,创建对象的可打印形式,但在结果中只是用ascii字符,非ascii字符都转换为合适的转义序列。
print(ascii('hello你好'))
# 'hello\u4f60\u597d'
# repr(obj)
# 将其它类型数据转换为字符串,支持大部分内置数据类型
print(repr(123))      # 123
print(repr('hello 你好'))  # 'hello 你好'
print(repr([1,2,3]))    # [1, 2, 3]
print(repr({'a':1}))    # {'a': 1}
print(repr(object()))    # <object object at 0x7f4e9de470a0>
# str(value='', encoding=none, errors='strict')
# 转换为字符串
print(str())    # ''
print(str(666))   # 666
print(str(6.66))  # 6.66
print(str(b'666')) # b'666'
# bin(x)
# 返回一个字符串,其中包含整数x的二进制形式 0b1010
print(bin(0),bin(1),bin(10))
# 0b0 0b1 0b1010
# class bool([x])
# 是class,返回true或false
print(bool(),bool(0),bool(1),bool(''),bool('abc'),bool([]),bool([1]),bool(false),bool(true))
# false false true false true false true false true
# class bytearray(source=none, encoding=none, errors='strict')
# 返回一个字节数组,字符范围[0,255]
print(bytearray("hello 你好","utf-8"))
# bytearray(b'hello \xe4\xbd\xa0\xe5\xa5\xbd')
# bytes(value=b'', encoding=none, errors='strict')
# 返回字节类型,字符范围[0,255]
print(bytes("hello 你好","utf-8"))
# b'hello \xe4\xbd\xa0\xe5\xa5\xbd'
# callable(o)
# 返回true或者false,判断一个给定对象 o 是否是可调用对象
print(callable(1),callable(''),callable(str))
# false false true
# chr(x)
# 返回unicode编码表中整数x对应的字符
print(chr(65),chr(20001))
# a 両
# ord()
# 返回单个字符在unicode码表中对应的整数编码
print(ord('a'),ord('李'),ord('永'),ord('平')) # 65 26446 27704 24179
# @classmethod()
# 将一个普通函数转换为类方法,等价于@classmethond装饰器
class a():
  def func01(*args):
    print('classmethod()',*args)
  classmethod(func01)
  @classmethod
  def func02(clz,*args):
    print('@classmethond',*args)
a.func01()
a.func02()
# 输出
# classmethod()
# @classmethond
# @staticmethod
# 将一个普通函数转换为静态方法
class a():
  def func01(*args):
    print('staticmethod()',*args)
  staticmethod(func01)
  @staticmethod
  def func02(*args):
    print('@staticmethod',*args)
a.func01()
a.func02()
# 输出
# staticmethod()
# @staticmethod
# compile(source, filename, mode, flags=0, dont_inherit=false, optimize=-1)
# 将字符串格式的源代码,编译为可以被exec()或eval()函数执行的代码code对象
# source:一个python模块或多个代码块,或者是单一代码块,或者是一个表达式
# filename:运行时错误消息提示
# mode:与source对应,模块或多个代码块--"exec",单一代码块--"single",表达式--"eval"
statements="""
print('-'*50)
num=3
while num:
  print("hello")
  num-=1
print('-'*50)"""
filename="run-time error"
codes=compile(source=statements,filename=filename,mode="exec")
print(type(codes))
# eval(codes)
exec(codes)
# 输出
# <class 'code'>
# --------------------------------------------------
# hello
# hello
# hello
# --------------------------------------------------
# eval(expression, globals=none, locals=none)
# 运行python表达式字符串或者是经过compile()编译后生成的code对象
# obj可以是字符串对象或者已经由compile编译过的代码对象,
# globals和locals是可选的,分别代表了全局和局部名称空间中的对象,其中globals必须是字典,而locals是任意的映射对象
print(eval("2**3"))   # 8
print(eval("type({'key':'value'})"))  # <class 'dict'>
# exec(object[, globals[, locals]])
# 运行python代码字符串或者是经过compile()编译后生成的code对象
statements="""
num=1
if num<3:
  print("1<3")"""
exec(statements)  # 1<3
exec('print("exec")')  # exec
# class complex(real, imag=none)
# 返回复数
c=complex(1,2)
print(c,c.real,c.imag)
c=complex('1+2j')
# c=complex('1 +2j')  # 报错valueerror,字符串中不能包含空格
# c=complex('1+2i')  # 报错valueerror,复数虚部必须使用英文字母 j 表示
print(c,c.real,c.imag)
# 输出
# (1+2j) 1.0 2.0
# (1+2j) 1.0 2.0
# delattr(obj,attr)
# 等价于 del obj.attr
# 删除对象obj的attr属性
class a:
  attr_01=1
  attr_02=2
print(a.attr_01)
delattr(a,'attr_01')
# print(a.attr_01)  # attributeerror: type object 'a' has no attribute 'attr_01'
print(a.attr_02)
del a.attr_02
# print(a.attr_02)  # attributeerror: type object 'a' has no attribute 'attr_02'
# class dict(**kwarg)
# class dict(mapping, **kwarg)
# class dict(iterable, **kwarg)
# 返回一个字典对象
print(dict())  # {}
print(dict(a=2,b=1))  # {'b': 1, 'a': 2}
print(dict([('a',1),('b',2),('c',3)])) # {'a': 1, 'b': 2, 'c': 3}
print(dict({'a':'a','b':'b'})) # {'a': 'a', 'b': 'b'}
# dir(obj)
# 参数为空,返回当前作用域中的属性和方法列表
# 参数不为空,返回参数对象obj的作用域中的属性和方法列表
# 参数不为空,且该参数对象所属类中重载了 __dir__(self) 运算符,则返回 __dir__(self)的返回值
print(dir())
print(dir(int))
print(dir(dict))
class b():
  def __dir__(self):
    return ['哼','哈']
  def func(self):
    pass
b=b()
print(dir(b))  # ['哈', '哼']
# divmod(a,b)
# 等价于 (a//b,a%b)
# 返回长除法的商与余数组成的元组
print(divmod(10,3),(10//3,10%3))
print(divmod(10,3.0),(10//3.0,10%3.0))
print(divmod(10.0,3),(10.0//3,10.0%3))
# (3, 1) (3, 1)
# (3.0, 1.0) (3.0, 1.0)
# (3.0, 1.0) (3.0, 1.0)
# enumerate(i,start=0)
# 根据给定iterable,返回枚举类型对象,是iterator类型
print(list(enumerate('abc',start=1)))
for item in enumerate('123',start=0):
  print(item)
# 输出
# [(1, 'a'), (2, 'b'), (3, 'c')]
# (0, 'a')
# (1, 'b')
# (2, 'c')
# filter(function, iterable)
# 过滤序列中的值
# filter函数将序列iterable中的每一个元素传入函数function中,如果返回值为真,则添加到结果集中;否则,过滤掉
# 如果function为none,则将iterable中值为true的元素添加到结果集中
data=[-1,0,1,2,3,false]
res=filter(lambda x:x>=0,data)
print(res)   # <filter object at 0x7f97fe23f7b8>
print(list(res))  # [0, 1, 2, 3, false]
res=filter(none,data)
print(list(res))  # [-1, 1, 2, 3]
# class float([x])
# 生成浮点数,x为数字或者字符串
# inf:无穷
print(float(),float(1),float('1'),float('+1.23'),float('+1e6'),float('-infinity'),float('  -12345\n'))
# 0.0 1.0 1.0 1.23 1000000.0 -inf -12345.0
# format(value, [format_spec])
# 格式化显示value的值,类型为str
# 如果format_spec为空,则等效于str(value)
print(format(123)) # 123
print(format(true)) # true
print(format({'a':1,'b':2}))  # {'a':1,'b':2}
print(format(123,'b')) # 格式化为2进制 1111011
print(format(123,'o')) # 格式化为8进制 173
print(format(123,'d')) # 格式化为10进制 123
print(format(123,'x')) # 格式化为16进制,使用小写字母显示 7b
print(format(123,'x')) # 格式化为16进制,使用大写在木显示 7b
print(format(123456789.123456789,'e'))   # 科学计数法,默认保留6位小数 1.234568e+08
print(format(123456789.123456789,'0.2e'))  # 科学计数法,保留2位小数 1.23e+08
print(format(123456789.123456789,'e'))   # 科学计数法,1.234568e+08
print(format(123456789.123456789,'0.2e'))  # 科学计数法,1.23e+08
print(format(123456789.123456789,'f'))   # 小数点计数法,默认保留6位小数,123456789.123457
print(format(123456789.123456789,'0.2f'))  # 小数点计数法,保留2位小数,123456789.12
print(format(1.0e+1000,'f'),format(-1.0e+1000,'f')) # 小数点计数法,无穷大转换为字母 inf,-inf
# class set([iterable])
# 获取一个set实例对象,可变,元素不重复
print(set())   # set()
print(set('123')) # {'2', '3', '1'}
# class frozenset([iterable])
# 返回一个frozenset实例对象,不可变,元素不重复
print(frozenset())   # frozenset()
print(frozenset('123')) # frozenset({'2', '3', '1'})
# getattr(object, name[, default])
# 返回object的name属性值,name必须是str类型
# 如果不存在name属性,设置了default返回default值,否则,抛出异常attributeerror
class a(object):
  attr_01='value_01'
print(getattr(a,'attr_01'))
print(getattr(a,'attr_02','value_02'))
# print(getattr(a,'attr_03')) # attributeerror: type object 'a' has no attribute 'attr_03'
# hasattr(object, name)
# 判断object是否拥有属性name,返回true或false
print(hasattr(a,'attr_01')) # true
print(hasattr(a,'attr_02')) # false
# setattr(object, name, value)
# 给object设置属性name,值为value
setattr(a,'attr_02','value_02')
print(hasattr(a,'attr_02')) # true
# globals()
# 返回属于全局作用域的属性或者方法的字典表
print(globals())
# locals()
# 返回属于本地作用域的属性和方法的字典表
print(locals())
def function():
  a,b=1,2
  print(locals())   # {'b': 2, 'a': 1}
function()
# vars(object)
# 返回任意对象的__dict__属性,前提是存在该属性
print(vars(int))
# hash(object)
# 返回object的哈希值,大小相等的数字,哈希值一定相同
print(hash(1),hash(1.0))
print(hash(a),hash(a()))
print(hash(int),hash(hash))
# help([object])
# 调用内置的帮助系统
# object可以为空,module, function, class, method, keyword, or documentation topi
# help()
# import re
# help(re)
# help(hash)
# help('class')
# class int(x=0)
# class int(x, base=10)
# 将给定数据x从base进制转换为10进制int
# x为数字或可转换为数字的字符串,base为数字x本来的进制
print(int(255)) # 255
print(int('255'))  # 255
print(int('255',base=10))  # 255
print(int('255',base=8))  # 173
# oct(x)
# 将10进制数x转换为8进制数
print(oct(255)) # 0o377
# hex(x)
# 将一个int类型的数字转换为16进制
print(hex(255),hex(0)) # 0xff 0x0
# id()
# 返回代表object身份的一个int数字,可以认为c语言中"对象的内存地址"
print(id(0))
print(id(id))
# input([prompt])
# 接收用户的输入并返回字符串
# value=input('--->')
# print(value)
# print(*objects, sep=' ', end='\n', file=sys.stdout, flush=false)
# *args:任意多个字符串
# sep:字符串之间的分割符,默认为空格
# end:结束符号,默认为换行 \n
print('a','b','c',sep='$',end='\n\n')
# isinstance(object, classinfo)
# 判断object是否是classinfo的一个实例
class a():pass
print(isinstance(1,int))  # true
print(isinstance(a(),a))  # true
# issubclass(class, classinfo)
# 判断class是否是classinfo的一个子类
class a():pass
class b(a):pass
print(issubclass(b,a)) # true
# iter(object[, sentinel])
# 将一个可迭代对象转换为迭代器iterator
i=iter('abc')
print(type(i))
# next(iterator[, default])
# 返回迭代器的下一个元素
# 如果没有下一个,返回default参数,如果没有default,抛出stopiteration异常
print(next(i),next(i),next(i))
# print(next(i)) # stopiteration
print(next(i,'没有更多元素了'))
# len(iterable)
# 返回iterable的元素个数
print(len('abc'))  # 3
print(len([1,2,3])) # 3
print(len((1,2,3))) # 3
print(len({'a':1})) # 1
print(len({1,2,3})) # 3
# class list([iterable])
# 实例化一个list对象
print(list())
print(list('abcd'))
print(list(range(5)))
# map(function, iterable, ...)
# 在序列中映射函数:map函数会对一个序列对象中的每一个元素应用被传入的函数,并返回一个包含所有函数调用结果的映射集合
# res=map(lambda x:x,[1,2,3])
res=map(lambda x,y:x+y,[1,2,3],[4,5,6])
print(type(res))
print(list(res))
# max()
# 返回给定序列中的最大值
print(max(1,2))   # 2
print(max([1,2]))  # 2
print(max({'a':2,'b':1})) # b
print(max({'a','b'}))   # b
# min()
# 返回给定序列中的最小值
print(min(1,2))   # 1
print(min([1,2]))  # 1
print(min({'a':2,'b':1})) # a
print(min({'a','b'}))   # a
# memoryview(object)
# 什么鬼?内存视图?c中的指针?
view=memoryview(b'abcd')
print(view[0]) # 97
# class object
# 返回一个object
print(object) #<class 'object'>
print(object()) # <object object at 0x7fc4731ef0c0>
# open(file, mode='r', buffering=-1, encoding=none, errors=none, newline=none, closefd=true, opener=none)
# 打开一个文件对象
# pow(x,y,[z])
# 2个参数时,等效于x**y
# 3个参数时,等效于x**y%z
print(pow(10,3))  # 1000
print(pow(10,3,3)) # 1
# class property(fget=none, fset=none, fdel=none, doc=none)
# 不懂?
# range([start,]stop[,sep])
# 生成数字列表
r=range(5)
print(type(r),isinstance(r,iterator))  # <class 'range'> false
for i in range(1,10,2):
  print(i,end=' ')    # 1 3 5 7 9
print('\n')
# reversed(seq)
# 翻转序列seq,返回iterator
i=reversed(['a','b','c'])
print(i)
print(next(i),next(i),next(i),next(i,'没有了'))
# round(number[, ndigits])
# 四舍五入
# ndigits为保留小数点位数,默认为0
print(round(16),round(16.18),round(8.88),round(-8.88))     # 16 16 9 -9
print(round(16,1),round(16.18,1),round(8.88,1),round(-8.88,1)) # 16 16.2 8.9 -8.9
# class slice(stop)¶
# class slice(start, stop[, step])
# 返回一个切片slice对象,表示步距,可用于切片操作,实际上对可迭代对象的切片操作就是调用了slice方法
print(slice(5))   # slice(none, 5, none)
print(slice(1,5))  # slice(1, 5, none)
print(slice(1,5,2)) # slice(1, 5, 2)
seq='abcdefghj'
print(seq[slice(5)])  # abcde
print(seq[slice(1,5,2)])# bd
# sorted(iterable, *, key=none, reverse=false)
# 对可迭代对象进行排序
# key为函数,依次作用于每个元素
# reverse为是否倒序排序
print(sorted('872aadbc',key=none,reverse=true))
# ['d', 'c', 'b', 'a', 'a', '8', '7', '2']
print(sorted('872aadbc',key=lambda x :str.lower(x),reverse=true))
# ['d', 'c', 'b', 'a', 'a', '8', '7', '2']
# sum(iterable[, start])
# 求和:iterable中各元素之和,加上第二个参数start的值
# 第二个参数start默认为0
print(sum([1,2,3]))
print(sum([1,2,3],10))
# super([type[, object-or-type]])
# 调用父类中的方法
class a(object):
  def methond(self):
    print('----a----')
class b(a):
  def methond(self):
    super(b,self).methond()
    # 等价于
    # super().methond()
    print('----b----')
b.methond(b())
# tuple([iterable])
# 返回一个元祖对象,不可变的list
print(tuple(['l','o','v','e','e']))
# type(obj)
# 返回obj的数据类型
print(type(0))
print(type(''))
print(type([]))
print(type((0,)))
print(type({}))
# zip()
# 创建一个迭代器,结果为俩个iterable中各元素从开始位置开始的映射关系
# 如果2个iterable中的元素个数不同,则舍弃比较多的元素
ziped=zip('abcd','1234')
print(isinstance(ziped,iterator))  # true
print(list(ziped)) # [('a', 'a'), ('b', 'b'), ('c', 'c'), ('d', 'd')]
ziped=zip('abc','1234')
print(list(ziped))   # [('a', '1'), ('b', '2'), ('c', '3')]
ziped=zip('abcd','123')
print(list(ziped))   # [('a', '1'), ('b', '2'), ('c', '3')]
print(list(zip('abc'))) # [('a',), ('b',), ('c',)]
print(list(zip('abc',''))) # []
# __import__(name, globals=none, locals=none, fromlist=(), level=0)
# 不常用的高级函数
# import importlib
# importlib.import_module('module_name')

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对的支持。如果你想了解更多相关内容请查看下面相关链接