文章目录
Python是一门面向对象设计的编程语言，所以Python里面提供了非常专业的面向对象用法。本篇就来总结一下面向对象相关的知识，从面向对象设计，到面向对象编程，再到Python中独有的类与对象
面向对象设计
先来看一个面向对象设计的例子（里面没有用到类与对象）：
def wushi(name,age,wutype):
#武士的动作
def sword(sw):
print('{}正在释放{}'.format(sw['one_sword'],sw['three_sword'])) #取键对应的值
def teji(tj):
print('{}释放{}大招'.format(tj['one_sword'],tj['three_teji']))
#武士的属性
def init(name,age,wutype): #定义一个函数来专门装存武士属性的字典
#一个定义属性的字典
zhaoshi = {
'one_sword':name, #字典的值为形参变量
'two_sword':age,
'three_sword':wutype,
'one_teji':'大振撼',
'three_teji':'三千世界',
#字典的值可以是一个函数名,这样就将武士的动作和属性绑定起来了
#键'sword'和'teji'就是属性，值sword和teji就是动作（函数）
'sword':sword,
'teji':teji,
}
return zhaoshi #返回一个字典
res = init(name,age,wutype)
return res
ret1 = wushi('索隆','22','三刀流') #运行函数，将返回值赋值给ret
ret1['sword'](ret1)
#找到字典键['sword']对应的值，因为是个函数，可以用()直接运行
#传入的是一个字典，所以在sword函数中可以用键取值
ret2 = wushi('路飞','19','无刀流')
ret2['teji'](ret2)
#这样就可以生成多个武士（wushi函数），并且给他们传入不同的属性
运行结果：
类与对象的概念
1、类与对象的本质
一个对象就是动作跟属性的结合；
一个类就是承载同种类事物的动作和属性的一个容器；
因为这容器有特定的属性和动作，就相当于一个模型。
2、面向对象设计 到 面向对象编程
在上文的代码中，wushi(武士)就是一个类，sword和teji函数就是类中定义的动作，zhaoshi就是类中定义的属性；
而ret1和ret2就两个对象，这两个对象拥有了类中的动作和属性
3、类实例化
由类产生一个对象就是类实例化，这个对象具备类中的属性和动作，一个类可以产生任意个对象
4、例如一个学校类
属性： name, address, type
动作： 考试, 招生, 开除学生
每一所学校则就是一个个对象；由这个学校类产生多个学校就类实例化
面向对象编程
1、案例
#创建一个wushi类
class wushi: #类可以不要参数
#定义属性
def __init__(self,name,age,wutype): #相当于存放属性的一个函数，self参数是必要参数
self.name = name #将self的name用传入的形参name来赋值，就相对于面向对象设计中的字典给键赋值
self.age = age
self.wutype = wutype
#定义动作
def sword(self): #传入的参数为self这个属性，将动作与属性结合起来
print('{}岁的{}正在释放{}'.format(self.age, self.name, self.wutype))
#用self.来使用属性变量，类似字典中的sw['age'],sw['name'],sw['wutype']
def teji(self):
print('{}岁的{}释放大招{}'.format(self.age, self.name, self.wutype))
#创建对象，即类实例化，每一个对象都调用了wushi这个类
wushi_one = wushi('路飞','19','无刀流')
wushi_two = wushi('索隆','22','三刀流')
wushi_three = wushi('鹰眼','32','大宝剑')
#调用对象，即使用对象中的属性和动作
wushi_one.sword()
wushi_two.teji()
wushi_three.teji()
运行结果：
2、面向对象语言和面向对象编程之间的关系
Python是一门面向对象设计的编程语言，但面向对象编程并不是每个程序都必须的，如果用普通的函数堆叠就能实现功能也可以不用class类和__init__的方法。
只是在程序比较大的时候，用面向对象编程可以使程序更简单。
还有一个概念，用面向对象语言写程序、程序的设计是面向对象的是两码事。
比如第一段代码里面，它是面向对象设计，但在非面向对象语言里这样写代码，那也可以叫做程序的设计是面向对象的
3、类的属性
数据属性： 就是变量
函数属性： 就是函数，但在面向对象里面称作方法
#创建一个wushi类
class wushi:
#定义属性
vv = '海贼王' #定义一个数据属性
def killer(self):
print(self)
return 'killer 的返回值'
print(wushi.vv) #调用数据属性
print(wushi.killer('三千世界')) #调用函数属性
print(dir(wushi)) #查看类的所有属性名
print(wushi.__dict__) #查看类属性字典，包括属性名和属性
print(wushi.__dict__['vv']) #用键值对取数据属性
print(wushi.__dict__['killer']('三千世界')) #用键值对取函数属性
运行结果：
4、类的其他一些属性
#创建一个wushi类
class wushi:
'这是一个武士的类' #相当于一个类的描述
#定义属性
vv = '海贼王' #定义一个数据属性
def killer(self):
print(self)
return 'killer 的返回值'
print(wushi.__name__) #输出类的名称
print(wushi.__doc__) #输出类的描述
print(wushi.__base__) #类的类型，都为<class 'object'>
print(wushi.__module__) #查看类所在的模块
运行结果：
5、类中的作用域
在类定义的变量是属性，可以调用，全局变量则不能当做属性来调用
name = 'Kevie'
#创建一个类
class wushi:
age = 18
print('this is from 类%s' %name)
v = wushi()
print(v.age)
#print(v.name) #name是全局变量
#创建一个函数
def wushi_2():
age = 18
print('this is from 函数%s' %name)
wushi_2()
运行结果：
6、实例化相关（查、增、改、删）
实例由类产生，类有数据属性和函数属性；但实例（对象）只有数据属性，没有函数属性；只是通过数据属性来访问函数属性；所以每个函数都需要传入self属性作为参数
class wushi:
def __init__(self,name,age):
self.name = name
self.age = age
def bark(self,greet):
print('%s ! %s am %s' %(greet,self.name,self.age))
v = wushi('索隆','22') #实例化一个类，生成对象（实例）v
print(v.age) #用实例来调用数据属性
v.bark('Hello') #通过数据属性self来访问bark函数属性，同时再传入一个参数
#修改实例（对象）的属性
v.name = '路飞'
v.bark('Hello')
#增加类属性
wushi.wutype = '三千世界1'
print(wushi.wutype)
#增加对象（实例）属性
v.wutype = '三千世界2'
print(wushi.wutype)
#增加一个动作（类与实例方法相同）
def play_game():
print('this is from play_game')
v.play_game = play_game
v.play_game()
#删除类属性（实例属性方法同）
del wushi.wutype
print(wushi.__dict__) #查看所有属性，就不存在wutype了
运行结果：
注意：类修改后只改变了类，在改之前创建的实例是不会变的；同样，实例的修改也不会影响类的属性
