python基础

妄心×

已于 2024-07-30 03:48:20 修改

阅读量345

点赞数 3

文章标签： python 开发语言

于 2024-07-18 09:27:39 首次发布

本文链接：https://blog.csdn.net/2401_82603291/article/details/140512349

版权

目标：

⽬标:
1. 学习掌握 python 的基本语法
2. 在代码中遇到常⻅的错误,⾃⼰能够动⼿解决问题
Python 只是⼀个编程语⾔,在⼯作中需要结合其他的⼯具使⽤
Python + selenium web ⾃动化(功能测试转换为代码)
Python + appium 移动端(⼿机端 APP)⾃动化
Python + requests 接⼝

python基础

一、认识Python

作者: 吉多·范罗苏姆(Guido van Rossum) ⻳叔
1989 年开始书写, 1991年诞⽣

问什么学习 Python?

简单, 易学, 免费, 开源, 适⽤⼈群⼴泛
应⽤领域⼴泛(⾃动化测试)

Python 的版本

Python2 (2.x 2.7)
Python3(主流使⽤的版本, 3.6 之后的版本(即⼤于等于3.6))

语⾔的分类:

计算机只认识 ⼆进制(0 和 1).
编程语⾔是⼈和计算机沟通的语⾔.
编程语⾔分类: 编译型语⾔, 解释型语⾔

二、Python环境配置

python 解释器(必须有): 将我们书写的 Python 代码转换为⼆
进制, 建议 版本 >= 3.6
pycharm(选装): 是 Python 中最好⽤的IDE(集成开发环境)之
⼀, 是⽤来书写代码运⾏代码,调试代码的...
vscode, idle , 记事本 ...

三、Python解析器安装

双击安装包
选择安装⽅式(可以默认安装, 可以⾃定义), 不要忘了勾选添加path环境变量

path 环境变量: 将⼀个软件或者程序添加到 path 环境变量之后, 就可以使⽤终端(cmd) 在任意路径下使⽤ 这个软件(如果没有环境变量,只能在安装⽬录使⽤)Python 安装之后, 在桌⾯中没有快捷⽅式,也不需要, 是在pycharm 中使⽤或者在cmd 中使⽤

四、pycharm安装

pycharm 有两个版本, ⼀个是专业版(收费的), ⼀个社区版(免
费使⽤)

直接双击安装即可, 看⻅⼀下界⾯即可

路径选择 (建议)

1. 可以直接使⽤默认的路径
2. ⾃定义路径
2.1 不建议使⽤中⽂
2.2 可以在某个盘的根⽬录中创建⼀个⽬录 tools, 可以将所以
学习阶段的环境都安装在 tools ⽬录
2.3 Python 安装, tools ⽬录中创建 Python36 ⽬录,
pycharm 安装,创建 pycharm 的⽬录, 其他软件的安装,都创建
⼀个⽬录
3. 严禁安装之后,⾃⼰剪切移动⽬录

使⽤ pycharm 书写代码

pycharm 是书写代码的软件,还能运⾏代码, 运⾏代码的前提是在 pycharm 软件中配置了解释器.

pycharm 组织代码的⽅式是 项⽬(project), 简单的理解为⼀
个⽬录, ⽬录中可以放很多的代码

建议: 每天的代码作为⼀个项⽬
每次在创建项⽬的时候, 需要保证这个⽬录是⼀个空⽬录

双击打开 pycharm 软件
创建新项⽬

配置项⽬的路径和解释器

创建代码⽂件书写代码

1. 将来在⼯作中, 代码的⽂件名字不要使⽤中⽂,但⽬前学习
阶段,我会使⽤中⽂
2. Python ⽂件的后缀是 .py
3. 代码要顶格书写
4. 代码中的标点符号要使⽤英⽂状态的标点

运⾏代码⽂件

查看运⾏结果

pycharm常见的设置

设置背景色

设置代码的字体和⼤⼩

右键菜单的使⽤

设置解释器

print 函数的简单使用

python命令

注释

1. 注释是对代码解释说明的⽂字, 不会执⾏, 可以增加代码的可读性
2. Python 中的注释分为两种, 单⾏注释和多⾏注释

单行注释

