Python内置函数用法详解

#### 按字母顺序
# #1 abs()
取绝对值
# #2 all()
用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

元素除了是 0、空、None、False 外都算 True。
函数源码：
```
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
```
用法：
```
>>> all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True

>>> all((0, 1, 2, 3))          # 元组tuple，存在一个为0的元素
False
```
# #3 any()
用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。

元素除了是 0、空、FALSE 外都算 TRUE。
函数源码:
```
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False
```
用法：

```
>>>any(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True

>>> any((0, '', False))        # 元组tuple，元素全为0,'',false
False
```

### 注意：all()是全为真时才返回真，any()全为假时才返回假

# #4 bin()
bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
```
bin(10)
Out[4]: '0b1010'
```

# #5 bool()
bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。

bool 是 int 的子类。

```
bool(1)
Out[5]: True
bool()
Out[6]: False
issubclass(bool,int)
Out[7]: True
```
# #6 bytearray()
bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

```
bytearray()
Out[9]: bytearray(b'')
bytearray([1,2,3])
Out[10]: bytearray(b'\x01\x02\x03')
bytearray('ron','utf-8')
Out[11]: bytearray(b'ron')
```
# #7 callabe()

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

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

```
>>>callable(0)
False
>>> callable("runoob")
False
 
>>> 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
```
# #8 chr()
chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
返回返回值是当前整数对应的 ASCII 字符
```
>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a
```

# #9 classmethod

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

    # 属性默认为类属性（可以给直接被类本身调用）
    num = "类属性"

    # 实例化方法（必须实例化类之后才能被调用）
    def func1(self): # self : 表示实例化类后的地址id
        print("func1")
        print(self)

    # 类方法（不需要实例化类就可以被类本身调用）
    @classmethod
    def func2(cls):  # cls : 表示没用被实例化的类本身
        print("func2")
        print(cls)
        print(cls.num)
        cls().func1()

    # 不传递传递默认self参数的方法（该方法也是可以直接被类调用的，但是这样做不标准）
    def func3():
        print("func3")
        print(A.num) # 属性是可以直接用类本身调用的
    
# A.func1() 这样调用是会报错：因为func1()调用时需要默认传递实例化类后的地址id参数，如果不实例化类是无法调用的
A.func2()
A.func3()
```

# #10 cmp()函数 compare

cmp(x,y) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
py3没有这个模块
实现比较功能，引入operator模块
```
>>> import operator
>>> operator.eq('hello', 'name');
False
>>> operator.eq('hello', 'hello');
True
```
# #11 compile()
compile() 函数将一个字符串编译为字节代码。个人理解，相当于写好一个函数，用于其调用

```
co = compile("for i in range(10): print(i, end=' ')", '', 'exec')
exec(co)

print('\n')

so = compile("sum([1,5,3,6,8])",'','eval')
sol = eval(so)
print(sol)
```
# #12 complex() 返回一个复数
```
complex('1+2j')
Out[19]: (1+2j)
# 不能有空格，如‘’1 + 2j
# 不能是i，只能是j
```
# #13 delattr()函数
删除类的属性

```
class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
 
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z)
 
delattr(Coordinate, 'z')
 
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y)
 
# 触发错误
print('z = ',point1.z)
```
# #14 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}
>>> dict1 = {}
>>> dict1['firstname'] = 'ma'
>>> dict1['lastname'] = 'yun' # 添加方式
>>> dict1 = {'firstname':'ma', 'lastname':'yun'} # {}字典的标志大括号方式

```

# #15dir()

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

返回模块的属性列表。
>>>dir()   #  获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ])    # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
# #16 divmod()
返回商和余数
```
divmod(7,2)
Out[22]: (3, 1)
```
# #17 enumerate()
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。返回 enumerate(枚举) 对象。

```
seasons = ['Spring','Summer','Fall','Winter']
for i , j in enumerate(seasons,start=1):
    print(i,j)
```
# #18 eval()
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
```
a = eval('3*7')
print(a)
```
# #19 execfile()
execfile() 函数可以用来执行一个文件。py3删除了，可以用
```
with open('test.py','rb') as f:
    exec(f.read())
```
# #20 file()
py3已经将file改名了，改为了open()
```
f = open('test.txt')
f.read()
```
# #21 filter()

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

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

