python内置函数总结---考试小抄版

总结自菜鸟教程：https://www.runoob.com/python/python-built-in-functions.html

abs(): 返回数字的绝对值，若参数为复数，则返回复数的绝对值（此复数与它的共轭复数的乘积的平方根）????。

abs(1+1j)
1.4142135623730951

all()：用于判断可迭代参数 iterable 中的所有元素是否都为 TRUE，即不能有( 0、空、None、False) ，如果是返回 True，否则返回 False。

all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0 True
all(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素 False
all([0, 1，2, 3])          # 列表list，存在一个为0的元素 False
   
all(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0 True
all(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素 False
all((0, 1, 2, 3))          # 元组tuple，存在一个为0的元素 False
# 注意
all([])             # 空列表 True
all(())             # 空元组 True

any()： 用于判断可迭代参数 iterable 中的所有元素是否有 TRUE，即除了( 0、空、None、False) 之外，还有别的元素，如果有返回 True，否则返回 False。

>>> any(['a', 0, '', False])  # 列表list中存在0、空、FALSE 之外的东西
>>> any([]) # 空列表  False
>>> any(()) # 空元组  False

bin()： 返回一个整数 int 或者长整数 long int 的二进制表示的字符串。

bin(10)
'0b1010'

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

>>> bool(0)
False

bytearray() ：方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。不知道有啥用

>>> bytearray([1,2,3])
bytearray(b'\x01\x02\x03')

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

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

lass 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

chr()： 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

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

类方法 @classmethod

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

class 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()

输出

func2
<class '__main__.A'>
类属性
func1
<__main__.A object at 0x7f7f7113c710>
func3
类属性

cmp(x,y): 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

cmp(80, 100) :  -1

compile() :函数将一个字符串编译为字节代码。

str = "for i in range(0,3): print(i)"
c = compile(str,'','exec')   # 编译为字节代码对象
print(c)
print(exec(c))

str = "3 * 4 + 5"
a = compile(str,'','eval')
print(eval(a))

输出

<code object <module> at 0x7f03c840c300, file "", line 1>
0
1
2
None
17

complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

complex(1, 2)
(1 + 2j)

delattr： 函数用于删除属性。delattr(x, ‘foobar’) 相等于 del x.foobar。

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}

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']

divmod() ：函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)

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

seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print(i, element)

输出

0 one
1 two
2 three

eval() ：函数用来执行一个字符串表达式，并返回表达式的值。

x = 7
eval( '3 * x' )
21
eval('pow(2,2)')
4

execfile() ：函数可以用来执行一个文件。

execfile('hello.py')
hello

file()： 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。

f = file('hello.py')
f.read()
print('hello')

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)

float()： 函数用于将整数和字符串转换成浮点数。

float(1024)
1024.0

format()：基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。

"{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

frozenset()： 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

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

class A(object):
    def set(self, a, b):
        x = a
        a = b
        b = x
        print(a, b)


a = A()
c = getattr(a, 'set')  # 等价于c = a.set
print(a)
print(c)
c(a='1', b='2')

globals()： 函数会以字典类型返回当前位置的全部全局变量。
globals 函数返回一个全局变量的字典，包括所有导入的变量。
想起来一个关键字 global

name = "小明"
def test():
    global name # 把外面的拿过来
    print(name)
    name = "along"
    return name

if __name__ == "__main__":
    print(name)
    print(test())
    print(name)

输出

小明
小明
along
along

hasattr() ：函数用于判断对象是否包含对应的属性

class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
print(hasattr(point1, 'x'))  
print(hasattr(point1, 'no'))  # 没有该属性
True
False 

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

hash('test')            # 字符串
2314058222102390712

help()： 函数用于查看函数或模块用途的详细说明。

help('sys')             # 查看 sys 模块的帮助
……显示帮助信息……

hex()： 函数用于将10进制整数转换成16进制，以字符串形式表示。

hex(255)
'0xff'

id()： 函数返回对象的唯一标识符，标识符是一个整数。

CPython 中 id() 函数用于获取对象的内存地址。

a = 'runoob'
>>> id(a)
4531887632

input：函数接受一个标准输入数据，返回为 string 类型。

a = input("input:")
a = int(a)
输入：
input:123 
#注意
数字接收后需要转换一下，防止报错

int() ：函数用于将一个字符串或数字转换为整型。

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

