python-内置函数
python 总共有68个内置函数
数学运算(7)
|
函数 |
作用 |
| 1 |
abs(iterable) |
求数值的绝对值 |
| 2 |
divmod(a, b) |
返回两个数值的商和余数 |
| 3 |
max() |
返回可迭代对象或序列的元素中的最大值 |
| 4 |
min() |
返回可迭代对象或序列的元素中的最小值 |
| 5 |
pow(base, exp[, mod]) |
返回两个数值的幂运算或者其与指定mod的模值 |
| 6 |
round() |
对浮点数进行四舍五入值 |
| 7 |
sum() |
对元素类型是数值的可迭代对象中的每个元素求和 |
# abs
print(abs(-2))
2
# ------------------------------------------------------------
# divmod
print(divmod(5,2))
(2,1)
print(divmod(5.5,2))
(2.0,1.5)
# ------------------------------------------------------------
# max min
print(max('1234'))
# 传入1个可迭代对象，取其最大元素值
'4'
print(max(-1,0,key = abs))
#绝对值最大
-1
# ------------------------------------------------------------
# pow()
print(pow(2,3))
8
print( pow(2,3,5))
# pow(2,3)%5
3
# ------------------------------------------------------------
# round
print( round(1.1314926,1))
1.1
print( round(1.1314926,5))
1.13149
print(sum(range(5)))
#15
类型转换(16)
|
函数 |
作用 |
| 1 |
bool() |
将给定参数转换为布尔类型，True 或者 False |
| 2 |
int() |
返回一个基于数字或字符串 x 构造的整数对象 |
| 3 |
float() |
返回从数字或字符串 x 生成的浮点数。 |
| 4 |
complex() |
根据传入的参数创建一个新的复数 |
| 5 |
str() |
返回一个 str版本的 object |
| 6 |
bytearray() |
返回一个新的 bytes 数组 |
| 7 |
bytes() |
返回一个新的“bytes”对象 |
| 8 |
memoryview() |
创建一个新的内存查看对象 |
|
|
|
| 9 |
list() |
根据传入的参数创建一个新的列表 |
| 10 |
tuple() |
根据传入的参数创建一个新的元组 |
| 11 |
dictionary() |
根据传入的参数创建一个新的字典 |
| 12 |
set() |
根据传入的参数创建一个新的集合 |
| 13 |
frozenset() |
根据传入的参数创建一个不可变集合 |
| 14 |
slice() |
创建一个新的切片类型对象 |
|
|
|
| 15 |
super() |
创建一个新的子类和父类关系的代理对象 |
| 16 |
object() |
创建一个新的object对象 |
# bool：根据传入的参数的逻辑值
>>> bool() #未传入参数
False
>>> bool(0) #数值0、空序列等值为False
False
>>> bool(1)
True
# ------------------------------------------------------------
# int：根据传入的参数创建一个新的整数
>>> int() #不传入参数时，得到结果0。
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
# ------------------------------------------------------------
# float：根据传入的参数创建一个新的浮点数
>>> float('3')
3.0
# ------------------------------------------------------------
frozenset() 不能在添加删除元素
a = frozenset(range(10)) # 先创建一个冻结集合
print(a)
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
del a[0]
# TypeError: 'frozenset' object doesn't support item deletion
字符转换(6)
|
函数 |
作用 |
| 1 |
ord() |
返回对应字符的ascii码 |
| 2 |
chr() |
返回ascii码对应的字符 |
| 3 |
bin() |
将整数转化为2进制字符串 |
| 4 |
oct() |
将整数转化为8进制字符串 |
| 5 |
hex() |
将整数转化为16进制字符串 |
| 6 |
ascill() |
转义非 ASCII 字符 |
|
|
|
# ------------------------------------------------------------
# ord() ord()函数是chr()的配对函数
print( ord('b') ) # 返回：98
print( ord('%') ) # 返回：37
# 把数字98在ascii码中对应的字符打印出来
print( chr(98) ) # 返回：b
# ------------------------------------------------------------
# bin()函数返回一个整数int或者长整数long int的二进制
print( bin(10) ) # 0b1010
print( bin(133) ) # 0b10000101
# ------------------------------------------------------------
# oct() 整数转八进制
print( oct(10) ) # 0o12
print( oct(255) ) # 0o377
print( oct(-6655) ) # -0o14777
# ------------------------------------------------------------
print(hex(1)) # 0x1
print(hex(-256)) # -0x100
print(type(hex(-256))) #<class 'str'>
序列操作(8)
|
函数 |
作用 |
| 1 |
all() |
所有元素存在且不为空，0 返回True |
| 2 |
any() |
存在元素存在， 0也可以，返回为True |
| 3 |
filter() |
过滤序列，过滤可迭代对象的元素 |
| 4 |
map() |
使用指定方法取作用传入的每个迭代对象的元素，生成新的可迭代对象 |
| 5 |
next() |
返回可迭代对象的下一个元素值 |
| 6 |
reversed() |
反转序列生成新的可迭代对象 |
| 7 |
sorted() |
对可迭代对象进行排序，返回一个新的列表 |
| 8 |
zip() |
聚合传入的每隔迭代器中的相同位置的元素，返回一个新的元祖类型迭代器 |
all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0
# True
all(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
# False
# ------------------------------------------------------------
any(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
# True
any([0, '', False]) # 列表list,元素全为0,'',false
False
# ------------------------------------------------------------
def is_odd(n):
return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
[1, 3, 5, 7, 9]
# ------------------------------------------------------------
def square(x) : # 计算平方数
return x ** 2
res=map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
print(res)
# [1, 4, 9, 16, 25]
# ------------------------------------------------------------
bb = [1,3,5,7]
print(reversed(bb))
# <list_reverseiterator object at 0x0000029336879E48>
print(list(reversed(bb)))
# [7,5,3,1]
# ------------------------------------------------------------
a=[1,2,3]
b=['a','c','d','e']
zz=zip(a,b)
print(zz)
print(list(zz))
x,y=zip(*[[1,2],[3,4],[5,6]])
print(x)
print(y)
#<zip object at 0x000001457B3375C8>
#[(1, 'a'), (2, 'c'), (3, 'd')]
#(1, 3, 5)
#(2, 4, 6)
遍历迭代生成器(4)
|
函数 |
作用 |
| 1 |
range() |
根据传入的参数创建一个新的range对象 |
| 2 |
iter() |
生成迭代器 |
| 3 |
next() |
回可迭代对象的下一个元素值 |
| 4 |
enumerate() |
根据可迭代对象创建枚举对象 |
|
|
|
list1=range(5)
print(list(list1)) # [0,1,2,3,4]
# ------------------------------------------------------------
# iter()
#list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器
it = [1,2,3]
it_list = iter(it)
print(next(it_list))
1
# ------------------------------------------------------------
# next()
it = iter([1,2,3,4,5])
print(next(it))
1
# ------------------------------------------------------------
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
# 返回：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
面向对象(11)
|
函数 |
作用 |
| 1 |
help() |
返回对象的帮助信息 |
| 2 |
dir() |
返回对象或者当前作用域内的属性列表 |
| 3 |
id() |
返回对象的唯一标识符 |
| 4 |
hash() |
获取对象的哈希值 |
| 5 |
type() |
元类,类的最高层 |
| 6 |
len() |
返回对象的长度 |
| 7 |
format() |
格式化显示值 |
| 8 |
vars() |
返回当前作用域内的局部变量，和其值组成的字典，或者返回对象的属性列表 |
|
|
|
| 装饰器 |
|
|
| 9 |
classmethod |
标示方法为类方法的装饰器 |
| 10 |
staticmethod |
标示方法为静态方法的装饰器 |
| 11 |
property |
标示属性的装饰器 |
|
|
|
help()
a = [1,2,3]
help(a) # 查看列表 list 帮助信息
help(a.append) # 显示list的append方法的帮助
# ------------------------------------------------------------
dir()
# ------------------------------------------------------------
id()
a = "123" # 字符串
print(id(a)) # 13870392
b = [1,2,3] # 列表
print(id(b)) # 7184328
# ------------------------------------------------------------
hash() # 获取一个对象（数字或者字符串等）的哈希值。不能直接应用于 list、set、dictionary
print(hash(1)) # 1
print(hash(20000)) # 20000
print(hash('123')) # -6436280630278763230
print(hash('ab12')) # 5468785079765213470
print(hash('ab12')) # 5468785079765213470
# ------------------------------------------------------------
# len()
print(len('1234')) # 字符串，返回字符长度4
print(len(['1234','asd',1])) # 列表，返回元素个数3
print(len((1,2,3,4,50))) # 元组，返回元素个数5
# ------------------------------------------------------------
fromt()
print('name:{n},url:{u}'.format(n='alex',u='www.xxxxx.com'))
# name:alex,url:www.xxxxx.com
反射操作(8)
|
|
|
| 1 |
__import__ |
动态导入模块 |
| 2 |
isinstance() |
判断对象是否是类或者类型 |
| 3 |
issubclass() |
判断类是否是另外一个类子类 |
| 4 |
hasattr() |
检查对象是否含有属性 |
| 5 |
getattr |
获取对象的属性值 |
| 6 |
setattr |
设置对象的属性值 |
| 7 |
delattr |
删除对象的属性 |
| 8 |
callable |
检测对象是否可被调用 |
# # ------------------------------------------------------------
# isinstance()
print(isinstance(a,int)) # True
print(isinstance(a,str)) # False
print(isinstance(a,(str,tuple,dict))) # False
# # ------------------------------------------------------------
issubclass()
class A:
pass
class B(A): # b继承了a，即b是a的子类
pass
print(issubclass(A,B)) # 判断 a 是 b 的子类？
# False
print(issubclass(B,A)) # 判断 b 是 a 的子类？
# True
# # ------------------------------------------------------------
hasattr()
list_list=[]
print(hasattr(list_list, 'append'))
True
print(hasattr(list_list, 'add'))
False
# # ------------------------------------------------------------
class Test():
name="ming"
def run(self):
return "Hello World"
t=Test()
getattr()
# # ------------------------------------------------------------
# callable()函数用于检查一个对象是否可调用的
def sayhi():pass # 先定义一个函数sayhi()
print( callable( sayhi ) ) # True
作用域相关(2)
|
函数 |
作用 |
| 1 |
globals() |
返回当前位置的全部全局变量 ，字典类型 |
| 2 |
locals() |
以字典类型返回当前位置的全部局部变量 |
def function(arg): # 两个局部变量：arg、z
z = 1
print (locals())
function(4)
# {'z': 1,'arg':4}
a = 1
print(globals())
# {'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, 'a': 1, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}
# 多一个 a:1
交互操作(2)
|
函数 |
作用 |
| 1 |
print() |
向标准输出对象打印输出 |
| 2 |
inpurt() |
读取用户输入值 |
>>> print(1,2,3,sep = '+',end = '=?')
1+2+3=?
s = input('please input your name:')
please input your name:Ain
>>> s
'Ain'
文件操作(1)
|
函数 |
作用 |
| 1 |
open() |
使用指定的模式和编码打开文件，返回文件读写对象 |
>>> a = open('test.txt','rt')
>>> a.read()
'some text'
>>> a.close()
编译执行(4)
|
函数 |
作用 |
| 1 |
compile |
将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值 |
| 2 |
eval() |
执行动态表达式求值 |
| 3 |
exec() |
执行动态语句块 |
| 4 |
repr |
函数将对象转化为供解释器读取的形式 |
str = "for i in range(0,10): print(i,end=' ')"
c = compile(str, '', 'exec')
exec(c)
# 输出
0 1 2 3 4 5 6 7 8 9
# # ------------------------------------------------------------
# eval() 函数用来执行一个字符串表达式
print(eval('3 * 2')) # 6
# # ------------------------------------------------------------
# exec() 执行储存在字符串或文件中的Python语句
exec("print('Hello World')") # 执行简单的字符串
# Hello World
exec("for i in range(5): print('iter time is %d'%i)") # 执行复杂的for循环
# iter time is 0
# iter time is 1
# iter time is 2
# iter time is 3
# iter time is 4
# # ------------------------------------------------------------
# repr() 将对象转化为供解释器读取的形式。返回一个对象的 string 格式
r = repr((1,2,3))
print( r ) # (1, 2, 3)
print( type(r) ) # <class 'str'>
dict = repr({'a':1,'b':2,'c':3})
print( dict ) # {'c': 3, 'a': 1, 'b': 2}
print( type(dict) ) # <class 'str'>
