一、python基础
1.认识python
- 简单、易学、开源
- 自动化测试（应用广泛）
- 语言分类
编译型：先转换在执行（c语言）
解释型：边执行边转换（python）
2.python环境搭建
- 解释器官网：https://www.python.org/
3.PyCharm
-
详细安装：https://blog.youkuaiyun.com/weixin_46211269/article/details/119934323
成功啦!
-
代码需顶格书写，标点用英文
配置解释器
4.注释、变量、变量类型、输入输出、运算符
print() 输出/打印函数
1. 注释
单行注释
井号空格：#
Ctrl/（取消：再次使用）
多行注释
三对引号
2.波浪线
- 红色：代码错误
- 灰色：不影响正常执行
PEP8：书写规范方面
快捷键 ctrl alt l来规范自动格式化代码
- 绿色：不影响执行，认为是单词时会出现
在cmd终端中运行python代码
3.变量
- 存储数据（用户名，密码）
- 必须先定义后使用
4.定义变量
变量名=数据值（使用时直接用变量名）
结果：
5.变量名的命名规范
- 必须由字母 数字 和下划线组成，不能以数字开头
- 不能使用Python的关键字
- 区分大小写
- 建议（大驼峰：MyName，大驼峰：myName，下划线：my_name，见名知意：name）
6.变量类型
- 数字类型
整型（int）：整数，不带小数点
浮点型（float）：小数
复数类型 （3+4i）
布尔类型（bool）：两个值
真（True，1） 假（Flase，0，非0即真）
-
非数字类型
字符串（str）：使用引号引起来的
列表（list）：【1，2，3，4】
元组（tuple）：（1，2，3，4）
字典（dict）：{‘name’：‘小米’，‘age’：18} -
type（）函数
获取变量数据类型
type（变量）
eg：print（type（变量））
结果：
7.类型转换
变量=要转换为的类型（原数据）
运行
int（）将其他类型转换为int类型
1.float类型转换为整型
2.整数类型的字符串
float（）将其他类型转换为浮点型
1.int类型转换 float（3） 》3.0
2.数字类型的字符串转换（整数，小数）
str（）将其他类型转换为字符串
1.任何类型都可以
8.python交互模式
9.输入
输入：变量 = input（‘提示的信息’）
运行
输入
回车（输入类型都是str）
10.输出
print（‘hello world，hi’）
格式化输出
%格式化输出占位符号
1.%d 占位，填充整型数据 digit
2.%f 占位，填充浮点型数据 float
3.%s占位，填充字符串数据string（可以任意类型）
f-string（f字符串个格式化方法）
1.需要在字符串前加f“”或F“”
2 .占位符号统一变为{}
3.需要填充的变量写在{}中
字符串.format（）
1.在需要使用变量的地方使用（）占位
2.‘{}，{}，…’.format（变量，变量，…）
3.可以在任意版本使用
11.快捷键
添加引号括号：直接选中即可
撤销：ctrl z
删除一行：ctrl x
复制粘贴一行：Ctrl d快速新建一行：shift 回车
12.运算符
算数运算符
- 除得到浮点类型
- 优先级（）> ** > / // % > + -
比较运算符（得到的都是bool类型）
1.==判断两个数是否相等，相等为 True ，不相等为False
2.！=判断两个数是否不相等，不相等为 True ，相等为False
逻辑运算符（可以连接多个条件）
1.or 或 一真为真
2.and 和 一假为假
3.not 非 真变假 假变真
优先级由低到高
4.在判断和循环中
赋值运算符
= 右边的值保存在左边的变量中
复合型赋值运算符
+= ， -=，*=， /=
a+=b 》a=a+b
运算符优先级
可以使用（）改变优先级
二、流程控制结构
1.判断语句
if的基本结构
基本语法：if 判断条件
书写条件成立，执行代码
1.if是一个关键字，和后续的判断条件之间需要一个空格
2.判断条件后边需要一个冒号
3.冒号之后，回车，需要缩进（4个空格或tab）
4. 所有在if代码下方的缩进中书写的代码，属于if语句的代码块，判断为True时会执行
5.if 代码块中的代码，要么执行，要么都不执行
6.if代码块结束之后，代码要顶格书写，与if无关
if else 结构
1.else是关键字，后边需要冒号
2.冒号之后回车，需要缩进
3.处于else代码下方缩进中的内容，属于else代码块
4.if和else的代码块，只会执行其中一个
5.else需要结合if使用
if elif else 结构
1.elif也是关键字，后边和判断条件之间需要一个空格，判断条件之后需要一个冒号
2.冒号之后回车需要缩进，处在这个缩进中的代码表示是elif的代码块
3.在一个if判断中，可以有很多个elif
4.只有if的条件不成立，才会判断elif
5.在一个if中，如果有多个elif ，只要有一个条件成立，后续所有都不在判断
6.多个if之间没有关联性
多个if实现
Debug 调试代码
查找错误/查看执行步骤
1.打断点（小红点：想要在哪里停）
2.切换到控制台
3.单步执行即可
if嵌套
1.递进关系，第一个条件满足才会判断第二个
条件
案例：猜拳游戏
石头1，剪刀2，布3
在python中随机获取整数数字
1.导入随机数工具包：import random
2.使用工具包中的工具产生指定范围内的数字random.randint（a，b）
import random #随机数的应用
num= random.randint(1,3)
print(num)
import random #猜拳游戏
player = int(input('请出拳：'))
computer= random.randint(1,3)
if player==1 and computer==2 or player ==2 and computer==3 or player ==3 and computer ==1:
print('玩家胜利')
elif player == computer:
print('平局')
else:
print('电脑胜利')
结果
2.循环
程序三大流程：顺序，分支，循环
while循环
#说几遍我爱你
i=0
while i<5:
print('love')
i=i+1
#i+=1
结果
love
love
love
love
love
死循环和无限循环
死循环：不停的运行（bug）
无限循环：故意无限
使用场景：不确定运行多少次
if判断break终止
import random #猜拳游戏无限版
while True:
player = int(input('请出拳：'))
if player ==0:#玩家输入0停止
break
computer= random.randint(1,3)
if player==1 and computer==2 or player ==2 and computer==3 or player ==3 and computer ==1:
print('玩家胜利')
elif player == computer:
print('平局')
else:
print('电脑胜利')
结果
请出拳：2
玩家胜利
请出拳：1
玩家胜利
请出拳：00
Process finished with exit code 0
案例 使用循环求1-100之间数字的和
num =0
i=1
while i<=100:
num+=i
i+=1
print('结果：',num)
结果： 5050
Process finished with exit code 0
案例 使用循环求1-100之间偶数的和
方法一
num =0#找出所有偶数相加
i=1
while i<=100:
num+=i
i+=2
print('结果：',num)
方法二
#判断是否是偶数，然后相加
num=0
i=1
while i<=100:
if i%2 ==0:
num+=i
i+=1
print('结果：',num)
结果： 2550
Process finished with exit code 0
for循环
for 变量名 in 容器：
重复执行的代码
1.for 和in 都是关键字
2.容器中有多少个数据，循环会执行多少次（0个数据，执行0次）
3.每次循环，会将容器中的数据取出一个保存到in关键字前边的变量中
kapok ='hello'
#字符串有五个字符，循环五次
for i in kapok:
print('爱你哦~')
爱你哦~
爱你哦~
爱你哦~
爱你哦~
爱你哦~
Process finished with exit code 0
for做指定次数的循环
for 变量 in range （n):
重复执行的代码
1.range（）是python中的函数，作用使用可以生成【0，n）之间的整数，不包含n的，一个有n个数字，所以这个循环循环n次
2.想循环几次，n就写几
3.变量的值，也是每次循环从【0，n）取出一个值，第一次取0，最后取n-1
for i in range (4):
print(i)
结果：
0
1
2
3
range()变形
for 变量 in range（a，b):
重复执行的代码
#获取5到10之间的数字
for m in range(5,11):
print(m)
outcome：
5
6
7
8
9
10
break和continue
关键字，只能在循环中使用
break：遇见立即结束
continue：跳过本次循环
kk = input('请输入一个字符串：')
for i in kk:
if i == 'e':
continue
print(i)
outcome：
请输入一个字符串：hhgkufexhj
h
h
g
k
u
f
x
h
j
Process finished with exit code 0
三、数据序列
1.字符串
定义字符串
#单引号
kapok ='name'
print(kapok,type(kapok))
#双引号
kapok1 ="name"
print(kapok1,type(kapok))
#三引号
kapok2 ='''name'''
print(kapok2,type(kapok))
#字符串本身包含引号I’m kapok
#本身有单、双引号，定义是不能使用对应的
kapok3 ='''nam“e”'''
print(kapok3,type(kapok))
#使用转义字符，本身有单引号也能用
#转义可以重复使用
kapok4 ='I\'m kapok'
print(kapok4,type(kapok))
#在字符串前加r“”，字符串中的\不作为转义字符
kapok5 =r'I\'m kapok'
print(kapok5,type(kapok))
结果：
name <class 'str'>
name <class 'str'>
name <class 'str'>
nam“e” <class 'str'>
I'm kapok <class 'str'>
I\'m kapok <class 'str'>
Process finished with exit code 0
下标
获取某个位置的字符
python中支持负数下标，可从右向左进行编号
kk='kapok'
#打印最开始字符
print(kk[0])
#打印最后一个
print(kk[-1])
#下标为2
print(kk[2])
#获取长度
num = len(kk)
print(num)
k
k
p
5
Process finished with exit code 0
切片
可以获取字符串的多个字符（有规律）
kk = 'kapok'
#kap
print(kk[0:3:1])
print(kk[0:3])#步长为1 可不写
print(kk[:3])#开始为0 可不写
#pok
print(kk[2:5:1])
print(kk[-3:5:1])
#最后一个字符要，可以不写
print(kk[2:])
#开始结束都不写 all
print(kk[:])
#获取kpk
print(kk[0:5:2])
#步长为负数，开始结束不写，意义全变，
#反转 字符串
print(kk[::-1])
kap
kap
kap
pok
pok
pok
kapok
kpk
kopak
Process finished with exit code 0
字符串查找
find
字符串。find（sub_str，start，end）
kk='I like the wind in March, the rain in April, the constant sun and myself'
#查找 myself
num = kk.find('myself')
print(num)
#第一个the出现
num1 = kk.find('the')
print(num1)
#第一次出现的后一位
num2=kk.find('the',num1+1)
print(num2)
#第三个the
num3 = kk.find('the', num2 + 1)
print(num3)
#第四个the
num4= kk.find('the', num3 + 1)
print(num4)
66
7
26
45
-1
Process finished with exit code 0
字符串的替换 replace
字符串.replace（old_str，new_str，count）
将old换为new
count：替换的次数，一般默认
返回：替换之后完整的字符串，原来的字符串没有改变
kk='I like the wind in March, the rain in April, the constant sun and myself'
#将t变为T
kk2=kk.replace('t','T')
print('kk:',kk)
print('kk2:',kk2)
#将I变为kapok
kk3= kk.replace('I','kapok')
print('kk3:',kk3)
#将第二个in变为大写
kk4=kk.replace('in','IN')
kk4=kk4.replace('IN','in',1)
print('kk4:',kk4)
kk: I like the wind in March, the rain in April, the constant sun and myself
kk2: I like The wind in March, The rain in April, The consTanT sun and myself
kk3: kapok like the wind in March, the rain in April, the constant sun and myself
kk4: I like the wind IN March, the raIN IN April, the constant sun and myself
Process finished with exit code 0
字符串的拆分 split
字符串.split（sep，max_split）
将字符串按照sep进行分割
kk='I like the wind in March, the rain in April, the constant sun and myself'
#按照the进行拆分
kk1=kk.split('the')
print(kk1)
#只拆分一次
kk2 = kk.split('the',1)
print(kk2)
#按照空白字符切割
kk3 = kk.split()
print(kk3)
['I like ', ' wind in March, ', ' rain in April, ', ' constant sun and myself']
['I like ', ' wind in March, the rain in April, the constant sun and myself']
['I', 'like', 'the', 'wind', 'in', 'March,', 'the', 'rain', 'in', 'April,', 'the', 'constant', 'sun', 'and', 'myself']
Process finished with exit code 0
字符串的连接 join
字符串1.join（列表）
括号中内容主要是列表，也可以是其他
list =['I', 'like', 'the', 'wind', 'in', 'March,', 'the', 'rain', 'in', 'April,', 'the', 'constant', 'sun', 'and', 'myself']
#使用空格连接起来
list1 =' '.join(list)
print(list1)
#用$连
list2 = ' $ '.join(list)
print(list2)
I like the wind in March, the rain in April, the constant sun and myself
I $ like $ the $ wind $ in $ March, $ the $ rain $ in $ April, $ the $ constant $ sun $ and $ myself
Process finished with exit code 0
2.列表
list 使用最多，可以存储多个数据，使用逗号隔开，可以存放任何类型
列表的定义
#类实例化，不常用
#定义空列表
#变量=list（）
list1 = list()
print(type(list1),list1)
#类型转换 list（容器） 将其他的转换为列表
list2 =list('kapok')
print(type(list2),list2)
#直接使用中括号
list3 = []
print(type(list3),list3)
list4 = [1,'kapok',19]
print(type(list4),list4)
<class 'list'> []
<class 'list'> ['k', 'a', 'p', 'o', 'k']
<class 'list'> []
<class 'list'> [1, 'kapok', 19]
Process finished with exit code 0
列表支持下标和切片
list1 = ['I', 'like' ,'the' ,'wind ','in',' March']
#获取第一个数据
print(list1[0])
#获取一和二的数据
print(list1[0:2])
#列表支持len
print(len(list1))
I
['I', 'like']
6
Process finished with exit code 0
列表查询
index（）方法
列表.index（数据，start，end）
查找-判断是否存在
数据 in 容器 True/False
查找-统计出现的次数
列表.count（数据）
list=['I', 'like' ,'the' ,'wind ','in',' March']
#找the
num= list.index('the')
print(num)
if 'love' in list:
num = list.index('love')
print(num)
else:
print('真遗憾')
if list.count('the')>2:#统计the出现的次数
num = list.index('love')
print(num)
else:
print('真遗憾')
2
真遗憾
真遗憾
Process finished with exit code 0
列表添加
尾部添加
列表.append（数据）
返回None（关键字，空）
指定下标添加
列表.insert（下标，数据）
原有数据会后移
列表合并
列表1.extend（列表2）
将列表2的数据逐个添加在列表1的尾部
list = []
print(list)
#添加
list.append('kapok')
print(list)
#尾部添加
list.append('张国荣')
print(list)
#下标为1添加
list.insert(1,'刘亦菲')
print(list)
#下标为1添加
list.insert(1,'张子枫')
print(list)
#定义新的列表
list1=['1','2']
#添加到list,逐个数据添加
list.extend(list1)
print(list)
#整体添加
list.append(list1)
print(list)
[]
['kapok']
['kapok', '张国荣']
['kapok', '刘亦菲', '张国荣']
['kapok', '张子枫', '刘亦菲', '张国荣']
['kapok', '张子枫', '刘亦菲', '张国荣', '1', '2']
['kapok', '张子枫', '刘亦菲', '张国荣', '1', '2', ['1', '2']]
Process finished with exit code 0
列表修改
列表【下标】=数据
list=[1,2,3,4,5]
#下标1的改为9
list[1] =9
print(list)
#指定下标不存在，会报错
[1, 9, 3, 4, 5]
Process finished with exit code 0
列表删除
在列表删除中间的，后面的会向前移动
根据下标
列表.pop（下标）
1.下标不写，默认删除最后一个
2.返回：返回删除的数据
根据数据值删除
列表.remove（数据值）
1.返回：None
2.如果删除数据不存在，会报错
清空
列表.clear（）
list=[1,2,6,85,85,69]
#删除最后一个
num=list.pop()
print('删除的值：',num)
print(list)
#删除下标为1
list.pop(1)
print(list)
#删除6,即使有多个，也只删第1个
list.remove(6)
print(list)
删除的值： 69
[1, 2, 6, 85, 85]
[1, 6, 85, 85]
[1, 85, 85]
Process finished with exit code 0
列表反转和逆置
列表【：：-1】
新列表，原列表不变
列表.reverse（）
改变原列表
list=[1,2,3,5,6,8]
#切片
list1=list[::-1]
print('list1',list1)
print('list',list)
#reverse
list.reverse()
print('list',list)
list1 [8, 6, 5, 3, 2, 1]
list [1, 2, 3, 5, 6, 8]
list [8, 6, 5, 3, 2, 1]
Process finished with exit code 0
列表的复制
复制给到新的列表
1.切片
变量=列表【：】
2.copy
变量=列表.copy（）
list=[1,2,3]
list1=list[:]
print('list',list)
print('list1',list1)
print('-' *30)
list2 = list.copy()
print('list',list)
print('list2',list2)
#原列表不变
list [1, 2, 3]
list1 [1, 2, 3]
------------------------------
list [1, 2, 3]
list2 [1, 2, 3]
Process finished with exit code 0
列表的排序
一般对数字
列表.sort（）
升序排序
列表.sort（reverse=True）
降序排序
list=[1,5,9,5,4,8,6]
list.sort()
print(list)
list.sort(reverse=True)
print(list)
[1, 4, 5, 5, 6, 8, 9]
[9, 8, 6, 5, 5, 4, 1]
Process finished with exit code 0
列表嵌套
列表中还有列表
list=[['nm','i','f'],[1,5,9]]
print(len(list))
print(list[0])
print(list[0][0])
print(list[0][0][0])
#将i改为r
list[0][1]='r'
print(list)
#加2在第二个列表
list[1].append(2)
print(list)
2
['nm', 'i', 'f']
nm
n
[['nm', 'r', 'f'], [1, 5, 9]]
[['nm', 'r', 'f'], [1, 5, 9, 2]]
Process finished with exit code 0
列表去重
list=[1,2,3,2,1,3,3,1]
list1=set(list)
print(list1)
{1, 2, 3}
Process finished with exit code 0
list=[1,2,3,2,1,3,3,1]
new_list =[]
#for i in list:
# if i in new_list:
# pss
# else:
# new_list.append(i)
for i in list:
if i not in new_list:
new_list.append(i)
print(new_list)
[1, 2, 3]
Process finished with exit code 0
3.元组
tuple 和列表相似
区别
1.数据内容不能改变
2.使用（）
主要应用于传参和返回值，保证不会被修改
元组的定义
#类实例化的方式
#定义空元组
tuple1=tuple()
print(tuple1)
#类型转换
tuple1=tuple([1,2,3])
print(tuple1)
#直接使用（）
tuple3=(1,2,5)
print(tuple3)
#定义只有一个数的元组时，后面须有逗号
tuple5 =(1,)
print(type(tuple5),tuple5)
()
(1, 2, 3)
(1, 2, 5)
<class 'tuple'> (1,)
Process finished with exit code 0
1.只能查看
2.可以使用下标和切片
3.index
4.count
5.in
4.字典
1.字典 dict ，数据由键（key）值（value）组成
2.一组键值对是一个数据，中间逗号隔开
变量=（key;value,…)
3.一个字典的键是唯一的，值是任意的
4.字典的键一般都是字符串，可以是数字，不能是列表
定义
#类实例化
dict1=dict()
print(type(dict1),dict1)
#基本没有类型转换
#使用{}定义
dict2={}
print(dict2)
#非空字典
dict3={'kapok',22,155,'painting'}
print(dict3)
print(len(dict3))
<class 'dict'> {}
{}
{'painting', 155, 'kapok', 22}
4
Process finished with exit code 0
增加，修改
字典【键】=数据值
dict1={'name':'kapok','height':155,'like':['painting','study','eat']}
#添加女
dict1['sex']='女'
print(dict1)
dict1['height']=190
print(dict1)
#添加爱好
dict1['like'].append('beauty')
print(dict1)
dict1['like'].remove('eat')
print(dict1)
{'name': 'kapok', 'height': 155, 'like': ['painting', 'study', 'eat'], 'sex': '女'}
{'name': 'kapok', 'height': 190, 'like': ['painting', 'study', 'eat'], 'sex': '女'}
{'name': 'kapok', 'height': 190, 'like': ['painting', 'study', 'eat', 'beauty'], 'sex': '女'}
{'name': 'kapok', 'height': 190, 'like': ['painting', 'study', 'beauty'], 'sex': '女'}
Process finished with exit code 0
删除
删除指定键值对
del字典【键】
清空
字典.clear（）
dict1={'name':'kapok','height':155,'like':['painting','study','eat']}
del dict1['name']
print(dict1)
#pop的写键
dict1.pop('height')
print(dict1)
dict1['like'].pop(0)
print(dict1)
dict1.clear()
print(dict1)
{'height': 155, 'like': ['painting', 'study', 'eat']}
{'like': ['painting', 'study', 'eat']}
{'like': ['study', 'eat']}
{}
Process finished with exit code 0
查询
要通过key来获取
- 字典【键】
- 字典.get（键）
dict1={'name':'kapok','height':155,'like':['painting','study','eat']}
print(dict1['name'])
print(dict1.get('name'))
# print(dict1['sex']) 报错
print(dict1.get('sex'))
print(dict1.get('sex','保密'))
#获取第二个爱好
print(dict1['like'][1])
kapok
kapok
None
保密
study
Process finished with exit code 0
字典的遍历
- 键进行遍历
1.for 变量 in字典：
print（变量）
2.for 变量in字典.key（）：
print（变量）
- 值
for 变量 in字典.value（）：
print（变量）
- 键值
for 变量1，变量2 in字典.items（）：
dict1={'name':'kapok','height':155,'like':['painting','study','eat']}
#遍历键
for k in dict1:
print(k)
for k in dict1.keys():
print(k)
print('-'*30)
#遍历值
for v in dict1.values():
print(v)
print('-'*30)
#键值
for k,v in dict1.items():
print(k,v)
name
height
like
name
height
like
------------------------------
kapok
155
['painting', 'study', 'eat']
------------------------------
name kapok
height 155
like ['painting', 'study', 'eat']
Process finished with exit code 0
总结
1.字符串，列表，元组支持加法运算
str1=‘hello’+‘world’ #hello world
list=【1，2】+【3，4】 #【1，2，3，4】
tuple=（1，2）+（3，4）#（1，2，3，4）
2.字符串 列表 元组支持乘一个数字
‘hello’*3 #3个hello
【1，2】*3 #【1，2，1，2，1，2】
（1，2）*3 #（1，2，1，2，1，2）
3.len（）在容器中都可以使用
4.in关键字在容器中都能使用，在字典中判断键是否存在
四、函数
1.函数基础
将多行代码写在一块，起个名字
减少代码的冗余，提高效率
def login():
print('1.输入用户名')
print('2.输入密码')
print('3.输入验证码')
print('4.点击登录')
print('-'*30)
print('1.输入用户名')
print('2.输入密码')
print('3.输入验证码')
print('4.点击登录')
print('-'*30)
login()
------------------------------
1.输入用户名
2.输入密码
3.输入验证码
4.点击登录
------------------------------
1.输入用户名
2.输入密码
3.输入验证码
4.点击登录
Process finished with exit code 0
函数的定义
起名字
先定义后使用
def 函数名（）：
函数中的代码
1.def是关键字，定义函数
2.函数名需要遵守标识符规则
3.处于def 缩进中的代码称为函数体
4.函数体不会执行，调用才会执行
函数的调用
使用函数
函数名（）
def dayin():
print('hello 1')
print('hello 2')
print('hello 3')
dayin()
hello 1
hello 2
hello 3
Process finished with exit code 0
文档注释
书写位置和作用比较特殊
1.在函数名的下方使用 三对双引号进行的注释
2.告诉别人这个函数如何使用
3.查看，在调用是用光标放在函数名上，快捷键ctrl q
def dayin():
"""打印三个hello"""
print('hello 1')
print('hello 2')
print('hello 3')
dayin()
函数的嵌套调用
1.函数定义不会执行
2.调用会执行
3.结束后回到调用的地方继续执行
def kk():
print(1)
print('kk')
print(2)
def kk1():
print(3)
kk()
print(4)
print(5)
kk1()
print(6)
5
3
1
kk
2
4
6
Process finished with exit code 0
函数参数
#对两个数字进行求和计算
def sum(num1,num2):#形式参数，占位
num=num1+num2
print(num)
sum(10,20)#实参
sum(5,6)
30
11
Process finished with exit code 0
函数返回值
print（）》None
input（）》输入的内容
在函数中想要将一个数据作为返回值返回，需要用return关键字（只能在函数中使用）
1.将数据值作为返回
2.函数代码执行遇到return，会结束函数的执行
def sum(a,b):
num = a+b
#print(num) 没有返回值，这个结果只能在函数中用一次，后续不能使用
#要想在后续使用，用到return
return num
print('123') #不会执行，return之后
#直接输出
print(sum(1, 2))
#将数据保存，以便在后续使用
#变量=函数（）
result =sum(1,3)
print(result)
print('使用1，直接打印',result)
print('使用2，对数字加10',result+10)
3
4
使用1，直接打印 4
使用2，对数字加10 14
Process finished with exit code 0
返回值的说明
def 函数名（）：#返回值None
pass #代码中没有return
def 函数名（）：
return #return后边没有数据，返回值None
def 函数名（）：
return xx #返回值xx
2.变量进阶【理解】
变量的引用
1.在定义变量的时候 变量=数据值，python解释器会在内存中开辟两块空间
2.变量和数据都有自己的空间
3.日常简单理解，将数据保存到变量的内存中
4.变量中存储数据地址的行为，就是引用（变量中存储了数据）存储的地址成为引用地址
5.可以使用id（）来获取变量中的引用地址（即数据地址），如果两个变量的id（）获取的引用地址一样，即代表着，两个变量引用同一个数据，是同一个数据
6.只有 赋值运算符=，可以改变变量的引用（等号左边数据的引用）
7.python中数据的传递，都是传递的引用
a =1 #讲数据1的引用存到a对应的内存中
print(id(a))
b=a
print(id(b))
a= 10
print(id(a))#a的引用变了
140732487041832
140732487041832
140732487042120
Process finished with exit code 0
可变类型和不可变类型
数据类型：int float bool str list tuple dict set
可变不可变：内存是否允许被修改
可变：list dict set
不可变：int float bool tuple str
list=[1,2,3]
list1=[1,2,3] #定义了一个新的列表
print(id(list))
print(id(list1))
print('-'*30)
print(id(list),id(list[1]))
list[1]=10
print(list)
print(id(list),id(list[1]))#列表没变，下标为1的地址变了
print('-'*30)
tuple=(1,2,[3,4])#三个地址不变
print(tuple)
print(id(tuple),id(tuple[-1]))
tuple[-1][0]=10
print(tuple)
print(id(tuple),id(tuple[-1]))#列表没变，元组也没变
2312785514944
2312785570304
------------------------------
2312785514944 140732477277000
[1, 10, 3]
2312785514944 140732477277256
------------------------------
(1, 2, [3, 4])
2312785890496
(1, 2, [10, 4])
2312785890496
Process finished with exit code 0
交换两个变量的值
a=10
b=20
#方法一：引入第三个变量
# c=a
# a=b
# b=c
# print(a,b)
#方法二，数学
# a=a+b
# b=a-b
# a=a-b
# print(a,b)
#方法三 python特有
a,b =b,a
print(a,b)
20 10
Process finished with exit code 0
组包和拆包
组包（pack）：将多个数据值使用逗号连接的过程，组成元组
拆包（unpack）：将容器中数据值使用多个变量分别保存。变量要于容器数据的个数保持一致
赋值运算符先看右再看左
a=10
b=20
#组包
c=b,a
print(type(c),c)
#拆包
a,b =c
print(a,b)
<class 'tuple'> (10, 20)
10 20
Process finished with exit code 0
局部变量和全局变量
根据变量的定义位置区分
局部变量：在函数（缩进）内部定义的内容
1.只能在当前函数内部使用
2.在不同函数中，可以定义名字相同的局部变量，两者之间没有影响
3.生存周期（生命周期，作用范围）调用时创建，结束时销毁
def fun():
num=10
print(f"fun函数{num}")
def fun2():
num=100
print(f"fun2函数{num}")
fun()
fun2()
fun()
fun函数10
fun2函数100
fun函数10
Process finished with exit code 0
全局变量
在函数外部定义的变量
1.可以再任何函数中获取全局变量的值
2.如果在函数中存在和全局变量名字相同的局部变量，在函数中使用的是 局部变量的值（就近）
3.在函数内部想要修改全局变量的引用，需要添加global关键字，对变量进行声明为全局变量
4.生命周期
代码执行的时候被创建，代码执行结束是销毁
num =10
def fun():
print(f'fun中{num}')#在函数中可以读取全局变量的值
def fun2():
num= 20 #定义局部变量，不影响全局变量
print(f'fun2中{num}')
def fun3():
global num #这个函数使用都是全局变量
num= 30#修改了全局变量
print(f'fun3中{num}')
fun()
fun2()
fun()
fun3()
fun()
# print(num) 不调用，则还为10
fun中10
fun2中20
fun中10
fun3中30
fun中30
Process finished with exit code 0
3.函数进阶
返回值-函数返回多个数据值
多个数据值组成容器进行返回，一般是元组（组包）
def calc(a,b):
num=a+b
num1=a-b
return num,num1
#写法1
result =calc(10,5)
print(result,result[0],result[1])
#写法2，直接拆包
x,y = calc(10,56)
print(x,y)
(15, 5) 15 5
66 -46
Process finished with exit code 0
函数参数
形参的不同书写
函数传参方式
位置传参
在参数调用的时候，按照形参的顺序，将实参值传递给形参
关键字传参
在函数调用的时候，指定数据值给到那个形参
混合使用
1.关键字传参必须写在位置传参的后面
2.不要给一个形参传递多个数据值
def func(a,b,c):
print(f'a:{a},b:{b},c:{c}')
#位置传参
func(1,2,3)
#关键字传参
func(a=1,b=2,c=3)
#混合使用
func(1,b=2,c=3) #关键字得在后面
a:1,b:2,c:3
a:1,b:2,c:3
a:1,b:2,c:3
Process finished with exit code 0
缺省参数
缺省函数/默认函数
列表.pop #不写参数，删除最后一个
列表.sort（reserse=True）
1.定义方式
在函数定义的时候，给形参一个默认的数据值，这个形参就变为缺省参数，
注意：缺省参数的书写要放在普通参数的后边
2.特点（好处）
缺省参数，在函数调用的时候，可以传递实参值，也可以不传递实参值
如果传参，使用的就是传递的实参值，如果不传参，使用默认值
def show(name,sex='保密'):
print(name,sex)
show('小王')
show('小王','男')
小王 保密
小王 男
Process finished with exit code 0
多值参数
不确定具体个数时
def fun(*args,**kwargs):
print(type(args),args)
print(type(kwargs),kwargs)
print('-'*30)
fun()
fun(1,2,3)
fun(a=1,b=2,c=3)
fun(1,2,3,a=1,b=2,c=3)
<class 'tuple'> ()
<class 'dict'> {}
------------------------------
<class 'tuple'> (1, 2, 3)
<class 'dict'> {}
------------------------------
<class 'tuple'> ()
<class 'dict'> {'a': 1, 'b': 2, 'c': 3}
------------------------------
<class 'tuple'> (1, 2, 3)
<class 'dict'> {'a': 1, 'b': 2, 'c': 3}
------------------------------
Process finished with exit code 0
#函数传参中的拆包
sum(*list)
sum(**dict)
print函数
print(1)
print(2)
print(3)
print(1,end=' ')#结束会打印的，一般默认是\n
print(2,end=' ')
print(3)
print(1,2,3,4,5,6,sep='_')#sep 多个位置参数之间的间隔
1
2
3
1 2 3
1_2_3_4_5_6
Process finished with exit code 0**
4.匿名函数
lambda 参数：一行代码
# 1.无参无返回值
def fun1():
print(1)
# fun1()
fun11=lambda : print(2)
fun11()
# 2.无参有返回值
def fun2():
return 10
# print(fun2())
fun22=lambda : 9
print(fun22())
# 3.有参无返回值
def sum(a,b):
print(a+b)
# sum(1,2)
sum11=lambda a,b:print(a+b)
sum11(10,20)
# 4.有参有返回值
def func4(a,b):
return a+b
# print(func4(1,2))
func44= lambda a,b:a+b
print(func44(10,20))
2
9
30
30
Process finished with exit code 0
练习：
#求两个数的乘机
def cheng(a,b):
print(a*b)
cheng11 =lambda a,b : print(a*b)
cheng11(2,3)
#参数是字典，返回字典中键为age的值
fun=lambda x:x.get('age')
dict1={'name':'kapok','age':18,'height':155,'like':['painting','study','eat']}
print(fun(dict1))
匿名函数作为函数的参数-列表中的字典排序
dict1=[{'name':'kapok','age':18,},
{'name':'kk1','age':20,},{'name':'kk2','age':30,}]
dict1.sort(key=lambda x:x['age'],reverse=True)
print(dict1)
[{'name': 'kk2', 'age': 30}, {'name': 'kk1', 'age': 20}, {'name': 'kapok', 'age': 18}]
Process finished with exit code 0
字符串比大小
比较的是ascii的值
orc（）函数可以获取ascii的值
字符串比较对应下标的ascii值
五、面向对象
1.面向对象
注重结果
2.类和对象
类：相似的，泛指的
对象：特指的
面向代码的步骤
3.面向对象基础语法
# 小猫爱吃鱼，小猫要喝水，定义不带属性的类
class cat:
def eat(self):
print('cat want eat fish')
def drink(self):
print('cat want drink water')
cat= cat()
cat.eat()
cat.drink()
cat want eat fish
cat want drink water
Process finished with exit code 0
self的说明
# 小猫爱吃鱼，小猫要喝水，定义不带属性的类
class cat:
def eat(self):
print('cat want eat fish')
def drink(self):
print(f'{id(self)},self')
print('cat want drink water')
cat= cat()
print(f'{id(cat)},self')#解释器将cat对象传给self，换一个对象，id会变
cat.eat()
cat.drink()
2199483399248,self
cat want eat fish
2199483399248,self
cat want drink water
Process finished with exit code 0
对象的属性操作
cat.name='灰灰' #添加name属性
魔法方法
_init_方法
# 猫类 name age show_info（输出的属性信息）
class cat:
def __init__(self):
self.name='cat'
self.age=50
print('我被调用了')
def show_info(self):
print(f'my name is {self.name},age is {self.age}')
cat()
cat=cat()
cat.show_info()
我被调用了
我被调用了
my name is cat,age is 50
Process finished with exit code 0
_init_方法（带参数的）
# 猫类 name age show_info（输出的属性信息）
class cat:
def __init__(self,name,age):
self.name=name
self.age=age
def show_info(self):
print(f'my name is {self.name},age is {self.age}')
cat=cat('cat',5)
cat.show_info()
my name is cat,age is 5
Process finished with exit code 0
__str__方法
class cat:
def __init__(self,name,age):
self.name=name
self.age=age
def show_info(self):
print(f'my name is {self.name},age is {self.age}')
def __str__(self):
return f'my name is {self.name},age is {self.age}'
cat=cat('cat',5)
print(cat)
my name is cat,age is 5
Process finished with exit code 0
__ del __
class demo:
def __init__(self,name):
print('调用')
self.name= name
def __del__(self):
print(f'{self.name}没了，处理后事')
#运行结束后的输出
# demo('a')
a=demo('a')
print('代码运行结束')
调用
代码运行结束
a没了，处理后事
Process finished with exit code 0
案例
class person:
def __init__(self,name,weight):
self.name=name
self.weight=weight
def __str__(self):
return f'姓名：{self.name},体重:{self.weight}kg'
def run(self):
print(f'{self.name}跑步5km，体重减少了')
self.weight-=0.5
def eat(self):
print(f'{self.name}大餐一顿，体重增加了')
self.weight += 1.
xm = person('小明',75.0)
print(xm)
xm.run()
print(xm)
xm.eat()
print(xm)
姓名：小明,体重:75.0kg
小明跑步5km，体重减少了
姓名：小明,体重:74.5kg
小明大餐一顿，体重增加了
姓名：小明,体重:75.5kg
4.封装、继承、多态
封装
class houseitem:
def __init__(self,name,area):
self.name =name
self.area=area
def __str__(self):
return f'家具名字{self.name},占地面积{self.area}平米'
class house:
def __init__(self,name,area):
self.name=name
self.total_area=area
self.free_area=area
self.item_list=[]
def __str__(self):
return f'户型：{self.name},总面积：{self.total_area},剩余面积：{self.free_area}\'' \
f'家具名称列表{self.item_list}'
def add_item(self,item):#item表示家具对象
if self.free_area>item.area:
self.item_list.append(item.name)
self.free_area-=item.area
print(f'{item.name}添加成功')
else:
print('剩余不足')
bed = houseitem('席梦思',4)
chest=houseitem('衣柜',2)
table=houseitem('餐桌',1.5)
print(bed)
print(chest)
print(table)
house =house('三室一厅',150)
print(house)
#添加 家具
house.add_item(bed)
print(house)
家具名字席梦思,占地面积4平米
家具名字衣柜,占地面积2平米
家具名字餐桌,占地面积1.5平米
户型：三室一厅,总面积：150,剩余面积：150'家具名称列表[]
席梦思添加成功
户型：三室一厅,总面积：150,剩余面积：146'家具名称列表['席梦思']
私有和公有
class person:
def __init__(self,name,age):
self.name=name
#私有的本质，两个下划线重命名
self.__age=age
def __str__(self):
return f'name:{self.name} age:{self.__age}'
xm=person('kapok',18)
print(xm)
# print(xm.__age) 类外部不能使用
xm.__age=20
print(xm)#不能修改
print(xm._person__age)
xm._person__age=19
print(xm)#修改，尽量不要用
name:kapok age:18
name:kapok age:18
18
name:kapok age:19
继承
class animal:
def eat(self):
print('吃东西')
class dog(animal):
def brak(self):
print('汪汪叫')
class xiao(dog):
def xiao(self):
print('wu')
an1=animal()
an1.eat()
dog=dog()
dog.eat()
dog.brak()
xiao=xiao()
xiao.eat()
xiao.brak()
xiao.xiao()
吃东西
吃东西
汪汪叫
吃东西
汪汪叫
wu
结论：
重写
覆盖
class dog:
def bark(self):
print("o")
class xiao(dog):
def bark(self):
print('a')
xiao=xiao()
xiao.bark()
a
扩展
class dog:
def bark(self):
print("o")
class xiao(dog):
def bark(self):
print('a')
xiao=xiao()
xiao.bark()
a
o
a
多态
5.类属性和类方法
对象的划分
属性的划分
实例属性
类属性
练习
class dog:
count =0#类属性
def __init__(self,name):
self.name=name#实例对象
dog.count += 1
print(dog.count)
dog1=dog('1')
print(dog.count)
0
1
方法的划分
练习
import random
class game:
top_score=0
def __init__(self,name):
self.name=name
@staticmethod
def show_help():
print(f'这是游戏的帮助信息{game.show_help}')
@classmethod
def show_top_score(cls):
print(f'打印最高分{game.top_score}')
def start_game(self):
print(f'{self.name}开始一局游戏')
score=random.randint(10,100)
print(f'本次得分为{score}')
if score > game.top_score:
game.top_score=score
xw =game('小王')
xw.start_game()
xw.show_top_score()
xw.start_game()
xw.show_top_score()
小王开始一局游戏
本次得分为53
打印最高分53
小王开始一局游戏
本次得分为18
打印最高分53
六、异常、模块、文件操作
1.异常 
num =input('请输入一个整型数字：')
num= int(num)
print(num)
请输入一个整型数字：a
Traceback (most recent call last):
File "D:\软件测试\pycharm file\pythonProject\异常的介绍.py", line 2, in <module>
num= int(num)
^^^^^^^^
ValueError: invalid literal for int() with base 10: 'a'
异常捕获
try:
num =input('请输入一个整型数字：')
num= int(num)
print(num)
except:
print('请输入数字')
print('后续其他代码可以正常执行')
请输入一个整型数字：a
请输入数字
后续其他代码可以正常执行
Process finished with exit code 0
捕获多个指定类型的异常
try:
num =input('请输入一个整型数字：')
num= int(num)
print(num)
a=10/num
print(f'a:{a}')
except ValueError: #只能捕获ValueError类型及其子类的异常
print('发生了异常，请输入数字')
except ZeroDivisionError:
print('除数不能为0')
请输入一个整型数字：0
0
除数不能为0
Process finished with exit code 0
异常捕获完整版本
try:
num =input('请输入一个整型数字：')
num= int(num)
print(num)
a=10/num
print(f'a:{a}')
except Exception as e:
print(f'错误信息为：{e}')
else:
print('没有发生异常我会执行')
finally:
print('不管有没有异常，我都会执行')
异常传递（了解）
def func1():
num=10/0
print(num)
def func2():
print('1111')
func1()
try:
func2()
except Exception as e:
print(e)
file/pythonProject/异常的传递.py"
1111
division by zero
Process finished with exit code 0
2.模块和包
导入模块的语法
#方式一
# import random
# print(random.randint(1,60))
#方式二
# from random import randint
# print(randint(1,60))
#方式三
from random import *
print(randint(1,60))
模块的查找顺序
__name__的作用
def add(a,b):
return a+b
if __name__ == '__main__':
print('在代码中调用函数')
print(add(1,2))
print(add(10,20))
print('tools:',__name__)
file/pythonProject/tools.py"
在代码中调用函数
3
30
tools: __main__
Process finished with exit code 0
调用
import tools
print(tools.add(100,200))
file/pythonProject/调用自己模块中的内容.py"
300
练习
def add(a,b):
return a+b
def func():
print('我是tools模块中的func函数')
class dog:
def __init__(self,name,age):
self.name=name
self.age=age
def play(self):
print(f'{self.name}在快乐的玩耍')
import tools
tools.func()
dog=tools.dog('小白',2)
dog.play()
file/pythonProject/练习 tools.py"
我是tools模块中的func函数
小白在快乐的玩耍
Process finished with exit code 0
包
3.文件操作
文件操作的步骤
#写
f=open('a.txt','w',encoding='utf-8')
f.write('good good study\n')
f.write('day day up')
f.close()
good good study
day day up
#读
f=open('a.txt','r',encoding='utf-8')
buf = f.read()
print(buf)
f.close()
使用with open
with open('a.txt','a',encoding='utf-8') as f:
f.write('2')
good good study
day day up2
按行读取文件
文件对象.redline()
json 文件的处理
json文件
{
"name": "小明",
"age": 18,
"isMen": true,
"like": ["听歌","游戏","购物","吃饭","睡觉","打豆豆"],
"local": ["中国","上海"]
}
import json
with open('a.json',encoding='utf-8') as f:
result =json.load(f)
print(type(result))
print(result.get('name'))
<class 'dict'>
小明
Process finished with exit code 0
import json
list=[(1),(2)]
with open('a.json','w',encoding='utf-8') as f:
json.dump(list,f,ensure_ascii=F,indent=4)#直接显示中文，不以ascii显示
#indent为显示缩进
七、UnitTest框架
1.UnitTest基本使用
介绍
TestCase（测试用例）
import unittest
class TestDemo(unittest.TestCase):
#书写测试方法，即测试用例，目前没有真正的用例代码，使用print代替
#书写要求，测试方法 必须以test_开头（本质是以test开头）
def test_method1(self):
print('测试方法1')
def test_method2(self):
print('测试方法2')
#执行用例
#光标放在类名后边运行，会执行类中所有的测试方法
#将光标放在方法名的后边 只执行当前的方法
问题一 代码文件的命名不规范
问题二 没有结果
问题三 没有找到用例
TestSuite 和TestRunner
#导包
import unittest
#实例化（创建对象）套件对象
suite= unittest.TestSuite()
from testcase1 import TestDemo1
from testcase2 import TestDemo2
#使用套件对象添加用例方法
#方法一：套件对象。addTest（测试类名（’方法名‘））
suite.addTest(TestDemo1('test_method3'))
suite.addTest(TestDemo1('test_method4'))
suite.addTest(TestDemo2('test_method5'))
suite.addTest(TestDemo2('test_method6'))
#实例化运行对象
runner = unittest.TextTestRunner()
#使用运行对象去执行套件对象
#运行对象.run(套件对象）
runner.run(suite)
file/pythonProject/testsuite和testrunner.py"
测试方法3
测试方法4
测试方法5
测试方法6
....
----------------------------------------------------------------------
Ran 4 tests in 0.000s
OK
Process finished with exit code 0
第二种写法
#方式二：将一个测试类中所有方法进行添加
#套件对象.addTest(unittest.makeSuite(测试类名))
#缺点：不会提示错误
suite.addTest(unittest.makeSuite(TestDemo1))
suite.addTest(unittest.makeSuite(TestDemo2))
练习
用例代码
import unittest
#自定义测试类
from tools import add
class TestAdd(unittest.TestCase):
def test_method1(self):
if add(1,2)==3:
print('测试通过')
else:
print('测试不通过')
def test_method2(self):
if add(10,20)==30:
print('测试通过')
else:
print('测试不通过')
def test_method3(self):
if add(2,3)==5:
print('测试通过')
else:
print('测试不通过')
套件和执行代码
import unittest
#实例化套件对象
from test import TestAdd
suite=unittest.TestSuite()
#添加测试方法
suite.addTest(unittest.makeSuite(TestAdd))
#实例化执行对象
runner=unittest.TextTestRunner()
runner.run(suite)
TestLoader（测试加载）
#1.导包
import unittest
#2.实例化加载对象并添加用例
suite=unittest.TestLoader().discover('./venv','testcase*')
#3.实例化运行对象
# runner=unittest.TextTestRunner()
#4.执行
# runner.run(suite)
#3和4和一起
unittest.TextTestRunner().run(suite)
第二种方法
#导包
import unittest
#使用默认的加载对象并加载用例
suite=unittest.defaultTestLoader.discover('venv','testcase')
#3和4和一起
unittest.TextTestRunner().run(suite)
Fixture（测试夹具）
案例
import unittest
class TestLogin(unittest.TestCase):
#每个测试方法执行之前调用
def setUp(self) -> None:
print('输入网址')
#每个测试方法执行之后调用
def tearDown(self) -> None:
print('关闭当前页面')
@classmethod
def setUpClass(cls) -> None:
print('打开浏览器')
@classmethod
def tearDownClass(cls) -> None:
print('关闭浏览器')
def test_1(self):
print('请输入正确的用户名密码验证码，点击登录1')
def test_2(self):
print('请输入正确的用户名密码验证码，点击登录1')
打开浏览器
输入网址
请输入正确的用户名密码验证码，点击登录1
关闭当前页面
输入网址
请输入正确的用户名密码验证码，点击登录1
关闭当前页面
关闭浏览器
2.UnitTest断言
3.参数化
安装插件
参数化代码
#1.导包
import unittest
from parameterized import parameterized
from tools import login
#组织测试数据【（），（），（）】
data=[
(),
(),
()
]
#2.定义测试类
class TestLogin(unittest.TestCase):
# 3.书写测试方法（用到的测试数据使用变量代替）
@parameterized.expand(data)
def test_login(self,username,password,expect):
self.assertEqual(expect,login(username,password))
#4.组织测试数据并传参(装饰器@）
跳过
import unittest
version =30
class TestDemo(unittest.TestCase):
@unittest.skip('没有原因，不想执行')
def test_1(self):
print('1')
@unittest.skipIf(version>=30,'版本号大于等于30，不用测试')
def test_2(self):
print('2')
def test_3(self):
print('3')
Skipped: 没有原因，不想执行
Skipped: 版本号大于等于30，不用测试
3
4.生成HTML报告
自带的测试报告
生成第三方的测试报告
import unittest
from HTML TestRunnerCN import HTML TestRunnerCN
#组装用例方法
suite =unittest.defaultTestLoader.discover('.','*')
#实例化运行对象
with open('report_cn.html','wb') as f:
runner =HTMLTestReportCN(f)
runner.run(suite)
扫一扫
80万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