评论中

怒写一波：
int(x,base)
x 有两种：str / int
1、若 x 为纯数字，则不能有 base 参数，否则报错；其作用为对入参 x 取整
>>> int(3.1415926)
3
>>> int(-11.123)
-11
>>> int(2.5,10)
#报错
>>> int(2.5)
2
2、若 x 为 str，则 base 可略可有。
base 存在时，视 x 为 base 类型数字，并将其转换为 10 进制数字。
若 x 不符合 base 规则，则报错。如:
>>>int("9",2)  #报错，因为2进制无9
>>> int("9")
9 
#默认10进制
>>> int("3.14",8)
>>> int("1.2")
#均报错，str须为整数
>>>int("1001",2)
9
# "1001"才是2进制格式，并转化为十进制数字9
>>> int("0xa",16)
10
# ≥16进制才会允许入参为a,b,c...
>>> int("b",8) #报错
>>> int("123",8)
83
#视123为8进制数字，对应的10进制为83

isinstance() ：函数来判断一个对象是否是一个已知的类型，类似 type()。
对于基本类型来说 classinfo 可以是：int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple

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

issubclass() ：方法用于判断参数 class 是否是类型参数 classinfo 的子类。

class A:
    pass
class B(A):
    pass 
print(issubclass(B,A))     # 返回 True

iter() ：函数用来生成迭代器。
这个例子不好，因为list本身就可以for出来

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

输出

<class 'list_iterator'>
1
2
3

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

str = "runoob"
len(str)   
6

list()： 用于将元组转换为列表。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中

strs="python"
list_str = list(strs)
print(list_str )

输出

['p', 'y', 't', 'h', 'o', 'n']

下面是字典

dicts = dict(zip(["a", "b", "c"],["e", "f", "g"]))
dicts = list(dicts)
print(dicts)
['a', 'b', 'c']

locals() ：函数会以字典类型返回当前位置的全部局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。

def runoob(arg):    # 两个局部变量：arg、z
    z = 1
    print (locals())
 
runoob(4)
{'z': 1, 'arg': 4}      # 返回一个名字/值对的字典

long() ：函数将数字或字符串转换为一个长整型。

long(123)
123L

map() ：会根据提供的函数对指定序列做映射。

def square(x) :            # 计算平方数
    return x ** 2

>>> map(square, [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]

max() ：方法返回给定参数的最大值，参数可以为序列。

max(80, 100, 1000)
1000

min()： 方法返回给定参数的最小值，参数可以为序列。

min(80, 100, 1000)
80

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

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

结果

1 2 3

评论
如果传入第二个参数, 获取最后一个元素之后, 下一次next返回该默认值, 而不会抛出 StopIteration:

it = iter([1, 2, 3])
while True:
    x = next(it, 'a')
    print(x)
    if x == 'a':
        break

oct() ：函数将一个整数转换成 8 进制字符串。

oct(10)
'012'

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

file_name = str(file_path.rsplit('/', 1)[1]) # 拿到的是文件名
f = open(file_path, 'rb') # 文件名打开
response = FileResponse(f)  # 文件响应

还需要详细写

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

ord('a')
97

pow() 方法返回 xy（x 的 y 次方） 的值。

math.pow(2, 4) :  16.0

@property
廖雪峰的python

class Student(object):

    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        if not isinstance(value, int):
            raise ValueError('birth must be an integer!')
        if value < 0 or value > 2020:
            raise ValueError('birth must between 0 ~ 2020!')
        self._birth = value
      
    @property
    def age(self):
        return 2020 - self._birth
 
 along = Stuent()
 along.birth = 2000
 print(along.birth)
 print(along.age)

输出

2000
20

range()： 函数可创建一个整数列表，一般用在 for 循环中。

range(3)
[0, 1, 2]

raw_input() ：将所有输入作为字符串看待，返回字符串类型。
reduce() ：函数会对参数序列中元素进行累积。

reduce(lambda x, y: x+y, [1,2,3,4,5]) 
15

评论：reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 functools 模块里

from functools import reduce

reload()： 用于重新载入之前载入的模块。
Python 3.0 把 reload 内置函数移到了 imp 标准库模块中。它仍然像以前一样重载文件，但是，必须导入它才能使用。

from imp import reload
reload(module)

repr() ：函数将对象转化为供解释器读取的形式。现在看来就是加双引号

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

reverse()： 函数用于反向列表中元素。

aList = [123, 'xyz', 'zara']
aList.reverse()
['zara', 'xyz', 123]

round() ：方法返回浮点数x的四舍五入值。

round(80.23456, 2) # 小数点后两位
80.23 

评论

在实际使用中发现round函数并不总是如上所说的四舍五入。如：
In [14]: round(2.355, 2)
Out[14]: 2.35
注：环境为 python3.5.2
因为该函数对于返回的浮点数并不是按照四舍五入的规则来计算，而会受到计算机表示精度的影响。
关于该问题搜索后解释比较清楚的文章地址如下：http://www.runoob.com/w3cnote/python-round-func-note.html

set()： 集合函数

x = set('along')
y = set('google')
x = set(x)  # 重复的被删除
y = set(y)
print(x)
print(y)
print(x & y)         # 交集
print(x | y)         # 并集
print(x - y)         # 差集

输出

{'g', 'n', 'a', 'l', 'o'}
{'l', 'e', 'o', 'g'}
{'l', 'o', 'g'}
{'a', 'l', 'o', 'e', 'g', 'n'}
{'n', 'a'}

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

class Student():
    name = "along"
along = Student()
getattr(along, "name")
print(along.name)
setattr(along, "name", "xiefan")
print(along.name)
# 设置一个没有的属性
setattr(along, "age", 18)
print(along.age)

输出

along
xiefan
18

slice() ：函数实现切片对象，主要用在切片操作函数里的参数传递。
不好用，直接切片就行

myslice = slice(5)    # 设置截取5个元素的切片
arr = list(range(10))
print(arr[myslice])         # 截取 5 个元素
print(arr[:3])         # 截取 3 个元素

输出

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4]
[0, 1, 2]

