面向对象初识
什么是类？
类即类别、种类，是面向对象设计最重要的概念，对象是特征与技能的结合体，而类则是一系列对象相似的特征与技能的结合体
那么问题来了，先有的一个个具体存在的对象（比如一个具体存在的人），还是先有的人类这个概念，这个问题需要分两种情况去看
在现实世界中：先有对象，再有类
世界上肯定是先出现各种各样的实际存在的物体，然后随着人类文明的发展，人类站在不同的角度总结出了不同的种类，如人类、
动物类、植物类等概念也就说，对象是具体的存在，而类仅仅只是一个概念，并不真实存在
什么是对象？
对象，就是基于类而创建的一个具体的存在事物
利用嵌套函数的方式实现面向对象
实例1：
def dog(name,sex,type):
def init(name,sex,type):
dog1={
'name':name,
'sex':sex,
'type':type,
'jiao':jiao,
'chis':chis,
}
return dog1
def jiao(dog):
print('一只狗[%s],在叫汪汪汪' %dog['name'])
def chis(dog):
print('一只狗[%s],在吃屎' %dog['name'])
return init(name,sex,type)
d1=dog('lala','man','tesla')
d2=dog('bobi','母','te1')
d1['jiao'](d1)
d2['chis'](d2)
实例2
def people(name,sex,age):
def init(name,sex,age):
human={
'name':name,
'sex':sex,
'age':age,
'say':say,
'dead':dead,
}
return human
def say(xxx):
print('Human %s sex:%s 正在说话' %(xxx['name'],xxx['sex']))
def dead(xxx):
print('Human %s age:%s 已经死了' %(xxx['name'],xxx['age']))
return init(name,sex,age)
p1=people('亚瑟','男','40')
p2=people('大鸡','女','19')
p1['say'](p1)
p2['dead'](p2)由上面两个实例可以看出,面向对象设计,并不仅仅是通过class定义一个类然后生成实例,才叫做面向对象。
Python中的类
实例1
class Person: # class 关键字，定义了一个类
'''
类里面的所有内容
'''
animal = '高级动物' # 静态变量
soup = '有思想' # 静态变量
def __init__(self,name,sex,eye,high,weight,): # 构造方法,每次实例一个对象都会执行构造方法
self.eye = eye # 属性
self.name = name
self.sex = sex
self.high = high
self.weight = weight
print(666)
def work(self): #动态变量，动态方法，方法
print(self)
# self.job = 'IT'
print('人会工作....')我们就通过这个类的实例来学习下，Python中关于类的操作
类如何调用查看静态变量，动态变量
类操作静态变量有两种方式：
1，类名.__dict__方法 只能查看,不能增删改。
print(Person.__dict__)
print(Person.__dict__['animal'])
Person.__dict__['name'] = 'alex' #这样是使用会报错
2，类名.变量名 可增删改查
print(Person.animal)
print(Person.soup) #查看
Person.kind = '有性格' #增加
Person.animal = '低等动物' #修改
del Person.kind #删除
一般你想查询全部的静态变量时，用__dict__ 其他全部都用类名.变量名。
类操作方法(动态变量)有两种方式：
1，类名.__dict__[方法名]()
print(Person.__dict__['work'](11))
2，类名.方法名
Person.work(11)
类操作方法：类名.方法名()
只要创建一个类，里面的内容就已经加载到内存。
创建对象
类名() 实例化一个对象。实例化对象：类名()过程就叫做实例化。
p1 = Person() # p1 对象
p2 = Person()只要实例化一个对象，自动触发__init___
内部进行三步：
1，实例化一个对象，在内存中产生一个对象空间。
2，自动执行init方法，并将这个空间对象。 <__main__.Person object at 0x0000000001F5ABE0> 传给self
3，通过构造方法里的代码给空间对象添加一些属性，并返回给对象。
对象如何调用查看静态变量，动态变量，属性
对象操作属性变量有三种方式：
1,对象.__dict__方法 只能查看,不能增删改。
print(p1.__dict__)
2,对象.变量名 可增删改查
print(p1.name)
print(p1.eye)
p1.color = '黄皮肤'
print(p1.color)
print(p1, type(p1))
3,可以访问类的静态变量
print(p1.__dict__)
print(p1.animal)
print(p1.soup)
# 一般你想查询全部的静态变量时，用__dict__ 其他全部都用类名.变量名。
对象操作方法有两种方式：
1,对象.方法名()
p1.work()
print(p1)
print(p1.__dict__)
2,类名.方法名(对象)
Person.work(111)
Person.work(p1)
关于类空间与对象空间
通过实例化对象查找属性，先从对象空间找，没有则通过类对象指针从 类空间找。
组合
组合：给一个类对象的属性 封装 另一个类的对象。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#组合：给一个类对象的属性 封装 另一个类的对象。
class Game_person:
def __init__(self,nickname,sex,hp,ad):
self.nickname = nickname
self.sex = sex
self.hp = hp
self.ad = ad
def attack(self,p):
p.hp -= self.ad
print('%s了%s,%s还剩%s血量'%(self.nickname,p.nickname,p.nickname,p.hp))
def weapon_attack(self,武器):
self.武器 = 武器 #斧子对象
class Weapon:
def __init__(self,name,ad):
self.name=name
self.ad=ad
def fight(self,p1,p2):
p2.hp -= self.ad
print('%s使用%s打了%s%s血,%s还剩%s滴血'\
%(p1.nickname,self.name,p2.nickname,self.ad,p2.nickname,p2.hp))
ts = Game_person('泰森','男',200,50)
barry = Game_person('太白','男',100,10)
fuzi = Weapon('斧子',60)
# wea.fight(barry,ts) 这样写不好,主体应该是人
# ts.attack(barry)
# barry.attack(ts)
barry.weapon_attack(fuzi) #将fuzi对象传给了weapon_attack方法
# barry对象调用weapon_attack方法，
# 方法执行的是将斧子对象wea封装到barry对象的属性中、
# barry.武器 相当于 wea
barry.武器.fight(barry,ts)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
