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
  • 相关阅读:
    函数
    python操作文件
    POJ-2689-Prime Distance(素数区间筛法)
    POJ-2891-Strange Way to Express Integers(线性同余方程组)
    POJ-2142-The Balance
    POJ-1061-青蛙的约会(扩展欧几里得)
    Educational Codeforces Round 75 (Rated for Div. 2) D. Salary Changing
    Educational Codeforces Round 75 (Rated for Div. 2) C. Minimize The Integer
    Educational Codeforces Round 75 (Rated for Div. 2) B. Binary Palindromes
    Educational Codeforces Round 75 (Rated for Div. 2) A. Broken Keyboard
  • 原文地址:https://www.cnblogs.com/dwenwen/p/7874928.html
Copyright © 2011-2022 走看看