python long函数_python 内置函数

查看内置函数：

>>> dir(__builtins__)

min(arg1, arg2, *args, *[, key=func])函数：函数至少传入两个参数，但是有只传入一个参数的例外，此时参数必须为可迭代对象，返回的是可迭代对象中的最小元素。

1 >>> min((11,23,32)) #放入可迭代对象元组

2 11

3 >>> min([5,4,6]) #放入可迭代对象列表

4 4

5 >>> min(8,9,12) #直接放入数字进行比较

6 8

7 >>> min('k','b','c') #直接放入字母进行比较

8 'b'

9 >>> min(9) #最少放一个参数(除可迭代参数外)

10 Traceback (most recent call last):11 File "", line 1, in

12 min(9)13 TypeError: 'int' object is notiterable14 >>>

max(arg1, arg2, *args, *[, key=func]函数：返回最大值。

1 >>> max(3,2,8) #比较数字

2 8

3 >>> max((7,5,6)) #比较可迭代元素，元组

4 7

5 >>> max([9,8,18]) #比较可迭代元素，列表

6 18

7 >>> max('b','k','c') #比较字母

8 'k'

9 >>>

sorted(iterable, /, *, key=None, reverse=False)函数：iterable是可迭代对象；key主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse是排序规则，reverse = True 降序 ， reverse = False 升序(默认)。

>>> sorted([5,1,8,6,12]) #对列表里面的元素进行排序

[1, 5, 6, 8, 12]>>> sorted(['5s','a1s','1','321','grsg'],key=len) #按照元素的字符长短进行排序。

['1', '5s', 'a1s', '321', 'grsg']>>> sorted(['5s','a1s','1','321','grsg'],key=len,reverse=True) #添加了参数reverse=True，从大到小排序

['grsg', 'a1s', '321', '5s', '1']>>>

reversed(sequence)函数：反转一个序列对象，将其元素从后向前颠倒构建成一个新的迭代器。

1 >>> a = reversed([3,6,78,1,2,'a','b','c']) #反转这个列表

2 >>> list(a) #需要使用list函数来查看

3 ['c', 'b', 'a', 2, 1, 78, 6, 3]

sum(iterable, start=0, /)函数：对系列进行求和计算。

1 >>> sum((1,2,3)) #对元组里面的数求和

2 6

3 >>> sum((1,2,3),10) #对元组里面的数求和，从10开始加：10+1+2+3

4 16

5 >>> sum([2,4,6]) #对列表里面的数求和

6 12

7 >>> sum([2,4,6],10) #对列表里面的数求和，从10开始加：10+2+4+6

8 22

9 >>>

进制转换函数：

1 >>> bin(5) #转换为二进制

2 '0b101'

3 >>> oct(16) #转换为八进制

4 '0o20'

5 >>> hex(15) #转换为十六进制

6 '0xf'

7 >>> ord('a') #将字符转化为对应的ASCII码值

8 97

9 >>> ord('A'10 65

11 >>> chr(65) #将ASCII码值转化为对应的字符

12 'A'

13 >>>

enumerate(iterable[, start])函数：在字典上进行枚举、列举，对于一个可迭代的(iterable)/可遍历的对象，enumerate将其组成一个索引序列，利用它可以同时获得索引和值。enumerate多用于for循环中得到计数。

1 >>> enumerate(['a','b','c']) #枚举对象，返回函数体

2

3 >>> list(enumerate(['a','b','c'])) #使用list()查看结果，返回有索引的参数

4 [(0, 'a'), (1, 'b'), (2, 'c')]5 >>> list(enumerate(['a','b','c'],6)) #后边添加参数6，就是索引以6开始

6 [(6, 'a'), (7, 'b'), (8, 'c')]7 >>> dict(enumerate(['a','b','c'])) #使用dict()查看结果，返回有索引的参数

8 {0: 'a', 1: 'b', 2: 'c'}9 >>> list(enumerate(('a','b','c'),6)) #可迭代对象换成了元组，索引也从6开始

10 [(6, 'a'), (7, 'b'), (8, 'c')]11 >>> dict(enumerate({'a','b','c'},8)) #可迭代对象换成了集合，索引也从8开始，集合是没有索引的，所以返回一个假索引

12 {8: 'a', 9: 'b', 10: 'c'}13 >>>

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

1 >>> filter(None,[1,2,3]) #返回函数体

2

3 >>> list(filter(None,[1,2,3])) #因为需要两个参数，所以必须要填写参数None

4 [1, 2, 3]5 >>> def test(a): #添加一条简单的比较大小的函数

6 return a>1

7

8 >>> list(filter(test,[1,2,3])) #使用创建好的函数

9 [2, 3]10 >>> list(filter(lambda x:x>1,[1,2,3])) #直接使用内置lambda函数

11 [2, 3]12 >>>

map(func, *iterables)函数：以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

1 >>> map(None,[1,2,3,4,5]) #返回一个函数体

2

3 >>> list(map(lambda x:x>3,[1,2,3,4,5])) #每个元素都会调用函数，每次返回函数的结果

4 [False, False, False, True, True]5 >>> list(map(lambda x:x+1,[1,2,3,4,5])) #每个元素都会调用函数，每次返回函数的结果

6 [2, 3, 4, 5, 6]7>>> list(map(str,[1,2,3,4,5])) #*iterables，这里的*号就是解包的作用，这里再func部分放了str，返回的都是字符串

['1', '2', '3', '4', '5']

zip(iter1 [,iter2 [...]])函数：将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

1 >>> zip([1,2,3]) #返回函数体

2

3 >>> list(zip([1,2,3])) #使用list()查看

4 [(1,), (2,), (3,)]5 >>> list(zip([1,2,3],['a','b','c'])) #配对

6 [(1, 'a'), (2, 'b'), (3, 'c')]7 >>> list(zip([1,2,3],['a','b','c'],{'long','xiao','d'}))8 [(1, 'a', 'xiao'), (2, 'b', 'long'), (3, 'c', 'd')]9

10 >>> a = [1,2,3]11 >>> b = ['a','b','c']12 >>> test = zip(a,b) #使用变量进行配对

13 >>>list(test)14 [(1, 'a'), (2, 'b'), (3, 'c')]