面向对象

面向对象简介

  • Python是一门面向对象的编程语言
  • 所谓面向对象的语言，就是语言中所有操作都是通过对象来进行的
  • 面向过程：
    • 将程序分解为一个个步骤，通过每个步骤的抽象来完成程序
    • 这种编写方式旺旺只适用于一个功能，如果要实现别的功能，复用性比较低
    • 这种变成方式符合人类思维，编写起来比较容易
  • 面向对象的编程语言，关注的是对象忙不注重过程，对于面向对象一切皆对象
  • 面向对象的变成思维，将所有功能同意保存到对应的对象中，要是用某个功能，直接找到对应的对象
  • 这种编码方式比较容易阅读，并且依云维护，容易复用，但编写的过程中不太符合常规思维，相对麻烦
  • 三大特性
    • 封装 确保对象中的数据的安全
    • 继承 保证对象的扩展性
    • 多态 保证程序灵活性

类

  • class
  • 我们目前学习的都是Python的内置对象，但是内置对象并不都能满足我们的需求，所以，我们在开发中经常要自定义一些对象
  • 类 就相当于一个图纸，在程序汇总我们需要根据类来创建对象
  • 类 就是对象的图纸
  • 我们也称对象是类的实例（instance）
  • 如果多个对象是通过一个类创建的，我们称这些对象是一类对象
1
2
3
4
5
a = 123
b = 'python'
print(type(a),type(b))

<class 'int'> <class 'str'>
1
2
3
4
5
class MyClass():
    pass
print(MyClass)

<class '__main__.MyClass'>
1
2
3
4
5
6
7
class MyClass():
    pass
mc = MyClass()
print(mc,type(mc))

<__main__.MyClass object at 0x0000021D8C0BE128> <class '__main__.MyClass'>
                     对象                                类
  • 用isinstance（）检测是否属于一类 isinstance(检查对象，类)
1
2
3
4
5
6
7
8
9
10
11
12
13
class MyClass():
    pass
mc = MyClass()
mc1 = MyClass()
mc2 = MyClass()
mc3= MyClass()
r = isinstance(mc1,MyClass)
print(r)
c = isinstance(mc1,int)
print(c)

True
False
  • 类也是一个对象，类就是用来创建对象的对象
  • 可以向对象中添加变量，对象中的变量称为属性语法 对象.属性名 = 属性值

类的定义

  • 类和对象都是对像是生活中事务的抽象

  • 包含两部分

    • 数据（属性）
    • 行为（方法）

  • 调用方法 对象.方法名()

  • 方便调用和函数调用的区别：如果是函数调用，调用时有几个形参，就会传递几个实参。如果是方法调用，默认传递一个参数，所以方法中至少得有一个形参

1
2
3
4
5
6
7
8
9
10
11
class MyClass():
    name = '三三不得酒吖'
    def fn(self):
        print('大家好')

mc = MyClass()
print(mc.name)
mc.fn()

三三不得酒吖
大家好

  • 在类代码块中，我们可以定义变量和函数

    • 变量会成为该类实例的公共属性，所有的该实例都可以通过 对象.属性名的形式访问
    • 函数会成为该类实例的公共方法，所有该类实例都可以通过 对象.方法名的形式访问

  • 当我们调用的一个对象属性时，解释器会在当前对象中寻找是否含有该属性

    • 有，则返回当前对象的属性值
    • 没有，则取当前对象的类对象中寻找，如果有则返回当前类对象的属性值，如果没有则报错
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class MyClass():
        name = '三三不得酒吖'
        def fn(self):
            print('大家好')

    mc = MyClass()
    mc1 = MyClass()
    mc.name = '三三'
    print(mc.name)
    print(mc1.name)

    三三
    三三不得酒吖

  • 总结:

    • 类对象和实例对象都可以保存属性和方法
    • 如果这个属性（方法）是所有案例共享，则应该保存到类对象中
    • 如果这个属性（方法）是实例独有，则保存到实例的对象中
    • 一般情况下属性保存到实例对象中
    • 一般情况下方法保存到类对象中

参数self

属性和方法

  • 类中定义的属性和方法都是公用的，任何实例都可以访问
  • 属性和方法的查找流程
    • 当我们调用一个对象的属性时，解析器会现在当前的对象中寻找是否还有该属性，如果有，则直接返回当前的对象的属性值。如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值。如果没有就报错
  • 类对象和实例对象中都可以保存属性(方法)
    • 如果这个属性(方法)是所以的实例共享的，则应该将其保存到类对象中
    • 如果这个属性(方法)是摸个实例独有的。则应该保存到实例对象中
    • 一般情况下，属性保存到实例对象中 而方法需要保存到类对象中

