Python基础

认识Python

Python 是一门快速增长的计算机编程语言

1989 ：诞生(创始人为荷兰人吉多·范罗

苏姆)

2008 ：Python2发布 (最新稳定版本是Python 2.7)

2000：Python3发布(不完全兼容Python 2)

2020.1.1：Python2终结(停止 Python 2 的更新)

2022.12：Python3.11发布(Python 3最新稳定版)

Python属于解释型语言(跑代码需要解析器)

计算机代码运行是否生成新的可执行文件，可以分为2种语言：

编译型语言——生成新的可执行文件
解释型语言——不会生成，需要一个解释器，边执行边解释

Python环境搭建

安装Python解释器

提示：Python 是一门解释型语言，通过解释器来运行 .py 文件

操作步骤：

\1. 下载解释器安装包

下载地址：www.python.org/downloads/r…

\2. 安装

双击安装包开始安装
选择自定义安装
勾选添加环境变量

\3. 验证

cmd进入命令行，输入python 查看信息

安装PyCharm

PyCharm介绍：

Pycharm 是一种 Python IDE (集成开发环境)，内置功能丰富提高开发效率
Pycharm 分为专业版(professional) 和社区版(community)

操作步骤：

\1. 下载安装包

下载地址：

www.jetbrains.com/pycharm/dow…

\2. 安装

双击安装包选择默认选项即可完成安装

PyCharm中编写HelloWorld程序

操作步骤：

双击打开 pycharm 软件的快捷方式（不要双击安装包)
创建新项目（文件--》新建项目）
设置项目目录（电脑存放代码的地方）和 Python 解释器（启动程序）
创建代码文件（右键--》新建--》python文件(.py文件)）
书写代码
```
print('hello world')
```
运行代码（右键--》运行）& 查看结果，在下方控制台中即可看到打印的内容

基本语法

注释(就是对代码的解释和说明)

目的：理清思路

让人们能够更加轻松地了解代码
增强代码的可读性

特点：不会被解释器执行

分类：

单行注释：

# 这里是单行注释 
print("hello") 
例子：
# 李白的名字
print('李白')

多行注释：

