Python基础学习之内置函数
Python3.5版本中的68个内置函数,按顺序逐个进行了自认为详细的解析,现在是时候进行个总结了。为了方便记忆,将这些内置函数进行了如下分类:
1. 数学运算(7个)
1.1 abs(),求绝对值
求数值的绝对值
abs(-10) # 输出:10
1.2 divmod(),求商和余数
求两个数值的商和余数
# divmod
divmod(10 , 3) # 输出:(3, 1)
divmod(10.1,3) # 输出:(3.0, 1.0999999999999996)
divmod(-10,4) # 输出:(-3, 2)
1.3 max(),求最大值
求最大值
max(1,2,3) # 传入3个参数 取3个中较大者;输出:3
max('1234') # 传入1个可迭代对象,取其最大元素值;输出:'4'
max(-1,0) # 数值默认去数值较大者;输出:0
max(-1,0,key = abs) # 传入了求绝对值函数,则参数都会进行求绝对值后再取较大者;输出:-1
1.4 min(),求最小值
求最小值
min(1, 2, 3) # 传入3个参数 取3个中较小的;输出:1
min('1234') # 传入1个可迭代对象,取其最小元素值;输出:'1'
min(-1,-2) # 数值默认去数值较小者;输出:-2
min(-1,-2,key = abs) # 传入了求绝对值函数,则参数都会进行求绝对值后再取较小者;输出:-1
1.5 pow(),求幂运算
求两个数的幂运算
pow(2, 3) # 2^3 = 8
1.6 round(),四舍五入
对数值进行四舍五入
round(1.131415926,1) # 输出:1.1
round(1.131415926,5) # 输出:1.13142
1.7 sum(),求和
求数值的和
# 传入可迭代对象
sum((1,2,3,4)) # 输出:10
# 元素类型必须是数值型
sum((1.5,2.5,3.5,4.5)) # 输出:12.0
sum((1,2,3,4),-10) # 输出:0
2. 类型转换(24个)
2.1 bool(),布尔转换
根据传入的参数的逻辑值创建一个新的布尔值
bool() # 未传入参数;输出:False
bool(0) # 数值0、空序列等值为False;输出:False
bool(1) # 输出:True
2.2 int(),整型转换
根据传入的参数创建一个新的整数
int() #不传入参数时,得到结果0;输出:0
int(3) # 输出:3
int(3.6) # 输出:3
2.3 float(),浮点型转换
根据传入的参数创建一个新的浮点数
float() # 不提供参数的时候,返回:0.0
float(3) # 返回:3.0
float('3') # 返回:3.0
2.4 complex(),复数
根据传入参数创建一个新的复数
complex() # 当两个参数都不提供时,返回复数 0j。
complex('1+2j') # 传入字符串创建复数,输出:(1+2j)
complex(1,2) # 传入数值创建复数,输出:(1+2j)
2.5 str(),字符串转换
返回一个对象的字符串表现形式(给用户)
str() # 返回:''
str(None) # 输出:'None'
str('abc') # 输出:'abc'
str(123) # 输出:'123'
2.6 bytearray(),字节数组
根据传入的参数创建一个新的字节数组,不怎么用;
bytearray('中文','utf-8') # bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
2.7 bytes(),不可变字节数组
根据传入的参数创建一个新的不可变字节数组
bytes('中文','utf-8') # b'\xe4\xb8\xad\xe6\x96\x87'
2.8 memoryview(),内存查看
根据传入的参数创建一个新的内存查看对象
v = memoryview(b'abcefg')
v[1] # 输出:98
v[-1] # 输出:103
2.9 ord(),字符 --> ASC
返回Unicode字符对应的整数
ord('a') # 输出:97
2.10 chr() ,ASC --> 字符
返回整数所对应的Unicode字符
chr(97) # 输出:'a'
2.11 bin(),转换成二进制
将整数转换成2进制字符串
bin(3) # 输出:'0b11'
2.12 oct(),转换成八进制
将整数转化成8进制数字符串
oct(10) # 输出:'0o12'
2.13 hex(),转换成十六进制
将整数转换成16进制字符串
hex(15) # 输出:'0xf'
2.14 tuple(),创建元组
根据传入的参数创建一个新的元组
tuple() # 不传入参数,创建空元组; 输出:()
tuple('121') # 传入可迭代对象。使用其元素创建新的元组;输出: ('1', '2', '1')
2.15 list(),创建列表
根据传入的参数创建一个新的列表
list() # 不传入参数,创建空列表;输出:[]
list('abcd') # 传入可迭代对象,使用其元素创建新的列表;输出:['a', 'b', 'c', 'd']
2.16 dict(),创建字典
根据传入的参数创建一个新的字典
dict() # 不传入任何参数时,返回空字典。返回:{}
dict(a = 1,b = 2) # 可以传入键值对创建字典。返回:{'b': 2, 'a': 1}
dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。返回:{'b': 2, 'a': 1}
dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。返回:{'b': 2, 'a': 1}
2.17 set(),创建集合
根据传入的参数创建一个新的集合
set() # 不传入参数,创建空集合;输出:set()
set(range(10)) # 传入可迭代对象,创建集合;输出:{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
2.18 frozenset(),创建不可变集合
根据传入的参数创建一个新的不可变集合
a = frozenset(range(10)) # 输出:frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
2.19 enumerate(),创建枚举对象
根据可迭代对象创建枚举对象
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons)) # 输出:[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1)) # 指定起始值,输出:[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
2.20 range(),创建range对象
根据传入的参数创建一个新的range对象
a = range(10)
b = range(1,10)
c = range(1,10,3)
a,b,c # 分别输出a,b,c,输出:(range(0, 10), range(1, 10), range(1, 10, 3))
list(a),list(b),list(c) # 分别输出a,b,c的元素;输出:([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])
2.21 iter(),创建可迭代对象
根据传入的参数创建一个新的可迭代对象
a = iter('abcd') #字符串序列
print(a) # 输出:<str_iterator object at 0x03FB4FB0>
next(a) # 输出:'a'
next(a) # 输出:'b'
next(a) # 输出:'c'
next(a) # 输出:'d'
next(a) # 由于后面没有元素了,所以会报错;报错内容如下:
# Traceback (most recent call last):
# File "<pyshell#29>", line 1, in <module>
# next(a)
# StopIteration
2.22 slice(),创建切片对象
根据传入的参数创建一个新的切片对象
slice(5) # 输出:slice(None, 5, None)
slice(2,5) # 输出:slice(2, 5, None)
slice(1,10,3) # 输出:slice(1, 10, 3)
2.23 super(),继承
根据传入的参数创建一个新的子类和父类关系的代理对象
#定义父类A
class A(object):
def __init__(self):
print('A.__init__')
#定义子类B,继承A
class B(A):
def __init__(self):
print('B.__init__')
super().__init__()
#super调用父类方法
b = B()
print(b) # 输出:
# B.__init__
# A.__init__
# <__main__.B object at 0x0000025B3398C160>
2.24 object(),创建对象
创建一个新的object对象
a = object()
3. 序列操作(8个)
3.1 all(),all运算
判断可迭代对象的每个元素是否都为True值
all([1,2]) # 列表中每个元素逻辑值均为True,返回True; 输出:True
all([0,1,2]) #列表中0的逻辑值为False,返回False;
all(()) # 空元组,输出:True
all({}) # 空字典,输出:True
3.2 any(),any运算
判断可迭代对象的元素是否有为True值的元素
any([0,1,2]) # 列表元素有一个为True,则返回True
any([0,0]) # 列表元素全部为False,则返回False
any([]) # 空列表,输出: False
any({}) # 空字典,输出: False
3.3 filter(),过滤可迭代对象
使用指定方法过滤可迭代对象的元素
a = list(range(1,10)) #定义序列, 输出 a 为:[1, 2, 3, 4, 5, 6, 7, 8, 9]
def if_odd(x): # 定义奇数判断函数
return x % 2 == 1
list(filter(if_odd , a)) # 筛选序列中的奇数,输出:[1, 3, 5, 7, 9]
3.4 map(),对可迭代对象中每个元素运算
使用指定方法去作用传入的每个可迭代对象的元素,生成新的可迭代对象
a = map(ord,'abcd') # 此时,a为:<map object at 0x03994E50>
list(a) # 对字符串'abcd' 分别计算ord(), 输出为:[97, 98, 99, 100]
3.5 next(),迭代对象中的下一个
返回可迭代对象中的下一个元素值
a = iter('abcd') #字符串序列
print(a) # 输出:<str_iterator object at 0x03FB4FB0>
next(a) # 输出:'a'
next(a) # 输出:'b'
next(a) # 输出:'c'
next(a) # 输出:'d'
next(a) # 由于后面没有元素了,所以会报错;报错内容如下:
# Traceback (most recent call last):
# File "<pyshell#29>", line 1, in <module>
# next(a)
# StopIteration
3.6 reversed(),返序
反转序列生成新的可迭代对象
a = reversed(range(10)) # 传入range对象
list(a) # 输出:[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
3.7 sorted(),排列
对可迭代对象进行排序,返回一个新的列表
a = ['a','b','d','c','B','A']
sorted(a) # 默认按字符ascii码排序,输出:['A', 'B', 'a', 'b', 'c', 'd']
sorted(a,key = str.lower) # 转换成小写后再排序,'a'和'A'值一样,'b'和'B'值一样;输出:['a', 'A', 'b', 'B', 'c', 'd']
3.8 zip(),列表 --> 字典
聚合传入的每个迭代器中相同位置的元素,返回一个新的元组类型迭代器
x = [1,2,3] #长度3
y = [4,5,6,7,8] #长度5
list(zip(x,y)) # 取最小长度3,输出: [(1, 4), (2, 5), (3, 6)]
4. 对象操作(9个)
4.1 help(),帮助文件
返回对象的帮助信息
help(list)
Help on class list in module builtins:
class list(object)
| list() -> new empty list
| list(iterable) -> new list initialized from iterable's items
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
4.2 dir(),属性列表
返回对象或者当前作用域内的属性列表
dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
4.3 id(),唯一标识符
返回对象的唯一标识符
a = 'kai'
id(a) # 输出:2332201834456
4.4 hash(),哈希值
获取对象的哈希值
hash('good good study') # 输出:6003936519601954108
4.5 type(),对象类型
返回对象的类型,或者根据传入的参数创建一个新的类型
type(10) # 输出:<class 'int'>
type('10') # 输出:<class 'str'>
4.6 len(),对象长度
返回对象的长度
len('abcd') # 字符串,返回:4
len(bytes('abcd','utf-8')) # 字节数组,返回:4
len((1,2,3,4)) # 元组,返回:4
len([1,2,3,4]) # 列表,返回:4
len(range(1,5)) # range对象,返回:4
len({'a':1,'b':2,'c':3,'d':4}) # 字典,,返回:4
len({'a','b','c','d'}) # 集合,,返回:4
len(frozenset('abcd')) #不可变集合,,返回:4
4.7 ascii(),可打印字符串
返回对象的可打印表字符串表现方式
ascii(1) # 输出:'1'
ascii('&') # 输出:"'&'"
ascii(9000000) # 输出:'9000000'
ascii('中文') #非ascii字符 # 输出:"'\\u4e2d\\u6587'"
4.8 format(),格式化显示
格式化显示值
# 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
format(3,'b') #转换成二进制,输出:'11'
format(97,'c') # 转换unicode成字符,输出:'a'
format(11,'d') # 转换成10进制,输出:'11'
format(11,'o') # 转换成8进制,输出:'13'
format(11,'x') # 转换成16进制 小写字母表示,输出:'b'
format(11,'X') # 转换成16进制 大写字母表示,输出:'B'
format(11,'n') # 和d一样,输出:'11'
format(11) # 默认和d一样,输出:'11'
# 浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
format(314159267,'e') # 科学计数法,默认保留6位小数,输出:'3.141593e+08'
format(314159267,'0.2e') # 科学计数法,指定保留2位小数,输出:'3.14e+08'
format(314159267,'0.2E') # 科学计数法,指定保留2位小数,采用大写E表示,输出:'3.14E+08'
format(314159267,'f') # 小数点计数法,默认保留6位小数,输出:'314159267.000000'
format(3.14159267000,'f') # 小数点计数法,默认保留6位小数,输出:'3.141593'
format(3.14159267000,'0.8f') # 小数点计数法,指定保留8位小数,输出:'3.14159267'
format(3.14159267000,'0.10f') # 小数点计数法,指定保留10位小数,输出:'3.1415926700'
format(3.14e+1000000,'F') # 小数点计数法,无穷大转换成大小字母,输出:'INF'
# g的格式化比较特殊,假设p为格式中指定的保留小数位数,先尝试采用科学计数法格式化,得到幂指数exp,如果-4<=exp<p,则采用小数计数法,并保留p-1-exp位小数,否则按小数计数法计数,并按p-1保留小数位数
format(0.00003141566,'.1g') # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留0位小数点,输出:'3e-05'
format(0.00003141566,'.2g') # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留1位小数点,输出:'3.1e-05'
format(0.00003141566,'.3g') # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留2位小数点,输出:'3.14e-05'
format(0.00003141566,'.3G') # p=1,exp=-5 ==》 -4<=exp<p不成立,按科学计数法计数,保留0位小数点,E使用大写,输出:'3.14E-05'
format(3.1415926777,'.1g') # p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留0位小数点,输出:'3'
format(3.1415926777,'.2g') # p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留1位小数点,输出:'3.1'
format(3.1415926777,'.3g') # p=1,exp=0 ==》 -4<=exp<p成立,按小数计数法计数,保留2位小数点,输出:'3.14'
format(0.00003141566,'.1n') # 和g相同,输出:'3e-05'
format(0.00003141566,'.3n') # 和g相同,输出:'3.14e-05'
format(0.00003141566) # 和g相同,输出:'3.141566e-05'
4.9 vars(),局部变量和值
返回当前作用域内的局部变量和其值组成的字典,或者返回对象的属性列表
class A(object):
pass
a = A()
print(a.__dict__) # 输出:{}
print(vars(a)) # 输出:{}
a.name = 'Kim'
print(a.__dict__) # 输出:{'name': 'Kim'}
print(vars(a)) # 输出:{'name': 'Kim'}
5. 反射操作(8个)
5.1 import(),动态导入模块
动态导入模块
index = __import__('index')
index.sayHello()
5.2 isinstance(),判断实例
判断对象是否是类或者类型元组中任意类元素的实例
isinstance(1,int) # 输出:True
isinstance(1,str) # 输出:False
isinstance(1,(int,str)) # 输出:True
5.3 issubclass(),判断子类
判断类是否是另外一个类或者类型元组中任意类元素的子类
issubclass(bool,int) # 输出:True
issubclass(bool,str) # 输出:False
issubclass(bool,(str,int)) # 输出:True
5.4 hasattr(),判断属性
检查对象是否含有属性
class Student:
def __init__(self, name):
self.name = name
s = Student('Aim')
hasattr(s, 'name') # a含有name属性,True
hasattr(s, 'age') # a不含有age属性,False
5.5 getattr(),获取属性
获取对象的属性值
class Student:
def __init__(self, name):
self.name = name
s = Student('Aim')
hasattr(s, 'name') # a含有name属性,True
hasattr(s, 'age') # a不含有age属性,False
getattr(s, 'name') # 存在属性name,返回: Aim
getattr(s,'age',0) # 不存在属性age,但提供了默认值,返回默认值0;
getattr(s,'age') # 不存在属性age,没有默认值,则会报错;AttributeError: 'Stduent' object has no attribute 'age'
5.6 setattr() ,设置属性
设置对象的属性值
class Student:
def __init__(self,name):
self.name = name
a = Student('Kim')
a.name # 输出:'Kim'
setattr(a,'name','Bob') # 修改name
a.name # 输出:'Bob'
5.7 delattr(),删除属性
删除对象的属性
#定义类A
class A:
def __init__(self,name):
self.name = name
def sayHello(self):
print('hello',self.name)
#测试属性和方法
a.name # 输出:'小麦'
a.sayHello() # 输出: hello 小麦
#删除属性
delattr(a,'name')
a.name # 报错:'A' object has no attribute 'name'
5.8 callable(),对象是否可调用
检测对象是否可被调用
class B: # 定义类B
def __call__(self):
print('instances are callable now.')
callable(B) # 类B是可调用对象,输出:True
b = B() # 调用类B
callable(b) # 实例b是可调用对象,输出:True
b() # 调用实例b成功,输出:instances are callable now.
6. 作用域变量操作(2个)
6.1 globals(),全局变量 & 值
返回当前作用域内的全局变量和其值组成的字典
globals() # 直接可以调用,查看当前的全局变量和其值组成的字典;
6.2 locals(),局部变量 & 值
返回当前作用域内的局部变量和其值组成的字典
locals() # 直接可以调用,查看当前的局部变量和其值组成的字典;
7. 交互操作(2个)
7.1 print(),打印输出
向标准输出对象打印输出
print(1,2,3) # 输出:1 2 3
print(1,2,3,sep = '+') # 输出:1+2+3
print(1,2,3,sep = '+',end = '=?') # 输出:1+2+3=?
7.2 input(),用户输入
读取用户输入值
s = input('please input your name:') # 代码运行到此,就需要用户进行输入;
8. 文件操作(1个)
8.1 open(),打开文件
使用指定的模式和编码打开文件,返回文件读写对象
# t为文本读写,b为二进制读写
a = open('test.txt','rt')
a.read() # 输出:'some text'
a.close()
9. 编译执行(4个)
9.1 compile(),编译代码
将字符串编译为代码或者AST对象,使之能够通过exec语句来执行或者eval进行求值
#流程语句使用exec
code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1)
9.2 eval(),执行动态表达式
执行动态表达式求值
eval('1+2+3+4') # 输出:10
9.3 exec(),执行动态语句
执行动态语句块
exec('a=1+2') # 执行语句,
9.4 repr(),字符串表现形式
返回一个对象的字符串表现形式(给解释器)
a = 'some text'
str(a) # 输出:'some text'
repr(a) # 输出:"'some text'"
10. 装饰器(3个)
10.1 property(),属性装饰器
标示属性的装饰器
class C:
def __init__(self):
self._name = ''
@property
def name(self):
"""i'm the 'name' property."""
return self._name
@name.setter
def name(self, value):
if value is None:
raise RuntimeError('name can not be None')
else:
self._name = value
c = C()
print(c.name) # 访问属性,输出为''
c.name = 'Kim' # 设置属性
print(c.name) # 访问属性,输出为:Kim
c.name = None # 设置属性时进行验证
# 弹出错误: RuntimeError: name can not be None
del c.name # 删除属性,不提供deleter则不能删除
10.2 classmethod(),类装饰器
标示方法为类方法的装饰器
class C:
@classmethod
def f(cls, arg1):
print(cls)
print(arg1)
C.f('类对象调用类方法')
# 输出如下:
# <class '__main__.C'>
# 类对象调用类方法
c = C()
c.f('类实例对象调用类方法')
# 输出如下:
# <class '__main__.C'>
# 类实例对象调用类方法
10.3 staticmethod(),静态方法装饰器
标示方法为静态方法的装饰器
# 使用装饰器定义静态方法
class Student(object):
def __init__(self, name):
self.name = name
@staticmethod
def sayHello(lang):
print(lang)
if lang == 'en':
print('Welcome!')
else:
print('你好!')
Student.sayHello('en') # 类调用,'en'传给了lang参数
# 输出如下:
# en
# Welcome!
b = Student('Kim')
b.sayHello('zh') # 类实例对象调用,'zh'传给了lang参数
# 输出如下:
# zh
# 你好
本文参考地址:https://blog.csdn.net/oaa608868/article/details/53506188?utm_medium=distribute.pc_relevant.none-task-blog-title-9&spm=1001.2101.3001.4242
标签:__,输出,内置,name,10,Python,self,对象,详解 From: https://blog.51cto.com/zhemeshenqi/5786429