第五篇 Python内置函数

内置函数
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	pow()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format() l	en()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

1.数学运算类函数

abs，divmod，max，min，pow，round，sum

1)计算数值的绝对值：abs()

 print(abs(-)) 

 -----输出结果----
  

2)返回两个数的商和余数：divmod()

 print(divmod(,))

 ------输出结果------
 (,)

3)返回所有参数中元素的最大值或者返回可迭代对象中元素的最大值：max()

 print(max(,,))  #取三个数中的最大者

 print(max(''))  #取可迭代对象中的最大者

 print(max(-,-,,key=abs)) #把-，-，0依次传给abs的参数，然后把abs的结果返回给key，max依次比较key的大小

 -------输出结果-------
 -

4)返回所有参数中元素的最小值或者返回可迭代对象中元素的最小值：min()

 print(min(,,))  #取三个数中的最小者

 print(min(''))  #取可迭代对象中的最小者

 print(min(-,-,,key=abs)) #把-，-，0依次传给abs的参数，然后把abs的结果返回给key，max依次比较key的大小

 -------输出结果-----

5)返回两个数值的幂运算值或者其与指定值的余数：pow()

 print(pow(,)) #2的4次幂

 print(pow(,,)) #2的4次幂，然后除以3的余数 

 ------输出结果-----

6)对浮点数进行四舍五入：round()

 print(round(2.563,))  #.563四舍五入，精度为1

 print(round(2.561654132,)) #.561654132四舍五入，精度为5

 --------输出结果------
 2.6
 2.56165

7)对参数类型为数值的可迭代对象中的每个元素求和：sum()

 print(sum((,,,,,)))  #对可迭代对象进行求和

 print(sum((,,,,,),)) #可迭代对象的和与'start'的和

 --------输出结果-----

 2.类型转换类函数

bool，int，float，complex，str，bytearray，bytes，memoryview，ord，chr，bin，oct，hex，tuple，list，dict，set，frozenset，enumerate，range，slice，super，object。

1)根据传入的参数的值返回布尔值：bool()

 print(bool()) #不传递参数，返回False
 print(bool())
 print(bool(''))
 print(bool(())) # ,'',()等为值的布尔值为False

 print(bool())

 ------输出结果------
 False
 False
 False
 False
 True

2)根据传入的参数值创建一个新的整数值：int()

 print(int())  #不传递参数时，结果为0

 print(int(1.8)) #向下取整

 print(int('')) #根据字符串类型创建整型

 -------输出结果------

3)根据传入的参数值创建一个新的浮点数值：float()

 print(float())  #不传递参数时，结果为0.

 print(float())

 print(float('')) #根据字符串类型创建浮点值

 -------输出结果------
 0.0
 1.0
 12.0

4)根据传入的参数值创建一个新的复数值：complex()

 print(complex())  #不传递参数时，结果为0j

 print(complex())

 print(complex(,)) #1为实数部分，3为虚数部分

 print(complex('')) #根据字符串类型创建复数

 print(complex('1+2j'))

 ------输出结果-----
 0j
 (+0j)
 (+3j)
 (+0j)
 (+2j)

5)返回一个对象的字符串表示形式，这个主要是给用户看：str()

 >>> str(None)
 'None'
 >>> str('')
 ''
 >>> str()
 ''
 >>> str()
 ''
 >>>

6)根据传入的参数创建一个字节数组（可变）：bytearray()

 print(bytearray('博小园','utf-8'))

 ------输出结果-----
 bytearray(b'\xe5\x8d\x9a\xe5\xb0\x8f\xe5\x9b\xad')

7)根据传入的参数创建一个不变字节数组：bytes()

 print(bytes('博小园','utf-8'))

 ------输出结果-----
 b'\xe5\x8d\x9a\xe5\xb0\x8f\xe5\x9b\xad'

8)根据传入的参数创建一个内存查看对象：memoryview()

 memview=memoryview(b'abcdef')

 print(memview[])
 print(memview[-])

 --------输出结果--------

9)根据传入的参数返回对应的整数：ord()

 print(ord('a'))

 -------输出结果------
 

10)根据传入的参数的整数值返回对应的字符：chr()

 print(chr())

 -------输出结果------
 a

11)根据传入的参数的值返回对应的二进制字符串：bin()

 print(bin())

 -------输出结果------
 0b1100

