python自动化测试学习笔记-1
一、什么是自动化
自动化测试是把以人为驱动的测试行为转化为机器执行的一种过程。直白的就是为了节省人力、时间或硬件资源,提高测试效率,便引入了通过软件或程序自动化执行测试用例进行测试;
二、python简介
Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。
我们先来看一各种编程语言的类型。
机器语言:是指一台计算机全部的指令集合,计算机所使用的是由"0"和"1"组成的二进制数,二进制是计算 计算机语言机的语言的基础。
编译型语言:将源代码编译生成机器语言,再由机器运行机器码(二进制)。例如:c c++ c#
解释型语言:相对于编译型语言存在的,源代码不是直接翻译成机器语言,而是先翻译成中间代码,再由解释器对中间代码进行解释运行。
代码在运行的时候才进行编译,如 java 、JavaScript、Perl 、Shell、PHP、ruby、python
脚本语言:一个脚本通常是 解释执行而非编译。一开始的时候这种语言只有单一的功能,如shell用户编写linux的脚本,js用于制作网页特效
python的应用:数据挖掘(爬虫)、数据分析、自动化运维、自动化测试、后台服务器接口开发、AI、人工智能、嵌入式开发、web开发等。
python的特点:
1编写的代码质量高:采用缩进的方法,让代码的可读性更好,也很适合团队协作开发。
2提高开发的效率:简单的语法,动态的类型,不过不要认为python仅可以完成简单的任务,其实他只是让复杂的编程任务变的高效和有趣,曾经我一个搞JAVA的朋友,他完成一个任务要写几百行代码,而我只写了10几行代码,的确python这们语言是想把程序员解放出来,腾出一些时间去享受生活。
3程序的可移植性:你编写的代码可以放到几个平台上去运行,比如windows,linux,unix。
4很多标准库和第3方库:等你了解python标准库的时候,你就会觉的它的标准库太多了,而且功能和强大,从字符处理到网络处理无所不能。
5编程思想是大道至简:python希望程序员能够用最简单的方法来解决问题,化繁为简。
好了下面开始我们的python学习之旅~
三、python基础
基本概念
字符集:是一个系统支持的所有抽象字符的集合,计算机中储存的信息都是用二进制数表示的。
字符编码(Character Encoding):是一套法则,使用该法则能够对自然语言的字符的一个集合(如字母表或音节表),与其他东西的一个集合(如号码或电脉冲)进行配对。即在符号集合与数字系统之间建立对应关系,它是信息处理的一项基本技术。以计算机为基础的信息处理系统则是利用元件(硬件)不同状态的组合来存储和处理信息的。元件不同状态的组合能代表数字系统的数字,因此字符编码就是将符号转换为计算机可以接受的数字系统的数,称为数字代码。
常用的字符集合字符编码
常见字符集名称:ASCII字符集、GB2312字符集、BIG5字符集、GB18030字符集、Unicode字符集等。计算机要准确的处理各种字符集文字,需要进行字符编码,以便计算机能够识别和存储各种文字。
UTF-8(8-bit Unicode Transformation Format)是一种针对Unicode的可变长度字符编码(定长码),也是一种前缀码。它可以用来表示Unicode标准中的任何字符,且其编码中的第一个字节仍与ASCII兼容,这使得原来处理ASCII字符的软件无须或只须做少部份修改,即可继续使用。因此,它逐渐成为电子邮件、网页及其他存储或传送文字的应用中,优先采用的编码。互联网工程工作小组(IETF)要求所有互联网协议都必须支持UTF-8编码。
有时我们看到页面上的乱码,可能就是字符集不一致导致的。
变量(variable)变量就是代表某个数据(值)的名称。python是一种动态类型语言,在赋值的执行中可以绑定不同类型的值,这个过程叫做变量赋值操作,赋值同时确定了变量类型。
静态类型语言是指在编译时变量的数据类型即可确定的语言,多数静态类型语言要求在使用变量之前必须声明数据类型,某些具有类型推导能力的现代语言可能能够部分减轻这个要求.
动态类型语言是在运行时确定数据类型的语言。变量使用之前不需要类型声明,通常变量的类型是被赋值的那个值的类型。
python中变量的定义
1、变量名可以包括字母、数字、下划线,但是数字不能做为开头。例如:name1是合法变量名,而1name就不可以。
2、系统关键字不能做变量名使用
3、除了下划线之个,其它符号不能做为变量名使用
4、Python的变量名是区分大小写的,例如:name和Name就是两个变量名,而非相同变量哦。
5、中文也能定义变量名,单实际当中不这样运用
python的数据类型
1)整型——int——数字
python有5种数字类型,最常见的就是整型int,例如:a = 123 或 b = -123 等号左边是变量名,右边是要赋的值
2)布尔型——bool——用符号==表示
布尔型是一种比较特殊的python数字类型,它只有True和False两种值,它主要用来比较和判断,所得结果叫做布尔值。例如:3==3 给出True,3==5给出False
3)字符串——str——用' '或" "表示
例如:URL='www.iplaypy.com'或者name="lijing"
4)列表——list——用[ ]符号表示
例如:num=[1,2,3,4]
5)元组——tuple——用( )符号表示
例如:('d',300)
6)字典——dict——用{ }符号表示
例如:{'name':'coco','country':'china'}
实战演练
安装python,安装pycharm编码软件进行编码。
1、hello world!
python中输出函数print函数,字符串和数值类型的可以直接输出,如下
print('hello world') print(1)
输出内容:
输出字符串内容可以用‘’,也可以用“”,当输出的字符串中包含‘’时,则字符串用“”;当输出的字符串中包含“”号时,则字符串用‘’;当输出的字符串中‘’和“”都包含时,则字符串用‘’‘ ‘’’来输出;如下
print("你真的很'帅'!") print('你真的很"帅"!') print(''''哇!'你真的很"帅"!''')
输出内容:
输出变量类型
x='hello world!' print(x) s=13 print(s) l=[1,2,3,'p'] print(l)
格式化输出
输出的内容中包含定义的参数时,
name=input('请输入你的姓名:') time='2017年12月19日' print('%s欢迎光临!'%name)
输出内容
%字符:标记转换说明符的开始 ,s表示格式转换类型为字符串,f表示十进制浮点数,d表示带符号的十进制整数
当有两个输出参数的使用,在%(参数1,参数2)列出需要传参的参数名
name=input('请输入你的姓名:') time='2017年12月19日' print('%s欢迎光临!'%name) print('%s欢迎光临!时间是:%s'%(name,time))
输出内容:
+的形式进行字符串拼接:
name=input('请输入你的姓名:')
time='2017年12月19日'
print('%s欢迎光临!'%name)
print(name+'欢迎光临!')
输出内容:
可以看到字符串拼接 + 的输出内容与%形式的转换是一样的;
还有一种方式更加简便快捷常用,{}的形式进行传参
name=input('请输入你的姓名:') time='2017年12月19日' print('%s欢迎光临!'%name) print('%s欢迎光临!时间是:%s'%(name,time)) print(name+'欢迎光临!') print('{}欢迎光临!时间是:{}'.format(name,time))
输出内容:
请输入你的姓名:pei
pei欢迎光临!
pei欢迎光临!时间是:2017年12月19日
pei欢迎光临!
pei欢迎光临!时间是:2017年12月19日
当参数较多时,可能会记忆混乱出现传参错误的情况,此时我们可重新定义一下传参的内容:如下实现方法
name=input('请输入你的姓名:') time='2017年12月19日' print('%s欢迎光临!'%name) print('%s欢迎光临!时间是:%s'%(name,time)) print(name+'欢迎光临!') print('{}欢迎光临!时间是:{}'.format(name,time)) print('{username}欢迎光临!时间是:{localtime}'.format(username=name,localtime=time))
输出内容:
2、条件判断基本使用方法
语法:
if 条件表达式:
语句块
例子:
如果成绩达到80分或以上,视为优秀。
成绩达到60分到80分(不包括80分),视为及格。
成绩60分以下,视为不及格。
我们输入一个分数,用if语句判断是否能打印出分数所属阶段:
score =input('请输入分数:') if score >= 80: print('优秀') elif score >=60 and score<80: print('及格') else: print('不及格!')
执行上面的语句,输入分数为89,看执行结果
上述结果我们看到执行报错了,str类型的与int类型不能进行比较;
因为score为一个输入类型的变量,而input函数所有形式的输入按字符串处理,如果想要得到其他类型的数据进行强制类型转化,此处我们需要对输入内容强制进行转化,如下
score =int(input('请输入分数:')) if score >= 80: print('优秀') elif score >=60 and score<80: print('及格') else: print('不及格!')
执行上述代码,输入分数为99,查看输出结果
输入分数为78,查看输出结果
输入分数为55,查看输出结果
2、for循环和while循环的基本使用方法
for循环
for something in XXXX:
语句块
即表示对XXXX中的每一个元素,执行某些语句块,XXXX可以是列表,字典,元组,迭代器等等。
如下
for x in range(10): print('test')
执行查看输出结果,输入了10次test
while循环:
while 条件表达式1:
语句块
while 循环不会迭代 list 或 tuple 的元素,而是根据表达式判断循环是否结束。while循环会每次判断 条件表达式1 是否为true,如果为true,则执行语句块,否则退出循环。
例如:
count=0 while count<3: print('哈哈哈') count+=1
执行看一下结果
结果输出了3次‘哈哈哈’,每一次输入,count+1,直到不满足条件count<3时,退出循环。
continue和break
break:
直接退出整个循环体;
continue:
跳出本次循环,执行下一次循环。
例如上边的例子,我们加上break和continue来看一下结果
for x in range(10):
print('test')
break
执行并查看结果
我们看到for循环中添加break之后,执行一次,遇到break就退出循环了,没有继续循环。
在while中添加continue来试试:
count=0 while count<3: count += 1 username=input('请输入您的姓名:') if username=='小王': print('%s,欢迎光临!'%username) break else: print('您好,您重新输入!') continue else: print('您好,输入次数过多!')
执行上述代码,输入姓名为:ww,查看结果
执行代码,输入姓名为:小王,查看结果
其中,字符串的比较
相等:==
不等于 :=!
小于等于 :<=
大于等于:>=
我们再来试一个猜数字的例子
Python中的random模块用于生成随机数。下面介绍一下random模块中最常用的几个函数。
random.random
random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0
random.uniform
random.uniform的函数原型为:random.uniform(a, b),用于生成一个指定范围内的随机符点数,两个参数其中一个是上限,一个是下限。如果a > b,则生成的随机数n: a <= n <= b。如果 a <b, 则 b <= n <= a。
random.randint
random.randint()的函数原型为:random.randint(a, b),用于生成一个指定范围内的整数。其中参数a是下限,参数b是上限,生成的随机数n: a <= n <= b
random.randrange
random.randrange的函数原型为:random.randrange([start], stop[, step]),从指定范围内,按指定基数递增的集合中 获取一个随机数。如:random.randrange(10, 100, 2),结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效。
random.choice
random.choice从序列中获取一个随机元素。其函数原型为:random.choice(sequence)。参数sequence表示一个有序类型。这里要说明 一下:sequence在python不是一种特定的类型,而是泛指一系列的类型。list, tuple, 字符串都属于sequence。
random.shuffle
random.shuffle的函数原型为:random.shuffle(x[, random]),用于将一个列表中的元素打乱。
random.sample
random.sample的函数原型为:random.sample(sequence, k),从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列。
首先需要导入random模块
import random random_num=random.randint(1,1999) print(random_num)
执行查看结果为 736 ,取了一个随机数。
下面来写猜数字的例子:如果7次之内猜出数字,则结束,如果错误,输入超过7次后结束。
import random # 导入random模块 random_num = random.randint(1, 500) count = 0 while count < 7: count += 1 num = int(input('请输入你猜的数字:')) if num > random_num: print('你猜的太大了') continue elif num < random_num: print('你猜的太小了') continue else: print('恭喜你猜对了,答案是:%s'%num) break
执行输入相应的数字,查看结果、
python自动化测试学习笔记-2-列表
python的数据类型-列表
列表是最常用的python数据类型,每一个元素都配有一个位置(角标或索引),从0开始依次类推。可以进行的操作包括索引,切片,追加,检查等。
1、定义一个列表
只要使用方括号括起来,并用逗号分隔不同数据项,就定义好一个列表了。例如:
stus=['xiaoli','xiaowang','xiaotu','xiaozhao']
那我们怎么打印出列表中的值呢,刚刚我们说了,列表有角标,我们可以通过角标找到想要的数据,如下:
stus=['xiaoli','xiaowang','xiaotu','xiaozhao'] print(stus[3])
角标是3,从0开始的话那就是第四个数据,我们执行看一下结果:
角标可以从正向计数,也可以从逆向计数,例如最后一个元素的角标为-1,依次类推,例如:
stus=['xiaoli','xiaowang','xiaotu','xiaozhao'] print(stus[3]) print(stus[-1])
我们执行一下,可以看到打印的效果是一样的:
如果定义一个空的列表
stus=[]
上面我们列举的都是一维数组,python中还存在多维数组,例如:
stus=['一年级','二年级','三年级','四年级',['一班','二班','三班','四班','五班',[1,2,3,4,5,6,7,8]]] print(stus)
我们打印来看一下
可以看到多维数组中字符串类型和int类型是可以同时存在的。
2、增加元素
append方法,在末尾增加一个元素,一次只能增加一个。我们来实验一下
stus=['xiaoli','xiaowang','xiaotu','xiaozhao']
stus.append('wangzhi') print(stus)
查看打印结果:
insert方法,将对象插入列表指定的位置,如:
stus=['xiaoli','xiaowang','xiaotu','xiaozhao']
stus.insert(2,'www')
print(stus)
当输入的下标不存在的场合,就会把数据添加到末尾,来实验一下:
stus=['xiaoli','xiaowang','xiaotu','xiaozhao']
stus.insert(9,333) print(stus)
打印看一下结果:
extend方法,在列表的末尾一次性追加另一个序列中的多个值(把两个列表合并):
num1=[1,2,3,4,5] num2=[6,7,8,9,10] num1.extend(num2) print(num1) print(num2)
查看执行结果
我们可以看到,打印出来的num1,是合并之后的列表,列表num2是不受影响的。
3、更新元素
可以直接给列表中的某一个元素进行赋值,如下:
num1=[1,2,3,4,5] num1[2]=11 print(num1)
看一下执行结果:
可以看到角标为2的第三个元素,已经被修改为11;
4、删除元素
del 语句:删除操作可以使用del语句来操作,例如
num1=[1,2,3,4,5] del num1[0] print(num1)
我们来打印一下,看一下结果:
可以看到删除了填写的下标元素,此处需要注意的是,下标是必须填写的,不填写就会报错,如果想要删除整个列表,可以用clear方法,如下:
clear方法:
num1=[1,2,3,4,5] num1.clear() print(num1)
执行看一下结果,可以看到清空了整个list
pop方法,移除列表中的一个元素(默认最后一个元素),并且返回该元素的值。
num1=[1,2,3,4,5] num2=[6,7,8,9,10] num1.pop(1) num2.pop() print(num1) print(num2)
看一下执行结果:
我们可以看到删除操作中,我们指定了角标,则删除了对应角标位置的数据,没有指定角标的删除了最后一个数据。
删除操作还有一种方法,remove方法,直接删除需要删除的元素;如下:
num1=[1,2,3,5,4,5] num1.remove(5) print(num1)
看一下执行结果:
我们看到上述列表中有两个[5],我们使用remove方法删除5的时候,只会删除其中的一个元素,删除第一个匹配的元素,不会全部删除。
pop和remove的区别还在于pop会返回删除元素的值,而remove不会返回。
num1=[1,2,3,5,4,5] print(num1.remove(5)) print(num1.pop(2))
我们看一下执行结果,remove返回的是none,pop返回了删除的数据3:
5、反转排序
reverse方法,使列表中的元素反向排列,例如
num1=[1,2,3,5,4,5] num1.reverse() print(num1)
执行结果:
sort 方法,对列表进行排序,但只能是同类型的元素进行排序,不同类型的元素会报错,看一下:
num1=[1,2,5,3,4,'a','z','l','t'] num1.sort() print(num1)
执行结果:
错误提示信息显示str类型和int类型不能进行排序。我们来看一下同类型的排序:
num1=['a','z','l','t'] num1.sort() print(num1)
查看结果:
排序默认的话为升序排序,如果需要倒叙排序我们可以借助reverse方法,对排序进行反转,如下:
num1=[45,23,67,111,1,9,100] num1.sort(reverse=True) print(num1)
查看执行结果:
index方法,从列表中找出某个元素第一个匹配项的索引位置,使用方法如下:
num1=[45,23,67,111,1,9,100] print('111的索引位置是:%s'%num1.index(111))
查看执行结果:
6、循环
list的一个重要特性就是可循环的,python可以对list进行解析,对list的元素进行遍历,我们看一下直接应用for循环的结果:
num=['haha','hehe','heihei','hengheng'] for i in num: print(i)
看一下执行结果,可以看到循环一个列表,取出了列表中的每一个元素:
在其他语言中想要遍历出列表的每一个元素就没有这么容易了,
7、切片
由于list可循环可遍历的特性,我们就可以对list进行切片操作,取出我们想要的元素。
切片是list取值的一种方式。
切片的语法格式:
list[start:stop:step]
star:表示取值的开始
stop:表示取值的结束
step:表示步长
我们来实验一下:
num=['haha','hehe','heihei','hengheng']
num2=num[0:3:1]
print(num2)
差看执行结果:
我们看到上述的结果,当我们结束值为3时,实际取到的值为下标为2的值,所以想取到一个列表中全部的值时,结束取值应为末尾下标+1。
num=['haha','hehe','heihei','hengheng'] num2=num[0:4:1] print(num2)
执行结果:
#如果切片的开始值不写的话,默认从0开始;如下:
num=['haha','hehe','heihei','hengheng'] num2=num[0:4:1] num3=num[:3:1] print(num2) print(num3)
查看打印结果:
#如果切片的结束值不写的话,则默认到最后,例如:
num=['haha','hehe','heihei','hengheng'] num2=num[0:4:1] num3=num[:3:1] num4=num[1::2] print(num2) print(num3) print(num4)
查看打印结果,num4我们步长设置的2,所以是隔一个取一个数值:
#如果步长不写的话默认是1,如下:
num=['haha','hehe','heihei','hengheng']
num2=num[0:4:1]
num3=num[:3:1]
num4=num[1::]
print(num2)
print(num3)
print(num4)
查看执行结果:
#如果都不填写的话默认就是列表所有,步长为1,如下
num=['haha','hehe','heihei','hengheng'] num2=num[0:4:1] num3=num[:3:1] num4=num[:] print(num2) print(num3) print(num4)
查看执行结果:
当步长为负数的场合,相当于从右往左取,如下:
num=['haha','hehe','heihei','hengheng'] num2=num[0:4:1] num3=num[:3:1] num4=num[:] num5=num[::-1] print(num2) print(num3) print(num4) print(num5)
差看执行结果:
当步数是步数的时候,开始值和结束值也应该是负数,如下:
num=['haha','hehe','heihei','hengheng'] num2=num[0:4:1] num3=num[:3:1] num4=num[:] num5=num[::-1] num6=num[-1:-5:-1] print(num2) print(num3) print(num4) print(num5) print(num6)
查看执行结果,负数的时候,结束标志同样需要+1:
总结:切片操作的开始结束值是顾头不顾尾,结束值为末尾角标+1。
8、切片同样适用于字符串
切片:
str='今天真开心!明天星期五'
str1=str[1:10:1]
print(str1)
查看执行结果:
字符串用于循环:
str='今天真开心!明天星期五' for i in str: print(i)
查看结果:
如果需要同时打印下标和文字,用enumerate:
str='今天真开心!明天星期五'
for i,j in enumerate(str):
print('%s的下标是%s'%(j,i))
查看执行结果:
布尔类型
布尔类型只有True和False两种值,简单地说是非空即真,非0即真;如下:
a='' b=0 c=' ' if a: print('zhen') else: print('jia') if b: print('zhen') else: print('jia') if c: print('zhen') else: print('jia')
执行结果:
综上我们来做一个小程序温习一下:
要求:写一个死循环, 注册用户,提示用户注册成功,如果已经存在则提示用户已经存在。
user=[] #d定义一个空列表 while True: username=input('请输入用户名:')#输入用户名 passwd=input('请输入密码:') #输入密码 if username in user: #判断输入的用户名是否存在在列表中 print('用户已经存在,请重新输入!') else: print('恭喜你,注册成功') #注册成功 user.append(username) #用户名添加到列表中
查看执行结果:
上面我们判断用户名是否存在,用了 in 进行判断,还可以用计数的方法判断,判断输入的用户名在列表中的个数,如果个数为0则说明输入的用户名不存在,可以注册成功。例如:
username=[] while True: name=input('请输入用户名:') passwd=input('请输入密码:') if username.count(name)==0: print('恭喜你注册成功!') username.append(name) else: print('用户已经存在,请重新输入!')
查看执行结果:
python自动化测试学习笔记-2-字典、元组、字符串方法
一、字典
Python字典是另一种可变容器模型,且可存储任意类型对象,如字符串、数字、元组等其他容器模型。
字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,格式如下所示:
f = {key1 : value1, key2 : value2 }
键必须是唯一的,但值则不必。
值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} print(d)
查看打印结果:可以看到字典里面的排序是无序的。
1、查看元素
如果我们要查看某个键值的值,把相应的键放入方括弧,字典没有下标,直接取key,例如:
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} print(d) print(d['name'])
执行查看结果:
还可以用get方法获取键值,例如:
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} print(d) print(d['name']) print(d.get('name'))
差看执行结果:
当get的键值不存在的时候会返回默认值:
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} print(d.get('weight'))
查看执行结果:
None
2、增加元素
如果需要增加元素就直接在方括号中写入key名,然后写入相应的值,例如:
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} d['phone']='13102011111111' print(d)
查看执行结果,加入了phone:
setdefault()方法和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default值,我们看一下和get的区别:
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} print(d.get('weight',120)) print(d) t={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} print(t.setdefault('weight',130)) print(t)
查看执行结果:
120
{'age': 12, 'name': 'pei', 'money': 19000, 'sex': '女', 'addr': '昌平'}
130
{'age': 12, 'name': 'pei', 'sex': '女', 'addr': '昌平', 'money': 19000, 'weight': 130}
可以看到,get的key不存在的时候,只会返回默认值,不会添加到字典中,setdefault的可以不存在的场合,会返回默认值,并把key 添加到字典中,并默认值赋值;
3、修改元素
如果需要修改字典中的键值,同样也是在方括号中写入已有的key值,然后写入相应的值,例如:
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} d['name']='yingfei' print(d)
查看执行结果:
4、删除字典元素
如果只需删除一个元素,可以用del命令:
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} del d['name']
查看执行结果:
{'addr': '昌平', 'money': 19000, 'sex': '女', 'age': 12}
如果需要清空字典表,用clear方法,例如:
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} d.clear() print(d)
查看执行结果:
{}
如果需要删除字典表,可以用del,例如:
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} del d print(d)
查看执行结果:
我们可以看到,d这个字典已经不存在了
和列表一样,还可以用pop()方法删除一个元素
删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} d.pop('name') print(d)
查看执行结果:
{'sex': '女', 'addr': '昌平', 'age': 12, 'money': 19000}
popitem()方法也可以用来删除,由于字典是无序的,所以popitem方法会随机删除字典中的一个元素,例如
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} d.popitem() print(d)
查看执行结果:
{'name': 'pei', 'age': 12, 'addr': '昌平', 'sex': '女'}
5、字典的其他方法
keys以列表形式返回一个字典所有的键;
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} print(d.keys())
执行结果:
dict_keys(['addr', 'name', 'sex', 'age', 'money'])
values,以列表返回字典中的所有值;
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} print(d.values())
查看执行结果:
dict_values(['女', '昌平', 12, 'pei', 19000])
6、循环
我们对字典进行循环操作,看一下得到的结果:
d={'name':'pei','age':12,'sex':'女','addr':'昌平','money':19000} for k in d: print(k) for k in d: print(k,d.get(k)) for k in d: print(k,d[k]) for k,v in d.items(): print(k,v) 查看执行结果: money name addr sex age 我直接对列表循环,我们得到的只有key; 要想得到key的value值,需要单独取获取; money 19000 name pei addr 昌平 sex 女 age 12 money 19000 name pei addr 昌平 sex 女 age 12
item方法,以列表返回可遍历的(键, 值) 元组数组,
money 19000 name pei addr 昌平 sex 女 age 12
练习:
下面我们看一下列表与字典的实际应用,通常情况下,两者都是结合使用的。例如:
stus = { 'pei': { 'age': 18, 'sex': '男', 'addr': '昌平区', 'money': 10000000, 'jinku': { '建行卡': 80000, '工商卡': 800000, '招商卡': 8000000 } }, 'li': { 'age': 19, 'sex': '女', 'addr': '昌平区', 'money': 10000000, 'huazhuangpin': ['chanle','haha'] }, 'wang': { 'age': 19, 'sex': '女', 'addr': '昌平区', 'money': 10000000, "bag": { 'lv': '一车', '鳄鱼':10 } }, }
以上,
1.我们要取到‘pei’的招商卡的金额:
print(stus['pei']['jinku']['招商卡'])
查看执行结果:8000000
2.我们要取到‘li’的化妆品种类
print(stus['li']['huazhuangpin'])
查看执行结果:['chanle', 'haha']
3.我们查看‘wang’的bag的种类:
print(stus['wang']['bag'].keys())
查看执行结果:dict_keys(['lv', '鳄鱼'])
4.如果我们查‘wang’的bag的总数量呢:
我们可以直接使用内置的函数sum(),如下:
print(sum(stus['wang']['bag'].values()))
查看执行结果:100
还可以用相加的方法:
ls=stus['wang']['bag'].values() sum=0 for i in ls: sum=sum+i print(sum)
查看执行结果:100
再来做一个小实验:
#####################################################
#用户注册:存入字典表中,注册时进行非空验证,,验证密码和确认密码是否一致,已经存在的不能重复注册
user={} while True: username=input('请输入您的账号:').strip() passwd=input('请输入您的密码:').strip() cpasswd=input('请确认您的密码:').strip() if username and passwd: if username in user: print('用户已经存在,请重新输入!') else: if passwd==cpasswd: print('恭喜您,注册成功!') user[username]=passwd break else: print('两次密码不一致,请重新输入!') else: print('用户名或密码不能为空!请重新输入。') while True: usr=input('请输入您的账号:').strip() pwd=input('请输入您的密码:').strip() if usr and pwd : if usr in user: if pwd==user[usr]: print('恭喜您登陆成功!') break else: print('密码不正确,请重新登陆!') else: print('用户名密码不存在,请重新登陆!') else: print('用户名或密码不能为空,请重新登陆')
大家执行一下看一下结果吧~
元组
Python的元组与列表类似,不同之处在于元组的元素不能修改。
元组使用小括号,列表使用方括号。元组与字符串类似,下标索引从0开始,可以进行截取,组合等。
1、创建
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
如下:
a=(1) b=('111','222','333')#元祖也是list,只不过不能变 print(a) print(b)
执行查看结果:
1
('111', '222', '333')
2、修改元组
元组中的元素值是不允许修改的:
b=('111','222','333') print(b) b[0]=12 print(b[0])
我们执行看一下,看到执行的结果报错了。
TypeError: 'tuple' object does not support item assignment
#可变变量:创建后可以修改
#不可变变量:一旦创建后,不能修改,如果修改只能重新定义,例如元祖和字符串
mysql2=('182.168.55.14',8080,'pei','123456')#不可变,防止被修改 print(mysql2.count('m'))#统计次数 print(mysql2.index('pei'))#下标位置
查看执行结果:
0
2
3、切片
元组的切片与列表切片类似,用:进行分割
b=('111','222','333','444') print(b[0:5:2])
查看执行结果:
('111', '333')
我们来做个小程序:
如果列表中的数除2取余数不为0的,则从列表中删除:
li=[1,1,2,3,4,5,6,7,8,9]
for i in li: if i%2!=0: li.remove(i) print(li)
运行以上程序,查看结果:
[1, 2, 4, 6, 8]
我们看到以上程序【1】没有被删除,那是因为我们直接修改了列表,进行了删除操作,当遇到第一个1时,进行了删除,列表变为[1,2,3,4,5,6,7,8,9],此时循环的角标变为1,取到的是2,略过了[1];
所以循环list的时候不能删除列表中的数据,角标会进行变化;
这个时候我们就需要拷贝一份新的列表进行循环:
li=[1,1,2,3,4,5,6,7,8,9] li2=li[:]#深拷贝,内存地址会变 li3=li#浅拷贝,内存地址不变 print(li2) print(li3) print(id(li)) print(id(li2)) print(id(li3)) for i in li2: if i%2!=0: li.remove(i) print(li)
查看执行结果:
[1, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 1, 2, 3, 4, 5, 6, 7, 8, 9]
13995656
13967944
13995656
[2, 4, 6, 8]
我们看到了,通过切片拷贝的内容和直接赋值的内容是一样的,但地址是不一样的。
我们叫做深拷贝和浅拷贝,深拷贝的时候删除原有列表的数据,不影响拷贝的列表。
字符串方法
下面列举字符串常用的方法
name=' {a} besttest best ' name1='a besttest best' name2=' a besttest best\n' name3='a.txt' name4=' A B C D, E F G ' name5='1234567677' print(name.strip())#默认去掉首尾的空格和换行 print(name) print(name1.rstrip('best'))#去掉右边指定的字符 print(name1.rstrip('t'))#去掉右边指定的字符 print(name1.lstrip('a'))#去掉左边指定的字符 print(name2.rstrip())#去掉右边的空格和换行 print(name2) print(name.count('e'))#计数 print(name.index('a'))#查找角标 print(name.replace('e','E'))#替换 print(name.format(a='test'))#格式化 print(name1.capitalize())#首字母大写 print(name1.center(30,'$'))#居中 print(name3.endswith('t'))#判断是以什么结尾的 print(name3.startswith('e'))#判断是以什么开头的 print(name1.expandtabs(16)) print(name1.find('w'))#找不到的时候会返回-1 print(name1.index('b'))#找不到的时候会报错 print(name1.upper())#把所有的小写字母变大写 print(name4.lower())#把所有的大写字母变小写 f={'name':'wang','age':13} d='{name}欢迎,his age is {age}' print(d.format_map(f))#字符串格式化,传进去的是字典 print(name.isdigit())#判断是否是数字 print(name.islower())#判断是否全是小写 print(name.isupper())#判断是否全是大写 print(name5.isalnum())#判断是否全是数字 print(name5.isalpha())#判断是否全是字母 print(name4.split())#分个字符串,默认以空格进行分割 print(name4.split(','))#以指定符号分割字符串 list=['a','b','c','d','e'] print('$'.join(list))#以指定字符链接列表中的字符串 s='asdasd asdasd asd asd asdasd a' print('0'.join(s))#链接字符串的的元素 list2=['a','b','c','d',1,2,3,4,5] #print('*'.join(list2))#int类型的不能进行拼接
大家可以自己试一下~ 文件读写
################################################## #文件读写 #读 r 打开文件没有指定模式,那么默认是读;r权限不能进行写文件操作,r+模式是读写模式,会追加写入的内容;r,r+文件不存在的时候会报错 #写 w w模式会清空原文件,w只能写,不能读; w+ 写读模式,会清空文件内容 #追加 a a+追加读写都可以,文件不存在的时候,会创建文件 file=open('test3','a+')#报GDK的错误,添加utf-8,打开文件 # file.write('hehe呵呵\n') # print(file.readlines())#读取文件的所有内容,并把内容写成list格式 # file.seek(0)#读操作以后,指针位置在末尾,再读就不会读出来 # print(file.readline())#读一行 st=['a','b','c','d'] #file.write(st)#write不能写入list,只能写入字符串 file.writelines(st)#写入一个可迭代的元素 file.seek(0) #print(file.readlines())# print(file.read())#已经读过一次,会自动识别已经读过的数据 # for i in file: # print(i) file.close()#关闭文件
#####################################################3 #高效读文件的方法 # fw=open('test2',encoding='utf-8') count=1 for f in fw: f=f.strip() stu_lst=f.split(',') print(stu_lst) #直接循环文件对象的话,循环文件里面的每一行 # fw.close()
python自动化学习笔记3-集合、函数、模块
文件操作
上次学习到文件的读写,为了高效的读写文件,我们可以用循环的方式,一行一行的进行读写操作,打开文件的方法是open的方法,打开文件执行完后还要进行关闭操作。
一般的文件流操作都包含缓冲机制,write方法并不直接将数据写入文件,而是先写入内存中特定的缓冲区。
正常情况下缓冲区满时,操作系统会自动将缓冲数据写入到文件中。
至于close方法,原理是内部先调用flush方法来刷新缓冲区,再执行关闭操作,这样即使缓冲区数据未满也能保证数据的完整性。
如果进程意外退出或正常退出时而未执行文件的close方法,缓冲区中的内容将会丢失。
所以我们通常用flush方法刷新缓冲区的,即将缓冲区中的数据立刻写入文件,同时清空缓冲区。如下:
f=open('www','a+',encoding='utf-8') f. f.write('hahah\n') f.flush() f.close()
还有一种打开文件的方式,可以自动关闭文件,防止open方式忘记手动关闭文件。
with open('aaa','a+',encoding='utf-8') as f: f.seek(0) f.write('haha\n') f.flush()
在 “with” 打开的代码块内,文件是打开的,而且可以自由读取。 然而,一旦Python代码从 “with” 负责的代码段退出,文件会自动关闭。
用with打开文件的时候可以打开多个,用逗号分开就好:
with open('aaa','a+',encoding='utf-8') as f,open('www','w',encoding='utf-8')as w: f.seek(0) f.write('haha\n') f.flush() w.write('再见你好!')
打开多个文件时,我们就可以对多个文件同时进行操作了。
在文件操作时可能会遇到需要下载图片或视频的内容,如果我们要下载一个网站的图片,进行保存,由于图片地址时http协议的,所以我们需要用到request处理HTTP的功能。
import requests url='https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1515432257731&di=feaf94121db96dc3e315f6c170e0d5a0&imgtype=0&src=http%3A%2F%2Fh.hiphotos.baidu.com%2Fzhidao%2Fpic%2Fitem%2F1e30e924b899a901934d50551d950a7b0208f55d.jpg' img=requests.get(url).content f=open('ooo.jpg','wb') f.write(img)
wb模式时文件的一种操作模式,wb代表以二进制的格式写文件,还有以下几种方式:
"rb" 以二进制读方式打开,只能读文件 , 如果文件不存在,会发生异常
"wb" 以二进制写方式打开,只能写文件, 如果文件不存在,创建该文件
如果文件已存在,先清空,再打开文件
"rt" 以文本读方式打开,只能读文件 , 如果文件不存在,会发生异常
"wt" 以文本写方式打开,只能写文件, 如果文件不存在,创建该文件
如果文件已存在,先清空,再打开文件
"rb+" 以二进制读方式打开,可以读、写文件 , 如果文件不存在,会发生异常
"wb+" 以二进制写方式打开,可以读、写文件, 如果文件不存在,创建该文件
如果文件已存在,先清空,再打开文件
实战练习:
用学过的知识完成下面的小程序:
将文件中的内容个别文字进行批量替换。
with open('ttt','a+',encoding='utf-8')as f: f.seek(0) content=f.read() new_content=content.replace('终于','还好') f.seek(0) f.truncate() f.write(new_content) f.flush()
上述方法我们直接取出所有内容,然后进行替换,清空源文件后再写入所有内容,这样的效率时不高的,文件小的时候还好,当文件有大量数据的时候,这种方法的效率就太低了。
我还可以用for循环的方式,进行逐行读取,逐行修改的方式,但在文件中我们没办法在原文件中取读完每一行就立马进行修改
所以可以分为以下几个步骤进行:
1、逐行高效读取文件,进行修改
2、将修改后的内容写入一个新的文件中
3、修改完成后删除原有文件
4、将新文件的名称修改为目标文件的名称
import os#导入文件操作模块 with open('ttt','r',encoding='utf-8')as f,open('new','a+',encoding='utf-8')as newf:#打开要修改的文件和一个新文件 for content in f:#遍历文件内容 new_content=content.replace('还好','终于')#替换文字 newf.write(new_content)#写入新文件 newf.flush()#立即刷新 os.remove('ttt')#删除原有文件 os.rename('new','ttt')#重命名文件
集合
在Python中集合set是基本数据类型的一种,它有可变集合(set)和不可变集合(frozenset)两种。创建集合set、集合set添加、集合删除、交集、并集、差集的操作都是非常实用的方法。
集合的一个特点是天生去重
创建集合:
s=set()#空集合 s2={'1','2','3','3','3'} list=[1,2,3,4,5,5,5,5,5,5] s3=set(list) #list 去重的话,需要循环取出比较 print(list) print(s2) print(s3)
查看执行结果:
[1, 2, 3, 4, 5, 5, 5, 5, 5, 5]
{'2', '3', '1'}
{1, 2, 3, 4, 5}
取集合的数据:
s2={'1','2','3','3','3'} #集合是无序的,没有办法通过下标来取数据 print(s2[2])
查看执行结果:
添加元素:
s2={'1','2','3','3','3'}
s2.add('5')#add方法可以添加一个元素
print(s2)
查看执行结果:
{'5', '2', '1', '3'}
如果想添加多个元素的话,可以用update
s2={'1','2','3','3','3'}
s2.update([7,8,9]) # 添加多个元素
print(s2)
执行查看结果:
{7, '2', 8, 9, '1', '3'}
删除元素:
删除元素可以用pop()随机删除一个元素:
s2={'1','2','3','4','8','9'} print(s2.pop()) print(s2)
查看执行结果:
2
{'9', '1', '8', '4', '3'}
集合的运算操作:
交集、并集、差集、子集、包含
s2={'1','2','3','5'}
s3={'1','2','3','4','8','9'}
#交集
print(s2.intersection(s3))#intersection
print(s2&s3)#&f符号是取交集
查看执行结果:
{'1', '3', '2'}
{'1', '3', '2'}
#并集 print(s2.union(s3))#union取并集 print(s2|s3)#|取并集
查看执行结果:
{'8', '3', '5', '2', '1', '4', '9'}
{'8', '3', '5', '2', '1', '4', '9'}
# #差集
print(s2.difference(s3))#S2中有,但是S3中没有的 print(s3.difference(s2))#s3中有,但是s2中没有的 print(s2-s3)#-代表差集,S2中有,但是S3中没有的 查看执行结果:
{'5'}
{'4', '8', '9'}
{'5'}
子集、包含关系:
s2={'1','2','3'} s3={'1','2','3','4','8','9'} print(s2.issubset(s3)) #S2是S3的子集 print(s3.issuperset(s2))#S3包含S2
查看执行结果
True
True
函数
函数是把一堆代码合到一起,变成一个整体,是一个方法或者功能的代码段,可以重复使用。
定义一个函数的规则:
- 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始,并且缩进。
- return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
定义一个函数,并调用:hello world!
def hello(): print('hello world!') hello() #函数的调用
查看执行结果:
hello world!
再来看一个实例:
def hello(): f=open('sss','a+') f.seek(0) f.write('www') f.close() hello()
查看执行结果:SSS文件中写入了www
参数传递
在 python 中,类型属于对象,变量是没有类型的
a=[1,2,3] a="Runoob"
以上代码中,[1,2,3] 是 List 类型,"Runoob" 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针),可以是 List 类型对象,也可以指向 String 类型对象。
实例:def hello(filename,content=''):#形参,形式参数 f = open(filename, 'a+',encoding='utf-8') #return #函数中添加return时,结束后边的代码 if content: f.seek(0) f.write(content) res='' else: f.seek(0) res=f.read() #return res return以后文件就不会被关闭了,所以要把return写到后边 f.close() return res print(hello('www','乒乒乓乓乒乒乓乓乒乒乓乓'))#实参,实际的参数 users=hello('aaa') print(users) 上述代码我们可以看到,当content为空或不为空的时候会有一个判断,一个用来读文件,一个用来写文件
形参,实参 #形参,位置参数也叫必填参数 #默认参数,定义是有一个默认值 #默认值参数是不必填的 #函数里边的变量只能在函数里边用,出了函数里边就不能用了,如果想获取到函数的处理结果,必须return #没有return的话,返回的是none,return是非必填的,需要返回值的时候再写 #函数中遇到return,函数运行结束 #所以return的两个作用:1、返回函数值,2、结束运行 可变参数,默认参数,扩展参数(不定长参数)
def test(a,b=1,*args):#b=1为默认参数,默认参数为非必填 print('a',a) print('b',b) print('args',args) test('hhh') test('aaa','222','22233','44444','5555')#位置调用,根据参数的位置指定 test(b=5,a=10)#关键字参数,关键字调用,与位置调用不能混用
查看执行结果: a hhh b 1 args () a aaa b 222 args ('22233', '44444', '5555') a 10 b 5 args () *args是可扩展参数,可扩展参数为非必填参数,会把多传的参数放到一个元祖中,可以自己定义名字。 参数为字典表的时候:
def test2(**kwargs):#keargs 字典 print(kwargs) test2(name='222',sex='eee')#kwargs方式必须用关键字调用的方法 def test3(a,**kwargs): print(a) print(kwargs) test3(a=10000,s='sss',d='ssss3')
查看执行结果: {'sex': 'eee', 'name': '222'} 10000 {'d': 'ssss3', 's': 'sss'} 全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。
如下实例:
a=100 #全局变量 def test(): a=5 #局部变量 print('函数内部:',a) def test2(): b=1 print(a)#获取的全局变量100 test() test2() print('函数外部',a)#直接打印的外部的全局变量
查看执行结果: 函数内部: 5 100 函数外部 100 如果函数内部要使用全局变量的话,可以单独进行声明:例如:
# d=100 def test(): global d#声明一下这是全局变量 print('libian',d) d=6 test() print('waibian',d)
查看执行结果: libian 100 waibian 6 我们看到函数内部因为生命了d为全局变量,所以执行的时候首先取全局变量d=100,然后对d进行了修改为d=6,所以全局变量变为6,再次打印的时候显示为6. 我们看一下下边这个例子:
money = 899 def test(consume): return money-consume def test1(money): return test(money)+test(money) money=test1(money) print(money)
可以先预计一下执行结果,money=test1(money),先调用test1,money=899,执行test1又会调用test,传参都是money,所以test执行后是0,test1执行是0+0=0; 我们执行一下看预期结果:0 #执行结果是0,预期正确 再看一下下边的例子:
def test(): global f f=5 print(f) def test1(): c=f+5 return c res=test1() print(res)
看上边的例子,有的朋友会预期,调用test1,c=f+5,f=5,所以结果应该是10,我们执行看一下结果:
从执行结果看到报错了,因为没有f没有定义,那是因为我们调用的时候只调用了test1,没有调用test,所以系统是不知道f的值的,只有调用的时候才会进行运算。 正确的是:
def test(): global f f=5 print(f) def test1(): c=f+5 return c test()#需要调用才会执行test,不调用不执行 res=test1() print(res)
查看执行结果:10 实例演练: 写一个小程序,校验输入的字符串是否是一个合法的小数。 分析:1、小数分为正小数和负小数:例3.3,-2.33 2、小数有且只有一个小数点 3、校验字符串就要先把输入的内容强制类型转换成字符串类型
def check_float(number): if number.count('.') == 1:#判断小数点的个数 num_left=number.split('.')[0]#以小数点为分割点 num_rigth=number.split('.')[1] if num_left.isdigit() and num_rigth.isdigit():#小数点左边和右边都是数字,则为正小数 print('您输入的是正小数') elif number.count('-')==1 and number.startswith('-'):#判断符号的个数,且以负号开头 if num_left.split('-')[1].isdigit() and num_rigth.isdigit():#小数点左边,负号右边都是数字,小数点右边都是数字 print('您输入的是负小数') else: print('您输入的不是小数') else: print('您输入的不是小数') else: print('您输入的不是小数!') str=input('请输入要校验的字符串:')#input输入的就是字符串类型 check_float(str)#调用函数
大家可以自己试一下执行一下结果。 递归 在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。 下面看一个例子:
def test1(): num =int(input('请输入数字:')) if num%2==0: return True else: print('不是偶数请重新输入:') return test1() test1()
上述代码,表达了输入一个数字,如果是偶数,返回True ,如果是计数再次调用test1,知道输入的是偶数返回True为止。这种我们就叫它递归函数。 递归函数的优点是定义简单,逻辑清晰。 但是使用递归函数需要注意防止栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧, 每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。递归最多调用999次; 比较两个字典的key和value:
######################################## #对比两个报文中不一样值 #1、循环第一个字典,取出key #2、拿第一个的key去第二个的字典中去取值 d1={'a':'1','b':'2'} d2={'a':'1','b':'3'} def compare(d1,d2): for key in d1: v1=d1.get(key) v2=d2.get(key) if v2: if v1==v2: pass else: print('两个值不一样,不一样的key:%s,v1的值:%s,v2的值:%s'%(key,v1,v2)) compare(d1,d2)
查看执行结果: 两个值不一样,不一样的key:b,v1的值:2,v2的值:3
判断对象的数据类型方法,可以用type()方法,如:
def print_var_type(var): if type(var)==str:#字符串类型 print('string') elif type(var)==dict:#字典类型 print('dict') elif type(var)==list:#列表类型 print('list') s={'name':'pei'} print_var_type(s)
执行查看结果:
dict
模块
在Python中用关键字import来引入某个模块,比如要引用模块math,就可以在文件最开始的地方用import math来引入。
如果需要调用模块中的函数的话,需要用 模块名.函数名 进行调用。
#一个python文件就是一个模块 #1、标准模块 # python自带的,不需要安装的 #2、第三方模块 # 别人写的,只要安装就能使用 #3、自己写的模块 # pip install radis #直接pip install 就可以 在 python安装目录下的scripts,加到环境变量中 #下载好安装包手动安装,解压,在命令行里边进入到解压后的目录,在执行python setup.py install #或者进入到目录中,shift+右键,在当前窗口打开命令,输入python setup.py install
例如上面的校验是否是小数的函数,存放在check.py文件中,如果需要直接调用函数,则需要导入这个模块,如下:
import cheak print(cheak.check_float('1.6'))
执行的话就会直接调用check中的check_float 函数。
#导入python文件的实质是从头到尾运行一次 # #import play #import 导入文件的时候是在当前目录下找文件, #当前目录找不到的话,从环境变量里面找 #环境变量就是让一个命令在任何目录下都能执行 #查看当前系统的环境变量目录 import sys print(sys.path)
实战演练:
需求:access.log日志
60S内同一个IP地址访问超过200次,IP加入黑名单
#60s读一次文件
#以空格切割,取第一个元素,获取到IP
#把IP地址存入list,如果大于200次,则加入黑名单
import time point = 0#文件指针 while True: ips=[]#空列表,用于存放所有IP bip = set()#定义一个空集合,用于存放需要加入黑名单的 with open('access.log') as f: f.seek(point) for line in f: ip=line.split()[0]#分割每一行,默认split是以空格分隔 ips.append(ip)#添加到list中 if ips.count(ip)>199:#判断 bip.add(ip) for i in bip:#bip为集合,存入的去重的ip print('已经把%s加入黑名单'%i) point=f.tell() time.sleep(60)
感谢每一个认真阅读我文章的人,看着粉丝一路的上涨和关注,礼尚往来总是要有的,虽然不是什么很值钱的东西,如果你用得到的话可以直接拿走:
① 2000多本软件测试电子书(主流和经典的书籍应该都有了)
② 软件测试/自动化测试标准库资料(最全中文版)
③ 项目源码(四五十个有趣且经典的练手项目及源码)
④ Python编程语言、API接口自动化测试、web自动化测试、App自动化测试(适合小白学习)
⑤ Python学习路线图(告别不入流的学习)
在我的QQ技术交流群里(技术交流和资源共享,广告进来腿给你打断)
可以自助拿走,群号550412533(备注“csdn999”)550412533(备注“csdn999”)群里的免费资料都是笔者十多年测试生涯的精华。还有同行大神一起交流技术哦。
————————————————