Python:初始面对对象(1)

初始面对对象

  • 面对对象和面对过程

    1. ⾯面向过程: ⼀一切以事物的流程为核心. 核心是”过程”⼆二字, 过程是指解决问题的步骤,即, 先干什么, 后干什么. 基于该思想编写程序就好比在编写⼀一套流⽔线. 是⼀一种机械式的编程思维

      根据业务逻辑从上到下写垒代码

      • 优点: 负责的问题流程化, 编写相对简单
      • 缺点: 可扩展性差

    2. ⾯面向对象:Object Oriented Programming，OOP， ⼀一切以对象为中⼼心.
      什么是对象? 不好解释. 先解释解释什么是车? 有轱辘, 有方向盘, 有发动机, 会跑的
      是车. 好. 在解释⼀一个. 什么是人. 有名字, 年龄, 爱好, 会唱歌跳舞思考的是人. 我们给这两个东西下了了⼀一个简单的定义. 总结: 具有相同属性和动作的结合体叫对象. 面向对象思维, 要自己建立对象. 自己建立场景. 你是就是面向对象世界中的上帝. 你想让车干嘛就干嘛. 你想让人干嘛人就能干嘛.

      对函数进行分类和封装，让开发“更快更好更强…”

      • 优点: 可扩展性强
      • 缺点: 编程的复杂度⾼高于⾯面向过程

  • 类(Class)和实例(Instance)是面向对象最重要的概念。

    类与对象的关系: 类是对事物的总结. 抽象的概念. 类用来描述对象. 对象是类的实例
    化的结果. 对象能执行哪些方法. 都由类来决定. 类中定义了什么. 对象就拥有什么

    • 类和对象是面向对象中的两个重要概念
    1. 类：类有静态属性和静态方法，类无法访问动态属性和动态方法；
    2. 对象：对象有动态属性和动态方法，对象可以访问静态属性和静态方法；

    在python中定义一个类

    1
    2
    3
    class Cars:
        block

  • 现在我们来定义一辆车,把车特征信息写进类定义中,在python中 通过特殊的__init__方法实现.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    #定义一辆车
    class Car:
        #出厂设置(__int__) 构造方法
        def __init__(self,color,pai,pailinag,own): #表示当前类的对象
            #print("造车")
            #print(self)
            #绑定属性.
            self.color1 =  color
            self.pai = pai
            self.pailing = pailinag
            self.own = own
        #车能跑,跑就是一个动作,要写函数(方法)
        def run(self): #self: 当前类的对象.
            print("%s车飞起来了"% self.color1)
            print(self)
        def tiaogao(self):
            print("有一台%s车在疯狂调高"% self.color1)
             c1 = Car("红色","川B9BB95","2.0L",'manotu') # 自动调用int函数(方法) #c1是对Car()的实例化
    c1.run() #对象.方法

    c1.tiaogao()

    print(c1)

    print(c1.dict)

    print(c1.color1)

    c1.color1= "绿色"

    print(c1.color1)

      #

    #
    c2 = Car("宝蓝色","川B66666","3.0T","baozi") 

    c2.run() #执行run方法
    print(c2)

    ps：类中的函数第一个参数必须是self

类中定义的函数叫做 “方法”

面对对象的三大特征

封装 继承 多态

一.封装

封装: 把具有相同属性和功能的内容封装在一个对象中

在使用面向对象的封装特性时，需要：

  • 将内容封装到对象

  • 从对象调用被封装的内容

    1. 将内容封装到某处
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16



    #创建类

    class Foo:
        def __init__(self,name,age): #称为构建方法,根据类创建对象时自动执行
            self.name = name
            self.age =age
            
    #根据类Foo创建对象
    #自动执行Foo类的__init__方法
    #将amntou 和18 分别封装到obj1 self 的name 和age 属性中
    obj1 = Foo("amntou",18)

    obj2 = Foo("baozi",20)

  1. 调用被封装的内容时，有两种情况：

    • 通过对象直接调用
    • 通过self间接调用
    1. 通过对象直接调用 对象.属性名 
   
1
2
3
4
5
6
7
8
class Foo:
    def __init__(self,name,age): 
        self.name = name
        self.age =age
obj1 = Foo("amntou",18)
print(obj1.name) #直接调用obj1对象name属性
obj2 = Foo("baozi",20)
print(obj2.age) # 直接调obj2对象 age属性


   ​

   ​

   ​

   2. 通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Foo:
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def detail(self):
        print self.name
        print self.age
 
obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
 
obj2 = Foo('alex', 73)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78
    


> ** 综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。 **
二 继承

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。

​

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Animal: #在此代码段中,为父类
    def eat(self):
        print("%s吃"% self.name)
    def dirnk(self):
        print("%s喝"% self.name)
    def sleep(self):
        print("%s睡"% self.name)
class Cat(Animal):# 在类名括号中写入另一个类名表示继承另一个类

    def __init__(self,name):
        self.name = name
        self.breed = "猫"
    def cry(self):
        print("喵喵叫")
class Dog(Animal): # 在类名括号中写入另一个类名表示继承另一个类

    def __init__(self,name):
        self.name = name
        self.breed = "狗"
    def cry(self):
        print("汪汪")


cat = Cat("福禄丸")
cat.eat()
cat.cry()
cat.dirnk()
dog = Dog("帕克")
dog.cry()
dog.dirnk()

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

1
2
3
4
5
6
7
class 父类
	def 父类中的方法(self): #子类继承父类,即拥有了父类中所以方法
     #
class 子类(父类):
  pass
zi = 子类() #创建子类对象
zi.父类中的方法() #执行从父类中继承的方法

  1. python的类可以继承多个类,java 和c#中则只能继承一个类

  2. python的类继承了多累,寻找方法的方式为两种分别是深度优先 和 广度优先

    • 如果是经典类MRO为DFS（深度优先搜索（子节点顺序：从左到右）
  • 如果是新式类MRO为BFS（广度优先搜索（子节点顺序：从左到右））
  • Python 至少有两种不同的 MRO：
    • 经典类（classic class）的深度遍历。
    • Python 2.2 的新式类 MRO
    • Python 2.3 的新式类的C3 算法。它也是 Python 3 唯一支持的方式。

mor算法参考博客

1
2
3
4
5
6
7
8
9
10
11
12
#经典类
class C1:
	pass
class C2(C1):  C2是经典类
  pass


# 新式类
class N1(object):
  pass
class N1(N1):
  pass

三 多态

Python

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！