12)根据传入的参数的值返回对应的八进制字符串：oct()

 print(oct())

 -------输出结果------
 0o14

13)根据传入的参数的值返回对应的十六进制字符串：hex()

 print(hex())

 ------输出结果-----
 0xc

14)根据传入的参数创建一个tuple元组：tuple()

 print(tuple())  #不传递参数，创建空元组 ()
 print(tuple('')) #根据可迭代参数，创建元组

 ------输出结果-----
 ()
 ('', '', '', '', '')

15)根据传入的参数创建一个新列表：list()

 print(list())  #不传递参数，创建空列表 ()
 print(list('')) #根据可迭代参数，创建列表

 -------输出结果-------
 []
 ['', '', '', '', '']

16)根据传入的参数创建一个新的字典：dict()

 print(dict())  #不传递参数，创建一个空的字典

 print(dict(x=,y=)) #传递键值对创建字典

 print(dict((('x',),('y',))))  #传入可迭代对象创建新的字典

 print(dict([('x',),('y',)]))
 print(dict(zip(['x','y'],[,])))  #传入映射函数创建新的字典

 ---------输出结果-----
 {}
 {'x': , 'y': }
 {'x': , 'y': }
 {'x': , 'y': }
 {'x': , 'y': }

17)根据传入的参数创建一个新的集合：set()

 print(set()) #传入的参数为空，返回空集合

 print(set(range()))  #传入一个可迭代对象，创建集合

 -------输出结果-----
 set()
 {, , , , , , }

18)根据传入的参数创建一个新的不可变集合：frozenset()

 print(frozenset(range()))

 -------输出结果------
 frozenset({, , , , , , , })

19)根据可迭代对象创建枚举对象：enumerate()

 names=['zhangsan','lisi','wangwu','boxiaoyuan']

 print(list(enumerate(names)))

 print(list(enumerate(names,)))

 -------输出结果-----
 [(, 'zhangsan'), (, 'lisi'), (, 'wangwu'), (, 'boxiaoyuan')]
 [(, 'zhangsan'), (, 'lisi'), (, 'wangwu'), (, 'boxiaoyuan')]

20)根据传入的参数创建一个新的range对象：range()

 x=range() #0至8

 y=range(,) #1至8 步长为1

 z=range(,,) #1至8 步长为2

 print(list(x))
 print(list(y))
 print(list(z))

 -------输出结果--------
 [, , , , , , , , ]
 [, , , , , , , ]
 [, , , ]

21)根据传入的参数创建一个新的可迭代对象：iter()

 x=iter('')
 print(x)

 print(next(x))
 print(next(x))
 print(next(x))
 print(next(x))
 print(next(x))

 -------输出结果-------
 <str_iterator object at 0x000001BE6D71B860>

 Traceback (most recent call last):
   File "E:/pythontest/test06.py", line , in <module>
     print(next(x))
 StopIteration

22)根据传入的对象创建一个新的切片对象：slice()

切片函数主要对序列对象进行切去对应元素。

 a=[,,,,,,,,,]

 s=slice(,,)   #从start:0到stop:，步长为step:
 print(a[s])

 -------输出结果------
 [, , , , ]

23)根据传入的参数创建一个新的子类和父类关系的代理对象：super()

 class A:
     def __init__(self):
         print("A.__init__")

 class B(A):
     def __init__(self):
         print("B.__init__")
         super().__init__()

 b=B()

 -------输出结果------
 B.__init__
 A.__init__

24)创建一个新的object对象：object()

 a=object()
 a.name='boxiaoyuan'  #不能设置属性，object没有该属性

 --------输出结果-------
 Traceback (most recent call last):
   File "E:/pythontest/test06.py", line , in <module>
     a.name='boxiaoyuan'
 AttributeError: 'object' object has no attribute 'name'

 3.序列操作类函数

all，any，filter，map，next，reversed，sorted，zip

1)判断每个可迭代对象的每个元素的值是否都是True，都是Ture，则返回True：all()

 print(all([,,,,]))  #列表中的每个元素的值都为True，则返回True

 print(all([,,,,,])) 

 print(all({})) #空字典返回True

 print(all(())) #空元组返回True

 ------输出结果------
 True
 False
 True
 True

