类:
- 一个公共框架，一个公共模型
一：我们定义的类的属性到底存到哪里了？有两种方式查看
- 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
