• 面向对象第二天


    面向对象第二天

    # 类 : 这个类有什么属性 用什么方法 大致的样子
    #      不能知道具体的属性对应的值
    # 对象 :之前所有的属性值就都明确了
    # 类型 :int float str dict list tuple set -- 类(内置的数据类型,内置的类)
    # 变量名 = xx数据类型对象
    # a = 10
    # b = 12.5
    # l = [1,2,3]
    # d = {'k':'v'}
    # o = 函数
    # q = 迭代器
    # u = 生成器
    # i = 类名
    
    # python中一切皆对象,对象的类型就是类
    
    # 所有的对象都有一个类型,class A实例化出来的对象的类型就是A类
    # 123的类型是int/float
    # 'ajksfk'的类型是str
    # {}的类型是dict
    # alex = Person()的类型是Person
    # 小白 = Dog()的类型是Dog
    
    # def abc():pass
    # print(type(abc))
    
    # 类的成员和命名空间
    # class A:
    #     Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
    #     def __init__(self,name,age):  # 绑定方法 存储在类的命名空间里的
    #         self.name = name
    #         self.age = age
    #     def func1(self):
    #         print(self)
    #     def func2(self):pass
    #     def func3(self):pass
    #     def func4(self):pass
    #     def func5(self):pass
    #
    # a = A('alex',83)
    # print(a.name)
    # print(a.Country)
    
    # print(A.Country)
    # a.func1() # == A.func1(a)
    
    # class A:
    #     Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
    #     def __init__(self,name,age,country):  # 绑定方法 存储在类的命名空间里的
    #         self.name = name
    #         self.age = age
    #         self.Country = country
    #     def func1(self):
    #         print(self)
    #     def func2(self):pass
    #     def func3(self):pass
    #     def func4(self):pass
    #     def func5(self):pass
    #
    # a = A('alex',83,'印度')
    # print(a.name)
    # print(a.Country)
    # print(A.Country)
    
    # class A:
    #     Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
    #     def __init__(self,name,age,country):  # 绑定方法 存储在类的命名空间里的
    #         self.name = name
    #         self.age = age
    #         self.country = country
    #     def func1(self):
    #         print(self)
    #     def func2(self):pass
    #     def func3(self):pass
    #     def func4(self):pass
    #     def func5(self):pass
    #
    # a = A('alex',83,'印度')
    # b = A('wusir',74,'泰国人')
    # a.Country = '日本人'
    # print(a.Country)
    # print(b.Country)
    # print(A.Country)
    
    # class A:
    #     Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
    #     def __init__(self,name,age,country):  # 绑定方法 存储在类的命名空间里的
    #         self.name = name
    #         self.age = age
    #     def func1(self):
    #         print(self)
    #     def func2(self):pass
    #     def func3(self):pass
    #     def func4(self):pass
    #     def func5(self):pass
    #
    # a = A('alex',83,'印度')
    # b = A('wusir',74,'泰国人')
    # A.Country = '日本人'
    # print(a.Country)
    # print(b.Country)
    # print(A.Country)
    
    # 类中的变量是静态变量
    # 对象中的变量只属于对象本身,每个对象有属于自己的空间来存储对象的变量
    # 当使用对象名去调用某一个属性的时候会优先在自己的空间中寻找,找不到再去对应的类中寻找
    # 如果自己没有就引用类的,如果类也没有就报错
    # 对于类来说,类中的变量所有的对象都是可以读取的,并且读取的是同一份变量
    
    # 实现一个类,能够自动统计这个类实例化了多少个对象
    # class A:pass
    # A.Country = 123   # 属性的增加
    # print(A.Country)  # 查看或者引用
    
    # class A:
    #     count = 0
    #     def __init__(self):
    #         A.count += 1
    #
    # a1 = A()
    # print(a1.count)
    # a2 = A()
    # print(A.count)
    # 类中的静态变量的用处
    # 如果一个变量 是所有的对象共享的值,那么这个变量应该被定义成静态变量
    # 所有和静态变量相关的增删改查都应该使用类名来处理
    # 而不应该使用对象名直接修改静态变量
    

    组合

    # 组合
        # 一个类的对象是另外一个类对象的属性
    
    # 学生类
        # 姓名 性别 年龄 学号 班级 手机号
    # 班级信息
        # 班级名字
        # 开班时间
        # 当前讲师
    # class Student:
    #     def __init__(self,name,sex,age,number,clas,phone):
    #         self.name = name
    #         self.sex = sex
    #         self.age = age
    #         self.number = number
    #         self.clas = clas
    #         self.phone = phone
    # class Clas:
    #     def __init__(self,cname,begint,teacher):
    #         self.cname = cname
    #         self.begint = begint
    #         self.teacher = teacher
    
    # 查看的是大壮的班级的开班日期是多少
    # 查看的是雪飞的班级的开班日期是多少
    # py22 = Clas('python全栈22期','2019-4-26','小白')
    # py23 = Clas('python全栈23期','2019-5-28','宝元')
    # 大壮 = Student('大壮','male',18,27,py23,13812012012)
    # 雪飞 = Student('雪飞','male',18,17,py22,13812012013)
    # print(大壮.clas,py23)
    # print(py23.begint)
    # print(大壮.clas.begint)
    
    
    
    # 练习 :
    # 对象变成了一个属性
    # 班级类
        # 包含一个属性 - 课程
    # 课程
        # 课程名称
        # 周期
        # 价格
    
    # 创建两个班级 linux57
    # 创建两个班级 python22
    # 查看linux57期的班级所学课程的价格
    # 查看python22期的班级所学课程的周期
    
    class Clas:
        def __init__(self,cname,begint,teacher):
            self.cname = cname
            self.begint = begint
            self.teacher = teacher
    class Course:
        def __init__(self,name,period,price):
            self.name = name
            self.period = period
            self.price = price
    py22 = Clas('python全栈22期','2019-4-26','小白')
    linux57 = Clas('linux运维57期','2019-3-27','李导')
    linux58 = Clas('linux运维58期','2019-6-27','李导')
    python = Course('python','6 months',21800)
    linux = Course('linux','5 months',19800)
    py22.course = python
    linux57.course = linux
    linux58.course = linux
    print(py22.course.period)
    print(linux57.course.price)
    linux.price = 21800
    print(linux57.course.price)
    print(linux58.course.price)
    
    # class Clas:
    #     def __init__(self,cname,begint,teacher,cprice,cperiod):
    #         self.cname = cname
    #         self.begint = begint
    #         self.teacher = teacher
    #         self.cprice = cprice    # 课程价格
    #         self.cperiod = cperiod  # 课程周期
    # linux57 = Clas('linux运维57期','2019-3-27','李导',19800,'5 months')
    # linux58 = Clas('linux运维58期','2019-3-27','李导',19800,'5 months')
    # linux59 = Clas('linux运维59期','2019-3-27','李导',19800,'5 months')
    # linux60 = Clas('linux运维60期','2019-3-27','李导',19800,'5 months')
    # linux61 = Clas('linux运维51期','2019-3-27','李导',19800,'5 months')
    # linux57.cprice = 21800
    # linux58.cprice = 21800
    

    作业

    # 8点之前 统计作业完成度,难点
    # 作业笔记
        # 写每一个题的用时
        # 遇到的问题
        # 解决思路
    
    
    #第一大题 : 读程序,标出程序的执行过程,画出内存图解,说明答案和为什么
    # 请不要想当然,执行之后检查结果然后再确认和自己的猜想是不是一致
    (1)
    class A:
        Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
        def __init__(self,name,age,country):  # 绑定方法 存储在类的命名空间里的
            self.name = name
            self.age = age
        def func1(self):
            print(self)
    
    a = A('alex',83,'印度')
    b = A('wusir',74,'泰国')
    A.Country = '英国'
    a.Country = '日本'
    print(a.Country)
    print(b.Country)
    print(A.Country)
    
    (2)
    class A:
        Country = ['中国']     # 静态变量/静态属性 存储在类的命名空间里的
        def __init__(self,name,age,country):  # 绑定方法 存储在类的命名空间里的
            self.name = name
            self.age = age
        def func1(self):
            print(self)
    
    a = A('alex',83,'印度')
    b = A('wusir',74,'泰国')
    a.Country[0] = '日本'
    print(a.Country)
    print(b.Country)
    print(A.Country)
    
    (3)
    class A:
        Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
        def __init__(self,name,age,country):  # 绑定方法 存储在类的命名空间里的
            self.name = name
            self.age = age
            self.Country = country
        def func1(self):
            print(self)
    
    a = A('alex',83,'印度')
    b = A('wusir',74,'泰国')
    A.Country = '英国'
    a.Country = '日本'
    print(a.Country)
    print(b.Country)
    print(A.Country)
    
    (4)
    class A:
        Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
        def __init__(self,name,age,country):  # 绑定方法 存储在类的命名空间里的
            self.name = name
            self.age = age
        def Country(self):
            return self.Country
    
    a = A('alex',83,'印度')
    b = A('wusir',74,'泰国')
    print(a.Country)
    print(a.Country())
    
    # 第二大题:基于圆形类实现一个圆环类,要求接收参数 外圆半径和内圆半径
    # 完成方法 :计算环形面积和环形周长(公式自己上网查)
    # 要求,借助组合,要求组合圆形类的对象完成需求
    
    # 第三大题:继续完成计算器和优化工作
    
  • 相关阅读:
    Redux
    版本控制(.git + .svn + SourceTree)
    前端埋点
    前端IDE:VSCode + WebStorm
    浏览器
    Mutation Observer
    函数节流与函数去抖
    React 初识
    Ajax
    JS
  • 原文地址:https://www.cnblogs.com/styxr/p/12200417.html
Copyright © 2020-2023  润新知