使⽤ 井号空格进⾏注释(单独⼀个# 也可以)
快捷键 Ctrl(cmd) /
1. 可以选中多⾏,使⽤快捷键
2. 如果代码已经添加注释, 再次使⽤快捷键,会取消注释

多⾏注释

多⾏注释中的内容 可以换⾏书写

多⾏注释可以使⽤ 3 对 双引号或者 3 对 单引号 , 被三对
引号包括的内容就是注释的内容

三对引号的注释,⼀般写在⽂件的最开始部分,或者⽂档注释
处(函数)

#这是单⾏注释,代码不会执⾏
# 以井号空格开始的注释
print('hello world')
"""
使⽤三对双引号包括起来的内容 ,也是注释,
可以换⾏, 不会执⾏
"""
'''
使⽤三对单引号包括起来的内容 ,也是注释,
可以换⾏, 不会执⾏
'''
print('end')

python必备内容

Python 代码中三种波浪线和 PEP8

红色

红⾊波浪线是代码的错误, 必须处理,代码才能执⾏

注意: 在后续课程中,某些代码没有写完,也会出现红⾊波浪线

灰⾊

灰⾊波浪线, 不会影响代码的正常执⾏, 基本上所有的灰⾊波
浪线都是 PEP8 造成的

PEP8: 是 Python 代码的书写规范, 如果不按照这个规范书
写,会给灰⾊波浪线提示,建议代码的书写按照 PEP8 的规范书
写

1. 可以书写代码的时候注意 PEP8 的代码规范
2. 可以在书写完成之后,使⽤快捷键 Ctrl Alt L 来按照
PEP8 的规范⾃动格式化代码

绿色

绿⾊波浪线, 不影响代码的正常执⾏, 在引号中, 认为你书写
的内容不是⼀个单词,就会给你绿⾊提示.

在 cmd 终端中运行 python代码

python 代码⽂件的名字

变量

作⽤

⽤来存储数据的(在程序代码中出现的数据,想要保存下来使⽤, 就必须使⽤变量)。如: 测试数据, ⽤户名, 密码, 验证码。

变量注意事项: 变量必须先定义(保存数据)后使⽤(取出数据).

定义变量

变量名 = 数据值 # 可以理解为 是将数据值保存到变量中
# ⽐如:
name = '张三' # 定义⼀个变量 name, 存储的数据值是 张三

使⽤变量

变量定义之后, 想要是使⽤变量中的数据, 直接使⽤变量名即可
# 使⽤变量获取数据, 打印
print(name)

# 定义⼀个变量,存储你的名字
name = '张三'
# 使⽤变量打印名字, 不需要加引号
print(name) # 张三
# 如果给 name 添加引号, 添加引号之后,输出的就是引号中的
内容
print('name') # name

变量名的命名规范

起名字的规范, 标识符的规则

必须由字⺟数字和下划线组成, 并且不能以数字开头
不能使⽤ Python 中的关键字作为变量名
- 关键字: Python ⾃带的已经使⽤的标识符,具有特殊的作⽤
区分⼤⼩写
建议性的命名
- 驼峰命名法
  - ⼤驼峰: 每个单词的⾸字⺟⼤写 MyName
  - ⼩驼峰: 第⼀个单词的⾸字⺟⼩写,其余单词的⾸字⺟
    
    ⼤写 myName
下划线连接法: 每个单词之间使⽤下划线连接 my_name

Python 中的变量的定义使⽤的是 下划线连接

⻅名知意

name 姓名 age 年龄 height 身⾼ ...

数据类型

将⽣活常⻅的数据划分为不同的类型, 因为不同的类型可以进⾏的操作是不⼀样的, 数字需要加减乘除 , ⽂字不需要 ...

数字类型

整型 (int ) , 就是整数 , 即不带⼩数点的数
浮点型( float ), 就是⼩数
布尔类型(bool), 只有两个值
真 True , 1
假 False 0, ⾮ 0 即真

True 和 False 都是 Python 中的关键字, 注意⼤⼩
写,不要写错了

复数类型 3 + 4i, 不会⽤的

⾮数字类型

字符串: (str) 使⽤引号引起来的就是字符串
列表 (list) [1, 2, 3, 4]
元组(tuple) (1, 2, 4, 4)
字典 (dict) {'name': '⼩明', 'age': 18}

type() 函数

可以获取变量的数据类型
type(变量)

想要将这个变量的类型在控制台显示, 需要使⽤ print 输出
print(type(变量))

# 整型 <class 'int'>
age = 18
print(type(age)) # type(age).print 回⻋

# 浮点型 <class 'float'>
height = 1.71
print(type(height))

# 布尔类型 <class 'bool'> True False
isMen = True
print(type(isMen))

# 字符串类型, 使⽤引号引起来的就是字符串 <class 'str'>
name = '⼩明'
print(type(name))
num = '18'
print(type(num)) # str
num = 'True'
print(type(num)) # str

类型转换

根据代码的需要, 将⼀种数据类型转换另⼀种数据类型(将
input 输⼊得到的数字转换为整型)

语法:
变量 = 要转换为的类型(原数据)
1. 数据原来是什么类型
2. 你要转换为什么类型

注意点: 数据类型转换,不会改变原来的数据的类型, 会⽣成⼀个
新的数据类型

int() 将其他类型转换为 int 类型
1. 可以将 float类型的数字转换为整型
2. 可以将整数类型的字符串转换为整型 3 123
float() 将其他类型转换为浮点型

可以将 int 类型转换为浮点型 float(3) ---> 3.0
可以将数字类型的字符串(整数类型和⼩数类型) 转换为浮点型

str() 将其他类型转换为字符串类型

任何类型都可以使⽤ str() 将其转换为字符串, ⼀般都是直接加上引号

输入输出

输入

获取⽤户使⽤键盘录⼊的内容

使⽤的函数是 input()
变量 = input('提示的信息')
1. 代码从上到下执⾏, 遇到 input 函数之后,会暂停执⾏,等待
⽤户的输⼊, r如果不输⼊会⼀直等待
2. 在输⼊的过程中,遇到回⻋,代表本次输⼊结束
3. 会将你输⼊的内容 保存到等号左边的变量中, 并且 变量的数
据类型 ⼀定是 str

result = input('请输⼊内容:')
print(type(result), result) # 打印数据类型和 数据值

# 1. 直接回⻋ <class 'str'>
# 2. ⼩明 <class 'str'> ⼩明
# 3. 18 <class 'str'> 18
# 4. True <class 'str'> True

输出

输出使⽤的函数是 print() 函数, 作⽤,将程序中的数据或者结果打印到控制台(屏幕)

print('hello world')
name = '⼩明'
print(name)
age = 18
print(name, age) # 可以使⽤逗号输出多个内容

格式化输出

在字符串中指定的位置,输出变量中存储的值.
1. 在需要使⽤变量的地⽅,使⽤特殊符号占位
2. 使⽤变量填充占位的数据

% 格式化输出占位符号
- %d 占位, 填充整型数据 digit
- %f 占位. 填充浮点型数据 float
- %s 占位, 填充字符串数据 string

补充: 其实 %s 的占位符,可以填充任意类型的数据

# 定义变量 姓名 年龄 身⾼
	name = '⼩明' # 可以使⽤ input 输⼊
	age = 18 # 可以使⽤ input 输⼊
	height = 1.71 # 可以使⽤ input 输⼊

# 要求按照以下个数输出个⼈信息
# 我的名字是 xx, 年龄是 xx, 身⾼是 xx m
# 使⽤格式化输出实现
# print('我的名字是 name, 年龄是 age, 身⾼是 heightm')
	print('我的名字是 %s, 年龄是 %d, 身⾼是 %f m' %(name, age,height))
# ⼩数默认显示 6 位, 如果想要指定显示⼩数点后⼏位, 
	%.nf , n 需要换成具体的整数数字,即保留⼩数的位置
	print('我的名字是 %s, 年龄是 %d, 身⾼是 %.2f m' (name,age,height)) 

# 两位⼩数
	print('我的名字是 %s, 年龄是 %d, 身⾼是 %.1f m' %
	(name, age, height)) # ⼀位⼩数
# 补充
	stu_num = 1 # 学号
# 我的学号是 000001
	print('我的学号是%d' % stu_num)
# %0nd n 需要换成具体的整数数字, 表示整数⼀共占⼏位
	print('我的学号是%06d' % stu_num)
	num = 90 # 考试的及格率
# 某次考试的及格率为 90%, 如果在 格式化中需要显示%,
在书写的使⽤ 需要使⽤ 两个 %% 才可以
	print('某次考试的及格率为 %d%%' % num)

F-string( f字符串的格式化⽅法)

f-string 格式化的⽅法,想要使⽤ ,Python 的版本 >= 3.6
1. 需要在字符串的前边加上 f"" 或者 F""
2. 占位符号统⼀变为 {}
3. 需要填充的变量 写在 {} 中

# 定义变量 姓名 年龄 身⾼
name = '⼩明' # 可以使⽤ input 输⼊
age = 18 # 可以使⽤ input 输⼊
height = 1.71 # 可以使⽤ input 输⼊

stu_num = 1 # 学号
num = 90 # 及格率
# print('我的名字是 xx, 年龄是 xx, 身⾼是 xx m, 学号
xx, 本次考试的及格率为 xx%')
  print(f'我的名字是 {name}, 年龄是 {age}, 身⾼是 {height} m, 
学号{stu_num}, 本次考试的及格率为{num}%')
# ⼀般不会有这样的需求
print(f'我的名字是 {name}, 年龄是 {age}, 身⾼是
{height:.3f} m, 学号 {stu_num:06d}, 本次考试的及格
率为 {num}%')
# 在字符串中想要输出换⾏ \n (转义字符)
print(f'我的名字是 {name}, 年龄是 {age}, 身⾼是
{height:.3f} m, 学号 {stu_num:06d},\n本次考试的及格
率为 {num}%')

快捷键(⼩操作)

添加引号括号: 可以直接选中要添加引号或者括号的内容, 书写
即可
撤销 : Ctrl Z
删除⼀⾏: Ctrl x
复制粘贴⼀⾏: Ctrl d
快速 在代码下⽅, 新建⼀⾏: shift 回⻋
优先级: 先算谁,再算谁 (不确定优先级,

运算符

算术运算符

优先级: 先算谁,再算谁 (不确定优先级,就使⽤ ())
() > ** > * / // % > + -

⽐较运算符

⽐较运算符得到都是 bool 类型
> < >= <=
== 判断两个数是否相等, 相等为 True, 不相等为 False
!= 判断两个数是否不相等, 不相等为 True, 相等为 False

字符串格式化的补充

字符串.format() 可以在任意版本中使用

1. 在需要使用 变量的地方使用 {} 占位
2. '{}, {}, ...'.format(变量, 变量, ...)

# 定义变量 姓名 年龄 身高

age = 18 # 可以使用 input 输入
height = 1.71 # 可以使用 input 输入
stu_num = 1 # 学号
num = 90 # 及格率
# print('我的名字是 xx, 年龄是 xx, 身高是 xx m, 学号 xx, 本次考试的及格率为 xx%')
print(f'我的名字是 {name}, 年龄是 {age}, 身高是 {height} m, 
    学号 {stu_num}, 本次考试的及格率为{num}%')

# 一般不会有这样的需求
print(f'我的名字是 {name}, 年龄是 {age}, 身高是 {height:.3f} m, 
    学号 {stu_num:06d}, 本次考试的及格率为 {num}%')

# 字符串.format()
print('我的名字是 {}, 年龄是 {}, 身高是 {} m, 学号 {}, 
    本次考试的及格率为 {}%'.format(name,age, height, stu_num, num))
print('我的名字是 {}, 年龄是 {}, 身高是 {:.3f} m, 
    学号 {:06d}, 本次考试的及格率为
{}%'.format(name, age, height, stu_num, num))

逻辑运算符

逻辑运算符 可以连接多个条件, 在判断和循环中使用

and 逻辑与 和,并且 and 连接两个条件,都必须为 True, 整体结果才为 True, 即一假为假 (当第一个条件为False 的时候,第二个条件就不再判断)

or 逻辑或 或者 or 连接的两个条件, 只要有一个条件为 True , 整体结果就为 True, 即 一真为真 (当第一个条件为 True的时候,第二个条件就不再判断)

not 逻辑非 取反 not 后边的条件, 如果本来是 True,变为 False, 本来是 False,变为 True

赋值运算符

赋值运算符 =, 作用就是将等号右边的值保存到等号左边的变量中

复合赋值运算符(将算术运算符和赋值运算符进行结合)

+= -= *= /= //= %=
a += b ===> a = a + b

运算符优先级

不需要刻意去记忆优先级,因为可以使用 () 改变优先级

python判断

日常生活中说的 如果 ... 否则 .... ,这个就是判断,在程序代码中需要使用 if(如果) elif(如果) else(否则) 三个关键字来实现

在代码中有判断语句, 待会不会全部执行, 会有一部分不会执行

一、if 的基本结构

即 只有 如果的情况, 如果的条件成立, 会执行的代码,会做的事

基本语法

if 判断条件:
  书写条件成立(真),执行的代码
  书写条件成立(真),执行的代码
  
顶格书写,没有缩进的代码,和 if无关, 不管条件是否成立,都会执行

# 1. if 是一个关键字, 和后续的判断条件之间需要一个空格
# 2. 判断条件后边需要一个冒号,不要少了
# 3. 冒号之后,回车,代码需要缩进, 在 pycharm 中会自动进行缩进, 一般是 4 个空格 或者 一个 tab
键
# 4. 所有在 if 代码下方的缩进中书写的代码,属于 if 语句的代码块, 判断条件为 True 的时候会执行
# 5. if 代码块中的代码,要么都执行,要么都不执行
# 6. if 代码块结束之后, 代码要顶格书写(不再有缩进), 表示是和 if 无关的代码

代码案例

1. 使用 input 获取用户的年龄
2. 判断年龄是否满足 18 岁
3. 如果年龄大于等于(满足)18 岁, 输出 '满 18 岁了,可以进入网吧为所欲了'

# 1. 使用 input 获取用户的年龄, 类型是 str
age = input('请输入你的年龄:')

# 2. 判断年龄是否满足 18 岁
if int(age) >= 18: # 字符串和 int 类型不能比大小, 先类型转换,再比大小
# 3. 如果年龄大于等于(满足)18 岁, 输出 '满 18 岁了,可以进入网吧为所欲了'
print('满 18 岁了,可以进入网吧为所欲为了')
print('我和 if 判断没有关系,不管怎样,都会执行')

练习

1. 获取用户输入的用户名信息
2. 如果用户名信息是 admin, 就在控制台输出出来

# 1. 获取用户输入的用户名信息
  name = input('请输入你的用户名:')
# 2. 如果用户名信息是 admin, 就在控制台输出出来
if name == 'admin':
  print('欢迎 admin')

二、if else 结构

如果 条件成立 做什么事 否则(条件不成立) 做另一件事

基本语法

if 判断条件:
  书写条件成立(真),执行的代码
  书写条件成立(真),执行的代码
else:
  书写条件不成立(假), 执行的代码
  书写条件不成立(假), 执行的代码
# 1. else 是关键字, 后边需要冒号
# 2. 冒号之后回车,同样需要缩进
# 3. 处于 else 代码下方缩进中的内容,属于 else 的代码块
# 4. if 和 else 的代码块, 只会执行其中的一个
# 5. else 需要结合 if 使用
# 6. if else 之间不能有其他顶格书写的内容(不提 elif)

代码案例

1. 使用 input 获取用户的年龄
2. 判断年龄是否满足 18 岁
3. 如果年龄大于等于(满足)18 岁, 输出 '满 18 岁了,可以进入网吧为所欲为了'
4. 如果不满足, 输出 '不满 18 岁,回去写作业吧'

# 1. 使用 input 获取用户的年龄, 类型是 str
age = input('请输入你的年龄:')
# 2. 判断年龄是否满足 18 岁
if int(age) >= 18: # 字符串和 int 类型不能比大小, 先类型转换,再比大小
  # 3. 如果年龄大于等于(满足)18 岁, 输出 '满 18 岁了,可以进入网吧为所欲为了'
  print('满 18 岁了,可以进入网吧为所欲为了')
  # 4. 如果不满足, 输出 '不满 18 岁,回去写作业吧'
else:
  print('不满 18 岁,回去写作业吧')

三、if 和逻辑运算符结合使用

案例一

1. 获取用户输入的用户名和密码
2. 判断用户名是 admin 并且密码是 123456 时, 在控制台输出: 登录成功!
3. 否则在控制台输出: 登录信息错误!

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

案例二

1. 获取用户输入的用户名
2. 判断用户名是 admin 时, 在控制台输出: 欢迎 admin 登录!
3. 用户名是 test 时, 在控制台输出: 欢迎 test 登录!
4. 如果是其他信息, 在控制台输出: 查无此人!

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

# username == 'admin' 或者 'test'(一直 True, 空字符串是 False)
if username == 'admin' or 'test':
  pass # pass 关键字, 占位,

四、if elif else 结构

如果某个判断条件有多个, 此时建议使用 if elif else 结构来实现

语法

if 判断条件1:
  判断条件1成立,执行的代码
elif 判断条件2: # 只有判断条件1不成立,才会判断 判断条件2
  判断条件2成立执行的代码
else:
  以上条件都不成立,执行的代码
# 1. elif 也是关键字,后边和判断条件之间需要一个空格,判断条件之后需要冒号
# 2. 冒号之后回车需要缩进, 处在这个缩进中的的代码表示是 elif 的代码块
# 3. 在一个 if判断中,可以有很多个 elif
# 4. 只有 if 的条件不成立,才会去判断 elif 的条件
# 5. 在一个if 中, 如果有多个 elif , 只要有一个条件成立,后续的所有都不再判断
# 6. if elif else 结构, 和 if 的缩进相同的只能是 elif 和 else,如果是其他的,就表示 这个判断结构结束了


if 判断条件1:
  执行的代码
if 判断条件2:
  执行的代码
if 判断条件3:
  执行的代码
# 多个 if 的结构, 每个 if 都会进行判断,之间没有关联系

案例

1. 定义 score 变量记录考试分数
2. 如果分数是大于等于90分应该显示优
3. 如果分数是大于等于80分并且小于90分应该显示良
4. 如果分数是大于等于70分并且小于80分应该显示中
5. 如果分数是大于等于60分并且小于70分应该显示差
6. 其它分数显示不及格

elif 实现

多个 if 实现

五、Debug调试代码

debug 在代码中出现问题错误(bug), 可以使用 debug 来调试代码,查找错误.
我们使用 debug 主要用来 查看代码的执行步骤

打断点

在 pycharm 中, 代码和行号之间进行点击, 出现小红点即打断点, 再次点击小红点会取消断点

断点的位置,一般来说会在代码的第一行(在程序运行的时候,想要在什么地方停下来)

注意点: 可能会出现的 bug(pycharm 软件的问题): 代码中只有一个断点的时候不能 debug 调试查看代码执行过程, 解决方案,在代码其他任意地方多加一个断点

右键 debug 运行代码

单步执行代码

六、if 嵌套

if 嵌套, 是指在一个 if(elif else) 中嵌套另一个 if.
使用场景: 判断条件存在递进关系(只有第一个条件满足了,才会判断第二个条件)

语法

if 判断条件1:
  判断条件1成立,执行的代码
if 判断条件2:
  判断条件2成立,执行的代码
else:
  判断条件2不成立,执行的代码
else:
  判断条件1不成立,执行的代码

代码案例

取款机取钱的过程, 假定 你的密码是: 123456, 账户余额为 1000
1. 提示用户输入密码
2. 判断密码是否正确
3. 密码正确后,提示输入取款的金额,
4. 判断取款的金额和余额的关系

#取款机取钱的过程,假定你的密码是:123456,账户余额为1000 
pwd='123456' #可以预先定义变量,也可以在判断的时候直接使用
money=1000 #可以预先定义变量,也可以在判断的时候直接使用

#1.提示用户输入密码
password=input('请输入密码:')

#2.判断密码是否正确
ifpassword==pwd:
  print('密码正确,登录成功')

#3.密码正确后,提示输入取款的金额,
  get_money=int(input('请输入要取款的金额:'))  
  
#4.判断取款的金额和余额的关系
  ifmoney>=get_money:
    print('取款成功')
  else:
    print('余额不足')
else:
  print('密码有误,请再次尝试')

练习

假定某网站用户名固定为'admin',密码固定为'123456',验证码固定为'8888'
1.获取用户输入的用户名,密码和验证码
2.先判断验证码是否正确,如果正确打印输出验证码正确,再判断用户名和密码是否正确
3.如果验证吗不正确,直接输出验证码不正确,请重新输入

#假定某网站用户名固定为'admin',密码固定为'123456',验证码固定为'8888'

#1.获取用户输入的用户名,密码和验证码
username=input('请输入用户名:')
pwd=input('请输入密码:')
code=input('请输入验证码:')

#2.先判断验证码是否正确,如果正确打印输出验证码正确,
    再判断用户名和密码是否正确ifcode=='8888':
  print('验证码正确')
  #再判断用户名和密码是否正确
  ifusername=='admin'andpwd=='123456':
    print('用户名密码正确,登录成功')
  else:
    print('用户名或者密码错误,请再次尝试')
    
#3.如果验证吗不正确,直接输出验证码不正确,请重新输入
else:
  print('验证码不正确')

案例:猜拳游戏

案例的步骤:
1.自己出拳(石头(1)/剪刀(2)/布(3))input (player)
2.电脑随机出拳(使用随机数模块(工具)完成) (computer)3.判断输赢
3.1玩家胜利
3.1.1player==1andcomputer==2
or
3.1.2player==2andcomputer==3
or
3.1.3player==3andcomputer==1
3.2平局 player==computer
3.3玩家输了else

随机出拳

在Python中想要随机获得整数数字可以使用如下方法
#1.导入随机数工具包
importrandom
#2.使用工具包中的工具产生指定范围内的数字
random.randint(a,b) #产生[a,b]之间的随机整数,包含ab的

import random # 这行代码习惯性的放在第一行
num = random.randint(1, 3)
print(num)

代码

import random
# 1. 自己出拳(石头(1)/剪刀(2)/布(3)) input (player)
player = int(input('请出拳石头(1)/剪刀(2)/布(3):')) # 不要忘了类型转换
# 2. 电脑随机出拳 (使用随机数模块(工具)完成) (computer)
computer = random.randint(1, 3)
# 3. 判断输赢
# 3.1 玩家胜利
if (player == 1 and computer == 2) or
   (player == 2 and computer == 3) or 
   (player == 3 and computer == 1):
  print('恭喜你获得胜利')
# 3.2 平局 player == computer
elif player == computer:
  print('平局')
# 3.3 玩家输了 else
else:
  print('输了, 不要放弃, 再来一局')

循环

一、while循环

程序开发中(写代码), 有三大流程(三大结构):
1, 顺序, 代码从上到下,全部执行
2, 分支, 判断语句,代码有选择性的执行
3, 循环, 重复执行某一部分的代码

循环的作用就是让 指定的代码 重复的执行

语法

1. 设置循环的初始条件(计数器)
2. 书写循环的判断条件
while 判断条件:
  # 3. 需要重复执行的代码
  # 4. 改变循环的初始条件(计数器)
# 1. while 是关键字

代码

# 1. 设置循环的初始条件 (记录说了几遍 我错了)
i = 0
# 2. 书写判断条件
while i < 5:
  # 3. 重复执行的代码
  print('媳妇, 我错了')
  # 4. 改变初始条件,
  # i = i + 1
  i += 1

死循环和无限循环

死循环: 一般是由写代码的人不小心造成的 bug, 代码一直不停的运行下去

无限循环: 写代码的人故意让代码无限制的去执行,代码一直不停的运行下去
无限循环的使用场景: 在书写循环的时候,不确定循环要执行多少次
无限循环的使用一般会在循环中添加一个 if 判断, 当 if 条件成立,使用关键字 break 来终止循环

while True:
重复执行的代码 # 可以在 if 的上边
if 判断条件:
    break # 关键字的作用就是终止循环, 
    当代码执行遇到 break,这个循环就不再执行了
重复执行的代码 # 可以在 if 的下边

书写循环的技巧:
确定这行代码执行几次,如果执行多次,就放在循环的缩进中,如果只执行一次,就不要放在循环的缩进中

import random
while True: # 不知道你想玩几次,所以使用 无限循环
# 1. 自己出拳(石头(1)/剪刀(2)/布(3)) input (player)
player = int(input('请出拳石头(1)/剪刀(2)/布(3)/退出(0):')) # 不要忘了类型转换
if player == 0:
  break # 代码遇到 break,就会终止循环
  
# 2. 电脑随机出拳 (使用随机数模块(工具)完成) (computer)
computer = random.randint(1, 3)

# 3. 判断输赢
# 3.1 玩家胜利
if (player == 1 and computer == 2) or (player == 2 and computer == 3) or (player
== 3 and computer == 1):
  print('恭喜你获得胜利')
# 3.2 平局 player == computer
elif player == computer:
  print('平局')
# 3.3 玩家输了 else
else:
  print('输了, 不要放弃, 再来一局')

使用循环求 1-100 之间数字的和

1 + 2 + 3 + ... + 99 + 100

# 1. 定义变量 保存求和的结果
num = 0

# 2 定义循环获取 1- 100 之间的数字并求和
# 2.1 定义初始条件
i = 1
# 2.2 书写循环的条件
while i <= 100:
  # 2.3 书写重复执行的代码
  # 0 + 1 + 2 + 3 + 4 + .. + 99 + 100
  num += i # 因为每一次 i 的值会变化
  # 2.4 改变计数器
  i += 1

# 3 打印求和的结果
print('求和的结果是:', num)

使用循环求 1-100 之间偶数的和

方法一

直接找到 1-100 之间所有的偶数,进行相加
2 4 6 8 .. 98 100

# 1. 定义变量 保存求和的结果
num = 0
# 2 定义循环获取 1- 100 之间的偶数并求和
# 2.1 定义初始条件
i = 2
# 2.2 书写循环的条件
while i <= 100:
  # 2.3 书写重复执行的代码
  num += i # 因为每一次 i 的值会变化 num = num + i
  # print(i)
  # 2.4 改变计数器
  i += 2 # 每次加 2, 才可以保证所有的数字都是偶数
# 3 打印求和的结果
print('求和的结果是:', num)

方法二

1. 找 1-100 之间所有的数字
2. 判断这个数字是不是偶数, 如果是偶数再求和
偶数: 能被 2 整除的数, (数字除 2 的余数是 0)
i % 2 == 0

num = 0
i = 1
while i <= 100:
  # 判断该数字是不是偶数,如果是偶数再求和
  if i % 2 == 0:
  # print(i)
  num += i
  # 改变计数器
  i += 1
  
print('求和的结果是:', num)

二、for循环

for循环也可以让指定的代码重复执⾏ (循环)
for循环可以遍历容器中的数据(
 遍历: 从容器中把数据⼀个⼀个取出
 容器: 可以简单理解为盒⼦, 盒⼦中可以存放很多的数据
(字符串 str, 列表 list, 元组 tuple, 字典 dict)
)
for 循环 也可以称为 for 遍历

基本的 for 循环语法:

for 变量名 in 容器:
 重复执⾏的代码
 
# 1. for 和 in 都是关键字
# 2. 容器中有多少个数据,循环会执⾏多少次(0 个数据,执⾏
0 次, ...)
# 3. 每次循环,会将容器中数据取出⼀个保存到 in 关键字前
边的变量中

for 做指定次数的循环

range() 变形

# 需求: 使⽤ for 循环获取 5 到 10 之间的数字
for 变量 in range(a, b):
 重复的代码
 
# range(a, b) 作⽤是⽣成 [a, b) 之间的整数数字, 不
包含 b

for i in range(5): # [0 1 2 3 4 ]
 print(i)
print('-' * 30)
# 需求: 使⽤ for 循环获取 5 到 10(包含) 之间的数字
for m in range(5, 11):
 print(m)

三、break 和 continue

break 和 continue 是 Python 中的两个关键字, 只能在循环中使⽤

break: 终⽌循环, 即代码执⾏遇到 break, 循环不再执⾏,⽴即结束

continue: 跳过本次循环. 即代码执⾏遇到 continue,本次循环剩下的代码不再执⾏, 继续下⼀次循环

# 1. 获取你输⼊的字符串
result = input('请输⼊⼀个字符串:')
# 2. 遍历打印这个字符串
for i in result:
# 3. 在遍历的时候,如果这个字符是 e, 不打印(即后续的
代码不执⾏)
 if i == 'e':
 continue # 本次循环后续的代码不执⾏,执⾏下⼀次
循环
 print(i)
print('-' * 30)
for i in result:
 # 3. 在遍历的时候,如果这个字符是 e, 不打印(即后续的
代码不执⾏)
 # 如果这个字符不是 e, 打印
 if i != 'e':
 print(i)

容器

容器: 也可以称为是数据序列, 或者⾼级数据类型, 也是Python 中的数据类型容器中可以存放多个数据.

一、字符串

字符串是容器, 因为字符串中可以包含多个字符

定义

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

# 1. 使⽤单引号定义
my_str1 = 'hello'
print(my_str1, type(my_str1))

# 2, 使⽤双引号定义
my_str2 = "hello"
print(my_str2, type(my_str2))

# 3. 使⽤三引号定义
my_str3 = """hello"""
print(my_str3, type(my_str3))
my_str4 = '''hello'''
print(my_str4, type(my_str4))

# 4. 字符串本身包含引号 I'm ⼩明
# 4.1 字符串本身包含单引号, 则在定义的时候不能使⽤单引号
# 4.2 字符串本身包含双引号, 则在定义的时候不能使⽤双引号
my_str5 = "I'm ⼩明"
print(my_str5)

# 5. 字符串本身包含单引号,在定义的时候,我就是想使⽤单引号
# 5.1 使⽤ \ 转义字符,将字符串本身的引号进⾏转义 \' -->
' \" --> "
my_str6 = 'I\'m ⼩明'
print(my_str6)

# 5.2 字符串 I\'m ⼩明 \\ --> \
my_str7 = 'I\\\'m ⼩明'
print(my_str7)

# 5.3 字字符串前边加上 r"" 原⽣字符串, 字符串中 的\不会
作为转义字符, ⽂件操作会⽤⼀下
my_str8 = r'I\'m ⼩明'
print(my_str8)
my_str9 = r'I\\\'m ⼩明'
print(my_str9)

二、下标

下标(索引): 就是指字符在字符串中的位置编号, 这个编号就是下标

这个编号⼀般来说都是从左到右进⾏编号的, 从 0 开始的(Python 中⽀持负数下标,从右到左进⾏编号的, 从-1 开始)

下标作⽤: 可以使⽤下标获取字符串中某个位置的字符

语法

字符串[下标] # 获取指定位置的字符

str1 = 'abcdefg'
# 1. 打印字符串中最开始位置的字符
print(str1[0]) # a
# 2. 打印最后⼀个位置的数据
print(str1[-1]) # g
# 3. 打印倒数第⼆个位置的字符
print(str1[-2]) # f

# 打印下标为 2 的数据
print(str1[2]) # c
# 获取字符串中字符的个数(获取字符串的⻓度)
# len(字符串) # length(⻓度)
num = len(str1)
print(num)
# ⻓度-1 的下标位置是最后⼀个字符
print(str1[num-1]) # g 最后⼀个字符,倒数第⼀个
print(str1[len(str1)-1]) # g 最后⼀个字符,倒数第⼀个

三、切⽚

可以获取字符串中多个字符(多个字符的下标是有规律的,等差数列)

语法：

字符串[start:end:step]
start 是开始位置的下标, end 是结束位置的下标(注意,不能取
到这个位置的字符) step 步⻓,等差数列的差值, 所取的相邻字
符下标之间的差值,默认是 1, 可以不写
例: [1:5:1] # 1 2 3 4
[1:5:2] # 1 3
[1:5:3] # 1 4
[1:5:4] # 1

# 切⽚会得到⼀个字符串, 即可以获取字符串中的多个字符
str1 = 'abcdefg'
# 1. 获取 abc 字符
print(str1[0:3:1]) # abc
# 1.1 如果步⻓是 1 可以不写, 最后⼀个冒号也不写
print(str1[0:3]) # abc
# 1.2 如果开始位置为 0 ,可以不写, 但是冒号必须有
print(str1[:3]) # abc
# 2. 获取 efg 字符
print(str1[4:7]) # efg
print(str1[-3:7]) # efg

# 2.1 如果最后⼀个字符也要取, 可以不写, 但是冒号必须有
print(str1[4:]) # efg
# 2.2 如果开始和结束都不写, 获取全部内容, 但是冒号必须有
print(str1[:]) # abcdefg
# 3. 获取 aceg # 0 2 4 6, 所以步⻓为 2
print(str1[0:7:2]) # aceg
print(str1[::2]) # aceg
# 4. 特殊应⽤, 步⻓为负数, 开始和结束不写,意思全变, ⼀般
不⽤管,只有⼀种使⽤场景
# 反转(逆置) 字符串 字符串[::-1]
print(str1[::-1]) # gfedcba

四、字符串方法

查找⽅法 find

字符串.find(sub_str, start, end) 
 作⽤: 在字符串中查找是否存在 sub_str 这样的字符串
 sub_str: 要查找的⼩的字符串
 start: 开始位置, 从哪个下标位置开始查找, ⼀般不写,默
认是 0
 end: 结束位置, 查找到哪个下标结束, ⼀般不写,默认是
len()
 返回(代码执⾏之后会得到什么, 如果有返回,就可以使⽤变
量保存):
 1. 如果在字符串中找到了 sub_str , 返回 sub_str
第⼀次出现的正数下标(sub_str 中第⼀个字符在⼤字符串中的
下标)
 2. 如果没有找到,返回 -1

 str1 = "and itcast and itheima and Python"
# 在字符串中查找 and
num = str1.find('and')
print(num) # 0
# 在字符串中查找 第⼆个 and 出现的下标, 从第⼀次出现的后
⼀位开始找
num1 = str1.find('and', num+1)
print(num1) # 11
# 在字符串中查找 第三个 and 出现的下标, 从第⼆次出现的后
⼀位开始找

num2 = str1.find('and', num1+1)
print(num2) # 23
# 在字符串中查找 第四个 and 出现的下标, 从第三次出现的后
⼀位开始找
num3 = str1.find('and', num2+1)
print(num3) # -1

替换⽅法 replace

字符串.replace(old_str, new_str, count) # 将字符串中
old_str 替换为 new_str
- old_str: 被替换的内容
- new_str: 替换为的内容
- count: 替换的次数, ⼀般不写,默认是全部替换
- 返回: 替换之后的完整的字符串, 注意: 原来的字符串没有发
⽣改变

str1 = 'good good study'
# 1, 将 str1 中 所有的 g 改为 G
str2 = str1.replace('g', 'G')
print('str1:', str1) # str1: good good study
print('str2:', str2) # str2: Good Good study

# 2. 将 str1 中第⼀个 good 改为 GOOD
str3 = str1.replace('good', 'GOOD', 1)
print('str3:', str3) # str3: GOOD good study
# 3. 将 str1 中第⼆个 good 改为 GOOD
# 3.1 先将全部的 good --> GOOD
str4 = str1.replace('good', "GOOD")
# 3.2 再将第⼀个 GOOD --> good
str4 = str4.replace('GOOD', 'good', 1)
print('str4:', str4) # str4: good GOOD study

拆分 split

字符串.split(sep, maxsplit) # 将字符串按照 sep 进⾏分
割(拆分)
- sep, 字符串按照什么进⾏拆分, 默认是空⽩字符(空格, 换
⾏\n, tab键\t)
- max_split, 分割次数,⼀般不写, 全部分割
- 返回: 将⼀个字符串拆分为多个,存到列表中
- 注意: 如果 sep 不写, 想要指定分割次数 则需要按照如下⽅
式使⽤
字符串.split(maxsplit=n) # n 是次数
str1 = "hello world and itcast and itheima and
Python"

# 1. 将 str1 按照 and 字符进⾏拆分
result1 = str1.split('and')
print(result1) # ['hello world ', ' itcast ', '
itheima ', ' Python']
# 2, 将 str1 按照 and 字符进⾏拆分, 拆分⼀次
result2 = str1.split('and', 1)
print(result2) # ['hello world ', ' itcast and
itheima and Python']
# 3. 按照空⽩字符进⾏切割
result3 = str1.split()
print(result3) # ['hello', 'world', 'and',
'itcast', 'and', 'itheima', 'and', 'Python']
# 4. 按照空⽩字符进⾏切割, 拆分⼀次
result4 = str1.split(maxsplit=1)
print(result4)

链接 join

字符串.join(列表) # 括号中的内容主要是列表,可以是其他
容器
# 作⽤: 将字符串插⼊到列表中每相邻的两个数据之间, 组成⼀
个新的字符串
- 列表中的数据使⽤使⽤ 逗号隔开的
- 注意点: 列表中的数据必须都是字符串, 否则会报错

list1 = ['good', 'good', 'study']
# 1. 将 列表中的字符串使⽤空格连起来
str1 = ' '.join(list1)
print(str1) # good good study
# 2. 将 列表中的字符串使⽤ and 连起来
str2 = ' and '.join(list1)
print(str2) # good and good and study

五、列表

列表 list, 是使⽤最多的⼀种容器(数据类型)
列表中可以存储多个数据, 每个数据之间使⽤逗号隔开
列表中可以存放任意类型的数据

定义

# 1. 类实例化的⽅式(不常⽤)
# 1.1 定义空列表(没有任何数据的列表)
# 变量 = list()
list1 = list()
print(type(list1), list1) # <class 'list'> []

# 1.2 类型转换 list(容器) 将其他的容器转换为列表
# 转换字符串会将字符串中的每个字符作为⼀个数据存⼊到列表
中
list2 = list('hello')
print(type(list2), list2) # <class 'list'> ['h',
'e', 'l', 'l', 'o']

# 2, 直接使⽤ [] 进⾏定义(常⽤)
# 2.1 定义空列表
my_list = []
print(my_list) # []

# 2.2 定义⾮空列表
my_list1 = [1, '⼩明', 3.14, False]
print(my_list1) # [1, '⼩明', 3.14, False]

列表⽀持下标和切⽚,⻓度

列表⽀持下标和切⽚操作, 使⽤⽅法和字符串中的使⽤⽅法⼀致
区别: 列表的切⽚得到的是列表

list1 = ['⼩明', 18, 1.71, True]
# 获取第⼀个数据,名字
print(list1[0])
# 获取最后⼀个数据
print(list1[-1])
# 第⼀第⼆个数据
print(list1[0:2]) # ['⼩明', 18]
# 列表⻚⽀持 len() 求⻓度的, 求数据元素个数
print(len(list1)) # 4

查找

查找 - 查找列表中数据下标的⽅法

在字符串中使⽤的 find ⽅法查找下标的,不存在返回的是 -1.
在列表中没有 find ⽅法, 想要查找数据的下标,使⽤的
index() ⽅法

列表.index(数据, start, end) 使⽤和 find ⽅法⼀样, 同
时在字符串中也有 index ⽅法
区别: 返回, index() ⽅法,找到返回第⼀次出现的下标, 没有
找到代码直接报错

查找 - 判断是否存在

判断容器中某个数据是否存在可以使⽤ in 关键字
数据 in 容器 # 如果存在返回 True ,如果不存在,返回
False

查找 - 统计出现的次数

统计出现的次数,使⽤的是 count() ⽅法
列表.count(数据) # 返回 数据出现的次数

my_list = [1, 3, 5, 7, 2, 3]

# 找 数据 3 出现的下标
num = my_list.index(3)
print(num) # 1
# 找 数据 4 出现的下标
# num1 = my_list.index(4) # 代码会报错
if 4 in my_list:
 num1 = my_list.index(4)
 print(num1)
else:
 print('不存在数据 4')
# my_list.count(4) 统计 数据 4 出现的次数
if my_list.count(4) > 0:
 num1 = my_list.index(4)
 print(num1)
else:
 print('不存在数据 4')

添加

尾部添加(最常⽤)

列表.append(数据) # 将数据添加到列表的尾部

返回: 返回的 None(关键字,空), ⼀般就不再使⽤ 变量 来
保存返回的内容

想要查看添加后的列表,需要打印的是列表

指定下标位置添加

列表.insert(下标, 数据) # 在指定的下标位置添加数据,
如果指定的下标位置本来有数据, 原数据会后移

返回: 返回的 None(关键字,空), ⼀般就不再使⽤ 变量 来
保存返回的内容

想要查看添加后的列表,需要打印的是列表

列表合并

列表1.extend(列表2) # 将列表 2 中的所有数据逐个添加
的列表1 的尾部

返回: 返回的 None(关键字,空), ⼀般就不再使⽤ 变量 来
保存返回的内容

想要查看添加后的列表,需要打印的是列表

my_list = []
print(my_list) # []

# 1. 想列表中添加数据 郭德纲
my_list.append('郭德纲')

print(my_list) # ['郭德纲']

# 2. 向列表的尾部添加 郭麒麟
my_list.append('郭麒麟')
print(my_list) # ['郭德纲', '郭麒麟']

# 3. 在下标位置为 1 的位置添加数据 '岳岳
my_list.insert(1, '岳岳')
print(my_list) # ['郭德纲', '岳岳', '郭麒麟']

# 4. 在下标位置为 1 的位置添加数据 于谦
my_list.insert(1, '于谦')
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟']

# 5. 定义新的列表 list1
list1 = ['孙越', '烧饼']
# 将 list1 中数据逐个添加到 my_list 中
my_list.extend(list1)
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟',
'孙越', '烧饼']
# 将 list1 作为⼀个整体添加到 my_list
my_list.append(list1)
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟',
'孙越', '烧饼', ['孙越', '烧饼']]

修改

想要修改列中的指定下标位置的数据, 使⽤的语法是:

列表[下标] = 数据

# 字符串中字符不能使⽤下标修改

# 定义列表
my_list = [1, 3, 5, 7]

# 1. 想要将下标为 1 的数据修改为 22
my_list[1] = 22
print(my_list) # [1, 22, 5, 7]
# 修改最后⼀个位置的数据, 改为 'hello'
my_list[-1] = 'hello'
print(my_list) # [1, 22, 5, 'hello']

# 2. 如果指定的下标不存在, 会报错的
# my_list[10] = 10 # 代码会报错

删除

在列表中删除中间的数据, 那么后⾯的数据会向前移动

根据下标删除

列表.pop(下标) # 删除指定下标位置对应的数据
1. 下标不写,默认删除最后⼀个数据(常⽤)
2. 书写存在的下标, 删除对应下标位置的数据

返回: 返回的删除的数据

根据数据值删除

列表.remove(数据值) # 根据数据值删除

返回: None
注意: 如果要删除的数据不存在, 会报错

清空数据(⼀般不⽤)

列表.clear()

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]

# 1. 删除最后⼀个位置的数据
num = my_list.pop()
print('删除的数据为:', num)
print(my_list) # [1, 3, 5, 7, 9, 2, 4, 6, 8]

# 2. 删除下标为 1 的数据 3
my_list.pop(1)
print(my_list) # [1, 5, 7, 9, 2, 4, 6, 8]

# 3. 删除数据为 7 的数据
my_list.remove(7) # 注意, 如果列表中有多个 7, 只能删除
第⼀个, 如果数据不存在,会报错的
print(my_list) # [1, 5, 9, 2, 4, 6, 8]

# my_list.remove(7) # 会报错的
# 清空
my_list.clear()
print(my_list) # []

反转

字符串中 反转倒置: 字符串[::-1]

列表中 反转和倒置: 
1. 列表[::-1] # 使⽤切⽚的⽅法,会得到⼀个新列表, 原列表
不会发⽣改变
2. 列表.reverse() # 直接修改原列表, 返回 None

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]

