20210725 start
期末事情很多，一家团圆。发现抽空也是可以学习的。加油！
看了上次的笔记，回忆起一些内容，所以记录笔记也很重要！
今日目标
面向对象——类和示例复习，有点忘了，有点混乱。
牛客网解题

面向对象程序设计
二十世纪七十年代，先后出现了两门语言——SIMULA67和Smalltalk，将面向对象编程的思想
类 与实例
类 就是 哺乳类
子类 是 犬科类、猫科类
猫、狗就是具体的 实例
类是实例的模板，实例是类的具体化。
在面向对象编程中，也把实例称为对象。

面向过程程序设计
这种使用函数将具体过程依次表达出来的编程方式叫做面向过程编程

Python里面所有的“体”我们都已经接触到了。
if判断语句下面的判断体，
for和while语句下面的循环体，
def下面的函数体
class下面的类体。

类
class 类名(FatherClass1,FatherClass2...):
类体

case
    class 猫科动物(): ——定义类的时候，括号里没有 父类，就直接继承py的object根类。

理解类
打印效果
case1
class Fidi():
print('hi')
pass
print(Fidi)

    case1-output
        hi
        <class '_main_.Fidi'>     （这里居然复制不了？挺神奇的，在py结果里复制不过来）

    case2——官方
        class Fidi():
            pass —— （用来占位的，啥都不做，但是以防程序出错）
        print(Fidi)

    case2- output
        <class '_main_.Fidi'>   ——（告诉你定义了一个类 但是啥都没做）

    case3-
        class Fidi():
            print('hi')
           #pass  —— with case1,是否# 都会出现<> 结果，  所以也就是  类，都会出<>这句话，和pass没有关系
        print(Fidi)

    case3-output
        hi
        <class '_main_.Fidi'>

构造实例
类是一个模板
实例是具体的产品
注意：
定义类 有括号：——有点类似 定义函数 def sumup():
引用类 有括号
实例是个变量，没有括号，print时候也没有括号 

case1
    class lei():   ——定义一个类
        pass     ——这个类啥都不做
    shili=lei()   ——定义一个对象
    shili2=lei()  ——定义类另一个对象——以此类推可以定义多个对象
    print(shili)  ——看看出来是啥——因为类啥都没做，所以就是告诉你定义了一个 类的对象
    print(shili2)

case1-output
    <__main__.lei object at 0x7fe07609df28>    ——这个对象和下一个对象的关系是啥？  每次好像都固定的
    <__main__.lei object at 0x7fe076075860>  —— 这回这个更具体一些， _main_.lei 的结构没变，但是因为定义了对象，所以 后面object at 应该是个地址

case2  ——自己尝试 子类继承父类 效果
    class plove(): —— 定义 打印love的类，我爱你youzi，妈妈，爸爸
        print('I love you, youzi')
    class maplove(plove):  ——定义了 继承plove的子类maplove
        print('by mama')
    class baplove(maplove,plove): —— 定义了 继承两个子类的baplove
        print('by baba')
    mama=maplove()   ——分别定义实例，然后输出
    print(mama)
    baba=baplove()
    print(baba)

case2- output ——输出结果有些意外
    我以为 ——尤其是baplove 执行结果 这里很不确定，但应该把原来的内容继承吧？
        I love you, youzi
        by mama
        <class '__main.maplove' object at 地址1>     
        I love you, youzi     
        by mama
        by baba
        <class '__main.baplove' object at 地址1>

    实际结果
        I love you, youzi
        by mama
        by baba
        <__main__.maplove object at 0x7fbda9841dd8>   
        <__main__.baplove object at 0x7fbda9841da0>


case3 ——case2的基础上换一下 变量顺序
    class plove():
        print('I love you, youzi')
    class maplove(plove):
        print('by mama')
    class baplove(maplove,plove):
        print('by baba')
    baba=baplove()
    print(baba)
    mama=maplove()
    print(mama)

case3- output ——居然实际输出内容的结果是一样的，只是类提醒的顺序 根据变量顺序 而变化了
    I love you, youzi
    by mama
    by baba
    <__main__.baplove object at 0x7faa63942dd8>    
    <__main__.maplove object at 0x7faa63942da0>

