python常用内置函数

python内置函数

1.isinstance()函数

描述

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

isinstance() 与 type() 区别：

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

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

  ​ 如果要判断两个类型是否相同推荐使用 isinstance()。

语法

​ isinstance(object, classinfo)

参数

• object – 实例对象。
• classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。

返回值

​ 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

实例

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

#type() 与 isinstance()区别：
class A:
    pass
A() 
class B(A):
    pass
B() 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

2.filter()函数

描述

​ filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

​ 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法

​ filter(function,iterable)

参数

• function–判断函数
• iterable–可迭代对象

返回值

​ 返回一个可迭代对象

实例

#过滤出列表中的所有奇数
def is_odd(n):
	return n % 2 == 1
	
templist=filter(is_odd,[1,2,3,4,5,6,7,8,9])
newlist=list(templist)
print(newlist)

#执行结果
[1, 3, 5, 7, 9]

#过滤出1~100中平方根是整数的数
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)

#执行结果
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

3.内置计算函数

(1).divmod()函数

描述

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

语法

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

复数除法运算计算方法

​ 分子、分母同乘分母共轭复数，将分母变为常数

(2).abs函数

描述

​ abs()函数返回数字的绝对值

语法

abs(x)

参数

• x–数值表达式

返回值

​ 返回数字的绝对值

实例

print('abs(-45):',abs(-45))
print('abs(100.12):',abs(100.12))

#执行结果
abs(-45) :  45
abs(100.12) :  100.12

(3).pow()函数

描述

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

语法

​ math 模块 pow() 方法的语法:

import math

math.pow( x, y )

​ 内置的 pow() 方法

pow(x, y[, z])

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

注意pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

参数

• x – 数值表达式。
• y – 数值表达式。
• z – 数值表达式。

实例

import math

print('math.pow(100,2):',math.pow(100,2))
print('pow(100,2):',pow(100,2))
#执行结果
math.pow(100,2): 10000.0
pow(100,2): 10000

print('pow(2,3,3):',pow(2,3,3))
#执行结果
pow(2,3,3): 2

(4).round()函数

描述

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

语法

round(x [,n])

参数

• x–数字表达式
• n–数字表达式

返回值

​ 返回浮点数x的四舍五入值。

实例

print "round(80.23456, 2) : ", round(80.23456, 2)
print "round(100.000056, 3) : ", round(100.000056, 3)
print "round(-100.000056, 3) : ", round(-100.000056, 3)

#执行结果
round(80.23456, 2) :  80.23
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0

4.eval()函数

描述

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

语法

eval(expression [,globals[,locals]])

参数

• expression – 表达式。
• globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
• locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

返回值

​ 返回表达式计算结果。

实例

eval('pow(2,2)')  #return 4

dict1=dict(a=100,b=200)
d=eval('a+b',dict1)
print(d)  #return 300

x,y=eval('输入点x,y的坐标，使用逗号隔开：')

5.zip()函数

描述

​ zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。使用 list() 转换来输出列表。

语法

zip([iterable,...])

参数

• iterable–一个或多个迭代器

返回值

​ 返回一个对象。

实例

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
 
>>> a1, a2 = zip(*zip(a,b))# 与zip相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

6.enumerate()函数

描述

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

语法

enumerate(sequence,[start=0])

参数

• sequence – 一个序列、迭代器或其他支持迭代对象。
• start – 下标起始位置。

返回值

​ 返回enumerate(枚举)对象。

实例

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

#普通for循环
i=0
seq=['one','two','three']
for element in seq:
	print(i,seq[i])
	i +=1
	
#执行结果
0 one
1 two
2 three

#for 循环使用enumerate
seq=['one','two','three']
for i，element in enumerate(seq):
	print(i,element)
	
#执行结果
0 one
1 two
2 three

7.map()函数

描述

​ map() 会根据提供的函数对指定序列做映射。返回结果使用列表转换输出。

语法

map(function, iterable, ...)

参数

• function – 函数
• iterable – 一个或多个序列

返回值

​ 返回迭代器

实例

def square_num(x) :    # 定义函数，计算平方数
	return x ** 2
#调用square_num函数，计算列表各个元素的平方
print(list(map(square_num, [1,2,3,4,5]))) 
#执行结果
[1, 4, 9, 16, 25]


print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))  # 使用 lambda 匿名函数
#执行结果
[1, 4, 9, 16, 25]
 
# 提供了两个列表，对相同位置的列表数据进行相加
print(list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])))
#执行结果
[3, 7, 11, 15, 19]

8.reverse()函数

描述

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

语法

list.reverse()

返回值

​ 无返回值，对列表的元素反向输出。

实例

ls=[123,'xyz','abc','python','xyz']
ls.reverse()
print(ls)

#执行结果
['xyz', 'python', 'abc', 'xyz', 123]

9.sorted()函数

描述

​ sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

​ sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法

sorted(iterable, cmp=None, key=None, reverse=False)

参数

• iterable – 可迭代对象。
• cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值

​ 返回重新排序的列表。

实例

>>>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, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])     # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True) # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

10.其他常用内置函数

(1).int()函数将一个字符串或数字转换为整型。字符串只支持整数型字符串。

>>>int()  #不传入参数返回0
0

>>>int(3.2)
3

>>>int('12')
12

>>>int('1.2') #报错

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

>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('123')     # 字符串
123.0

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

>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>>bool(0.1+0.2==0.3)
False

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

>>>complex(1, 2)
(1 + 2j)
 
>>> complex(1)    
(1 + 0j)
 
>>> complex("1")  # 当做字符串处理
(1 + 0j)
 
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)

>>>a=1+2j
>>>a.real #获取复数的实部
1.0
>>>a.imag #获取复数的虚部
2.0
>>>a.conjugate() #￥获取共轭复数
(1-2j)

(5)len()函数返回对象（字符串、列表、元组、集合、字典等）长度或项目个数。

>>>str = "runoob"
>>> len(str)             # 字符串长度
6
>>> l = [1,2,3,4,5]
>>> len(l)               # 列表元素个数
5
>>>d={'one':1,'two':2}   #字典个数
2

(6)max()、min()函数返回给定参数的最大值、最小值，参数可以为序列。

(7)range()函数使用list转换可创建一个整数列表，一般用在 for 循环中。

>>>list(range(10))        # 从 0 开始到 9
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>>list(range(0, 30, 5))  # 步长为 5
[0, 5, 10, 15, 20, 25]

>>>list(range(0, -10, -1)) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>>list(range(0))
[]
>>>list(range(1, 0))
[]

(8)sum()函数对系列进行求和计算。

>>>sum([0,1,2])  
3  
>>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
12

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

说明：本篇博客中的内置函数基于python3.x，内容参考菜鸟教程