一、python常见的内置函数

1、dir()

返回参数的属性、方法列表，可以查看某个对象的属性和方法。

print(dir(list))
-------------
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

2、open()

用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写

open(name[, mode[, buffering]])

• name : 文件名称。

• mode : 打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认为只读r（常见的模式有：w-写入，r-只读，a-追加）。

• buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

3、staticmethod()

返回函数的静态方法，一般通过装饰器的形式使用，方便将外部函数集成到类体中

staticmethod(function)

示例：

class Test:
    @staticmethod
    def test():
        print(1111)
# 以上实例声明了静态方法 test，从而可以实现实例化使用 Test().test()，当然也可以不实例化调用该方法 Test.test()
# 使用staticmethod装饰器装饰后，定义的方法中不用加self
Test.test()
Test().test()

4、enumerate()

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般结合for循环使用

enumerate(sequence, [start=0])

• sequence：一个序列、迭代器或其他支持迭代对象。
• start：下标起始位置的值。
• 返回值：<enumerate object at 0x10ab11e40>

print(list(enumerate(["a", "b", "c"])))
------------
[(0, 'a'), (1, 'b'), (2, 'c')]

5、int()

将一个字符串或数字转换为整型

int(x, base=10)

• x – 字符串或数字（若 x 为纯数字，则不能有 base 参数，否则报错；若 x 为 str，则 base 可略可有）。
• base – 进制数，默认十进制。

>>> int(3.6)
3
>>> int('12',16)        # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18

6、ord()/chr()

ord() ：以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值

>>>ord('a')
97

chr(i)：用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符，i可以是10进制也可以是16进制的形式的数字

>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a

7、eval()/exec

1、eval()
执行一个字符串表达式，并返回表达式的值

eval(expression[, globals[, locals]])

>>> eval('2 + 2')
4

2、exec
exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码

exec(object[, globals[, locals]])

• object：必选参数，表示需要被指定的 Python 代码。它必须是字符串或 code 对象。如果 object 是一个字符串，该字符串会先被解析为一组 Python 语句，然后再执行（除非发生语法错误）。如果 object 是一个 code 对象，那么它只是被简单的执行。
• globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
• locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与 globals 相同的值。

>>>exec('print("Hello World")')
Hello World
# 单行语句字符串
>>> exec("print ('runoob.com')")
runoob.com
 
#  多行语句字符串
>>> exec ("""for i in range(5):
...     print ("iter time: %d" % i)
... """)
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4

8、isinstance()

判断一个对象是否是一个已知的类型，类似 type()

isinstance(object, classinfo)

• object – 实例对象。
• classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。

>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True

type() 与 isinstance()区别：

class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

9、dict()

用于创建一个字典
创建字典有三种方式，关键字/映射函数/可迭代对象，具体实例如下：

>>>dict()                        # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}

10、help()

返回对象帮助信息

11、getattr()/setattr()

1、getattr() 函数用于返回一个对象属性值

getattr(object, name[, default])

• object – 对象。
• name – 字符串，对象属性。
• default – 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

>>> getattr(a, 'bar')        # 获取属性 bar 值
1
>>> getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
>>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
3

2、setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的

setattr(object, name, value)

• object – 对象。
• name – 字符串，对象属性。
• value – 属性值。

>>> setattr(a, 'bar', 5)       # 设置属性 bar 值
>>> a.bar
5

12、hex()

将一个指定数字转换为 16 进制数

>>>hex(255)
'0xff'

13、next()

返回迭代器的下一个项目，next() 函数要和生成迭代器的 iter() 函数一起使用

next(iterable[, default])

• iterable – 可迭代对象
• default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

14、id()

返回对象的唯一标识符，标识符是一个整数（返回对象的内存地址）

15、sorted()

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

• iterable – 可迭代对象。
• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

>>> sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]   # 默认为升序

sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

16、bin()

返回一个整数 int 或者长整数 long int 的二进制表示

>>>bin(10)
'0b1010'

17、filter()

用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换；

filter(function, iterable)

• function – 判断函数。
• iterable – 可迭代对象。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中

def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
-------------
[1, 3, 5, 7, 9]

