一、数据类型

1.格式化输出

按照⼀定的格式,在字符串中使⽤ 变量, 将变量的值进⾏输出

字符串.format()

F-string

1, 可以在任意的 Python 版本中使⽤

2, 字符串中需要使⽤变量的地⽅,使⽤ {} 进⾏占位

3, 在 format 的括号中 按照占位的顺序,将变量写上去

1, python 3.6 版本开始可以使⽤,即⼤于等于 3.6 可以使⽤

2, 在字符串前边加上 f'' 或者 F''

3, 字符串中需要使⽤变量的地⽅,使⽤ {} 进⾏占位

4, 将变量直接写在 占位的⼤括号中

name = '⼩明'
age = 18
sex = '男'
# 我的名字是 xx, 年龄 xx 岁, 性别为 xx.
print('我的名字是 ' + name + ', 年龄 ' + str(age) + '岁, 性别为 ' + sex + '.')
print('我的名字是 {}, 年龄 {} 岁, 性别为{}.'.format(name, age, sex))
print(f'我的名字是 {name}, 年龄 {age} 岁, 性别为{sex}.')

转义字符

将两个字符进⾏转义表示⼀个特殊的字符

\n ---> 换⾏,回⻋

\t ---> 制表符, tab键

print( end='\n') print 函数中默认有⼀个 end='\n', 所

以,每个 print 结束之后, 都会输出⼀个 换⾏

2.容器

字符串 str

切片

语法 容器[start:end:step]

my_str = 'abcdefg'

print(my_str[0:3:1]) # abc

# 1.1 如果步长是 1, 可以省略不写
print(my_str[0:3]) # abc
# 1.2 如果 start 开始位置的下标为 0, 可以不写,但是冒号不能少
print(my_str[:3]) # abc
# 需求 2: 打印字符串中的 efg , start 4, end 7, step 1
print(my_str[4: 7]) # efg
# 2.1 如果取到最后一个字符, end 可以不写,但是冒号不能少
print(my_str[4:]) # efg
# 需求 3: 打印字符串中的 aceg , start 0, end 7(最后), 步长 2
print(my_str[::2]) # aceg
# 练习: cf
print(my_str[2:6:3])
# 特殊情况, 步长为 -1, 反转(逆序) 字符串
print(my_str[::-1]) # gfedcba

字符串查找方法 find()

result = my_str.find(sub_str)

字符串的替换 replace()

my_str1 = my_str.replace('good', 'GOOD')

字符串拆分 split()

str1 = 'hello Python\tand itcast and\nitheima'
# 1. 默认 按照空白字符分隔
list1 = str1.split()
print(list1) # ['hello', 'Python', 'and', 'itcast', 'and', 'itheima']
# 2. 按照 空格分隔
list2 = str1.split(' ')
print(list2) # ['hello', 'Python\tand', 'itcast', 'and\nitheima']
# 3. 按照 and 分隔
list3 = str1.split('and')
print(list3) # ['hello Python\t', ' itcast ', '\nitheima']

字符串的连接 join

list1 = ['hello', 'Python', 'and', 'itcast', 'and', 'itheima']
# 将 列表中数据使用 空格 组成新的字符串
str1 = ' '.join(list1)
print(str1) # hello Python and itcast and itheima
# 使用 逗号 连接
str2 = ','.join(list1)
print(str2) # hello,Python,and,itcast,and,itheima
# 使用 _*_ 连接
str3 = '_*_'.join(list1)
print(str3) # hello_*_Python_*_and_*_itcast_*_and_*_itheima

列表 list

使用 []

list1 = list()
print(type(list1), list1) # <class 'list'> []
index()

# 查找 2 出现的下标

num = list1.index(2)
print(num)
1, 找到 返回下标
2, 没有找到, 直接报错

count() 方法

# 统计数据 2 出现的次数
num1 = list1.count(2)
print(num1)

添加数据 append()

# 定义空列表
list1 = []
print(list1)
# 添加数据 张三
list1.append('张三')
print(list1)

删除数据 pop()

