投稿
  1. 首页
  2. python

Python基础学习第六天

code • 2022-4-25 • python • 阅读 29

Python基础学习第六天,第1张

面向对象基础
  • 1. 面向对象
  • 2.类与对象
    • 2.1 概念
    • 2.2 类和对象的关系
    • 2.3 类的设计
      • 类名的确定
    • 2.3 面向对象基础语法
  • 2.定义简单类
    • 2.1 **定义只包含方法的类**
    • 2.2 引用概念的强调
  • 3. 初始化方法
    • 3.1初始化方法
  • 4.私有属性和方法
    • 4.1 定义方式
    • 4.2 伪私有属性和私有方法
  • 5.单继承
    • 5.1 继承的概念、语法和特点
      • 5.1.1继承的概念
      • 5.1.2继承的语法
      • 5.1.3 **继承的传递性**
  • 6.重写
    • 6.1 方法的重写
    • 6.2覆盖父类的方法：

1. 面向对象

面向对象编程 —— Object Oriented Programming
我们之前学习的编程方式就是 面向过程 的，面向过程 和 面向对象，是两种不同的 编程方式
过程 是早期的一个编程概念
过程 类似于函数，只能执行，但是没有返回值
函数 不仅能执行，还可以返回结果

面向过程 和 面向对象 基本概念
面向过程 —— 怎么做

  • 把完成某一个需求的 所有步骤 从头到尾 逐步实现
  • 根据开发需求，将某些 功能独立 的代码 封装 成一个又一个 函数
  • 最后完成的代码，就顺序地调用不同的函数
    特点
    • 注重 步骤与过程，不注重职责分工
    • 如果需求复杂，代码会变得很复杂
    • 开发复杂项目，没有固定的套路，开发难度很大

      相比较函数，面向对象 是 更大 的 封装，根据 职责 在 一个对象中 封装 多个方法
      面向对象 —— 谁来做
    • 在完成某一个需求前，首先 确定职责一一要做的事情(方法)
    • 根据 职责 确定不同的 对象，在 对象 内部封装不同的方法(多个)
    • 最后完成的代码，就顺序地让 不同的对象 调用 不同的方法
      特点
    • 注重 对象和职责，不同的对象承担不同的职责
    • 更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路
    • 需要在面向过程基础上，再学习一些面向对象的语法
2.类与对象 2.1 概念

类 和 对象 是 面向对象编程的 两个 核心概念
类 是对一群具有 相同 特征 或者 行为 的事物的一个 统称，是抽象的，不能直接使用

  • 特征 被称为 属性
  • 行为 被称为 方法

对象 是 由类创建出来的一个具体存在，可以直接使用
由 哪一个类 创建出来的 对象 ，就拥有在 哪一个类 中定义的：

  • 属性
  • 方法
    在程序开发中，应该 先有类，再有对象
2.2 类和对象的关系
  • 类是模板，对象 是根据 类 这个模板创建出来的，应该 先有类，再有对象
  • 类 只有一个，而 对象 可以有很多个，不同的对象 之间 属性 可能会各不相同
  • 类 中定义了什么 属性和方法，对象 中就有什么属性和方法，不可能多，也不可能少
2.3 类的设计

在程序开发中，要设计一个类，通常需要满足三个要素：
1.类名 这类事物的名字，满足大驼峰命名法， 类名首字母大写
2.属性 这类事物具有什么样的特征
3.方法 这类事物具有什么样的行为

类名的确定

名词提炼法 分析整个业务流程。
出现的 名词，通常就是找到的类

大驼峰命名法 CapWords
1.每一个单词的首字母大写
2.单词与单词之间 没有 下划线

属性和方法的确定
对 对象的特征描述，通常可以定义成 属性
对象具有的行为（动词），通常可以定义成 方法

提示：需求中没有涉及的属性或者方法在设计类时，不需要考虑

练习
小明 今年 18岁，身高1.75，每天早上 跑 完步，会去 吃 东西
小美 今年 17岁，身高1.65，小美不跑步，小美喜欢 吃 东西

练习
一只 黄颜色 的 狗狗 叫 小黑
看见生人 汪汪叫
看见家人 摇尾巴

2.3 面向对象基础语法

dir 内置函数
在 python 中 对象几乎是无所不在的，我们之前学习的 变量，数据，函数 都是对象
在 Python 中可以使用一下两个方法验证：
在 标识符/数据 后输入一个 . ，PyCharm 会提示该对象能够调用的 方法列表
使用内置函数 dir 传入 标识符/数据， 可以查看对象内的 所有属性方法
提示 ：方法名 格式的方法是 Python 提供的 内置方法/属性

2.定义简单类

面向对象 是 更大 的 封装, 在 一个类中 封装 多个方法, 这样 通过这个类创建出来的对
象,就可以直接调用这些方法了！

2.1 定义只包含方法的类

在 python 中定义一个只包含方法的类，语法格式如下：

方法 的定义格式和之前学习过的函数几乎一样
区别在于第一个参数必须是self
注意: 类名的命名规则要符合 大驼峰命名法

(1)创建对象
当一个类定义完成之后，要使用这个类来创建对象，语法格式如下：

对象变量 = 类名()

示例：
小猫 爱 吃 鱼，小猫 要 喝 水
分析
定义一个 猫 类 Cat
定义两个方法 eat 和 drink
按照需求——不需要定义属性

class Cat:
    """这是一个猫类"""
    def eat(self):
        print("小猫爱吃鱼")
    def drink(self):
        print("小猫在喝水")
# 创建 猫 对象
tom = Cat()
tom.eat()
tom.drink()
print(tom)
2.2 引用概念的强调

面向对象开发中,引用 / 地址 的概念是同样适用的
- 在 Python中使用类创建对象之后,tom 变量 中仍然记录的是 对象在内存中的地址
- 也就是 tom 变量 引用 了 新建的猫对象
- 使用 print 输出 对象变量,默认情况下,是能够输出这个变量 引用的对象 是 由哪一个类创建的对象,以及在内存中的地址(十六进制表示)

提示:在计算机中,通常使用 十六进制 表示 内存地址

  • 十进制 和 十六进制 都是用来表达数字的,只是表示的方式不一样
  • 十进制 和 十六进制 的数字之间可以来回转换
  • %d可以以 10进制输出数字
  • %x可以以 16进制 输出数字
  • %o
  • %b

案例改造—— 给对象增加属性
在 Python中,要 给对象设置属性,非常的容易,但是不推荐使用
因为:对象属性的封装应该封装在类的内部
只需要在 类的外部的代码 中直接通过 . 设置一个属性即可
注意 : 这种方式虽然简单,但是不推荐使用！

tom.name = “Tom”
Lazy_cat.name = “大懒猫”

使用self在方法内部输出每一只猫的名字
由 哪一个对象 调用的方法,方法内的 self 就是 哪一个对象的引用

  • 在类封装的方法内部,self 就表示 当前调用方法的对象自己
  • 调用方法时,程序员不需要传递self参数
  • 在方法内部；可以通过self访问对象的属性；也可以通过self调用其他的对象方法
    改造代码如下:
class Cat:
    """这是一个猫类"""
    def eat(self):
        print("%s爱吃鱼" % self.name)
# 创建 猫 对象
tom = Cat()
tom.name = "汤姆"
tom.eat()
3. 初始化方法

之前代码存在的问题——在类的外部给对象增加属性
将案例代码进行调整,先调用方法再设置属性,观察一下执行效果

tom = Cat()
tom.drink()
tom.eat()
tom.name = "Tom"
print(tom)

程序报错如下;

