Python3内置函数

Python3内置函数
一、简介
python中的全局函数，又称内置函数，为了方便使用，今天给大家总结了一下。
二、使用说明
这里就是使用菜鸟教程上面的介绍，和下面总结的顺序一样。
欢迎大家多去菜鸟教程：www.runnoob.com 去总结学习知识！

1.abs()函数返回数字的绝对值
abs(-40) >>40
abs(100.10) >>100.1

2.all()函数用于判断给定的可迭代参数iterable中的所有元素是否都为True,
如果是就返回True，否则返回False。
元素除了0、空字符串、None、False外都算是True。
def all(iterable):
for element in iterable:
if not element:
return False
return True
print(all([i for i in range(1, 10)])) >>True

all([])                         >>True
all(())                         >>True
all(["0", "1", "2"])            >>True
all([0, 1, 2, 3, 4])            >>False           
all(["","a","123","hello"])     >>False
注意：空元组、空列表的返回值为True，这里要特别注意。

3.any()函数用于判断给定的可迭代参数iterable是否全部为False,则返回False,
如果有一个为True,则返回True。 【注意：和all()函数的区别】
元素除了0、空字符串、None、False外都算是True。
def any(iterable):
for element in iterable:
if element:
return True
return False
print(any([0])) >>False

any([])                         >>False
any(())                         >>False
any(["0", "1", "2"])            >>True
any([0, 1, 2, 3, 4])            >>True          
any(["","a","123","hello"])     >>True
any([None])                     >>False

4.ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非
ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。
ascii(“a”) >>"‘a’"

5.bin()返回一个整数int或长整数long int的二进制表示
bin(10) >>‘0b1010’
bin(20) >>‘0b10100’

6.bool()函数用于将给定参数转换为布尔类型，如果没有参数或参数为0、None、空字符串，返回False。
bool是int的子类。
bool() >>False
bool(0) >>False
bool(1) >>True
bool(2) >>True
issubclass(bool,int) >>True # 判断bool是否是int的子类

7.bytearray()方法返回一个新字节数组。这里数组里的元素是可变的，并且每个元素的值范围：0<=x<256。
语法：
class bytearray([source[,encoding[,errors]]])
参数：
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

bytearray()                     >>bytearray(b'')
bytearray([4,5,6])              >>bytearray(b'\x04\x05\x06')
bytearray("English","utf-8")    >>bytearray(b'English')

8.bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数
不可变序列。它是 bytearray 的不可变版本。
bytes([4,5,6]) >>b’\x04\x05\x06’
bytes(“runoob”,“ascii”) >>b’runoob’

9.callable()函数用于检查一个对象是否是可调的。如果返回True，object仍然调用可能失效；
但如果返回False，调用对象object绝对不会成功。
对于函数、方法、lambda函式、类以及实现了__call__方法的类实例，它都返回True。
callable(0) >>False
callable(“runoob”) >>False
def add(a,b):
return a+b

callable(add)                    >>True
class A(object):
    pass

a = A()
print(callable(a))               >>False

class B(object):

def __call__(self, *args, **kwargs):
    return 0


b = B()
print(callable(b))               >>True

10.chr()用于范围在range(256)内的(就是0~256)整数作参数，返回一个对应的字符。
chr(0x32),chr(0x65),chr(0x120) >>(‘2’, ‘e’, ‘G’)
chr(48),chr(65),chr(122) >>(‘0’, ‘A’, ‘z’)

11.classmethod修饰符对应的函数不需要实例化，不需要self参数，但第一个参数需要是表示
自身类的cls参数，可以用来调用类的属性，类的方法，实例化对象等。
class A(object):

    bars = 1

    def fun1(self):
        print("我是方法1")

    @classmethod
    def fun2(cls):
        print("我是方法2")
        print(cls.bars)  # 调用类属性
        cls().fun1()    # 调用方法1
    

A.fun2()
输出结果：
    我是方法2
    1
    我是方法1

12.compile()函数将一个字符串编译为字节代码。
语法：
compile(source, filename, mode[, flags[, dont_inherit]])
参数：
source – 字符串或者AST（Abstract Syntax Trees）对象。。
filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode – 指定编译代码的种类。可以指定为 exec, eval, single。
flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志

>>> str = "3 * 10 + 7"
>>> a = compile(str,"","eval")
>>> eval(a)
37

