傻瓜式学Python3——面向对象

来自网络.jpg

写在前面

最近心情有些焦虑，说不出的糟糕，但是我不想每天带着负能量生活，，毕竟还有更重要的事情要去做。只有让自己忙碌起来，希望忙碌的生活，可以忘记一些烦恼吧

面向对象简析

之前的文章提到过，接触过java的人，学习 python 的门槛会极低，因为 java 是一门彻底的面向对象编程语言，在 java 中有句经典的话叫做 万物皆对象，也就是在 oop(面向对象编程) 中，一切事物都可以称之为对象，对象是 类 实例化之后的一块内存空间，一切事物都可以使用 类 来描述，封装了一类事物共有的属性，以及这类事物所能做的事情，即方法。只要实例化类的实例，拿到对象。就能操作对象中存储的属性，以及调用它对应的方法。。。而恰巧，python 的核心编程思想也是 面向对象的，这对于 java 程序员无疑是天大的好事。

例如：可以把人封装为一个类(class)，人 具有 姓名，年龄，家庭住址等属性，具备吃饭，睡觉等一系列动作，即方法。当然了，类的划分都是相对的，也可以再细粒度的分类，人也属于动物，也可以再封装一层。。。

下面开始进入 python3 面向对象的傻瓜式学习之旅，滴滴滴~马上开车。。。

开车.png

python3 类的基本定义

class Cat():
    """模拟小猫的类"""

    def __init__(self,name,age):
        """初始化属性name和age"""
        self.name = name
        self.age = age

    def eat(self):
        """小猫会吃饭"""
        print(self.name.title() + ' is now eating.')

    def sleep(self):
        """小猫会睡觉"""
        print(self.name.title() + ' is now sleeping.')

分析：

• 使用格式 calss+类名():定义类，缩进的代码块为类的所有内容

• 其中的方法__init__(self,name,age) 是固定写法，相当于 java 中的构造方法，用于实例化 类实例，传入的参数 self 类似于 java 中的 this 指针，即当前类的实例，可以在类中调用任何属性与方法，必须放在参数第一位。剩下的即为类的属性，可以有任意多个，一般在__init__(self,name,age)中将形参赋值给当前对象的属性，用来初始化类的实例。

• 剩下的 eat()，sleep(self) 为类的方法，只要实例化类实例，即可随意调用，当然在类中也可以直接用 self 指针直接调用。

创建类实例

类定义好了，可以直接实例化实例，从而访问类属性，以及方法。格式：类名(xxx，yyy，zzz....) 根据_init_()方法的属性个数，传入对应多个参数值。

my_cat = Cat('willie',6)#实例化类实例，存储在my_cat变量中

注意：实例化过程就是在内存中开辟一块内存空间地址

使用类实例访问类成员属性及方法

一旦类被实例化之后，对象中就存储着类对应的属性值，从而可以直接访问。

print(my_cat)#打印类实例
print(my_cat.name)#访问name属性
print(my_cat.age)#访问age属性
my_cat.eat()#调用eat方法
my_cat.sleep()#调用sleep方法

结果：

<__main__.Cat object at 0x000000000112EEF0>
willie
6
Willie is now eating.
Willie is now sleeping.

从结果中可以看出，Cat('willie',6) 对象实例确实是在内存空间中开辟了一块地址。

给类属性设置默认值

类的全局属性一般是在_init_() 方法中初始化的，当初始化类实例时，python 会帮我们调用_init_()方法，并生成具备属性值的实例。理论上，我们可以在_init_()方法中对全局属性做一些操作，比如初始化默认值，属性值递增，甚至可以调用一些初始化别的类实例的方法等等。

  def __init__(self,name,age):
        """构造方法,初始化属性name和age"""
        self.name = name
        self.age = age
        self.color = 'blue'#颜色默认值

my_cat = Cat('willie',6)#实例化类实例，存储在my_cat变量中
print(my_cat.color)#结果为 blue

动态修改对象属性值

• 直接访问属性赋值

my_cat.color = 'red'
print(my_cat.color)#结果为 red

• 封裝方法進行動態調用賦值，这种方法其实就类比 java 中的 set 方法。

