一: 类的定义
# 语法 class 类名: pass 对象=类名() # 范例 class Person: contry = '中国' def __init__(self,name,age,sex): self.name = name self.age = age self.sex = sex def eat(self): print('%s正在吃饭'%self.name) wangys=Person('wangys',18,'男') print(wangys.name) print(wangys.age) print(wangys.sex)
二 类成员
- 变量(字段)
- 方法
- 属性
2.1 变量
变量又可以称之为字段,有实例变量(字段),类变量(静态字段)两大类,同时每大类又有私有变量
2.1.1 实例变量
class Persion: def __init__(self,name,age): self.name = name # 实例变量 self.age = age # 实例变量 def info(self): print(self.name,self.age) wangys = Persion('wangys',18) print(wangys.name,wangys.age) #对象在外部调用实例变量 wangys.info() # 对象通过方法在内部调用实例变量
2.1.2 实例的私有变量
class Persion: def __init__(self,name,age): self.name = name # 实例变量 self.__age = age # 实例的私有变量 def info(self): print(self.name,self.__age) wangys = Persion('wangys',18) print(wangys.name,wangys.__age) # 在外部直接调用会报错 wangys.info() # 可以在类内部通过方法调用私有变量
2.1.3 类变量
class Persion: country = 'China' # 类变量(静态字段) def __init__(self,name,age): self.name = name # 实例变量 self.age = age # 实例变量 wangys = Persion('wangys',18) print(wangys.name,wangys.age) # 实例变量由实例进行调用 print(Persion.country) # 类变量(静态字段)推荐使用类直接调用
2.1.4 类私有变量
class Persion: __country = 'China' # 类私有变量 def __init__(self,name,age): self.name = name # 实例变量 self.age = age # 实例变量 def info(self): print(Persion.__country) wangys = Persion('wangys',18) print(wangys.name,wangys.age) # 实例调用实例变量 print(Persion.__country) # 外部调用类私有变量报错 print(wangys.info()) # 内部调用类的私有变量可以正常调用
2.3 方法
2.3.1 实例方法
class Persion: def __init__(self,name,age): self.name = name self.age = age def info(self): # 实例方法,调用了封装的实例变量 print(self.name,self.age) wangys = Persion('wangys',18) wangys.info()
2.3.2 静态方法
class Person: def __init__(self,name,age): self.name = name self.age = age def info(self): # 实例方法 print(self.name,self.age) @staticmethod def func(a,b): # 静态方法(没有调用封装在对象种的字段) return a+b wangys = Person('wangys',18) Person.func(1,2) # 静态方法通过类调用即可 print(ret)
2.3.3 类方法
class Persion: def __init__(self,name,age): self.name = name self.age = age def info(self): # 实例方法 print(self.name,self.age) @staticmethod def func(a,b): # 静态方法 return a + b @classmethod def func1(cls,c,d): # 类方法 return c + d ret = Persion.func1(1,2) print(ret)
2.4 属性
当一个方法只需要封装在self的参数,并且功能更像一个属性,而非方法,例如圆的面积,这个面积更像是园的属性
class Circle: def __init__(self,r): self.r = r def area(self): # 定义一个求面积的方法 return 3.14*self.r*self.r c1 = Circle(1) print(c1.area()) # 查看面积时需要加上小括号,像方法,而不是这个园的属性 class Circle: def __init__(self,r): self.r = r @property def area(self): # 定义属性 return 3.14*self.r*self.r c1 = Circle(1) print(c1.area) # 直接用点调用即可,更像时园的属性,而非方法
命名空间
class Course:
language = 'Chinese'
def __init__(self,teacher,name,period,price):
self.teacher = teacher
self.name = name
self.period = period
self.price = price
print(Course.language)
python = Course('wangys','python','6 months',20000)
print(python.language)
静态属性
- 类的属性和方法可以被类调用,也可以被对象调用
- 类的静态属性当使用类进行修改时,使用字典的方式修改时不允许的,但可以通过 类名.属性=。。。 进行修改
- 通过
类的静态属性可以被类调用,也可以被对象调用
class Course:
language = 'Chinese'
def __init__(self,teacher,name,period,price):
self.teacher = teacher
self.name = name
self.period = period
self.price = price
print(Course.language) # 类调用
python = Course('wangys','python','6 months',20000)
print(python.language) # 对象调用
# 不论是类调用还是对象调用,都是可以的
类的静态属性当通过类进行修改的时候,只能通过 类命.属性的方式进行修改
class Course: # 定义了一个课程类
language = 'chinese' # 有一个语言静态属性
def __init__(self,teacher,name,period,price): # ————init__方法有老师,课程名称,周期,价格等
self.teacher = teacher
self.name = name
self.period = period
self.price = price
Course.language = 'EN' # 通过类名.属性方式修改
print(Course.language)
# EN
Course.__dict__['language'] = 'chinese' # 通过字典的方式修改不允许
print(Course.language)
# TypeError: 'mappingproxy' object does not support item assignment
类可以直接修改静态属性,修改后,对象与类都共享修改
class Course:
language = 'Chinese'
def __init__(self,teacher,name,period,price):
self.teacher = teacher
self.name = name
self.period = period
self.price = price
python = Course('wangys','python','6 months',20000)
linux = Course('wc','linux','6 months',20000)
print(Course.language) # 类可以调用
print(python.language) # 对象可以调用
print(linux.language) # 对象可以调用
Course.language = 'english' # 类修改静态属性
print(Course.language) # 可以看到已经修改
print(python.language) # 对象共享修改
print(linux.language) # 对象共享修改
Chinese
Chinese
Chinese
english
english
english
通过对象进行静态属性修改,实际上是在对象的 命名空间里增加了一个变量,并没有改变类命名空间的静态属性,当然其他对象对该静态属性也没有改变、、
class Course:
language = 'chinese'
def __init__(self,teacher,name,period,price):
self.teacher = teacher
self.name = name
self.period = period
self.price = price
def func(self):
return self.price
python = Course('eval','python','6 months',20000)
linux = Course('wangys','linux','7 months',10000)
print(Course.language)
print(python.language)
print(linux.language)
python.language = 'english' # 对象修改静态属性
print(python.language) # 对象的命名空间里有了该名称
print(linux.language) # 其他对象并没有改变
print(Course.language) # 类也一样
# 结论 对于类的不可变的数据类型静态属性,使用类进行操作
# 对于类的可变数据类型静态属性,修改时共享的,重新赋值是独立的
class Course:
language = ['chinese']
def __init__(self,name,period,price):
self.name = name
self.period = period
self.price = price
def func(self):
pass
python = Course('python','6 months',20000)
linux = Course('linux','6 months',20000)
python.language[0] = 'English' # 对象对可变数据类型进行修改
print(python.language) # 对象读取的是修改后的值
print(Course.language) # 类读取的是修改后的值
print(linux.language) # 其他对象读取的也是修改后的值
python.language=['Chinses'] # 对象重新赋值
print(python.language) # 读取的是修改后的值
print(Course.language) # 读取的原来的值
print(linux.language) # 读取的是原来的值
['English']
['English']
['English']
['Chinses']
['English']
['English']
# 如果是修改,会先找到该列表,然后做修改,因为是类静态属性,所以找到的是类的静态属性,然后做的是对类列表的修改,都生效,如果是赋值,会在对象的命名空间重新生成一个对象属性,故该的是对象属性,而不是类的属性,所以类和其他对象没有影响
例子:记录实例化次数
class Foo:
count = 0
def __init__(self):
Foo.count +=1
f1 = Foo()
print(f1.count)
f2 = Foo()
print(f1.count)
# 1
# 2
绑定方法
def func():
pass
class Foo:
def func(self):
pass
f1 = Foo()
print(func)
print(Foo.func)
print(f1.func)
<function func at 0x000001A9AEA37048>
<function Foo.func at 0x000001A9B071E1E0>
<bound method Foo.func of <__main__.Foo object at 0x000001A9B071D1D0>> # 绑定方法
# 对象在调用类的方法是,实际上是将self的值传递给方法,两者发生了绑定关系
类的组合
- 组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合
- 当类之间有显著不同,并且较小的类是较大的类所需要的组件时,用组合比较好
人狗大战(人使用武器攻击)
# 定义了一个Dog类,有名字,攻击力,血量,种类,并且有咬的技能(方法)
class Dog:
def __init__(self,name,aggr,hp,kind):
self.name = name
self.aggr = aggr
self.hp = hp
self.kind = kind
def bite(self,person):
person.hp -= self.aggr
# 定义了一个人的类,有名字,攻击力,血量,性别,金钱,有攻击技能,有获取武器的技能
class Person:
def __init__(self,name,aggr,hp,sex):
self.name = name
self.aggr = aggr
self.hp = hp
self.sex = sex
self.money = 0
def attack(self,dog):
dog.hp -= self.aggr
def get_weapon(self,weapon):
if self.money > weapon.price: # 得到武器之前先判断人是否有钱买整个武器
self.money -= weapon.price # 得到武器后人的钱减去武器的价钱
self.weapon = weapon # 给人类加了一个weapon属性
self.aggr += weapon.aggr # 人的攻击力加上武器的攻击力
else:
print('余额不足') # 如果钱不够,则报错
# 定义了一个武器类,有名称,攻击力,耐久度,价钱,还有大招hand18
class Weapon:
def __init__(self,name,aggr,njd,price):
self.name = name
self.aggr = aggr
self.njd = njd
self.price = price
def hand18(self,dog):
if self.njd >0: # 使用大招有限度
dog.hp -= self.aggr *2 # 血量直接减去武器攻击力的两倍
self.njd -=1 # 耐久度减去1
w = Weapon('打狗棒',100,3,998) # 实例化一个打狗棒武器
alex = Person('alex',0.5,100,'male') # 实例化一个alex人对象
jin = Dog('金老板',100,500,'teddy') # 实例化一个狗对象
alex.money =1000 # 人的金钱增加,可以买武器
alex.get_weapon(w) # alex获得武器
alex.attack(jin) # 攻击狗对象
alex.weapon.hand18(jin) # 使用武器大招攻击
print(jin.hp)
圆环周长及面积
class Circle:
role = '圆形'
def __init__(self,radius):
self.radius = radius
def perimeter(self):
return 3.14*2*self.radius
def area(self):
return 3.14*(self.radius**2)
c1 = Circle(1)
c2 = Circle(2)
print(c1.perimeter() + c2.perimeter())
print(c2.area() - c1.area())
class Ring():
name = '圆环'
def __init__(self,inner_circle_radius,outer_circle_radius):
self.inner_circle_radius = inner_circle_radius
self.outer_circle_radius = outer_circle_radius
self.inner_circle = Circle(inner_circle_radius)
self.outer_circle = Circle(outer_circle_radius)
def perimeter(self):
return self.inner_circle.perimeter() + self.outer_circle.perimeter()
def area(self):
return self.outer_circle.area() - self.inner_circle.area()
r1 = Ring(1,2)
print(r1.perimeter())
print(r1.area())
教授有生日,有教授课程
教授一个类,生日一个类,课程一个类,教授可以有生日,可以教授课程
class Brith_date:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
class Course:
def __init__(self,course_name,course_period,course_price):
self.course_name = course_name
self.course_period = course_period
self.course_price = course_price
class Teacher:
def __init__(self,name,age,brith,course):
self.name = name
self.age = age
self.brith = brith
self.course = course
def teaching(self):
print('teaching')
t1 = Teacher('wangys',18,Brith_date('2000','10','19'),Course('Python','6 months',20000))
print(t1.course.course_name)
print(t1.brith.year)