2)判断可迭代对象的每个元素的值是否存在为True，存在则返回True：any()

 print(any([,,,,]))  #列表中的存在一个为True，则返回True

 print(any([,]))

 print(any({})) #空字典返回False

 print(any(())) #空元组返回False

 -------输出结果------
 True
 False
 False
 False

3)使用指定方法过滤可迭代对象的元素：filter()

 lists=[,,,,,,,,,]

 def is_odd(x):
     if x%==:
         return x

 print(list(filter(is_odd,lists)))

 -------输出结果-------
 [, , , , ]

4)使用指定方法作用传入的每个可迭代对象的元素，生成新的可迭代对象：map()

 x=map(ord,'')

 print(x)

 print(list(x))

 -------输出结果-----
 <map object at 0x0000026B7296B860>
 [, , , , ]

5)返回可迭代对象的下一个对象：next()

a=[0,1,2]
it=a.__iter__()
print(next(it))
print(next(it))
print(next(it))
print(next(it,3))  #传入default，当还有元素值没有迭代完，则继续迭代，如果已经迭代完，则返回默认值

-------输出结果--------
0
1
2
3

6)反转序列生成的可迭代对象：reversed()

 a=range()
 print(a)  #可迭代对象
 print(list(reversed(a)))

 -------输出结果------
 range(, )
 [, , , , , , , , , ]

7)对可迭代对象进行排序：sorted()

 a=[,,,,,,]

 print(list(sorted(a)))

 b=['a','c','d','A','C','D']

 print(list(sorted(b,key=str.lower)))

 -------输出结果-----
 [, , , , , , ]
 ['a', 'A', 'c', 'C', 'd', 'D']

8)聚合传入的每个迭代器的相同位置的元素值，然后染回元组类型迭代器：zip()

 x=[,,]
 y=[,,,,]

 print(list(zip(x,y)))

 -------输出结果------
 [(, ), (, ), (, )]

 4.对象操作类函数

help，dir，id，hash，type，len，ascii，format，vars

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]
  |
  |  __gt__(self, value, /)
  |      Return self>value.
  |
  |  __iadd__(self, value, /)
  |      Implement self+=value.
  |
  |  __imul__(self, value, /)
  |      Implement self*=value.
  |
  |  __init__(self, /, *args, **kwargs)
  |      Initialize self.  See help(type(self)) for accurate signature.
  |
  |  __iter__(self, /)
  |      Implement iter(self).
  |
  |  __le__(self, value, /)
  |      Return self<=value.
  |
  |  __len__(self, /)
  |      Return len(self).
  |
  |  __lt__(self, value, /)
  |      Return self<value.
  |
  |  __mul__(self, value, /)
  |      Return self*value.n
  |
  |  __ne__(self, value, /)
  |      Return self!=value.
  |
  |  __new__(*args, **kwargs) from builtins.type
  |      Create and return a new object.  See help(type) for accurate signature.
  |
  |  __repr__(self, /)
  |      Return repr(self).
  |
  |  __reversed__(...)
  |      L.__reversed__() -- return a reverse iterator over the list
  |
  |  __rmul__(self, value, /)
  |      Return self*value.
  |
  |  __setitem__(self, key, value, /)
  |      Set self[key] to value.
  |
  |  __sizeof__(...)
  |      L.__sizeof__() -- size of L in memory, in bytes
  |
  |  append(...)
  |      L.append(object) -> None -- append object to end
  |
  |  clear(...)
  |      L.clear() -> None -- remove all items from L
  |
  |  copy(...)
  |      L.copy() -> list -- a shallow copy of L
  |
  |  count(...)
  |      L.count(value) -> integer -- return number of occurrences of value
  |
  |  extend(...)
  |      L.extend(iterable) -> None -- extend list by appending elements from the iterable
  |
  |  index(...)
  |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
  |      Raises ValueError if the value is not present.
  |
  |  insert(...)
  |      L.insert(index, object) -- insert object before index
  |
  |  pop(...)
  |      L.pop([index]) -> item -- remove and return item at index (default last).
  |      Raises IndexError if list is empty or index is out of range.
  |
  |  remove(...)
  |      L.remove(value) -> None -- remove first occurrence of value.
  |      Raises ValueError if the value is not present.
  |
  |  reverse(...)
  |      L.reverse() -- reverse *IN PLACE*
  |
  |  sort(...)
  |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
  |
  |  ----------------------------------------------------------------------
  |  Data and other attributes defined here:
  |
  |  __hash__ = None