# 使⽤切⽚的⽅法反转, 会得到⼀个新列表

list1 = my_list[::-1]
print('my_list:', my_list)
print('list1 :', list1)

# 使⽤ reverse ⽅法, 直接修改原列表
my_list.reverse()
print('my_list:', my_list)

复制

将列表中的数据复制⼀份,给到⼀个新的列表
# 使⽤场景: 有⼀个列表, 需要修改操作列表中的数据, 修改之
后, 需要和原数据进⾏对⽐,即原数据不能改
1. 使⽤切⽚
变量 = 列表[:]
2. 使⽤ copy ⽅法
变量 = 列表.copy()

my_list = [1, 2, 3]

my_list1 = my_list[:]
print('my_list :', my_list)
print('my_list1:', my_list1)
my_list1[1] = 22
print('my_list :', my_list)
print('my_list1:', my_list1)
print('-' * 30)

my_list2 = my_list.copy()
print('my_list :', my_list)
print('my_list2:', my_list2)
my_list2[2] = 33
print('my_list :', my_list)
print('my_list2:', my_list2)

print('=' * 30)
my_list3 = my_list # 这是同⼀个列表,多了⼀个名字, 引⽤
print('my_list :', my_list)
print('my_list3:', my_list3)
my_list3[0] = 11
print('my_list :', my_list)
print('my_list3:', my_list3)

