[toc]
查看内置函数，可以用以下方法：

import builtins
for i in dir(builtins):
    print(i)

详细参考，点击查看
下面将内置函数进行分类：

1. 数学运算

abs() , round() , pow() , divmod() , max() , min() , sum()

'''
1、数学运算
'''
# abs(-5)  # 取绝对值，也就是5
# round(2.623423, 4)  # 四舍五入取整，也就是3.0, 4为精确到四位四舍五入
# pow(2, 3)  # 相当于2**3，如果是pow(2, 3, 5)，相当于2**3 % 5
# divmod(9, 2)  # 除法运算，返回商和余数
# max([1, 5, 2, 9])  # 求最大值
# min([9, 2, -4, 2])  # 求最小值
# sum([2, -1, 9, 12])  # 求和

2. 工厂函数

int() , float() , str() , bool() , slice() , list() , tuple() , dict() , set() , frozenset()

# int("5")  # 转换为整数 integer
# float(2)  # 转换为浮点数 float
# str(2.3)  # 转换为字符串 string
# bool(0)  # 转换为相应的真假值，在Python中，0相当于False在Python中，下列对象都相当于False：[], (), {}, 0, None, 0.0, ''
# slice(5, 2, -1)  # 构建下标对象 slice，切片函数
# list((1, 2, 3))  # 转换为表 list
# tuple([2, 3, 4])  # 转换为定值表 tuple
# dict(a=1, b="hello", c=[1, 2, 3])  # 构建词典 dictionary
# set()          创建集合函数
# frozenset()　　创建一个不可修改的集合 如:s=frozenset({1,2}) # 定义不可变集合

3. 类型转换

chr() , ord() , bin() , hex() , oct() , complex()

# ord("A")  # "A"字符在ascii码表中对应的数值
# chr(65)  # 数值65对应的ascii码表中的字符
# bin(56)  # 返回一个字符串，表示56的二进制数
# hex(56)  # 返回一个字符串，表示56的十六进制数
# oct(56)  # 返回一个字符串，表示56的八进制数
# complex(3, 9)  # 返回复数 3 + 9j

4. 序列操作

all() , any() , sorted() , reversed()

1 # all([True, 1, "hello!"])        # 是否所有的元素都相当于True值
2 # any(["", 0, False, [], None])   # 是否有任意一个元素相当于True值
3 # sorted([1,5,3])                  # 从小到大排序，也就是[1,3,5]
4 # reversed([1,5,3])               # 将元素翻转，也就是[3,5,1]

5. 编译执行函数

repr() , compile() , eval() , exec()

# repr(me)                         # 返回一个对象的字符串表示。有时可以使用这个函数来访问操作。
# compile("print('Hello')",'test.py','exec')       # 编译字符串成为code对象
# eval("1 + 1")                     # 解释字符串表达式。参数也可以是compile()返回的code对象
'''
# cmd='print("你瞅啥")'
# 
# dic="{'a':1,'b':2}"
# d=eval(dic)
# print(type(d),d['a'])
# 
# with open('user.db','w',encoding='utf-8') as f:
#     user_dic={'name':'egon','password':'123'}
#     f.write(str(user_dic))
# 
# with open('user.db','r',encoding='utf-8') as f:
#     dic=f.read()
#     print(dic,type(dic))
#     dic=eval(dic)
#     print(dic['name'])
'''
# exec("print('Hello')")            #  exec()执行字符串或complie方法编译过的字符串，没有返回值

6. 帮助函数

dir() , help() , id() , len() , callable()

'''
6、帮助函数
'''
# dir()　　不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表
'''
l=[]
print(dir(l)) #查看一个对象下面的属性
'''
# help()　　返回对象的帮助文档
'''
print(help(l))
'''
# id()　　返回对象的内存地址
'''
# x=1
# y=x
# print(id(x),id(y))
#
# print(x is y) #判断的是身份
'''
# len()　　返回对象长度，参数可以是序列类型（字符串，元组或列表）或映射类型（如字典）
# callable()　　判断对象是否可以被调用，能被调用的对象就是一个callables对象，比如函数和带有__call__()的实例
'''
def func():
    pass
print(callable(func))
'''

7. 作用域查看函数

globals() , locals() , vars()

# globals()　　返回一个描述当前全局变量的字典
# locals()　　打印当前可用的局部变量的字典
# vars()  # 1. 当函数不接收参数时，其功能和locals函数一样，返回当前作用域内的局部变量。
          # 2. 当函数接收一个参数时，参数可以是模块、类、类实例，或者定义了__dict__属性的对象。

8. 迭代器函数

iter() , next() , enumerate() , range()
python3中这几个函数会生成一个迭代器

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

2 # next()　　返回一个可迭代数据结构（如列表）中的下一项
3 # enumerate()　　# 返回一个可以枚举的对象，该对象的next()方法将返回一个元组
4 # x=range(10)
5 # enumerate([1,2,3]).__next__()
6 # range()　　根据需要生成一个指定范围的数字，可以提供你需要的控制来迭代指定的次数

9. 其他函数

hash() , filter() , format() , input() , open() , print() , zip() , map() , import

1 #hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
>>>hash('test')            # 字符串
2314058222102390712

2 #filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
语法：filter(function, iterable)
    function -- 判断函数。
    iterable -- 可迭代对象。
    
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
for i in new_list:
    print(i)
# 输出：
<filter object at 0x00F3C490>
1
3
5
7
9
```
```
3 # format()　　#格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法

"I am {0}, I like {1}!".format("wang", "moon")
"I am {}, I like {}!".format("wang", "moon")
"I am {name}, I like {msg}!".format(name = "wang", msg ="moon")
```
```
4 # input()　　   # 获取用户输入内容
5 # open()　　    # 打开文件
6 # print()　　   # 输出函数
```
```
7 # zip()　　拉链函数将对象逐一配对
s='helloo'
l=[1,2,3,4,5]

z=zip(s,l)
print(z)
for i in z:
    print(i)
```
```
8 # __import__
# import time
# m=__import__('time') #以字符串的形式导入模块
# m.sleep(3000)
```
```
9 # map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
语法：
map(function, iterable, ...)
参数：
function -- 函数，有两个参数
iterable --  一个或多个序列

实例：
>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
 
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
```

#### 10. 面向对象使用的函数
super(), isinstance(), issubclass(), classmethod(), staticmethod(), proerty(), delatter(), hasattr(), getattr(), setattr()

```
#super()　　调用父类的方法

# isinstance()　　检查对象是否是类的对象，返回True或False
# issubclass()　　检查一个类是否是另一个类的子类。返回True或False


# classmethod()　　# 用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行雷的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法
# staticmethod
# property

# delattr()　　# 删除对象的属性
# hasattr
'''
hasattr(object，name)
判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object，name)）是否抛出异常来实现的。
参数object：对象
参数name：特性名称
>>> hasattr(list, 'append')
True
>>> hasattr(list, 'add')
False
'''
#getattr()　　获取对象的属性
#setattr()　　与getattr()相对应
```