类:

• 一个公共框架，一个公共模型

一：我们定义的类的属性到底存到哪里了？有两种方式查看

• dir(类名)：查出的是一个名字列表
• 类名.__dict__:查出的是一个字典，key为属性名，value为属性值
• print(类.__dict__[属性]) # 通过__dict__方式 单独的属性及方法可以查，但是不能增删改
• 工作中，学习中 一般用到 __dict__查看类中的所有属性及方法,不进行其他操作。

二：特殊的类属性

• 类名.__name__# 类的名字(字符串)
• 类名.__doc__# 类的文档字符串
• 类名.__base__# 类的第一个父类(在讲继承时会讲)
• 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
• 类名.__dict__# 类的字典属性
• 类名.__module__# 类定义所在的模块
• 类名.__class__# 实例对应的类(仅新式类中)

三:万能的"."

• 查看,（增删改）类中某个，某些属性 用万能的点' . '
• 类.属性 = 值 # 增
• del 类.属性 # 删
• 类.属性 = 值 # 改
• print(类.属性) # 查
• print(类.函数名) # 查出地址

操作方法 一般不通过类名操作！
类.函数名(对象名)

实例化：类——>对象的过程
self：在实例化时自动将对象/实例本身传给__init__的第一个参数
语法：对象名 = 类名(参数)

实例化过程内部进行了三个阶段：

• 1,在内存中开辟了一个对象空间
• 2,自动执行类中的__init__方法，并且将对象空间自动传给self参数，其他参数手动传入。
• 3,执行__init__方法 给对象空间封装相应的属性。

  def __init__(self,*args):

对象操作对象空间:

• 对象查看对象空间所有的属性 __dict__
• print(对象名.__dict__)
• 对象名.属性 = 值 # 增
• del 对象名.属性 # 删
• 对象名.属性 = 值 # 改
• print(对象名.属性) # 查

对象操作类空间的属性 只能查

对象操作类空间的方法 --->>对象.方法()

对象能调用类中的属性与方法而且只是调用，不能改变
先从自己空间去找，没有此属性他会通过类对象指针从类去找， 类中找不到，会从父类去找。

类不能调用对象的属性

对象与对象之间可不可互相调用？
同一个类实例化出来的对象之间是不能互相访问的。
不同类实例化的对象有可能互相访问。

给对象封装属性：__init__ 任意位置 --->> 注意:在方法中也ok

class 类名:

    属性 = 值
    def __init__(self,形参):
        self.属性 = 形参

    def 方法(self):
        pass

    def pen(self): 需要额外添加的属性 ---->>任意位置添加属性
        self.属性=值
对象 = 类(实参)

组合:给一个类的对象封装一个属性,这个属性是另一个类的对象
组合的意义:让类的对象与另一个类的对象产生关系,类与类产生关系

class Game_role:

    def __init__(self,name,ad,hp):
        self.name = name
        self.ad = ad
        self.hp = hp

    def attack(self,role):
        role.hp=role.hp-self.ad
        print('%s攻击%s,%s掉了%s血, 还剩%s血'%(self.name,role.name,role.name,self.ad,role.hp))

    def foo(self,w):
        self.属性 = 另一个类的对象

class Weapon:
    def __init__(self,name,ad):
        self.name = name
        self.ad = ad

    def fight(self,role1,role2):
        role2.hp = role2.hp - self.ad
        print('%s 用 %s 攻击了%s, %s掉了%s血,还剩%s血'%\
              (role1.name,self.name,role2.name,role2.name,self.ad,role2.hp))

p1 = Game_role('概论',30,3000)
p2 = Game_role('剑豪',100,2000)
w1 = Weapon('大保健',40)
w2 = Weapon('武士刀',100)

p1.attack(p2)  #def attack(self,role):

p1.foo(w1)
p1.Weapon.fight(p1,p2)
p2.foo(w2)
p2.Weapon.fight(p2,p1)

w1.fight(p1,p2)
w2.fight(p2,p1)

• 组合的另一种用法

from math import pi

class Circle:
    '''
    定义了一个圆形类；
    提供计算面积(area)和周长(perimeter)的方法
    '''
    def __init__(self,radius):
        self.radius = radius

    def area(self):
         return pi * self.radius * self.radius

    def perimeter(self):
        return 2 * pi *self.radius


circle =  Circle(10) #实例化一个圆
area1 = circle.area() #计算圆面积
per1 = circle.perimeter() #计算圆周长
print(area1,per1) #打印圆面积和周长

class Ring:
    '''
    定义了一个圆环类
    提供圆环的面积和周长的方法
    '''
    def __init__(self,radius_outside,radius_inside):
        self.outsid_circle = Circle(radius_outside)
        self.inside_circle = Circle(radius_inside)

    def area(self):
        return self.outsid_circle.area() - self.inside_circle.area()

    def perimeter(self):
        return  self.outsid_circle.perimeter() + self.inside_circle.perimeter()


ring = Ring(10,5) #实例化一个环形
print(ring.perimeter()) #计算环形的周长
print(ring.area()) #计算环形的面积

• 当类中的属性发生改变的时候，对象中没有同名的属性、方法的时候，对象使用属性名会跟着类中的变量走

class Foo:
   count = 0
   def __init__(self):
       Foo.count += 1

f1 = Foo()
print(f1.count)
f2 = Foo()
f3 = Foo()
f4 = Foo()
f5 = Foo()
print(f1.count)
print(f5.count)
print(Foo.count)

• 运行结果

C:\Users\Administrator\PycharmProjects\Snack\venv\Scripts\python.exe
1
5
5
5

Process finished with exit code 0

• 只要对象的某个属性被直接赋值，那么一定是对象的命名空间发生变化
• 只要是静态变量，就用类名操作

class Foo:
    count = [0]

f1 = Foo()
f1.count[0] += 1
print(f1.count[0])
print(Foo.count[0])
f1.count = [2]
print(f1.count)
print(Foo.count)

• 运行结果

1
1
[2]
[1]

Process finished with exit code 0