python_面向对象&异常

一.面向对象_类&对象

1.定义一个类

#实例
class Student():
    #类属性
    school="高新一中"
    def __init__(self,name):
        """
        对象属性
        :param name:
        """
        self.name=name
        self.age=None
        self.height=None
        self.sex=None
#实例化一个对象
#对象属性
stu1=Student(name="张三")
print(stu1.name)

stu2=Student("李四")
print(stu2.name)

stu3=Student("王麻子")
print(stu3.name)

#对象赋值
stu1.name="王五"
print(stu1.name)
#调类属性
print(Student.school)
#类不能调对象属性(会报错)
# print(Student.name)
#对象调类属性
print(stu1.school)
#对象改变类属性，不影响类属性
stu1.school="八中"
print(stu1.school)
print(Student.school)

#打印结果
张三
李四
王麻子
王五
高新一中
高新一中
八中
高新一中

2.（类、属性、方法）对象和类调用方法、动态定义属性、属性可任意定义。

#实例：对象和类调用方法、动态定义属性
class Student:
    """
    学生类：
    属性：名字，年龄，性别，身高
    1.对象属性
    2.类属性
    方法：
    """
    # 类属性跟对象无关，是所有对像共有的属性
    school = "七中"

    def __init__(self,name,age,height,sex):
        # 对象属性 self类似于Java和C#中的this关键字
        # self 指代当前这个对象
        self.name = name
        self.age = age
        self.height = height
        self.sex = sex

    def showinfo(self):
        print("name:{},age:{},sex:{},height:{}，address:{}"
              .format(self.name,self.age,self.sex,self.height,self.address))

"""对象调方法"""
stu = Student("张三",23, 175, "男")
"""类调方法"""
#类调方法(不能调，因为类有self)
# Student.showinfo()
#类调方法要传参（对象）才能调
# Student.showinfo(stu)
"""动态定义属性"""
stu.address = "天府大道"
print(stu.address)
stu.showinfo()

#打印结果
天府大道
name:张三,age:23,sex:男,height:175，address:天府大道

#实例：任何地方定义属性
class Student:
    """
    学生类：
    属性：名字，年龄，性别，身高
    1.对象属性
    2.类属性
    方法：
    """
    # 类属性跟对象无关，是所有对像共有的属性
    school = "七中"

    def __init__(self,name,age,height,sex):
        # 对象属性 self类似于Java和C#中的this关键字
        # self 指代当前这个对象
        self.name = name
        self.age = age
        self.height = height
        self.sex = sex

    def showinfo(self):
        print("name:{},age:{},sex:{},height:{}，address:{}"
              .format(self.name,self.age,self.sex,self.height,self.address))
    def work(self,course):
        #任何地方定义属性
        self.course=course
        print("每天学习的科目是:{}".format(self.course))

stu = Student("张三",23, 175, "男")
stu.work("shuuxe")

#打印结果
每天学习的科目是:shuuxe

3.类方法

​ 对象和类都可以调用类方法。

#实例
class Student:
    """
    学生类：
    属性：名字，年龄，性别，身高
    1.对象属性
    2.类属性
    方法：
    """
    # 类属性跟对象无关，是所有对像共有的属性
    school = "七中"

    def __init__(self,name,age,height,sex):
        # 对象属性 self类似于Java和C#中的this关键字
        # self 指代当前这个对象
        self.name = name
        self.age = age
        self.height = height
        self.sex = sex

    def showinfo(self):
        print("name:{},age:{},sex:{},height:{}，address:{}"
              .format(self.name,self.age,self.sex,self.height,self.address))
    #类方法
    @classmethod # @开头的叫装饰器
    def sleep(cal):
        print("每个人都要睡觉")

stu = Student("张三",23, 175, "男")
#类调用类方法
Student.sleep()
#对象调用类方法
stu.sleep()

#打印结果
每个人都要睡觉
每个人都要睡觉

4.静态方法

​ 静态方法建议通过类调用。

#实例
class Student:
    """
    学生类：
    属性：名字，年龄，性别，身高
    1.对象属性
    2.类属性
    方法：
    """
    # 类属性跟对象无关，是所有对像共有的属性
    school = "七中"

    def __init__(self,name,age,height,sex):
        # 对象属性 self类似于Java和C#中的this关键字
        # self 指代当前这个对象
        self.name = name
        self.age = age
        self.height = height
        self.sex = sex

    def showinfo(self):
        print("name:{},age:{},sex:{},height:{}，address:{}"
              .format(self.name,self.age,self.sex,self.height,self.address))

    #静态方法建议用类调用
    @staticmethod
    def eat():
        print("每个人都要吃饭")
stu = Student("张三",23, 175, "男")
#类调用
Student.eat()
#对象也可以调用
stu.eat()

#打印结果
每个人都要吃饭
每个人都要吃饭

