Python3内置函数表.md

>>> import builtins
>>> dir(builtins)

['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError',
'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError']

['__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__',]

#内置函数
['abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']

#!/use/bin/python3
#coding utf-8
#内置函数

#1.(input) / print
value = input("请输入一串字符或者数值:")
print("输入的值为 ：",value," | 类型：",type(value))

#2.(type)
a = '520' 
print(type(a))    #<class 'str'>
print(type(5.2))  #<class 'float'>
print(type(True))  #<class 'bool'>

#3.isinstance(类型值,类型) =>类型值能匹配上类型则为True,否则False
print(isinstance(a,str))
print(isinstance(12,int))
print(isinstance(12.5,float))
print(isinstance(True,bool))


#4.assert 断言的使用
>>> assert 3 > 4       //程序为假就assert报错
Traceback (most recent call last):
  File "<pyshell#51>", line 1, in <module>
    assert 3 > 4
    AssertionError

#5.range()-BIF函数生成序列
print(list(range(5)))  #[0, 1, 2, 3, 4]
for i in range(10):      //默认是从0开始不包含10
  print(i,end=" ")  #0 1 2 3 4 5 6 7 8 9

#6.sorted 排序功能 / 7.reversed
sorted([23,56,2,16,96,12,14])   # [2, 12, 14, 16, 23, 56, 96]
list(reversed([23,56,2,16,96,12,14]))   #reversed 返回的是一个对象, 再用reversed转换成列表显示反序  [14, 12, 96, 16, 2, 56, 23]

#8.enumerate  
list(enumerate([23, 56, 2, 16, 96, 12, 14])) #进行枚举，返回对象然后经过list返回一个（ 索引+数值）的列表元组 //[(0, 23), (1, 56), (2, 2), (3, 16), (4, 96), (5, 12), (6, 14)]
for index,line in enumerate(f): # 还可以将打开的文件进行获取index 与 每一行的值 （当文件较大的时候推荐使用）
    print(index,line)  # 0 #!/usr/bin/python3

#9.zip 列表对应
list(zip([1,2,3], [4,5,6,7]))    #//a与b的列表是一一对应的[(1, 4), (2, 5), (3, 6)]

#10.map 映射功能 注意：强大的map()后边是可以接受多个序列作为参数的。
map(lambda x: x ** 2, [1, 2, 3, 4, 5])   #使用 lambda 匿名函数与map映射 [1, 4, 9, 16, 25]
list(map(lambda x, y : [x, y], [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))  #打包形式是列表而不是元组
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]  


#11.filte 过滤出1~100中平方根是整数的数 #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(list(filter(lambda x: math.sqrt(x) % 1 == 0,range(100))))  

#13.bin 二进制转换
bin(255)  #'0b11111111'

#14.locals
>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}


#15.issubclass()  类的内置函数.START
class t1:
  pass

class t2(t1):
  noneValue = None  #为空值,相当于C中的null
  def __init__(self,x=0):
    self.x = x

print(issubclass(t2,t1))  #t2 是 t1 的子类为真
test = t2(1024)
print(isinstance(test,t1))  #为真的实例化对象test是t1实例化对象

#16.hasattr 注意对象属性是要传入字符串
print(hasattr(test,'x'))  #‘x’是test对象的属性 返回 True

#17.getattr 获取对象属性值
print(getattr(test,'x'))   #1024
print(getattr(test,'e','实例化对象中没有 e 属性')) #有实例化对象中没有 e 属性

#18.setattr  设置对象属性值
setattr(test,e,'Hello world')
print(getattr(test,'e','实例化对象中没有 e 属性')) #hello world

#19.delattr 删除对象属性
delattr(test,'e')

#20.property() 利用属性设置属性（将方法再次进行封装调用,无论里面方法名怎么改,接口始终是不变得）！important
class getSize:
    def __init__(self,size = 0):
        self.size = size
    def getsize(self):
        return self.size
    def setsize(self,value):
        self.size = value
    def delsize(self):
        del self.size
    
    x = property(getsize,setsize,delsize,"I'm the 'x' property.") #包含该类建立得一些方法 (此时x是一个属性)

demo = getSize(1024) #实例化对象
print(demo.x)  #利用属性获取方法返回值  1024
demo.x = 2048  #利用属性设置方法值
print(demo.x)  #获取值   2048
del demo.x     #删除值

>>> class A:
...     pass
>>> class B(A):   #B 是 A 的子类
...     pass
>>> isinstance(A(), A)  #True
>>> type(A()) == A      #True
>>> isinstance(B(), A)  #True
>>> type(B()) == A      #False

