python基础-day19

最新推荐文章于 2025-03-09 18:23:40 发布

「已注销」

最新推荐文章于 2025-03-09 18:23:40 发布

阅读量259

点赞数

#人懂循环，神懂递归
menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {'111':{111},'222':{222}},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '爱奇艺': {},
                '汽车之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '老男孩': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '东城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车战': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '山东': {},
}
#解读下程序，上面是三级菜单的数据，存储格式是字典，
#数据特点好像树杈，会有好几个分支，代表不同大的地方，比如北京，上海，山东，
#不同大的地方，又会分出几个小地方，比如北京又有海淀，昌平等，

def threeLM(dic):       #第一层是北京，上海，山东，第二层比如北京是朝阳，昌平，
    while True:
        for k in dic:       #这里的for循环，打印的是对应层的所有地名，
            print(k)
        key = input('input>>').strip()
        if key == 'b' or key == 'q':    #这里的b和q很费脑，最好站在第二层以上的调用来看
            return key                  #b会结束当前这一层的函数，返回上一层，而整个方法是个while循环，因此会打印你你返回的上层的地名，
                                        #其间会经历下面q的判断，因为字符b不等于字符q，因此可以无视，
        elif key in dic.keys() and dic[key]:
            ret = threeLM(dic[key])
            if ret == 'q':
                return 'q'              
#这里的q比较有意思，比如第三层调用，返回q，经过判断如果是q，又往上返回，又返回q，又判断，最终直到结束整个函数的所有递归，

threeLM(menu)
#这个实现是通过递归，还有个通过堆栈实现的，看的确实烦，就暂时pass吧，

#为元素添加序号，枚举是个好东西
for index, value in enumerate(lst, 1):
        print(index, value)

开始今天的内容，

#首先，什么是组合呢？其实就是一个类的对象中，增加了一个属性，而这个属性就是另一个类的对象，
#关于组合对象的内存分配，相互是独立的，各是各的，
#使用sys.getsizeof()方法，测试了人在装配（就是组合）武器前后的大小，都一样，可见上面的结论是对的，
#而具体到数值为什么是56或者其它，超出我们要了解的范围了，
#其实在python中，这不应该是你关注的重点，即together或part is not importance

#其次，再把之前说的一个点，重复下，类的对象在创建后，可以再添加属性，
#但是并不影响原来的类，即此时你再实例化对象，对象和最开始创建出来具备的属性一样，

import sys
n = sys.getsizeof(str)  #源码意思：Return the size of object in bytes.
print(n)
#打印：400

#关于代码，就是组合部分，但是感觉没什么好贴的，

# 圆环面积和周长计算的题目，
# 老师是通过调用圆的计算方法来间接得到的，即定义的有Circle类和Ring类，代码部分我也不直接贴了，
# 我有个好奇的地方是，圆环类对象初始化的过程中，也实例化了2个圆类对象，
# 那么这个圆环类对象，内存空间占用多少呢？？
#为此，我特地将圆环初始化部分，注释掉了圆形类对象实例化的代码，
#结果前后测试出的大小值都是56，看来其内部是通过指针指向来相互使用的，

#代码也不贴了，就是很基础的类定义和实例化对象，
# 无意中发现，测量类对象的大小，老是出现56这个数字，

# 图画的挺细，自己画要好久，就贴上吧，

# 自己看吧，

#关于上面这张图，我的估计打印结果错了，
#给你五颗星，
#打印的是in son func
#我来个小总结：继承是抽象的，无关具体数据的；而具体数据的追寻，是从子类往父类追寻的，
#即，抽象从上至下，具体从下至上，

继承太多了，分两部分来贴吧，

import sys
# 面向对象的三大特性，封装，继承，多态，

class Person:
    def __init__(self,name,hp,ad):
        self.name = name     # 对象属性 属性
        self.hp = hp         #血量
        self.ad = ad         #攻击力

class Dog:
    def __init__(self,name,hp,ad):
        self.name = name
        self.hp = hp
        self.ad = ad
# d = Dog(111,111,111)
# print(Dog.__bases__)        #没有继承任何类，会打印祖类：(<class 'object'>,),即在python3中，所有的类都会默认继承object类
# print(d.__bases__)          #这个会报错，大概这个操作是针对类而言的吧，类的实例化对象不行，



# class mixed(Person, Dog):
#     pass
# print(mixed.__bases__)      #打印：(<class '__main__.Person'>, <class '__main__.Dog'>)



# 类与类之间的关系： 什么是什么的关系
# 单继承
# class Parent:pass
# class Son(Parent):pass   # 继承关系
# # Son继承了Parent
# print(Son.__bases__)  # 内置的属性
# print(Parent.__bases__)  # 内置的属性





# 多继承
# class Parent1:pass
# class Parent2(Parent1):pass
# class Parent3:pass
# class Son(Parent2,Parent3):pass   # 继承关系
# print(Parent2.__bases__)
# print(Son.__bases__)




# 父类 ：基类 超类
# 子类 ：派生类
class Animal:
    role = 'Animal'
    def __init__(self,name,hp,ad):
        self.name = name     # 对象属性 属性
        self.hp = hp         #血量
        self.ad = ad         #攻击力

    def eat(self):
        print('%s吃药回血了'%self.name)

class Person(Animal):
    r = 'Person'
    def attack(self,dog):   # 派生方法
        print("%s攻击了%s"%(self.name,dog.name))

    def eat2(self):
        print('执行了Person类的eat方法')
        self.money = 100
        self.money -= 10
        self.hp += 10

class Dog(Animal):
    def bite(self,person):  # 派生方法
        print("%s咬了%s" % (self.name, person.name))



# 继承中的init
# alex = Person('alex',10,5)
# print(Person.__dict__)   # role
# print(Person.role)
# print(alex.__dict__)
# dog = Dog('teddy',100,20)
# print(dog)
# print(dog.__dict__)
# alex.eat()



# 继承中的派生方法
# alex = Person('alex',10,5)
# dog = Dog('teddy',100,20)
# alex.attack(dog)
# dog.bite(alex)



# 继承父类的方法：自己没有同名方法
# alex = Person('alex',10,5)
# dog = Dog('teddy',100,20)
# alex.eat2()
# alex.eat()
# dog.eat()



# 对象使用名字的顺序: 先找对象自己内存空间中的，再找对象自己类中的，再找父类中的
# alex = Person('alex',10,5)
# print(alex.ad)      #这句是我自己加的，效果是想知道，子类是否继承了父类的非静态变量，结果能打印出来，说明继承了，
# alex.eat = 'aaa'
# print(alex.eat())  # 报错

继承第二部分

class Parent:
    s = 4
    def func(self):
        print('in parent func')
    def __init__(self,a,b):
        self.b = b
        self.a = a
        self.func()

class Son(Parent):
    s = 5
    def func(self):
        print('in son func')

# p = Parent(4,5)
# s = Son(4,5)
# print(sys.getsizeof(p))     #我增加了父类的属性，结果还是打印56
# print(sys.getsizeof(s))     #我增加了父类的属性，结果还是打印56，
                              # 来个大胆的猜想，python对于类，都是通过指针，引用，
                              # 而通过这种方式的好处是，只需要知道属性或方法的位置，而不必因为属性或者方法的增减，而改变自身的大小，因此可以做到1个56就能满足各种情况，
                              #同时也能体现，python中一切皆是引用，
# print(p.__dict__)
# print(s.__dict__)
# print(s.s)