self

  • self在定义时需要定义，但是在调用时会自动传入
  • self名字随意，但是按照规定是用self
  • self总是只调用时的类的实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class MyClass():
    name = '三三不得酒吖'
    def fn(self):
        print('大家好,我是%s'%self.name)

    def fn1(self):
        print('我要学%s'%self.name)

mc = MyClass()
mc1 = MyClass()
mc.name = '三三'
print(mc.name)
mc.fn()
mc.fn1()
print(mc1.name)
mc1.fn()

三三
大家好,我是三三
我要学三三
三三不得酒吖
大家好,我是三三不得酒吖

特殊方法

  • 在类中可以定义一些特殊方法，也称为魔术方法
  • 特殊方法形如__xxx__()这种形式
  • 特殊方法不需要我们调用，会在特定的时候自动调用
1
2
3
4
5
6
7
8
9
10
11
12
13
class Person():
    print('执行类')
    def __init__(self,name):
        self.name = name

    def speak(self):
        print('大家好，我是%s'%self.name)

p1 = Person('刘亦菲')
p1.speak()

执行类
大家好，我是刘亦菲

封装

封装

  • 封装原因:增强数据安全性
    • 属性不能随意修改
    • 属性不能改为任意值
  • 封装为面向对象三大特性之一
  • 封装指隐藏对象中一些不希望被外部所访问到的属性或方法
  • 用_xxx 告诉访问者 此对象不建议修改
  • 防君子不妨小人
1
2
3
4
5
6
7
8
9
class Car():

    def __init__(self,name):
        self._name = name
        
car = Car('兰博基尼')
print(car._name)

兰博基尼

  • 可以提供get方法和set方法从外部访问到属性

    • get方法获取对象中的指定属性,书写方法如下
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    class Car():

        def __init__(self,name):
            self._name = name
        def getname(self):
            print('调用get')
            return self._name
            
    car = Car('兰博基尼')
    print(car._name)
    print(car.getname())

    兰博基尼
    调用get
    兰博基尼
    • 可以用set方法设置对象属性
    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
    class Car():

        def __init__(self,name):
            self._name = name

        def getname(self):
            print('调用get')
            return self._name
            
        def set_name(self,name):
            print('调用set')
            self._name = name

    car = Car('兰博基尼')
    print(car._name)
    print(car.getname())
    car.set_name('二哈')
    print(car.getname())

    兰博基尼
    调用get
    兰博基尼
    调用set
    调用get
    二哈

  • 使用封装确实增加类定义的复杂程度，也确保了数据的安全

    • 隐藏属性名，使调用者无法随意修改对象中的属性
    • get与set方法 控制属性是否只读
    • set属性可以进行数据验证
    • 使用get方法获取属性，使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理
    • 防君子不防小人
    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
    class Car():

        def __init__(self,name):
            self._name = name

        def getname(self):
            print('调用get')
            return self._name
            
        def set_name(self,name):
            print('调用set')
            self._name = name

    car = Car('兰博基尼')
    print(car._name)
    print(car.getname())
    car.set_name('二哈')
    print(car.getname())
    car._name = 'car'
    print(car._name)
    print(car.getname())

    兰博基尼
    调用get
    兰博基尼
    调用set
    调用get
    二哈
    car
    调用get
    car

绝对封装

  • 可以使用双下划线开头进行绝对封装，隐藏属性只能在类的内部进行访问，无法通过对象访问
  • 隐藏属性不过是python自动为属性改了一个名字 _类名__属性名例如 _Person__name
  • 这种方式实际上依然可以外部访问 所以我们一般不用，一般我们会将一些私有属性以_开头
  • 一般情况下,使用_开头的属性都是私有属性，没有特殊情况下不要修改私有属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Person:
    def __init__(self,name):
        self.__name = name

    def speak(self):
        print('大家好，我是%s'%self.__name)

    def get_name(self):
        print('调用GET')
        return self.__name

    def set_name(self,name):
        print('调用SET')
        self.__name = name

p1 = Person('三三')
print(p1.get_name())
p1.__name = '成仙啦'
print(p1.get_name())

调用GET
三三
调用GET
三三
  • 绝对封装外部修改方法 实例.函数名__修改对象
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
class Person:
    def __init__(self,name):
        self.__name = name

    def speak(self):
        print('大家好，我是%s'%self.__name)

    def get_name(self):
        print('调用GET')
        return self.__name

    def set_name(self,name):
        print('调用SET')
        self.__name = name

