Day5-1 面向对象和面向过程

摘要:

类的定义

类的增删改查

对象的增删改查

对象的查找和绑定

面向对象和面向过程的区别:

1.面向过程就像是工厂的流水线,按部就班的有序的工作.

优点:把复杂的问题简单化

缺点:可扩展性差.一个步骤改动,其他的步骤几乎都要跟着改动.

适用:功能一旦实现之后就很少需要改变的场景.

2.面向对象:

2-1 什么是对象?

对象的具有一些特征和方法的集合.比如孙悟空是一个对象,他的特征是 毛脸雷公嘴,金箍棒,金箍圈.他的方法(技能)七十二变,火眼金睛.

优点:可扩展性强

缺点:编程复杂度高.

适用:互联网应用,企业应用,游戏.

类:是一系列对象相似的特征与技能的结合体

在不同的角度,获取的类是不一样的.比如在生物类的角度看,人,花草树木都是一类的,归于生物类.在人类的角度,人类是单独的类别,花草树木是植物类.

那么是先对有对象还是现有类?

在现实世界中:现有对象,再有类.

在程序中:要先定义类,再通过调用类产生对象.

类与函数的区别:

函数只有在被调用的时候,才会产生一个局部名称空间来存放函数体中的变量.

类一旦定义好了,就会产生一个局部名称空间来存放类体中的变量

注意：
  1.类中可以有任意python代码，这些代码在类定义阶段便会执行
  2.因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过 类名.__dict__查看
  3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的.语法
  4.点是访问属性的语法，类中定义的名字，都是类的属性

类的定义和增删改查:

 #在程序中:先定义类
 class Luffycity():
     school = "路飞学城"     # 这个叫数据属性

     def eat(self):         # 函数属性
         print("is eating")

     def sleep(self):
         print("is sleeping")

     def learn(self):
         print("is learning")

 # 查看类的名称空间:
 print(Luffycity.__dict__)
 # 查看类的名称空间中变量或者函数
 print(Luffycity.__dict__["school"])
 print(Luffycity.__dict__["learn"])
 print(Luffycity.__dict__["eat"])
 # 下面的语句等同于上面的查看方法
 print(Luffycity.school)
 print(Luffycity.learn)
 print(Luffycity.eat)
 # 增加一个类,比如增加一个country = china
 Luffycity.country ="china"
 print(Luffycity.country)

 # 删除一个类数据类型
 del Luffycity.country
 print(Luffycity.__dict__)

 # 修改,把路飞学城修改成luffycity
 Luffycity.school = "luffycity"
 print(Luffycity.school)

类的定义和增删改查

实例化对象和对象的增删改查:

 在现实世界中,对象和类:
     对象1.李春花
         特征:
             学校="路飞学城"
             名字="李春花"
             性别="女"
             年龄=20
         技能:
             吃饭
             睡觉
             学习
        对象2.小狗剩
         特征:
             学校="路飞学城"
             名字="小狗剩"
             性别="男"
             年龄=30
         技能:
             吃饭
             睡觉
             学习
        对象3.王武
         特征:
             学校="路飞学城"
             名字="王武"
             性别="男"
             年龄=18
         技能:
             吃饭
             睡觉
             学习

 现实生活中路飞学城的学生类:
         相似的特征:
         学校="路飞学城"
         相似的技能:
         吃饭
         睡觉
         学习
 """
 #__init__ 方法为对象定义独有的特征.
 class Luffycity():
     school = "路飞学城"
         #          stu1,"李春花",20,"女"
     def __init__(self,name,age,sex):
         self.Name=name
         self.Age=age
         self.Sex=sex

     # __init__初始化的过程相当于
     #self.Name="李春花"
     #self.Age=20
     #self.Sex="女"

     def eat(self):
         print("is eating")

     def sleep(self):
         print("is sleeping")

     def learn(self):
         print("is learning")

 #stu1 = Luffycity()      # 实例化,产生一个对象,但是每个stu1只有学校是一样的,他们的姓名年龄性别都有不同,该怎么办呢?
 #stu1 = Luffycity()     # 使用了__init__方法后,如果我们不按位置参数传参的话,会报少3个位置参数的错误.
 stu1=Luffycity("李春花",20,"女")        # Luffycity.__init__(stu1,"李春花",20,"女")
 # 我们来剖析一下加上__init__方法后,实例化的过程
 #1.产生一个空的对象stu1
 #2.Luffycity.__init__(stu1,"李春花",20,"女")    #self表示的就是对象自己

 #stu1对象经过实例化,也产生了3个数据属性.通过__dict__也能查看
 print(stu1.__dict__)

 # 对象的增删改查

 # 查看
 print(stu1.Name)
 # 删除
 del stu1.Name
 print(stu1.__dict__)
 # 修改
 stu1.Name = "王春花"
 print(stu1.__dict__)
 #增加
 stu1.class_name = "python全栈开发"
 print(stu1.__dict__)

 对象的增删改查

对象的增删改查

对象的查找和绑定函数数据:

 class Luffycity():
     school = "路飞学城"
         #          stu1,"李春花",20,"女"
     def __init__(self,name,age,sex):
         self.Name=name
         self.Age=age
         self.Sex=sex

     # __init__初始化的过程相当于
     #self.Name="李春花"
     #self.Age=20
     #self.Sex="女"

     def eat(self):
         print("%s is eating" % self.Name)

     def sleep(self):
         print("is sleeping")

     def learn(self,x):
         print("%s is learning in %s" % (self.Name,x))

 stu1 = Luffycity("李春花", 20, "女")
 stu2 = Luffycity("小狗剩", 30, "男")
 stu3 = Luffycity("王武", 18, "男")
 # 对象:特征与技能的结合体
 #类:一系列对象的相似的特征与相似的技能的结合体

 # 类中的数据属性:所有对象共有的. 我们看到对象和类的school的ID是一样的.说明他们引用的是同一个数据属性
 print(Luffycity.school, id(Luffycity.school))
 print(stu1.school, id(stu1.school))
 print(stu2.school, id(stu2.school))
 print(stu3.school, id(stu3.school))
 # 类中的函数属性:绑定到对象,给对象使用的,但是每个对象的绑定方法不一样.下面输出的函数属性的内存地址都不同,说明分别绑定了对象
 print(Luffycity.learn)
 print(stu1.learn)
 print(stu2.learn)
 print(stu3.learn)
 """当对象调用函数属性时,默认会把对象当作第一个参数传给函数属性中的self.也就是说谁调用函数属性,就把谁当作第一个参数传给self,
 如果函数属性中,还有其他参数,必须传其他参数进去.实际上,类中的函数属性,就是给对象使用的"""

 stu1.learn("home") # 等价于stu1.learn(stu1,"home"),输出的是:李春花 is learning in home.默认会把stu1传入到self,所以我们不用写stu1

 # 如果类和对象有一些共同的属性,那么对象去查找这个属性的时候,按照什么顺序呢?
 stu1.x="i'm stu1"   # 当对象中,有x这个属性的时候,会输出对象本身的属性.
 Luffycity.x = "i'm luffycity"   # 把上一行注释掉,发现,sut.x输出的是类的x属性.
 print(stu1.x)
 """把luffycity.x也注释掉,我们在全局设置一个x变量.再次输出stu1.x会报错.说明了查找属性的时候,只会从对象本身或者类中查找,
 如果类上面还有父类,也会在父类中查找"""

绑定和查找