python测试（5-6）

1.元组tuple

元组的作用与列表的作用差不多，都可以存放多个值，可以进行元组的索引，也可以进行元组的切片。

元组与列表相比，元组的内容是不可被更改的，列表的可以被修改，相较而言，元组的安全性更高。

元组的表示形式：

a = (1,2,3,4,5)
print(a)

结果：

(1,2,3,4,5)

元组的索引：

a = (1,2,3,4,5)
print(a[1])

结果：

2

元组的切片：

a = (1,2,3,4,5)
print(a[1:3])
print(a[:])

结果：

(2, 3)
(1, 2, 3, 4, 5)

元组的切片依然是元组

元组不能像列表一样进行增删改查，内容是不可变的。列表的相关操作比元组的多

判断以下是否为元组：

a = ()
print(type(a))

这是一个空元组，属于元组

a = (1,'abc',True,[1,2])
print(type(a))

该元组内含多个数据类型，也属于元组

a = (1)
print(type(a))

元组中如果只有一个值，必须要在后面打一个逗号，才能算元组。如果没有逗号，那么括号内是啥类型，该变量就是啥类型。比如上述例子，1为整型，后面没有逗号，那么a就是int类型

a = (['5','abc'],)
print(type(a))

虽然只有一个值，但是后面加了逗号，所以为元组。如果没有加就是列表list

a = 5,8
print(type(a))

元组的括号有些时候也可以去掉，去掉括号后也算元组，但是不建议这样使用

a,b= 5,8
print(type(a))

这个可以理解为两边同时把括号去掉了，这种就不能称之为元组，结果为int类型。相当于a对应5，b对应8

即

a = 5
b = 8
print(type(a))

2.字典dict

字典也是用来存储多份数据，但都是以键值对的形式出现的。列表可以存放很多数据，但是当数据一多，很有可能分不清原本的数据的含义是什么，而字典的话就可以同时记录下含义和数据。

字典是不能进行索引和切片的

表示方法如下：

a = {'tv':'hhh'}
print(type(a))

这是一个字典类型，’tv’是key，代表含义，后面的是具体的值

字典使用时的注意事项：

1.同一个字典中key的数据类型可以是不一样的，但是必须是不可变类型，现在所学的可变类型有列表和字典和集合

例如：

a = {'tv':'hhh',1:'ab',True:'ha',None:'hei'}
print(type(a))

上述例子中的key都是不同数据类型，但是他们有一个共同的特点就是他们都是不可变类型。

虽然字典的Key可以用不同的不可变数据类型，但是实际上一般都是用的字符串

2.同一个字典中的key名称不能重复

例如：

a = {'tv':'hhh',1:'ab',False:'ha',None:'hei','tv':'fa'}
print(a)

结果：

{‘tv’: ‘fa’, 1: ‘ab’, False: ‘ha’, None: ‘hei’}

上述代码重复了‘tv’，虽然说不会报错，但是后面的’tv’会覆盖掉前面’tv’的内容

还有一种情况：

a = {'tv':'hhh',1:'ab',True:'ha',None:'hei'}
print(a)

结果：

{‘tv’: ‘hhh’, 1: ‘ha’, None: ‘hei’}

因为True是布尔类型，就是相当于数字1，所以与前面的1重复了，所以会覆盖前一个1的内容

3.字典的增删改查

字典的增

例如：

a = {'tv':'hhh',3:'ab',True:'ha',None:'hei'}
a['xiaoxue'] = 123
print(a)

结果：

{‘tv’: ‘hhh’, 3: ‘ab’, True: ‘ha’, None: ‘hei’, ‘xiaoxue’: 123}

意思是在字典a后边加上一个key为’xaioxue’，值为123的数据

字典的改

改的操作类似于增

例如：

a = {'tv':'hhh',3:'ab',True:'ha',None:'hei','xiaoxue':123}
a['xiaoxue'] = 'abc'
print(a)

结果：

{‘tv’: ‘hhh’, 3: ‘ab’, True: ‘ha’, None: ‘hei’, ‘xiaoxue’: ‘abc’}

当某个Key已经存在的时候，再去进行操作为改。还未存在时为增

字典的删

用pop，因为字典中没有索引，所以要把key写上去

a = {'tv':'hhh',3:'ab',True:'ha',None:'hei','xiaoxue':123}
a.pop('xiaoxue')
print(a)

结果：

{‘tv’: ‘hhh’, 3: ‘ab’, True: ‘ha’, None: ‘hei’}

字典的查

a = {'tv':'hhh',3:'ab',True:'ha',None:'hei','xiaoxue':123}
print(a['tv'])

结果：

hhh

“”“

字典里的别的用法拓展：

keys：

a = {'tv':'hhh',3:'ab',True:'ha',None:'hei','xiaoxue':123}
print(a.keys())

结果：

dict_keys([‘tv’, 3, True, None, ‘xiaoxue’])

#把key打印出来

values:

a = {'tv':'hhh',3:'ab',True:'ha',None:'hei','xiaoxue':123}
print(a.values())

结果:

dict_values([‘hhh’, ‘ab’, ‘ha’, ‘hei’, 123])

#把值打印出来

items(重点掌握):

a = {'tv':'hhh',3:'ab',True:'ha',None:'hei','xiaoxue':123}
print(a.items())

结果：

dict_items([(‘tv’, ‘hhh’), (3, ‘ab’), (True, ‘ha’), (None, ‘hei’), (‘xiaoxue’, 123)])

#里面分为多个元组，一个元组里面是以一个键值对的形式存在的

”“”

4.集合

集合的表示方式：{元素} 集合的形式与字典差不多，外边都是一个花括号 集合比较少用

里面的元素可以是不同的数据类型

判断是否为集合：

a = {}
print(type(a))

结果：

<class ‘dict’>

为空字典而不是集合！

空集合的表示方式：

a = set()
print(type(a))

集合里面不能有重复的元素，与字典中的key类似，所以集合在自动化测试中主要就是用来去除重复的元素

例如：

a = {1,2,4,2,3,3,7}
print(a)

结果：

{1，2，3，4，7}

在此过程中并没有进行排序，集合是无序的

例如：

想给列表[1，3，5，5，6，1]去重：

a = [1,3,5,5,6,1]
b = set(a)
print(b)
c =list(b)
print(c)

5.数据类型的转换

类型的名称加上括号就是转换函数

例如想把列表转换为元组tuple

a = [1,3,5,5,6,1]
b = tuple(a)
print(b)

有些数据类型的转换并不能通过结果看出

比如将整型6转换成字符串6再进行打印输出，在屏幕上是没有区别的（整型、浮点数、布尔类型都是这样，不会打引号）

a = 6
b = str(a)
print(b)

结果：6

几乎所有的数据类型都可以转换从字符串类型

但是并不是每一个数据类型之间都可以进行转换，例如无法在某些情况下将字符串转变成整型

eg:

a = "abc"
print(int(a))

6.类型运算

算术运算符：+、- 、/、//、%、***、

字符串的运算可以用到*

比如：

a = "abc"
b = a*10
print(b)

结果：

abcabcabcabcabcabcabcabcabcabc

比较运算：等于、不等于、大于、小于、大于等于、小于等于

比较运算得到的是布尔值，True或者False

例如：

print(4==5)
print(4!=5)
print(4>=5)
print(4<=5)
print(4>5)
print(4<5)

结果：

False
True
False
True
False
True

成员运算： in 或者 not in,得到的结果为布尔类型

用来判断一个数据是否包含另一个数据

在字符串中：

a = 'hello world'
print('e' in a )

结果：

True

在列表中：

a = [1,2,3,4,5,6]
print(5 not in a )

结果：False

在字典中：

a = {'name':'youjin','age':'20','hobby':'aoteman'}
print('20' in a)
print('name' in a)
print('aoteman' in a)

结果：

False
True
False

在字典中用值来找是找不到的，要用key来找，因为系统是用键值对将key和值连接起来，实际上是得不到值的，所以用值来找是找不到的。

如果想用值来找的话，可以先把值给取出来：

a = {'name':'youjin','age':'20','hobby':'aoteman'}
print('20' in a.values())

结果：

True

逻辑运算：and、or、and

and:两个同时真才为真，不然为假

or:两个中只要有一个为真就是真

not:与原来的相反

例如：

a = [1,2,3,4]
result_1 = 4 in a
b = (1,'3',(2,3))
result_2 = (2,3) not in b
print(result_1 and result_2)
print(result_1 or result_2)
print(not result_1)
print(not result_2)

结果：

False
True
False
True

赋值运算：+= 、-= 、*= 、/= 、//= 、**==

a+=4

a=a+4

…

其余类似

7.八大类中相对重要的几类

字符串：内容是固定的

列表：一般存储所有测试数据

字典：一般存储单条测试数据

布尔

8.if的相关内容

流程控制：当遇到流程控制时，就会出现选择和分叉

在python中一般代码都是顶格写，但是当遇到冒号时，下一行行首就应该要进行缩进

不管同一个if语句中有多少个分叉，最终都只会执行一条语句,并且是最先满足条件的那句，从上到下

公式：

if 条件1：

​ 满足条件1执行的代码

else：

否则，执行的代码

例如：

age = 17
if age >= 18:
    print("年满十八，可以入内")
else:
    print("未满十八，禁止入内")

结果：

未满十八，禁止入内

条件1是怎么确定的，因为条件1的判断得出来为一个布尔类型，如果为True，那么就执行，如果为False，就会执行另外一种

PS: 比较运算：<、>、=、<=、>=、!= 成员运算：in not in 逻辑运算：and、or、not 得到的都是布尔类型的结果

else省略的情况

if语句中，else是可以省略的，判断条件，满足则执行if,不满足也不会报错，相当于没有任何反应

例如：

age = 17
if age >= 18:
    print("年满十八，可以入内")

结果为空

情况大于两种

当情况大于两种时会用到elif（可以多次用)，并且else只能放在最后，不能写多个else（在同一个if下）

例如：