排序

列表的排序, ⼀般来说都是对数字进⾏排序的

列表.sort() # 按照升序排序, 从⼩到⼤

列表.sort(reverse=True) # 降序排序, 从⼤到⼩

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]

# 升序排序
my_list.sort()
print(my_list)

# 降序排序
my_list.sort(reverse=True)
print(my_list)

嵌套

列表嵌套, 列表中的内容还是列表

使⽤下标来确定获取的是什么类型的数据,然后确定可以继续进⾏什么操作

person_info = [["张三", "18", "功能测试"], ["李四",
"20", "⾃动化测试"]]

print(len(person_info)) # 2
print(person_info[0]) # ['张三', '18', '功能测试']

print(person_info[0][0]) # '张三'

print(person_info[0][0][0]) # 张

# 将 18 改为 19
person_info[0][1] = '19'
print(person_info) # [['张三', '19', '功能测试'],
['李四', '20', '⾃动化测试']]

# 给 李四 所在的列表添加⼀个性别 信息
person_info[1].append('男')
print(person_info) # [['张三', '19', '功能测试'],
['李四', '20', '⾃动化测试', '男']]

# 将张三的年龄信息删除
# person_info[0].pop(1)
person_info[0].remove('19')
print(person_info) # [['张三', '功能测试'], ['李四',
'20', '⾃动化测试', '男']]

去重

列表去重:列表中存在多个数据, 需求, 去除列表中重复的数据.
⽅式1. 思路
遍历原列表中的数据判断在新列表中是否存在, 如果存在,不管,
如果不存在放⼊新的列表中
遍历: for 循环实现
判断是否存在: 可以 使⽤ in
存⼊数据: append()
⽅法 2:
在 Python 中还有⼀种数据类型(容器) ,称为是 集合(set)
特点: 集合中不能有重复的数据(如果有重复的数据会⾃动去重)
可以使⽤集合的特点对列表去重
1. 使⽤ set() 类型转换将列表转换为 集合类型
2. 再使⽤ list() 类型转换将集合 转换为列表
缺点: 不能保证数据在原列表中出现的顺序(⼀般来说,也不考虑
这件事)

六、元组

元组: tuple, 元组的特点和列表⾮常相似

1. 元组中可以存放任意类型的数据
2. 元组中可以存放任意多个数据

区别:
1. 元组中的数据内容不能改变, 列表中的可以改变的
2. 元组使⽤ (), 列表 使⽤ []

应⽤: 在函数的传参或者返回值中使⽤, 保证数据不会被修改

定义

1. 使⽤ 类实例化的⽅式
2. 直接使⽤ () ⽅式

常⽤⽅法

由于元组中的数据不能修改,所以只有查看的⽅法

1. 在元组中也可以使⽤ 下标和切⽚获取数据
2. 在元组中存在 index ⽅法, 查找下标, 如果不存在,会报错
3. 在元组中存在 count ⽅法, 统计数据出现的次数
4. 在元组中可以使⽤ in 操作, 判断数据是否存在
5. len() 统计个数
以上⽅法的使⽤ 和列表中⼀样的

# 1, 类实例化的⽅式
# 1.1 定义空元祖(不会使⽤的)
my_tuple1 = tuple()
print(type(my_tuple1), my_tuple1) # <class 'tuple'>
()
# 1.2 类型转换
# 可以将列表转换为元组, 只需要将 [], 变为 (), 同时 可以
将元组转换列表 , 将() 变为 []
my_tuple2 = tuple([1, 2, 3])
print(my_tuple2) # (1, 2, 3)
# 转换字符串, 和列表中⼀样,只是将列表的[] 变为()
my_tuple3 = tuple('hello')
print(my_tuple3) # ('h', 'e', 'l', 'l', 'o')

# 2. 直接使⽤ () 定义
my_tuple4 = (1, "⼩王", 3.14, False)
print(my_tuple4)

# 3. 特殊点, 定义只有⼀个数据的元组时, 数据后边必须有⼀
个逗号
my_tuple5 = (1,)
print(my_tuple5) # (1,)
print(my_tuple4[1]) # ⼩王

七、字典

1. 字典 dict, 字典中的数据是由键(key)值(value)对组成的
(键表示数据的名字, 值就是具体的数据)
2. 在字典中⼀组键值对是⼀个数据, 多个键值对之间使⽤ 逗号
隔开
变量 = {key: value, key:value, ...}
3. ⼀个字典中的键是唯⼀的,不能重复的, 值可以是任意数据
4. 字典中的键 ⼀般都是 字符串,可以是数字, 不能是列表

定义

# 1. 使⽤ 类实例化的⽅法
my_dict = dict()
print(type(my_dict), my_dict) # <class 'dict'> {}

# dict() 不能转列表和元组,字符串

# 2. 直接使⽤{} 定义
# 2.1 空字典
my_dict1 = {}
print(type(my_dict1), my_dict1) # <class 'dict'> {}
# 2.2 ⾮空字典, ⼩明('name') 18('age') 1.71('height')
True(is_men) 抽烟 喝酒 烫头('like')
my_dict2 = {"name": "⼩明", "age": 18, "height":
1.71, "is_men": True, "like": ["抽烟", "喝酒", "烫头"]}

print(my_dict2)
print(len(my_dict2)) # 5

增加和修改操作

语法:
字典[键] = 数据值
1. 如果键已经存在,就是修改数据值
2. 如果键不存在,就是添加数据(即添加键值对)

# 定义字典 ⼩明 18 爱好

my_dict = {"name": "⼩明", "age": 18, "like": ['抽
烟', '喝酒', '烫头']}
print(my_dict) # {'name': '⼩明', 'age': 18,
'like': ['抽烟', '喝酒', '烫头']}

# 1. 添加性别信息 sex
my_dict['sex'] = '男'
print(my_dict) # {'name': '⼩明', 'age': 18,
'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}

# 2. 修改年龄为 19
my_dict['age'] = 19
print(my_dict) # {'name': '⼩明', 'age': 19,
'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}

# 3. 添加⼀个爱好, 学习--> 本质是向列表中添加⼀个数据
my_dict['like'].append('学习')
print(my_dict) # {'name': '⼩明', 'age': 19,
'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}

删除

删除指定键值对

del 字典[键]
or
字典.pop(键) # 键必须书写

清空

字典.clear()

my_dict = {'name': '⼩明', 'age': 19, 'like': ['抽
烟', '喝酒', '烫头', '学习'], 'sex': '男'}

# 删除 sex 键值对
del my_dict['sex']
print(my_dict) # {'name': '⼩明', 'age': 19,
'like': ['抽烟', '喝酒', '烫头', '学习']}

# 字典.pop('键')
my_dict.pop('age')
print(my_dict) # {'name': '⼩明', 'like': ['抽烟','喝酒', '烫头', '学习']}

# 删除抽烟的爱好 ---> 本质操作是在列表中删除 数据值
# my_dict['like'].pop(0)
my_dict['like'].remove('抽烟')
print(my_dict) # {'name': '⼩明', 'like': ['喝酒','烫头', '学习']}

# 清空键值对
my_dict.clear()
print(my_dict) # {}

查询

根据键获取对应的值

字典中没有下标的概念,想要获取数据值,要使⽤ key(键)来获取

使⽤字典[键]

字典[键]
1. 如果键存在 返回键对应的数据值,
2, 如果键不存在, 会报错

使⽤字典.get(键)

字典.get(键, 数据值) 
1. 数据值⼀般不写, 默认是 None
返回:
1. 如果键存在 返回键对应的数据值
2, 如果键不存在, 返回的是 括号中书写的数据值(None)
⼀般建议使⽤ get ⽅法

my_dict = {'name': '⼩明', 'age': 19, 'like': ['抽
烟', '喝酒', '烫头', '学习']}

# 1. 获取 名字
print(my_dict['name']) # ⼩明
print(my_dict.get('name')) # ⼩明
print(my_dict.get('name', 'zzz')) # ⼩明

# 2. 获取 sex 性别
# print(my_dict['sex']) # 代码会报错, 原因 key 不存
在
print(my_dict.get('sex')) # None
print(my_dict.get('sex', '保密')) # 保密

# 3. 获取 第⼆个爱好
print(my_dict['like'][1]) # 喝酒
print(my_dict.get('like')[1]) # 喝酒

遍历

字典的键进⾏遍历

for 变量 in 字典:
 print(变量) # 变量就是字典的 key, 键
 
for 变量 in 字典.keys(): # 字典.keys() 可以获取字典中
所有的键
 print(变量)

对字典的值进⾏遍历

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

字典的键值对进⾏遍历

# 变量1 就是 键, 变量2 就是键对应的值
for 变量1, 变量2 in 字典.items(): # 字典.items() 获取
键值对
 print(变量1, 变量2)

# 定义字典
my_dict = {'name': '⼩明', 'age': 18, 'sex': '男'}
# 1. 遍历字典的键
for k in my_dict:
 print(k)
for k in my_dict.keys():
 print(k)
print('-' * 30)
# 2. 遍历字典的值
for v in my_dict.values():
 print(v)
print('*' * 30)
# 3. 遍历键值
for k, v in my_dict.items():
print(k, v)