二.面向对象三大思想

1.封装

​ 将属性私有化，对外只提供共有的的访问接口。

#实例1：进行封装,私有化属性（__）。
class Person:
    def __init__(self,name,age):
        #私有化
        self.__name=name
        self.__age=age
    def showinfo(self):
        print(self.__name,self.__age)

stu=Person("张三",20)
print(stu.__age)

#打印结果：报错。
Traceback (most recent call last):
  File "D:/AI_clb/code/20191022_python面向对象异常Matplot/面向对象_三大思想.py", line 10, in <module>
    print(stu.__age)
AttributeError: 'Person' object has no attribute '__age'

#实例2：私有化属性，提供共有方法访问私有属性
class Person:
    def __init__(self,name,age):
        #1.私有化
        self.__name=name
        self.__age=age
    def showinfo(self):
        #2.共有方法进行访问
        print(self.__name,self.__age)

stu=Person("张三",20)
# print(stu.__age)
#共有方法进行访问
stu.showinfo

#打印结果
张三 20

#实例3：一般情况下设置属性和调用属性的方法。
class Cat:
    def __init__(self):
        self.__name=None
        self.__age=None
    def setName(self,name):
        self.__name=name
    def getName(self):
        return self.__name
cat=Cat()
cat.setName("加菲猫")
print(cat.getName())

#打印结果
加菲猫

#实例4：使用property将setName和getName包装起来。
class Cat:
    def __init__(self):
        self.__name=None
        self.__age=None
    def setName(self,name):
        self.__name=name
    def getName(self):
        return self.__name
    # 通过一个property来包装一下
    name=property(getName,setName)
cat=Cat()
cat.setName("加菲猫")
print(cat.getName())
print(cat.getName())
print(cat.name)
cat.name="机器猫"
print(cat.name)

#打印结果
加菲猫
加菲猫
加菲猫
机器猫

#实例5：私有化方法中进行非法验证
class Person:
    def __init__(self,name,age):
        #1.私有化
        self.__name=name
        self.__age=age
        if age <0:
            print("age不能小于0")
            self.__age=0
        else:
            self.__age=age
    def showinfo(self):
        #2.共有方法进行访问
        print(self.__name,self.__age)

stu=Person("张三",-20)
# print(stu.__age)
#共有方法进行访问
stu.showinfo()

#打印结果
age不能小于0
张三 0

2.继承

#实例1:基本继承
class Animal:
    def __init__(self):
        self.name=None
        self.age=None
class Dog(Animal):
    pass

dog=Dog()
dog.name=("旺财")
print(dog.name)

#打印结果
旺财

#实例2:较复杂继承
class Animal:
    def __init__(self):
        #私有化
        self.__name=None
        self.__age=None
    def setName(self,name):
        self.__name = name

    def getName(self):
        return self.__name

    def setAge(self,age):
        self.__age = age

    def getAge(self):
        return self.__age

    def showinfo(self):
        print(self.getName(), self.getAge())


    # 通过一个property来包装一下
    name = property(getName, setName)

class Dog(Animal):
    pass
class Cat(Animal):
    pass

cat = Cat()
cat.setName("加菲猫")
print(cat.getName())
cat.name = "机器猫"
print(cat.name)

dog = Dog()
dog.setName("旺旺")
print(dog.getName())
dog.setAge(2)
print(dog.getAge())
dog.showinfo()

#打印结果
加菲猫
机器猫
旺旺
2
旺旺 2

#实例3：通过super调用父类方法，并重写父类方法。子类比父类有多的东西。
class Animal:
    def __init__(self):
        #私有化
        self.__name=None
        self.__age=None
    def setName(self,name):
        self.__name = name

    def getName(self):
        return self.__name

    def setAge(self,age):
        self.__age = age

    def getAge(self):
        return self.__age

    def showinfo(self):
        print(self.getName(), self.getAge())
    def eat(self):
        print("动物要吃东西")

    # 通过一个property来包装一下
    name = property(getName, setName)

class Dog(Animal):
    def eat(self):
        """
        重载/重写父类方法
        """
        """将父类的方法调过来"""
        #调的第一种写作方法
        # super(Dog,self).eat()
        #调的第二种写作方法
        super().eat()
        print("主要想吃肉")
class Cat(Animal):
    pass

cat = Cat()
cat.setName("加菲猫")
print(cat.getName())
cat.name = "机器猫"
print(cat.name)

dog = Dog()
dog.setName("旺旺")
print(dog.getName())
dog.setAge(2)
print(dog.getAge())
dog.showinfo()
dog.eat()

#打印结果
加菲猫
机器猫
旺旺
2
旺旺 2
动物要吃东西
主要想吃肉