```
def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
```
# #22 float()
float() 函数用于将整数和字符串转换成浮点数。
```
>>> float(-123.6)
-123.6
>>> float('123')     # 字符串
123.0
```
# #23 format()
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。
### format函数比较重要，实际用法，参照：https://www.runoob.com/python/att-string-format.html
最基本的用法：
```
'{} {}'.format('hello','world')
Out[26]: 'hello world'
```
# #24 frozenset()
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
```
a = frozenset(range(10))
```
# #25 getattr()
getattr() 函数用于返回一个对象属性值。
```
>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> 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
```
# #26 globals()
globals() 函数会以字典类型返回当前位置的全部全局变量。
```
>>>a='runoob'
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
````
# #27 hasattr()
hasattr() 函数用于判断对象是否包含对应的属性。如果对象有该属性返回 True，否则返回 False。
```
point1 = Coordinate() 
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))  # 没有该属性
```

# #28 hash()
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
hash() 函数的用途

hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，也用于校验程序在传输过程中是否被第三方（木马）修改，如果程序（字符）在传输过程中被修改hash值即发生变化，如果没有被修改，则 hash 值和原始的 hash 值吻合，只要验证 hash 值是否匹配即可验证程序是否带木马（病毒）。

hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。

在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。
```
>>>hash('test')            # 字符串
2314058222102390712
>>> hash(1)                 # 数字
1
>>> hash(str([1,2,3]))      # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378
```
# #29 help()
help() 函数用于查看函数或模块用途的详细说明。
```
>>>help('sys')             # 查看 sys 模块的帮助
……显示帮助信息……
 
>>>help('str')             # 查看 str 数据类型的帮助
……显示帮助信息……
 
>>>a = [1,2,3]
>>>help(a)                 # 查看列表 list 帮助信息
……显示帮助信息……
 
>>>help(a.append)          # 显示list的append方法的帮助
……显示帮助信息……
```
# #30 hex()
hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
返回的是字符串形式
```
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
>>> hex(12)
'0xc'
>>> type(hex(12))
<class 'str'>      # 字符串
```
# #31 id() 返回内存地址
id() 函数返回对象的唯一标识符，标识符是一个整数。

CPython 中 id() 函数用于获取对象的内存地址。
```
>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608
```
# #32 input()
Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
# #33 int()
int() 函数用于将一个字符串或数字转换为整型。
# #34 isinstance()
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
```
>>> isinstance (a,int)
True
```
# #35 issubclass()
issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
```
class A:
    pass
class B(A):
    pass
    
print(issubclass(B,A))    # 返回 True
```
# #36 iter()
iter() 函数用来生成迭代器。

````
>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
````
# #37 len()
Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
```
>>>str = "runoob"
>>> len(str)             # 字符串长度
6
```
# #38 list()
list() 方法用于将元组转换为列表。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
```
atuple = (123,3,'dd')
alist = list(atuple)
print('列表元素：',alist)
```
# #39 locals()
locals() 函数会以字典类型返回当前位置的全部局部变量。

对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
```
def run1(arg):
    z = 1
    print(locals())

run1(4)
```
# #40 map()
map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
Python 2.x 返回列表。

Python 3.x 返回迭代器。
````
def add(x,y):
    return x+y

# a = map(add,[1,2,3],[1,2,3])
# for i in a:
#     print(i)

a = map(lambda x,y:x+y,[1,2,3],[1,2,3])
for i in a:
    print(i)
````
# #41 max()
max() 方法返回给定参数的最大值，参数可以为序列。
# #42 memoryview()
memoryview() 函数返回给定参数的内存查看对象(memory view)。

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
不知道有什么用。！！！
# #43 min()
max() 方法返回给定参数的最小值，参数可以为序列。
# #44 next()
next() 返回迭代器的下一个项目。
```
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
        
it = iter([1, 2, 5, 4, 3])
while True:
    x = next(it, 9)
    print(x)
    if x == 9:
        break