#!/usr/bin/python3
#coding:utf-8
#字符串内置方法

string = "thisisdemo"
print(string.capitalize())    #首字母大写 Thisisdemo
print(string.center(30,'-'))  #将指定字符居中,将剩下的使用-填充 Thisisdemo
print(string.count('i'))      #字符在字符串出现的次数 2

str = "Python编程语言"
str_gbk = str.encode("GBK")
print(str)   #字符编码
print("UTF-8 编码：",str.encode("UTF-8"))  # UTF-8 编码： b'Pythonxe7xbcx96xe7xa8x8bxe8xafxadxe8xa8x80'
print("GBK 编码：", str_gbk )  #GBK 编码： b'Pythonxb1xe0xb3xccxd3xefxd1xd4'
print(str_gbk.decode('GBK','strict'))     #字符解码 Python编程语言

print(str.endswith('言'))  #判断是否以它结尾返回 True
print(str.find('thon'))  #检测 str 是否包含在字符串中如果包含返回开始的索引值 2
print(str.rfind('thon'))  #同上只不过是从右开始查找 2

print("1234578".isdigit()) #检测字符串是不是都是数字 true
print(string.islower())   #如果字符串中包含至少一个区分大小写的字符
str = "This is String Example...Wow!!!"
print (str.title())   #将字符串所有的单词拼写首字母为大写 This Is String Example...Wow!!!
print (str.istitle())  #所有的单词拼写首字母是否为大写

print("ABC".lower())  #将大写转换成小写  abc
print("abc".upper())  #将小写转换成大写  ABC

# 创建字符映射的转换表
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab,outtab)
str = "this is string example....wow!!!"  #th3s 3s str3ng 2x1mpl2....w4w!!!
print(str.translate(trantab))  #将str字符串的存在的字符采用映射表来替代 比如 i -> 3

str.maketrans('s','S')     # {115: 83} 返回Ascii码
str.maketrans('A','a')    # {65: 97}   返回Ascill码

print(str.replace('this','demo'))  #字符串替换
print(" this is a string ".strip())  #清空两边的空格 还有lstrip() / rstrip()
print('-'.join("this"))  #将序列中的元素以指定的字符连接生成一个新的字符串 t-h-i-s
print(str.split(" ")) #字符分割返回列表 ['this', 'is', 'string', 'example....wow!!!']
print("this".zfill(10)) #原字符串右对齐，前面填充0  000000this
print("t r his n is n".splitlines())  #按照 ('r', 'rn', n') 进行分割字符串 返回列表 ['t ', ' his ', ' is ']
test = """
... I love you baby
... vercy
... add string"""
test.splitlines() #['', 'I love you baby', 'vercy', 'add string']

'XiaotJiatYutPython'.expandtabs(tabsize=2)  # 把字tab符号转为空格  'Xiao  Jia Yu  Python'
'I test you'.partition('t')                    # 分割成元组 ('I ', 't', 'est you')

"{0} love {1} {2}".format("I","fishc","com")         #  //位置参数  'I love fishc com'
"{a} love {b} {c}".format(a="I",b="fishc",c="com")   #  //关键字参数 'I love fishc com'
"{0} love {b} {c}".format("I",b="fishc",c="com")      #//混合使用 #也可以将两则混合使用，但关键字参数必须在未知参数后 
"{{123123213}}".format("不打印")                      #//'{123123213}' 字符串转义

#!/usr/bin/python
#功能：获取列表内置方法
dir(list)  #查看内置方法

member = ['list1','list2','list3']
print("列表长度：",len(member))

#列表是一个大杂缸可以进行比较 可以进行一些 常用操作符
list1 = [123]
list2 = [234]
print(list1 > list2) #进行逻辑判断
list3 = [234]
print((list1 < list2) and (list2 == list3))  #进行逻辑判断

#列表添加方法
member.insert(0,'0insert') #头部插入    //member是对象,append()是对象的一个方法
member.insert(2,'2insert') #指定位置插入
member.extend(['list3','list4']) #从新建立的一个列表中添加到另外一个列表中，所以extend()中的数据必须是列表.
member.append(['4apped1','4apped2']) #尾部插入列表
print(member)

#列表删除元素
member.remove('2insert') #不需要知道位置,只需要知道list中的元素数据
del member[0] #加上列表的索引就删除该索引上的元素,加上列表对象就删除该列表.
print(member.pop()) #列表利用栈这个数据结构进行存储,因此有了pop()方法进行弹栈,默认从列表中取出最后一个元素给你
member.pop(2)  #还可以加入索引值，进行弹栈 
print(member,end="nn")

