8.1Python面向对象编程（一）

目录

目录

• 目录
• 前言
• （一）基本概念
  • 1.面向过程与面向对象
    • （1）面向过程
    • （2）面向对象
    • （3）面向过程与面向对象的关系
      • 共同点：
      • 不同点：
  • 2.类与对象
    • （1）类的概念
    • （2）对象的概念
    • （3）类与对象的关系
• （二）类属性的相关操作
  • 1.定义一个经典类
    • （1）说明：
    • （2）源代码：
    • （3）输出效果：
  • 2.对象属性的操作
    • （1）说明：
    • （2）源代码：
    • （3）输出效果：
  • 3.类属性的操作
    • （1）说明：
    • （2）源代码：
    • （3）输出效果：
  • 4.限制对象属性
    • （1）说明：
    • （2）源代码：
    • （3）输出效果：
• （三）类方法的相关操作
  • 1.类方法的分类
    • （1）说明：
    • （2）源代码：
    • （3）输出效果：
  • 2.不同类方法的使用不同属性
    • （1）说明：
    • （2）源代码：
    • （3）输出效果：
    • 作者：Mark
    • 日期：2019/02/12 周二

前言

在此之前，我们以前写的编程，都是面向过程的编程，今儿起，我们开始学习一类编程的思想，也是相对面向过程更高级的思想，面向对象编程。

（一）基本概念

1.面向过程与面向对象

（1）面向过程

侧重任务的规划，关心每一个步骤，并且自己一一实现。

相当于施工者。

（2）面向对象

侧重的是谁能做，然后派人去做，而不是自己去做，自己作为宏观调控，管理者。

相当于包工头。

（3）面向过程与面向对象的关系

共同点：

都是解决问题的一种思路，办法。

不同点：

面向对象其实就面向过程的一个封装，面向对象里面具体实施，也是要到面向过程来实现的。

2.类与对象

（1）类的概念

类是由事物抽象出来的一个模板，这个模板可以创建其他的对象。

像人类也是一个类，小猫小狗是动物类。

python是一门彻底的编程语言，在python一切都是对象。

类下面有两个特征名称：

1. 属性：静态的特征值
2. 方法：动态的行为

（2）对象的概念

对象是指具体的事物，万物皆对象。

像张三这个人，是具体一个人，就是一个对象。

（3）类与对象的关系

类是由某一对象抽象出来的模板，对象又是类创建出来的。类起到模板的作用，对象才是具体的事物。

类创建对象的过程就是实例化。

（二）类属性的相关操作

1.定义一个经典类

（1）说明：

在python里实现类的定义语法是：

class 类名：

​ 属性

​ 方法

（2）源代码：

# 定义一个经典类
class Money:
    pass

# 实例化（创建）一个对象，命名规范是：类的首个大小字母是大小。
one = Money()
print("类是：", Money)
print("对象是：", one)

# 类的一些共有属组
print("类的名称是", Money.__name__)

# 类名可以是变量
xxx = Money
Money = 666
print(xxx)
print(Money)

# 对象的共有属性
print(one.__class__)

（3）输出效果：

2.对象属性的操作

（1）说明：

对象.变量名 相对于 一个变量。可以通过对象.变量名来访问。

（2）源代码：

# 1.定义一个经典类
class Person:
    pass

# 2.实例化（创建）一个对象
one = Person()

# 3.给对象增加属性
one.age = 18
one.height = 180
print(one.age, id(one.age))

# 3.1返回对象的所有属性
print(one.__dict__)

# 4.修改对象的属性，其实就是把:one.age当作一个变量来处理就可以了。
one.age = 20
print(one.age, id(one.age))

# 5.删除对象的属性
del one.age
print(one.age)

（3）输出效果：

3.类属性的操作

（1）说明：

class Person:

# 直接定义变量，就是类的属性

age = 21

height = 175

（2）源代码：

# 1.类也是一个对象，基类的对象
class Person:
    # 直接定义变量，就是类的属性
    age = 21
    height = 175

# 2.实例化（创建）一个对象
one = Person()
print(one.age)
print(one.height)

# 3.查看类与实例的属性
print(Person.__dict__)
print(one.__dict__)

（3）输出效果：

4.限制对象属性

（1）说明：

有时候，我们定义的类，不希望这个类创建的对象来随意的添加属性，我们可以添加限制

用：slots = [ ]

（2）源代码：

class Person:
    # 允许对象添加的属性
    __slots__ = ["age"]

p1 = Person()
p1.age = 18
# 添加非法属性
p1.height = 178
print(p1.age)
print(p1.height)

（3）输出效果：

（三）类方法的相关操作

1.类方法的分类

（1）说明：

类方法分为三类，其主要的区分是第一个参数的含义，和特定的装饰器来区分。

1. 实例方法：第一个参数是self,无装饰器。
2. 类方法：第一个参数是：cls,使用：@classmethod 装饰器
3. 静态方法：无第一个参数，使用：@staticmethod 装饰器

（2）源代码：

"""
    方法的分类：三种方法
"""

class Person:
    # 定义一个是实例方法：
    def object_fun(self):
        print("我还一个实例方法", self)

    # 定义一个类方法
    @classmethod
    def class_fun(cls):
        print("我是一个类方法", cls)

    # 定义一个静态方法
    @staticmethod
    def static_fun():
        print("我是一个静态方法")

one = Person()
# 调用方法
one.object_fun()
one.class_fun()
one.static_fun()

print(Person.__dict__)

（3）输出效果：

2.不同类方法的使用不同属性

（1）说明：

1. 实例方法：可以访问类属性和实例属性
2. 类方法：只能访问类属性
3. 静态方法：不能访问实例属性与类属性

（2）源代码：

# 定义一个类
class Person:
    # 类属性
    age = 18

    # 定义一个是实例方法：
    def object_fun(self):
        print(self.age)
        print(self.num)

    # 定义一个类方法
    @classmethod
    def class_fun(cls):
        print(cls.age)

    # 定义一个静态方法
    @staticmethod
    def static_fun():
        print("我是一个静态方法")
        print(Person.age)

# 实例化一个对象
one = Person()
# 实例属性
one.num = 10

# 实例方法可以访问类属性和实例属性
one.object_fun()

# 类方法只能访问类属性
one.class_fun()

# 静态方法不能访问实例属性与类属性
one.static_fun()

（3）输出效果：

作者：Mark

日期：2019/02/12 周二