```
next() 函数要和生成迭代器的iter() 函数一起使用。
# #45 object()
对象 
# #46 oct()
oct() 函数将一个整数转换成 8 进制字符串。Python3.x 版本的 8 进制以 0o 作为前缀表示。
```
a = oct(10)
print(a)
b = oct(20)
print(b)
```

# #46 ord()  字母输出数值
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
```
>>>ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
```
# #47 pow()
pow() 方法返回 xy（x 的 y 次方） 的值。
```
import math
print(math.pow(2,3))
# 输出8.0
```
# #48 print()
print() 方法用于打印输出，最常见的一个函数。

在 Python3.3 版增加了 flush 关键字参数。
```
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
```
# #49 property() （有点难）
property() 函数的作用是在新式类中返回属性值。

# #50 range()
python range() 函数可创建一个整数列表，一般用在 for 循环中。
```
a = list(range(10))
print(a)
a= list(range(1,10,2))
print(a)
a=list(range(10,1,-2))
print(a)

```

# #51 raw_input()
已经被去除，只有input()输入的均作为字符串
# #52 reduce()
reduce() 函数会对参数序列中元素进行累积。函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

```
>>>def add(x, y) :            # 两数相加
...     return x + y
... 
>>> reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
15
```
# #53 reload()
reload() 用于重新载入之前载入的模块。
```
>>>import sys
>>> sys.getdefaultencoding()            # 当前默认编码
'ascii'
>>> reload(sys)                         # 使用 reload
<module 'sys' (built-in)>
>>> sys.setdefaultencoding('utf8')      # 设置编码
>>> sys.getdefaultencoding()
'utf8'
```
# #54 repr()
repr() 函数将对象转化为供解释器读取的形式。
两者之间的目标不同：
str()主要面向用户，其目的是可读性，返回形式为用户友好性和可读性都较强的字符串类型；
repr()面向的是python解释器，或者说开发人员，其目的是准确性，其返回值表示python解释器内部的含义，常作为编程人员debug用途。

```
s = 'aaa'
repr(s)
Out[32]: "'aaa'"
str(s)
Out[33]: 'aaa'

```
# #55 reverse()
reverse() 函数用于反向列表中元素。

```
alist = [1,2,3,4,5]
alist1 = alist.reverse()
print(alist)
print(alist1) # 表明只是在原列表中反向，而非产生了新的
print(type(alist1))
```
# #56 round()
round() 方法返回浮点数x的四舍五入值。
详见 https://www.runoob.com/w3cnote/python-round-func-note.html
round函数非精确
```
In [14]: round(2.355, 2)
Out[14]: 2.35
```

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

````
aset = set('sdhhh')
bset = set('sdjjj')
print(aset)
print(bset)
c = aset & bset
print(c)
d = aset | bset
print(d)
e = aset - bset
print(e)
````
# #58 setattr()
setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
```
class A(object):
    bar = 1

a =A()
a1 = getattr(a,'bar')
print(a1)
setattr(a,'age',28)
a2 = a.age
print(a2)
```

# #59 slice()
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
```
myslice = slice(6,8,1) # 开始位置6，终止位置8，步长1
print(myslice)
arr = list(range(10))
print(arr)
print(arr[myslice])
```
# #60 sorted()
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
iterable -- 可迭代对象。
cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回重新排序的列表

```
a = [1,23,4,55,123]
b = sorted(a)
print(a)
print(b)

# 进阶
alist = [('b',2),('a',1),('c',3),('d',4)]
print(alist)
print(alist[1])
blist = sorted(alist,key=lambda x:x[1],reverse=True)
print(blist)
```
# #61 staticmethod()
python staticmethod 返回函数的静态方法。

该方法不强制要求传递参数，如下声明一个静态方法：
```
class C(object):
    @staticmethod
    def f():
        print('runoob');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用
```
# #62str()
str() 函数将对象转化为适于人阅读的形式。
```
>>>s = 'RUNOOB'
>>> str(s)
'RUNOOB'
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
```
# #63sum()求和

# #64super()
```
class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)
 
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    fooChild = FooChild()
```
# #65tuple()元组
```
>>>tuple([1,2,3,4])
 
(1, 2, 3, 4)
 
>>> tuple({1:2,3:4})    #针对字典 会返回字典的key组成的tuple
 
(1, 3)
 
>>> tuple((1,2,3,4))    #元组会返回元组自身
 
(1, 2, 3, 4)
```
# #66type()返回类型

# #67unichr()

# #68unicode()

# #69vars()
vars() 函数返回对象object的属性和属性值的字典对象。
# #70xrange()
xrange() 函数用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器。
# #71zip()
```
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]
```
# #72__import__()
__import__() 函数用于动态加载类和函数 。

如果一个模块经常变化就可以使用 __import__() 来动态载入。