class Role:
hp=0#类属性
def __init__(self,hp):
self.hp=hp#成员属性
#调用类属性
print(Role.hp)
#调用成员属性
role=Role(100)
print(role.hp)
对于类:
1.类可以直接访问类属性
2.类不可以直接访问实例方法,必须通过实例化之后的对象来访问实例方法
3.类不可以访问对象特有的属性(比如:def __init__中定义的属性)
4.类可以直接访问类方法
5.类可以直接访问静态方法如果对象中的属性跟类中的属性相同,改变对象中的属性值,不会影响类中的属性值
对于对象:
1.对象可以直接访问类的属性(实例化过程中,类已经将属性赋给对象)
2.对象可以直接访问自己私有的属性,类的内部。
3.对象可以直接访问类方法
4.对象可以直接访问静态方法
5.对象可以直接访问实例方法
class Student:
count=100
def read(self):#实例化方法
print('read')
@staticmethod #静态方法 静态函数
def introdunce():
print('static method')
@classmethod#类方法 类函数
def class_info(cls):
print(cls.__name__)
# student=Student()#实例化调用
# student.read()
Student.introdunce()#静态调用
Student.class_info()#类调用
print(Student.count)
运行结果:
Python的动态性
动态语言的定义 :是在运行时可以改变其结构的语言 运行中新的函数、对象、甚至代码可以被引进,已有的函数可以被删除或是其他结构上的变化。
动态添加实例属性
class Npc:
pass
Npc.hp=100
print(Npc.hp)#调用的是类
npc1=Npc()
print(npc1.hp)#新生成一个对象
npc1.hp=1000
print(npc1.hp)
运行结果;
如果随意添加岂不是封装不安全了?可以通过__slots__限制添加的内容
class AI:
__slots__ = ('hp','mp','move')
def move(self,speed):
print('以',speed,'m/s移动')
ai=AI()
ai.hp=1000
ai.mp=100
print(ai.hp)
print(ai.mp)
# ai.account=1000
# print(ai.account)
# AI.account=1000
# print(AI.account)
import types
ai.move=types.MethodType(move,ai)
ai.move(200)
运行结果:
class Book:
pass
@staticmethod
def static_method():
print('this is static method')
@classmethod
def class_info(cls):
print(cls.__mro__)
Book.static_fun=static_method
Book.class_fun=class_info
Book.static_fun()
Book.class_fun()
运行结果:
动态的删除属性、方法
@classmethod
def class_info(cls):
pass
#定义类方法
@classmethod
def attack(cls):
print("attack")
# 定义静态方法
@staticmethod
def dead():
print("dead")
def move(self, speed):
print("move", speed)
a1 = AI()
a1.move = types.MethodType(move, a1)
AI.attack = attack
AI.attack()
AI.dead = dead
AI.dead()
del a1.move
# delattr(a1,'move') #另一种删除方式
# a1.move()
del AI.attack
del AI.dead
#只能删除动态添加的实例方法
# del a1.run #报错
#可以删除写在类中的静态方法和类方法
del AI.introduce
del AI.class_info
运行结果: