python（16）- python内置函数

python内置了一系列的常用函数，以便于我们使用，python英文官方文档详细说明：https://docs.python.org/3/library/functions.html

		Built-in Functions
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

1. abs()　　获取绝对值

abs(-10)
--->10 

abs(10)
--->10

abs(0)
--->0

a = -10
a.__abs__()
--->10

　　

2. all()　　参数为可迭代对象，迭代对象为空时，返回True.如果迭代对象的所有元素都为真，那么返回True，否则返回False.

all(['python',123])
--->True

all([])
--->True

all([0])
--->False

all(" ")
--->True

all(1,' ',2,None)
--->False

3.any()  参数为可迭代对象，参数为空时返回True

print(any([None,0,' ',{},1]))
--->True

print(any(' '))
--->True

　　

4.sum()  求和

res=sum(i for i in range(5))  #(i for i in range(5))为生成器表达式
print(res)
--->12

5.bin()  将参数转化为二进制

print(bin(3))
--->0b11

6.bool()   布尔函数，返回bool值，False或True

print(bool(0))
--->False

print(bool(None))
--->False

print(bool(' '))
--->False

7. ascii()　　调用对象的__repr__()方法，获得该方法的返回值.

8.bytes()  将一个字符串转化为字节类型

print(bytes('hello',encoding='utf8'))
--->b'hello'

s = 'python'
print(bytes(s, encoding='utf-8'))
--->b'python'

a = '王'
print(bytes(a, encoding='utf-8'))
--->b'\xe7\x8e\x8b'

9.str()　　将字符类型/数值类型等转换为字符串类型

print(str(b'\xe7\x8e\x8b', encoding='utf-8'))  # 字节转换为字符串
--->'王'

str(1)   # 整数转换为字符串
--->'1'

10.chr()   查看十进制数对应的ASCII字符

print(chr(67))
--->C

print(chr(65))
--->A

11.ord()   查看某个ASCII对应的十进制数

print(ord('A'))
--->65

12.callabe()   判断对象是否可以被调用，能被调用的对象就是一个callables对象，比如函数和带有__call__()的实例

def test():
    pass
print(callable(test))
--->True

print(callable(sum))
--->True

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

class Province:
    country = "中国"

    def __init__(self, name):
        self.name = name

    @classmethod
    def show(cls):  # 类方法，由类调用，最少要有一个参数cls，调用的时候这个参数不用传值，自动将类名赋值给cls
        print(cls)

# 调用方法
Province.show()

14.complie()　　将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译

1 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
2 将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。
3 参数source：字符串或者AST（abstract syntax trees）对象。
4 参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
5 参数model：指定编译代码的种类。可以指定'exec', 'eval', 'single'。
6 参数flag和dont_inherit：这两个参数为可选参数。

　　

s  = "print('helloworld')"
print(compile(s, "<string>", "exec"))
---><code object <module> at 0x000001C648038390, file "<string>", line 1>

15.complex()　　

1 创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数是字符串，则不需要指定第二个参数。
2 参数real：int，long，float或字符串。
3 参数imag：int，long，float。

x=complex(1-2j)
print(x.real)
--->1.0

print(x.imag)
--->2.0

16. delattr()　　删除对象的属性　　

17.int()  #数据类型，整型

int
num=1 #num=int(1)
print(type(num)) #查看num的类型
---> <class 'int'>

print(isinstance(num,int)) #判断num是否为int类型

print(num is 1) #is 是身份运算，根据id去判断身份

18. float()　　讲一个字符串或整数转换为浮点数

print(float())
--->0.0

print(float('123'))
--->123.0

print(float(1))
--->1.0

print(float('a'))

Traceback (most recent call last):
  File "<pyshell#45>", line 1, in <module>
    float('a')
ValueError: could not convert string to float: 'a'

19.list()  参数为可迭代对象

list
x=[]
x=list(i for i in range(10))  #生成器表达式，以元组的形式呈现
print(x)
--->[0,1,2,3,4,5,6,7,8,9]

列表构造函数
list([iterable])
list的构造函数。参数iterable是可选的，它可以是序列，支持编译的容器对象，或iterator对象。
该函数创建一个元素值，顺序与参数iterable一致的列表。如果参数iterable是一个列表，将创建
列表的一个拷贝并返回，就像语句iterables[:]。　　

20.tuple() 元组

21.dict()   创建数据字典

d={'a':1}
d=dict(x=1,y=2,z=3)
print(d)
--->{'y':2,'x':1,'z':3}

print(dict()) 空字典
--->{}

print(dict(one = 1, two =2))
--->{'one': 1, 'two': 2}

print(dict({'one':1 ,'two':2}))
--->{'one': 1, 'two': 2}

22.set()  集合

s={1,2,3,4,4}
print(s)
--->{1,2,3,4}

s.add(5)
print(s)
--->{1,2,3,4,5}

23.frozenset()   不可变集合

frozenset([iterable])
set和frozenset最本质的区别是前者是可变的，后者是不可变的。当集合对象会被改变时（例如删除，添加元素），只能使用set，
一般来说使用fronzet的地方都可以使用set。
参数iterable：可迭代对象。
f=frozenset({1,2,3,4})
print(type(f))
---> <class 'frozenset'>   

24.dir()　　不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表

print(dir())
--->['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'li', 'li1', 'li2', 'li_1'] >>> dir(list) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__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']

print(dir(sum))  #输出sum下有哪些可被sum调用的方法。（对象.方法），sum.方法

25.divmod()　　分别取商和余数.二个参数x和y，输出元组（x//y,x%y）

print(divmod(100,33))
--->(3,1)

26. enumerate()　　返回一个可以枚举的对象，该对象的next()方法将返回一个元组　

for i in enumerate(['a','b','c','d']):
    print(i)
--->(0, 'a')
    (1, 'b')
    (2, 'c')
    (3, 'd')
    (0, 'x')
    (1, 'y')

for i in enumerate({'x':1,'y':2}):
    print(i)
---->(0, 'x')
     (1, 'y')

27.eval()　　将字符串str中的表达式提取出来并运行

s = "1+2*3"
print(type(s))
---> <class 'str'>

print(eval(s))
---> 7

28.exec()　　执行字符串或complie方法编译过的字符串，没有返回值

29.filter()　　过滤器，构造一个序列，等价于[ item for item in iterables if function(item)]，在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据

filter(function, iterable)
参数function：返回值为True或False的函数，可以为None。
参数iterable：序列或可迭代对象。
def bigerthan5(x):
    return x > 5
print(filter(bigerthan5, [3, 4, 5, 6, 7, 8]))
---> [6, 7, 8]

30.format()　　格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法

print("I am {0}, I like {1}!".format("xu", "moon"))
--->'I am xu, I like moon!'

31.getattr()　　获取对象的属性

getattr(object, name [, defalut])
获取对象object名为name的特性，如果object不包含名为name的特性，将会抛出AttributeError异常；如果不包含名为name的特性
且提供default参数，将返回default。
参数object：对象
参数name：对象的特性名
参数default：缺省返回值

print(getattr(list, 'append'))
---> <method 'append' of 'list' objects>

mylist = [3, 4, 5]
append(mylist, 6)
print(mylist)
--->[3, 4, 5, 6]

print(getattr(list, 'add'))
--->Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'list' has no attribute 'add'

print(getattr(list, 'add', 'NoMethod'))
---> 'NoMethod'

32.globals()　　返回一个描述当前全局变量的字典

a = 1
print(globals())
---> {'__loader__': <class '_frozen_importlib.BuiltinImporter'>, 'a': 1, '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__name__': '__main__', '__package__': None, '__spec__': None}

33.hasattr()

hasattr(object，name)
判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object，name)）是否抛出异常来实现的。
参数object：对象
参数name：特性名称

