其他Python知识参考：软件测试基础（七）—— Python

目录

一、基本的介绍

1、⾯向过程

2、⾯向对象

二、类和对象

1、类的组成

2、类的抽象(类的设计) 

3、⾯向对象基本代码的书写步骤

3.1、定义类

3.2、创建对象

3.3、调⽤⽅法

3.3、示例

3.4、self 的说明

4、对象的属性操作 

4.1、添加属性

4.2、获取属性

三、魔法⽅法

1、__init__ ⽅法 **

2、__str__ ⽅法 * 

3、__del__ ⽅法（了解）

4、__dir__

5、__dict__

四、封装 

1、私有和公有 

五、继承 

1、语法

2、重写

2.1、覆盖 

2.2、扩展父类中的功能

六、多态（了解）

七、属性和方法

1、对象的划分

1.1、实例对象(实例)

1.2、类对象(类)

2、属性的划分

2.1、实例属性

2.2、类属性

3、方法的划分

3.1、实例方法(最常用)

3.2、类方法

3.3、静态方法

八、哈希（hash）

其他Python知识参考：软件测试基础（七）—— Python

一、基本的介绍

⾯向对象是⼀个编程思想(写代码的套路) 编程思想:

1. ⾯向过程

2. ⾯向对象

以上两种都属于写代码的套路(⽅法) ,最终⽬的都是为了将代码 书写出来,只不过过程和思考⽅法不太⼀样.

1、⾯向过程

关注的是 具体步骤的实现, 所有的功能都⾃⼰书写

亲⼒亲为

定义⼀个个函数, 最终按照顺序调⽤函数 

2、⾯向对象

关注的是结果, 谁(对象) 能帮我做这件事

偷懒

找⼀个对象(), 让对象去做 

二、类和对象

⾯向对象的核⼼思想是 找⼀个对象去帮我们处理事情

在程序代码中 对象是由 类 创建的

类和对象,是 ⾯向对象编程思想中⾮常重要的两个概念

类

1. 抽象的概念, 对多个特征和⾏为相同或者相似事物的统称

2.泛指的(指代多个,⽽不是具体的⼀个)

对象

1.具体存在的⼀个事物, 看得⻅摸得着的

2.特指的,(指代⼀个)

1、类的组成

1, 类名 (给这多个事物起⼀个名字, 在代码中 满⾜⼤驼峰命名 法(每个单词的⾸字⺟⼤写))

2, 属性 (事物的特征, 即有什么, ⼀般⽂字中的名词)

3, ⽅法 (事物的⾏为, 即做什么事, ⼀般是动词) 

2、类的抽象(类的设计) 

类的抽象,其实就是找到 类的 类名, 属性 和⽅法 

需求：

1. 小明 今年20岁，身高1.85，每天早上 跑 完步，会去 吃 东西

2. 小美 今年18岁，身高1.66，每天早上 不跑步，小美喜欢 吃 东西

类名: ⼈类(Person, People)

属性: 名字(name), 年龄(age), 身⾼(height)

⽅法: 跑步(run) 吃(eat)

3、⾯向对象基本代码的书写步骤

1. 定义类, 在定义类之前先设计类

2. 创建对象, 使⽤第⼀步定义的类创建对象

3. 通过对象调⽤⽅法

3.1、定义类

先定义简单的类, 不包含属性, 在 python 中定义类需要使⽤ 关键字 class

⽅法: ⽅法的本质是在类中定义的函数, 只不过,第⼀个参数是 self

class 类名:
    # 在缩进中书写的内容,都是类中的代码 
    def ⽅法名(self): # 就是⼀个⽅法 
        pass

3.2、创建对象

创建对象是使⽤ 类名() 进⾏创建,即 

类名() # 创建⼀个对象, 这个对象在后续不能使⽤ 
# 创建的对象想要在后续的代码中继续使⽤, 需要使⽤⼀个变量, 将这个对象保存起来 
变量 = 类名() # 这个变量中保存的是对象的地址, ⼀般可以 成为这个变量为对象

# ⼀个类可以创建多个对象, 只要出现 类名() 就是创建⼀个对象,每个对象的地址是不⼀样的

3.3、调⽤⽅法

对象.⽅法名()

列表.sort() 
列表.append()

3.3、示例

需求:⼩猫爱吃⻥，⼩猫要喝⽔

类名: 猫类 Cat

属性: 暂⽆

⽅法: 吃⻥ (eat) 喝⽔ (drink ) 

""" 
需求:⼩猫爱吃⻥，⼩猫要喝⽔, 定义不带属性的类 
"""

class Cat:
    # 在缩进中书写 ⽅法
    def eat(self): # self 会⾃动出现,暂不管 
        print('⼩猫爱吃⻥...')

    def drink(self):
        print('⼩猫要喝⽔----')

