Python 内置函数

abs(x)

abs(-45)        #      45
abs(100.12)     #      100.12

all(iterable)

判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。（元素除了是 0、空、FALSE 外都算 TRUE）

all(['a', 'b', 'c', 'd'])     # True
all(['a', 'b', '', 'd'])      # False
all([0, 1，2, 3])             #False

any(iterable)

判断给定的可迭代参数 iterable 中的所有元素至少一个为True或非零，如果是返回 True，否则返回 False。（元素除了是 0、空、FALSE 外都算 TRUE）

any(['a', 'b', 'c', 'd'])  #True 
any(['a', 'b', '', 'd'])   #True 
any([0, '', False])        #False

chr(integer)

unichr(i)

返回字符编码在[0 255]中对应的字符。

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

将一个字符串编译为字节代码:

• source -- 字符串
• filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值
• mode -- 指定编译代码的种类。可以指定为 exec, eval, single

str = "for i in range(0,10): print(i)" 
c = compile(str,'','exec')   # 编译为字节代码对象 
exec(c) #0 1 2 3 4 5 6 7 8 9

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

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}

divmod(x, y)

divmod(7, 2)         #(3, 1)
divmod(1+2j,1+0.5j)  #((1+0j), 1.5j)

list(enumerate(seasons, start=1))       
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

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

x = 10

expr = """

          z = 30

          sum = x + y + z

           print(sum) """

def func():

          y = 20

          exec(expr)

           exec(expr, {'x': 1, 'y': 2})

           exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})

func()

filter(f, [x1, x2, x3, x4])

接收一个函数和一个序列，把传入的函数依次作用于每个序列中元素，然后根据返回值是True还是False决定保留还是丢弃该元素。 

def is_odd(n):
      return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) # 一个list中，删掉偶数，只保留奇数

def not_empty(s):
    return s and s.strip() 
list(filter(not_empty, ['A', '', 'B', None, 'C', '  '])) # 把一个序列中的空字符串删掉
 

hash(obj)

hash('test')            # 字符串：2314058222102390712
hash(str([1,2,3]))      # 集合：1335416675971793195

hex(255)     #'0xff'

id(obj)

根据object返回唯一的整数标识

a=1
id(a)       #1873936880

input(prompt)

从标准输入返回字符串

isinstance(obj, cls)

判断一个对象是否是一个已知的类型，类似 type()

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。

• isinstance() 会认为子类是一种父类类型，考虑继承关系。

isinstance (2,int)        #True
isinstance (2,(str,int,list))    # 是元组中的一个返回True

map(f, iter1, iter2, ...)

根据提供的函数对指定序列做映射。返回包含每次 function 函数返回值的新列表

map(lambda x: x ** 2, [1, 2, 3, 4, 5])  #[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]

iter();next()

it = iter([1, 2, 3, 4, 5])
while True:
    try:
        x = next(it)
        print(x)
    except StopIteration:
        break

将一个整数转换成8进制字符串。

oct(10)    #'012'

ord(char)

pow(x, y)

返回x的y次方的值：pow() 参数作为整型，而 math 模块则会把参数转换为 float

• objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep -- 用来间隔多个对象，默认值是一个空格。
• end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
• file -- 要写入的文件对象。

print("aaa""bbb")  # aaabbb

print("aaa","bbb") # aaa bbb

print("www","baidu","com",sep=".") #www.baidu.com

range(start,stop[,step])

创建一个整数列表

reduce(f, iterable[,initializer])

函数会对参数序列中元素进行累积,f(f(f(x1, x2), x3), x4)

from functools import reduce

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

重新载入之前载入的模块:原来已经使用的实例还是会使用旧的模块，而新生产的实例会使用新的模块；

from imp import reload

import sys

sys.getdefaultencoding()         # 当前默认编码 'ascii'

reload(sys)

sys.setdefaultencoding('utf8')   # 设置编码 sys.getdefaultencoding()          # 'utf8'

list.reverse()

a = [1,2,3]

a.reverse()

a   # [3,2,1]

reversed([1,2,3])  #<list_reverseiterator object >

 for i in reversed([1,2,3]):

     print(i) # 3,2,1

round(x[,n])

round(80.23456,3)   #80.235

round(100.000065,3) #100.0

sorted(iterable[,key[,reverse]]])

• iterable -- 可迭代对象。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）

对所有可迭代的对象进行排序操作

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

a = [5,7,6,3,4,1,2]

b = sorted(a) # 保留原列表

a           # [5, 7, 6, 3, 4, 1, 2]

b          #[1, 2, 3, 4, 5, 6, 7]

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

sorted(L, key=lambda x:x[1])  # 利用key [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

zip([iterable, ...])

将可迭代的对象作为参数，将对象中对应位置的元素打包成一个个元组，然后返回的是一个对象。如需展示列表，需手动 list() 转换。

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

nums = ['flower','flow','flight']
for i in zip(*nums):
    print(i)

('f', 'f', 'f')
('l', 'l', 'l')
('o', 'o', 'i')
('w', 'w', 'g')

3.1415926

{:.2f}

3.14

保留小数点后两位

3.1415926

{:+.2f}

+3.14

带符号保留小数点后两位

-1

{:+.2f}

-1.00

带符号保留小数点后两位

2.71828

{:.0f}

3

不带小数

5

{:0>2d}

05

数字补零 (填充左边, 宽度为2)

5

{:x<4d}

5xxx

数字补x (填充右边, 宽度为4)

10

{:x<4d}

10xx

数字补x (填充右边, 宽度为4)

1000000

{:,}

1,000,000

以逗号分隔的数字格式

0.25

{:.2%}

25.00%

百分比格式

1000000000

{:.2e}

1.00e+09

指数记法

13

{:10d}

        13

右对齐 (默认, 宽度为10)

13

{:<10d}

13

左对齐 (宽度为10)

13

{:^10d}

    13

中间对齐 (宽度为10)

11

进制

list.append('ducati')    # 添加
list.insert(1,'ducati1')  # 插入

list.index('hello')      # 0

cars.sort()    #   永久性排序
cars.sort(reverse=True)  # 永久性排序
cars.reverse()  # 永久反转

sorted(cars)    # 临时排序
sorted(cars,reverse=True)
sorted([36, 5, -12, 9, -21], key=abs) # [5, 9, -12, -21, 36]
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) # ['about', 'bob', 'Credit','Zoo']

reversed(cars)  #临时反转

number = [2,"hello",4,5]
print(",".join(map(str,number)))