case4—— 在2基础上把 baplove的父类去掉一下，看看结果，预测和之前一样——因为maplove里都有plove的东西
    class plove():
        print('I love you, youzi')
    class maplove(plove):
        print('by mama')
    class baplove(maplove):
        print('by baba')
    baba=baplove()
    print(baba)
    mama=maplove()
    print(mama)

case4-output ——果然和之前一样
    I love you, youzi
    by mama
    by baba
    <__main__.maplove object at 0x7f56ec41edd8>
    <__main__.baplove object at 0x7f56ec41eda0>

case5 ——在2基础上把baplove继承为plove的子类
    class plove():
        print('I love you, youzi')
    class maplove(plove):
        print('by mama')
    class baplove(plove):
        print('by baba')
    baba=baplove()
    print(baba)
    mama=maplove()
    print(mama)

case5-output
    本以为的结果
        I love you, youzi
        by mama
        I love you, youzi  ——这句会多打一遍——因为是继承plove了，所以不应该重新吗？——还是说之前打印过都不会重复？
        by baba
        <__main__.maplove object at 0x7f56ec41edd8>
        <__main__.baplove object at 0x7f56ec41eda0>

    实际结果 ——并没有多打印那句
        I love you, youzi
        by mama
        by baba
        <__main__.maplove object at 0x7f686dfb2dd8>
        <__main__.baplove object at 0x7f686dfb2da0>


通过以上的例子发现：
    对 类的继承 效果 还不是非常清楚，有规则不明确的地方

很拗口的一些概念
new case 6
class FelidAnimal(): ——在类中 定义一个函数 ，叫作 方法
def init(self, fur, height, weight): ——方法
self.fur = fur
self.height = height
self.weight = weight
felid_animal1 = FelidAnimal(fur="yellow", height=1.2, weight=250)
print("猫科动物1的颜色是：{}" .format(felid_animal1.fur))
print("猫科动物1的身高是：{}" .format(felid_animal1.height))
print("猫科动物1的体重是：{}" .format(felid_animal1.weight))

这里有些特别，需要格外注意
    在类内定义的函数，叫做方法。
    __init__ () 是类中的 特殊方法   
        ——对于对象来说 就是默认被执行 /调用 的方法
            ——一般define 的函数 等到使用的时候才调用

        构造方法


def 函数中第一个参数 是 self——使用self. 的方法调用对象的变量

case7 
    class cat():
        def __init__(self,name,age,fur,hight,weight):
            self.name=name
            self.age=age
            self.fur=fur
            self.hight=hight
            self.weight=weight
    cat1=cat(name='Tom',age=2,fur='white',hight=0.4,weight=2.1)
    cat2=cat(name='Jerry',age=3,fur='y',hight=0.5,weight=3.1)
    cat3=cat('Jerry',3,'y',0.5,3.1) —— 不放 self参数也能成功， 不做形式传参也可以，直接赋值参数也行的
    print(cat1)   ——这样不会出结果，只是出 类的形式
    print(cat2)
    print('cat1的name is{} '.format(cat1.name)) ——这样才会出结果
    print('cat3的name is{} '.format(cat3.weight))

20210725 end
看了上次的笔记，回忆起一些内容，所以记录笔记也很重要！——坚持及时整理——任何事情都是！
今日目标
面向对象——类和示例复习，有点忘了，有点混乱。——感觉比第一次看得要明白一些，虽然在和老公生气刷碗的问题lll
牛客网解题——没来得及做

今日收获
    面向过程和面向对象的区别
    面向对象中
        类 ——模板
            特性
                继承性—— 到底规则是什么？
                封装性
                多态性

            类中定义函数 def
                方法
                构造方法——  def __init__(): 
                    默认直接被调用，不用等函数唤起



        实例——具体情况（产品）


下一步
    看到 类的变量 和实例的变量
        概念有些拗口，但是举例马上明白了

    继续向下学习，直到全部看完
    争取有时间写一篇教育paper发表——加油，时间挤挤还是有的！
    老公说我不能吃苦了，嘿，做给他看，也下定决心证明自己可以的！