![在这里插入图片描述](http://www.kaotop.com/file/tupian/20220421/7bd8dc20b48e4880a2d29f5317197799.png
提示
在日常开发中,不推荐在 类的外部 给对象增加属性；如果在运行时,没有找到属性,程序会报错
对象应该包含有哪些属性,应该 封装在类的内部

3.1初始化方法

当使用 类名( ) 创建对象时,会 自动 执行以下 *** 作
1.为对象在内存中分配空间一一创建对象
2.为对象的属性设置初始值一一初始化方法(init)

这个 初始化方法 就是__init__方法, __init__是对象的内置方法

__init__方法是 专门 用来定义ー个类 具有 哪些属性的方法！

在 Cat 中增加 init 方法，验证该方法在创建对象时会被自动调用

class Cat:
    """这是一个猫类"""
    def __init__(self):
        print("初始化方法")
tom = Cat()

在初始化方法内部定义属性

  • 在__init__方法内部使用 self.属性名=属性的初始值 就可以 定义属性
  • 定义属性之后,再使用 Cat类创建的对象,都会拥有该属性
class Cat:
    """这是一个猫类"""
    def __init__(self):
        print("初始化方法")
        # 定义用 Cat 类创建的猫对象都有一个 name 的属性
        self.name = "Tom"
    def eat(self):
        print("%s爱吃鱼" % self.name)
# 使用 类名() 创建对象的时候,会自动调用初始化方法 __init__
tom = Cat()
tom.eat()

改造初始化方法ー一初始化的同时设置初始值
在开发中,如果希望在 创建对象的同时,就设置对象的属性,可以对__init__方法进行改造

  1. 把希望设置的属性值,定义成__init__方法的参数
  2. 在方法内部使用 self.属性 = 形参 接收外部传递的参数
  3. 在创建对象时,使用类名(属性1,属性2,)调用
class Cat:
    """这是一个猫类"""
    def __init__(self):
        print("初始化方法")
        # 定义用 Cat 类创建的猫对象都有一个 name 的属性
        self.name = new_name
    def eat(self):
        print("%s爱吃鱼" % self.name)
# 使用 类名() 创建对象的时候,会自动调用初始化方法 __init__
tom = Cat("汤姆")
tom.eat()
4.私有属性和方法
  • 在实际开发中，对象 的 某些属性或方法 可能只希望 在对象的内部被使用，而 不希望在外部被访问到
  • 私有属性 就是 对象 不希望公开的 属性
  • 私有方法 就是 对象 不希望公开的 方法
4.1 定义方式

在 定义属性或方法时，在 属性名或者方法名前 增加 两个下划线，定义的就是 私有 属性或方法

设置私有属性之前：

class Girl:
    def __init__(self, name):
        self.name = name
        self.age = 18
    def secret(self):
        print("{}的年龄是{}岁".format(self.name, self.age))
Anna = Girl("小美")
Anna.secret()
print("小美")
print(Anna.age)  # 可以从外部访问属性

私有属性在外界不能被直接访问：

class Girl:
    def __init__(self, name):
        self.name = name
        self.__age = 18  # 将 age 设置成私有属性
    def secret(self):
        print("{}的年龄是{}岁".format(self.name, self.__age))
Anna = Girl("小美")
Anna.secret()
print(Anna)
# 私有属性，不能被外界访问！
print(Anna.__age) 
"""
程序运行结果：
	AttributeError: 'Girl' object has no attribute '__age'
"""

私有方法,在外界不能直接被调用:

class Girl:
    def __init__(self, name):
        self.name = name
        self.__age = 18  # 将 age 设置成私有属性
    def __secret(self):  # 将 secret 设置成私有方法
        print("{}的年龄是{}岁".format(self.name, self.__age))
Anna = Girl("小美")
# 私有方法，在外界不能直接被调用
Anna.__secret()
print(Anna)

"""
程序运行结果：
	AttributeError: 'Girl' object has no attribute '__secret'
"""
4.2 伪私有属性和私有方法

在给 属性、方法 命名时，实际是对 名称 做了一些特殊处理，使得外界无法访问
处理方式： 在 名称 前面加上 _类名 --> _类名 __名称
Python 中，并没有 真正意义 的 私有
提示：在日常开发中，不要使用这种方式，访问对象的 私有属性 或 私有方法

Anna = Girl("小美")
Anna._Girl__secret()
print(Anna._Girl__age)
print(Anna)
5.单继承

面向对象三大特性
1.封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中
2.继承 实现代码的重用，相同的代码不需要重复的编写
3.多态 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

5.1 继承的概念、语法和特点 5.1.1继承的概念

子类 拥有 父类 的所有 方法 和 属性

class Animal:
    def eat(self):
        print("吃")
    def drink(self):
        print("喝")
    def run(self):
        print("跑")
    def sleep(self):
        print("睡")
class Dog():
    def eat(self):
        print("吃")
    def drink(self):
        print("喝")
    def run(self):
        print("跑")
    def sleep(self):
        print("睡")
    def bark(self):
        print("汪汪汪")
wangcai = Dog()
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.bark()
5.1.2继承的语法

class 子类名(父类名)：
pass

子类 继承自 父类，可以直接 享受 父类中已经封装好的方法,不需要再次开发
子类 中应该根据 职责，封装 子类特有的 属性 和 方法

使用继承开发动物和狗
class Dog(Animal):
    def bark(self):
        print("汪汪汪")
wangcai = Dog()
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.bark()
class Animal:
    def eat(self):
        print("吃")
    def drink(self):
        print("喝")
    def run(self):
        print("跑")
    def sleep(self):
        print("睡")

专业术语
Dog 类 是 Animal 类的 子类，Animal 类是 Dog 类的 父类，Dog 类从Animal 类 继承
Dog 类 是 Animal 类的 派生类，Animal 类是 Dog 类的 基类，Dog 类从Animal 类 派生

5.1.3 继承的传递性

C 类从 B 类继承，B类又从 A 类继承
那么 C 类就具有 B 类和 A 类的所有属性和方法
子类 拥有 父类 以及 父类的父类 中封装的所有 属性 和 方法

继承的传递性
class Animal:
    def eat(self):
        print("吃")
    def drink(self):
        print("喝")
    def run(self):
        print("跑")
    def sleep(self):
        print("睡")
class Dog(Animal):
    def bark(self):
        print("汪汪汪")
class XiaoTianDog(Dog):
    def fly(self):
        print("我竟然会飞~")
xiaotian = XiaoTianDog()
xiaotian.eat()
xiaotian.drink()
xiaotian.run()
xiaotian.sleep()
xiaotian.bark()
xiaotian.fly()
6.重写 6.1 方法的重写

子类 拥有 父类 的所有 方法 和 属性
子类 继承自 父类，可以直接享受父类中已经封装好的方法，不需要再次开发
当 父类 的方法实现不能满足子类需求时，可以对方法进行 重写(override)

重写 父类方法有两种情况
覆盖 父类的方法
对父类方法进行 扩展

class Animal:
    def eat(self):
        print("吃")
    def drink(self):
        print("喝")
    def run(self):
        print("跑")
    def sleep(self):
        print("睡")
class Dog(Animal):
    def bark(self):
        print("汪汪汪")
xiaotian = XiaoTianDog()
xiaotian.eat()
xiaotian.drink()
xiaotian.run()
xiaotian.sleep()
xiaotian.bark()
xiaotian.fly()
class XiaoTianDog(Dog):
    def fly(self):
        print("我竟然会飞~")
    def bark(self):
        print("我不是普通狗，我会好几门外语")
6.2覆盖父类的方法：

如果在开发中，父类的方法实现和子类的方法实现 完全不同
就可以使用 覆盖 的方式，在子类中 重新编写 父类的方法实现
具体的实现方式，就相当于在 子类中 定义了一个 和父类相同名的方法并且实现
重写之后，在运行时，只会调用 子类中重写的方法，而不再会调用 父类封装的方法

对父类方法进行扩展

  • 如果在开发中，子类的方法实现 中 包含 父类的方法实现
    • 父类原本封装的方法实现 是 子类方法的一部分
  • 就可以使用 扩展 的方式
    • 在子类中重写 父类的方法
    • 在需要的位置使用 **super( ).**父类方法 来调用父类方法的执行
    • 代码其他的位置针对子类的需求，编写
      子类特有的代码实现
  • 关于 super
    • 在 python 中 super 是一个 特殊的类
    • super( )就是使用 super 类创建出来的对象
    • 最常使用的场景就是在 重写父类的方法时，调用 在父类中封装的方法实现

对父类方法进行 扩展

def bark(self):
    # 1.针对子类特有的需求，编写代码
        print("我不是普通狗，我会好几门外语")
    # 2.使用 super(). 调用原本在父类中的方法
        super().bark()
    # 3.增加其他子类的代码
        print("@#$@#$@#$@#$")

调用父类方法的另外一种方式（拓展）
在 python 2.x时，如果需要调用父类的方法，还可以使用以下方式

- 父类名.方法(self)
  • 这种方式，目前在 python 3.x 还支持这种方式
  • 这种方法不推荐使用，因为 一旦 父类发生变化，方法调用位置的 类名 同样需要修改
    提示：
    • 在开发时，父类名 和 super( ) 两种方式不要混用，建议使用 super( ) 方式
    • 如果使用 当前子类名 调用方法，会形成递归调用，出现死循环

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/715147.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-04-25
下一篇 2022-04-25

发表评论

登录后才能评论

评论列表（0条）

保存