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会报错.说明了查找属性的时候,只会从对象本身或者类中查找,
如果类上面还有父类,也会在父类中查找"""