13.complex()函数用于创建一个值为real + imag * j的复数或者转化为一个字符串或数为复数。
如果第一个参数为字符串，则不需要指定第二个参数。
complex(1,2) >>(1+2j)
complex(1) >>(1+0j)
complex(“1”) >>(1+0j)
complex(“1+10j”) >>(1+10j)
注意：这个地方在"+“号两边不能有空格，不能写成"1 + 10j”,应该是"1+10j",否则会报错。

14.delattr函数用于删除属性。
delattr(x,“foo”)相当于del x.foo
class Prac:
x = 5
y = 10
z = -5

p1 = Prac()
print(p1.x)
print(p1.y)
print(p1.z)
delattr(Prac,“z”)
print(p1.x)
print(p1.y)
print(“z已删除”)
print(p1.z)

15.dict()函数用于创建一个字典。
dict() >>{}
dict(a=“1”,b=“2”,c=“3”) >>{‘a’: ‘1’, ‘b’: ‘2’, ‘c’: ‘3’} # 传入关键字
dict(zip([“a”,“b”,“c”],[1,2,3])) >>{‘a’: 1, ‘b’: 2, ‘c’: 3} # 映射函数方式
dict([(“a”,1),(“b”,2),(“c”,3)]) >>{‘a’: 1, ‘b’: 2, ‘c’: 3} # 可迭代对象方式

16.dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
如果参数包含__dir__(),该方法将被调用，如果参数不包含__dir__(),该方法将最大限度地收集参数信息。
dir()
[‘annotations’, ‘builtins’, ‘doc’, ‘loader’, ‘name’,
‘package’, ‘spec’, ‘a’, ‘os’, ‘str’, ‘sys’]