#实例4：isinstance()判断某个对象是否属于某个类型。
class Animal:
    def __init__(self):
        #私有化
        self.__name=None
        self.__age=None
    def setName(self,name):
        self.__name = name

    def getName(self):
        return self.__name

    def setAge(self,age):
        self.__age = age

    def getAge(self):
        return self.__age

    def showinfo(self):
        print(self.getName(), self.getAge())
    def eat(self):
        print("动物要吃东西")

    # 通过一个property来包装一下
    name = property(getName, setName)

class Dog(Animal):
    def eat(self):
        """
        重载/重写父类方法
        """
        """将父类的方法调过来"""
        #调的第一种写作方法
        # super(Dog,self).eat()
        #调的第二种写作方法
        super().eat()
        print("主要想吃肉")
class Cat(Animal):
    def eat(self):
        super().eat()
        print("主要想吃鱼")

cat = Cat()
cat.setName("加菲猫")
print(cat.getName())
cat.name = "机器猫"
print(cat.name)
cat.eat()
print(isinstance(cat,Cat))
print(isinstance(cat,Animal))

dog = Dog()
dog.setName("旺旺")
print(dog.getName())
dog.setAge(2)
print(dog.getAge())
dog.showinfo()
dog.eat()

#打印结果
加菲猫
机器猫
动物要吃东西
主要想吃鱼
True
True
旺旺
2
旺旺 2
动物要吃东西
主要想吃肉

#实例5：两种不同东西的类型相互继承。如人和狗。可以，但不切合实际。
class  people(Animal):
    pass
class  Animal:
    pass

#实例6：子类在初始化的时候，父类肯定被初始化了。但是，在python中初始化子类，父类并没有被初始化。
class Animal:
    def __init__(self):
        #私有化
        self.__name=None
        self.__age=None
        print("父类初始化了")

class Dog(Animal):
    def __init__(self):
        """初始化子类前，先初始化父类，再初始化子类"""
        #第一种书方法
        super(Dog,self).__init__()
        #第二种书写方法
        super().__init__()
        print("子类初始化了")

# animal=Animal()
dog=Dog()

#打印结果
父类初始化了
父类初始化了
子类初始化了

#实例7：子类中初始化父类
class Animal:
    def __init__(self,name):
        #私有化
        self.__name=name
        self.__age=None
        print("父类初始化了")

    def setName(self,name):
        self.__name = name

    def getName(self):
        return self.__name

    def setAge(self,age):
        self.__age = age

    def getAge(self):
        return self.__age

    def showinfo(self):
        print(self.getName(), self.getAge())

    def eat(self):
        print("动物要吃东西")
    # 通过一个property来包装一下
    name = property(getName, setName)

    def show(self):
        print("这是Animal类")
class Dog(Animal):
    def __init__(self):
        """初始化子类前，先初始化父类，再初始化子类"""
        #第一种书方法
        super(Dog,self).__init__("小白")
        #第二种书写方法
        # super().__init__()
        print("子类初始化了")

# animal=Animal()
dog=Dog()
print(dog.getName())

#打印结果
父类初始化了
子类初始化了
小白

#实例8：多继承1。建议不要使用。
#多继承（本身不可以，因为有一个爸爸）。很多语言抛弃了多继承，python中保留了，但是不建议不要使用多继承。
class A:
    psss
class B:
    pass
class c(A,B):
    pass

#实例9：多继承1.1。当多继承中有相同的方法或属性时，继承的类谁在前，就先继承谁。
class A:
    def show(self):
        print("我是A")

class B:
    def show(self):
        print("我是B")
class C(A,B):
    pass
c=C()
c.show()

#打印结果
我是A

#实例9：多继承1.2。当多继承中有相同的方法或属性时，继承的类谁在前，就先继承谁。
class A:
    def show(self):
        print("我是A")

class B:
    def show(self):
        print("我是B")
class C(B,A):
    pass
c=C()
c.show()

#打印结果
我是B

3.多态

​ 不同的条件下具备不同形态。在python中一个对象本身就是一个多态。pass本身就是一个多态。动态语言都具有这种思想。

#实例1：便于理解的例子1
name="aaa"
print(name)
name = 123
print(name)

#打印结果
aaa
123

#实例2：便于理解的例子2
class Apple:

    def description(self):
        return "这是苹果,能被加工成苹果汁"

class Bananer:

    def description(self):
        return "这是香蕉，能被加工成香蕉汁"

class Drinker:

    def work(self, fruit):
        print(fruit.description())


d = Drinker()
d.work(Bananer())
d.work(Apple())

#打印结果
这是香蕉，能被加工成香蕉汁
这是苹果,能被加工成苹果汁

#实例3：如果不使用多态，实例2将写为：
class Fruit:

    def description(self):
        pass

class Apple(Fruit):

    def description(self):
        return "这是苹果,能被加工成苹果汁"

class Bananer(Fruit):

    def description(self):
        return "这是香蕉，能别加工成香蕉汁"