# 2. 创建对象 
blue_cat = Cat() 
# 3. 通过对象调⽤类中的⽅法 
blue_cat.eat() 
blue_cat.drink()

# 创建对象 
black_cat = Cat() 
black_cat.eat() 
black_cat.drink()

3.4、self 的说明

1. 从函数的语法上讲, self是形参, 就可以是任意的变量名, 只不过我们习惯性将这个形参写作 self

2. self 是普通的形参, 但是在调⽤的时候没有传递实参值, 原因是, Python 解释器在执⾏代码的时候, ⾃动的将调⽤这个 ⽅法的对象 传递给了 self, 即 self 的本质是对象

3. 验证, 只需要确定 通过哪个对象调⽤, 对象的引⽤和 self 的引⽤是⼀样的

4. self 是函数中的局部变量, 直接创建的对象是全局变量

4、对象的属性操作 

4.1、添加属性

对象.属性名 = 属性值

1. 类内部添加

在内部⽅法中, self 是对象,

self.属性名 = 属性值

# 在类中添加属性⼀般写在 __init__ ⽅法中

2. 类外部添加

对象.属性名 = 属性值  # ⼀般不使⽤

4.2、获取属性

对象.属性名 

1. 类内部

在内部⽅法中, self 是对象,

self.属性名

2. 类外部

对象.属性名  # ⼀般很少使⽤

三、魔法⽅法

python 中有⼀类⽅法, 以两个下划线开头,两个下划线结尾,并且在满⾜某个条件的情况下, 会⾃动调⽤, 这类⽅法称为 魔法⽅法

学习:

1. 什么情况下⾃动调⽤

2. 有什么⽤, ⽤在哪

3. 书写的注意事项

1、__init__ ⽅法 **

1. 什么情况下⾃动调⽤

        创建对象之后会⾃动调⽤

2. 有什么⽤, ⽤在哪

        (1) 给对象添加属性的, (初始化⽅法, 构造⽅法)

        (2) 某些代码, 在每次创建对象之后, 都要执⾏,就可以将这⾏代码写在 __init__ ⽅法

3. 书写的注意事项

        (1) 不要写错了

        (2) 如果 init ⽅法中,存在出了 self 之外的参数, 在创建对象的时候必须传参

""" 
猫类, 属性 name, age , show_info(输出属性信息) 
"""

class Cat:
    # 定义添加属性的⽅法 
    def __init__(self, name, age): # 这个⽅法是创建对象之后调⽤ 
        self.name = name # 给对象添加 name 属性 
        self.age = age # 给对象添加 age 属性


    # 输出属性信息 
    def show_info(self):
        print(f'⼩猫的名字是: {self.name}, 年龄是: {self.age}')

# 创建对象,不要在⾃⼰类缩进中创建 
# Cat() 
# 创建对象 ,会输出 
blue_cat = Cat('蓝猫', 2)

blue = blue_cat 
blue.show_info()

# 创建⿊猫 
black_cat = Cat('⿊猫', 3) 
black_cat.show_info()

2、__str__ ⽅法 * 

1. 什么情况下⾃动调⽤

        使⽤ print(对象) 打印对象的时候 会⾃动调⽤

2. 有什么⽤, ⽤在哪

        (1) 在这个⽅法中⼀般书写对象的属性信息的, 即打印对象的时候想要查看什么信息,在这个⽅法中进⾏定义的

        (2) 如果类中没有定义 __str__ ⽅法, print(对象) ,默认 输出对象的引⽤地址

3. 书写的注意事项

        这个⽅法必须返回 ⼀个字符串

class Cat:
    # 定义添加属性的⽅法 
    def __init__(self, name, age): # 这个⽅法是创建对象之后调⽤ 
        self.name = name # 给对象添加 name 属性 
        self.age = age # 给对象添加 age 属性

    def __str__(self):
        # ⽅法必须返回⼀个字符串, 只要是字符串就⾏, 
        return f'⼩猫的名字是: {self.name}, 年龄是: {self.age}'


# 创建对象,不要在⾃⼰类缩进中创建 
# Cat() 
# 创建对象 ,会输出 
blue_cat = Cat('蓝猫', 2)

blue = blue_cat 
print(blue_cat)

# 创建⿊猫 
black_cat = Cat('⿊猫', 3) 
print(black_cat)

3、__del__ ⽅法（了解）

__init__ ⽅法, 创建对象之后,会⾃动调⽤ (构造⽅法)

__del__ ⽅法, 对象被删除销毁时, ⾃动调⽤的(遗⾔, 处理后 事) (析构⽅法)

