python内置函数

abs（）

返回绝对值。

all()

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

list1=[0,1,2,3,4,4,54,54,5]
print(all(list1[i]==0 for i in range(len(list1))))
# False

list2=[1,1,1,1,1,1,1,1]
print(all(list2[i]==1 for i in range(len(list2))))
# True
1
2
3
4
5
6
7

any()

any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。

list1=[0,1,2,3,4,4,54,54,5]
print(any(list1[i]==0 for i in range(len(list1))))
# True

list2=[1,1,1,1,1,1,1,1]
print(any(list2[i]==1 for i in range(len(list2))))
# True
1
2
3
4
5
6
7

bin()

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

>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'
1
2
3
4

bool()

bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
bool 是 int 的子类。
元素除了是 0、空、FALSE 外都算 TRUE。

chr()

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

print(chr(0x30), chr(0x31), chr(0x61))
print(chr(48), chr(49), chr(97))
# 0 1 a
# 0 1 a
1
2
3
4

dict()

dict() 函数用于创建一个字典。

print(dict(a='a', b='b', t='t'))     # 传入关键字
print(dict(zip(['one', 'two', 'three'], [1, 2, 3])))   # 映射函数方式来构造字典
print(dict([('one', 1), ('two', 2), ('three', 3)]))    # 可迭代对象方式来构造字典
# {'a': 'a', 'b': 'b', 't': 't'}
# {'one': 1, 'two': 2, 'three': 3}
# {'one': 1, 'two': 2, 'three': 3}
1
2
3
4
5
6

divmod()

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

print(divmod(7, 2))
# (3, 1)
1
2

enumerate()

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

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

eval()

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

print(eval('pow(2,2)'))
# 4
1
2

file()

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

filter()

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

def is_odd(n):
    return n % 2 == 1 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
# [1, 3, 5, 7, 9]
1
2
3
4
5
6

format()

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
format 函数可以接受不限个参数，位置可以不按顺序。

print("{1} {0} {1}".format("hello", "world"))
# world hello world

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
1
2
3
4
5
6
7
8
9
10
11
12

help()

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

hex()

hex() 函数用于将一个指定数字转换为 16 进制数。

print(hex(255))
# 0xff
1
2

input()

Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。

a = input("input:")
1

int()

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

len()

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

list()

list() 方法用于将元组或字符串转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

list(i) for i in combinations(iterable=range(1, n + 1), r=k)

aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
1
2
3
4

map()

map() 函数会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

def square(x) :         # 计算平方数
     return x ** 2
map(square, [1,2,3,4,5])    # 计算列表各个元素的平方
# 
list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表
# [1, 4, 9, 16, 25]
list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数
# [1, 4, 9, 16, 25]
1
2
3
4
5
6
7
8

max()

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

min()

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

next()

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

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

oct()

oct() 函数将一个整数转换成 8 进制字符串，8 进制以 0o 作为前缀表示。

ord()

ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。

pow()

pow(x, y[, z])
函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

print()

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

• objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep – 用来间隔多个对象，默认值是一个空格。
• end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
• file – 要写入的文件对象。
• flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

range()

Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
Python3 list() 函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表。

range(stop)
range(start, stop[, step])
1
2

reversed()

# 字符串
seqString = 'Runoob'
print(''.join(reversed(seqString)))
 
# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))
 
# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
 
# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

round()

round() 方法返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端（四舍六入）。
round( x [, n] )

• x – 数字表达式。
• n – 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。

sorted()

sorted() 函数对所有可迭代的对象进行排序操作。
默认从小到大。

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

s = "2 2 1 1\n6 6 1 1\n4 4 1 1\n3 3 1 1\n7 7 1 1\n0 0 1 100"
stodata = s.split('\n')

# 使用sorted
para = {}

for line in range(len(stodata)):
    # 每一行数据
    data = stodata[line].split(' ')
    para[data[0]] = [int('-' + i) for i in data[1:]]
# 先根据x[1]排序，再根据x[0]排序
# x[1]内也是依次排序
new_para = sorted(para.items(), key=lambda x: (x[1], x[0]))
# new_para = sorted(para.items(), key=lambda x: x[1])
print([new_para[i][0] for i in range(len(para))])

c=[]
for i in new_para:
     c.append((i[0]))
for j in range(len(para)):
    print(f"{(j+1):2d}  {c[j]}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

str()

str() 函数将对象转化为适于人阅读的形式。

sum()

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

tuple()

tuple 函数将可迭代系列（如列表）转换为元组。

type()

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

isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。