age = 67
if 60>= age >=18:
    print("可以入内")
elif 80>=age>60 :
    print("优惠券")
elif age>80:
    print("请注意休息")
else :
    print("禁止入内")

多种情况也可以省略else

age = 35
if 60>= age >=18:
    print("可以入内")
elif 80>=age>60 :
    print("优惠券")
elif age>80:
    print("请注意休息")

当两种情况都满足时，会执行先满足的那一条（先来后到）

age = 60
if 60>= age >=18:
    print("可以入内")
elif 80>=age>=60 :
    print("优惠券")
elif age>80:
    print("请注意休息")

给的年龄为60，既满足第一条也满足第二条，但是由于先满足第一条，于是会输出 可以入内

不同的if语句是相互独立的，会分别进行判断：

age = 23
if age >18:
    print("请你看电影")
if age<55:
    print("请你吃雪糕")
if age==23:
    print("恭喜你23岁啦")

结果：

请你看电影
请你吃雪糕
恭喜你23岁啦

因为每一条if是独立的，所以每个都会判断

一个if语句里面可以嵌套多个if语句

age = 25
name = '幸运儿'
if age>=18:
    print("你是一个成年人")
    if age == 30:
        print("恭喜你奔3了")
        if name == '幸运儿':
            print("恭喜你，免单奖励")

但是嵌套语句不建议写太多，一般三层

调试代码debug是一个很重要的功能，能帮助我们知道代码的问题

例如：

username = 4
if len(username)>=6:
    print("注册成功")
else:
    print("注册不成功")

本来用户输入一个长度大于6的用户名即可以注册成功，但是有些时候由于开发没有想到一些情况，或者网站攻击者故意为之，都会造成一些错误。整型是没有长度的，在此处就会报错。如果没有意识到是哪里的错误，可以使用debug，来一步一步看

修改：因为可以转换为长度，于是可以将username先转变成字符串，因为字符串有长度，并且几乎所有的数据类型都可以转化从字符串

username = 4
username = str(username)
print(len(username))
if len(username)>=6:
    print("注册成功")
else:
    print("注册不成功")

结果：

1

注册不成功

9.for循环

当有很多个数据需要被打印使用时，一个个的用变量保存去使用，是比较麻烦的，这时就要用到for循环

列表

case = [1,2,3,4,5,6,7]
for c in case:
    print(f"正在运行：{c}")

for代表要使用for循环，c代表一个名为c的变量，上面的for循环就是指的打印每一个在case里面的数据

结果：

正在运行：1
正在运行：2
正在运行：3
正在运行：4
正在运行：5
正在运行：6
正在运行：7

字符串

case = '我在马路边捡到一分钱，把他交到警察叔叔手里边'
for c in case:
    print(c)

表示将case里面的字符一一打印出来

结果：

我
在
马
路
边
捡
到
一
分
钱
，
把
他
交
到
警
察
叔
叔
手
里
边

如果不知道代码是怎么实现的，可以debug

字典

case = {'name':'进','sex':'男','hobby':'奥特曼'}
for c in case:
    print(c)

结果：

name
sex
hobby

当for循环用在字典上时，不做任何改动的前提下，只能把key拿出来

如果key和value两者都想要得到，就要使用到items()

case = {'name':'进','sex':'男','hobby':'奥特曼'}
for c in case.items():
    print(c)

结果：

(‘name’, ‘进’)
(‘sex’, ‘男’)
(‘hobby’, ‘奥特曼’)

还有一种常用的方式：

case = {'name':'进','sex':'男','hobby':'奥特曼'}
for k,v in case.items():
    print(k,v)

结果：
name 进
sex 男
hobby 奥特曼

这样的结果就不是以元组的类型出现

如果只想得到value值：

case = {'name':'进','sex':'男','hobby':'奥特曼'}
for c in case.values():
    print(c)

for循环和if的组合

很多时候有些执行是有一定条件的，于是就会使用到for循环和if的组合

case = [
    {'id':1,'模块':'登录'},
    {'id':2,'模块':'支付'},
    {'id':3,'模块':'社区'},
    {'id':4,'模块':'登录'}
]
for a in case:
    if a['模块'] == '登录':
        print(a)

上述代码使用了列表加字典，这样可以打印出一个测试用例的全部信息

结果：

{‘id’: 1, ‘模块’: ‘登录’}
{‘id’: 4, ‘模块’: ‘登录’}

如果想要在得到数据后就立即停止，可以使用到break

case = [
    {'id':1,'模块':'登录'},
    {'id':2,'模块':'支付'},
    {'id':3,'模块':'社区'},
    {'id':4,'模块':'登录'}
]
for a in case:
    if a['模块'] == '登录':
        print(a)
        break

结果：

{‘id’: 1, ‘模块’: ‘登录’}

for循环和for循环的嵌套

一般为了解决二维数据

case = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
]
for a in case:
    for c in a:
        print(c)

如果想要把列表里面的数字打印出来就要使用到for循环的嵌套，因为一次for循环只能得到里面的不同列表

结果：

1
2
3
4
5
6
7
8
9