条件判断
1、单条件判断
1 # 接收输入的值，使用input函数,用input接收输入的值都是string类型的
2 age = input('请输入你的年龄：')
3 age = int(age) # 类型转换，转换成int类型
4 if age < 18:
5 print('未成年人')
6 else:
7 print('成年人')
2、多条件判断(and)
1 score = input('请输入你的成绩：')
2 score = int(score) # 类型转换，转换成int类型
3 if score >= 90:
4 print('优秀')
5 elif score >= 75 and score < 90:
6 print('良好')
7 elif score >= 60 and score < 75:
8 print('及格')
9 else:
10 print('不及格')
3、多条件判断(or)
1 sex = input('请输入你的性别：')
2 if sex == '男' or sex == '女':
3 print('性别合法')
4 else:
5 print('性别不合法')
循环
1、While循环
1 # 循环的时候是在重复执行循环体里面的东西
2 # 在循环体里面遇到break，立即结束循环，不管循环有没有完
3 # 在循环体里面遇到continue，那么就结束本次循环，继续进行下一次循环
4 # while循环对应一个else时，循环正常结束之后才会执行它
5 import random
6 num = random.randint(1,100) # 随机产生一个1-100之间的数
7 print(num)
8 count = 0 # 计数器
9 while count <3:
10 guess = input('请输入你要猜的数字:')
11 guess = int(guess)
12 if guess > num:
13 print('猜大了')
14 # continue # 这里用了continue后，后面的count就不会+1了，所以这里不能用
15 elif guess < num:
16 print('猜小了')
17 else:
18 print('猜对了')
19 break
20 count = count + 1
21 else:
22 print('游戏结束了')
2、For循环
#for循环可以对随机数、字符串、数组、字典等 #for循环在循环可迭代对象的时候，每次循环的是里面的每一个元素 #字符串循环的是每一个字符，包括任何字母、符号及空格 #循环一个字典的话，循环的是字典的key
1 # 循环数字
2 import random
3 num = random.randint(1,100) # 随机产生一个1-100之间的数
4 print(num)
5 count = 0 # 计数器
6 for i in range(3):
7 guess = input('请输入你要猜的数字:')
8 guess = int(guess)
9 if guess > num:
10 print('猜大了')
11 continue # 这里用不用continue都可以
12 elif guess < num:
13 print('猜小了')
14 else:
15 print('猜对了')
16 break
17 else:
18 print('游戏结束了')
1 # 循环数组
2 sites = ["Baidu", "Google","Taobao","Runoob"]
3 for site in sites:
4 if site == "Runoob":
5 print("菜鸟教程!")
6 break
7 else:
8 print("循环数据:"+ site)
9 else:
10 print("没有循环数据!")
11 print("完成循环!")
字符串格式化
1、第一种方式
1 import datetime
2 today = datetime.date.today()
3 username = input('请输入用户名：')
4 welcome = '欢迎光临：' + username+ '，今天的日期是：' + str(today) # 第一种方式
5 print(welcome)
2、第二种方式（占位符）
1 # %s字符串 %d整数 %.2f两位小数
2 username = input('请输入用户名：')
3 age = 18
4 score = 99.2
5 info = '你的用户名是：%s,年龄是：%d,成绩是：%.2f'%(username,age,score) # 占位符
6 print(info)
3、第三种方式（format）
1 import datetime
2 today = datetime.date.today()
3 username = '牛牛'
4 welcome = '欢迎光临：{username},今天的日期是：{today}'.format(username=username,today=today)
5 print(welcome)
数组
1、定义数组
1 city = [] # 定义一个空数组 2 name = ['Jack','Panda','Bob','Franck'] 3 # 根据下标找元素，最前面一个元素的下标是0，最后一个元素下标是-1 4 print(name[2]) 5 print(name[-1])
2、增加元素
1 city = [] # 定义一个空数组
2 city.append('北京') #在列表末尾增加一个元素
3 city.insert(0,'上海') #在指定的位置增加元素
3、修改元素
1 city = ['北京','上海','天津'] 2 city[1] = '南京' # 修改下标为1的元素为南京，如果指定的下标不存在，会报错
3 city[1:] = ['天津','广州'] # 同时修改list中的多个元素
4、删除元素
1 city = ['上海', '北京', '深圳'] 2 city.pop(-1) # 指定下标删除元素 3 del city[1:] # 指定下标删除元素，可以删除单个和多个元素（使用切片）
4 city.remove('上海') # 删除指定的元素 5 city.clear() # 清空list
5、查询元素
1 city = ['上海', '北京', '深圳','深圳']
2 print(city[0]) # 指定位置
3 print(city.index('深圳')) # 获取元素的下标，如果找不到元素，会报错。如果list存在多个相同元素，返回的是第一个元素的下标
4 print(city.count('深圳')) # 查看元素在list里面出现了多少次
6、反转
1 my_list = ['python','jmeter','charles','postman'] 2 my_list.reverse() # 把原来的list反转一下，但不返回任何东西 3 print(my_list)
7、排序
1 nums = [22,11,5,77,99,3,7,8,9,10] 2 nums.sort() # 升序 3 nums.sort(reverse = True) # 降序 4 print(nums)
8、合并数组
1 nums1 = [22,11,5,77,99,3,7,8,9,10] 2 nums2 = ['f','e','b','h','i','q','p','k','v','c'] 3 print(nums1 + nums2) 4 nums1.extend(nums2) # 把nums2数组中的元素传到数组nums1当中 5 print(nums1)
9、复制数组
1 nums1 = [22,11,5,77,99,3,7,8,9,10] 2 nums2 = ['f','e','b','h','i','q','p','k','v','c'] 3 print(nums1*2) 4 print(nums2*3)
10、数组练习
1 # 校验用户名是否合法
2 # (1)输入用户名
3 # (2)如果用户名存在，提示已经被注册，如果不存在，就可以注册
4 # (3)用户名不能为空
5 # (4)用户名长度在3-12之间
6 # (5)最多输入3次
7 all_user = ['张慧茹','牛寒阳','李妮娜','郑陶娜']
8 for i in range(3):
9 username = input('请输入用户名：').strip()
10 if len(username) > 2 and len(username) < 13:
11 if username in all_user:
12 print('用户名已经被注册')
13 else:
14 all_user.append(username)
15 print(all_user)
16 print('注册成功')
17 break
18 else:
19 print('用户名长度不合法')
20 else:
21 print('错误次数过多')
11、切片
1 # 切片：是list取值的一种方式 2 nums = ['段佳琳','陈伟良','王占宇','李波','韶钢'] 3 print(nums[1:3]) # 顾头不顾尾，不包含后面下标的元素 4 print(nums[1:]) # 从某个下标开始取，取到末尾，末尾的下标可以省略不写 5 print(nums[:2]) # 从头开始取，取到后面某个下标结束（不包括该下标的元素），开头的下标可以不写 6 print(nums[:]) # 取所有的元素
切片操作同样适用于字符串，如下：
1 info = '你好，今天天气很好' 2 print(info[2:6:1]) 3 s = 'San Francisco' 4 print(s[0]) 5 print(s[::-1])
12、步长
1 # 步长，隔几个取一次 2 lis = list(range(1,21)) # 产生一个从1~20的一个数组 3 print(lis) 4 # 如果步长是正数，从左往右开始取值 5 print(lis[::2]) 6 print(lis[0:10:2]) 7 # 如果步长是负数，从右往左开始取值 8 print(lis[::-2]) # 步长，隔个几个取一次 9 print(lis[::-1]) # 反转list，产生了一个新的list，不会改变原来list的值，与reverse不同 10 print(lis) 11 # -1倒序，从下标为1的元素'2'从右往左取值，因结尾没有取值，所以取到下标为0的元素 12 print(lis[1::-1]) 13 # -1倒序，开头没有取值，所以默认从20往左取值，取到下标为18的元素‘19’，但不顾尾，所以19不取 14 print(lis[:18:-1])
13、list循环
1 # for循环在循环可迭代对象的时候，每次循环的是里面的每一个元素 2 lists = ['段佳琳','陈伟良','王占宇','李波','韶钢',[1,2,3,4]] 3 for name in lists: 4 print(name) 5 for name in lists: 6 if type(name) == list: # 判断变量的类型是否为list类型 7 for i in name: 8 print(i) 9 print(name) 10 11 # 字符串循环的是每一个字符，包括任何字母、符号及空格 12 words = 'marry,lily,joker' 13 for name in words: 14 print(name)
14、数组练习
1 # 统计出所有已交和未交作业的名字及人数
2 stus = [
3 ['小明','未交'],
4 ['小白','已交'], ['小紫','已交'],
5 ['小红','未交'], ['小绿','未交'],
6 ['小黄','未交'], ['小黑','已交']
7 ]
8
9 pass_list = [] #已交
10 fail_list = [] #未交
11 for stu in stus:
12 name = stu[0]
13 status = stu[1]
14 if status == '已交':
15 pass_list.append(name)
16 else:
17 fail_list.append(name)
18 print('已交作业的人为：%s，总共有%s人'%(pass_list,len(pass_list)))
19 print('未交作业的人为：%s，总共有%s人'%(fail_list,len(fail_list)))
15、元组
1 # 元组也是一个list，它和list的区别是：元组里面的元素无法修改
2 t = (1,2,3,4,5,6,7)
3 print(type(t)) #查看变量类型
4 print(t[:3]) #切片
5 print(t[1]) #下标取值
6
7 # 元组的元素是不能修改的，一般用于定义数据库连接等不能修改的数据，如下：
8 lists = (
9 '192.168.0.1',
10 'root',
11 '123456',
12 '3306',
13 'niuhanyang')
14
15 # 如果元组里面只有一个元素，那么必须在这个元素后面加一个逗号
16 t = (1,2,3,4,5,6,7,2)
17 words=(1,)
18 words2=('abc',)
19 print(type(words))
20 print(type(words2))
21 print(t.index(2)) # 找到元组的下标,如果有多个相同的元素，返回的是第一个元素的下标
22 print(t.count(2)) # 找到元素的个数
字典
1、特点
1 取数据方便
2 速度快
3 key-value格式，类似Jason格式
4 infos = {'name':'Jack','sex':'男','age':'22','addr':'地球'}
2、查询元素
1 # 通过key查询value
2 infos = {'name':'Jack','sex':'男','age':'22','addr':'地球'}
3 print(infos.get('name'))
4 print(infos.get('phone')) # 取不到key的话，返回None
5 print(infos.get('name',110)) # 能取到key，后面的110不生效
6 print(infos.get('phone',110)) # 取不到key的话，默认返回110
7 print(infos['name'])
8 print(infos['phone']) # 如果key不存在，会报错
3、增加元素
1 # 增加元素
2 infos = {'name':'Jack','sex':'男','age':'22','addr':'地球'}
3 infos['Phone'] = 12877619908 # 增加一个key
4 infos.setdefault('家乡','深圳')
5 infos.setdefault('家乡','广东') # 如果key存在的话，不会修改原来key的值
6 print(infos)
4、 修改元素
# 修改元素
infos = {'name':'Jack','sex':'男','age':'22','addr':'地球'}
infos['addr'] = 'guangdong' # key存在时，修改原来key的值，key不存在时，添加元素
print(infos)
5、删除元素
1 # 删除元素
2 infos = {'name':'Jack','sex':'男','age':'22','addr':'地球'}
3 infos.pop('addr') # 指定key删除
4 del infos['name'] # 指定key来删除
5 infos.popitem() # 随机删除一个key
6 infos.clear() # 清空字典
6、合并字典
1 a = {"K1":"V1"}
2 b = {"K2":"V2"}
3 a.update(b) #将b字典的元素加入到a字典里面
4 print(a)
7、字典常用方法
1 infos = {'name':'Jack','sex':'男','age':'22','addr':'地球'}
2 infos.keys() # 获取到字典所有的key
3 infos.values() # 获取到字典所有的value
4 infos.items() # 获取到字典所有的key-value
9、循环字典
1 people = {
2 '天宇':18,
3 '张萌':20,
4 '任钱':35
5 }
6 # 直接循环一个字典的话，循环的是字典的key
7 for p in people:
8 print(p)
9 # 循环的时候，同时取key和value
10 for k,v in people.items():
11 print(k,'===>',v)
10、练习：注册小程序
1 # 字典小练习:注册小程序
2 # （1）使用字典存放所有的账号和密码
3 # （2）用户名和密码不能为空
4 # （3）判断用户名是否已注册
5 # （4）判断两次输入的密码是否一致
6 # （5）注册成功将用户名和密码写入字典
7
8 users = {
9 'niuhanyang':'123456',
10 'jack':'456789',
11 'tony':'135790'
12 }
13 username = input('请输入用户名：').strip()
14 passwd = input('请输入密码：').strip()
15 cpasswd = input('请输入密码：').strip()
16 if username not in users:
17 if username != '' and passwd != '' and cpasswd != '':
18 if passwd == cpasswd:
19 users[username] = passwd
20 print(users)
21 print('注册成功')
22 else:
23 print('两次密码输入不一致')
24 else:
25 print('用户名或密码不能为空')
26 else:
27 print('该用户已存在')
常用字符串方法
1、常用字符串方法
1 a = '
字 符 串
'
2 b = a.strip() # 默认去掉字符串两边的空格和换行符
3 c = a.lstrip() # 默认去掉字符串左边的空格和换行符
4 d = a.rstrip() # 默认去掉字符串右边的空格和换行符
5
6 words1 = 'day is a wonderful day'
7 words2 = 'http://baidu.COM'
8 print(words1.strip('day')) # 如果strip方法指定一个值的话，那么会在字符串两边去掉这个值
9 print(words1.count('day')) # 统计字符串出现的次数
10 print(words1.index('w')) # 找下标，如果元素找不到的话，会报错
11 print(words1.find('w')) # 找下标，如果元素找不到的话，返回-1
12 print(words1.replace('day','DAY')) # 替换字符串
13 print(words2.startswith('http')) # 判断是否以某个字符串开头
14 print(words2.endswith('.COM')) # 判断是否以某个字符串结尾
15 print(words2.upper()) # 把字符串的所有字母变成大写的
16 print(words2.lower()) # 把字符串的所有字母变成小写的
17 print('欢迎光临'.center(20,'*')) # 欢迎光临居中，以*号补齐20的长度
18
19 username = 'aaaaa123'
20 print(username.isalpha()) # 判断字符串是否全为汉字或字母，组合和单个都返回True
21 print(username.isalnum()) # 判断字符串是否全为汉字或字母或数字，组合和单个都返回True
22 print(username.isdigit()) # 判断字符串是否全为数字
23 print(username.isupper()) # 判断字符串是否全为大写字母
24 print(username.islower()) # 判断字符串是否全为小写字母
2、常用字符串方法补充
1 # 连接字符串join
2 # 把list变成了字符串
3 # 通过某个字符串把list里面的每个元素连接起来
4 # 只要是可以循环的，join都可以帮你连起来（字符串/list/字典/元组都可以）
5 s = ['张流量','田雨农','牛牛','安大叔']
6 res = '：'.join(s) # 通过冒号把s当中的每个元素连接起来
7 print(res)
8
9 import string
10 print(string.ascii_lowercase) # 所有小写字母
11 print(string.ascii_uppercase) # 所有大写字母
12 print(string.ascii_letters) # 所有字母（包括大写和小写）
13 print(string.digits) # 所有数字
14 print(string.punctuation) # 所有特殊字符
15 res = '：'.join(string.ascii_lowercase) # 通过冒号把所有小写字母连接起来
16 res = ''.join(string.ascii_lowercase) # 单引号中什么都没有的话直接把所有元素连起来
17 print(res)
18
19 # 分割字符串split
20 # 根据某个字符或字符串分割字符串,返回的是一个list
21 names = 'niuhanyang,zch, caoran,yangyafei'
22 name_list1 = names.split(',') # 以逗号分割字符串
23 name_list2 = names.split() # split中什么也不传的话，是以空格分割
24 print(name_list1)
25 print(name_list2)
26
27 # format格式化方法
28 user = '张流量'
29 sex = '女'
30 age = '25'
31 addr = '广东'
32 money = '10000'
33 cars = '1000台'
34 sqla = 'insert into user values("%s","%s","%s","%s","%s","%s");'%(user,sex,age,addr,money,cars)
35 print(sqla)
36 # format中的字段不必根据sqlb中的字段顺序来写，顺序可以随便写，一一对应上就可以
37 sqlb = 'insert into user values("{user}","{sex}","{age}","{addr}","{money}","{cars}");'
38 new_sql = sqlb.format(age=age,cars =cars,user=user,sex=sex,money=money,addr=addr)
39 print(new_sql)
集合
1、简介
- 集合也是一种数据类型，一个类似列表东西，它的特点是无序的，不重复的，也就是说集合中是没有重复数据的。
2、集合的作用
- 它可以把一个列表中重复的数据去掉，而不需要你再写判断
- 可以做关系测试，比如说有两个班，一个性能测试班，一个是接口测试班的，想找出来既学习了性能又学习了接口测试的同学，就可以用集合。
3、定义集合
1 # 集合：天生去重，集合是无序的
2 list = [2,3,1,2,3,4]
3 s1 = set() # 定义空集合
4 s2 = set('aaee1122') # 集合会把重复数据去掉
5 s3 = set(list) # 把list转换成一个集合
6 s4 = set([2,3,1,2,3,4]) # 这种方式和上面的都是把list转换成一个集合
7 s5 = {1,2,1,4,2,5,7} # 这种方式直接定义一个集合
4、集合相关操作
1 s = {1,2,3,4,5,6,7}
2 s.add(9) # 加元素
3 s.pop() # 随机删除一个元素
4 s.remove(7) # 指定删除哪个元素
5 s.update({11,12,13}) # 把另外一个集合加到s集合中去
5、交集
1 s1 = set('aaee1122')
2 s2 = {'1','2','1','4','2','5','7'}
3 print(s1 & s2) # 取交集
4 print(s1.intersection(s2)) # 取交集
5 print(s1.isdisjoint(s2)) # 判断s1和s2是否有交集，如果没有交集，返回True，有交集则返回False
6、并集
1 # 并集：把两个集合合并到一起，去重
2 s1 = set('aaee1122')
3 s2 = {'1','2','1','4','2','5','7'}
4 print(s1 | s2) # 取并集
5 print(s1.union(s2)) # 取并集
7、差集
1 # 差集：去掉前面的集合中两个集合都有的元素并去重
2 s1 = set('aaee1122')
3 s2= {'1','2','1','4','2','5','7'}
4 print(s1 - s2)
5 print(s1.difference(s2))
8、对称差集
1 # 对称差集：去掉两集合里面都有的，然后合并两个集合并去重
2 s1 = set('aaee1122')
3 s2 = {'1','2','1','4','2','5','7'}
4 print(s1 ^ s2)
5 print(s1.symmetric_difference(s2))
9、练习
1 # 校验密码里面是否包含数字、大写字母、小写字母和特殊符号
2 import string
3 num_set = set(string.digits)
4 upper_set = set(string.ascii_uppercase)
5 lower_set = set(string.ascii_lowercase)
6 pum_set = set(string.punctuation)
7 for i in range(3):
8 pwd = input('请输入密码：').strip()
9 pwd_set = set(pwd)
10 if pwd_set & num_set and pwd_set & upper_set and pwd_set & lower_set and pwd_set & pum_set:
11 print('密码输入合法')
12 break
13 else:
14 print('密码不合法，密码必须包含数字、大写字母、小写字母和特殊字符')
15 else:
16 print('错误次数超限')
文件操作
1、打开文件的模式
1 r，只读模式（默认）【不可写；文件不存在，会报错】 2 w，只写模式【不可读；不存在则创建；存在则删除内容】 3 a，追加模式【不可读；不存在则创建；存在则追加内容】 4 r+，读写模式【可读、可写、可追加，如果打开的文件不存在的话，会报错】 5 w+，写读模式【使用w+的话，已经存在的文件内容会被清空，可以读到已经写的文件内容】 6 a+，追加读写模式【不存在则创建；存在则只追加内容；】
2、文件基本操作
1 # 打开文件(python默认字符集为utf-8，windows为gbk，所以要指定encoding='utf-8')，不输入模式默认为r模式
2 m = open('words',encoding='utf-8')
3 print(m.read()) # 读文件
4 print(m.readline()) # 读取第一行
5 print(m.readlines()) # 把文件的每一行放到一个list里面
3、文件操作方法
1 f = open('words','r+',encoding='utf-8') # encoding参数可以指定文件的编码
2 f.readline() # 读一行
3 f.readable() # 判断文件是否可读
4 f.writable() # 判断文件是否可写
5 f.encoding # 打印文件的编码
6 f.read() # 读取所有内容，大文件时不要用，因为会把文件内容都读到内存中，内存不够的话，会把内存撑爆
7 f.readlines() # 读取所有文件内容，返回一个list，元素是每行的数据，大文件时不要用，原因和上面一样
8 f.tell() # 获取当前文件的指针指向
9 f.seek(0) # 把当前文件指针指向哪
10 f.write('爱情证书') # 写入内容
11 f.flush() # 写入文件后，立即从内存中把数据写到磁盘中
12 f.truncate() # 清空文件内容
13 f.writelines(['爱情证书','孙燕姿']) # 将一个列表写入文件中
14 f.close() # 关闭文件
4、大文件读取高效操作方法
用上面的read()和readlines()方法操作文件的话，会先把文件所有内容读到内存中，这样的话，内存数据一多，非常卡，高效的操作，就是读一行操作一行，读过的内容就从内存中释放了，如下：
1 # 这样的话，line就是每行文件的内容，读完一行的话，就会释放一行的内存
2 f = open('words',encoding='utf-8')
3 for line in f:
4 print(line)
5、文件指针
1 # 用来记录文件读到哪里
2 # a模式的文件指针是在末尾的
3 m = open('name','a+',encoding='utf-8')
4 m.write('呃呃呃')
5 m.seek(0) # 移动文件指针到最前面
6 print(m.read())
7 m.write('呵呵呵') # 移动完文件指针之后，从前面开始读，但写的时候还是在文件末尾写
8 m.seek(0)
9 print(m.read())
6、自动关闭文件
在操作文件的时候，经常会忘了关闭文件。可以使用with，它会在使用完这个文件句柄之后，自动关闭该文件，使用方式如下：
1 # 打开一个文件，把这个文件的句柄付给f
2 with open('file.txt', 'r') as f:
3 for line in f:
4 print(line)
5
6 # 这是多文件的操作，打开两个文件，fr是读file.txt，fw是新建一个file_bak文件
7 with open('file.txt') as fr,open('file_bak', 'w') as fw:
8 for line in fr: # 循环file.txt中的每一行
9 fw.write(line) # 写到file_bak文件中
7、修改文件
修改文件有两种方式：
- 一种是把文件的全部内容都读到内存中，然后把原有的文件内容清空，重新写新的内容
- 第二种是把修改后的文件内容写到一个新的文件中
第一种方式：
1 with open('words','r+',encoding='utf-8') as fr:
2 res = fr.read() # 读出文件中的全部内容
3 new_res = res.replace('花','flower') # 将'花'替换成'flower'
4 fr.seek(0) # 将文件指针指向文件最开头
5 fr.truncate() # 清空文件
6 fr.write(new_res) # 将替换后的内容写入文件
第二种方式：
1 # 这个是多文件的操作，打开两个文件，fr是读file.txt，fw是新建一个file_bak文件
2 import os
3 with open('file') as fr,open('new_file','w') as fw:
4 for line in fr: # 循环file.txt中的每一行
5 new_line = line.replace('花','flower')
6 fw.write(new_line) # 写到file_bak文件中
7 os.remove('file') # 删除文件
8 os.rename('new_file','file') # 改名
8、f.write()和f.writelines()
1 # f.write()只能写字符串
2 a = ['abc
','123
','!@#']
3 f = open('name','w')
4 for i in a:
5 f.write(i)
6
7 # f.writelines()会循环把list当中的元素写入文件
8 a = ['abc
','123
','!@#']
9 f = open('name','w')
10 f.writelines(a)
9、练习
（1）随机产生手机号，输入多少个就产生多少个
import random
start_num = '1387691'
f = open('test.txt','w',encoding='utf-8')
num = input('请输入要产生的手机号个数：')
for i in range(int(num)):
random_num = str(random.randint(1,9999)) # 随机产生一个1-9999的数字
new_num = random_num.zfill(4) # 不够四位，前面补0
phone_num = start_num + new_num
f.write(phone_num + '
')
f.close()
（2）监控日志，一分钟读一次日志文件，如果一分钟之内访问博客的IP地址超过50次，就把这个IP记录下加入黑名单
1 # 分析：
2 #打开日志文件
3 #把ip地址拿出来
4 #判断每一个ip出现的次数，如果大于50次，记录下来，加入黑名单
5 #每分钟读一次
6 import time
7 point = 0
8 while True:
9 all_ips = [] #存放所有的IP地址
10 f = open('access.log',encoding='utf-8')
11 f.seek(point) #移动文件指针
12 for line in f: #直接循环一个文件对象，每次循环的是文件的一行
13 ip = line.split()[0] #拿到IP地址
14 all_ips.append(ip) #把它存入数组当中
15 point = f.tell() #记录指针位置
16 all_ip_set = set(all_ips)
17 for ip in all_ip_set: #循环集合当中的IP，没有重复的
18 if all_ips.count(ip) > 50: #判断的是数组当中的IP
19 print('攻击的ip是：%s'%ip)
20 f.close()
21 time.sleep(2)
函数
一、函数是什么：
函数是指将一组语句的集合通过一个名字（函数名）封装起来，要想执行这个函数，只需要调用函数名就行。
二、函数的作用：
1、简化代码
2、提高代码的复用性
3、代码可扩展
三、定义函数：
1 def SayHello(): #函数名
2 print('Hello')#函数体
3 SayHello() #调用函数，函数不调用是不会被执行的
四、函数的参数
位置参数：必填参数
1 def calc(a,b): #形参，形式参数
2 res = a * b
3 print('%s * %s = %s'%(a,b,res))
4 calc(8.9,2.7) #实参，实际参数
默认值参数：非必填参数
1 # 操作文件函数（读和写）
2 def op_file(file_name,conent=None): #conent为写的内容
3 f = open(file_name,'a+',encoding='utf-8')
4 f.seek(0)
5 if conent: #conent不为空代表写入文件
6 f.write(conent)
7 f.flush()
8 else: #conent为空时读文件
9 all_users = f.read() #函数里面定义的局部变量只能在函数里面用
10 return all_users #调用完函数之后，返回什么结果
11 f.close()
12 # 把函数返回的结果存入变量
13 res = op_file('a.txt')
14 print(res)
非固定参数（参数组）：
1、非必填参数
2、不限定参数个数
3、把所有参数放到一个元组里面
1 def syz(*args): #参数组
2 print(args)
3 username = args[0]
4 pwd = args[1]
5 age = args[2]
6 syz()
7 syz('niuniu','123')
8 syz('niuniu','niuniu','test')
9 def syz2(a,*args):
10 print(a)
11 username = args[0]
12 pwd = args[1]
13 age = args[2]
14 syz2()
15 syz2('niuniu','123')
16 syz2('niuniu','niuniu','test')
关键字参数：
1、非必填参数
2、不限定参数个数
3、把所有参数放到一个字典里面
1 def syz(**kwargs):
2 print(kwargs)
3 syz()
4 syz(name='niuniu',age=23)
5 syz(name='niuniu',age=23,add='回龙观',home='河南')
6 def syz2(time,**kwargs):
7 print(kwargs)
8 syz2('20180418')
9 syz2(name = 'niuniu',age = 23,time = '20180418')
10 syz2('20180418',name = 'niuniu',age = 23,add = '回龙观',home = '河南')
五、全局变量
1、不安全，所有人都能改
2、全局变量会一直占用内存
1 name = '牛牛' #全局变量
2 def sayName():
3 global name #如果需要修改全局变量，需要先声明
4 name = '刘伟'#局部变量
5 print('name1:',name)
6 sayName()
7 print('name2:',name)
六、递归函数：函数自己调用自己
1、少用递归
2、递归最多调用999次，效率不高
1 def test():
2 num = int(input('please enter a number：'))
3 if num % 2 == 0:#判断输入的数字是不是偶数
4 return True #如果是偶数的话，程序就退出了，返回True
5 print('不是偶数请重新输入！')
6 return test() #如果不是偶数的话继续调用自己，输入值
7 print(test()) #调用函数
七、函数返回多个值
1 # 定义一个函数返回多个值 2 def say(): 3 num1 = 1 4 num2 = 2 5 num3 = 3 6 return num1,num2,num3 7 # 函数返回多个值会把它放到一个元组里面 8 print(say()) 9 # 函数如果返回多个值，可以用多个变量来接收 10 res1,res2,res3 = say() 11 print(res1) 12 print(res2) 13 print(res3)
内置函数、列表生成式、三元表达式
一、内置函数
所谓内置函数就是Python自带的函数
1 print(all([0,2,3,4])) #判断可迭代的对象里面的值是否都为真
2 print(any([0,1,2,3,4])) #判断可迭代的对象里面的值是否有一个为真
3 print(bin(10)) #十进制转二进制（0b1010：ob代表二进制，10的二进制是1010）
4 print(bool('a')) #把一个对象转换成布尔类型(非空即真，非0即真)
5 print(callable('aa')) #判断传入的对象是否可调用
6 print(chr(66)) #取数字对应的ascii
7 print(ord('B')) #取字符串对应的ascii码
8 print(dict(a=1,b=2)) #转换字典
9 print(dir('a')) #打印传入对象的可调用方法
10 print(eval('1+1')) #执行python代码，只能执行简单的，定义数据类型和运算
11 print(exec('def a():pass')) #执行python代码
12 print(filter(lambda x:x>5,[12,3,12,2,1,2,35]))#把后面的迭代对象根据前面的方法筛选
13 print(map(lambda x:x>5,[1,2,3,4,5,6]))
14 print(frozenset({1,2,3,3})) #定义一个不可修改的集合
15 print(globals()) #返回程序内所有的变量，返回的是一个字典
16 print(locals()) #返回局部变量
17 print(hash('aaa'))#把一个字符串哈希成一个数字
18 print(hex(111)) #数字转成16进制
19 print(max(111,12))#取最大值
20 print(min(111,12))#取最小值
21 print(abs(-10)) #取绝对值
22 print(oct(111)) #把数字转换成8进制
23 print(round(1.215,2))#取几位小数
24 print(sorted([2,31,34,6,1,23,4]))#排序
内置函数zip
把多个list组合到一起变成一个二维数组
1 list1 = ['a', 'b', 'c', 'd', 'f', 'g']
2 list2 = [1, 2, 3]
3 list3 = ['!', '#', '%', '*']
4 list4 = ['A', 'B', 'C', 'D', 'E']
5 # zip是把多个list组合到一起变成一个二维数组
6 print(list(zip(list1, list2, list3, list4)))
7 # 如果list长度不一样，则循环次数以元素少的list为准
8 for a, b, c, d in zip(list1, list2, list3, list4):
9 print(a, b, c, d)
内置函数map
自动循环调用函数
1 def my(num):
2 return str(num)
3 lis = [1,2,3,4,5,6,7,8,9]
4 # 将lis中的每个元素作为函数my的入参调用函数
5 res = list(map(my,lis)) # 将对象强制转换成list
6 print(res)
7 # 和以下代码功能一样
8 new_lis = []
9 for i in lis:
10 new_lis.append(my(i))
11 print(new_lis)
内置函数filter
同样是循环调用函数
1 def even(num):
2 if num % 2 == 0:
3 return True
4 else:
5 return False
6 lis = [1, 2, 3, 4, 5, 6, 7, 8, 9]
7 # filter只保留结果返回为真的list中的元素
8 res1 = list(filter(even, lis))
9 # 函数返回什么就保存什么
10 res2 = list(map(even, lis))
11 print(res1)
12 print(res2)
二、匿名函数
函数的功能很简单，只需要用一次
1 res = lambda x:x+1 #冒号后面的是函数的函数体，冒号前面的是返回值 2 print(res(2))
三、字典排序
1 dic = {'a':'2','b':'1','c':'3'}
2 res1 = sorted(dic.items(),key=lambda x:x[0]) #根据字典的key排序
3 res2 = sorted(dic.items(),key=lambda x:x[1]) #根据字典的value排序
4 print(sorted(dic.items())) # 后面不指定key和value则默认按照key排序
5 print(res1)
6 print(res2)
四、列表生成式
1 k = [i for i in range(1,101,2)] #生成100以内的奇数，放入一个list里面 2 print(k)
1 import random 2 red_num = random.sample(range(1,34),6) 3 new_num = [] 4 new_num = [str(num).zfill(2) for num in red_num] 5 # 以下代码和上面的列表生成式效果一样 6 for num in red_num: 7 tmp = str(num).zfill(2) 8 new_num.append(tmp)
五、三元表达式
1 a = 5 2 b = 4 3 c = a if a > b else b 4 # 相当于： 5 if a > b: 6 c = a 7 else: 8 c = b
异常处理
一、为什么要进行异常处理
程序在运行过程中，可能会遇到各种各样的错误，程序一旦出错，就会停止运行。为了让程序能够正常运行完，就需要捕捉异常，通过对捕捉到的异常做对应的处理，来保证程序正常运行。
二、捕捉所有异常
1、try：捕捉这段代码的异常
2、except Exception：捕捉所有异常
3、else：没有出错则执行else下面的代码，但else不写也可以
4、finally：无论是否有异常，都会执行finally下面的代码，它也可以不写
1 # 异常处理
2 first = input('first:')
3 second = input('second:')
4 try: # 捕捉异常
5 first = int(first)
6 second = int(second)
7 res = first/second
8 except Exception as e: # try里面这段代码出异常的时候走
9 print(e)
10 print('出错了')
11 else: # 没有出错，不是必须写的
12 print('没有出错') # 没有出错的时候走
13 print(res)
14 finally: # 不管是否出错都会执行它，也不是必须写的
15 print('无论是否出错都会执行这条代码！')
三、捕捉异常练习：完善MySQL操作函数
1 def my_db(sql):
2 import pymysql
3 try:
4 conn = pymysql.connect(**MYSQL_INFO)
5 except Exception as e:
6 print('数据库连接失败')
7 return '数据库连接失败' # 遇到return函数结束
8 else: # 没有出错继续执行
9 cur = conn.cursor()
10 try:
11 cur.execute(sql)
12 except Exception as res:
13 print('执行sql出错，sql是:%s'%sql)
14 else: # 没有出错继续执行
15 if sql.strip().split()[0].upper() == 'SELECT':
16 res = cur.fetchall()
17 else:
18 conn.commit()
19 res = 'OK'
20 finally: # 这个finally对应的是执行sql出错的try，前面连接失败直接跳出了函数
21 cur.close()
22 conn.close()
23 return res
四、常见的异常
1 AttributeError： 试图访问一个对象没有的属性，比如foo.x，但是foo没有属性x 2 IOError：输入 / 输出异常，一般是无法打开文件 3 ImportError： 无法导入模块或包，一般是路径问题或名称错误 4 IndentationError：代码没有正确对齐，属于语法错误 5 IndexError：下标索引超出序列边界，比如x只有三个元素，却试图访问x[3] 6 KeyError：试图访问字典里不存在的键 7 KeyboardInterrupt：Ctrl + C被按下 8 NameError：使用一个还未被赋予对象的变量 9 SyntaxError： 语法错误 10 TypeError： 传入对象类型与要求的不符 11 UnboundLocalError：试图访问一个还未被设置的局部变量，一般是由于在代码块外部还有另一个同名变量 12 ValueError： 传入一个调用者不期望的值，即使值的类型是正确的
五、主动抛出异常
在代码里让它自动抛出一个异常，然后捕捉到。比如我们在写自动化测试脚本时，结果和预期不符，就可以主动抛出一个异常，然后捕捉到做其他处理。主动抛出异常使用raise关键字。
1 try:
2 raise KeyError # 主动抛出一个keyerror的异常
3 except KeyError as e:
4 print('这是主动抛出的异常')