print(member.count('list3')) #统计元素出现次数
print(member.index('list2')) #元素索引,根据元素来搜索索引下标

member.reverse()  #列表重新排序
print(member,end="nn")

#采用sort按照指定的方式进行排序
#sort(func[指定排序的算法],key[与算法搭配的关键字])  => 默认算法归并排序
list1 = [4,8,10,58,2,6]
list1.sort()
print(list1)
list1.sort(reverse=True)  #或者直接采用reverse=True  => 列表中的元素必须是同一类型
print(list1)

#清空与复制列表
list2 = member.copy()
print(list2) #复制列表
list2.clear() #清空列表返回 []
print(list2)

# -*-coding:utf-8 -*-
import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
 
b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝
 
a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象
 
print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d
输出结果：
a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c =  [1, 2, 3, 4, ['a', 'b', 'c']]  #浅拷贝 追加不会修改/但是可以修改
d =  [1, 2, 3, 4, ['a', 'b']]       #深拷贝

#!/usr/bin/python3
#功能：集合内置函数

set1 = {1,2,3,5,6,7}
set2 = {7,11,9,10}
set1.add(8)  #添加集合元素
print("添加元素：",set1)  #添加元素： {1, 2, 3, 5, 6, 7, 8}
set1.update(set2)  #可以直接添加集合到 目标集合中
print("update：",set1)  #update： {1, 2, 3, 5, 6, 7, 8, 9, 10, 11}


set1 = set2.copy()  #拷贝集合
print("拷贝：",set1)    #拷贝： {9, 10, 11, 7}

print("pop 移除:",set2.pop())  #随机移除元素  pop 移除: 9
set2.remove(11)  #移除指定元素,元素不存在报错
set2.discard(10)  #移除指定元素，元素不存在不报错
print("remove：",set2)  #remove： {7}

set2.clear()  #清空集合
print("清空：",set2)    #清空： set()

#差集
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y)  #即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。
print(z)  #{'cherry', 'banana'}

x.difference_update(y)  #移除两个集合都包含的元素（直接在集合里面修改）
print("差集",x)  #差集 {'cherry', 'banana'}

#交集
x = {1,4,6}
y = {2,1,7}
z = x.intersection(y)
print("交集",z)   #交集 {1}

#并集
z = x.union(y)
print("并集：",z) #并集： {1, 2, 4, 6, 7}

#亦或集（两个集合中都不存在的集合）
z = x.symmetric_difference(y)
print("异集：",z)

#判断是否为子集
print({"a", "b", "c"}.issubset({"f", "e", "d", "c", "b", "a"})) #判断集合 x 的所有元素是否都包含在集合 y 中
print({"f", "e", "d", "c", "b", "a"}.issuperset({"a", "b", "c"}))#判断集合 y 的所有元素是否都包含在集合 x 中

#判断两个集合是否包含相同的元素
print("集合相同与否：",x.isdisjoint(y))

#冻结集合（不能被添加也不能被修改）
num = frozenset([1,2,3,4])  #frozenset({1, 2, 3, 4}) <class 'frozenset'>

#!/usr/bin/python3
#coding:utf-8
#功能：字典内置函数
dict1 = {"one":'weiyigeek',"two":"tterdst"}
dict2 =dict.fromkeys(('name','age'),'weiyigeek')
print("字典：",str(dict1),"类型:",type(dict1))
print("建立字典：",str(dict2))

print("姓名：",dict1.get('one'))
print("未知：",dict1.setdefault('three',"ValueNULL"))

print("Key :",list(dict1.keys()))
print("Value :",list(dict1.values()))
print("dict :",dict1.items()) #dict_items([('one', 'weiyigeek'), ('two', 'tterdst'), ('three', 'ValueNULL')])

dict1.update({'four':'update'}) #添加键值对
print("添加键值对：",dict1) #{'one': 'weiyigeek', 'two': 'tterdst', 'three': 'ValueNULL', 'four': 'update'}

print("pop('one') :",dict1.pop('one'))  #删除指定key与值并返回值 weiyigeek
print("popitem() :",dict1.popitem())  #删除末尾key ('four', 'update')

dict2.clear()
print("清空字典：",dict2)  #清空字典： {}

#成员运算符
print("判断键是不是在字典中：",'two' in dict1)  # True

#文件打开模式
'r'	以只读方式打开文件（默认）
'w'	以写入的方式打开文件，会覆盖已存在的文件
'x'	如果文件已经存在，使用此模式打开将引发异常
'a'	以写入模式打开，如果文件存在，则在末尾追加写入
'b'	以二进制模式打开文件
't'	以文本模式打开（默认）
'+'	可读写模式（可添加到其他模式中使用）
'U'	通用换行符支持

