python反射和面向对象的知识并简述基本的异常

# 1、面向对象不是所有的情况都适用
# 2、面向对象编程
#     a.定义类
#         class Foo:
#             def 方法1(self,bb):
#     b.根据类创建对象(创建)
 
# class Person():
#     def __init__(self,name,age):
#         print(name)
#         #print(self.name)
#         self.Name=name
#         self.Age=age
#     def show(self):
#         print("姓名：%s，年龄：%d"%(self.Name,self.Age))
#
# ol=Person("guo",23)
# ol.show()
# #**************
# import pickle
#
# ret=pickle.load(open('文件名'),'rb')
# ret=pickle.load(open('文件名'),'wb')
 
#存取游戏的进度
 
#面向对象编程之继承
 
# class animals():
#     def he(self):
#         print(self.name)
# class dog(animals):
#     def __init__(self,name):
#         self.name=name
#     def show(self):
#         print(self.name+'吃屎')
#
# do=dog("师傅")
# do.he()
# do.show()
 
#其中的animals叫做基类，dog叫做派生类，派生类可以继承基类的属性和方法
# 如果基类和派生类中有相同的属性或者方法的时候，则默认找派生类中的属性或者方法
#基类不能继承派生类的方法或者属性
#在java和c#中一个子类只能继承一个父类,但在python中，一个派生类可以继承多个基类例如：
#class dog(animals,shengwu):
   # 如果继承多个，并且每一个都有共同的属性或者方法，那么优先级是，自己，左，右
 
# 总结：
#    一、反射
#    字符串的形式导入模块__import__
#    字符串的形式从模块中找方法getattr\hasattr()\delattr()\setattr()
#    __import__("lib.bb.py",fromlist=True)
#    二、面向对象
#     类()=>__init__,构造方法
#      继承：python支持多继承，而java和c#中并不支持
#      多态：
 
#面向对象的进阶
   # 成员
   # 成员修饰符
   # 面相对象中一些特殊的方法
 
class Animals:
    def __init__(self):
        print("a的构造方法")
        self.ty="动物"
class Cat(Animals):
    def __init__(self):
        print("B的构造方法")
        self.n="猫"
        # self.ty="动物"
        #执行父类的构造方法
        super(Cat,self).__init__()#和java一样执行父类的构造方法
        #也可以用
        Animals.__init__(self)#这种方法来调用父类的调用的方法
 
#类后面加括号自动执行
#数据初始化
#a=Animals()
c=Cat()
print(c.__dict__)

#
#
# class Foo:
#     age=20
#     #则age叫做静态字段，存在类中
#     def __init__(self,name):
#         #name叫做普通字段，存在对象中
#         self.name=name
#     #show 叫做普通方法，存在类中
#     def show(self):
#         print("show")
#       #类方法只能通过类进行访问
#     @classmethod
#     def xxoo(self):
#       print("xxoo")
#
#     #静态方法
#     @staticmethod
#     def xo():
#         print("xo")
#     #特性
#     def stat(self):
#         return "这是一个测试"
#     @property
#     def end(self):
#         return "这里是结束"
#     @end.setter
#     def end(self,value):
#         print(value)
# c=Foo('alex')
# r=hasattr(c,'show')
# print(r)
# Foo.xo()#访问静态方法（通常用类进行访问，不要用对象进行访问）静态方法存在的意义，不用创建对象就可以访问这个方法
# ret=c.stat()
# print(c.end)#加property把原来用创建对象的方法访问变成这样访问，并且不能加参数，可以理解为将方法伪装成一个字段
#那么，字段可以设置，特性是这样设置呢,如下
# print(c.end)
# c.end=1234
 
#反射
#以字符串的形式去对象（模块）中操作其成员
#反射：类，只能找类里的成员
#r=hasattr(Foo,"show111")
#print(r)
#反射：对象，既可以找对象，找类的成员
 
# 一、面向对象的进阶
#     成员
#         #通过类访问有：静态字段
#         #通过对象访问：普通字段
#     成员修饰符
#           面向对象中一些常用特殊的方法
 
# 知识梳理
# 三大特性：封装、继承、多态
# 成员：
#     字段     静态字段、普通字段
#     方法     静态方法、类方法、普通方法
#     特性     普通特性
 
#成员修饰符
       #即__sx,把sx定义成私有的字段
       #即使子类也不能访问父类的私有字段
#python里特殊的

# class Foo:
#     def __init__(self):
#         print("init")
#     def __call__(self, *args, **kwargs):
#         print("call")
#     def __getitem__(self, item):
#         print(item)
#     def __setitem__(self, key, value):
#         print(key,value)
#     def __delitem__(self, key):
#         print(key)
# r=Foo()#执行__init__
# r()#执行__call__方法
# Foo()()
# r["dkfjladk"]#执行__getitem__方法
# r["xxx"]=123#执行__setitem__方法
# del r['ooo']
"""r[1:3]
del r[1:3]自己测试的模块"""
# dic=dict(k1=123,k2=456)
# print(dic['k1'])
# del dic['k2']
 
#************************
 
#异常处理
#基本的异常处理
# inp=input("请输入内容：")
# try:
#     num = int(inp)
#     print(num)
# except Exception as e:
#     print("转换失败")
#异常的完整结构
 
try:
    #主代码模块
     pass
except Exception as e:
    print(e)
    #异常时，执行该模块
else:
    #主代码执行完之后，执行该块
     pass
finally:
    #无论异常与否，最终执行该模块
     pass
#这个异常是解释器触发的异常
#下面这个列子是主动触发的异常信息
# try:
#     print("234")
#     raise Exception("错了")
# except Exception as e:
#     print(e)