print(hasattr(list, 'append'))
---> True

print(hasattr(list, 'add'))
---> False

34.hash()　　哈希值

hash(object)
hash是一种算法，二个数值相等hash值是确定的唯一的，常用来校验数据。
hash值不能逆推。
如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数，在字典查找中，哈希值用于快递比价字典的键。
两个数值如果相等，则哈希值也相等。

35.hex()   十进制转化为十六进制

print(hex(10))
---> 0xa

36. id()  查看唯一标识的身份

37. help()　　返回对象的帮助文档

38. input()　　获取用户输入内容

39. isinstance()　　检查对象是否是类的对象，返回True或False

isinstance(obj, cls)
检查obj是否是类cls的对象, 返回True 或 False
class Foo(object):
     pass
obj = Foo()
isinstance(obj, Foo)

40. issubclass()　　检查一个类是否是另一个类的子类。返回True或False

issubclass(sub, super)
检查sub类是否是super类的派生类（子类）。返回True 或 False

class Foo(object):
    pass

class Bar(Foo):
    pass

issubclass(Bar, Foo)

41. iter()

iter(o[, sentinel])
返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。
如果没有提供第二个参数，参数o必须是一个集合对象，支持遍历功能（__iter__()方法）或支持序列功能（__getitem__()方法），
参数为整数，从零开始。如果不支持这两种功能，将触发TypeError异常。
如果提供了第二个参数，参数o必须是一个可调用对象。在这种情况下创建一个iterator对象，每次调用iterator的next()方法来无
参数的调用o，如果返回值等于参数sentinel，触发StopIteration异常，否则将返回该值。

42. len()　　返回对象长度，参数可以是序列类型（字符串，元组或列表）或映射类型（如字典）

43.  locals()　　打印当前可用的局部变量的字典

不要修改locals()返回的字典中的内容；改变可能不会影响解析器对局部变量的使用。
在函数体内调用locals()，返回的是自由变量。修改自由变量不会影响解析器对变量的使用。
不能在类区域内返回自由变量。

44. lambda匿名函数

因为lambda函数没有函数名，引用计数为0，内存会被清理，所有匿名函数常与内置函数一起使用。

求出工资最高的
salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
def get_value(k):
    return salaries[k]
print(max(salaries))
---->yuanhao

print(max(salaries,key=get_value))  #迭代输出key,调用get_value函数，参数为key,得到每个人工资， max再进行比较工资，打印最大的人名key值
 --->alex   

使用匿名函数求出工资最高的
f=lambda k:salaries[k]  #匿名函数不写函数名，返回值为salaries[k]
print(f)  #f 相当于函数名
-----> <function <lambda> at 0x0000000002823A60>

print(f('egon'))
---->3000

print(max(salaries,key=lambda k:salaries[k]))   #求出最高工资的人
---->alex

print(min(salaries,key=lambda k:salaries[k]))   #求出最低工资的人
---->yuanhao

45. zip()     ‘拉链’，一对一的

l1=[1,2,3]
s="hel"
for i in zip(l1,s):   #zip(l1,s)为可迭代的
    print(i)
---->(1, 'h')
     (2, 'e')
     (3, 'l')

l1=[1,2,3,4],s不变，输出结果也同上；l1不变，s="hell",输出结果也同上。
因为zip()函数为一一对应的

用zip函数求最高工资的人
salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
print(salaries.keys(),salaries.values())#dict_keys(['egon', 'alex', 'wupeiqi', 'yuanhao']) dict_values([3000, 1000000, 10000, 2500])
z=zip(salaries.keys(),salaries.values())
print(z)
----> <zip object at 0x00000000027F3C08>

for i in z:
    print(i)  ---->('egon', 3000)
                   ('alex', 1000000)
                   ('wupeiqi', 10000)
                   ('yuanhao', 2500)

z=zip(salaries.values(),salaries.keys())  #工资value和人名key互换位置
print(max(z))
---->(1000000, 'alex')