p1 = Person('三三')
print(p1.get_name())
p1._Person__name = '三三不得酒吖'
print(p1.get_name())

调用GET
三三
调用GET
三三不得酒吖

property装饰器

  • 可以用@property装饰器创建只读属性，@property会将方法转换为相同名称的只读属性，可以与所定义的属性配合使用，这样可以防止被修改
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Person():
    def __init__(self,name):
        self._name = name

    @property
    def get_name(self):
        print('调用GET')
        return self._name

    @get_name.setter
    def set_name(self, name):
        print('set方法执行了')
        self._name = name

p = Person('三三')
print(p.get_name)
p.set_name = '三三不得酒吖'
print(p.get_name)

调用GET
三三
set方法执行了
调用GET
三三不得酒吖

继承

继承简介

  • 面向对象的散搭特性
  • 可以使一个类获取到其他类的属性和方法
  • 在定义类时，可以在类名后面括号中制定当前类的父类
  • 继承提高了类的复用性，让类与类之间产生了联系
  • 所有父类都有一个object
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
class Animal :
    def sleep(self):
        print('可以睡')

    def run(self):
        print('可以跑')

class Dog(Animal):
    pass

dog = Dog()
dog.sleep()
dog.run()
r = isinstance(dog, Dog)
print(r)
s = isinstance(dog,Animal)
print(s)
t = issubclass(Dog,Animal)     #检测父类
print(t)
u = issubclass(Dog,object)
v = issubclass(Animal, object)
w = issubclass(int, object)
print(u,v,w)


可以睡
可以跑
True
True
True
True True True

方法重写

  • 如果在子类中有和父类同名的方法，则通过子类实例调用方法时，会调用子类的方法，这个方法称为重写
  • 调用一个对象的方法时
    • 会优先去当前对象中寻找是否具有该方法，有则调用
    • 无则取父类寻找，父类有则调用
    • 以此类推最后找不到就报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Animal :
    def sleep(self):
        print('可以睡')

    def run(self):
        print('可以跑')

class Dog(Animal):
    def sleep(self):
        print('狗可以睡')

    def run(self):
        print('狗可以跑')
        
dog = Dog()
dog.sleep()
dog.run()

狗可以睡
狗可以跑

super

  • 继承会继承init特殊方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Person:
    def __init__(self,name):
        self.name = name

    def sleep(self):
        print('可以睡')

    def drink(self):
        print('可以喝酒')

class Sansan(Person):

    def sleep(self):
        print('可以睡')

    def drink(self):
        print('%s可以喝酒'%self.name)

san = Sansan('三三')     #init也会被继承
san.drink()

三三可以喝酒
  • 继承也会继承装饰器
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
40
41
42
43
class Person:
    def __init__(self,name):
        self.name = name

    @property
    def getname(self):
        print('调用get方法')
        return self.name

    @getname.setter
    def setname(self,name):
        print('调用set方法')
        self.name = name


    def sleep(self):
        print('可以睡')

    def drink(self):
        print('可以喝酒')

class Sansan(Person):

    def sleep(self):
        print('可以睡')

    def drink(self):
        print('%s可以喝酒'%self.name)

san = Sansan('三三')
san.drink()
print(san.getname)
san.setname = '三三啊'
print(san.getname)
san.drink()

三三可以喝酒
调用get方法
三三
调用set方法
调用get方法
三三啊
三三啊可以喝酒
  • init可以重写
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Person:
    def __init__(self,name):
        self.name = name

class Sansan(Person):
    def __init__(self,age,name):
        self.age = age
        self.name = name

    def sleep(self):
        print('可以睡')

    def drink(self):
        print('%s岁'%self.age)
        print('%s可以喝酒'%self.name)

san = Sansan('18','三三')
san.drink()

18岁
三三可以喝酒
  • 继承的普通方法
    • 此方法不建议使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def drink(self):
        print('可以喝酒')

class Sansan(Person):
    def __init__(self,name,age):
        Person.__init__(self,name,age)   #继承Person

    def drink(self):
        print('%s岁'%self.age)
        print('%s可以喝酒'%self.name)

san = Sansan('三三','18')
san.drink()