#!/usr/bin/python3
#功能：文件系统

#文件读取
file = open('.//python.txt',mode='r+',encoding='utf-8')  
print(file)  #指针对象

#返回一个列表,文件指针指向末尾.
print(file.readlines())  
print("文件指针位置：",file.tell())

#修改文件指针指向初始位置
file.seek(0,0)

print("文件读取",file.read())  #文件读取
file.seek(0,0)
print("读取行: %s" % (file.readlines()))

#用于截断文件并返回截断的字节长度,从第10个字节以后的内容全部删除了
file.seek(10)
file.truncate()  #默认截取当前指针位置
file.seek(0,0)
print("读取行: %s" % (file.readlines()))
file.close()  #关闭文件


f = open("test.txt",'w+',encoding='utf-8')    #写入文件

print ("文件描述符为: ", f.fileno()) #文件描述符为:  3

f.write("这是一个文件写入,为了不乱码需要指定utf-8编码")
f.writelines("文件写如一行字符串")
f.flush()   #将缓存区的数据写入文件/并清空缓存区（进行选择性写入）
f.close()

__new__(cls[, ...]) 
1.  __new__ 是在一个对象实例化的时候所调用的第一个方法
2. 它的第一个参数是这个类，其他的参数是用来直接传递给 __init__ 方法
3. __new__ 决定是否要使用该 __init__ 方法，因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 __new__ 没有返回实例对象，则 __init__ 不会被调用
4. __new__ 主要是用于继承一个不可变的类型比如一个 tuple 或者 string
__init__(self[, ...]) 	构造器，当一个实例被创建的时候调用的初始化方法
__del__(self)	析构器，当一个实例被销毁的时候调用的方法
__call__(self[, args...]) 	允许一个类的实例像函数一样被调用：x(a, b) 调用 x.__call__(a, b)
__len__(self)	定义当被 len() 调用时的行为
__repr__(self)	定义当被 repr() 调用时的行为
__str__(self)	定义当被 str() 调用时的行为
__bytes__(self)	定义当被 bytes() 调用时的行为
__hash__(self)	定义当被 hash() 调用时的行为
__bool__(self)	定义当被 bool() 调用时的行为，应该返回 True 或 False
__format__(self, format_spec)	定义当被 format() 调用时的行为
__bases__(self)   #补充，显示其基类

__getattr__(self, name)	定义当用户试图获取一个不存在的属性时的行为
__getattribute__(self, name)	定义当该类的属性被访问时的行为
__setattr__(self, name, value)	定义当一个属性被设置时的行为
__delattr__(self, name)	定义当一个属性被删除时的行为
__dir__(self)	定义当 dir() 被调用时的行为
__get__(self, instance, owner)	定义当描述符的值被取得时的行为
__set__(self, instance, value)	定义当描述符的值被改变时的行为
__delete__(self, instance)	定义当描述符的值被删除时的行为

__lt__(self, other)	定义小于号的行为：x < y 调用 x.__lt__(y)
__le__(self, other)	定义小于等于号的行为：x <= y 调用 x.__le__(y)
__eq__(self, other)	定义等于号的行为：x == y 调用 x.__eq__(y)
__ne__(self, other)	定义不等号的行为：x != y 调用 x.__ne__(y)
__gt__(self, other)	定义大于号的行为：x > y 调用 x.__gt__(y)
__ge__(self, other)	定义大于等于号的行为：x >= y 调用 x.__ge__(y)