sorted() 函数对所有可迭代的对象进行排序操作。list 的 sort 方法在原有的列表上进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

L = [('b', 3), ('a', 1), ('c', 2), ('d', 4)]
l = sorted(L, key=lambda x: x[1], reverse=True)  # 利用key, 按降序
print(l)

输出

('d', 4), ('b', 3), ('c', 2), ('a', 1)]

评论：
key 和 reverse 比一个等价的 cmp 函数处理速度要快。这是因为对于每个列表元素，cmp 都会被调用多次，而 key 和 reverse 只被调用一次，所以不用cmp

@staticmethod： 返回函数的静态方法。

该方法不强制要求传递参数，如下声明一个静态方法：

class Student(object):
    @staticmethod
    def f(name: str, age: int):
        print('along is {}'.format(name))
        print('age is {}'.format(age))


Student.f("along", 20)  # 静态方法无需实例化
stu = Student()
stu.f("alonglong", 21)  # 也可以实例化后调用

输出

along is along
age is 20
along is alonglong
age is 21

str()： 函数将对象转化为字符串。

num = 123
s = str(num)
print(type(s))

输出

<class 'str'>

sum()： 方法对序列进行求和计算。

sum([1, 2, 3])
6

评论 涉及到了numpy，单独写

import numpy as np
a = np.array([[1,2],[3,4]])
# 按行相加，并且保持其二维特性
print(np.sum(a, axis=1, keepdims=True))
# 按行相加，不保持其二维特性
print(np.sum(a, axis=1))

输出

array([[3], [7]])
array([3, 7])

super()：函数是用于调用父类(超类)的一个方法。

class A:
    def add(self, x):
        y = x + 1
        print(y)

class B(A):
    def add(self, x):
        print(x * 2)  # 前后都可添加代码
        super().add(x)
        print(x * 3)
b = B()
b.add(2)

输出

4
3
6

tuple()：元组函数将列表转换为元组。

tuple([1,2,3,4])
(1, 2, 3, 4)

type()： 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

type(1)
<type 'int'>

unichr() ：函数 和 chr() 函数功能基本一样， 只不过是返回 unicode 的字符。（python3 没有）

unichr(99)
u'c'

zip() ：拉链

a = [1,2,3]
b = [4,5,6]
zippo = zip(a,b)  
print(zippo)

输出

打火机

** _ _ feature _ _ **

from __future__ import division, print_function, absolute_import
如果你的python版本是python2.X，你也可以按照python3.X那样使用这些函数

愿你我都站上巨人的肩膀