17.python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组
(a//b, a%b)，在 python 3 版本之后不允许处理复数python，。
参数说明：a,b为数字，带参数的好像不支持。
divmod(8,4) >>(2,0)
divmod(7,3) >>(2,1)
divmod(1+2j, 1+0.5j) >>((1+0j), 1.5j) 【python2.7.12版本测试的】

18.enumerate()函数将用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
同时列出数据和数据下标，一般用在for循环当中。
语法：
enumerate(sequence, [start=0])
参数：
sequence – 一个序列、迭代器或其他支持迭代对象。
start – 下标起始位置。

>>> ss = ["春","夏","秋","冬"]
>>> list(enumerate(ss))
[(0, '春'), (1, '夏'), (2, '秋'), (3, '冬')]
>>> list(enumerate(ss,start=5))
[(5, '春'), (6, '夏'), (7, '秋'), (8, '冬')]

19.eval()函数用来执行一个字符串表达式，并返回表达式的值。【可以去字符串】
语法：
eval(expression[, globals[, locals]])
参数：
expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

>>> eval("9+9")
18
>>> eval("9*9")
81

20.exec 执行储存在字符串或文件中的Python语句，相比于eval,exec可以执行更复杂的Python代码。
exec(“print (‘runoob’)”) >>runoob
x = 20
expr = “”"
z = 30
sum = x + y + z
print(sum)
“”"
def func():
y = 20
exec(expr)
exec(expr, {‘x’: 4, ‘y’: 5})
exec(expr, {‘x’: 4, ‘y’: 5}, {‘y’: 6, ‘z’: 7})

func()                      >> 70   39   40 # (换行输出的)

21.filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要
转换为列表，可以使用 list() 来转换。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，
然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
def is_odd(n):
return n % 2 == 1

tmp = filter(is_odd, range(1,10))
news = list(tmp)
print(news)                         >>[1, 3, 5, 7, 9]                        

22.float() 函数用于将整数和字符串转换成浮点数。
>>> float(10)
10.0
>>> float(100)
100.0
>>> float(“123”)
123.0

23.format() Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。
“{} {}”.format(“月”,“日”) >>‘月 日’
“{1} {0} {1}”.format(“月”,“日”) >>‘日 月 日’

24.frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
>>> a = frozenset(range(10)) # 创建一个新的不可变集合
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
>>> b = frozenset(“hello”) # 创建不可变集合
>>> b
frozenset({‘l’, ‘o’, ‘h’, ‘e’})

25.getattr()函数用于返回一个对象属性值。
class A:
ba = 3

a = A()
print(getattr(a, "ba"))
print(getattr(a, "bar", 5))    # 属性不存在时，可设置默认值

26.globals() 函数会以字典类型返回当前位置的全部全局变量。
>>> a = “hello”
>>> print(globals()) # globals函数返回一个全部变量的字典，包括导入的所有变量
{‘name’: ‘main’, ‘doc’: None, ‘package’: None,
‘loader’: <class ‘_frozen_importlib.BuiltinImporter’>,
‘spec’: None, ‘annotations’: {}, ‘builtins’: <module ‘builtins’ (built-in)>, ‘ss’: [‘春’, ‘夏’, ‘秋’, ‘冬’], ‘a’: ‘hello’, ‘b’: frozenset({‘l’, ‘o’, ‘h’, ‘e’})}

27.hasattr() 函数用于判断对象是否包含对应的属性。
class A:
ba = 3

a = A()
print(hasattr(a, "ba"))         >>True      # 存在
print(hasattr(a, "bar"))        >>False     # 不存在

28.hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
>>> hash(“hello”)
-3912998349984635143
>>> hash(“123”)
-7732648090363988464
>>> hash(123)
123

29.help() 函数用于查看函数或模块用途的详细说明。
help(“sys”) # 查看sys模块的帮助
help(“str”) # 查看str模块的帮助

30.hex() 函数用于将一个指定数字转换为 16 进制数。
>>> hex(255)
‘0xff’
>>> hex(123)
‘0x7b’

31.id() 函数用于获取对象的内存地址。
>>> a = 12
>>> id(a)
1685089376
>>> b = “hello”
>>> id(b)
2402012896760

32.input() Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
>>> input(“输入:”)
输入:123
‘123’

33.int() 函数用于将一个字符串或数字转换为整型。
语法：
class int(x, base=10)
参数：
x – 字符串或数字。
base – 进制数，默认十进制。

int(3)
3

int(3.8)
3

int(“10”,16)
16

int(“10”,8)
8

34.isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
>>> b = “1234”
>>> isinstance(b, int)
False
>>> isinstance(b, str)
True
>>> isinstance(b, (int,list,str)) # 只要是元组中的一个就返回True
True

35.issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
class A:
ba = 3

class B(A):
    pass

print(issubclass(B,A))          >>True

36.iter() 函数用来生成迭代器。
语法：
iter(object[, sentinel])
参数：
object – 支持迭代的集合对象。
sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），
此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用object。

37.len() Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
>>> st = “123”
>>> len(st)
3

38.list() 方法用于将元组或字符串转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
>>> sta = (“123”,5,46,“hello”)
>>> stb = list(sta)
>>> type(stb)
<class ‘list’>

39.locals() 函数会以字典类型返回当前位置的全部局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。
def run1(arg): # 两个局部变量：arg、z
x = 1
print(locals())

run1(4)     # 返回一个名字/值对的字典
>>> {'x': 1, 'arg': 4}

40.map() 会根据提供的函数对指定序列做映射。 【Python3中返回值是迭代器】
第一个参数 function 以参数序列中的每一个元素调用 function 函数，
返回包含每次 function 函数返回值的新列表。
>>> def sq(x):
… return x ** 2
…
>>> b = map(sq, [4,9,10]) # b是迭代器对象
>>> next(b)
16
>>> next(b)
81
>>> next(b)
100
>>> a = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
>>> next(a) # a是迭代器对象
3
>>> next(a)
7
>>> next(a)
11

41.max() 方法返回给定参数的最大值，参数可以为序列。
>>> max(50,80,20)
80
>>> max(50,-80,20)
50

42.memoryview() 函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
>>> v = memoryview(bytearray(“abcefg”, ‘utf-8’))
>>> v[2]
99 # 返回值是ASCII码

43.min() 方法返回给定参数的最小值，参数可以为序列。
>>> max(50,80,20)
20
>>> max(50,-80,20)
-80

44.next() 返回迭代器的下一个项目。

45.oct() 函数将一个整数转换成8进制字符串。
>>> oct(20)
‘0o24’
>>> oct(100)
‘0o144’

46.open() Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要
使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

47.ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串
（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
>>> ord(“z”)
122
>>> ord(“0”)
48

48.pow() 方法返回 xy（x的y次方） 的值。
>>> import math
>>> math.pow(10,2)
100.0
>>> math.pow(10,-2)
0.01

49.print() 方法用于打印输出，最常见的一个函数。
print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。

50.property() 函数的作用是在新式类中返回属性值。

51.range() Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型，
所以打印的时候不会打印列表。
Python3 list() 函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，
返回的变量类型为列表。
Python2 range() 函数返回的是列表。
>>> range(10)
range(0, 10)

52.repr() 函数将对象转化为供解释器读取的形式。
>>> s = “hello”
>>> repr(s)
"‘hello’

53.reversed 函数返回一个反转的迭代器。
>>> xx = “hello”
>>> print(list(reversed(xx)))
[‘o’, ‘l’, ‘l’, ‘e’, ‘h’]

54.round() 方法返回浮点数x的四舍五入值。
>>> round(5.5)
6
>>> round(5.1)
5

55.set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
【具有去重特性】
>>> x = set()
>>> type(x)
<class ‘set’>

56.setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
参考getattr(),不存在的属性会创建，存在的属性会修改其值。

57.slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。【python3中去掉了，但是解释器python3.6还支持】
>>> my_slice = slice(3)
>>> my_slice
slice(None, 3, None)
>>> arr = range(10)
>>> arr
range(0, 10)
>>> arr[my_slice]
range(0, 3)

58.sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回
的是一个新的 list，而不是在原来的基础上进行的操作。
>>> sorted([6,10,50,46,20])
[6, 10, 20, 46, 50]

59.staticmethod() python staticmethod 返回函数的静态方法。
该方法不强制要求传递参数，声明一个静态方法。

60.str() 函数将对象转化为适于人阅读的形式。可以将其他类型转化为字符串。
>>> a = “hello”
>>> str(a)
‘hello’
>>> a = 123
>>> str(a)
‘123’

61.sum() 方法对系列进行求和计算。
语法：
sum(iterable[, start])
参数：
iterable – 可迭代对象，如：列表、元组、集合。
start – 指定相加的参数，如果没有设置这个值，默认为0。
>>> sum([45,45,10])
100
>>> sum([45,45,10],10)
110

62.super() 函数是用于调用父类(超类)的一个方法。
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，
但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

63.tuple 函数将列表转换为元组。

64.type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
>>> type(123)
<class ‘int’>
>>> type(123.0)
<class ‘float’>
>>> type(“hh”)
<class ‘str’>

65.vars() 函数返回对象object的属性和属性值的字典对象。
语法：
vars([object])
参数：
object – 对象
返回值：
返回对象object的属性和属性值的字典对象，如果没有参数，就打印
当前调用位置的属性和属性值 类似 locals()。
>>> vars()
{‘name’: ‘main’, ‘doc’: None, ‘package’: None,
‘loader’: <class ‘_frozen_importlib.BuiltinImporter’>,
‘spec’: None, ‘annotations’: {}, ‘builtins’: <module ‘builtins’ (built-in)>, ‘ss’: [‘春’, ‘夏’, ‘秋’, ‘冬’], ‘a’: 123, ‘b’: ‘1234’, ‘st’: ‘123’, ‘sta’: (‘123’, 5, 46, ‘hello’), ‘stb’: [‘123’, 5, 46, ‘hello’], ‘sq1’: <function sq1 at 0x0000022F431E6598>, ‘x’: set(), ‘v’: <memory at 0x0000022F4320F4C8>, ‘math’: <module ‘math’ (built-in)>, ‘s’: ‘hello’, ‘xx’: ‘hello’, ‘my_sclice’: slice(None, 3, None), ‘arr’: range(0, 10)}

66.zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后
返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，
可以将元组解压为列表。
zip 方法在 Python 2 和 Python 3 中的不同：在 Python 2.x zip() 返回的是一个列表。
如果需要了解 Pyhton2 的应用，可以参考 Python zip()。
>>> a = [1,2,3]
>>> b = [7,8,9]
>>> zippe = zip(a,b)
>>> zippe
<zip object at 0x0000022F4324DAC8>
>>> list(zippe)
[(1, 7), (2, 8), (3, 9)]

67.import() 函数用于动态加载类和函数 。
如果一个模块经常变化就可以使用 import() 来动态载入。

import(“abc”) # 导入abc.py模块

以上方法实属小编结合python3内置函数总结，如有出入，可关注联系，进行更正。

You need others to point out your mistakes so you don’t make too many. ——MRIRA