一、对象之间的交互

现在我们已经有一个人类了，通过给人类一些具体的属性我们就可以拿到一个实实在在的人。

现在我们要再创建一个狗类，狗就不能打人了，只能咬人，所以我们给狗一个bite方法。

有了狗类，我们还要实例化一只实实在在的狗出来。

然后人和狗就可以打架了。现在我们就来让他们打一架吧！

创建一个狗类

class Person:    role = 'person'  # 静态属性    def __init__(self, name, sex, hp, ad):        self.name = name  # 对象属性 属性        self.sex = sex        self.hp = hp        self.ad = ad    def attack(self):        print('%s发起了一次攻击' % self.name)class Dog:    role = 'person'  # 静态属性    def __init__(self, name, kind, hp, ad):        self.name = name  # 对象属性 属性        self.kind = kind        self.hp = hp        self.ad = ad    def bite(self):        print('%s咬了人一口' % self.name)alex = Person('a_sb', '不详', 1, 5)boss_jin = Person('金老板', '女', 20, 50)teddy = Dog('笨笨', 'teddy', 50, 10)alex.attack()  # 相当于执行Person.attack(alex)boss_jin.attack()  # 相当于执行Person.attack(boss_jin)teddy.bite()

执行输出：

a_sb发起了一次攻击

金老板发起了一次攻击

笨笨咬了人一口

 

那么问题来了，人发起了一次攻击，他攻击了谁？

 

交互 teddy打alex一下

class Person:    role = 'person'  # 静态属性    def __init__(self, name, sex, hp, ad):        self.name = name  # 对象属性 属性        self.sex = sex        self.hp = hp        self.ad = ad    def attack(self):        print('%s发起了一次攻击' % self.name)class Dog:    role = 'person'  # 静态属性    def __init__(self, name, kind, hp, ad):        self.name = name  # 对象属性 属性        self.kind = kind        self.hp = hp        self.ad = ad    def bite(self,people): #people是变量名,它是一个对象        people.hp -= self.ad #人掉血        print('%s咬了%s一口,%s掉了%s点血' % (self.name,people.name,people.name,self.ad)) #由于people是对象，取name就是people.namealex = Person('a_sb', '不详', 1, 5)boss_jin = Person('金老板', '女', 20, 50)teddy = Dog('笨笨', 'teddy', 50, 10)teddy.bite(alex) #alex是一个对象，把对象传进去了print(alex.hp) #查看alex的血

执行输出：

笨笨咬了a_sb一口,a_sb掉了10血

-9

 

再完善人攻击狗的技能

class Person:    role = 'person'  # 静态属性    def __init__(self, name, sex, hp, ad):        self.name = name  # 对象属性 属性        self.sex = sex        self.hp = hp        self.ad = ad    def attack(self,dog):        dog.hp -= self.ad        print('%s攻击了%s,%s掉了%s点血' % (self.name,dog.name,dog.name,self.ad))class Dog:    role = 'person'  # 静态属性    def __init__(self, name, kind, hp, ad):        self.name = name  # 对象属性 属性        self.kind = kind        self.hp = hp        self.ad = ad    def bite(self,people): #people是变量名,它是一个对象        people.hp -= self.ad #人掉血        print('%s咬了%s一口,%s掉了%s点血' % (self.name,people.name,people.name,self.ad)) #由于people是对象，取name就是people.namealex = Person('a_sb', '不详', 1, 5)boss_jin = Person('金老板', '女', 20, 50)teddy = Dog('笨笨', 'teddy', 50, 10)teddy.bite(alex) #alex是一个对象，把对象传进去了print(alex.hp) #查看alex的血alex.attack(teddy)print(teddy.hp) #查看teddy的血

执行输出：

笨笨咬了a_sb一口,a_sb掉了10点血

-9

a_sb攻击了笨笨,笨笨掉了5点血

45

 

这款游戏，还可以丰富一点，比如玩家有4个技能，可以选择

等学了模块，可以做随机事件

比如暴击，中毒，每秒掉血等等...

 

交互到这里就说完了

方法可以传参，参数可以是对象。

交互： 人和狗的互相残杀

类中的方法的传参与调用

 

二、类命名空间与对象、实例的命名空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性

而类有两种属性：静态属性和动态属性

• 静态属性就是直接在类中定义的变量
• 动态属性就是定义在类中的方法

