6-1 类的语法

一 类的概念和格式
1 概念
# 类  ： 具有相同属性和相同动作的一类事物 组成一个类,如人类
# 对象 ： 具体的某一个具有实际属性 和具体动作的一个实体。如蜘蛛侠就是一个对象

# 类是抽象的
# 对象是具体的

2 例子
类的第一个功能，类被创造出来 就是模子 是用来描述对象的

 1 class 类名:
 2     静态属性 = 123
 3     def 动态属性(self):
 4         # 在类中的方法的一个默认的参数，但也只是一个形式参数,约定必须叫self
 5         print('-->',self)
 6 print(类名.静态属性)#查看静态属性
 7 类名.静态属性=456
 8 print(类名.静态属性) #修改静态属性
 9 类名.静态属性2='abc' #增加静态属性
10 print(类名.静态属性2)
11 del 类名.静态属性2 #删除静态属性
12 
13 print(类名.动态属性)
14 类名.动态属性("我要把1传给动态属性self") #这个1传给了self
15 #print(类名.静态属性2)

#类的第二个功能实例化（创造一个具体的对象）

1 class Person:pass
2 alex=Person() #对象=类名() 也叫实例化
3 print(alex) #对象
4 print(Person) #类
5 print(alex.__dict__) #默认是空字典
6 alex.__dict__['name']='alex' # 给alex对象添加属性
7 alex.sex='男' #给alex对象添加属性
8 print(alex.__dict__)

3 实例化的过程

# 类名()就是实例化
# 在实例化的过程中发生了很多事情是外部看不到的
# 1.创建了一个对象
# 2.自动调用__init__方法
# 这个被创造的对象会被当做实际参数传到__init__方法中，并且传给第一个参数self
# 3.执行init方法中的内容
# 4.自动的把self作为返回值返回给实例化的地方

 1 实例化的过程
 2  
 3 class Person:
 4 #     def __init__(self,name,hp,dps,sex):
 5 #         self.name = name
 6 #         self.hp = hp
 7 #         self.dps = dps
 8 #         self.sex = sex
 9 #         self.bag = []
10 #
11 # alex = Person('alex',250,5,'N/A')
12 # print('alex : ',alex)
13 # print(alex.__dict__)
14 # print(alex.name)

4 实例

人狗大战

 1 class Person:
 2     def __init__(self,name,sex,dps,hp):
 3         self.name=name
 4         self.sex=sex
 5         self.dps=dps
 6         self.hp=hp
 7     def attack(self,dog): # 人打狗
 8         dog.hp-=self.dps
 9         print('%s打了%s,%s还剩%s点血'% (self.name,dog.name,dog.name,dog.hp))
10 
11 class Dog:
12 
13     def __init__(self,name,kind,hp,dps):
14         self.name=name
15         self.kind=kind
16         self.hp=hp
17         self.dps=dps
18     def bite(self,person):#狗咬人
19         person.hp -= self.dps
20         print('%s咬了%s,%s还剩%s点血'% (self.name,person.name,person.name,person.hp))
21 
22 alex = Person('alex','男',250,5)
23 ha2 = Dog('小白','藏獒',1000,200)
24 ha2.bite(alex)
25 #alex.attack(ha2) #第一种写法
26 # 对象名.方法名 相当于调用一个函数，默认把对象名作为第一个参数传入函数 alex调用了attack函数
27 Person.attack(alex,ha2)#第二种写法
28 print(ha2.hp)

计算园的面积和周长

 1 # from math import pi
 2 # class Yuan:
 3 #     def __init__(self,r):
 4 #         self.r=r
 5 #     def Yuan_mianji(self):
 6 #
 7 #         return pi *self.r **2
 8 #     def Yuan_zc(self):
 9 #
10 #         return pi * 2*self.r
11 # yuan = Yuan(3)
12 # mj=yuan.Yuan_mianji()
13 # #mj1=Yuan.Yuan_mianji(yuan)
14 # zc=yuan.Yuan_zc()
15 # print('我是面积%s\n我是周长%s'%(mj,zc))

5 命名空间

# 类有自己的命名空间
# 对象也有自己的命名空间
# 对象能访问类的命名空间
# 类不能访问对象的命名空间

 1 class Person:
 2     COUNTRY = ['中国人']       # 静态属性
 3     country = '中国人'
 4     def __init__(self,name):
 5         self.name = name
 6     def eat(self):
 7         print('%s在吃泔水'%self.name)
 8 alex = Person('alex')
 9 egon = Person('egon')
10 # print(alex.name)
11 # print(alex.country)
12 # alex.country='印度人' #这个只是在alex这个对象里面生效
13 # print(alex.country)
14 # print(egon.country)
15 # print(Person.country) # Person里面的没有改过来
16 # alex.COUNTRY[0] = '印度人' # 改的是列表里面的元素
17 # print(alex.COUNTRY)
18 # print(egon.COUNTRY)
19 # print(Person.COUNTRY)
20 alex.COUNTRY=['印度人']
21 print(egon.COUNTRY) #中国人
22 print(Person.COUNTRY) #中国人
23 print(alex.COUNTRY)

结论：
# 在访问变量的时候，都先使用自己命名空间中的，如果自己的空间中没有，再到类的空间中去找
# 在使用对象修改静态变量的过程中，相当于在自己的空间中创建了一个新的变量
# 在类的静态变量的操作中  应该使用类名来直接进行操作 就不会出现乌龙问题

猜你喜欢