z=zip(salaries.values(),salaries.keys())   #因为已经迭代完成了，所以要重新迭代
print(min(z))
---->(2500, 'yuanhao')

46.　sorted()    返回列表，列表包含所有的元素，按升序排列

l=[3,4,1,0,9,10]
print(sorted(l))
---->[0, 1, 3, 4, 9, 10]

s="hello abc"
print(sorted(s))
----->[' ', 'a', 'b', 'c', 'e', 'h', 'l', 'l', 'o']

#降序 reverse 反转
print(sorted(l,reverse=True))
---->[10, 9, 4, 3, 1, 0]

salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
print(sorted(salaries)) #默认是按照字典salaries的key去排序的
----->['alex', 'egon', 'wupeiqi', 'yuanhao']

排序且修改
l=[3,2,0,10]
l=sorted(l)
print(l)
--->[0, 2, 3, 10]

47. map()       映射，第一个参数为函数，第二个参数为可迭代对象

l=[1,2,3,4,7,5]
x=[i**2 for i in l]
print(x)
---->[1, 4, 9, 16, 49, 25]

#上述用map函数实现
#迭代取l 的值，传递给lamba函数
m=map(lambda item:item**2,l)
print(m)
----><map object at 0x00000000021DC3C8>

for i in m:
    print(i)
--->1    4    9    16    49    25

for 循环也可用print(list(m))来实现，不过要重新迭代
m=map(lambda item:item**2,l)
print(list(m))  
---->[1, 4, 9, 16, 49, 25]

map(function, iterable,...)
对于参数iterable中的每个元素都应用fuction函数，并将结果作为列表返回。
如果有多个iterable参数，那么fuction函数必须接收多个参数，这些iterable中相同索引处的元素将并行的作为function函数的参数。
如果一个iterable中元素的个数比其他少，那么将用None来扩展改iterable使元素个数一致。
如果有多个iterable且function为None，map()将返回由元组组成的列表，每个元组包含所有iterable中对应索引处值。
参数iterable必须是一个序列或任何可遍历对象，函数返回的往往是一个列表(list)。

li = [1,2,3]
data = map(lambda x :x*100,li)
print(type(data))
data = list(data)
print(data)

运行结果：

<class 'map'>
[100, 200, 300]

48.max()　　返回给定元素里最大值　

max(iterable [,args...][, key])
如果只提供iterable参数，函数返回可遍历对象（如：字符串，元组或列表）中最大的非空元素。
如果提供多个参数，那么返回值最大的那个参数。
可选参数key是单参数的排序函数。
如果提供key参数，必须是以命名的形式，如：max(a, b, c, key = fun)

49.min()　　返回给定元素里最小值

min(iterable [,args...][, key])
如果只提供iterable参数，函数返回可遍历对象（如：字符串，元组或列表）中最小的非空元素。
如果提供多个参数，那么返回值最小的那个参数。
可选参数key是单参数的排序函数。
如果提供key参数，必须是以命名的形式，如：max(a, b, c, key = fun)

50.object()

1 获取一个新的，无特性(geatureless)对象。Object是所有类的基类。它提供的方法将在所有的类型实例中共享。
2 该函数时2.2.版本新增，2.3版本之后，该函数不接受任何参数。

51.open()　　打开文件

open(filename [, mode [, bufsize]])
打开一个文件，返回一个file对象。 如果文件无法打开，将处罚IOError异常。
应该使用open()来代替直接使用file类型的构造函数打开文件。
参数filename表示将要被打开的文件的路径字符串；
参数mode表示打开的模式，最常用的模式有：'r'表示读文本，'w'表示写文本文件，'a'表示在文件中追加。
Mode的默认值是'r'。
当操作的是二进制文件时，只要在模式值上添加'b'。这样提高了程序的可移植性。
可选参数bufsize定义了文件缓冲区的大小。0表示不缓冲；1表示行缓冲；任何其他正数表示使用该大小的缓冲区；
负数表示使用系统默认缓冲区大小，对于tty设备它往往是行缓冲，而对于其他文件往往完全缓冲。如果参数值被省却。
使用系统默认值。

