python3.5及以上入门笔记（二）---------------面向对象

添加小程序，兑换各种视频教程/数据资源。

(一)面向对象编程：

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表示实例化时不知道会赋值什么类型的数据。
        print('在实例化类时，执行__init__方法')
    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)时，返回的值"

studentA=MyClass('Ace','IT')

2. 类的实例化：    

d=MyClass("Ace")    #实例化类，并执行了类的__init__方法。
d.name="Alice"  #修改类的静态变量。
d.func(27)   #调用类的动态方法。

class Gun:
    def __init__(self,name):
        self.name=name
        self.bullet=0
    def add_bullet(self,count):
        self.bullet=count
    def shoot(self):
        if self.bullet<=0:
            print("【%s】里面没有子弹"%self.name)
            return
        self.bullet-=1
        print("【%s】突突突....【%d】"%(self.name,self.bullet))


class Person:
    def __init__(self,name):
        self.name=name
        self.gun=None
    def fire(self):
        if self.gun is None:
            print("【%s】士兵没有枪"%self.name)
            return
        self.gun.add_bullet(50)
        self.gun.shoot()

ak=Gun('AK47')



Ace=Person('Ace')
Ace.gun=ak
Ace.fire()

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)   #旧版调用父类方法（不推荐）：self必填。既继承了父类的eat方法，又在eat方法基础上新增了功能。
        super().eat()   #新版调用父类方法（推荐）：
        print("为父类的eat方法添加新功能")
class Woman(People):   #子类继承父类People，   这里是多继承的话，与顺序有关。 
    cn="中国"
    def __init__(self,name,age,money):
        super(People,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指的是当前类，不是实例化对象。
        print("只能访问类变量cn，不能访问实例变量（静态属性）")
    @property    #即将下面的cx函数动态方法变为静态属性，即实例化对象d.cx即可调用，而不能d.cx()              
    def cx():
        print("已经变成静态属性，只需要实例化对象d.cx即可调用，不能d.cx()调用")



People.cc()  #调用静态方法（静态方法：即不需要调用类或类实例的属性/方法的方法）。
People.cm()  #调用类方法（类方法：即只需要调用类属性/方法的方法）。
Ace=People('小明')  
Ace.shop()   #调用实例方法（实例方法：即可以调用类/实例属性和方法的方法）。

    3.2 多继承：   同时继承多个父类，注意有顺序关系，相同继承的属性方法后者会覆盖前者。

class C(A,B):     #C类同时继承A类和B类。
    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

     ② __new__:给实例对象分配在内存中的空间。

class People(Object):
   def __new__(cls,*arg,**kwarg): #在类创建时执行（不是实例化时执行）。 
        return super().__new__(cls)     #继承父类的静态方法__new__,必须又返回值，为内存空间

Ace1=People()
Ace2=People()
 
print(Ace1)  #打印的内存空间 Ace1与Ace2不一样
print(Ace2)  #打印的内存空间 Ace1与Ace2不一样

    ③ 类的单例模式：即所有实例对象只分配一个相同的内存空间,如播放器..

class People(Object):
    idSinge=None    #是否开启单例模式
    def __new__(cls,*arg,**kwarg):
        if(cls.idSinge is None):
            cls.idSinge=super().__new__(cls)
            return cls.idSinge

print(Ace1)  #打印的内存空间 Ace1与Ace2一样
print(Ace2)  #打印的内存空间 Ace1与Ace2一样

    ④ __init__：类的初始化内置函数

class People(Object):
    def __init__(self,name,job):
        self.name=name
        self.job=job

Ace=People()  #实例化对象一次，执行一次__init__


class Dog(Object):
    isInit=false   #是否已经实例化过一次了
    def __init__(self,name,job):
        if Dog.isInit:
            return
        self.name=name
        self.job=job

wangzai=Dog()  #实例化对象一次，只执行一次__init__，以后再实例化对象，就不需要执行__init__

    ⑤ __file__：查看模块的路径地址

import text.py as test
print(test.__file__)   #返回text.py的文件路径。如：/python/test.py

     ⑹ __name__：只在当前文件执行，因为import 导入模块时，该模块内没有缩进的代码，在导入时，会被执行，如果需要在导入该模块时，不执行该模块内没有缩进的代码，就需要用到__name__，如

#test.py

def test():
    print('测试__name__的执行')

if __name__ =='main':   #在test.py文件运行时，可执行test()，但text.py作为模块，被其他文件引入时，此时就不会在执行test()文件
    test()     

 

 

 

---

拓展：

      身份运算符：is，is not。作用：比较2个对象的内容地址（id(a)查看对象的内存地址）。其中is是判断2个变量引用的内存地址是否相等，而==是判断2个变量的值是否相等。对于关键字None，建议is、is not作为判断。

      私有属性/方法：__name,__func() 。即通过__声明的变量和方法，是私有属性/方法。仅仅在当前类里面调用私有方法/属性，但是可以在实例化对象中通过"__MyClass__foo"可以调用私有属性和方法（但是不推荐使用），其子类（注意不是实例化对象，是子类）也不能调用父类的私有属性和私有方法。

---

(二)异常处理：

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