其中类的数据属性是共享给所有对象的

而类的动态属性是绑定到所有对象的

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

 

上面的例子，看下面2句话

alex = Person('a_sb', '不详', 1, 5)alex.attack(teddy)

有一个问题

alex是如何找到Person类的？

因为是Person是实例化了alex，那么实例化过程中，发生了什么呢？

查看对象的属性

print(alex.__dict__)

{'hp': -9, 'sex': '不详', 'name': 'a_sb', 'ad': 5}

 

 昨天的内容讲到，调用属性，需要__dict__中存在，才可以以调用

 那这....

 

在面向过程中，代码执行时从上向下执行

类并不是完全这样执行的，有些步骤跳过了。

 

直接Person.role 就可以调用类表里

print(Person.role)

执行输出：person

所以说类里面的 方法，在实例化之前，就已经加载到内存中了

类代码执行，会跳过某些步骤

类是感知不到它有多少个方法

每当实例化之后，对象和类是单向关系，只能是对象取找类

 

看下面一张图

 

代码执行顺序：

1.加载类名Person

2.加载类静态属性role='person'

3.加载类初始函数__init__，注意，它不执行代码

4.加载类方法attack，注意，它不执行代码

5.实例化对象alex

6.执行类方法attack

7.打印对象alex的属性

 

执行1~4之后，会有一个类命名空间Person，它存储了3个变量

执行第5步时，开辟一个实例命名空间alex,它存储了4个变量，里面还有一个隐藏的变量，类对象指针。

它指向了类命名空间Person以及自己的实例命名空间

在初始化方法里面的self，代码实例本身，也就是实例命名空间alex

执行第6步。先找自己的内存空间，再找到类对象指针，再根据类对指针找到类 再通过类找到attack

第7步，打印实例命名空间的属性。

 

对象的内存空间里 是不是只包含init方法里面创建的所有属性？

加一个age属性试试

alex = Person('a_sb', '不详', 1, 5)alex.attack()alex.age = 18 #此时init没有age#Person实例化alexprint(alex.__dict__)

执行输出：

a_sb发起了一次攻击

{'ad': 5, 'age': 18, 'name': 'a_sb', 'sex': '不详', 'hp': 1}

输出结果里面有age变量了

这就说明，可以从外面向里面添加属性

 

类方法，也可以给self加参数

class Person:    role = 'person'  # 静态属性    def __init__(self, name, sex, hp, ad):        self.name = name  # 对象属性 属性        self.sex = sex        self.hp = hp        self.ad = ad    def attack(self):        self.hobby = 'girl' #增加属性        print('%s发起了一次攻击' % self.name)alex = Person('a_sb', '不详', 1, 5)alex.attack()alex.age = 18 #此时init没有age#Person实例化alexprint(alex.__dict__)

执行输出：

a_sb发起了一次攻击

{'sex': '不详', 'name': 'a_sb', 'hp': 1, 'hobby': 'girl', 'age': 18, 'ad': 5}

 

对象内存空间里: 只存储对象的属性，而不存储方法和静态属性

查询对象内存空间，使用__dict__

为什么不存储类方法呢？假如类有50方法，都存一份？太浪费空间了。

为了节省空间，所以不存储类方法

方法和静态属性都存储在类的内存空间中

为了节省内存，让多个对象去恭喜类中的资源

当类空间不够时，会自动扩容

静态属性和方法是共享的

对象属性是独有的

对象不能有自己特有的方法

人狗大战里面再升级一下

人物类型里面有：

输出类：攻击高，血低

坦克类：血低，攻击低

治疗类：攻击低，治疗高

那么每一个类，都是一个单独的类。

假如治疗类里面有医生和护士

医生， 只能做手术

护士，只能包扎

所以医生和护士，必须是不同的类才行。不能用同一个类，因为方法不通。

对象和对象之间，方法不同时，那么它们一定是不同的类

 

在init里面增加和方法名同名的属性

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 = 'haha' #增加和方法名同名的属性    def attack(self):        print('%s发起了一次攻击' % self.name)alex = Person('a_sb', '不详', 1, 5)alex.attack()print(alex.__dict__)

执行报错：

TypeError: 'str' object is not callable

为什么呢？因为alex实例命名空间里面找不到attack，所以它从类命名空间中找，但是此时attack变成字符串了,它是被不能执行的