__add__(self, other)	定义加法的行为：+
__sub__(self, other)	定义减法的行为：-
__mul__(self, other)	定义乘法的行为：*
__truediv__(self, other)	定义真除法的行为：/
__floordiv__(self, other)	定义整数除法的行为：//
__mod__(self, other)	定义取模算法的行为：%
__divmod__(self, other)	定义当被 divmod() 调用时的行为，返回值是一个元组(a//b,a%b)
__pow__(self, other[, modulo]) 	定义当被 power() 调用或 ** 运算时的行为
__lshift__(self, other)	定义按位左移位的行为：<<
__rshift__(self, other)	定义按位右移位的行为：>>
__and__(self, other)	定义按位与操作的行为：&
__xor__(self, other)	定义按位异或操作的行为：^
__or__(self, other)	定义按位或操作的行为：|

__radd__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rsub__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rmul__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rtruediv__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rfloordiv__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rmod__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rdivmod__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rpow__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rlshift__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rrshift__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rand__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__rxor__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
__ror__(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）

__iadd__(self, other)	定义赋值加法的行为：+=
__isub__(self, other)	定义赋值减法的行为：-=
__imul__(self, other)	定义赋值乘法的行为：*=
__itruediv__(self, other)	定义赋值真除法的行为：/=
__ifloordiv__(self, other)	定义赋值整数除法的行为：//=
__imod__(self, other)	定义赋值取模算法的行为：%=
__ipow__(self, other[, modulo])	定义赋值幂运算的行为：**=
__ilshift__(self, other)	定义赋值按位左移位的行为：<<=
__irshift__(self, other)	定义赋值按位右移位的行为：>>=
__iand__(self, other)	定义赋值按位与操作的行为：&=
__ixor__(self, other)	定义赋值按位异或操作的行为：^=
__ior__(self, other)	定义赋值按位或操作的行为：|=

__pos__(self)	定义正号的行为：+x
__neg__(self)	定义负号的行为：-x
__abs__(self)	定义当被 abs() 调用时的行为
__invert__(self)	定义按位求反的行为：~x

__complex__(self)	定义当被 complex() 调用时的行为（需要返回恰当的值）
__int__(self)	定义当被 int() 调用时的行为（需要返回恰当的值）
__float__(self)	定义当被 float() 调用时的行为（需要返回恰当的值）
__round__(self[, n])	定义当被 round() 调用时的行为（需要返回恰当的值）
__index__(self)
1. 当对象是被应用在切片表达式中时，实现整形强制转换
2. 如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 __index__
3. 如果 __index__ 被定义，则 __int__ 也需要被定义，且返回相同的值

__enter__(self)
1. 定义当使用 with 语句时的初始化行为
2. __enter__ 的返回值被 with 语句的目标或者 as 后的名字绑定
3. 
__exit__(self, exc_type, exc_value, traceback)
1. 定义当一个代码块被执行或者终止后上下文管理器应该做什么
2. 一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作

__len__(self)	 （返回容器中元素的个数 - 前面有讲解）
__getitem__(self, key)	定义获取容器中指定元素的行为，相当于 self[key]
__setitem__(self, key, value)	定义设置容器中指定元素的行为，相当于 self[key] = value
__delitem__(self, key)	定义删除容器中指定元素的行为，相当于 del self[key]
__iter__(self)	定义当迭代容器中的元素的行为
__reversed__(self)	定义当被 reversed() 调用时的行为
__contains__(self, item)	定义当使用成员测试运算符（in 或 not in）时的行为

class t1:
  def t1print(self):
    print('t1')

class t2:
  def t2print(self):
    print('t2')

class t3(t1,t2):
  pass

print(t3.__bases__)  # 显示其基类信息 (<class '__main__.t1'>, <class '__main__.t2'>)

Ctrl + D  #EOFError
Ctrl + C  #KeyboardInterrupt

###### Python标准异常总结 ###############
AssertionError	断言语句（assert）失败
AttributeError	尝试访问未知的对象属性
EOFError	用户输入文件末尾标志EOF（Ctrl+d）
FloatingPointError	浮点计算错误
GeneratorExit	generator.close()方法被调用的时候
ImportError	导入模块失败的时候
IndexError	索引超出序列的范围
KeyError	字典中查找一个不存在的关键字
KeyboardInterrupt	用户输入中断键（Ctrl+c）
MemoryError	内存溢出（可通过删除对象释放内存）
NameError	尝试访问一个不存在的变量
NotImplementedError	尚未实现的方法
OSError	操作系统产生的异常（例如打开一个不存在的文件）
OverflowError	数值运算超出最大限制
ReferenceError	弱引用（weak reference）试图访问一个已经被垃圾回收机制回收了的对象
RuntimeError	一般的运行时错误
StopIteration	迭代器没有更多的值
SyntaxError	Python的语法错误
IndentationError 	缩进错误
TabError	Tab和空格混合使用
SystemError	Python编译器系统错误
SystemExit	Python编译器进程被关闭
TypeError	不同类型间的无效操作
UnboundLocalError	访问一个未初始化的本地变量（NameError的子类）
UnicodeError	Unicode相关的错误（ValueError的子类）
UnicodeEncodeError	Unicode编码时的错误（UnicodeError的子类）
UnicodeDecodeError	Unicode解码时的错误（UnicodeError的子类）
UnicodeTranslateError	Unicode转换时的错误（UnicodeError的子类）
ValueError	传入无效的参数
ZeroDivisionError	除数为零


#以下是 Python 内置异常类的层次结构：
BaseException
+-- SystemExit
+-- KeyboardInterrupt
+-- GeneratorExit
+-- Exception
      +-- StopIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning