本文是关于Python自动化测试的基础教程，介绍了Python语言的基本概念和常用工具PyCharm。讲解了Python的基础语法，如命名规范、转义序列、运算符、值类型、数据结构以及常用的语句、函数和面向对象编程。还涵盖了递归、循环、类与对象、装饰器、异常处理等内容，是学习Python自动化测试的良好起点。
前言
个人笔记，仅供参考。
一、python是什么？
python是一个高层次的结合了解释性，编译性，互动性和面向对象的脚本语言
二、使用工具
pycharm
python基础语法使用
书写规范：
- 物理行：书写的一条代码
- 逻辑行：一条语句（一条物理行最多写一条逻辑行）
- ： 后面的缩进与上一层逻辑属于 隶属关系
- # 注释
- ''' 文档注释 '''
python命名规则：首字母以字母，下划线，unicode字符，其他以字母下划线，数字，unicode，严格区分大小写，不允许有关键字
名词释义
- 变量：在类里面定义的变量，不必实例化即可调用
- 实例变量：在类里面定义的变量，必须实例化之后才可以调用
- 属性方法：调用时看起来像是一个变量，方法没有入参，可以变成一个属性方法
- 私有变量：__ 变量名 只能在类里面使用，出了类就不能使用
- 私有函数：__变量名__只能在类里面使用，出了类就不能使用
- 循环（loop）：指的是在满足条件的情况下，重复执行同一段代码。比如，while语句。
- 迭代（iterate）：指的是按照某种顺序逐个访问列表中的每一项。比如，for语句。
- 递归（recursion）：指的是一个函数不断调用自身的行为。比如，以编程方式输出著名的斐波纳契数列。
- 遍历（traversal）：指的是按照一定的规则访问树形结构中的每个节点，而且每个节点都只访问一次
- python运行机制：不在（-5-256）范围内的两个数在空值台一行一行的运行判断is是否相等，结果=False
转义序列：
- \n 换行符
- \t制表符
- \ 单个\后面符号不转译 print（'\\n'）
- 显示行连接，内容太多时，回车换行自动+\
- r 在内容前+ r 表示原始字符串 print(r'\n')
基本快捷键：
- 在文件目录空白处按shift+右键，打开命令窗口，输入python+文件名，查看文件内容
- #注释 ctrl+/
- tab 补全
- 将代码在控制台执行：alt+shift+E
- 直接运行整个文件：shift+f10
- 格式化代码 ：ctrl+alt+L
- Ctrl+q查看帮助
- F2自动定位问题行
- shift+tab 取消缩进
- ctrl+左键 查看源码
运算符
算术运算符 + -* / **幂 //取整 %取余
+也可以用作字符串拼接 print('a'+'b')
比较运算符 ==等于 ！=不等 > < >= <=
赋值运算符 = （ a = 1）
逻辑运算符 and 与 or 或 not 非，取反
成员运算符 in 在里面 查看值在指定的序列中，返回true或者Fales（ ‘a‘ in ex_dict 字典里有’a‘键，所以返回true）
not in 不在
值类型
布尔值bool：
- true（非 0 和 none true==1 返回true）
- False（条件不成立或值不相等， false==0 返回true）
相等 ==
- 1+1 == 2 返回True
取值赋值
- 下标从0开始，0为第一位
- 取值：one_list[1][2]
- 赋值：one_list[0]=100
none 空 （是一个对象，表示空数据），用法：is none
数据类型：
numbers 数字（int 整型，float 浮点型）
string 字符串 （‘ ’，“ ”）
list 列表 [ ]
tuple 元组( )
dictionary{ }
类型转换
str->int：int（‘123’）
int->str：str（‘123’）
list->set：set（[1,2,3,4,5]）
set->list：list（{1,2,3,4,5}）
list->tuple：tuple（[1,2,3,4,5]）
tuple->list：；ist（（1,2,3,4,5））
列表list
元素可变，可以增删改查
one_list=[value1，value2……] a=[1,2,3,3,5,2,4,5,6,7] # append（）追加在列表后面 a.append(7) # pop（）弹出指定下标,删除（默认删除最后一个） a.pop() # reverse（）0颠倒次序,在本列表操作 a.reverse() # a[::-1],生成另一个列表 # sort（）升序 a.sort() # 降序 a.sort(reverse=True) # remove（）移除内容第一次出现的位置 a.remove(5) # insert（）指定位置插入内容 a.insert(0,9) # copy（）浅拷贝,同等a[:] a.copy()
元组Tuple
元素不可变，定值表
tuple=（1,3,4,5,6） a = (1, 3, 4, 5, 6, 3, 5, 62, 2) # count（）统计内容在元组里出现的次数 a.count(2) # index（）查看内容在元组里面第一次出现的下标 a.index(3) # 空格也算一个字符 str1 = ' a-b b-s b-d c-t ' # help（）查看帮助 help(str) # find（）查看下标，如果不存在返回-1 str1.find('f') # split（）分割字符串，去除不需要的字符 str1.split() # 去掉字符的数量 str1.split('-', 2) # join（）合并字符串（必须都是字符串） '|'.join(['a', 'b b', 'c c-a']) # 去除开头和结尾的不可见字符 str2 = ' abc bcd \n \t ' # strip去除两边空白字符串 str2.strip() # 去除左右两边首次出现内容的字符 str1.strip('a') str1.strip('a-c') str1 = "a-b b-c c-a" # replace（）替换 str1.replace('-', '|') # 替换第n个字符位置的内容 str1.replace('-', '|', 2) # lower（）小写 str1.lower() # upper（）大写 str2.upper()
字典 Dictionary
以键值对的方式存在
键：以字符串命名，唯一
值：可以是任意值ex_dict={'a' : 1, 'b' :2} 取 ex_dict['a'] 返回1 赋 ex_dict['a']=20 重新给‘a’定义值 # items输出字典键值对 print(ex_dict.items()) # 遍历字典里面的键值对 for k,v in ex_dict.items(): if v==1: print(k,v) #get()查找键在字典里对应的值，如果没有就返回指定的值 ex_dict.get('r',-1) #setdefault() 查找字典里面的值，如果不存在就创建 ex_dict.setdefault('x',100) # update()更新，更新原有的，添加没有的 ex_dict.update({'b':120,'d':40}) # clear()清空列表 ex_dict.clear()
集合
- 集合是种无序不重复的元素集，：{} 不会创建一个空集合，只会创建一个空字典。
- set1={1,2,3,4,5}
集合运算
- 交集 &：返回两个集合都有的内容
- 并集 |：返回两个集合里面所有的内容，不包括重复的
- 补集 -：也叫差集，返回第一个比第二个多的值
- 对称补集^：不同出现在两者之中的，返回各自比对方多的不重复的内容
#使用 & 来获取交集 other_set = {3, 4, 5, 6} filled_set & other_set #=> {3, 4, 5} #使用 | 来获取并集 filled_set | other_set #=> {1, 2, 3, 4, 5, 6} #使用 - 来获取补集 {1,2,3,4} - {2,3,5} #=> {1, 4} #使用 in 来检查是否存在于某个集合中 2 in filled_set #=> True 10 in filled_set #=> False #copy（） 复制 set1={1,3,4,5,6} set2=set1.copy() #add（）添加，末尾追加 set2.add(100) # remove()移除 set2.remove(1) #issuperset() 判断是否为父级 set1.issuperset(set2) # clear()清空列表数据 set2.clear() # del删除列表 del set2
切片（范围引用）
序列名【下线：上限：步长】
- 包括下限，不包括上限，默认从左往右，-1是从右往左数
- 没有指定开始位置时默认从第一个开始
ex_list[1:4:1]:从列表第二个值开始到第四个
步数1为连续，2为跳格（1.3.5），正为正取，负为倒取
常用语句
if语句：
分支，只执行条件为True的语句块，if条件可以嵌套，嵌套的条件所属上一层条件
if 逻辑条件：
-->语句块
print(’条件成立时返回‘)
elif 条件：
print（’条件成立时返回‘）
else：
print（’以上条件不成立返回的内容‘）递归：以栈方式运算
1-100相加
def f(n):
if n == 1:
print(1)
return 1
else:
c=f(n - 1) + n
print(c)
return c
print(f(100))for迭代循环语句
遍历元素或已知循环次数
range（取值范围），break 结束循环， continue 跳过本轮循环， else 循环正常结束后执行
for var in 列表/range(取值范围):
-->语句块
----------------------------------------------------------------------
检查序列的值，再循环前初始化
s = "Some text"
cpt = 0
c：循环变量，由 for语句管理与赋值
for c in s：
if c==‘e’：
cnt=cnt+1
算法：计算字符串中e的数目
print(cnt)
else -->for循环顺利执行条件成立执行else9*9乘法表
遍历元素或已知循环次数
def 乘法表():
for i in range(1, 10):
for j in range(1, i + 1):
print(f"{j} * {i} = {i * j}", end="\t")
print()while条件循环
已知什么条件下循环
循环前初始化
s=0
i=0
while 逻辑条件（具有至少一个变量值的条件）：
--->语句块
s=s+i**2
i=i+1 -->改变i的值避免死循环
print（s）常用方法函数
print（）：打印打印结果默认换行，打印不换行：ent=\t(以制表符格式显示)
print('面积是：'，area，end=‘\t’)
type( )：查看类型
__class__:查看类型
print(type(a)) #获取类型 print(a.__class__) #获取类型
input 控制台输入：默认接收字符串类型
W=int(input('请输入宽度：'))
len 计算长度
len （a）
copy（） 复制
set1={1,3,4,5,6} set2=set1.copy()
del 删除
del a 删除变量
del newlist[0] 删除索引
合并
update 合并两个字典
dic={'age':19}
dic2={'name':'ls'}
dic.update(dic2)运算符+
list1=[1,3,5,6]
list2=[2,4,6,8]
list3=list1+list2变量
常量：固定不变的量
变量：可变的量
变量作用域
局部变量：自己有的先用自己的，自己没有的再往下找
global：声明全局变量，在内部定义全局变量会改变外面的值 global 变量名
面向对象，面向过程
面向过程：有精准的走向
面向对象：没有精准的走向，可扩展，适应性强，有编号（id），变量不需要声明三大特性：封装，继承，多态
id 查编号
is 判断是否为同一个对象
== 判断是否相等
继承
两个类之间的继承，子类继承父类所有的方法，除了私有的
pass 占位符，函数不返回值时使用
调用父类方法：super（）.hello（）
在子类方法调用父类方法传的是子类的值多重继承
采用c3算法，主要用于在多继承时判断属性的路径
mro 方法解释顺序，主要用于在多继承时判断属性的路径
print(F.mro())class O(object): def hello(self): print("O") class A(O): def hello(self): print('AO') class B(A,O): pass b=B() b.hello()-->AO print(B.mor()) <class '__main__.B'><class '__main__.A'><class '__main__.O'>
多态
：注解 ： 类型
对于同类的不同对象输出不同的动作
与类同级def hello(x: Animal): x.hello()
可变对象与不可变对象
可变对象，引用传递：数组，字典，集合为可变对象
def f(x): x[0]=100 print(x) a=[1,2,3] f(a)不可变对象，值传递：单数的值，元组不可变
def f(x): print('x',id(x)) x=100 print(id(x)) print(x) a=1
生成器
__next__()
生成循环的下一结果，如果一个列表里面有这个方法，他就是个循环对象
ex_iter = iter([1, 2, 3, 4, 5, 6, 7]) ex_iter.__next__()yieid
def gen(): a = 100 yield a yield 100 for i in gen(): print(i)
列表推倒式
[x ** 2 for x in range(10) if x % 2 == 0]
__main__
如果本模块作为主程序运行
__name__的值，为__main__print(__name__) import abc print(abc.__name__) if abc.__name__ == '__main__': print('本模块') else: print('abc不是本模块')
匿名函数
lambda ：左边传入参数，右边返回值
lambda_sum = lambda x, y: x + y print(lambda_sum(2, 3))
函数 def
定义函数，可以添加多个参数
分装：把一段代码包裹起来再调用，叫分装，先定义后调用，给函数填入参数叫泛化
def 函数名(参数1，参数2，参数3.。。):
print(‘定义函数’)定义类型
def square_sum(a: float, b: float)默认值
def f2(a, b, c=10):返回值：return，返回时终止函数（返回元组）
def add(x, y):
print(f"x is {x} and y is {y}")
return x + y # 使用 return 语句来返回值调用函数并传参
位置传参
add(5, 6) #=> 输出 "x is 5 and y is 6" 并且返回 11关键字传参
add(y=6, x=5) # 关键字参数可以以任意顺序传入仅位置/仅关键字传参
# /前面位置传参，*后面关键字传参 def f3(x, /, y, *, z):
包裹传参
包裹传参，定义函数时定义
包裹位置传参*接收所有的位置，收集为元组
包裹关键字传参** 收集为字典
混合传参位置要在关键字前面# 包裹位置传参* # 包裹关键字传参** def f3(x, y, *a, b=10, **c): f3(1, 2, 3, 4, 5, aa=100, bb=200, b=300)
解包裹
用于函数调用的时候， 一个*解元组，两个**解字典
args = (1, 2, 3) f1(*args) args = {"a": 1, "b": 2, "c": 3} f1(**args)自动解包裹特性：数值交换
a, b = 1, 2 a, b = b, a print(a, b)
类与对象
装饰器
类方法装饰器@classmethod
@classmethod
def how_many(cls): 将方法标记为类方法，在不改变方法本身的前提下增强方法静态方法装饰器：@staticmethod
# 静态方法：没有任何讲究，普通函数，都可以通过类名或者对象调用
def hello():静态方法可以不用传参
print('奥利给！')类：
一系列有公共特征和行为的事务的抽象概念的总和，对一类事物的抽象的描述，分类，归类
类的命名：类名首字母大写
class Human(object):
# 下面是一个类属性。它将被这个类的所有实例共享。
species = "H. sapiens"
# 初始化
def __init__(self, name):
# 把参数赋值为实例的 name 属性
self.name = name
# 下面是一个实例方法。所有方法都以 self 作为第一个参数。
def say(self, msg):
return f"{self.name}: {msg}"
# 类方法会被所有实例共享。
# 类方法在调用时，会将类本身作为第一个参数传入。
@classmethod
def get_species(cls):
return cls.species
# 静态方法在调用时，不会传入类或实例的引用。
@staticmethod
def grunt():
return "*grunt*"私有属性：
__开头命名 ，在类的外部无法访问
self.__age = age
self.n = name类变量：
类变量是共享的，只要发生变化所有对象都会变，类变量用类名访问，只有类本身拥有
类方法通过类调用类方法，第一个参数必须为cls 类本身
对象：
一类中具体存在的事物，该类事物中的个体
self：对象本身，不需要传参
类里面方法第一个参数永远是他本身，
调用的是已有对象的本身，和类本身的变量无影响
cls：类本身，用类名调用
类与对象调用类变量
- 通过 类名、对象名 调用类变量，读取值无影响（如果对象本身没有定义类型的值读取的就是类的值）
- 通过 类名 调用类变量修改值，所有由该类创建的对象共同看到修改后的结果
- 通过 对象名 调用类变量修改值，对类变量无影响，变为了对象变量，所改的值存储到对象本身的类里
对象方法（函数）
对象方法=实例方法：第一个参数必须为self，对象本身
如果初始化的时候定义了值，再传值的话就会覆盖初始值
初始化方法
不需要手动调用，对象创建好后自动调用
def __init__(self, sex, age, name):
# 对象绑定的值来源于上面的参数
# self:对象本身
self.sex = sex构造函数
创建对象，最开始执行的,自动调用
def __new__(cls, *args, **kwargs):
print('构造方法')
self = object.__new__(cls)
return self析构方法
# # 析构方法，对象死亡后调用
def __del__(self):
print('析构方法')
异常处理
Debug 断点（
）
- 执行try下的语句，如果引发异常，则执行过程会跳到第一个except语句。
- 如果第一个except中定义的异常与引发的异常匹配，则执行该except中的语句。
- 如果引发的异常不匹配第一个except，则会搜索第二个except，允许编写的except数量没有限制。
- 如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中
raise 主动触发异常
str1 = 'hello world'
try:
int(str1)
except IndexError as e:
print(e)
except KeyError as e:
print(e)
except ValueError as e:
print(e)
else:
print('try内没有异常')
finally:
print('无论异常与否,都会执行我')文件对象
open(文件名,方式,encoding='utf-8')'''
r+读写
.read()读取
w 写入,覆盖
a 追加
.read(2)读指定字符
.readline()读取一行
.readlines()读取所有行,返回列表
d 二进制
.close()关闭文件
'''
f=open(r'd:\1.txt','w',encoding='utf-8')
f.write('静夜思\n床前明月光\n疑是地上霜')
f.close()
f=open(r'd:\1.txt','r',encoding='utf-8')
f.read()
f.readline(0)
f.close()
# 上下文管理器(读取文件方式)with
with open(r'd:\1.txt','r',encoding='utf-8') as f:
# print(f.closed)
for line in f:
print(line)
print(f.closed)
标准库
- 引入：import 模块包
- 从模块包递归引入模块：from 模块包.模块包 import 模块
- 不可以两个模块之间相互引用
- as 别名
time时间戳
引入模块包 import time
时间戳：格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数
time.time() #本地当前时间对象
time.localtime() #本地当前标准时间
localtime（）获取时间的年，月，日等
.tm_year，.tm_mon，.tm_mday
time.localtime().tm_hour
#strptime（）将时间对象转换为字符串格式,注意区分大小写
time.strftime("%Y‐%m‐%d %H:%M:%S", time.localtime())
# 将字符串格式时间转换为时间对象
time.strptime('2020‐11‐23 16:27:21', "%Y‐%m‐%d %H:%M:%S")
#mktime（）将时间对象转换为时间戳(数字)
time.mktime(time.localtime())
#ctime（）将时间戳转换成字符串格式时间
time.ctime(1606120153)
#sleep（）休眠
time.sleep(3)时间运算
datetime.datetime.now() # 返回当前时间
datetime.datetime.now().day # 返回当前时间（日）
datetime.datetime.fromtimestamp(1606120153) # 将时间戳转换为日期
datetime.datetime.now() + datetime.timedelta(3) #运算，当前时间+3天
datetime.datetime.now() + datetime.timedelta(hours=3) #运算，+3个钟
datetime.datetime.now() + datetime.timedelta(minutes=3) #运算，+3分钟随机数 random
引入随机数模块 import random
values = [1, 2, 3, 4, 5, 6]
# choice（）从非空序列中返回一个随机元素
random.choice(values)
# sample（）无重复抽取指定个数的元素
random.sample(values, 2)
# 产生一个 [1-6] 随机整数
random.randint(1, 6)
# [0-1) 范围内的随机浮点数
random.random()
# 将序列随机打乱位置
random.shuffle(values)字符串常量
引入模块包 import string
# ascii_letters 大小写字母常数
print(string.ascii_letters) # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
# ascii_lowercase 小写字母常数
print(string.ascii_lowercase) # abcdefghijklmnopqrstuvwxyz
# ascii_uppercase 大写字母常数
print(string.ascii_uppercase) # ABCDEFGHIJKLMNOPQRSTUVWXYZ
# digits 十进制数字常数
print(string.digits) # 0123456789
# hexdigits 十六进制数字常数
print(string.hexdigits) # 0123456789abcdefABCDEF
# octdigits 八进制数字常数
print(string.octdigits) # 01234567拼接
+ 合并两个数组
a=林浩：字符串拼接print（f ' 姓名：{a} ' ） ==》姓名：林浩
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
