Python内置函数
详情参见官方说明：https://docs.python.org/3/library/functions.html?highlight=built#built-in-functions
abs()
#绝对值
print(abs(-9.04)) #9.04
print(abs(-9)) #9
print(abs(9)) #9
- all()
#all(iterable)传入可迭代的元素，如果所有元素都为真则返回True，如果有一个为假，返回False。
#注意：all传入的空元组、空列表、空字典也为真，any传入这些则为假。all()相当于下面代码：
'''
def all(iterable):
for element in iterable:
if not element:
return False
return True
'''
# print(all(10)) #TypeError: 'int' object is not iterable
print(all((0,1,-2))) #False，0是False
print(all([1,2,'a'])) #True
print(all({0:1})) #False
print(all({1:'a'})) #True
any()
#any(iterable)如果其中元素有一个为真，则为真。反之为假。
print(any(['a',0,2]))
print(any([])) #False
print(all([])) #True,注意与all()的区别
ascii()
#相当于repr(),返回一个可打印的字符串对象，
print([ascii([1,'a',3])]) #['[1, 'a', 3]']
s = ascii(1)
print(s) #q
print(type(s)) #<class 'str'>
bin()
#把数字换成'0b'开头的二进制
print(bin(2)) #0b10
print(bin(-255)) #-0b11111111
#如果不需要'0b'可以使用以下方法
print(format(14, '#b')) #0b1110
print(format(14, 'b')) #1110
print(f'{14:#b}') #0b1110
print( f'{14:b}') #1110
bool()
#判断元素，并返回相应的bool值，True或False
#空列表、空元组、空字典、空字符串、0、None都是False
print(bool(0)) #False
print(bool([])) #False
print(bool(())) #False
print(bool({})) #False
print(bool(None)) #False
print(bool('')) #False
print(bool(' ')) #True
print(bool(-1)) #True
print(bool(1)) #True
print(bool(not False)) #True
breakpoint()
breakpoint(*args, **kws)
This function drops you into the debugger at the call site. Specifically, it calls sys.breakpointhook(), passing args and kws straight through. By default, sys.breakpointhook() calls pdb.set_trace() expecting no arguments. In this case, it is purely a convenience function so you don’t have to explicitly import pdb or type as much code to enter the debugger. However, sys.breakpointhook() can be set to some other function and breakpoint() will automatically call that, allowing you to drop into the debugger of choice.
New in version 3.7.
bytearray()
#返回一个字节数组
'''
a.如果传入的是字符串，则需要加入编码。
b.如果传入的是1个整数，那返回的该数组将具有该大小，并使用空字节初始化
c.如果传入的是1个可迭代的对象，里面的整数范围是0<=x<256。
d.如果没有参数则会创建一个大小为0的数组
e.如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
'''
print(bytearray('你好',encoding='utf-8')) #bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
print(bytearray(2)) #bytearray(b'\x00\x00')使用空字节占用2个空间
print(bytearray([2,99,5,8])) #bytearray(b'\x02c\x05\x08')
# print(bytearray((256,2,5,8))) #ValueError: byte must be in range(0, 256)
print(bytearray()) #bytearray(b'')
print(bytearray(range(10))) #bytearray(b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t')
bytes()
#返回一个新的不可变的字节对象,整数范围是0<=x<256，可进行索引切片等操作。
x = bytes('你好，python',encoding='utf-8')
print(type(x)) #<class 'bytes'>
print(x) #<class 'bytes'>
y = bytes([11,2,5,6])
print(y) #b'\x05\x06'
print(y[1]) #2
print(y[2:4]) #b'\x05\x06'
callable()
#判断是不是一个可调用对象对象(函数、类)
def fuc():
print('hello,world')
print(callable(fuc)) #True
class Foo:
pass
print(callable(Foo)) #True
print(callable([1,2])) #False
chr()
#返回Unicode的整数码对应的字符,与之相反的是ord
print(chr(97)) #a
print(chr(65)) #A
classmethod()
#将方法转换为类方法。
# classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
class C:
@classmethod
def f(cls, arg1, arg2, ...): ...
compile()
#compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
#将字符串编译为字节代码。
code='''
l = []
for i in range(10):
l.append(i)
print(l)
'''
c = compile(code,'',mode='exec')
print(exec(c))
'''
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
None
'''
complex()
Return a complex number with the value real + imag*1j or convert a string or number to a complex number.
太深奥，不懂！！！
delattr()
#该函数用于删除属性
#delattr(x, 'foobar') 等价于 del x.foobar.
'''
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
'''
class Test:
x = 'a'
y = 'b'
z = 'c'
t = Test()
print(t.x)
#删除y属性
delattr(Test,'y')
# print(t.y) #AttributeError: 'Test' object has no attribute 'y'
dict()
#创建字典
d=dict({1:'a'})
print(d)
print(dict()) #不带参数返回空字典
dir()
#返回对象的属性和方法
print(dir(str))
divmod()
#计算两个数，返回一个包含商和余数的元组
x = divmod(5,3)
print(x) #(1, 2)
print(type(x)) #<class 'tuple'>
print(divmod(10,2)) #(1, 2)
enumerate()
#enumerate(iterable, start=0)
#返回一个enumerate对象，传入的参数必须是一个序列、迭代器或可迭代的对象。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons))) #[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
print(list(enumerate(seasons, start=1))) #[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
t = ('Spring', 'Summer', 'Fall', 'Winter')
for m,n in enumerate(t,1):
print(m,n)
'''
等价于：
def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield n, elem
n += 1
'''
eval()
#将字符串变成代码执行
print(eval('1+2+3'))
x,y = 5,2
z = 'x**y'
print(eval(z))
exec()
# exec执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码,返回值为None
code = 'for i in range(10):print(i)'
x = exec(code)
print("返回值%s:" %x)
filter()
#filter(function, iterable)
#过滤序列
def func(n):
if n%2 == 0:
return n
l = filter(func,[x for x in range(10)])
for i in l:
print(i)
l1 = filter(lambda n:n*2,[1,2,3,4])
print(l1.__next__())
float()
#返回浮点数，可将字符串返回浮点数
#“inf”，“Inf”，“INFINITY”和“iNfINity”都是正无穷大
print(float(1)) #1.0
print(float('1.2')) #1.2
print(float(' 3.1415926 \n \r')) #3.1415926
print(float('inf')) #inf
print(float('Inf')) #inf
print(float('iNfINity')) #inf
print(float('Infinity')) #inf
format()
#字符串格式化
#第一种方法,按顺序匹配
s = "李白是一位{},他是{}主义派的代表人物".format('诗人','浪漫')
print(s)
#第二种方法,从0开始，指定位置匹配
s1 = "李白是一位{0},他是{1}主义派的代表人物".format('诗人','浪漫')
s2 = "李白是一位{1},他是{0}主义派的代表人物".format('浪漫','诗人')
print(s1)
print(s2)
#第三种方法，指定参数名匹配
s3 = "李白是一位{pos1},他是{pos2}主义派的代表人物".format(pos2 = '浪漫',pos1 = '诗人')
print(s3)
#第四种方法，指定参数名，字典形式匹配
s4 = "李白是一位{pos1},他是{pos2}主义派的代表人物".format(**{'pos2':'浪漫','pos1':'诗人'})
print(s4)
#第五种方法，列表形式匹配
s5 = "李白是一位{0[1]},他是{0[0]}主义派的代表人物".format(['浪漫','诗人'])
print(s5)
frozenset()
#class frozenset([iterable])
#返回一个新的不可变(冻结)的对象
l = set([1,1,'a','a'])
l.add('ABC')
print(l) #{1, 'ABC', 'a'}
l1 = frozenset(set([1,1,'a','a']))
# l1.add('ABC') #AttributeError: 'frozenset' object has no attribute 'add'
print(l1) #frozenset({1, 'a'})
getattr()
#getattr(object, name[, default])
#返回一个对象的属性值
#getattr(x, 'foobar') 等价于 x.foobar
class Test:
x = 1
y = 'abc'
t = Test()
print(getattr(t,'x'))
# print(getattr(t,'z')) #AttributeError: 'Test' object has no attribute 'z',不设置默认值，属性不存在报错
print(getattr(t,'z',80)) #80，设置默认值属性不存在则返回默认值
globals()
#函数会以字典类型返回当前位置的全部全局变量。
num = 1
li = [1,2,3]
def func():
name = 'zhangsan'
age = 18
print(globals())
hasattr()
#判断对象是否包含对应的属性。
class Test:
x = 1
t = Test()
print(hasattr(t,'x')) #True
print(hasattr(Test,'y')) #False
hash()
#获取对象哈希值，传入字符串或数字
print(hash(101))
print(hash(str([1,2,3])))
print(hash('abc'))
help()
#查看帮助文件
print(help(tuple))
'''
class tuple(object)
| tuple() -> empty tuple
| tuple(iterable) -> tuple initialized from iterable's items
|
| If the argument is a tuple, the return value is the same object.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(...)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __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).
|
| __rmul__(self, value, /)
| Return self*value.
|
| count(...)
| T.count(value) -> integer -- return number of occurrences of value
|
| index(...)
| T.index(value, [start, [stop]]) -> integer -- return first index of value.
| Raises ValueError if the value is not present.
None
'''
hex()
#将整数转化为带'0x'的16进制
print(hex(10)) #0xa
print(hex(255)) #0xff
id()
#查看内存地址
print(id(1))
x = [1,2,3]
print(id(x))
input()
#用户交互，获取输入信息，字符串格式
s = input('输入:')
print(s)
print(type(s))
'''
#查看内存地址
print(id(1))
x = [1,2,3]
print(id(x))
'''
int()
#整型，可以将字符格式的整数转化为int类型
print(int(5.0))
n = '100'
print(int(n))
print(type(int(n)))
isinstance()
#判断对象类型是否一致，返回值为bool值
#与type区分，type()不考虑继承关系，isinstance()考虑继承关系。判断类型使用isinstance,而不要使用type
# print(isinstance('a',int)) #False
# print(isinstance([1,2,3],list)) #True
# print(isinstance('a',(str,list,tuple))) #True
class A:
pass
class B(A):
pass
print(isinstance(A(), A)) # True
print(type(A()) == A) # True
print(isinstance(B(), A)) # True
print(type(B()) == A) # False
print(isinstance(A(),B)) # False
issubclass()
#issubclass(class, classinfo)
#判断前者是不是后者的子类
class A:
pass
class B(A):
pass
print(issubclass(A,str)) #False
print(issubclass(A,B)) #False
print(issubclass(A,A)) #True
print(issubclass(B,A)) #True
print(issubclass(A,object)) #True
iter()
#生成迭代器
l = [1,2,'a','b']
# print(next(l)) #TypeError: 'list' object is not an iterator
# print(l.__next__()) #AttributeError: 'list' object has no attribute '__next__'
l2 = iter(l)
print(type(l2)) #<class 'list'>
print(next(l2)) #1
print(l2.__next__()) #2
len()
#返回长度
print(len([1,2,3]))
print(len('python,你好'))
print(len((1,2,3)))
print(len({'a':1,'b':2}))
list()
#列表
l = list((1,2,3))
print(l) #[1, 2, 3]
locals()
#函数会以字典类型返回当前位置的全部局部变量。
num = 1
li = [1,2,3]
def func():
name = 'zhangsan'
age = 18
print("函数内：%s"%locals()) #函数内：{'age': 18, 'name': 'zhangsan'}
print('函数外：%s'%locals()) #返回变量中包含num、li没有name和age
func()
map()
# max(iterable, *[, key, default])
# max(arg1, arg2, *args[, key])
# 根据提供的函数对指定序列做映射,返回一个迭代器
l = []
li = map(lambda x:x+2,[1,2,3])
for i in li:
l.append(i)
print(l) #[3, 4, 5]
#传入列表，则按照顺序一一匹配规则
li2 = map(lambda x,y:x*y,[1,2,3,4,5,6],[2,2,2,2])
l.clear()
for i in li2:
l.append(i)
print(l)
max()
#返回最大值
print(max(22,33)) #33
print(max(range(10))) #9
print(max(1,1,2,3)) #3
print(max((1,2,34))) #34
print(max('1','a')) #a
memoryview()
#返回给定参数的内存查看对象
# m = memoryview('abc') #TypeError: memoryview: a bytes-like object is required, not 'str'
#python3.x需传入字节，python2.x没有该要求
m = memoryview(bytearray('abcdefg','utf-8'))
print(m)
print(type(m))
print(m[5])
print(m[2:5])
'''
<memory at 0x104111948>
<class 'memoryview'>
102
<memory at 0x104111a08>
'''
min()
#返回最小值
print(min(22,33))
print(min(range(10)))
print(min(1,1,2,3))
print(min((1,2,34)))
print(min('1','a'))
next()
#同__next__(),返回迭代器的下一个值
def func():
for i in range(10):
yield i
f = func()
print(f.__next__())
print(next(f))
object()
#所有类发父类，不接受任何参数。
oct()
#将整数转换为前缀为“0o”的八进制字符串
n = oct(8)
print(type(n)) #<class 'str'>
print(n) #0o10
open()
#打开文件
f = open('demo',mode='r',encoding='utf-8')
#详见文件操作
ord()
#给定表示一个Unicode字符的字符串，返回表示该字符的Unicode代码点的整数。
print(ord('A')) #65
print(ord('a')) #97
pow()
#pow（x，y [，z ] ）
#返回x的y次方。
#如果有参数z，则将x的y次方的值与z取模，返回余数。
print(pow(2,3)) #8，相当于：2**3
print(pow(2,3,3)) #2，相当于：2**3//3
print()
#print(*objects, sep=' ', end='\n', file=sys.stdout)
#print（* objects，sep =''，end ='\ n'，file = sys.stdout，flush = False
#打印文本流文件对象
print('hello world',end='\t')
print('hello')
print('world')
property()
http://www.runoob.com/python/python-func-property.html
range()
# range(stop)
# range(start, stop[, step])
l = list()
for i in range(10):
l.append(i)
print(l)
l1 = []
for i in range(0,10,2):
l1.append(i)
print(l1)
repr()
#返回一个可打印的字符串对象，类似eval()
print(repr('asd efg '))
print([repr(1234)])
print(repr([1,'a',3,'b']))
print(repr({1:'a',2:'b'}))
reversed()
#返回一个反转的迭代器
l = [9,8,7,5,4,3]
t = ('a','b','c')
l1 = reversed(l)
t1 = reversed(t)
print(l) #[9, 8, 7, 5, 4, 3]
print(l1) #<list_reverseiterator object at 0x10419f550>
print(t) #('a', 'b', 'c')
print(t1) #<reversed object at 0x10419f5f8> 同print(t1.__iter__())
print(l1.__next__()) #3
print(t1.__next__()) #c
print(t1.__iter__()) #<reversed object at 0x10419f5f8>
round()
#round(number[, ndigits])
#取小数点精度,会四舍五入，不加ndigits则取整
print(round(5.333)) #5
print(round(5.333,2)) #5.33
print(round(5.336,2)) #5.34
print(round(3562.67533445,-2)) #3600.0
set()
#集合
x = set([1,2,'a','b'])
print(type(x)) #set
print(x) #{1,2,'a','b'}
setattr()
#setattr(object, name, value)
#设置属性值，该属性必须存在,如果不存在则不做修改
class A():
x = 1
print(A.x)
setattr(A,'x',20)
print(A.x)
slice()
# class slice(stop)
# class slice(start, stop[, step])
# 用于切片，主要用在切片操作函数里的参数传递。
d = range(10)
print(d) #range(0, 10)
sli = slice(2,5,1)
d1 = d[sli]
print(d1) #range(2, 5)
print(d[2:5]) #range(2, 5)
sorted()
#sorted（iterable，*，key = None，reverse = False ）
#对可迭代对象进行排序，返回一个新的列表
'''
参数介绍：
iterable -- 可迭代对象。
key -- 主指定用来比较的元素，只有一个参数。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
'''
'''
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
'''
d = [[1,'d'],[3,'b'],[2,'c'],[4,'a']]
print("原数据：%s" %d)
d1 = sorted(d)
print("不指定比较参数排序：%s" %d1)
d2 = sorted(d,key=lambda k:k[1])
print("指定比较参数排序：%s" %d2)
d3 = sorted(d,key=lambda k:k[1],reverse=True)
print("指定比较参数降序排序：%s" %d3)
staticmethod()
#声明静态方法
class Test(object):
@staticmethod
def f():
print('static func()');
Test.f() # 静态方法无需实例化
t = Test()
t.f() # 也可以实例化后调用
str()
# class str(object='')
# class str(object=b'', encoding='utf-8', errors='strict')
#字符串
s = str(123)
print(type(s)) #<class 'str'>
print(s)
sum()
# sum（iterable [，start ]）
# 求和。Sums 从左到右开始和迭代的项目并返回总数。 开始默认为0。该迭代的项目通常是数字，起始值不允许是一个字符串。
# 指定start，则前面相加之后再加上start值并返回结果,返回值是int类型。
print(sum([])) #0
print(sum([1,2,3,4],22)) #32，相加之后再加22
print(sum([5,5],100)) #110
super()
# super() 函数是用于调用父类(超类)的一个方法。
class Foo():
def __init__(self):
# self.parent = 'I\'m the parent.'
print('Foo')
class Goo(Foo):
def __init__(self):
super(Goo, self).__init__()
print('Child')
fooChild = Goo()
tuple()
#元组
t = tuple([1,2,3])
print(t)
type()
#查看类型
print(type('123')) #<class 'str'>
print(type(123)) #<class 'int'>
vars()
#返回对象object的属性和属性值的字典对象。
#返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。
num = 1
print(vars())
class A:
xx = 100
print(vars(A))
print(vars())
zip()
#zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回一个对象，py2.x直接返回一个列表，py3.x需使用列表转换。
# 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
a = [1,2,3]
b = [4,5,6]
c = ['a','b','c','d','e']
zipped = zip(a,b) # 打包为元组的列表
print(zipped)
print(list(zipped))
print(list(zip(a,c,b)))
__import__()
#__import__() 函数用于动态加载类和函数，如果一个模块经常变化就可以使用该函数来动态载入。
#__import__（name，globals = None，locals = None，fromlist =（），level = 0 ）
#这是日常Python编程中不需要的高级函数。
All is well~