2)获取对象和当前作用域的属性列表：dir()

 import math

 print(dir(math))

 -----输出结果-----
 ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

3)返回对象的唯一标识符：id()

 name='boxiaoyuan'

 print(id(name))

 ------输出结果------
 

4)获取对象的hash码：hash()

 name='boxiaoyuan'

 print(hash(name))

 -------输出结果------
 

5)根据参数返回参数的类型或者返回创建的新的对象：type() 

 print(type())
 class A(object):
     name='zhangsan'

 class B(object):
     name='lisi'

 cObject=type('C',(A,B),{'name':'boxiaoyuan'}) #第一个参数是一个新的对象的名称，第二个参数是基类，第三个参数是属性
 print(cObject.name)

 -------输出结果-----
 <class 'int'>
 boxiaoyuan

6)查看对象的长度：len()

 print(len('abcde'))

 print(len({'a':}))

 print(len((,,,)))

 ------输出结果------

7)调用对象的__repr__，获取该方法的返回值：ascii()

 # -*- coding:utf- -*-

 class Person:

     def __repr__(self):
         return "hello world"

 if __name__ == '__main__':
     person = Person()
     print(ascii(person))

8)返回对象的格式化值：format()

 #.通过位置
 x='a={} b={} c={}'.format('zhangsan','lisi','boxiaoyuan') #{} 不带参数
 print(x)
 y='a={1} b={0} c={2}'.format('zhangsan','lisi','boxiaoyuan') #{} 带参数
 print(y)
 #.通过关键字参数
 z='my English name is {name},my age is {age}'.format(name='boxiaoyuan',age='')
 print(z)
 #.通过对象属性
 class Person:
     def __init__(self,name,age):
         self.name=name
         self.age=age

 p=Person('boxiaoyuan',)
 print('name={p.name},age={p.age}'.format(p=p))
 #.通过下标
 a1=[,,,]
 a2=['a','b','c']

 print('{0[0]},{1[1]}'.format(a1,a2))
 #.格式化输出
 print('左对齐定长10位 [{:<10}]'.format())  #对齐与填充
 print('右对齐定长10位 [{:>10}]'.format())
 print('右对齐定长10位，以0填充 [{:0>10}]'.format())

 print('[{:.2f}]'.format(13.123456)) #小数点输出
 print('[{:,}]'.format(12345.1234567))#以逗号分割金额

 print('10转换为2进制：{:b}'.format())  #进制转换

 -------输出结果------
 a=zhangsan b=lisi c=boxiaoyuan
 a=lisi b=zhangsan c=boxiaoyuan
 my English name is boxiaoyuan,my age is
 name=boxiaoyuan,age=
 ,b
 左对齐定长10位 [        ]
 右对齐定长10位 [        ]
 右对齐定长10位，以0填充 []
 [13.12]
 [,345.1234567]
 10转换为2进制：

 9)返回当前作用域的局部变量和对象的属性列表和值：vars()

 name='zhangsan'
 print(vars())  #不传入参数时和locals等效，
 print(locals())
 class A(object):
     name='boxiaoyaun'

 print(vars(A))

 -------输出结果------
 {'name': 'zhangsan', '__cached__': None, '__doc__': None, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/pythontest/test06.py', '__name__': '__main__', '__package__': None, '__spec__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020E15CF6BE0>}
 {'name': 'zhangsan', '__cached__': None, '__doc__': None, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/pythontest/test06.py', '__name__': '__main__', '__package__': None, '__spec__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020E15CF6BE0>}
 {'name': 'boxiaoyaun', '__module__': '__main__', '__doc__': None, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>}

 5.交互类函数

input，print

1)键盘输入：input()

 password = input("请输入您的银行卡密码：")
 print(password)

 -----输出结果-----
 请输入您的银行卡密码：123456
 123456

 2)输出到控制台：print()

%被称为格式化操作符，专门用于处理字符串中的格式。

格式化输出：

格式	解释	备注
%d	整数	%06d，表示显示如果显示的数字不够6位前面用0填充
%f	浮点数	%.2f表示小数点后只显示两位
%s	字符串
%%	输出百分号

 name = "小明"
 print("hello %s" % name)
 age =
 print("小明， 你的学号是：%06d" % )
 price = 2.56
 weight =
 total = price * weight
 print("小明，苹果的单价是%.2f，你买了%.2f斤，共%.2f元" % (price,weight,total))

 --------输出结果------
 hello 小明
 小明， 你的学号是：
 小明，苹果的单价是2.，你买了12.00斤，共30.72元