class Drinker:
    # fruit的类型是 Fruit
    def work(self, fruit:Fruit):
        print(fruit.description())


d = Drinker()
d.work(Bananer())
d.work(Apple())

#打印结果
这是香蕉，能别加工成香蕉汁
这是苹果,能被加工成苹果汁

三.类的专有方法

__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 称方

#实例
class Drinker:
    def __init__(self,name):
        self.name=name

    #运算符重载
    def __str__(self):
        return "这是榨汁机"

    #其实也是运算符重载
    def __add__(self, other):
        return (self.name,other.name)


d = Drinker("九阳榨汁机")
print(d)
d2=Drinker("苏泊尔")
print(d+d2)

#打印结果
这是榨汁机
('九阳榨汁机', '苏泊尔')

四.异常

1.python常见异常类型

python标准异常
异常名称 描述
BaseException 所有异常的基类
SystemExit 解释器请求退出
KeyboardInterrupt 用户中断执行(通常是输入^C)
Exception 常规错误的基类
StopIteration 迭代器没有更多的值
GeneratorExit 生成器(generator)发生异常来通知退出
StandardError 所有的内建标准异常的基类
ArithmeticError 所有数值计算错误的基类
FloatingPointError 浮点计算错误
OverflowError 数值运算超出最大限制
ZeroDivisionError 除(或取模)零 (所有数据类型)
AssertionError 断言语句失败
AttributeError 对象没有这个属性
EOFError 没有内建输入,到达EOF 标记
EnvironmentError 操作系统错误的基类
IOError 输入/输出操作失败
OSError 操作系统错误
WindowsError 系统调用失败
ImportError 导入模块/对象失败
LookupError 无效数据查询的基类
IndexError 序列中没有此索引(index)
KeyError 映射中没有这个键
MemoryError 内存溢出错误(对于Python 解释器不是致命的)
NameError 未声明/初始化对象 (没有属性)
UnboundLocalError 访问未初始化的本地变量
ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError 一般的运行时错误
NotImplementedError 尚未实现的方法
SyntaxError Python 语法错误
IndentationError 缩进错误
TabError Tab 和空格混用
SystemError 一般的解释器系统错误
TypeError 对类型无效的操作
ValueError 传入无效的参数
UnicodeError Unicode 相关的错误
UnicodeDecodeError Unicode 解码时的错误
UnicodeEncodeError Unicode 编码时错误
UnicodeTranslateError Unicode 转换时错误
Warning 警告的基类
DeprecationWarning 关于被弃用的特征的警告
FutureWarning 关于构造将来语义会有改变的警告
OverflowWarning 旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning 关于特性将会被废弃的警告
RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
SyntaxWarning 可疑的语法的警告
UserWarning 用户代码生成的警告

2.几种异常的书写方式：

#实例

#打印结果

（1）.处理异常

#实例
try:
    a = 5
    b = 0
    print(a / b)
except:
    print("错误")

#打印结果
错误

（2）.逐个捕捉，并处理异常

​ 不同异常处理不同错误。

#实例
try:
    a = 5
    b = 0
    print(a / b)
    print(c)
    a = [1,2,3,4]
    print(a[5])
except (ZeroDivisionError,NameError,IndexError):
    print("error")

#打印结果
error

（3）.简写形式

#实例1：简写形式1（常用形式）
try:
    # a = 5
    # b = 0
    # print(a / b)
    # print(c)
    a = [1,2,3,4]
    print(a[5])
except Exception :
    print("error")

#打印结果
error

#实例2：简写形式2
try:
    # a = 5
    # b = 0
    # print(a / b)
    # print(c)
    a = [1,2,3,4]
    print(a[5])
except :
    print("error")

#打印结果
error

（4）.通常是什么错打印什么信息

#实例
try:
    # a = 5
    # b = 0
    # print(a / b)
    # print(c)
    a = [1,2,3,4]
    print(a[5])
except Exception as e:
    print(e)

#打印结果
list index out of range

（5）.异常嵌套

#实例1
def divide(a,b):
    print(a/b)

def method(a,b):
    try:
        divide(a,b)
    except Exception as e:
        print(e)
method(2,0)

#打印结果
division by zero

#实例2
try:
    print("欢迎来到python世界")
    try:
        age = int(input("请输入你的年龄:\n"))
        print(age + 2)

    except Exception as e:
        raise e
except:
    try:
        pass
    except:
        pass

#打印结果
欢迎来到python世界
请输入你的年龄:

（6）.抛异常

#实例
def divide(a,b):
    try:
        print(a/b)
    except Exception as e:
        raise e #抛异常，抛给method

def method(a,b):
    try:
        divide(a,b)
    except Exception as e:
        #处理抛过来的异常
        print(e)

method(2,0)

#打印结果
division by zero