day4 面向对象 继承 异常

01_类的定义

class Student(object):
    # 定义成员变量，都在__init__函数中
    def __init__(self,name,age,height):
        self.name = name
        self.age = age
        self.height = height
    # 显示信息
    def ShowInfo(self):
        print(self.name,self.age,self.height)
    # 设置信息
    def SetInfo(self,name,age,height):
        self.name = name
        self.age = age
        self.height = height
stu1 = Student("周瑜", 18 , 180.5)
stu1.address = "江东"
stu1.ShowInfo()

02_类属性与对象属性

class Student(object):
    count = 10  # 类属性
    # 定义成员变量，都在__init__函数中
    def __init__(self,name,age,height):
        self.name = name
        self.age = age
        self.height = height
        Student.count+=1
    # 显示信息
    def ShowInfo(self):
        print(self.name,self.age,self.height)
    # 设置信息
    def SetInfo(self,name,age,height):
        self.name = name
        self.age = age
        self.height = height
    @classmethod
    def PrintfStuCount(cls):
        print(cls.count)
stu1 = Student("周瑜", 18 , 180.5)
stu2 = Student("黄盖", 18 , 175)
# 通过类名调用类方法
Student.PrintfStuCount()
访问类属性的时候，最好通过类名去使用
Student.count = 100
stu1.count = 50 它相当于给stu1动态添加了成员变量
print(stu1.count)
print(stu2.count)

03_权限保护

class Student(object):
    count = 10  # 类属性
    # 定义成员变量，都在__init__函数中
    def __init__(self,name,age,height):
        self.name = name       # 公有的
        self._age = age        # 保护的
        self.__height = height # 私有的
        Student.count+=1
    # 显示信息
    def ShowInfo(self):
        print(self.name,self.age,self.height)
    # 设置信息
    def SetInfo(self,name,age,height):
        self.name = name
        self.age = age
        self.height = height
stu1 = Student("周瑜", 18 , 180.5)
# print(stu1.__dict__)
print( stu1.name )
print( stu1._age ) # 单下划线也是能访问的
print( stu1._Student__height ) # 双下划线是修改了一下名字

04_继承

class Animal(object):
    def __init__(self,name):
        self.name = name
    def walk(self):
        print("我会走")
    def eat(self):
        print("我会吃饭")
class Dog(Animal):
    def __init__(self,name,breed):
        self.breed = breed
        # python中父类的构造，可以不调用
        # 我们需要想着调用一下
        Animal.__init__(self,name)
    def bite(self):
        print("我会咬人")
    def eat(self):
        print("我会吃骨头")
dog1 = Dog("小白","哈士奇")
dog1.walk() # 调用父类的函数
dog1.bite() # 调用子类的函数
dog1.eat()  # 重定义的时候调用的是子类自己的函数

05_多继承

class Animal(object):
    def __init__(self,name):
        self.name = name
    def walk(self):
        print("我会走")
    def eat(self):
        print("我会吃饭")
class Test(object):
    def FunTest(self):
        print("我是FunTest")
class Dog(Animal,Test):
    def __init__(self,name,breed):
        self.breed = breed
        # python中父类的构造，可以不调用
        # 我们需要想着调用一下
        Animal.__init__(self,name)
    def bite(self):
        print("我会咬人")
    def eat(self):
        print("我会吃骨头")
dog1 = Dog("小白","哈士奇")
dog1.walk() # 调用父类的函数
dog1.bite() # 调用子类的函数
dog1.eat()  # 重定义的时候调用的是子类自己的函数
dog1.FunTest() # 调用另外一个父类的函数

06_菱形继承

# 天然的python就解决的二义性问题
# 数据不产生二义性
# 函数 是先找到谁就使用谁
class TestBase(object):
    def __init__(self):
        self.test = 1
    def fun(self):
        print("我是Base的Fun")
class TestA(TestBase):
    def __init__(self):
        self.test = 10
        TestBase.__init__(self)
    def fun(self):
        print("我是TestA的Fun")
class TestB(TestBase):
    def __init__(self):
        self.test = 20
        TestBase.__init__(self)
    def fun(self):
        print("我是TestB的Fun")
class TestC(TestA,TestB):
    def __init__(self):
        TestA.__init__(self)
        TestB.__init__(self)
        self.test = 100