对象查找顺序：先找自己内存空间，再找类的内存空间中的

 

2个对象，alex和boss_jin。当alex修改类静态属性时，boss_jin调用时，也会更改吗？

class Person:    role = 'person'  # 静态属性    def __init__(self, name, sex, hp, ad):        self.name = name  # 对象属性 属性        self.sex = sex        self.hp = hp        self.ad = ad    def attack(self):        print('%s发起了一次攻击' % self.name)alex = Person('a_sb', '不详', 1, 5)boss_jin = Person('金老板', '女', 50, 20)alex.role = 'dog' #修改类静态属性print(alex.role) #查看类静态属性print(boss_jin.role)

执行输出：

dog

person

 

what?为什么没有改变，不是说类命名空间，是共享的吗？

但凡是对象操作类属性，它是没有权利的，它只能存储在自己内存空间里面

 

比如模拟人生的游戏

里面有一家人，爸爸妈妈出去工作赚钱，女儿和儿子上学，要花钱。

赚的钱，是共享的，大家都可以使用。

class Person:    money = 0    def __init__(self,name):        self.name = name    def work(self):        self.money += 1000        print(self.name,'工作,赚了%s快钱' %self.money)father = Person('father')mother = Person('mother')father.work()mother.work()print(Person.money) #查看钱

执行输出：

father 工作,赚了1000快钱

mother 工作,赚了1000快钱

0

 

但是钱没有涨？为什么？

因为对象获取了类属性money，直接使用self.money += 1000 ，就相当于在本实例空间操作了。

但是类命名空间并没有改变,，它还是0

 

 怎么解决这个问题呢？

直接用类属性修改

class Person:    money = 0    def __init__(self,name):        self.name = name    def work(self):        Person.money += 1000 #类属性修改        print(self.name,'工作,赚了%s快钱' %self.money)father = Person('father')mother = Person('mother')father.work()mother.work()print(Person.money) #查看钱

执行输出：　

father 工作,赚了1000快钱

mother 工作,赚了2000快钱

2000

 

对于静态属性的修改，应该使用类名直接修改，就不会出现不一致的情况

因为类属性是共享的。

 

小作业：

写一个类，完成一个功能，可以统计这个类有几个对象

代码如下：

class Foo:    count = 0    def __init__(self):        Foo.count += 1f1 = Foo()f2 = Foo()f3 = Foo()print(Foo.count)

执行输出： 3

 

如果对象名字一样呢？结果也是一样的

f1 = Foo()f1 = Foo()f1 = Foo()print(Foo.count)

执行输出： 3

 

此时此刻，只有一个f1，之前的被覆盖了。

实例化一次，就会有一个对象。

 

小测试，看如下代码，最终money会输出多少？2000还是0？

class Person:    money = [0]    def __init__(self,name):        self.name = name    def work(self):        self.money[0] += 1000        print(self.name,'工作,赚了1000快钱')father = Person('father')mother = Person('mother')father.work()mother.work()print(Person.money) #查看钱

执行输出：

father 工作,赚了1000快钱

mother 工作,赚了1000快钱

[2000]

 

为什么是2000 ？不是说但凡是对象操作类属性，它是没有权利的，它只能存储在自己内存空间里面

what?

第一次类初始化是，money[0] =0。

当father实例化之后，money[0]的指针就失效了，变成了1000

当mother实例化之后，money[0]的指针就失效了，变成了2000

最终结果为2000

 

因为list是可变类型，它有自己独立的内存空间。当实例改变时，它就改变了。所以最后调用时，money的值为2000

 

再来一个小测试，还是上面的例子，修改了一下代码

那么money是0还是2000？

class Person:    money = [0]    def __init__(self,name):        self.name = name    def work(self):        self.money = [Person.money[0] + 1000]        print(self.name,'工作,赚了1000快钱')father = Person('father')mother = Person('mother')father.work()mother.work()print(Person.money) #查看钱

执行输出：

father 工作,赚了1000快钱

mother 工作,赚了1000快钱

[0]

 

what?怎么是0了？它不是列表吗？它不是改了吗？

城市套路深我想回农村...

 

请注意表达式self.money = [Person.money[0] + 1000]

等式先计算右边的，Person.money[0]之间用类名.属性名调用，那么应该是[0 + 1000]，最终结果为[1000]。

