Python基础_将多个数据进行assertin

变量：用来储存数据的 必须先定义再使用

一、字符串

• 字符串查找方法 find( ) 

例：字符串.find(sub_str) #在字符串中 查找是否存在sub_str这样的字符串
如果存在sub_str，返回第一次出现sub_str位置的下标
如果不存在sub_str，返回-1

• 字符串的替换 replace( )

字符串.replace(old, new, count) #将字符串中的old字符串替换为new字符串
old 原字符串
new新字符串
count 一般不写，表示全部替换，可以指定替换的次数
返回：会返回一个替换后的完整的字符串，原字符串不会改变

• 字符串拆分 split( )

字符串.split(sep) #将字符串按照指定的字符串sep进行分割
-sep，按照sep分割，可以不写，默认按照空白字符（空格 \t \n）分割
返回：列表，列表中的每个数据就是分割后的字符串

• 字符串的连接

字符串.join(容器) #容器一般是列表，将字符串插入到列表相邻的两个数据之间，组成新的字符串
注意点：列表中的数据，必须都是字符串才可以

二、列表

定义：列表，list，使用[ ]

1. 列表可以存放任意多个数据

2. 列表中可以存放任意类型的数据

3. 列表中数据之间使用逗号隔开

列表的切片得到的是新的列表
字符串的切片得到的是新的字符串
如果下标不存在，会报错

• 列表查询 index( )方法

index()这个方法的作用和字符串中的find()的作用是一样的
列表中是没有find()方法的,只有index()方法
字符串中同时存在find()和index()方法

index()
1.找到 返回下标
2.没有找到，报错

• 列表count( )方法

列表：count(数据) #统计 指定数据在列表找那个出现的次数

• 增删查改

增：列表.append(数据)  #向列表的尾部添加数据 
返回：None，所以不用使用 变量 = 列表.append( )
直接在原列表中添加数据，不会生成新的列表，如果想要查看添加后的数据，直接打印元列表

删：列表.pop(index)  #根据下标删除列表中的数据
index下标可以不写，默认删除最后一个
返回，删除的数据

改：列表[下标] = 新数据
想要修改列表中的数据，直接是所有下标即可

• 列表的反转reverse( )

