L'origine de l'orienté objet
Pour plus de détails, s'il vous plaît voir cet article
Quelle est la programmation et pourquoi nous avons orienté objet besoin
Procédé de conception orientée
concept
Le processus de base est le mot, fait référence aux étapes du processus pour résoudre le problème, ce qui est à faire et ensuite faire ...... conception orientée processus est comme une chaîne de montage mieux que bien conçu, est un moyen mécanique de la pensée. Si le début du programme est de traiter un gros problème, idée de conception de base axée sur les processus est ce grand problème dans de nombreux petits problèmes ou sous-processus, ces sous-processus continuent à se décomposer dans le processus de mise en œuvre jusqu'à ce que suffisamment petits problèmes facile à résoudre en petites étapes dans une plage.
avantage
la complexité du processus du problème, et une plus grande simplification (une question complexe, dans une petite étape pour atteindre la réalisation de petites étapes sera très facile)
défaut
Un pipeline ou le procédé est utilisé pour résoudre un problème, la production de la production de boissons non alcoolisées de la ligne d'assemblage automobile ne peut pas, même peuvent, ils ont un grand changement, changer un composant, en effet affecter le corps, l'évolutivité pauvres.
scénarios
idées de programmation axées sur les processus sont généralement utilisés pour ces fonctions une fois atteint rarement besoin de changer la scène. Si vous écrivez juste un script simple, de faire quelques tâches uniques, sont excellentes avec une manière axée sur les processus. Une fois que le peu de changement de base de la scène, des exemples bien connus sont le noyau Linux, git et Apache HTTP Server, etc., mais si vous voulez gérer la tâche est complexe et nécessite l' itération constante et l' entretien, et ce fut le
面向对象plus commode.
La programmation orientée objet
concept
Le noyau est l'objet du mot, (pour comprendre pourquoi l'objet doit se considérer comme Dieu, toutes choses sont tous les objets existent dans les yeux du monde que Dieu n'existe pas peut être créé. La programmation orientée objet, comme une bonne conception Journey to the West, problème tathagata à résoudre est de passer par le livre des terres est Datang, tathagata pensé résoudre ce problème, il faut quatre personnes: moine, Shahe Shang, porc, Monkey king, chacun a ses propres caractéristiques et compétences (ce qui est l'objet du concept les caractéristiques et les compétences correspondent aux attributs de données et méthodes de propriétés de l'objet), mais ce n'est pas amusant, alors Tathagata a également organisé un groupe de démons, afin d'éviter que le mentorat quatre Gaosi pendant le voyage, et d'organiser un groupe de dieux escorte, ce sont des objets commencent alors à apprendre, le mentorat quatre dieux et les démons interagissent avec jusqu'à ce que finalement fait Écritures. Tathagata ne ramasser quatre tubes de mentorat conformément à ce que le processus), l'objet est une combinaison de caractéristiques et de compétences, sur la base processus de conception orientée objet est comme la création d'un monde, tu es le Dieu de ce monde, il y a tous , Il peut également être créé, en contraste frappant avec la mécanique axée sur les processus de pensée, accorder plus d'attention à la simulation orientée objet du monde réel, il est un type de pensée « Dieu ».
avantage
Résoudre le problème du programme à faible expansion. Il est souligné que, pour une qualité de logiciel, la programmation orientée objet ne représente pas tous. La programmation orientée objet est utilisé seulement pour résoudre le problème de l'évolutivité.
défaut
1, beaucoup plus élevé que la complexité du processus de programmation orientée, orientée objet et ne comprennent pas immédiatement commencé sur la base du processus de conception, très sujettes à des problèmes plus conçus. Certaines exigences de faible évolutivité scène invitant en utilisant la programmation orientée objet sera plus difficile, comme le système de gestion de scripts shell ne convient pas à utiliser des objets pour la conception, axée sur le processus , mais plus approprié.
2, ne peut pas être la conception pipe - line peut être très précis processus de traitement des problèmes de prédiction et les résultats de la programmation axée sur les processus, la programmation orientée objet une fois que vous commencez à résoudre les problèmes posés par l'interaction entre les objets, même Dieu ne peut prédire avec précision le résultat final . Donc , on voit souvent jeu d' arcade, un nouveau jeu de caractères, compétences Yin Pa se produisent très facilement pendant la bataille, le couteau piraté à mort trois personnes, cette situation est pas exactement prévisible, que l'interaction entre les objets peut être avec précision connaître le résultat final.
scénarios
En constante évolution des besoins des logiciels, des changements dans la demande générale est concentrée dans un bon endroit pour la couche utilisateur, des applications Internet, des logiciels d'entreprise, jeux, etc. sont la programmation orientée objet orienté objet programmation pour montrer leurs talents est pas tout. Pour une qualité de logiciel, la programmation orientée objet est uniquement utilisé pour résoudre l'évolutivité.
Fonction utilisant la conception orientée objet
OOD fonctionnelle
#方案一
def dog(name,gender,type):
# 狗的动作
def jiao(dog):
print('一条狗[%s]，汪汪汪' % dog['name'])
def chi_shi(dog):
print('一条[%s] 正在吃屎' % dog['type'])
#狗的特征
dog1 = {
'name':name,
'gender': gender,
'type': type,
'jiao':jiao,
'chi_shi':chi_shi,
}
return dog1
d1=dog('wj','母','中华田园犬')
d2=dog('qf','公','藏敖')
print(d1)
print(d2)
d1['jiao'](d1)
d2['chi_shi'](d2)
#方案二（改进）
def dog(name,gender,type):
# 狗的动作
def jiao(dog):
print('一条狗[%s]，汪汪汪' % dog['name'])
def chi_shi(dog):
print('一条[%s] 正在吃屎' % dog['type'])
def init(name,gender,type):
dog1 = {
'name':name,
'gender': gender,
'type': type,
'jiao':jiao,
'chi_shi':chi_shi,
}
return dog1
return init(name,gender,type)
d1=dog('wj','母','中华田园犬')
d2=dog('qf','公','藏敖')
print(d1)
print(d2)
d1['jiao'](d1)
d2['chi_shi'](d2)
la pratique de la conception orientée objet
def school(name,addr,type):
def init(name, addr, type):
sch = {
'name': name,
'addr': addr,
'type': type,
'kao_shi': kao_shi,
'zhao_sheng': zhao_sheng,
}
return sch
def kao_shi(school):
print('%s 学校正在考试' %school['name'])
def zhao_sheng(school):
print('%s %s 正在招生' %(school['type'],school['name']))
return init(name,addr,type)
s1=school('文天','郑蒲岗','公立学校')
print(s1)
print(s1['name'])
s1['zhao_sheng'](s1)
s2=school('清华','北京','公立学校')
print(s2)
print(s2['name'],s2['addr'],s2['type'])
s2['zhao_sheng'](s2)
classe Object (classe en utilisant la conception orientée objet)
Le concept de classes et objets
La catégorie est la catégorie, le type, la conception orientée objet est le plus des concepts importants avant que nous apprenons de l'objet est une combinaison de caractéristiques et de compétences, et la catégorie est une série d'objets similaires et est une combinaison de compétences.
La question est, est d'avoir une existence concrète d'un objet (comme la présence d'une personne spécifique)? Il était d'abord le concept? Cette question doit examiner deux cas
Dans le monde réel: certainement le premier, l'objet, et ont la classe
Le monde est certainement une variété d'objet existe réellement, puis avec le développement de la civilisation humaine, les êtres humains différents points de vue résumaient les différentes catégories, telles que le concept des êtres humains, les animaux, les plantes, etc., qui est, ledit objet est une existence concrète, alors que la classe est seulement un concept, n'était pas réel, par exemple, vous ne pouvez pas me dire ce qui se réfère spécifiquement à la personne humaine.
Dans le programme: vous qui définissent la classe, après avoir généré l'objet
Cette fonction est similaire à l' utilisation de la fonction: la première définie, la fonction est appelée.
Classe est le même: la nécessité du programme pour définir la classe. Après avoir appelé la classe.
Pas la même chose: la fonction appelant exécutera le code de corps de la fonction et renvoie le résultat de l' exécution du corps de la fonction. La classe devra appeler un objet, l'objet est retourné.
Définir une classe (le monde réel, le programme mondial)
Suivez les étapes ci-dessus, nous définissons une classe (nous sommes sur le point de vue de l'école, vous êtes tous les étudiants)
Dans le monde réel: certainement le premier, l'objet, et ont la classe
Dans le monde réel, jour debout de l'angle texte scolaire: d'abord, l'objet, et alors classe
objet réel
对象1：李易峰
特征:
学校=文天
姓名=李易峰
性别=男
年龄=23
技能：
学习
吃饭
睡觉
对象2：勇虹王者
特征:
学校=文天
姓名=勇虹王者
性别=男
年龄=28
技能：
学习
吃饭
睡觉
对象3：秋名山
特征:
学校=文天
姓名=秋名山
性别=男
年龄=18
技能：
学习
吃饭
睡觉
La réalité de la classe
现实中的学生类
相似的特征:
学校=文天
相似的技能：
学习
吃饭
睡觉
Dans le programme: assurer que définie (s), l'utilisation de la classe (pour objet générateur)
Dans le programme Python
类avec laclass关键字définition et dans le programme特征avec l'变量identité,技能avec l'函数identité, la classe et donc le plus commun est tout simplement:变量et函数définitions.
Programme en classe
class WentianStudent:
school='文天'
def learn(self):
print('is learning')
def eat(self):
print('is eating')
def sleep(self):
print('is sleeping')
#注意
#1.类中可以有任意python代码，这些代码在类定义阶段便会执行,因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过WentianStudent.__dict__查看
#2.类中定义的名字，都是类的属性，点是访问属性的语法
#3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的语法
Objets dans le programme
L'appel d'une classe, ou appelée instanciation, l'objet d'obtenir
s1=WentianStudent()
s2=WentianStudent()
s3=WentianStudent()
#如此，s1、s2、s3都一样了，而这三者除了相似的属性之外还各种不同的属性，这就用到了__init__
'''
__init__方法：
__init__方法是在对象产生之后才会执行，只用来为对象进行初始化操作
可以有任意代码，但一定不能有返回值(可以返回None,但是没有意义)
'''
class WentianStudent:
......
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
......
#先调用类产生空对象s1，然后调用OldboyStudent.__init__(s1,'李易峰','男',23)
s1=WentianStudent('李易峰','男',23)
s2=WentianStudent('勇虹王者','男',28)
s3=WentianStudent('秋名山','男',18)
les classes de programmes d'utilisation et d'objets
programme Classe d'utilisation
.:专门用来访问属性，本质操作的就是__dict__
WentianStudent.school #等于经典类的操作WentianStudent.__dict__['school']
WentianStudent.school='文天' #等于经典类的操作WentianStudent.__dict__['school']='文天'
WentianStudent.x=1 #等于经典类的操作WentianStudent.__dict__['x']=1
del WentianStudent.x #等于经典类的操作WentianStudent.__dict__.pop('x')
Utilisation d'objets programme
#执行__init__,s1.name='秋名山'，很明显也会产生对象的名称空间
s2.__dict__
{'name': '勇虹王者', 'age': '男', 'sex': 28}
s2.name #s2.__dict__['name']
s2.name='勇虹王者' #s2.__dict__['name']='勇虹王者'
s2.course='python' #s2.__dict__['course']='python'
del s2.course #s2.__dict__.pop('course')
Une explication détaillée de la méthode d'initialisation __init__
#方式一、为对象初始化自己独有的特征
class People:
country='China'
x=1
def run(self):
print('----->', self)
# 实例化出三个空对象
obj1=People()
obj2=People()
obj3=People()
# 为对象定制自己独有的特征
obj1.name='雯婧'
obj1.age=18
obj1.sex='female'
obj2.name='樵夫'
obj2.age=28
obj2.sex='male'
obj3.name='书呆子'
obj3.age=28
obj3.sex='male'
# print(obj1.__dict__)
# print(obj2.__dict__)
# print(obj3.__dict__)
# print(People.__dict__)
#方式二、为对象初始化自己独有的特征
class People:
country='China'
x=1
def run(self):
print('----->', self)
# 实例化出三个空对象
obj1=People()
obj2=People()
obj3=People()
# 为对象定制自己独有的特征
def chu_shi_hua(obj, x, y, z): #obj=obj1,x='雯婧',y=18,z='female'
obj.name = x
obj.age = y
obj.sex = z
chu_shi_hua(obj1,'雯婧',18,'female')
chu_shi_hua(obj2,'樵夫',28,'male')
chu_shi_hua(obj3,'书呆子',28,'male')
#方式三、为对象初始化自己独有的特征
class People:
country='China'
x=1
def chu_shi_hua(obj, x, y, z): #obj=obj1,x='雯婧',y=18,z='female'
obj.name = x
obj.age = y
obj.sex = z
def run(self):
print('----->', self)
obj1=People()
# print(People.chu_shi_hua)
People.chu_shi_hua(obj1,'雯婧',18,'female')
obj2=People()
People.chu_shi_hua(obj2,'樵夫',28,'male')
obj3=People()
People.chu_shi_hua(obj3,'书呆子',28,'male')
# 方式四、为对象初始化自己独有的特征
class People:
country='China'
x=1
def __init__(obj, x, y, z): #obj=obj1,x='雯婧',y=18,z='female'
obj.name = x
obj.age = y
obj.sex = z
def run(self):
print('----->', self)
obj1=People('雯婧',18,'female') #People.__init__(obj1,'雯婧',18,'female')
obj2=People('樵夫',28,'male') #People.__init__(obj2,'樵夫',28,'male')
obj3=People('书呆子',28,'male') #People.__init__(obj3,'书呆子',28,'male')
# __init__方法
'''
强调：
1、该方法内可以有任意的python代码
2、一定不能有返回值
'''
class People:
country='China'
x=1
def __init__(obj, name, age, sex): #obj=obj1,x='雯婧',y=18,z='female'
# if type(name) is not str:
# raise TypeError('名字必须是字符串类型')
obj.name = name
obj.age = age
obj.sex = sex
def run(self):
print('----->', self)
# obj1=People('雯婧',18,'female')
obj1=People(3537,18,'male')
# print(obj1.run)
# obj1.run() #People.run(obj1)
# print(People.run)
notes de classe
1. Les stations à différents angles, la définition de la classe est différente, la demande d'analyse détaillée des objets réels
2 en réalité pas exactement égale au programme de classe, comme une réalité de l' entreprise, parfois le programme besoin de se scinder en classe départements, classe affaires ......
3. parfois dans le but d'exigences du programme, le programme peut également définir la réalité n'existe pas dans la classe, telles que les classes politiques, en réalité , n'existe pas, mais dans le programme il est un type très courant
classe python construit des propriétés spéciales
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)