1. 调⽤场景, 程序代码运⾏结束, 所有对象都被销毁

2. 调⽤场景, 直接使⽤ del 删除对象(如果对象有多个名字(多 个对象引⽤⼀个对象),需要吧所有的对象都删除才⾏ )

class Demo:
    def __init__(self, name):
        print('我是 __init__, 我被调⽤了 ') 
        self.name = name

    def __del__(self):
        print(f'{self.name} 没了, 给他处理后事...')

# Demo('a')
a = Demo('a')

b = Demo('b')
del a # 删除销毁 对象, 
print('代码运⾏结束')

4、__dir__

1. 获取对象所有属性（包含方法）组成的列表
  对象.__dir__()
2. 获取对象所有属性（包含方法）组成的列表，已排序
  dir(对象) 

5、__dict__

对象.__dict__

魔法属性, 可以将对象具有的属性组成字典返回

四、封装 

1、私有和公有 

1. 在 Python 中定义的方法和属性, 可以添加访问控制权限(即在什么地方可以使用这个属性和方法)

2. 访问控制权限分为两种, 公有权限, 私有权限

3. 公有权限

        > 直接书写的方法和属性, 都是公有的

        > 公有的方法和属性, 可以在任意地方访问和使用

4. 私有权限

        > 在类内部, 属性名或者方法名前边加上两个下划线 , 这个属性或者方法就变为私有的

        > 私有的方法和属性, 只能在当前类的内部使用

5. 什么时候定义私有

        > 1. 某个属性或者方法,不想在类外部被访问和使用, 就将其定义为私有即可

        > 2. 测试中,一般不怎么使用, 直接公有即可

        > 3. 开发中,会根据需求文档, 确定什么作为私有

6. 如果想要在类外部操作私有属性, 方法是, 在类内部定义公有的方法, 我们通过这个公有方法去操作

五、继承 

1. 继承描述的是类与类之间的关系

2. 继承的好处: 减少代码的冗余(相同的代码不需要多次重复书写), 可以直接使用

1、语法

# class A(object):
class A: # 没有写父类,但也有父类, object, object 类是 Python 中最顶级(原始)的类 
    pass

class B(A): # 类B, 继承类 A
    pass

术语:

1. A 类, 称为是 父类(基类)

2. B 类, 称为是 子类(派生类)

单继承: 一个类只继承一个父类,称为单继承

继承之后的特点:

        > 子类(B)继承父类(A)之后, 子类的对象可以直接使用父类中定义的公有属性和方法

# 1. 定义一个 动物类, 吃 
class Animal:
    def eat(self):
        print('要吃东西')

# 2. 定义一个 狗类, 继承动物类, 吃, 叫 
class Dog(Animal):
    def bark(self):
        print('汪汪汪叫....')

# 3. 定义一个 哮天犬类, 继承 狗类 
class XTQ(Dog):
    pass

# 创建 动物类的对象 
# ani = Animal() 
# ani.eat() 
# 创建狗类对象 
# dog = Dog() 
# dog.eat() # 调用父类中的方法 
# dog.bark() # 调用自己类中方法 
# 创建哮天犬类对象 
xtq = XTQ() 
xtq.bark() # 调用 父类 Dog 类的方法 
xtq.eat() # 可以调用 父类的父类中的方法

总结：

python 中 对象.方法() 调用方法

1. 现在自己的类中的去找有没有这个方法 如果有,直接调用

2. 如果没有去父类中 查找, 如果有,直接调用

3. 如果没有, 去父类的父类中查找, 如果有直接调用

4 ...

5. 如果 object 类中有,直接调用, 如果没有,代码报错

2、重写

重写: 在子类中定义了和父类中名字相同的方法, 就是重写

重写的原因: 父类中的方法,不能满足子类对象的需求,所以重写

重写之后的特点: 调用子类字节的方法, 不再调用父类中的方法

重写的方式:

        1. 覆盖(父类中功能完全抛弃,不要,重写书写)

        2. 扩展(父类中功能还调用,只是添加一些新的功能) (使用较多)

 

2.1、覆盖 

1. 直接在子类中 定义和父类中名字相同的方法

2. 直接在方法中书写新的代码

class Dog:
    def bark(self):
        print('汪汪汪叫.....')

class XTQ(Dog):
    # XTQ 类bark 方法不再是汪汪汪叫, 改为 嗷嗷嗷叫 
    def bark(self):
        print('嗷嗷嗷叫...')

xtq = XTQ() 
xtq.bark()

2.2、扩展父类中的功能

1. 直接在子类中 定义和父类中名字相同的方法

2. 在合适的地方调用 父类中方法 super().方法()

3. 书写添加的新功能