52.print()　　输出函数

python2中的print语句被python3中的print()函数取代。
如何限制print的默认换行：
    1. python2版本下，在print输出的最后加一个逗号','
    2. python3.4以后，print(value, ...,sep='',end='\n',file=sys.stdout,flush=False),将end设为空即可。

53.range()　　根据需要生成一个指定范围的数字，可以提供你需要的控制来迭代指定的次数

用于创建包含连续算术值的列表(list)。常用于for循环。参数必须是普通整数。
参数step默认值为1，参数start的默认值为0。
全参数调用该函数将返回一个普通整数列表。
step 可以是正整数或者负整数。不可以为0，否则将处罚ValueError异常。
range(3)代表0,1,2.等价于range(0,3)
print(range(0,10,2)) #第一个参数是起始数，第二个是终止数(不包含这个)，第三个数步数
---->[0,2,4,6,8]

55. repr()　　将任意值转换为字符串，供计时器读取的形式

返回一个对象的字符串表示。有时可以使用这个函数来访问操作。
对于许多类型来说，repr()尝试返回一个字符串，eval()方法可以使用该字符串产生对象；
否则用尖括号括起来的，包含类名称和其他二外信息的字符串被返回。

56.reversed()　　　反转，逆序对象，反着排序。

 返回一个逆序的iterator对象。参数seq必须是一个包含__reversed__()方法的对象或支持序列操作(__len__()和__getitem__())
该函数是2.4中新增的

print(list(reversed([1,3,5,9])))
----->[9,5,3,1]

57.round()　　四舍六入五留双，五留双留离整数最近的偶数

print(round(10.3))
----> 10

print(round(10.5))
----> 10

print(round(10.6))
----> 11

print(round(10.9))
----> 11

print(round(11.5))
----> 12

　　

58.pow()　　幂函数

print(pow(3,2))   #3**2
---->9

print(pow(3,2,2))   #3**2%2
---->1

59. reduce()         合并，第一个参数为函数，第二个参数为可迭代对象。第三个参数可有可无，默认初始值。

from functools import reduce #合并
l=list(range(100))
print(l)
---->[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

print(reduce(lambda x,y:x+y,l,100))
i=iter(l)
# 100 next(i) --->100,0----->x,y-x+y-->100
# 100 next(i)---->100,1----->x,y--x+y-->101
# 101 next(i)----->101,2
---->5050

60. filter    过滤

name_l=[
    {'name':'egon','age':18},
    {'name':'dragonFire','age':1000},
    {'name':'gaoluchuan','age':9000},
    {'name':'fsw','age':10000},
]

f=filter(lambda d:d['age'] > 100,name_l)
print(f)
-----><filter object at 0x00000000027DCCF8>

print(list(f))   #与map函数不同的是其返还的是查询的内容
---->[{'name': 'dragonFire', 'age': 1000},{'name': 'gaoluchuan', 'age': 9000},{'name': 'fsw', 'age': 10000}]

for i in f: print(i)
---->{'name': 'dragonFire', 'age': 1000}
 　　 {'name': 'gaoluchuan', 'age': 9000}
 　　 {'name': 'fsw', 'age': 10000}

　　

61.oct()   十进制转化为八进制

print(oct(10))
---->0o12

62.slice  切片

l=[1,2,3,4,5]
print(l[2:4])
--->[3,4]

s=slice(2,4)
print(l[s])
---->[3,4]

63. vars    没有参数时和locals()一样，有参数得到字典

64. __import__

import time
#print(time)  ----><module 'time' (built-in)>
time.sleep(3)
上述代码等价于下面代码内容
m=__import__('time')
#print(m)  ----><module 'time' (built-in)>
m.sleep(3)