python基础-day18

待会在正文里，会解答昨天的关于类中的静态变量的问题，

#回答昨天的两个问题，
class Person:
    role = 'person'   # 静态属性
    def __init__(self,name,sex,hp,ad):
        self.name = name     # 对象属性 属性
        self.sex = sex
        self.hp = hp
        self.ad = ad
        self.attack = 'hahaha'
    def attack(self):
        print('%s发起了一次攻击'%self.name)

alex = Person('a_sb','不详',1,5)
boss_jin = Person('金老板','女',50,20)
print(alex.role)
print(boss_jin.role)
print(alex.__dict__)
alex.__dict__['role'] = 'dog'
print(alex.__dict__)
print(alex.role)
print(boss_jin.role)    # dog or ? person
#打印结果：
# person
# person
# {'ad': 5, 'attack': 'hahaha', 'hp': 1, 'sex': '不详', 'name': 'a_sb'}
# {'ad': 5, 'attack': 'hahaha', 'hp': 1, 'sex': '不详', 'role': 'dog', 'name': 'a_sb'}
# dog
# person


#这一段代码，就可以回答昨天的两个问题，
#1，内不可以，对象可以，意思就是！！！类不可以__dici__的方式修改静态变量属性值，而对象可以以这种方式修改，比如alex.__dict__['role'] = 'dog'
#2,第二个问题，静态变量不是对于类中来说是共享的吗？为什么，创建多个对象后，alex.__dict__['role'] = 'dog'之后，打印的结果不同？那是因为你这样做之后，对象中也创建了一个这样的变量，
#再打印就不是你以为的类中的静态变量了，而是对象自己那里的变量了，这个例子也说明了，初始化之后也可以向对象中添加变量，比如role就是一个例子！！！！！

#以下是回顾以前知识再次有新认识的地方，整理如下，
# one
name = "aleX leNb"
print(name.strip('bae')) #leX leN
#值得注意！！！


#two
#python编程不用过多关注底层内存等，


#three
#虽然有各种编码，但是对于英文部分，它们可能都是用ascii编码。


#four
def wraaper1():
    name = '老男孩'

    def inner():
        print(name)  # 这里的name是对外层的引用

    inner()  # 这里即使不调用inner()函数，下面的闭包判断函数依旧成立，
    print(inner.__closure__)  # cell        #打印：(<cell at 0x000001EE78525D98: str object at 0x000001EE785C0990>,)
                                            #这里打印了2个地址，一个是闭包所在的地址，一个是字符串所在的地址，
wraaper1()
#顺便教你一个单词，cell，细胞的意思。

程序，记得在同文件夹下添加个ReadMe文件，
说明，运行环境，启动步骤，用了什么技术等内容，

# 关于类的交互，首先不是input()和 print()
# 而是说，一个类中会引用另一个类的对象以及它相关的方法和属性，
# 感觉没必要贴代码，想不起来了再去看看人狗大战吧，

# 这里是对上面图的解读：
# 1：先读入Person类
# 2：读入静态变量role
# 3：读入函数方法名，仅仅读入函数名，
# 4：读入函数方法名，仅仅读入函数名，
# 之后开始创建对象，
# 为了便于说明，我假设创建了2个以上的对象，在此总结一些规律：
# 首先，类中的静态变量和函数方法，是存放在类的存储空间中的，
# 而对于创建的对象，其自身的属性单独开辟一个空间，
# 看这里！！！对象中的存储空间，有指向类的指针！！！即图片中的指示牌，

# 这张图在上张图的基础上，
# 重点是想说：类产生的对象，调用其方法，是怎样一个过程，
# 首先是到对象所在的存储空间，
# 在空间中找到类的指针，进而进入类的地盘，
# 进入类的地盘后，调用你之前调用的方法，
# 运行函数后，返回到你调用的位置

class Person:
    role = 'person'   # 静态属性
    def __init__(self,name,sex,hp,ad):
        self.name = name     # 对象属性 属性
        self.sex = sex
        self.hp = hp
        self.ad = ad
        self.attack = 'hahaha'
    def attack(self):
        print('%s发起了一次攻击'%self.name)