18岁
三三可以喝酒

  • super方法

    • 写super时不用写self
    • 继承父类方法
    • 开发中不要用父类.方法和super()混用，会形成递归，造成死循环
    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
    class Person:
        def __init__(self,name,age):
            self.name = name
            self.age = age

        @property
        def getname(self):
            print('调用get方法')
            return self.name

        @getname.setter
        def setname(self,name):
            print('调用set方法')
            self.name = name


        def sleep(self):
            print('可以睡')

        def drink(self):
            print('可以喝酒')

    class Sansan(Person):
        def __init__(self,name,age):
            super().__init__(name,age)   #不要写self

        def sleep(self):
            super().sleep()

        def drink(self):
            print('%s岁'%self.age)
            print('%s可以喝酒'%self.name)

    san = Sansan('三三','18')
    san.drink()
    san.sleep()

多重继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class A:
    def test(self):
        print('A')

class B(A):
    def test(self):
        print('B')

class C(B):
    pass

c = C()
c.test()
print(C.__bases__)   #print C父类

B
(<class '__main__.B'>,)
  • 每个子类都可以继承多个父类
    • 不建议这么写
    • 解耦合：不希望不同部分的代码产生过多牵连
      • 提高问题的解决效率
      • 提高问题的解决概率
      • 提高问题的解决速度
      • 降低将来爆发隐患的可能性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class A:
    def test(self):
        print('A')

class B:
    def test1(self):
        print('B')

class C(A, B):

    pass

c = C()
c.test()
c.test1()

A
B

多态

多态简介

  • 面向对象的萨达特性之一

  • 一个对象可以以不同形态去呈现

  • python的多态是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容平的函数

  • 多态特点

    • 只关心对象实例方法是否同名，不关心所属类型
    • 对象所属的类之间，继承关系可有可无
    • 可以增加代码外部调用的灵活性，让代码更通用，兼容性强
    • 是调用方法的技巧，不会影响到类的内部设计

  • 无继承关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class A:
    def age(self):
        print('三三会长大')

class B:

    def age(self):
        print('三三会喝酒')

class C:

    def age(self):
        print('三三会跳舞')

def age(obj):
    obj.age()

a = A()
b = B()
c = C()

age(a)
age(b)
age(c)
  • 有继承关系
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
40
41
42
class Old:
    def __init__(self,money):
        self.money = money

    def speak(self):
        print('我是old,我的工资是%s'%self.money)


class Young(Old):
    def __init__(self, money,job):
        super().__init__(money)
        self.job = job

    def speak(self):
        print('我是yong,我的工作是%s'%self.job)
        print('我是yong,我的工资是%s' % self.money)

class Son(Old):
    def __init__(self,money,job):
        super().__init__(money)
        self.job = job

    def speak(self):
        print('我是son,我的工作是%s'%self.job)
        print('我是son,我的工资是%s' % self.money)

def fn(obj):
    obj.speak()

old = Old(3000)
young = Young(10000,'教师')
son = Son(20000,'程序员')

fn(old)
fn(young)
fn(son)

我是old,我的工资是3000
我是yong,我的工作是教师
我是yong,我的工资是10000
我是son,我的工作是程序员
我是son,我的工资是20000

属性和方法

类属性

  • 直接定义在类中的属性
  • 可以通过类和该类的实例来访问
1
2
3
4
5
6
7
8
9
10
class A():
    count = 0

a = A()
a.count = 10
print(a.count)
print(A.count)

10
0

  • 类属性不能通过实例进行修改，只能通过类对象来修改

  • 实例属性只能通过实例来访问，不能通过类对象访问

实例方法

  • 以self为第一个参数的方法都是实例方法
  • 担当通过实例对象调用时，会自动传递当前对象作为self传入
  • 当通过类对象调用时，不会传递self，需传递实例对象

类方法

  • 在类内部使用@classmethod修饰的方法属于类方法
  • 类方法可以通过类对象调用，也可以通过实例对象调用
  • 类方法第一个参数默认cls，cls相当于当前的类对象
1
2
3
4
5
6
7
8
9
10
11
12
13
class A():

    @classmethod
    def fn(cls):
        print('这是fn方法')


a = A()
a.fn()
A.fn()

这是fn方法
这是fn方法

静态方法

  • 使用@statcimethod修饰的方法
  • 不需要指定任何的默认参数，静态方法可以被类对象和实例对象调用（静态方法和类本身无关，只是一个功能函数）
1
2
3
4
5
6
7
8
9
10
11
12
13
class A():

    @staticmethod
    def fn1():
        print('这是静态方法')

a = A()
a.fn1()
A.fn1()

这是静态方法
这是静态方法