将结果赋值给self.money，它是实例本身调用money，所以修改的值[1000]，存放在本实例空间。

类属性，并没有被改变，所以最终调用类属性时，输出结果为[0]

 

有一个终极方法，一招制敌

不管时类里面还是类外面，统一使用如下方法修改

类名.静态变量名

 

总结：

 

实例查找变量的顺序:

       先找自己的内存空间->再找到类对象指针->再根据类对象指针找到类->再通过类找

 

对象的内存空间里: 只存储对象的属性，而不存储方法和静态属性

方法和静态属性都存储在类的内存空间中

为了节省内存，让多个对象去共享类中的资源

 

对象属性是独有的，静态属性和方法是共享的

对象使用名字：先找自己内存空间中的，再找类的内存空间中的

类名.静态变量名 ：对于静态属性的修改，应该使用类名直接修改

 

三、面向对象的实例

圆

计算圆的周长 2rπ  (r表示半径)

计算圆的面积 r²π

现在有5个圆，半径分别是1,3,5,7,9

请使用面向对象编写出来

提示：π需要用python模块math里面的pi方法

math---数学函数

作用：提供函数完成特殊的数学运算。

pi表示圆周率

from math import piprint(pi)

执行输出：

3.141592653589793

 

代码如下:

from math import piclass Circle:    def __init__(self, r):        self.r = r    def cal_area(self):        '''        计算圆面积的方法        :return:返回值是float数据类型的面积        '''        return pi * self.r ** 2    def cal_perimeter(self):        '''        计算圆周长的方法        :return:返回值是float数据类型的周长        '''        return pi * self.r * 2for i in range(1, 10, 2): #隔一个取一个,得到1,3,5,7,9    c1 = Circle(i) #实例化    print(c1.cal_area())    print(c1.cal_perimeter())

执行输出：

3.141592653589793

6.283185307179586

28.274333882308138

18.84955592153876

78.53981633974483

31.41592653589793

153.93804002589985

43.982297150257104

254.46900494077323

56.548667764616276

 

到这里

面向对象的基础就结束了

 

作业：

1.计算圆环的面积和周长2.默写交互3.整理校园管里系统的思路   把需求中找到所有能找到的类，属性定义出来   比如，学生类，它的属性有姓名，性别，班级，课程  方法，查看自己所在的班级，查看所学课程

 

答案：

1.圆环面积和周长公式

大圆半径R,小圆半径r:

圆环的周长=大圆的周长+小圆的周长

=2Rπ+2rπ

=2π(R+r);

[圆环的面积=大圆的面积-小圆的面积

=R²π-r²π

=(R²-r²)π,

 

代码如下：

from math import piclass Ring:    def __init__(self, R, r):        self.r = r        self.R = R    def cal_area(self):        '''        计算圆环面积的方法        :return:返回值是float数据类型的面积        '''        return 2 * pi * (self.R + self.r)    def cal_perimeter(self):        '''        计算圆环周长的方法        :return:返回值是float数据类型的周长        '''        return (self.R ** 2 - self.r ** 2) * pic1 = Ring(10, 6)  # 实例化print(c1.cal_area()) #面积print(c1.cal_perimeter()) #周长

执行输出：

100.53096491487338

201.06192982974676

 

2.默认交互

class Person:    role = 'person'  # 静态属性    def __init__(self, name, sex, hp, ad):        self.name = name  # 对象属性 属性        self.sex = sex        self.hp = hp  # 血量        self.ad = ad  # 攻击力    def attack(self, d):        d.hp -= self.ad        print('%s攻击了%s,%s掉了%s点血' % (self.name, d.name, d.name, self.ad))class Dog:    role = 'person'  # 静态属性    def __init__(self, name, kind, hp, ad):        self.name = name  # 对象属性 属性        self.kind = kind        self.hp = hp        self.ad = ad    def bite(self, p):        p.hp -= self.ad  # 人掉血        print('%s咬了%s一口,%s掉了%s点血' % (self.name, p.name, p.name, self.ad))alex = Person('a_sb', '不详', 1, 5)boss_jin = Person('金老板', '女', 20, 50)teddy = Dog('笨笨', 'teddy', 50, 10)teddy.bite(alex)print(alex.hp)boss_jin.attack(teddy)print(teddy.hp)

3.题目需求链接

https://www.cnblogs.com/Eva-J/articles/7747946.html