在默认情况下，print函数输出内容之后，会自动在内容末尾增加换行，如果不希望末尾添加换行，可以在print函数输出内容的后面增加,end=""，其中""中间可以指定print函数输出内容之后，继续希望显示的内容。

语法格式如下：

 # 向控制台输出内容结束之后，不会换行
 print("*",end="")

 # 单纯的换行
 print("")

 6.编译执行类函数

eval，exec，repr，compile

1)将字符串当成有效的表达式来求值并返回计算结果：eval()

 print(eval('1 + 1'))

在开发时不要使用eval直接转换input的结果，因为这样可以使用户任意执行操作系统命令，不安全

如__import__('os').system('ls')

2)执行动态语句块：exec()

 # -*- coding:utf- -*-

 exec('x = 3+6')
 print(x)

3)返回对象的字符串表现形式给解释器：repr()

 In []: a = 'test text'

 In []: str(a)
 Out[]: 'test text'

 In []: repr(a)
 Out[]: "'test text'"

 In []:

4)将字符串编译为可以通过exec进行执行或者eval进行求值：complie()

 # -*- coding:utf- -*-

 code = 'for a in range(1, 7): print(a)'

 comp = compile(code, '', 'exec')  # 流程的语句使用exec

 exec(comp)

 code1 = '1 + 2 + 3 + 4'

 comp1 = compile(code1, '', 'eval')  # 求值使用eval

 print(eval(comp1))

7.文件操作类函数

open，globals，locals

1)打开文件，并返回文件对象：open()

 # -*- coding:utf- -*-

 with open("d:test.txt", "r") as file:
     for line in file:
         print(line, end="")

8.变量操作类函数

1)获取当前作用域的全局变量和值的字典：globals()

>>> globals()
{'__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__name__': '__main__', '__spec__': None, '__builtins__': <module 'builtins' (built-in)>}
>>> a =
>>> globals()
{'__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__name__': '__main__', '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, 'a': 4}

2)获取当前作用域的局部变量和值的字典：locals()

 >>> def func():
 ...     print('before a')
 ...     print(locals())
 ...     a =
 ...     print('after a')
 ...     print(locals())
 ...
 >>> func()
 before a
 {}
 after a
 {'a': 2}
 >>>

9.反射操作类函数

__import__，isinstance，issubclass，hasattr，getattr，setattr，delattr，callable

1)动态导入模块：__import__()

 # -*- coding:utf- -*-

 time = __import__("time")
 now = time.localtime()
 print(time.strftime("%Y-%m-%d %H:%M:%S", now))

2)判断对象是否是给定类的实例：isinstance()

 In []: isinstance(, int)
 Out[]: True

 In []: isinstance('', (int, str))
 Out[]: True

3)判断类是否为给定类的子类：issubclass()

 In []: issubclass(bool, int)
 Out[]: True

 In []: issubclass(bool, (int, str))
 Out[]: True

 In []:

4)判断对象是有含有给定属性：hasattr();获取对象的属性值：getattr();设置对象的属性值：setattr();删除对象的属性值：delattr()

 In []: class Person:
    ...:     def __init__(self, name):
    ...:         self.name = name
    ...:

 In []: p = Person('zhangsan')

 In []: hasattr(p,'name')
 Out[]: True

 In []: getattr(p, 'name')
 Out[]: 'zhangsan'

 In []: setattr(p, 'name','lisi')

 In []: getattr(p, 'name')
 Out[]: 'lisi'

 In []: delattr(p, 'name')

 In []: getattr(p, 'name')
 ---------------------------------------------------------------------------
 AttributeError                            Traceback (most recent call last)
 <ipython-input--ee5bfa7ae925> in <module>
 ---->  getattr(p, 'name')

 AttributeError: 'Person' object has no attribute 'name'

5)检查对象是否可被调用：callable()

 # -*- coding:utf- -*-

 class Person:

     def __init__(self, name):
         self.name = name

     def __call__(self, *args, **kwargs):
         print("实例可以被调用")

 p = Person("张三")
 p()  # 类定义了__call__，代表该类的实例可以被调用