1.类中的代码是在什么时候执行的?
在实例化之前
2一个类可不可以没有__init__? 可以
1 class A: 2 Country = 'China' 3 def talk(self): 4 print('%s is talking'%self.name) 5 alex = A()
alex.name="alex"
alex.talk
3.在没有__init__的情况下,实例化经历了哪些步骤?
1,创建一个空间给对象
2,将这个空间的地址返回
4,静态属性的增删改 :
1 class A:
2 Country = 'China'
3 def __init__(self,name):
4 self.name = name
5 def talk(self):
6 print('%s is talking'%self.name)
8 新增静态属性
9 A.静态属性名 = 'abc'
10 print(A.静态属性名)
11 修改静态属性
12 A.Country = '印度'
13 print(A.Country)
14 删除静态属性
15 del A.Country
16 print(A.Country) # 报错
17
18 print(A.__dict__) # 只能看,不能改也不能删
5.类的命名空间有什么:
静态属性
动态属性(方法)
6.在实例化的过程中,又开辟了属于对象的一块空
7. 对象的命名空间和类的命名空间之间的关系 :
对象和类之间有一个单向的联系,类对象指针
对象在使用某个名字的时候,如果在自己的空间中没有找到,就要到类的空间中去找
8.对象可以查看类的静态属性,但是不能修改.并且一旦修改,就不能取到类当中的内容了(除非手动删除这个修改的属性)
9.所有的静态属性的修改,都应该由类名来完成,而不应该使用对象名来完成
10.静态属性就是用来描述所有的对象都共享的某一个值
练习1
1 """写一个类,能够记录这个类有多少个对象了(每一次实例化都能够被记录下来)"""
2 第一种
3 class A:
4 count = 0
5 def __init__(self):
6 A.count += 1
7 print(A.count)
8 a = A()
9 print(A.count)
10 第二种
11 class A:
12 count = 0
13 def __init__(self):
14 self.counter()
15 def counter(self):
16 A.count+=1
17 a = A()
11.如果静态变量是一个不可变数据类型,那么只要对象修改这个数据,就相当于在对象的空间中新建
如果静态变量是一个可变数据类型,那么对象修改这个容器中的元素,相当于修改类的空间中的元素
如果静态变量是一个可变数据类型,那么对象直接对这个变量重新赋值,相当于修改对象自己空间中的元素
1 class B:
2 l = []
3 def __init__(self,name):
4 self.l.append(name)
5
6 alex = B('alex')
7 baoyuan = B('宝元')
8 print(B.l)
9 print(alex.l)
10 print(baoyuan.l)
12.大结论:
只要是静态变量,就用类名去修改,永远修改成功,并且所有的对象都共享这个改变
13.总结:
对象的命名空间:类指针\对象的所有属性
类的命名空间:方法和(静态属性\字段)
对象在寻找名字的时候 : 先找对象自己内存空间中的,找不到就去类的命名空间中寻找
类中的名字是什么时候写入内存的 : 代码从上到下执行的时候就已经写入的.一定是在实例化之前
静态变量 : 尽量用类名去操作
组合
1.什么是组合:
一个类对象的属性是另外一个类的对象
1 class Person:
2 def __init__(self,name,sex,hp,mp,ad):
3 self.name = name
4 self.sex = sex
5 self.hp = hp
6 self.mp = mp
7 self.ad = ad
8 def attack(self,dog):
9 print('%s攻击了%s'%(self.name,dog.name))
10 dog.hp -= self.ad
11
12 class Dog:
13 def __init__(self,name,kind,hp,ad):
14 self.name = name
15 self.kind = kind
16 self.hp = hp
17 self.ad = ad
18 def bite(self,person):
19 print('%s咬了%s'%(self.name,person.name))
20 person.hp -= self.ad
21
22 alex = Person('alex','不详',10,10,0.1)
23 hei = Dog('小黑','中华田园犬',999,1.1)
24 hei.bite(alex)
25 # 赚钱
26 # 充值
27 # 武器装备 增加人的攻击力ad
28 # 武器类 :
29 class Weapon:
30 def __init__(self,name,price,ad):
31 self.name = name
32 self.price = price
33 self.ad = ad
34 def skill(self,dog):
35 print('%s被%s攻击了'%(dog.name,self.name))
36 dog.hp -= self.ad
37
38 sh = Weapon('鞋底子',9.99,66)
39 # sh.skill(hei)
40 alex.武器 = sh # 组合
41 # 什么是组合 : 一个类对象的属性是另外一个类的对象
42 alex.武器.skill(hei) # 组合的应用
43 sh.ad -= 10
44 alex.武器.skill(hei)
练习1
1 """ 年月日的类
2 年 月 日
3 student类
4 姓名 性别 出生日期
5 """
6
7 class Birthday:
8 def __init__(self,year,month,day):
9 self.year = year
10 self.month = month
11 self.day = day
12
13 class Student:
14 def __init__(self,name,sex,birth_day):
15 self.name = name
16 self.sex = sex
17 self.birthday = birth_day
18
19 birth = Birthday(1996,9,13)
20 bobo = Student('bobo','male',birth)
21 # bobo.birthday == birth
22 birth.year
23 print(bobo.birthday.year)
练习2
"""
环形类
实例化 接收参数 :大圆半径 小圆半径
有两个对应的方法:计算环形周长,环形的面积
"""
from math import pi
class Circle: #定义了一个圆形类；提供计算面积(area)和周长(perimeter)的方法
def __init__(self,radius):
self.radius = radius #属性 半径=半径
def area(self): #圆的面积
return pi*self.radius*self.radius # 3.14*半径*半径
def perimeter(self): #圆的周长
return 2 * pi * self.radius # 2*3.14*半径
circle =Circle(10) #实例化一个圆
areal = circle.area() #计算圆面积
per1=circle.perimeter()#计算圆周长
print(areal,per1) #打印圆面积和周长
class Ring: #定义了一个圆环形,提供圆环的面积和周长的方法
def __init__(self,radius_outside,radius_inside):#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()) #计算环形的面积