class Dog:
    def bark(self):
    print('汪汪汪叫.....') 
    print('汪汪汪叫.....')

class XTQ(Dog):
    # XTQ 类bark 方法不再是汪汪汪叫, 改为 
    # 1. 先 嗷嗷嗷叫(新功能) 2, 汪汪汪叫(父类中功能) 3. 嗷嗷嗷叫 (新功能) 
    def bark(self):
        print('嗷嗷嗷叫...')
        调用父类中的代码 
        super().bark() # print() 如果父类中代码有多行呢? 
        print('嗷嗷嗷叫...')

xtq = XTQ() 
xtq.bark()

六、多态（了解）

1. 是一种写代码,调用的一种技巧

2. 同一个方法, 传入不同的对象, 执行得到不同的结果, 这种现象称为是多态

3. 多态 可以 增加代码的灵活度

-------

哪个对象调用方法, 就去自己的类中去查找这个方法, 找不到去父类中找

七、属性和方法

Python 中一切皆对象.

即 使用 class 定义的类 也是一个对象

1、对象的划分

1.1、实例对象(实例)

1. 通过 类名() 创建的对象, 我们称为实例对象,简称实例

2. 创建对象的过程称为是类的实例化

3. 我们平时所说的对象就是指 实例对象(实例)

4. 每个实例对象, 都有自己的内存空间, 在自己的内存空间中保存自己的属性(实例属性)

1.2、类对象(类)

1. 类对象 就是 类, 或者可以认为是 类名

2. 类对象是 Python 解释器在执行代码的过程中 创建的

3. 类对象的作用: ① 使用类对象创建实例 类名(), ② 类对象 也有自己的内存空间, 可以保存一些属性值信息 (类属性)

4. 在一个代码中, 一个类 只有一份内存空间

 

2、属性的划分

2.1、实例属性

概念: 是实例对象 具有的属性

定义和使用：

            在 init 方法中, 使用 self.属性名 = 属性值 定义

            在方法中是 使用 self.属性名 来获取(调用)

内存：实例属性,在每个实例中 都存在一份

使用时机：

        1. 基本上 99% 都是实例属性,即通过 self 去定义

        2. 找多个对象,来判断这个值是不是都是一样的, 如果都是一样的, 同时变化,则一般定义为 类属性, 否则定义 为 实例属性

2.2、类属性

概念: 是 类对象 具有的属性

定义和使用：

        在类内部,方法外部,直接定义的变量 ,就是类属性

        类对象.属性名 = 属性值 or 类名.属性名 = 属性值

内存：只有 类对象 中存在一份

3、方法的划分

方法, 使用 def 关键字定义在类中的函数就是方法  

3.1、实例方法(最常用)

定义：

# 在类中直接定义的方法 就是 实例方法 
class Demo:
    def func(self): # 参数一般写作 self,表示的是实例对象 
        pass

定义时机(什么时候用)：

        如果在方法中需要使用实例属性(即需要使用 self), 则这个方法必须定义为 实例方法

调用：

        对象.方法名()  # 不需要给 self 传参

3.2、类方法

定义：

# 在方法名字的上方书写 @classmethod 装饰器(使用 @classmethod 装饰的方法) 
class Demo:
    @classmethod 
    def func(cls): # 参数一般写作 cls, 表示的是类对象(即类名) class 
        pass

 定义时机(什么时候用)：

        1. 前提, 方法中不需要使用 实例属性(即 self)

        2. 用到了类属性, 可以将这个方法定义为类方法,(也可以定义为实例方法)

调用：

        # 1. 通过类对象调用

        类名.方法名() # 也不需要给 cls 传参, python 解释器自动传递

        # 2. 通过实例对象调用

        实例.方法名() # 也不需要给 cls 传参, python 解释器自动传递

3.3、静态方法

定义：

# 在方法名字的上方书写 @staticmethod 装饰器(使用 @staticmethod 装饰的方法) 
class Demo:
    @staticmethod 
    def func(): # 一般没有参数 
        pass

定义时机(什么时候用)：

        1. 前提, 方法中不需要使用 实例属性(即 self)

        2. 也不使用 类属性, 可以将这个方法定义为 静态方法

调用：

        # 1. 通过类对象调用

        类名.方法名()

        # 2. 通过实例对象调用

        实例.方法名()

八、哈希（hash）

哈希（hash）: 是一个算法， 可以对数据产生一个唯一的值（指纹）

is 可以用来判断两个对象是不是同一个对象，即 两个对象的引用是否相同 a is b === > id(a) == id(b)

面试中可能会问： is 和 == 的区别？

== 只判断数据值是否相同， is 判断引用是否相同

 其他Python知识参考：软件测试基础（七）—— Python