复习python面向对象

1.面向对象定义
2.类特殊方法
3.封装
- property装饰器
4.继承
- 多重继承
5.多态
6.属性和方法

1.面向对象定义

在讲面向对象之前，先来看看面向过程。
面向过程 ：将一个功能分解成一个一个小的步骤，通过完成一个个步骤来完成一个程序。
面向对象：关注的是对象，而不关注过程。它的编程思想是将所有的功能统一保存到对应的对象中，易于维护和复用。

python 复制代码

class Person():
    # 在类中可以定义变量和函数
    name = 'swk'    # 公共属性，所有实例都可以访问

    def say_hello(self):
        print('你好！%s' % self.name)

p1 = Person()
p2 = Person()

p1.name = '猪八戒'
# 调用方法，对象.方法名（）
p1.say_hello()

2.类特殊方法

特殊方法都以__开头，__结尾的方法。

特征：特殊方法不需要我们自己调用。

学习特殊方法：1.特殊方法什么时候调用 2.特殊方法有什么作用。

python 复制代码

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    # 当我们打印一个对象时，实际上打印的是对象中的特殊方法__str__返回值    
	def __str__(self):
        return 'Person [name = %s, age = %s]'%(self.name, self.age)

    # __repr__作用：指对象在'交互模式'中直接输出的效果
    def __repr__(self):
        return 'hello'

    # object.__lt__(self, other)    小于
    # object.__le__(self, other)    小于等于
    # object.__eq__(self, other)    等于
    # object.__ne__(self, other)    不等于
    # object.__gt__(self, other)    大于
    # object.__ge__(self, other)    大于等于
    def __gt__(self, other):
        return self.age > other.age

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

	# del是一个特殊方法，它会在对象被垃圾回收前调用

    def __del__(self):
        print('Person()对象被删除了~',self)


p1 = Person('孙悟空', 20)
p2 = Person('孙悟空', 15)
print(p1.name)
p1.say_hello()
print(p1)
print(repr(p1))
print(p1 > p2)
print(p2 > p1)

p = Person('孙悟空', 20)
p = None   # 将a设置为None,此时没有任何变量要引用，它就变成垃圾
input('回车键退出...')

3.封装

封装指的是隐藏对象中一些不希望被外部所访问的属性或对象。

如何隐藏一个对象中的属性？

将对象的属性名，修改为一个外部不知道的名字
如何获取（修改）对象中的属性？
需要提供一个getter和setter方法使外部可以访问到属性
getter获取对象中的指定属性（get_属性名）
setter设置对象中的指定属性（set_属性名）
使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全性。

python 复制代码

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

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name


p = Person('mimi')
# print(p.__name)   # __开头的属性是隐藏属性，无法通过对象访问
# print(p._Person__name)     # 这样也可以访问到
print(p.get_name())

python 复制代码

# 使用__开头的属性，实际上依然可以在外部访问，一般不用
# 一般我们会将一些私有属性以_开头,告诉别人不希望修改
class person:
    def __init__(self, name):
        self._name = name

    def get_name(self):
        return self._name

    def set_name(self, name):
        self._name = name
p = person('mimi')
print(p._name)

property装饰器

property装饰器，用来将一个get方法，转换为对象的属性。

python 复制代码

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

    # property装饰器，用来将一个get方法，转换为对象的属性
    # 添加为property装饰器以后，我们就可以像调用属性一样使用get方法
    @property
    def name(self):
        print('get方法执行了~')
        return self._name

    # setter方法的装饰器：@属性名.setter
    @name.setter
    def name(self, name):
        self._name = name

p = Person('nunu')
p.name = '孙悟空'
print(p.name)

4.继承

通过继承我们可以使一个类获取到其他类中的属性和方法。

python 复制代码

class Animal:
    def run(self):
        print('动物会跑~')

    def sleep(self):
        print('动物睡觉~')


# 通过继承我们可以使一个类获取到其他类中的属性和方法
class Dog(Animal):
    def bark(self):
        print('汪汪汪~')

    def run(self):
        print('狗跑~')

d = Dog()
d.bark()

r = isinstance(d, Dog)
print(r)

python 复制代码

# 调用方法时，
#     会优先去当前对象中寻找，如果有则直接调用，
#     如果没有，则去父类中寻找，即就近原则
class A(object):
    def test(self):
        print('AAA')

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

class C(B):
    def test(self):
        print('ccc')

c = C()
c.test()

super()可以用来获取当前的父类

python 复制代码

super().__init__(name)

多重继承

多重继承，就是我们可以为一个类同时指定多个父类

5.多态

多态：一个对象可以以不同的形态去呈现。

python 复制代码

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

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name


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

    def __len__(self):
        return 10

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

a = A('孙悟空')
b = B('租八戒')

def say_hello(obj):
    print('你好%s'%obj.name)

say_hello(a)
say_hello(b)

面向对象三大特征：
封装：确保对象中的数据安全
继承：保证了对象的可扩展性
多态：保证了程序的灵活性

6.属性和方法

1.类属性

类属性，直接在类中定义的属性是类属性

类属性可以通过类或类对象的实例访问到

但是类属性只能通过类对象来修改，无法通过实例对象修改

2.实例属性

实例属性，通过实例对象添加的属性属于实例属性

3.类方法

在类内部使用@classmethod 来修饰的方法属于类方法。

4.实例方法

在类中定义，以self为第一个参数的方法都是实例方法。
类方法和实例方法区别：实例方法的第一个参数是self,而类方法的第一个参数是cls 。

5.静态方法

在类中使用@staticmethod来修饰的方法属于静态方法。

静态方法不需要指定任何的默认参数，静态方法可以通过类和实例去调用。

python 复制代码

class A(object):
    # 类属性
    count = 0
    def __init__(self):
        # 实例属性
        self.name = '孙悟空'

    # 实例方法
    def test(self):
        print('test方法~~~', self)

    # 类方法
    @classmethod
    def test_2(cls):
        print('test_2方法，它是一个类方法', cls)
        print(cls.count)

    # 静态方法
    @staticmethod
    def test_3():
        print('test_3执行了~')

a = A()
# 实例属性，通过实例对象添加的属性属于实例属性
# a.count = 10
A.count = 100
print(a.count)
print(A.count)
#     实例属性只能通过实例对象来访问和修改，类对象无法访问修改
# print(a.name)
# print(A.name)   # 报错
A.test_2()

A.test_3()
a.test_3()

最近在找工作，希望能尽快找到自己满意的工作。也希望每个看我文章的人有好的未来。加油！加油！加油！！！