zoukankan      html  css  js  c++  java
  • python-面向对象的命名空间和组合

    面向对象的命名空间

    命名空间:
    静态属性:属于类内部的命名空间
    动态属性:属于类内部的命名空间
    对象属性:属于对象的,在类内和self发生联系,在类外和对象名发生联系
    可以查看静态属性的都有那些:类名,对象名
    可以调用类中的方法的有哪些:类名.方法名(对象),对象.方法名()
    类到对象之间没有联系,而对象到类之间有联系
    对象在查找名的时候,会先再自己的空间里找,再到类的空间里找
    # 属性:静态属性,(直接和类名关联或者直接在class下的变量)
            # 对象属性(在类内和self关联,在类外和对象名关联的变量)
            # 动态属性(函数,方法)
    #
    # class Foo:
    #     country = 'China'
    #     country_lst = ['China']
    #     def __init__(self,name):
    #         self.name = name
    # #
    # alex = Foo('alexander')
    # egg = Foo('egon')
    # print(Foo.country)      #类的属性
    # print(alex.name)        #对象的属性
    # alex.country = '印度'  #在内存中对象指向类的类对象指针断开了,重新指向了印度这个地方,而其他的对象和的类对象指针始终没有断开,所以egg的country没有改变
    # print(alex.country)
    # print(egg.country)
    # print(Foo.country)
    # alex.country_lst.append('hahaha')       #在内存中的对象指针没有断开,country_lst中添加元素,改变的是类空间中的属性所以egg调用这个属性时,显示的是修改之后的country_lst
    # print(alex.country_lst)
    # print(egg.country_lst)
    # print(Foo.country_lst)
    # alex.country_lst = []
    # print(alex.country_lst)
    # print(egg.country_lst)
    # 类名操作变量,不管操作可变还是不可变数据类型,都是勒种对应的变量放生变化
    # 对象名操作静态变量
    # 引用变量:现在自己的命名空间中查找,找不到就去类的命名空间中找
    # 修改变量:
    # 如果是对可变数据类型中的元素进行修改,那么全局生效
    # 如果是对变量进行重新赋值,那么只是在对象自己的命名空间里增加了一个新的属性
    
    
    # 设计一个类,统计这个类被实例化的次数,且所有的对象共享这个属性
    # class Foo:
    #     count = 0
    #     def __init__(self):
    #         Foo.count+=1
    
    # f1 = Foo()
    # print(f1.count)
    # f2 = Foo()
    # print(f2.count)
    # f3 = Foo()
    # print(f3.count)
    
    # class Foo:
    #     count = 0
    #     def __init__(self):
    #         Foo.count+=1
    # f1 = Foo()
    # f2 = Foo()
    # f3 = Foo()
    # print(f1.count)     #相当于是Foo.count
    # print(f2.count)     #Foo.count
    # print(f3.count)     #Foo.count
    
    # class Person:
    #     # def __init__(self):pass
    #     #给一个什么属性都没有的对象赋一些初始的属性,init不是类中必须存在的
    #     def eat(self):
    #         print('吃猪食')
    # alex = Person()     #就是一个裸着的对象(没有传入参数调用init)
    # print(alex.__dict__)        #是一个空字典{}
    # alex.eat()      #alex.eat == Person.eat(alex)
    # alex.eat = '泔水'     #对象使用名字的顺序:先用自己的,再用类的,但是类不可以使用对象的属性
    # alex.eat()          #在alex自己的命名空间中调用eat的这个属性,但由于属性值是'泔水'字符串,字符串是不能被调用的
    
    # 对象可以使用类的属性,但是类无法使用对象的属性
    # 原因是:
    # print(Person.eat)
    # print(alex.eat)     #类对象指针的东西  alex = {'eat':eat}

    组合

    # 面向对象:
    # 定义
    # 命名空间
    # 三大特性:封装继承和多态组合
    
    # 组合:表示什么有什么的关系
    # 一个对象的属性是另外一个类的对象
    
    # class Teacher:
    #     def __init__(self,name,age,sex):
    #         self.name = name
    #         self.age = age
    #         self.sex = sex
    # class Birthday:
    #     def __init__(self,year,month,day):
    #         self.year = year
    #         self.month = month
    #         self.day = day
    # birthday1 = Birthday(1968,12,31)
    # boss_gold =Teacher('太白',40,'不详')
    # boss_gold.birth = birthday1
    # print(boss_gold.birth.year)
    # 将一个类的对象拥有的属性,再将其定义成一个类以提高代码的复用
    # class Teacher:
    #     def __init__(self,name,age,sex,year,month,day):
    #         self.name = name
    #         self.age = age
    #         self.sex = sex
    #         self.birth = Birthday(year,month,day)
    # class Birthday:
    #     def __init__(self,year,month,day):
    #         self.year = year
    #         self.month = month
    #         self.day = day
    # boss_gold = Teacher('太白',40,'不详',1968,12,31)
    # print(boss_gold.birth)
    
    
    # 求环形的周长及面积
    #  既能hold住圆形的问题
    # 又能解决环形的问题
    # from math import pi
    # class Circular:
    #     def __init__(self,r):
    #         self.r = r
    #     def Circular_perimeter(self):     #Circular_perimeter圆的周长
    #         return 2*pi*self.r
    #     def Circular_area(self):            #Circular_area圆形的面积
    #         return pi*self.r *self.r
    #
    # class Ring:
    #     def __init__(self,outer_r,inner_r):
    #         self.outer_circle = Circular(outer_r)
    #         self.inner_circle = Circular(inner_r)
    #     def perimeter(self):
    #         return self.outer_circle.Circular_perimeter()+self.inner_circle.Circular_perimeter()
    #     def area(self):
    #         return self.outer_circle.Circular_area()-self.inner_circle.Circular_area()
    # a = Ring(4,3)
    # print(a.perimeter())
    # print(a.area())

     组合的例题

    #
    # class Dog:  # 定义一个狗类
    #     def __init__(self, name, breed, aggressivity, life_value):
    #         self.name = name  # 每一只狗都有自己的昵称;
    #         self.breed = breed  # 每一只狗都有自己的品种;
    #         self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
    #         self.life_value = life_value  # 每一只狗都有自己的生命值;
    #
    #     def bite(self,people):
    #         people.life_value -= self.aggressivity
    # #人
    # class Person:  # 定义一个人类
    #     def __init__(self, name, aggressivity, life_value, money):
    #         self.name = name  # 每一个角色都有自己的昵称;
    #         self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
    #         self.life_value = life_value  # 每一个角色都有自己的生命值;
    #         self.money = money
    #
    #     def attack(self,dog):
    #         dog.life_value -= self.aggressivity
    #
    #     def get_weapon(self,weapon_obj):
    #         if self.money > weapon_obj.price:
    #             self.money -= weapon_obj.price  # 金老板花钱买武器
    #             self.weapon = weapon_obj  # 金老板装备打狗棒
    #             self.aggressivity += weapon_obj.aggr  # 金老板的攻击力增加了
    #
    # # boss_gold = Person('金老板',5,250,100)
    # # huang = Dog('大黄','藏獒',100,3000)
    # # huang.bite(boss_gold)
    # # print(boss_gold.life_value)
    # # boss_gold.attack(huang)
    # # print(huang.life_value)
    # #不公平
    # #武器装备
    # #人 有 武器 —— 组合
    # #武器:攻击力,名字,价格
    # class Weapon:
    #     def __init__(self,name,price,aggr):
    #         self.name = name
    #         self.price = price
    #         self.aggr = aggr
    # dgb = Weapon('打狗棒',99.8,100)
    # boss_gold = Person('金老板',5,250,100)
    # huang = Dog('大黄','藏獒',100,3000)
    # boss_gold.get_weapon(dgb)
    # boss_gold.attack(huang)
    # print(huang.life_value)
    
    #游戏的组合
    #人可以有装备 ——
    #狗 ——
    
    #组合和命名空间
    #继承的一点知识
    
    class Dog:  # 定义一个狗类
        def __init__(self, name, breed, aggressivity, life_value):
            self.name = name  # 每一只狗都有自己的昵称;
            self.breed = breed  # 每一只狗都有自己的品种;
            self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
            self.life_value = life_value  # 每一只狗都有自己的生命值;
    
        def bite(self,people):
            people.life_value -= self.aggressivity
    #
    class Person:  # 定义一个人类
        def __init__(self, name, aggressivity, life_value, money):
            self.name = name  # 每一个角色都有自己的昵称;
            self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
            self.life_value = life_value  # 每一个角色都有自己的生命值;
            self.money = money
    
        def attack(self,dog):
            dog.life_value -= self.aggressivity
    
    
    #不公平
    #武器装备
    #人 有 武器 —— 组合
    #武器:攻击力,名字,价格
    class Weapon:
        def __init__(self,name,price,aggr):
            self.name = name
            self.price = price
            self.aggr = aggr
    dgb = Weapon('打狗棒',99.8,100)
    boss_gold = Person('金老板',5,250,100)
    huang = Dog('大黄','藏獒',100,3000)
    if boss_gold.money > dgb.price:
        boss_gold.money -= dgb.price  # 金老板花钱买武器
        boss_gold.weapon = dgb  # 金老板装备打狗棒
        boss_gold.aggressivity += dgb.aggr  # 金老板的攻击力增加了
    boss_gold.attack(huang)
    print(huang.life_value)
    View Code
  • 相关阅读:
    yarn 国内加速,修改镜像源
    Gradle Wrapper 介绍
    使用 Gradle 快速创建 Java 项目
    Gradle 安装
    gradle 国内加速,修改镜像源
    maven 国内加速,修改镜像源
    java如何对map进行排序详解(map集合的使用)
    Java8 Collections.sort()及Arrays.sort()中Lambda表达式及增强版Comparator的使用
    给定字符串正整数,进行排序并返回排序后字符串
    Linux学习118 nginx与php结合实现web网站及优化
  • 原文地址:https://www.cnblogs.com/dwenwen/p/7874928.html
Copyright © 2011-2022 走看看