# 删除最后一个数据
list1.pop()
print(list1)
# 删除第二个数据
name = list1.pop(1)
print('删除的对象为:', name)
print(list1)

列表的反转 reverse()

my_list1 = my_list[::-1]
my_list.reverse()

列表的排序

# 排序 升序
my_list.sort()
# 降序
my_list.sort(reverse=True)

列表的嵌套

student_list = [["张三", "18", "功能测试"], ["李四", "20", "自动化测试"], ["王五", "21", "自动化测
试"]]
# 张三
print(student_list[0][0])
# 李四
print(student_list[1][0])
# 张三 的信息添加一个 性别 男 ---> 向张三所在的列表 添加数据
student_list[0].append('男')
print(student_list)
# 删除 性别
student_list[0].pop()
print(student_list)
# 打印 所有人员的年龄
for info in student_list: # info 是 列表
print(info[1])

3.元组 tuple

tuple1 = tuple()
print(type(tuple1), tuple1) # <class 'tuple'> ()
# 1.2 类型转换 , 将列表(其他可迭代类型)转换为元组
tuple2 = tuple([1, 2, 3])
print(tuple2)
# 2. 直接使用 () 定义
# 2.1 定义空元组
tuple3 = ()
# 2.2 非空元组
tuple4 = (1, 2, 'hello', 3.14, True)
print(tuple4)
print(tuple4[2]) # hello
# 2.3 定义只有一个数据的元组, 数据后必须有一个逗号
tuple5 = (10,)
print(tuple5)

4.字典 dict

1.字典 dict, 使用 {} 表示

2, 字典是由键(key)值(value)对组成的, key: value

3, 一个键值对是一组数据, 多个键值对之间使用 逗号隔开

4, 在一个字典中, 字典的键 是不能重复的

5, 字典中的键 主要使用 字符串类型, 可以是数字

6, 字典中没有下标

遍历字典的值[使用较多]

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

遍历字典的键和值

# 变量1 就是 键, 变量2 就是值
for 变量1, 变量2 in 字典.items(): # 字典.items() 获取的是字典的键值对
print(变量1, 变量2)
my_dict = {'name': '小明', 'age': 18, 'sex': '男'}
for k in my_dict:
print(k)
print('*' * 30)
for k in my_dict.keys():
print(k)
print('-' * 30)
for v in my_dict.values():
print(v)
print('_*_' * 30)
for k, v in my_dict.items():
print(k, v)

集合 set, {数据, 数据, ...}

1, 集合中的数据是不能重复的, 即没有重复数据

2, 应⽤, 对列表进⾏去重操作 就是类型转换 , 可以将 列表转

换为 集合, 然后再将集合转换为列表

my_list = [1, 2, 1, 2, 5, 2, 2, 4, 13]
# ⽅式⼀
list1 = list(set(my_list))
print(list1)

函数

def login():

模块和包

from random import randint
num = randint(1, 10)
print(num)

3.匿名函数

user_list = [
{'name': '张三', 'age': 22, 'title': '测试工程师'},
{'name': '李四', 'age': 24, 'title': '开发工程师'},
{'name': '王五', 'age': 21, 'title': '测试工程师'}
]
def func(x):
return x['age']
user_list.sort(key=lambda x: x['age'])
print(user_list)

class Cat:
def eat(self): # self 是调⽤这个⽅法的对象
"""吃⻥的⽅法"""
print(f'self:{id(self)}')
print(f'⼩猫{self.name}爱吃⻥...')
# 创建对象
tom = Cat()
# 通过对象 调⽤类中的⽅法
print(f"tom :{id(tom)}")
# 给 Tom 对象添加 name 属性
tom.name = '汤姆'
print(tom.name)
tom.eat()
blue_cat = Cat()
print(f'blue:{id(blue_cat)}')
blue_cat.name = '蓝猫'
blue_cat.eat()

# 1. 定义动物类，动物有姓名和年龄属性，具有吃和睡的行为
class Animal:
"""动物类"""
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
"""吃"""
print(f'{self.name} 吃东西')
def sleep(self):
"""睡"""
print(f"{self.name} 睡觉")

# 2. 定义猫类，猫类具有动物类的所有属性和方法，并且具有抓老鼠的特殊行为
class Cat(Animal):
"""猫类"""
def catch(self):
print(f"{self.name} 会抓老鼠...")

# 定义类方法,需要在方法名上方 书写 @classmethod , 即使用 @classmethod 装饰器装饰
class 类名:
@classmethod
如果 方法中 不需要使用 实例属性, 但需要使用 类属性, 则这个方法 **可以** 定义为 类方法(建议)
def 方法名(cls):
pass

# 定义静态方法, 需要使用 装饰器 @staticmethod 装饰方法
class 类名:
@staticmethod
方法中即不需要使用 实例属性, 也不需要使用 类属性, **可以** 将这个方法定义为 静态方法
def 方法名():
pass

with open(file, mode, encoding) as 变量: # 变量 就是文件对象
pass
# 使用这种写法打开文件, 会自动进行关闭,不用手动书写关闭的代码
# 出了 with 的缩进之后, 文件就会自动关闭
with open('a.txt', 'a', encoding='utf-8') as f:
f.write('good good study\n')

import json
json.dump(info, f, ensure_ascii=False, indent=2)
# 直接显示中⽂

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

# 1. 导包 unittest
import unittest
# 2. 定义测试类, 只要继承 unittest.TestCase 类, 就是
测试类
class TestDemo1(unittest.TestCase):
# 3. 书写测试⽅法, ⽅法中的代码就是真正⽤例代码,
⽅法名必须以 test 开头
def test_method1(self):
print('测试⽅法1-1')
def test_method2(self):
print('测试⽅法1-2')

# 1. 导包 unittest
import unittest
from hm_02_testcase1 import TestDemo1
from hm_02_testcase2 import TestDemo2
# 2. 实例化套件对象 unittest.TestSuite()
suite = unittest.TestSuite()
# 3. 添加⽤例⽅法
# 3.1 套件对象.addTest(测试类名('测试⽅法名')) # 建议复制
suite.addTest(TestDemo1('test_method1'))
suite.addTest(TestDemo1('test_method2'))
suite.addTest(TestDemo2('test_method1'))
suite.addTest(TestDemo2('test_method2'))
# 4. 实例化 执⾏对象 unittest.TextTestRunner()
runner = unittest.TextTestRunner()
# 5. 执⾏对象执⾏ 套件对象 执⾏对象.run(套件对象)
runner.run(suite)
# 套件对象.addTest(unittest.makeSuite(测试类名)) # 在不同的 Python 版本中,可能没有提示
suite.addTest(unittest.makeSuite(TestDemo1))
suite.addTest(unittest.makeSuite(TestDemo2))

import unittest
# 实例化加载对象并加载⽤例,得到套件对象
# suite = unittest.TestLoader().discover('⽤例所在的⽬录', '⽤例代码⽂件名*.py')
suite = unittest.TestLoader().discover('.','hm_02*.py')
# 实例化执⾏对象并执⾏
# runner = unittest.TextTestRunner()
# runner.run(suite)
unittest.TextTestRunner().run(suite)

# 类级别的 Fixture 需要写作类⽅法
@classmethod
def setUpClass(cls): # 类前置
pass
@classmethod
def tearDownClass(cls): # 后置
pass
# 类前置 ⽅法前置 ⽤例 ⽅法后置 ⽅法前置 ⽤例 ⽅法后置
类后置

使用代码自动的判断预期结果和实际结果是否相符
assertEqual(预期结果，实际结果)
- 判断预期结果和实际结果是否相等，如果相等， 用例通过，如果不相等，抛出异常， 用例不通过
assertIn(预期结果，实际结果)
- 判断预期结果是否包含在 实际结果中， 如果存在，用例通过， 如果不存在，抛出异常，用例不通过
pip install parameterized
pip install -i https://pypi.douban.com/simple/ parameterized
from parameterized import parameterized

使用

7.测试报告