(一)面向对象编程：
1.类的声明：类包括类名（符合大/驼峰命名法），属性和方法三要素。dir(a) 可以查看a变量类型所有的内置方法。
class MyClass(obj): #声明一个类MyClass，继承obi类对象。
n=11 #这是类变量，即实例化对象可以调用，但是只能修改/添加该实例化对象的n类变量的值，不能影响该类的其他实例化对象类变量n的值。也可以通过MyClass.n在类内外修改/调用其值。
def __init__(self,name,job): #声明类的静态属性，即构造函数，在实例化时初始化类的一些变量，即将变量存储。
self.name=name
self.__job=job #私有属性，和私有方法一样使用。
self.age=0/None #可以定义一个属性，不需要类形参，在实例化时，可以赋值字基础类型的数据以及其他类的方法作为该属性的值。None表示实例化时不知道会赋值什么类型的数据。
def __foo(): #私有方法
print("__这是类的私有方法，无法实例化类调用，只能在声明MyClass类中调用，如在func中调用")
def func(self,age): #声明类动态方法。
print("名字：%s，年龄：%s"%(self.name,age)) #age是实例化类，调用func函数传入的参数d.func(27)。
self. __foo() #仅仅在当前类里面调用私有方法/属性，但是可以在实例化对象中通过"__MyClass__foo"可以调用私有属性和方法，其子类（注意不是实例化对象，是子类）也不能调用父类的私有属性和私有方法。
return
def __del__(self): #析构函数，类销毁，释放时执行的函数。
#print("类被销毁时执行该析构函数")
def __str__(self): #打印实例化对象时返回该函数下的字符串数据。
return "这是打印实例化对象如print(studentA)时，返回的值"
2. 类的实例化：
d=MyClass("Ace") #实例化类。
d.name="Alice" #修改类的静态变量。
d.func(27) #调用类的动态方法。
3.类的继承：python3的经典类（class People()，不推荐）和新式类（class People(object)，推荐）都是按照广度优先继承的。
3.1 单继承：只有一个父类。
class People(object): #父类
def __init__(self,name,age):
self.Name=name
self.age=age
print("实例化类时就执行此代码！")
def eat(self):
print("%s is eating...."%self.name)
class Man(People): #子类继承父类People，
def __init__(self,name,age,money):
People.__init__(self,name,age) #旧的方式：继承父类的静态属性，一条代码只能继承一个父类
self.money=money #添加子类的静态属性
def game(self):
print("子类%s的自己的方法"%self.name)
def eat(self): #重构父类的eat方法
People.eat(self)
print("为父类的eat方法添加新功能")
class Woman(People): #子类继承父类People， 这里是多继承的话，与顺序有关。
cn="中国"
def __init__(self,name,age,money):
super(Woman,self).__init__(name,age) #新的方式：继承父类的静态属性，可以继承多个父类
self.money=money #添加子类的静态属性
def shop(self):
print("%s is shopping"%self.name)
@staticmethod #即将下面的cc函数变为静态方法，即不在与Woman类有关系了，只是单纯放在Woman类里的函数
def cc(): #调用静态方法，类名.cc(),不需要实例化类对象.cc()调用。
print("这是静态方法，不能调用Woman类里的方法和属性") #即不能在self.name/shop()了
@classmethod #即将下面的cm函数变为类方法，即其下方法只能访问类变量，不能访问实例变量（__init__里面的变量，静态属性）。
def cm(cls): #通过cls.类属性，就可以访问类属性，不访问静态属性，cls相当于self，不需要实例化传入该参数。
print("只能访问类变量cn，不能访问实例变量（静态属性）")
@property #即将下面的cx函数动态方法变为静态属性，即实例化对象d.cx即可调用，而不能d.cx()
def cx():
print("已经变成静态属性，只需要实例化对象d.cx即可调用，不能d.cx()调用")
3.2 多继承： 同时继承多个父类，注意有顺序关系，相同继承的属性方法后者会覆盖前者。
class C(A,B): #C类同时继承A类和B类（先继承A后继承B，重复继承的属性方法，B的该重复的属性方法会覆盖A）。
pass #print(C.__mro__),可以打印出(<class '__main__.C'>,<class '__main__.A'>,<class '__main__.B'>,<class 'object'>) 表示C类继承父类的顺序，先查看C类有没有，有就执行，没有就继续再查看A类有没有，有就执行，没有再查看B类，直到最后查看object类。
4.类的多态：即不同子类调用相同父类方法，产生不同的结果。如重构、拓展父类的该动态方法。如在子类中重写父类的该方法。或在子类中eat方法中调用supper().eat()，并拓展其他代码，重而实现对父类该方法的拓展。
5.类的专有方法：__str__，__doc__，__iter__，__getitem__，__getattr__，__new__(静态方法，创建类实例时执行，给实例对象在内存中分配空间，如果重写__new__时，需要return supper().__new__(cls) )。
① __doc__:打印类的描述信息。
class Dog():
'''这是类的描述信息注释，可以通过Dog.__doc__打印出来该描述注释信息'''
pass
(二)异常处理：
1.异常处理：对异常可能报错的处理。
try:
#这是执行可能报错的代码。
except KeyError as e:
print("错误是：",e)
except Exception as e :
print("除了KeyError的其他异常:",e)
else:
print("没有报错异常执行该代码")
finally:
print("无论是否有异常，有会执行该代码")
2.自定义异常：
2.1自定义异常方法一：
class MyException(Exception): #自定义异常，继承异常类Exception
pass
try:
raise MyException("这是我定义的异常")
except MyException as e:
print e
2.2 自定义异常方法二：
def password():
.....................
ex=Exception("这是我自定的异常")
raise ex
try:
password()
except Exception as e:
print e
3. 异常的传递：如
def demo1():
return int(input("请输入整数")) #当输入的值不是数值类型，如输入字符串'a'时，int()不能转换为整数，就会报错。
def demo2():
return demo1()
print(demo2()) #当demo1输入字符串'a'时，报错异常会沿着demo2传递到此，如果这里没有异常处理，就会在这里报错
try: #因为异常是可以传递的，所以可以在这里处理对demo1中的异常进行处理。
print(demo2())
except MyException as e:
print e