"""
被注释内容
被注释内容
"""
'''被注释内容''
例子：
'''
杜甫的名字
杜甫的年龄
'''
print('杜甫')
print(20)

红色波浪线：代码错误(运行错误，报错)

绿色波浪线：写错字了(不影响运行)

灰色波浪线：代码注释不规范【不符合pep8代码规范】

代码规范快捷键操作：CTRL+ALT+L

注释-扩展

注释快捷键：ctrl + /
注释并非越多越好，一目了然的代码无需注释
逻辑复杂的代码，应当先写注释再编码
不要用中文去翻译 python 代码的含义

变量和标识符

变量

概念：变量在计算机语言中能储存计算结果或表示某个数据值
定义(先定义后使用)：变量名(没有引号)=数据值

# 示例代码
name = "张三"
age = 18
print(name)
print(age)

说明：

变量名自定义, 要满足标识符命名规则

数据值为要存储的数据，可以为不同的数据类型

单等号用于赋值，不具备比较功能

标识符

概念：标识符是用户编程时使用的名字，用于给变量、函数、类等命名

标识符规则：

由数字, 字母, 下划线组成

不能使用数字开头

不能使用Python内置关键字

严格区分大小写

不建议使用中文

Python中的关键字 
False None True and as assert break 
class continue def del elif else except finally for 
from global if import in 
is lambda nonlocal not or pass raise return try 
while with yield

2. 命名规范

驼峰命名

大驼峰：每个单词首字母大写, 例如: MyName
小驼峰：第二个单词开始首字母大写, 例如: myName

下划线命名

每个单词之间使用下划线连接, 例如: my_name

数据类型

思考：数据为什么需要类型？

• 人类可以肉眼观察轻松的区分不同类型数据，但是计算机做不到

• 计算机工作的过程就是完成不同的类型的计算，例如做数学运算、做文件存储、做逻辑判断

• 数据类型可以对不同数据进行分类管理和标识

数字型
  整型：int  1 2 3
  浮点型：float 小数  1.1  1.23
  布尔型(非0即真)：bool  TRUE 真  FALSE  假
非数字型(多个值)
  字符串：str    ' '    "  "    """ """    ''' '''
  列表：list  [1,2,3,4]
  元组：tuple  (1,2,3,4,5)
  集合：set  {}
  字典：dict  键值对  {"name":"张三"}

3. 查看数据类型：

语法: type(数据/变量名)

注意: 该函数本身不具备输出功能, 需要配合print()函数使用!

4. 数据类型转换(字符串不能转换成数字)

函数	说明	注意
int(x)	将x转换为一个整数	x是字符串时，必须是整数类型的字符串
float(x)	将x转换为一个浮点数	x是字符串时，只要是数字类型的字符串即可
str(x)	将x转换为字符串	对于任意数据类型x都可以转为字符串类型
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表

例如：将 num2 = '3.14' 转换为浮点型 float() ，转换前后打印数据的类型，查看类型的变化情况
num1 = '3.14'
num1 = float(num1)
print(num1)
print(type(num1))

程序的输入和输出

程序的输入

说明：在 Python 中接收用户输入的数据的过程为程序的输入

语法: 变量名 = input('提示信息:')

当程序执行到 input() 函数会等待用户输入, 因此最好给出提示信息
input() 函数接收用户输入的信息后, 一般需要保存到到变量中, 方便后续使用
input() 函数会把用户输入的任意数据都当做字符串处理, 需要运算时注意类型转换

输出

说明：将程序的运行结果按照一定的格式输出

格式化输出-format方法实现

print("name={} age={}".format(name, age))

格式化输出-f格式化实现

print(f"name={name} age={age}")

# 1. 提示用户输入两个数字
num1 = input('请输入第一个数字')
num2 = input('请输入第二个数字')
# 2. 使用获取到的数据进行加法运算   ---》思考：只有整型才能做运算
num1 = int(num1)
num2 = int(num2)
# 3. 在控制台输出计算结果，格式要求: xx + xx = xx - --》方式1：format
num3 = num1 + num2
print("{}+{} ={}".format(num1, num2,num3))
# 4. 在控制台输出计算结果，格式要求: xx + xx = xx - --》方式2：f - 格式化字符串
print(f"{num1} + {num2} = {num1 + num2}")

转义符：一类特殊的字符，使用两个字符，来表示一个特殊的字符
- \n 转义为一个字符，换行
- \t 转义为一个字符，tab键，制表符

运算符

算术运算符：常规数字运算

符号	作用	说明
+	加
-	减
*	乘
/	除
//	求商	获取的是两个数据做除法的商
%	求余	获取的是两个数据做除法的余数
**	幂次方	获取数的几次方(4**7：4的7次方)

比较运算符

注意：比较运算符的结果全

部为布尔值(True/False)

符号	作用	说明
==	相等	检查运算操作数的值是否相等，如果成立返回True，否则返回False
!=	不相等	检查运算操作数的值是否不相等，如果成立返回True，否则返回False
大于		检查左侧操作数的值是否大于右侧，如果成立返回True，否则返回False
>=	大于等于	检查左侧操作数的值是否大于或等于右侧，如果成立返回True，否则返回False
<	小于	检查左侧操作数的值是否小于右侧，如果成立返回True，否则返回False
<=	小于等于	检查左侧操作数的值是否小于或等于右侧，如果成立返回True，否则返回False

赋值运算符

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a，相当于a=a+b
-=	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a*=b，将a×b的值给a
/=	除后赋值	a/=b，将a÷b的商给a
%=	取余后赋值	a%=b，将a÷b的余数给a

注意事项

= ，单等号在程序语言中不表示比较，用于赋值
复合赋值运算符之间没有空格，连接在一起

逻辑运算符

在程序开发中，通常在判断条件时，会需要同时判断多个条件
只有多个条件都满足，才能够执行后续代码，这个时候需要使用到逻辑运算符
逻辑运算符可以把多个条件按照逻辑进行连接，变成更复杂的条件
and：逻辑与
or：逻辑或
not：逻辑非

流程控制

判断语句

判断的定义：

如果条件满足，才能做某件事情，
如果条件不满足，就做另外一件事情，或者什么也不做

提示：判断语句涉及的关键字有 if、elif、 else

if 要判断的条件:

条件成立时，要做的事情

else:

条件不成立时，要做的事情

注意：

if 和 else 语句以及各自的缩进部分共同是一个完整的代码块

else 关键字必须和 if 联合使用, 不能单独使用

if 条件1:

条件1满足执行的代码

elif 条件2:

条件2满足时，执行的代码

elif 条件3:

条件3满足时，执行的代码

······

else:

以上条件都不满足时，执行的代码

提示：elif 和 else 都必须和 if 联合使用，而不能单独使用

循环语句

while语句基本语法

初始条件设置 # 通常是重复执行的计数器

while 条件: # 判断计数器是否达到目标次数

条件满足时，做的事情1

条件满足时，做的事情2

条件满足时，做的事情3

...(省略)...

处理条件(计数器 + 1)

while Ture ：执行无限循环

while break ：如果条件成立，就退出程序，后续代码不再执行

continue：如果条件成立，就结束本次循环，后面的代码不再实现，但是会开启一个新的循环

image-20230923154759949转存失败，建议直接上传图片文件 python1

1. 案例一

1. 获取用户输入的用户名和密码
2. 判断用户名是 admin 并且密码是 123456 时, 在控制台输出: 登录成功!
3. 否则在控制台输出: 登录信息错误!
user = input("输入用户名")  # 获取用户名
password = input("输入密码")  # 获取密码
if user == "admin" and password == "123456":
    print("登录成功!")
else:
    print("登录信息错误!")

2. 案例二

1. 定义两个整数变量python_score、c_score，使用 input 获取成绩 编写代码判断成绩
2. 要求只要有一门成绩 >= 60 分就输出合格
python_score = int(input("获取成绩"))
c_score = int(input("获取成绩"))
if python_score >= 60 or c_score >= 60:
    print("合格")
else:
    print("不合格")

3. 案例三

1. 获取用户输入的用户名
2. 判断用户名是 admin 时, 在控制台输出: 欢迎 admin 登录! 
3. 判断用户名是用户名是 test 时, 在控制台输出: 欢迎 test 登录!
4. 如果是其他信息, 在控制台输出: 查无此人!
user = input("输入用户名")  # 获取用户名
if user == "admin":
    print("欢迎 admin 登录! ")
elif user == "test":
    print("欢迎 test 登录!")
else:
    print("查无此人!")

4.练习：if elif else 结构

1. 定义 score 变量记录考试分数
2. 如果分数是 大于等于 90分 显示 优
3. 如果分数是 大于等于 80分 并且 小于 90分 显示 良
4. 如果分数是 大于等于 70分 并且 小于 80分 显示 中
5. 如果分数是 大于等于 60分 并且 小于 70分 显示 差
6. 其它分数显示 不及格
score = int(input("输入分数"))
if score >= 90:
    print("优")
elif score >= 80:
    print("良")
elif score >= 70:
    print("良")
elif score >= 60:
    print("差")
else:
    print("不及格")

5.练习：if 嵌套

取款机取钱的过程, 假定 你的密码是: 123456,  账户余额为 1000
1. 提示用户输入密码
2. 判断密码是否正确
3. 如果密码正确：
    3.1提示输入取款的金额
    3.2判断取款的金额和余额的关系
        3.2.1 取款成功
        3.2.2 余额不足
4.否则提示密码错误
balance = int(1000)
password1 = 123456
password2 = int(input("输入密码"))
if password2 == password1:
    if int(input("输入取款的金额")) >= balance:
        print("余额不足")
    else:
        print("取款成功")
else:
    print("密码错误")

6.典型案例-石头剪刀布

1. 从控制台输入要出的拳  石头(1) 剪刀(2) 布(3)
2. 电脑随机出拳
3. 比较胜负平
import random
player = int(input("输入 石头(1) 剪刀(2) 布(3)"))
computer = random.randint(1, 3)
print(computer)
if player == computer:
    print("平局")
elif (player == 1 and computer == 2) or (player == 2 and computer == 3) or (player == 3 and computer == 1):
    print("胜")
else:
    print("负")

步骤

# 1. 从控制台输入要出的拳  石头(1) 剪刀(2) 布(3)
player = input()
# 2. 电脑随机出拳
computer = xx
# 3. 比较胜负
    # 3.1 玩家胜利
        # 3.1.1 玩家出石头 并且 电脑出剪刀
        player == 1 and computer == 2
        # 3.1.2 玩家出剪刀, 电脑出布  or 
        player == 2 and computer == 3
        # 3.1.3 玩家出布, 电脑出石头  or
        player == 3 and computer == 1
    # 3.2 平局(出的一样就是平局)
        player == computer
    # 3.3 玩家失败（只要不是玩家胜利或平局，剩下一定是失败）
        else

Python随机函数random使用详解(推荐)

www.pythontab.com/html/2018/p…

7.练习：while 循环

# 需求: 打印 100 遍 "媳妇儿,我错了"
i = 1
while i <= 100:
    print("媳妇儿,我错了")
    i = i + 1
print(i)  # 获取执行结束的i的值

8.典型案例-石头剪刀布-while循环

普通代码改循环【套路】:
1. 先确定哪些代码需要重复执行
2. 书写 while 循环
3. 选中需要重复执行的代码,使用 tab 键进行缩进
-----
1. 运行一次,只能玩一次游戏  --> 加入 循环(无限循环)
2. 输入 1 2 3 之外的数据,判断结果为 玩家失败  ---> 添加判断,如果输入的不是 1 2 3, 让其重新输入，重新开启下一次游戏
3.无法退出游戏   ---> 添加退出选项 退出 0
import random
while True:
    player = int(input("输入 石头(1) 剪刀(2) 布(3)"))
    computer = random.randint(1, 3)
    if player==0: 
        print("欢迎下次再玩")
        break
    if player not in (1,2,3):
            print("重新输入")
            continue
    if player == computer:
        print("平局")
    elif (player == 1 and computer == 2) or (player == 2 and computer == 3) or (player == 3 and computer == 1):
        print("胜")
    else:
        print("负")

9.案例-while循环-计算0~100所有数字的累加和结果

# 累加和: 0 + 1 + 2 + 3 + ... + 100 = 5050
---------
难点: 需要 0 ~ 100 之间的数字, 使用循环, 从 0 开始 ,每次+1, 到 100 结束
把数字全部相加即可, 需要一个变量保存相加的结果
i=0
result =0
while i<=100:
    result +=i
    i+=1
    print(f"0~100相加的结果={result}")

10.练习：for 循环

# 需求：打印 100 遍 "媳妇儿,我错了"
for i in range(100):
    print("媳妇儿,我错了")

# 需求：for 循环 实现0到100求和
i=0
sum_num =0
for i in range(101):
    sum_num +=i
    i+=1
    print(sum_num)

11、综合案例

# 提示用户输入登录系统的用户名和密码
# 校验用户名和密码是否正确（正确的用户名：admin、密码：123456）
# 如果用户名和密码都正确，打印“登录成功！”，并结束程序
# 如果用户名或密码错误，打印“用户名或密码错误！”，提示用户继续输入用户名和密码登录
# 如果用户输入的用户名为“exit”，则退出程序
while True:
# 提示用户输入登录系统的用户名和密码  --> input
    user=input("请输入登录用户名")
    password=int(input("请输入登录密码"))
# 如果用户输入的用户名为“exit”，则退出程序  --> break
    if user =="exit":
        print("操作错误")
        break
# 校验用户名和密码是否正确（正确的用户名：admin、密码：123456）  -->  if and
# 如果用户名和密码都正确，打印“登录成功！”，并结束程序  --> while break
    if (user=="admin")and(password==123456):
        print("登录成功！")
        break
# 如果用户名或密码错误，打印“用户名或密码错误！”，提示用户继续输入用户名和密码登录  --> continue
    if (user!="admin")or(password!=123456):
        print("用户名或密码错误！")
        continue

练习

# 1. 提示用户输入用户姓名，并保存到变量中
name = input('请输入姓名')
# 2. 提示用户输入用户年龄，保存到变量中，并转换成整数
age = input('请输入年龄')
age = int(age)
# 3. 提示用户输入用户身高，保存到变量中，并转换成浮点数
height = float(input('请输入身高'))
# 4. 在控制台输出用户姓名、年龄、身高对应变量的数据类型
print({name}, {age}, {height})
# 5. 按照以下格式输出用户信息：“姓名:xxx 年龄:xxx 身高:xxx”
print(f"姓名:{name} 年龄:{age} 身高:{height}")
# 6. 在控制台输出该用户5年之后的年龄，格式：“张三 5 年之后的年龄是 25”
print(f"{name}5年之后的年龄是{age+5}")
# 7. 在控制台输出该用户现在是否成年，格式：“张三是否成年：True”
print(f"{name}是否成年：{age>=18}")

数据序列

字符串

1. 定义

使用引号(单引号,双引号,三引号)引起来的内容就是字符串.

可使用单引号、双引号、三引号定义字符串
字符串本身包含引号号时，要使用其他引号
字符串本身包含引号时，也可以使用\转义
不想让字符串的转义字符进行转义，可以在字符串前面加上r

# 3种定义方式
# 使用单引号定义
my_str = 'hello'
# 双引号定义
my_str1 = "hello"
# 三引号定义
my_str2 = """hello world"""
my_str3 = '''hello'''
# 字符串本身包含单引号, 定义不能使用单引号,可以使用双引号和三引号，其他引号也同理
my_str4 = "I'm 小明"
print(my_str4)
# 3. 字符串本身包含单引号,定义的时候 还是想用 单引号, 字符串本身的引号 可以使用 转义字符 \ 进行转义
my_str5 = 'I\'m 小明'
print(my_str5)  # I'm 小明
# 4. 记忆:不想让字符的转义字符进行转义, 可以在字符串前边加上一个字符 r(raw) 原生字符串,不会进行转义
# 应用: Windows 的文件的路径,都会加上r, 防止转义
my_str7 = r'c:\user\rjcs\'tython 阶段'  # \t tab键制表符
print(my_str7)  # c:\user\rjcs\'tython 阶段

2. 索引(下标)

索引(下标) 是数据在容器中的位置编号. 对于字符串来说,就是字符在整个字符串中的位置.

一般情况下,使用的都是正数索引(从左到右), 从 0 开始的
Python 中支持负数索引(从右到左),-1 表示容器中最后一个数据
使用索引(下标) 可以获取容器中指定位置的数据变量[下标]
下标是整数数字

0	1	2	3	4	5	6	正数索引
a	b	c	d	e	f	g	字符串
-7	-6	-5	-4	-3	-2	-1	负数索引

1.通过索引取字符串值（变量[下标]   第1个、最后1个、倒数第2个字符）
2.计算字符串有多少字符（字符串长度），通过字符串长度获取最后字符

my_str = 'abcdefg'
# 打印字符串中一共有多少个字符字符串长度  len(容器)
print(len(my_str))  # 7
# 通过字符串长度获取最后字符 len(my_str)=7 
print(my_str[len(my_str)-1])  # g
# 分别使用 for 循环 和 while 循环对字符串进行遍历(将字符串中每个字符都取出,进行打印)
# for循环遍历字符串
# for i in my_str:
#     print(i)  # 输出字符串中每一个字符

# while循环 循环次数（字符串、循环次数确定，字符串中有多少个字符，就循环多少次 len()）
j = 0  # 0 1 2 3 4 5 ... 与字符串中的下标对应一致
while j < len(my_str):  # 把j当做字符串的下标
    print(my_str[j]
    j += 1   # 修改计数次数

3. 切片[常见]

使用下标(索引) 可以获得字符串中指定位置的一个字符
使用切片可以获取字符中多个字符

语法格式：字符串[start: end: step]
- start: 开始位置的下标, 从哪个位置开始取字符
- end: 结束位置的下标, 取到哪里结束(end 对应位置的数据不能取到的)
- step: 步长. 所取字符串中相邻两个数据下标之间的间隔（索引差值）
- 举例：str1='helloworld' str1[0:3:1] --> h e l str1[0:3:2] --> h l

my_str = 'abcdefg'
# 正常切片取cde   start:1 end:5 step:1
print(my_str[1:5:1])
# 1.字符串切片，如果步长为1，可以不写
print(my_str[1:5])
# 取efg  start:4  end:7  step:1
print(my_str[4:7])
# 2.字符串切片，如果取到最后一个字符，结尾位置可以不写，但是：必须要写
print(my_str[4:])
# 取aceg  start:0 end:7 step:2
print(my_str[0::2])
# 3.字符串切片，如果从0开始切，开始位置可以不写
print(my_str[::2])
# 从0开始，最后一个字符不取，ace
print(my_str[:-1:2])
# 4.补充，特殊情况，切片步长可以是负数，应用在字符串反转、颠覆、倒置
my_str7 = my_str[::-2] # 字符串位置反转
print(my_str7)   # geca

4.字符串查找 find[常见]

查找某字符是否存在于当前字符串中.
语法格式：字符串.find(sub_str)
- sub_str: 要查找的内容
返回值(返回): 是指这行代码执行的结果
- 如果找到sub_str, 返回 sub_str 出现的下标【正数索引】
- 如果没有找到sub_str, 返回 -1(-1不是索引，相当于失败的意思，固定语法)

5. 字符串替换 replace[常见]

语法格式：字符串.replace(old_str, new_str, count)
- 将字符串中的 old_str 替换为 new_str
- old_str: 原字符串(要替换的字符串)
- new_str: 新字符串(替换为的字符串)
- count: 替换的总次数,一般不写,表示全部替换
返回一个替换之后的完整的字符串, 原来的不会改变

my_str = 'good good study'
# 需求：将 good 全部替换 GOOD(替换全部值 字符串.replace(old_str, new_str))
my_str1 = my_str.replace('good','GOOD')
print('my_str2: ',my_str2)
# 需求：仅替换第1个(字符串.replace(old_str, new_str, 1))
my_str2 = my_str.replace('good','GOOD',1)
print('my_str2: ',my_str2)
# 需求：仅替换第2个(无直接的语法，先全部替换为GOOD，再把第1个GOOD替换为good，曲线救国)
my_str3 = my_str.replace('good','GOOD').replace('GOOD','good',1)
print('my_str3: ',my_str3)

6. 字符串切割 split[常见]

切割, 分隔, 拆分

语法格式：字符串.split(sep)
- 字符串按照指定字符串 sep 进行切割
- sep, 指定按照什么字符串进行分隔,可以不写,默认是空白字符(空格, \n, \t)
返回: 返回的是列表,列表中的内容是分隔之后的字符串
- 1.按照默认字符拆分【字符串.split() 空格, \n, \t】
- 2.按照空格拆分【字符串.split(' ')】
- 3.按照指定字符拆分【字符串.split('xxx')】注意：拆分字符xxx会被去掉

my_str = 'hello Python and\titcast and\nitheima'
# 1.按照默认字符拆分(空格, \n, \t)
my_str1 = my_str.split()
print('my_str1: ',my_str1)
# my_str1:  ['hello', 'Python', 'and', 'itcast', 'and', 'itheima']
# 2.按照空格拆分(' ')
my_str2 = my_str.split(' ')
print('my_str2: ',my_str2)
# my_str2:  ['hello', 'Python', 'and\titcast', 'and\nitheima']
# 3.按照指定字符拆分 and
my_str3 = my_str.split('and')
print('my_str3: ',my_str3)
# my_str3:  ['hello Python ', '\titcast ', '\nitheima']

7.字符串连接 join

语法格式：字符串.join(容器)
- 容器一般使用的都是列表,使用字符串将列表中的内容连接起来.得到一个新的字符串
注意点: 容器(列表) 中的数据必须都是字符串类型
使用指定字符连接容器(列表) 'xxx'.join([x,x,x])

my_list = ['a', 'b', 'c', 'd']
# my_list = 'abcd'  # 字符串本身也可以连接
my_str1 = ' '.join(my_list)  # 使用空格连接列表中的字符
my_str2 = '_*_'.join(my_list)  # 使用 _*_ 连接列表中的字符
print('my_str1: ',my_str1)
print('my_str2: ',my_str2)
print('my_str3: ',my_str1+my_str2)  # 字符串合并使用+即可

字符串常用方法小结

1-定义
	使用引号引起来 '' "" '''''' """"""
	如果字符包含引号：1-使用另外的引号；2-使用转义字符\
	如果windows路径包含转义字符\,不想让转义字符生效，在前面加上r
2-索引
	索引使用来获取指定的1个字符，正向索引从0开始，反向索引从-1开始
	获取字符串的长度len(字符串/变量)
3-切片
	str[start:end:step]  # step代表的是索引的差值
	字符串反转：str[::-1]
4-查找
	str.find(str2):找到返回索引，找不到返回-1（-1是默认格式，不是反向索引）
5-替换
	str.replace(old,new,count)  # count可以不写代表全部；也可以执行前count个
6-切割
	str.split(str2) # 如果不指定，默认按照空格 \t \n 切割；也可指定字符切割
7-连接
	str.join(list)  # 按照指定的字符将列表中的字符拼接为新的字符串  '_*_'.join([])

列表 list[重点]

列表 list, 可以用来存储一组(多个)数据
列表中的多个数据之间使用逗号隔开
列表表现形式为 []
列表中可以存储任意类型的数据（比如整型、浮点型、布尔型、字符串...）

1.定义

1. 类的实例化list()定义（空列表非空列表-字符串）
1. 直接使用[]定义（空列表非空列表）
1. 也可以使用len(列表)求列表长度

# 1.类的实例化list定义（空列表 非空列表）
# 1.1 通过类的实例化定义空列表
list1 = list()
print('list1: ',list1)
# 1.2 类型转换 通过list(容器) 将其他容器转为列表
list2 = list('good')  # 将字符串中每一个字符都做为1个数据单独存入列表中
print('list2: ',list2)  # ['g', 'o', 'o', 'd']
# 2.直接使用[]定义（空列表 非空列表)-->推荐
# 2.1 直接使用[]定义空列表
list3 = []
print('list3: ',list3)
# 2.2 使用[]创建非空列表，列表中可以存入任意类型数据
list4 = [123,1.75,True,'hello']
print('list4: ',list4)
# 3.补充：列表长度 len(列表)
print(len(list4))  # 4

2. 列表索引(下标)和切片

1. 通过索引取列表的值（列表[下标] 第1个、最后1个）
1. 使用切片可以获取列表中多个值列表[start: end: step]

# 列表索引和切片
my_list = ['小明',18,1.81]
# 通过索引获取第1位数
print(my_list[0])  # 小明
# 通过索引获取最后一位
print(my_list[-1])  # 1.81
# 列表切片，返回的还是列表
print(my_list[0:2])  # ['小明', 18]

3. 列表遍历[重点]

1.通过for循环遍历列表【推荐】

my_list = ['登录成功','用户名为空','密码错误']
# 列表遍历-for 循环
for i in my_list:
    print(i)
# 列表遍历-while 循环
j = 0  
while j < len(my_list):  
    print(my_str[j]
    j += 1

4.统计列表中某个数据的个数[面试]

语法格式：变量 = 列表.count(数据)
- 统计数据在列表中出现的次数

my_list = [1,2,3,1,2,0]
num1=my_list.count(1)  # 统计1出现的次数  2
print(num1)
num2=my_list.count(5)  # 统计5出现的次数  0
print(num2)

# 1-如何判断某个数据是否出现列表当中
if my_list.count(2) > 0:
    print(f"该数据存在列表中,一共出现{my_list.count(2)}次")
    
# 2-通过in判断
print(2 in my_list)  # True

5.列表的增删改[重点]

1. 不要使用 print 直接打印,

2.不要使用变量来保存，想要查看修改之后的数据,直接打印原列表

增加

语法格式：列表.append(数据)
- 在列表的尾部添加一个数据
返回: None(1.不要使用 print 直接打印, 2.不要使用变量来保存)，想要查看添加之后的数据,直接打印原列表
一次只能添加1个数据

删除

语法格式：列表.pop(下标)
- 删除列表中指定下标对应的数据,
下标可以不写,默认删除最后一个数据
返回的是删除的数据

修改

修改使用下标去修改对应位置的数据
语法格式：列表[下标] = 数据值

练习

使用随机数向列表添加 10 个 1-20 之间的随机整数
统计数据 8 出现的个数
删除最后一个数据
修改第一个数据为 8
再次统计数据 8 出现的个数要求: 每次操作完成后,打印列表,查看列表的变化.

import random
# 1. 使用 随机数 向列表 添加 10 个 1-20 之间的随机整数
# 1.1 创建空列表
my_list = []
# 1.2 使用循环 执行添加10次
for i in range(10):
    # 1.3 使用random 获取1~20的随机数
    num = random.randint(1,20)
    # 1.4 添加到列表
    my_list.append(num)
# 1.5 返回生成的列表
print(my_list)
# 2. 统计 数据 8 出现的个数
num2 = my_list.count(8)
print(f'数据8在列表出现的次数：{num2}')
# 3. 删除 最后一个数据
my_list.pop()
print(my_list)
# 4. 修改第一个数据为 8
my_list[0] = 8
print(my_list)
# 5. 再次统计 数据 8 出现的个数
num3 = my_list.count(8)
print(f'修改列表后，数据8在列表出现的次数：{num3}')

6.列表反转/逆置[常见]

方法一使用切片列表[::-1] --> 不会修改原列表,得到一个新列表
方法二列表.reverse() ---> 直接修改原列表

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 方式一,使用切片, 生成一个新的列表, 原列表内容不会改变
my_list1 = my_list[::-1]
print('my_list :', my_list)
print('my_list1:', my_list1)
# 方式二 列表.reverse()  直接修改 原列表
my_list.reverse()
print('my_list :', my_list)

7.列表排序[常见]

将列表按指定规则进行数据排序, 默认为升序列表的排序, 是直接修改原列表
- 升序(默认) 从小到大列表.sort()
- 降序从大到小列表.sort(reverse=True)

my_list = [1, 4, 7, 2, 5, 8, 3, 6, 9]
# 升序,从小到大
my_list.sort()
# 降序 从大到小
my_list.sort(reverse=True)
print(my_list)

8. 列表的嵌套

列表中可以存放任意类型的数据
列表中可以保存列表
列表中存的都是列表,就称为是列表嵌套

不管列表中嵌套什么数据,只需要根据列表的语法取数据

my_list = [['登录成功','admin','123456'],['用户名错误','user','123456'],['密码为空','admin','']]
# 嵌套取值：取第2个子列表中的用户名出来
# my_list2 = my_list[1]
# print(my_list2,type(my_list2))
# print(my_list2[1])
print(my_list[1][1])
# 嵌套修改：把第3个子列表的用户名改为user
my_list[2][1] = 'user'
print(my_list)
# 嵌套删除：删除第3个子列表的密码
my_list[2].pop()  # 默认删除最后一个
print(my_list)
# 嵌套添加：添加第3个子列表的密码为"123456"
my_list[2].append("1234546")
print(my_list)

列表的常用方法小结

1-定义
    list()  或 []  可以是空列表，也可以是非空列表
    len(list) 获取列表的长度
2-索引和切片
    list[索引]  取1个值
    list[start:end:step]  # 取多个值
3-列表的遍历
    for i in list：
        print(i)
4-列表统计某个数据出现的次数【面试】
    list.count(数据)  数据存在，返回出现的次数；数据不存在，返回0
5-列表的增删改
    新增1个数据：list.append(xxx)
    删除1个数据：list.pop(下标)  如果没有下标，默认删除最后一个
    修改数据：list[下标]=某个值
6-列表的反转
    方式一：切片    list[::-1]  # 生成新的列表，旧列表不改变
    方式二：reverse（）  list.reverse()  # 直接修改原列表数据
7-列表的排序【面试】
    list.sort()  # 升序
    list.sort(reverse=True)  # 降序
8-列表的嵌套
    list[][]  # 多层嵌套处理

元组tuple

1. 定义

元组 tuple , 表现形式为 ()
元组和列表一样,都可以存储多个数据, 都可以存储任意类型的数据
元组中的内容不能修改（增删改）, 列表中的可以修改
应用: 主要作为函数的参数和返回值, 在自动化课程中,数据需要组成元组
类的实例化tuple()定义【空列表-无意义数据转换非空列表-字符串、列表】
直接使用()定义【[特殊情况]定义只有1个数据的元组，必须有,逗号】
因为元组中的数据不能修改,所以只有查询方法：

- 下标获取单个数据
- 切片获取多个数据
- len() 求长度
- count() 统计某个数据个数
- 遍历

2. 交换两个变量的值

需求：a=10,b=20 --> a=20,b=10

在定义元组的时候, 小括号可以省略不写的
组包(pack): 将多个数据值,变成元组存储的过程
拆包(unpack): 将容器中的数据分别给到多个变量的过程, 需要保证容器中数据的个数和变量个数保持一致

a = 10
b = 20
a, b = b, a
print(a, b)

a = 10
b = 20
print(a,b)
# # 目标 交换2个变量的值---简单办法
# c = a
# a = b
# b = c
# print(a,b)
# 目标 交换2个变量的值---魔法【拆包和组包】
# temp = (a,b)
temp = a,b  # 与 temp = (10,20) 等价，定义元组时可以不写括号，也成为了组包pack
print(temp)
m,n = temp  # 拆包unpack，将容器中多个值分别给多个变量的过程
print(m,n)
# 直接将变量m,n 修改为a,b
b,a = temp  # 相当于 b,a = a,b
print(a,b)

字典dict【重点】

字典 dict, 是由键(key)值(value)对组成, 表现为 {键: 值, 键: 值, .... }
字典的键值对之间使用逗号隔开, 一个键值对表示一个数据
字典的键一般为字符串, 可以是数字
字典的值可以是任意类型
在一个字典中, 键(key)是不能重复的
字典中没有下标

1.定义

1.类的实例化dict()定义（空字典非空字典-列表套元祖）
2.直接使用{}定义（空字典非空字典）
3.也可以使用len(字典)求长度

# 1.类的实例化dict()定义（空字典 非空字典-列表套元祖）
my_dict = dict()
print(my_dict)
my_dict1 = dict([("name","小明"),("age","18")])  # 类型转换
print(my_dict1)
# 2.直接使用{}定义（空字典 非空字典）【推荐】
my_dict2 = {}
print(my_dict2)
my_dict3={"name":"小明","age":18,"height":1.81,"isMan":True,"like":['吃饭','睡觉','烫头']}
print(my_dict3)
# 3.也可以使用len(字典)求长度
print(len(my_dict3))

2.增加和修改[重点]

字典中没有下标
字典通过键(key)去修改数据

字典['键'] = 数据值
1. 如果键已经存在, 就是修改数据
1. 如果键不存在, 就是添加数据

3.删除[重点]

语法格式：字典.pop(键)

根据字典的键(key)删除指定的键值对

my_dict = {"name": "小明", "age": 18, "height": 1.78, "like": ["吃饭", "喝酒", "烫头"], 'sex': '男'}

# 1.如果键值不存在，则添加数据
my_dict["class"] = '1班'
print(my_dict)

# 2.如果键值存在，则修改数据
my_dict['age'] = 20
print(my_dict)

# 3.通过键名删除字典的值
my_dict.pop('sex')
print(my_dict)

# 4.字典中嵌套其他容器时的操作
# 我想给爱好like中添加一个 喝奶茶  -->本质：往列表中添加数据
# print(my_dict["like"],type(my_dict["like"]))
# my_dict["like"] = '喝奶茶'
# print(my_dict)
my_dict["like"].append('喝奶茶')
print(my_dict)
# 我想把最后一个爱好删除   --> 本质：是列表中删除一个数据
my_dict["like"].pop(-1)
print(my_dict)

4.查询

根据字典的键(key) 获取对应的值(value)

方式一
- 字典['键']
1. 键存在,获取对应的值
2. 键不存在, 代码直接报错
方式二[使用最多]
- 字典.get('键')
1. 键存在,获取对应的值
2. 键不存在, 返回 None

my_dict = {'name':'小明','age':18}
# 查询姓名 name，键存在,获取对应的值
print(my_dict['name'])
print(my_dict.get('name'))
# 查询性别 sex，键不存在
# print(my_dict['sex'])  # 报错，原因：健名不存在
print(my_dict.get('sex'))  # None

5.遍历

遍历: 将容器中的数据逐个取出.
字典是由键值对组成的, 字典的遍历分为三种

遍历字典的键(key)

for 变量 in 字典:  # 变量就是字典的键
    pass  # pass是空语句，是为了保持程序结构的完整性，不做任何处理
for 变量 in 字典.keys():  # 字典.keys()可以获取字典中所有的键(key)
    pass

遍历字典的值(value) [重点]

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

遍历字典的键(key)和值(value)

# 字典.items() 可以获取字典中所有的键值对,每个键值对组成元组
# 变量1 是键(key)  变量2 是值(value)
for 变量1, 变量2 in 字典.items():
    pass

my_dict = {"name": "小明", "age": 18, "height": 1.78}
# 遍历字典的键
方式一
for k in my_dict:
    print(k)
方式二
for k in my_dict.keys():
    print(k)
# 遍历字典的值
for v in my_dict.values():
    print(v)
# 遍历字典的键值
for k,v in my_dict.items():
    print(k,v)

字典的常用方法小结

1-什么是字典？
	键值对  键key 值value
2-字典有什么用？	
	可以存储测试数据（可以通过键描述数据的作用，方便理解）
3-字典如何定义？
	dict()   {}
4-字典如何进行增删改？
	新增和修改：dict["键"] 键不存在就是新增；如果存在就是修改
	删除：dict.pop("键")
5-字典如何进行查询？
	dict["键"]    dict.get("键")
6-字典如何进行遍历？
    遍历键  for i in dict:       for i in dict.keys():
    遍历值 for i in dict.values():    --->【使用较多】
    遍历键和值 for i,j in dict.items():

集合[了解]

集合 set, 表现形式 {数据, 数据, 数据}
集合中的数据是没有重复的(重要), 应用这个特点对列表中的数据进行去重【自动排序】

- 先将列表转换为集合类型,再将集合转换为列表类型

in/not in 对于字典来说, 判断的是键(key) 是否存在, 对其他容器来说,判断是否存在数据

my_list = [2,3,1,4,7,6,4,9,4]
# 列表去重方式一，利用集合自动去重【但是会自动排序，改变了原列表的顺序】
# result = list(set(my_list))
# print(result)
# 列表去重方式二，新建一个新的空列表，遍历旧列表数据，判断数据是否存在新列表中，如果不存在就将数据插入新列表，存在则不插入
# 1.定义新列表
new_list = []
# 2.遍历旧列表
for i in my_list:
    # 3.判断旧列表的数据是否存在新列表，不存在则添加
    if i not in new_list:
        new_list.append(i)
# 4.返回新列表
print(new_list)

容器综合案例

【套路】自己清楚 变量的类型,  类型确定了, 才能决定 使用什么方法,进行什么操作

需求：
参考TPshop项目的登录功能（登录时需要输入用户名、密码、验证码），至少设计3条测试用例
要求1：使用字典存储测试数据（方便识别数据作用），1个字典代表1个用例  {}
要求2：将3个字典数据合并到列表中，定义变量存储列表数据  [{},{},{}]
要求3：将 [{},{},{}]  ==> [(), (), ()]  注意：将字典的值（value）取出来转为元祖，字典的键不需要

案例思路

# 1.设计3个测试用例：
    1. 用户名错误  
    2. 密码错误
    3. 验证码错误
	# 定义字典,保存 tpshop 登录用例的数据 (用户名(username), 密码(password), 验证码(code),预期结果(expect)) ，每个测试用例对应不同的测试数据，测试用例数据使用字典保存：
	{"username": xxx, "password": xxx, code: xxx,expect: xxx}
# 2.将3个测试用例的数据汇总存放到列表中
	[{},{},{}]
# 3.将列表套字典的测试数据，试着转化为列表套元祖数据【为自动化测试的参数化做准备】
	[{},{},{}]  ===> [(),(),()]

案例代码

# 1.定义1个变量存储3组测试数据,假设正确的账户密码验证码是 15012344321 123456 8888
my_list = [
    {"username":15012344322,'password':123456,'code':8888,'expect':'用户名错误'},
    {"username":15012344321,'password':123,'code':8888,'expect':'密码错误'},
    {"username":15012344321,'password':123456,'code':6666,'expect':'验证码错误'}
]
# 2.将列表套字典的测试数据，试着转化为列表套元祖数据【为自动化测试的参数化做准备】
# [{},{},{}]  ===> [(),(),()] --》[(15012344322,123456,8888,'用户名错误'),(),()]
new_list = []
# 字典遍历方法：字典.values()  --> 得到一个字典全部的值组成的'列表'
for i in my_list:
    print(i)  # dict
    my_list2 = i.values()  # 得到字典全部的值组成的 '列表'
    print(my_list2)
    # 将字典全部的值组成的 '列表' 数据 转为元组
    my_tuple = tuple(my_list2)
    print(my_tuple)
    # 将元组添加到新列表中
    new_list.append(my_tuple)

print(new_list)

个人笔记，有很多不全，不懂的找其它专业人员(推荐) juejin.cn/post/684490… juejin.cn/column/7226…

python基础(测试)——个人笔记(1)

Python基础

认识Python

Python环境搭建

安装Python解释器

安装PyCharm

PyCharm中编写HelloWorld程序

基本语法

注释(就是对代码的解释和说明)

目的： 理清思路

分类：

注释-扩展

变量和标识符

变量

标识符

数据类型

程序的输入和输出

程序的输入

输出

运算符

算术运算符：常规数字运算

比较运算符

赋值运算符

逻辑运算符

流程控制

判断语句

循环语句

1. 案例一

2. 案例二

3. 案例三

4.练习：if elif else 结构

5.练习：if 嵌套

6.典型案例-石头剪刀布

Python随机函数random使用详解(推荐)

7.练习：while 循环

8.典型案例-石头剪刀布-while循环

9.案例-while循环-计算0~100所有数字的累加和结果

10.练习：for 循环

11、综合案例

练习

数据序列

字符串

1. 定义

2. 索引(下标)

3. 切片[常见]

4.字符串查找 find[常见]

5. 字符串替换 replace[常见]

6. 字符串切割 split[常见]

7.字符串连接 join

字符串常用方法小结

列表 list[重点]

1.定义

2. 列表索引(下标)和切片

3. 列表遍历[重点]

4.统计列表中某个数据的个数[面试]

5.列表的增删改[重点]

增加

删除

修改

练习

6.列表反转/逆置[常见]

7.列表排序[常见]

8. 列表的嵌套

列表的常用方法小结

元组tuple

1. 定义

2. 交换两个变量的值

字典dict【重点】

1.定义

2.增加和修改[重点]

3.删除[重点]

4.查询

5.遍历

遍历字典的键(key)

遍历字典的值(value) [重点]

遍历字典的键(key)和值(value)

字典的常用方法小结

集合[了解]

容器综合案例

目的：理清思路