obj1 = TestC()
print(obj1.__dict__)
obj1.fun()

07_多态

class Duck(object):
    def guaguagua(self):
        print("呱呱呱")
class YellowDuck(Duck):
    def guaguagua(self):
        print("呱呱")
class Cat(object):
    def miaomiao(self):
        print("喵喵喵")
    def guaguagua(self):
        print("呱呱呱")
def Fun(obj):
    # 判断 obj是Duck类或者Duck类的子类
    if isinstance(obj,Duck):
        obj.guaguagua()
objDuck = Duck()
objCat = Cat()
objDuck2 = YellowDuck()
Fun(objCat)
Fun(objDuck2)

08_异常处理

# 在我们编写代码的时候，完全可以将所有的代码，都放置在try中
# 进行异常处理，只有好处。
# python中的异常是有类型的，不同种类的异常需要使用
# 不同的类型去接收
# 被保护的代码放在try中，except的后面放置要处理的异常类型
# try:
#     # print(a)
#     li = [10,20,30,40,50]
#     print(li[5])
# except IndexError:
#     pass
# print("15pb")
# 1. 异常是可以嵌套的，嵌套了之后，内层处理不了，会往外传递
# 2. 一个try的后面，可以跟随多个except
# 3. 主动抛出异常  使用 Raise函数抛出异常
def fun():
    try:
        # 我们可以主动抛出异常
        name = input('please input name:')
        if name == 'hello':
            raise NameError('input name error !')
        # print(a)
        li = [10,20,30,40,50]
        print(li[5])
        # 捕获异常的同时，可以得到异常信息字符串
    except NameError as msg:
        print("nameError:",msg)
    except IndexError as msg:
        print("InnerIndexError:",msg)
    # 无论以何种方式，要离开try块，都会执行finally，我们
    #  可以在这里进行一定的资源清理 比如 关闭文件，断开网络....
    finally:
        print("我要结束了，需要清理一些资源")
try:
    fun()
except IndexError as msg:
    print("OuterIndexError:",msg)
# 这个一般都是放在最外层的最后一个处理
except Exception as msg:
    print("这里是通用异常处理，所有的异常我都能捕获",msg)
print("15pb")

09_Filter

# 题目：过滤其中的偶数
li = [213,21,321,4,435,45,56,7,657,51,34,123,43,4,45]
# 方法1：
li2 = []
for i in li:
    if i%2==0:
        li2.append(i)
print(li2)
# 方法2
li3 = [i for i in li if i%2==0]
print(li3)
# 3 新方法
# filter这个函数，会将后面的可迭代对象中的每一个元素
# 放入 fun中，如果fun返回True，就会留下这个元素 如果fun返回False
# 就不会留下这个元素
def fun(num):
    if num%2 ==0:
        return True
    else:
        return False
li = [213,21,321,4,435,45,56,7,657,51,34,123,43,4,45]
li4 = list(filter(fun,li))
print(li4)

10_reduce

# 求得列表中，每一个元素的和
# 原始方法
li = [1,2,3,4,5]
li_add = 0
for ele in li:
    li_add += ele
print(li_add)
# 新方法
from functools import reduce
li = [1,2,3,4,5]
def func(a,b):
    return a+b
num = reduce(func,li)
print(num)

11_map

# 得到一个新列表，元素是下面列表中元素的2倍
li1 = [1,2,3,4,5]
li2 = []
for ele in li1:
    li2.append(ele*2)
print(li2)
# 新方法
def func(num):
    return num*2
li3 = list(map(func,li1))
print(li3)

12_匿名函数

# 匿名函数的调用
add = lambda x,y:x+y
num = add(10,20)
# print(num)
# 但是上面的写法，给add赋值了，就相当于还是一个有名字的函数了
# 和下面没有任何区别
def add(x,y):
    return x+y
# 那么为什么还要匿名函数呢？？ 在使用高阶函数的时候更方便
# 比如
li = [213,21,321,4,435,45,56,7,657,51,34,123,43,4,45]
li1 = list(filter(lambda x : x%2 == 0,li))
print(li1)
# 再比如
from functools import reduce
li = [1,2,3,4,5]
num = reduce(lambda x,y:x+y,li)
print(num)
# 再比如
li1 = [1,2,3,4,5]
li3 = list(map(lambda x:2*x,li1))
print(li3)