18、pow()

返回 xy（x的y次方） 的值

# 函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
pow(x, y[, z])

注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

import math   # 导入 math 模块
print ("math.pow(100, 2) : ", math.pow(100, 2))
# 使用内置，查看输出结果区别
print ("pow(100, 2) : ", pow(100, 2))
------------------
math.pow(100, 2) :  10000.0
pow(100, 2) :  10000

19、super()

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

class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)  # 3

20、iter()

用来生成迭代器

iter(object[, sentinel])

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

>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
... 
1
2
3

21、print()

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

• objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep – 用来间隔多个对象，默认值是一个空格。
• end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
• file – 要写入的文件对象。
• flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

>>> print("aaa","bbb")
aaa bbb
 
>>> print("www","runoob","com",sep=".")  # 设置间隔符
www.runoob.com

22、tuple

tuple 函数将可迭代系列（如列表）转换为元组

tuple( iterable )

• terable – 要转换为元组的可迭代序列

23、callable()

检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True。

callable(object)

>>> def add(a, b):
...     return a + b
... 
>>> callable(add)             # 函数返回 True
True
>>> class A:                  # 类
...     def method(self):
...             return 0
... 
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 没有实现 __call__, 返回 False
False
>>> class B:
...     def __call__(self):
...             return 0
... 
>>> callable(B)
True
>>> b = B()
>>> callable(b)               # 实现 __call__, 返回 True
True

24、format

str.format()，它增强了字符串格式化的功能。format 函数可以接受不限个参数，位置可以不按顺序

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

# 数字格式化
>>> print("{:.2f}".format(3.1415926))
3.14

25、len()

len() 方法返回对象（字符、列表、元组等）长度或项目个数

>>>str = "runoob"
>>> len(str)             # 字符串长度
6

26、frozenset()

返回一个冻结的集合，冻结后集合不能再添加或删除任何元素，有集合的中的元素是另一个集合的情况，但是普通集合（set）本身是可变的，那么它的实例就不能放在另一个集合中（set中的元素必须是不可变类型）。
所以，frozenset提供了不可变的集合的功能，当集合不可变时，它就满足了作为集合中的元素的要求，就可以放在另一个集合中了。

>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合

27、range()

range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表

range(start, stop[, step])

• start: 计数从 start 开始。默认是从 0 开始;
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

28、classmethod 修饰符

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

class A:
    s = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.s)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

29、repr()

repr() 函数将对象转化为供解释器读取的形式，返回一个对象的 string 格式

>>> s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"

30、zip()

将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，一般会用listuo输出为列表

zip([iterable, ...])

• iterabl – 一个或多个迭代器;

print(list(zip([1,2,3],[2,3,4])))
print(dict(zip([1,2,3],[2,3,4])))
-----------
[(1, 2), (2, 3), (3, 4)]
{1: 2, 2: 3, 3: 4}

zip(*) 可理解为解压，返回二维矩阵式

aa=[(1, 2), (2, 3), (3, 4)]
a,b=zip(*aa)
print(a)
print(b)
-------------
(1, 2, 3)
(2, 3, 4)

31、round()

返回浮点数 x 的四舍五入值

round( x [, n]  )

• x – 数字。
• n – 表示从小数点位数，其中 x 需要四舍五入，默认值为 0

print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
------------
round(70.23456) :  70
round(56.659,1) :  56.7

32、hash()

获取取一个对象（字符串或者数值等）的哈希值

>>>hash('test')            # 字符串
2314058222102390712
>>> hash(1)                 # 数字
1
>>> hash(str([1,2,3]))      # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378

33、set()

创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等

>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])

34、map()

根据提供的函数对指定的序列做映射

map(function,iterable,...)

• 第一个参数function:接受一个函数名;
• 第二个参数：接受一个或多个可迭代的序列，返回的是一个集合

def map_test():
    num1=[1,2,3]
    num2=[2,3,4]
    num3=[3,4,5,6]
    result=map(lambda x,y,z:x+y+z,num1,num2,num3)
    return result
for i in map_test():
    print(i)
-----结果------
# 元素个数与最短的列表一致
6
9
12