• Day 023 面向对象命名空间:组合


    01 今日内容大纲

    • 面向对象相关
      • 组合
      • 命名空间和内存

    02 昨日内容回顾

    • 面向对象
        • 具有相同属性和相似功能的一类事物(一个大的范围,一个模子,抽象)
        • ..............................................
        • 你可以清楚的知道这一类事物有什么属性,有什么动作
        • 但是你不能知道这些属性具体的值
      • 对象 == 实例
        • 给类中所有的属性,填上具体的值,就是一个对象或者实例
        • 只有一个类,但是可以有多个对象都是这个类的对象
      • 实例/实例化(过程)
        • 实例 =类()
        • 首先开辟空间,调用init方法,将开辟的空间地址,传递给self参数
        • init方法中一般完成:把属性的值存储在self的空间里----对象的初始化
        • self这个地址会作为返回值,返回给实例
      • 方法
        • 定义在类里的函数,并且还带有self参数
      • 实例变量
        • self.名字

    03 今日内容

      • 这个类有什么属性,用什么方法,大致的样子
      • 不能知道具体属性对应的值
    • 对象

      • 之前所有的属性值就都明确了
      a = 10
      b = 12.5
      l = [1,2,3]
      d = {'k':'v'}
      #类型:int float str dict tuple set -- 类(内置的数据类型,内置的类)
      #变量名 = xx数据类型的对象
      
      o = 函数名
      q = 迭代器
      u = 生成器
      c = 装饰器
      i = 类名
      
    • python 中一切皆对象,对象的类型就是类

      class A:pass
      a = A()
      print(type(a))
      #<class '__main__.A'>
      
      b = 1
      print(type(b))
      #b = 1
      print(type(b))
      
      • 所有对象都有一个类型,classA实例化出来的对象的类型就是A类
      • 123的类型是int/float
      • 'ajksdka'的类型是str
      • {}的类型是dict
      • alex = Person()的类型就是Person
      • 小白 = Dog()的类型就是Dog
    • 命名空间问题

      • 类的成员和名称空间

        类的成员和命名空间
        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
        

    04 今日总结

    • 命名空间
      • 在类的命名空间里
        • 静态变量
        • 绑定方法
      • 在对象的命名空间里
        • 类指针
        • 对象的属性(实例变量)
      • 调用的习惯
        • 静态变量的调用习惯:
          • 类名.静态变量
          • 对象.静态变量(对象调用静态变量的时候不能对变量进行赋值操作 对象.静态变量 = 123123jkfg)
        • 绑定方法
          • 对象.绑定方法() ===>类名.绑定方法(对象)
        • 实例变量
          • 对象.实例变量(类调用不到)
    • 组合
      • 一个类的对象是另一个类对象的属性

      • 两个类之间 有 什么关系:班级有学生,学生有班级,班级有课程,图书有作者....

        # # 第二大题:基于圆形类实现一个圆环类,要求接收参数 外圆半径和内圆半径
        # # 完成方法 :计算环形面积和环形周长(公式自己上网查)
        # # 要求,借助组合,要求组合圆形类的对象完成需求
        from math import pi
        class Circle:
            def __init__(self,r):
                self.r = r
            def s(self,):
                S = self.r*self.r*pi
                return S
            def l(self,):
                L = 2*pi*self.r
                return L
        
        class Circle_ring:
            def __init__(self,wrapper_R,inner_R):
                wrapper_R, inner_R = (wrapper_R,inner_R) if wrapper_R > inner_R else (inner_R,wrapper_R)
                self.wrapper_circle = Circle(wrapper_R)
                self.inner_circle = Circle(inner_R)
            def s(self):
                S = self.wrapper_circle.s() - self.inner_circle.s()
                return S
            def l(self):
                L = self.inner_circle.l() + self.wrapper_circle.l()
                return L
        r = Circle_ring(10,5)
        print(r.s())
        print(r.l())
        

    05 预习内容

  • 相关阅读:
    JavaScript 对联广告、漂浮广告封装类(IE,FF,Opera,Safari,Chrome)
    一个程序员的梦想
    无刷新分页控件(原创)(jQuery+json+ashx)(Ajax)
    Ajax无刷新分页(jQuery+Json)
    飞信 .net接口
    STL学习小记起因
    C++山寨CSharp事件
    在win8上花了一上午的闲暇做的贪吃蛇sample, 顺便移植到了WPF...
    STL学习小记顺序容器
    最近做的一个store app音乐箱
  • 原文地址:https://www.cnblogs.com/Redbean1231/p/13515204.html
Copyright © 2020-2023  润新知