my_cat.setColor('black')
print(my_cat.color)#结果为 black

继承，面相对象三大特性之一

前面说到，类实可以用来描述一类事物的，而为了达到代码的复用性，面相对象提供了继承的概念，即可以通过继承的方式获取已存在类的属性及方法。被继承方称为父类，继承方称为子类。
定义 Car 父类：

class Car():
    """汽车类"""

    def __init__(self,make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descriptive_name(self):
        long_name = str(self.year) + ' ' + self.make + ' ' +self.model
        return long_name.title()

    def read_odometer(self):
        print('This car has ' + str(self.odometer_reading) + ' miles on it.')

    def updata_odometer(self,mileage):
        """动态处理属性值"""
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print('You can\'t  roll back an odometer!')

    def increment_odometer(self,miles):
        """属性值递增"""
        self.odometer_reading += miles

子类：

class ElectricCar(Car):
    """电动汽车"""

    def __init__(self,make,model,year):
        """初始化父类属性"""
        super().__init__(make,model,year)

my_tesla = ElectricCar('tesla','model s',2017)
print(my_tesla.get_descriptive_name())

结果：2017 Tesla Model S
简析：ElectricCar 累拥有 Car 类的所有属性及方法，在_init_() 中调用父类 _init_方法初始化父类属性，其中super为父类对象，可以使用它访问父类的方法及属性。

定义子类独有的属性及方法

一类事物公有的属性及方法可以封装在父类，以达到复用的效果。除了可以从父类继承公有属性及方法之外，子类还可以定义自己独有的属性及方法。

 def __init__(self,make,model,year):
        """初始化父类属性"""
        super().__init__(make,model,year)
        self.battery_size = 70
        
    def describe_battery(self):
        """子类特有的方法"""
        print('This car has a' + str(self.battery_size) + '-kwh battery.')
my_tesla = ElectricCar('tesla','model s',2017)
print(my_tesla.describe_battery())

结果：This car has a 70-kwh battery.

重写父类的方法

有时候父类定义的方法往往不符合子类现有的需求，可以对它进行重写，执行子类特有的逻辑。注意：只要重写了父类的方法，此时调用方法以子类实现为主

 def get_descriptive_name(self):
        print('重写了父类的方法')
print(my_tesla.get_descriptive_name())

结果肯定是打印 重写了父类的方法

导入类

oop 编程中，每个类都有自己特有的功能，当整个项目也来越复杂的时候，就需要每个类之间相互依赖，正常情况下，都是一个 python 文件存储一个类，当需要依赖别的类时，需要导入。使用格式 from 文件名 import 类名......，当然了 也可以一个文件存储多个类。
例如：在 car.py 中添加 Car 类

class Car():
    """汽车类"""

    def __init__(self,make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descriptive_name(self):
        long_name = str(self.year) + ' ' + self.make + ' ' +self.model
        return long_name.title()

    def read_odometer(self):
        print('This car has ' + str(self.odometer_reading) + ' miles on it.')

    def updata_odometer(self,mileage):
        """动态处理属性值"""
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print('You can\'t  roll back an odometer!')

    def increment_odometer(self,miles):
        """属性值递增"""
        self.odometer_reading += miles

在 electricCar.py 中添加 ElectricCar 类继承自 Car ,

from car import Car


class ElectricCar(Car):
    """电动汽车"""

    def __init__(self,make,model,year):
        """初始化父类属性"""
        super().__init__(make,model,year)
        self.battery_size = 70

    def describe_battery(self):
        """子类特有的方法"""
        print('This car has a ' + str(self.battery_size) + '-kwh battery.')

    def get_descriptive_name(self):
        print('重写了父类的方法')

现在，python 面向对象部分就粗糙的整理好了，然而这趟车还没到达终点，小司机仍需加油开车。。

最后记录今天看到的一句深刻的话:

如果一个人出海遇到狂风暴雨，被变换肆虐的风吹得团团转，你可能会觉得他航行了很远。其实航行得并不远，只是浮沉动荡的时间长而已。

更多原创文章会在公众号第一时间推送,欢迎扫码关注 张少林同学

张少林同学.jpg