字符串 反转 字符串[::-1]
列表 反转
1.列表[::-1] 得到一个新的列表，原列表不会改动
2.列表.reverse( ） 直接修改原列表的数据

• 列表的排序

前提：列表中的数据要一样
列表.sort( ) #升序，从小到大，直接在原列表中进行排序
列表.sort(reversed=True) #降序，从大到小，直接在原列表中进行排序

• 列表的嵌套

列表的嵌套 就是指列表中的数据都是列表

三、元组tuple

1.元组tuple，使用的( )
2.元组和列表非常相似，都可以存储多个数据，都可以存储任意类型的数据
3.区别在于元组中的数据不能修改，列表中的可以修改
4.因为元组中的数据不能修改，所以只能查询，如index，count，支持下标和切片
5.元组，主要用于传参和返回值
注意： 定义只有一个数据的元组，数据后必须有一个逗号

元组的应用：交换两个变量的值

1.在定义元组时，小括号可以省略不写
2.组包（pack），将多个数据值组成元组的过程
3.拆包（解包 unpack），将容器中多个数据，分别给到多个变量，需要保证容器中元素的个数和变量的个数保持一致

四、字典dict

1.字典dict，使用{}表示
2.字典是由键（key）值（value）对组成的，key：value
3.一个键值对是一组数据，多个键值对之间使用逗号隔开
4.在一个字典中，字典的键，是不能重复的
5.字典中的键主要使用字符串类型，可以是数字

增加和修改

字典['键'] = 值
1、键 存在，修改
2、键 不存在，添加

删除

字典的删除是根据字典的键，删除键值对
字典.pop('键')

查询

根据字典的key，获取对应的value值
方法一：字典['键']  #键不存在，会报错
方法二：字典.get(键） #键不存在，则返回None

字典的遍历：

字典存在 键(key) 值(value) 遍历分为3种情况

遍历字典的键

方式一
for 变量 in 字典：
           print(变量)
方式二
for 变量 in 字典.keys():  #字典.keys()可以获取字典所有的键
            print(变量)

遍历字典的值

for 变量 in 字典.values():  #字典.values()可以获取字典中所有的值
            print(变量)

遍历字典的键和值

#变量1是键 变量2是值
for 变量1，变量2 in 字典.items():   #字典.items()获取的是字典的键值对
             print(变量1，变量2）

五、集合

集合 set， {数据， 数据， ...}
1.集合中的数据不能重复
2.应用：去列表进行去重操作 将列表转换成集合 再将集合转换成列表

六、函数

print()在控制台输出
input()获取控制台输入的内容
type()获取变量的数据类型
len()获取容器的长度（元素的个数）
range()生成一个序列[0,n)
函数可以实现一个特定的功能
函数必须先定义后调用

函数的嵌套使用

在一个函数中调用另一个函数
1.代码从上到下执行
2.函数定义不会执行函数中的代码
3.函数调用会进入函数中执行函数的代码
4.函数中的代码执行结束，会回到调用的地方继续向下执行

函数的返回值

返回值：函数执行的结果
1.在一个函数中，想要返回一个数据(想要有返回值)，需要使用return关键字
2.为什么返回值？在函数中可能通过各种代码，得到的数据结果，想要在函数外部使用，就需要使用返回值
3.如果函数有返回值，一般在调用时，会使用变量来接收(保存)返回值，以便后续使用
4.return关键字的作用：
---将一个数据返回到调用的地址
--- 函数遇到rerurn会结束函数的执行
5.如果一个函数没有写return，可以认为返回值是None

七、模块和包

1.模块

1.在python中，每个代码文件，都可以称为一个模块
2.在模块中，别人写好的功能(变量、函数、类),可以直接拿来使用
3.写好的代码文件，想作为模块让别人使用，代码文件名(模块名)需满足表示符的规则
4.想要使用别人模块中写好的功能,需先导入别人写好的功能
5.as关键字，可以给模块或功能起别名

2.模块导入的方法

方式一：
import 模块名 #模块名，就是代码名，不要.py
#使用其中的功能
模块名.功能名 #功能可以是变量、函数和类
#多用于导入系统中的常用的模块和功能
 
方式二：
from 模块名 import 功能名 #导入特定的功能
#使用
功能名()
#多用于导入自己书写的，或者是第三方的模块

3.__name__变量

1.导入模块时，会执行模块中的代码
2.作用:如果在导入模块时，模块中的部分代码不想被执行，可以使用__name__
3.__name__变量，是python解释器内置的变量（变量的值是自动维护的），每个代码文件中，都有这个变量
--在模块中右键运行代码文件，__name__的值是'__main__’
--如果是被导入运行代码文件，__name__变量的值，是模块名（文件名）

if __name__ == '__main__':

4.模块的导入顺序

1.在导入模块时，会先从代码所在的目录进行导入
2.如果没有找到，回去python系统的目录查找导入
3.如果没有找到，报错

5.包（package）

包：将多个模块放在一个目录中集中管理，并在这个目录中创建一个__init__.py文件(可以是空的)，就是一个包

包的创建：

包的导入：

方式一：import 包名.模块名
使用： 包名.模块名.工具名
方式二：from 包名 import 模块名
使用： 模块名.工具名
方式三：from 包名.模块名 import 工具名 
使用：工具名

八、变量的进阶

1.引用的概念

1定义变量时，变量和数据都会在内存开辟新空间
2.变量所对应的内存空间中存储的是数据所在内存的地址
3.变量中记录数据的地址，就叫做引用
4.python中所有数据的传递，传递的都是引用(即地址)
5.赋值运算符（=），会改变变量的引用，只有=可以修改变量的引用
6.使用id( )函数可以查看变量中数据所在的内存地址
当给一个变量重新赋值时，本质上是修改了数据的引用
--变量不再对之前的数据引用
--变量改为对新赋值的数据引用

2.局部变量和全局变量

根据变量定义的位置将变量分为局部变量和全局变量

局部变量：（在函数内部定义的变量）
1.局部变量只能在当前函数内部使用，函数执行结束后，局部变量会被系统回收
2.可以在不同函数内定义名字相同的局部变量、
3.声明周期(即使用范围):在函数执行(调用)时被创建，函数执行结束被销毁(删除)
4.形参可以被认为是局部变量
5.如果想要在函数外部使用局部变量的值，使用return返回

全局变量：（在函数外部定义的变量）
1.全局变量，可以在任意函数内访问(读取)
2.想要在函数内部修改全局变量的引用，需要使用global关键字声明(使用global关键字可以声明为全局变量)
3.如果在函数内部出现和全局变量相同的局部变量，在函数内部使用的是局部变量
4.生命周期：代码执行时创建，执行结束销毁

函数中变量获取的顺序：

1. 查找函数内部是否有执行名称的局部变量，如果有直接使用

2. 内部如果没有，则查找函数外部是否存在指定名称的全局变量，有则直接使用，无则报错

九、可变类型与不可变类型

根据类型中的数据是否允许修改，将数据类型分为可变类型和不可变类型
（不使用等号 能不能修改数据值）
可变类型：
-列表(list) list.append( )
-字典(dict）dict.pop( )
-集合(set)
不可变类型:
-数字类型(int, float, bool)
-字符串(str)
-元组(tuple)

十、函数进阶

1.函数返回多个数据值

return关键字两个作用：
1.返回数据值
2.结束函数的运行
函数中如果想要返回多个数据值，一般是组成元组进行返回

2.函数传参的方式

如何将实参的值传给形参

（1）位置传参

在函数调用的时候按照形参的顺序将实参的值传递给形参

（2）关键字传参

在函数调用的时候，指定将实参传递给哪个形参

（3）混合使用

位置参数必须写在关键字参数的前边，关键字参数必须放在位置参数的后边

同一个形参只能接收一个形参值（不能即使用位置传参和关键字传参个给同一个形参传参）

3.缺省参数（默认参数）

定义：在函数定义时，给形参一个默认的数据值，这个参数就是缺省参数（默认参数）

特点：在函数调用时，缺省参数可以不用传递实参值

1. 如果不传实参值，使用的就是默认值

2. 如果传递实参值，使用的就是传递的实参值

缺省参数必须写在普通参数后边

4.多值参数（可变参数）

1. 在函数定义时，不确定在调用的时候，实参有多少个，此时可以使用多值参数

2. 在普通的参数前边加上一个*，这个参数就变为多值参数

3. 这个参数可以接收任意多个位置传参的数据，类型 元组

4. 这个形参一般写作args(arguments)，即*args

参数顺序
#普通，缺省，多值
def 函数名(普通， *args, 缺省):
pass

5.匿名函数

匿名函数：使用lambda关键字定义的表达式，称为匿名函数
语法：lambda参数，参数：一行代码 #只能实现简单的功能，只能写一行代码
#匿名函数，一般不直接调用，作为函数的参数使用的

匿名函数的应用：

6.案例

十一、面对对象基础

面向过程：
1.根据需求，将某些独立功能封装程一个有一个函数
2.最后完成的代码，就是顺序地调用不同的函数

面对对象:
1.相比较函数，面对对象是更大的封装，根据职责在一个对象中封装多个方法
2.根据职责确定不同的对象，在对象内部封装不同的方法

面对对象概念：面对对象编程（Onject Oriented programming）

1.类和对象

• 类：是对具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用

• 对象：是由类创建出来的一个具体存在的事物，可以直接使用

（1）类的构成

类的三大要素：

1. 类名（多个事物，起一个名字，类名满足大驼峰命名(所有单词首字母大写)）

2. 属性：事物的特征

3. 方法：事物的行为

（2）面对对象代码步骤：

1. 设计类（找类的三要素）

2. 定义类

3. 创建对象（实例化对象）

4. 由对象调用类中的方法

（3）类的设计

找三要素

类名的提取：使用名词提炼法，分析整个业务流程，得出的名词，通常就是类名

需求:进入某Web项目登录页面，输入用户名、密码、验证码之后，点击登录按钮可以登录系统
类名：LoginPage
属性：用户名(username),密码(password),验证码(verify_code),登录按钮(login_btn)
方法：登录方法(login)

2.面对对象基本语法

类的基本使用

1.定义类

在python中定义类使用关键字 class

class类名：
    #在class的缩进中定义类的属性和方法，方法的本质是函数
    def 方法名(self):  #方法的本质是函数
    pass

2.创建对象（实例化对象）

在代码中，对象是由类创建

类名( ) #就是创建对象
#一般使用变量将创建的对象保存起来
变量 = 类名( ) #一般将这个变量称为是对象，本质，变量中保存的是对象的引用地址

3.调用类中的方法

由类创建的对象，可以调用类中的方法

对象名.方法名( )

案例：

需求:小猫爱吃鱼 小猫要喝水
类的设计：
类名：小猫（Cat）
属性：暂无
方法：吃鱼(eat) 喝水(drink)

self参数

从函数的语法看，self是形参，可以使任意的变量名

特殊点：self是一个普通的参数，按照函数的语法，在调用的时候，必须传递实参值，原因：python解释器自动的将调用这个方法的对象作为参数传给self

slef代表调用这个方法的对象，谁调用self就是谁

属性

属性表示事物的特征

可以给对象添加属性或者获取对象的属性值

给对象添加属性：

对象.属性名 = 属性值 #添加或修改

获取对象的属性值

对象.属性名

在方法中操作属性（self是对象）：

self.属性名 = 属性值
self.属性名

魔法方法

在Python中存在一类方法，以两个下划线开头，两个下划线结尾，在满足某个条件的情况下会自动调用，折一类方法，称为是魔法方法

1. 初始化方法__init__

1.调用时机：在创建对象之后会自动调用
2.应用场景：初始化对象（给对象添加属性）
3.注意事项：

2.__str__方法

1. 调用时机：

使用print（对象）打印对象的时候，会自动调用

1. 如果没有定义__str__方法，默认打印的是，对象的引用地址

2. 如果定义__str__方法，打印的是方法的返回值

2. 应用场景

使用print（对象），打印输出对象的属性信息

3. 注意事项

必须返回一个字符串

3.dir()函数

dir(对象变量)

作用：可以查看对象内的所有属性和方法

注意：dir()函数不具备输出功能，需要和print()函数配合使用

2.面向对象的三大特征

（1）封装：根据需求将属性和方法封装到一个抽象的类中

案例一：

小明体重75.0公斤 小明每次跑步会减肥0.5公斤 小明每次吃东西体重增加1公斤

类名：人（person）
属性：体重（weight）姓名（name）
方法：跑步（run）-->修改属性值 吃东西（eat）-->修改属性值
__init__定义属性
__str__打印属性信息

案例二：

进入某web项目登录页面，输入用户名，密码，验证码之后登录系统

要求：1.模拟登录操作，输出每一步的登录信息
类的设计：
类名：LoginPage
属性：用户名（username），密码（password），验证码（verify_code）
方法：login

案例三：

类的设计：
类名：House
属性：户型（h_type）,总面积（total_area），剩余面积（free_area = total_area）家具名称列表(item_list=[])
方法：__init__, __str__,
添加家具的方法:add_item（1.修改剩余面积 2.判断剩余面积和家具面积的关系 3.向家具列表中添加家具的名字）
----------------------------
类名：家具类（HouseItem）
属性：名字name 占地面积area
方法

（2）继承：实现代码的重用，相同的代码不需要重复的编写

在继承关系中，子类可以拥有父类的所有方法和属性

语法：

class 类A：
    pass
class 类B(类A)： #类B继承类A
    pass
类A：父类（基类）
类B：子类（派生类）
子类继承父类之后，子类对象可以直接使用父类中的属性和方法

继承具有传递性：C继承B，B继承A，C可以使用A类中的属性和方法
对象调用方法的顺序:对象.方法名( )
1.会自己在类中查找，找到直接使用
2.没找到，去父类查找，找到直接使用
3.没找到，在父类的父类中找
4.知道object类，找到使用，没找到报错

重写（override）：在子类中定义了和父类一样的名字的方法，当父类的代码不能满足子类对象的需要时重写

覆盖式重写：父类的功能全部不要

拓展式重写：添加新功能

（3）多态：不同的子类对象调用相同的父类方法，产生不同的执行结果，增加代码的灵活度

3.私有和公有

公有权限：直接定义的属性和方法就是公有的
特点：可以在任何地方访问和使用，只要有对象就可以访问和使用

私有权限：只能在类内部定义（class关键字的缩进中）
只需要在属性名或方法名前面加上两个下划线，这个方法或属性就变为私有的

4.对象 属性 方法

• 对象分类：

1. 类对象

就是类，在代码执行时，解释器会自动创建

作用：1.使用类对象创建实例对象 2.存储一些类的特征值（类属性）

2. 实例对象

创建对象也称为实例化，所以由类对象（类）创建的对象，称为是实例对象，简称实例

一般来说，没有特殊强调，我们所说的对象都是值实例对象

实例对象，可以保存实例的特征值（实例属性）

就是使用类名()创建的对象

• 属性的划分

使用 实例对象.属性 访问属性时，会先在实例属性中查找，如果找不到去类属性中查找，找到就使用，找不到报错，即每个实例对象都有可能访问类属性值(前提：实例属性和类属性不重名）

1. 实例属性

概念:是每个实例对象，具有的特征（属性），每个实例对象的特征

定义：一般都是在init方法中使用self.属性名 = 属性值 来定义

特征：每个实例对象都会保存自己的实例属性，即内存中存在多份

代码中使用的属性基本都是实例属性，即都通过self定义

访问和修改:

#可以认为是通过self修改
实例对象.属性 = 属性值  #修改
实例对象.属性 #访问

2. 类属性

概念：是类对对象具有的特征，是整个类的特征

定义：一般是在类的内部（class缩进中），方法的外部（def的缩进外部）定义的变量

特征：只有类对象保存一份，即在内存中只有一个

访问和修改：

#即通过类名
类对象.属性 = 属性值
类对象.属性

类属性被该类的所有对象共享

案例：1.定义一个工具类 每间工具都有自己的name

需求：知道使用这个类，创建了多少个工具对象

类名：Tool
属性：name（实例属性）count（类属性）
方法：init

• 方法的划分

1. 实例方法

定义时机：如果方法中需要使用实例属性，则这个方法必须定义为实例方法

定义方法:

#直接定义的方法就是实例方法
class 类名
    def 方法名(self):
        pass

2. 类方法

定义时机：如果方法中不需要使用实例属性，需要使用类属性，则这个方法可以定义为类方法

定义方法：

#定义类方法，需要在方法名上方书写@classmethod，即使用@classmethod装饰器修饰
class 类名
    @classmethod
    def 方法名(cls): #参数一般写作cls，表示类对象，即类名，不需要手动传递，python解释器会自动传递
        pass

调用：

#方法一：
类名.方法名()
#方法二：
实例对象.方法名()

3. 静态方法

定义时机：方法中既不需要实例属性也不需要使用类属性，可以将这个方法定义为静态方法

定义方法：

#定义惊天方法，需要在方法名上方书写@staticmethod，即使用@staticmethod装饰器修饰
class 类名
    @staticmethod
    def 方法名():
        pass

调用：

#方法一：
类名.方法名()
#方法二：
实例对象.方法名()

案例：

类名：Game
属性:
top_score = 0 类属性
player_name 实例属性 init

十二、文件

文件操作，使用代码，来读写文件

1. Game案例，最高分不能保存的，可以将最高分保存到文件中

2. 自动化，测试数据在文件中保存，从文件中读取测试数据，进行自动化代码的执行

1.文件的概念：

可以存储在长期存储设备(硬盘、U盘)上的一段数据即为文件

2.文件的分类（能否使用文本软件打开）：

• 文本文件（可以使用文本软件打开，如记事本）：txt、py、md、json

• 二进制文件（不能直接使用文本软件打开，如MP3、MP4）

3.文件操作：

（1）打开文件 open()函数

open(file, mode = 'r', encoding=None)

• file:要操作的文件的名字，可以使用相对路径和绝对路径

• mode:打开文件的方式

---r表示只读，文件不存在会报错

---w只写，文件存在会覆盖原文件

---a（append）追加打开在文件末尾写入新的内容）

• encoding:编码格式，指二进制数据和汉字转换的规则的

--utf-8(常用)：指一个汉字转换为3个字节的二进制

--gbk：将一个汉字转换为2个字节的二进制

返回值：文件对象，后续对文件的操作，都需要这个文件对象

with open(file, mode, encoding) as 变量： #变量 就是文件对象
     pass
#使用这种方法打开文件，会自动进行关闭，不用手写关闭代码

打开文件的方式：

r w a 文本方式打开，适用于文本文件，会对二进制进行编码转换
rb wb ab 二进制方式打开，可以打开文本文件和二进制文件，但二进制文件只能使用二进制方式打开，同时不能传递encoding参数

（2）读写文件

读文件：red( )

变量 = 文件对象.read( )

返回值：返回读取到的文件内容，类型为字符串

写文件：write( )

文件对象.write( )

#参数：写入文件的内容，类型：字符串

返回值：写入文件的字符数、字符串的长度

（3）关闭文件 close( )

文件对象.close #关闭文件，如果是写文件，会自动保存，即将内存中的数据同步到硬盘

（4）按行读取文件

文件对象.readline()  #一次读取一行的内容，返回读取到的内容
read()和readline()如果读到文件末尾，反悔的都是空字符串

（5）读取大文件

4.json文件

json(JavaScript Object Notation）：javascript对象表示法

json文件：本质也是文本文件，是一种基于文本，独立于语言的轻量级数据交换格式，可以直接使用read和write去进行操作

（1）json的特点：

• 纯文本格式：不支持音频/视频/图片

• 具有良好的自我描述性，方便阅读和编写

• 具有清晰的层次结构

• 相较于XML文件，能够有效提升网络传输效率

（2）json语法：

(1) json中数据类型：
-对象{ } --->python字典
-列表[ ] --->python列表
-字符串，必须使用双引号 --->str
-数字类型 --->int float
-bool类型(true false) --->True False
-空值 null --->None
(2) json文件，是一个对象或者是数组，对象和数组可以相互嵌套
(3）json中的对象，是由键值对组成，键必须是字符串类型
(4) json中的数据直接使用逗号隔开，最后一个数据后边不能加逗号

（3）json文件的定义

（4）读取json文件

1.导包：import json
2，json.load(文件对象)  --->得到的是列表还是字典

（5）json文件的写入

#将python中列表或字典转换成json文件
#导包
#使用json.dump(python中数据，文件对象)

案例：

十三、异常

异常的概念：程序在运行时，如果python解释器遇到一个错误，则会停止程序的执行，并且提示一些错误信息，这就是异常

抛出异常：程序停止执行并且提示错误信息这个动作，通常称为抛出(raise)异常

异常类型：错误描述信息

1.捕获异常

try:
    #尝试执行的代码
except:
    #出现异常时执行的代码
#try:尝试，下方编写要尝试代码，不确定是否能够正常执行的代码
#except：如果有异常捕获，下方编写捕获到异常，处理失败的代码

2.捕获指定类型的异常

方法一：

try:
    可能发生异常的代码
except 异常类型1:
    发生了异常类型1，执行的代码
except 异常类型2：
    发生了异常类型2，执行的代码
except ......:
    pass

案例：

需求：1.提示用户输入一个整数 2.使用8除以用户输入的整数并且输出

方法二：

try:
    可能发生异常的代码
except Exception as 变量  #Exception常见异常类的父类，变量 异常对象，print()可以打印异常信息
    发生异常执行的代码

异常捕获的完整结构：

try:
    可能发生异常的代码
except 异常类型：
    发生了指定类型的异常代码
except Exception as e:
    发生了其他类型的异常执行的代码
else:
    没有发生异常会执行的代码
finally:
    不管有没有发生异常都会执行的代码

案例：

需求：
1.获取用户输入的数字
2.判断获取的数字是否整数
3.如果不是整数，提示输入错误
4.如果是整数，则进一步判断是奇数还是偶数
5.最终提示：程序运行结束
方法1：使用异常捕获
方案2：if判断 字符串.isdigit( )判断数字是否是纯数字，返回True，不是返回False

3.异常传递

python中已实现好的功能

异常传递：在函数的嵌套调用过程中，如果发生了异常，没有进行捕获，会将这个异常传递到函数调用的地方，直到被捕获为止，如果一直没被捕获，才会报错，终止运行

4.抛出异常

代码运行过程之所以发生异常，停止代码运行，是因为遇到raise关键字

raise关键字的作用：抛出异常，让代码终止执行

应用场景：自己书写代码板块，让别人使用，只有按照规定才能使用代码，不满足条件时使用raise抛出异常

案例:

十四、UnitTest框架

1.UnitTest基本使用

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】