alex = Person('a_sb','不详',1,5)
boss_jin = Person('金老板','女',50,20)
print(alex.attack)
print(alex.__dict__)
print(Person.attack)
print(Person.attack(alex))
#运行结果：
# hahaha
# {'ad': 5, 'sex': '不详', 'name': 'a_sb', 'hp': 1, 'attack': 'hahaha'}
# <function Person.attack at 0x0000026FD72BE2F0>
# a_sb发起了一次攻击
# None

# 这个例子说明：初始化中有这句话self.attack = 'hahaha'
# 使得对象多了一个变量attack，但是你没法直接调用attack函数方法了，得通过类的方式并传入对象指针来调用

# 这张图的解读，前面几张图的解读已经包含了，想不到有哪些新的内容可以写，

# 这张图，展现了操作类中静态变量，容易出现的问题，
# 你以为是在操作类中的变量，其实操作的是对象自己创建的一个和类中同名的变量，

# 前面讨论了，类中静态变量的特性，
# 那么对于存在多个对象的情况下，为了维护多个对象间静态变量的一致，
# 我们对其的操作，可以通过，
# 类.静态变量，
# 的形式调用，

下面三张图是一起的*********************我是可爱的分割线***********************************

#首先，打印结果是[2000]，
#这个也算一个特例，因为静态变量是列表的类型，所以虽然没有用，Person类名，的方式进行调用，
#但是其实还是对同一个变量进行的操作，

class Person:
    money = [0]
    def __init__(self,name):
        self.name = name
    def work(self):
        print(self.name,'工作,赚了1000块钱')
        temp =  [Person.money[0]+1000]
        print('id of temp is {},content is {}'.format(id(temp), temp))
        self.money = temp
        print('id of self.money is {},content is {}'.format(id(self.money), self.money))

father = Person('father')
mother = Person('mother')
print(mother.__dict__)
mother.work()
print(mother.__dict__)
print('id of Person.money is {},content is {}'.format(id(Person.money), Person.money))
father.work()
print('id of Person.money is {},content is {}'.format(id(Person.money), Person.money))  #
print(Person.money)
#运行结果：
# {'name': 'mother'}    #在mother没有work之前，看其有那个数据，
# mother 工作,赚了1000块钱
# id of temp is 2160366508232,content is [1000]             #这里的id和下面一行的id一样，
# id of self.money is 2160366508232,content is [1000]
# {'money': [1000], 'name': 'mother'}       #在mother进行work以后，她(对象)的数据增加了money，
# id of Person.money is 2160366523016,content is [0]        #而这里的id和上面两个的都不一样，说明了，我们的操作并没有作用到类的静态变量上，
# father 工作,赚了1000块钱
# id of temp is 2160366525640,content is [1000]             #这里id的变化情况同上面一样，不赘述，
# id of self.money is 2160366525640,content is [1000]
# id of Person.money is 2160366523016,content is [0]
# [0]               #这个打印结果，也说明，我们确实没有对类的静态变量进行操作，


#这个我要给五颗星，真是防不胜防啊，
#静态变量是不可变变量，比如int，这个坑我绕过去了，
#静态变量是可变变量，比如list，这个坑我也绕过去了，
#这个坑是个综合体，我还掉进去了，
#相比上张图，self.money[0]，这个使用，就代表了使用的是全局变量，所以不同对象操作的就是同一个数据，
#但是这张图，使用的是self.money = [Person.money[0]+1000]，前面是不可变类型，后面又是一个新列表，真的是混淆视野啊，

#这个变种，也蛮好，和上面那段代码一起看看，
class Person:
    money = [0]
    def __init__(self,name):
        self.name = name
    def work(self):
        print(self.name,'工作,赚了1000块钱')
        Person.money =  [Person.money[0] + 1000]

father = Person('father')
mother = Person('mother')
mother.work()
father.work()
print(Person.money)
#打印结果：
# mother 工作,赚了1000块钱
# father 工作,赚了1000块钱
# [2000]

最后这张图，该怎么写注解呢？？

上面三张图是一起的*********************我是可爱的分割线***********************************