一、python介绍

python 只是一个编程语言，在工作中需要结合其他的工具使用

• python + selenium

  • web自动化（功能测试转换为代码）

• python + appium

  • 移动端（app）自动化

• python + requests

  • 接口自动化

1、python特点

• 简单、易学、免费、开源、适用人群广泛
• 应用领域广泛（自动化测试）

2、python版本

• python2（2.x 2.7）
• python3（主流使用的版本，3.6之后的版本）

3、语言的分类

计算机只认识二进制（0、1）
编程语言是人和计算机沟通的语言
编程语言分类：编译型语言，解释型语言

1、编译型

• 把程序源代码都编译成机器语言（二进制），保存为二进制文件
• 计算机可以直接运行，执行速度快
• C，C++，GO，Swift，Object-C…

2、解释型

• 在程序执行的时候才会一行一行的处理成机器语言
• 执行速度慢
• JavaScript ，python，Ruby，PHP

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vkW3GhmZ-1659184224031)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220717094446602.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6sq3DAnC-1659184224033)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220717094051804.png)]

4、python环境配置

python 解释器：将我们书写的python代码转换为二进制，建议版本 >= 3.6

pycharm 书写代码的软件，还能运行代码，运行代码的前提是在pycharm软件中配置了解释器
- 组织代码方式：项目（project），简单的理解为一个目录，目录中可以放很多的代码

建议：每天的代码作为一个项目

5、pycharm基本使用

5.1 新建项目

1、打开pycharm
2、选择create new project
3、指定本地的python解释器
4、点击create创建完成

5.2 新建文件

1、进入pycharm项目
2、选中对应项目名，鼠标右击
3、点击new选择培python file
4、自定义文件名然后选择创建

5.3 编写代码运行

1、按语法书写python脚本
2、书写print（“第一个python脚本”）
3、在工具栏或直接运行py脚本

二、python基础

1、print函数

print("hello world")

print()是python中自带的函数，作用在控制台中输出括号中的内容

后续看到这个函数就是输出打印数据的，或者想要在控制台中显示某个内容，就要使用print()函数

print() 主要在学习阶段使用，便于我们确认结果的正确性
在实际工作的代码中，基本不会使用print，会使用其他的内容代替（日志模块）

print() 函数中是什么内容，就会显示什么内容，里边的文字信息，可以使用单引号，也可以使用双引号

print("hello world")
print('hello python')

2、python注释

注释的作用：

• 使用开发者自己熟悉的语言在程序代码中添加标注或说明
• 通过注释增强程序代码可读性
• 注释的内容不会被解释器执行

（1）单行注释

使用 并号空格进行注释（单独一个 # 也可以）

快捷键 CTRL+/

（2）多行注释

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

多行注释可以使用 3 对单引号或者 3 对双引号，被3对引号包括的内容就是注释的内容

# 单引号注释
'''
注释1
注释2
注释3
'''

# 双引号注释
"""
注释4
注释5
注释6
"""

3、python波浪线和PEP8

• 红色
  • 红色波浪线是代码的错误，必须处理，代码才能正常运行
  • 代码没有完全写完，也会出现红色波浪线
• 灰色
  • 灰色波浪线，不会影响代码的正常运行，基本所有的灰色波浪线都是PEP8不规范造成
  • PEP8：是python代码的书写规范，如果不按照这个规范书写，会给灰色波浪线，建议代码的书写按照PEP8规范书写
  • 快捷键：CTRL+alt+L 自动按照PEP8规范
• 绿色
  • 绿色波浪线，不影响代码正常执行。一般是单词编写错误会出现

4、python变量

（1）变量作用

用来存储数据的（在程序代码中出现的数据，想要保存下来使用，就必须使用变量）

如：测试数据、用户名、密码、验证码

注意：变量必须先定义（保存数据）后使用（取出数据）

（2）定义变量

变量名 = 数据值   #可以理解为 将数据值保存到变量中
# 比如：
name = '张三'  # 定义一个变量 name，存储的数据值是张三

（3）使用变量

变量定义之后，想要使用变量中的数据，直接使用变量名即可

# 使用变量获取数据，打印
print(name)

（4）命名规范

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

• 必须由字母、数字和下划线组成，并且不能以数字开头

• 不能使用python中的关键字

  • python自带的已经使用的标识符，具有特殊的作用

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xMVUwRGA-1659184224034)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220717121801312.png)]

• 区分大小写

• 命名习惯

  • 见名知义
  • 使用驼峰体
    • 大驼峰：每个单词首字母大写，例如MyName
    • 小驼峰：第二个单词开始首字母大写，例如myName
  • 使用下划线：每个单词之间使用下划线连接，例如my_name

5、python数据类型

（1）数字类型

• 整型（int）：就是整数，即不带小数点的数
• 浮点型（float）：就是小数
• 布尔类型（Boolean），只有两个值（真True（1）、假False（0））
  • True和False都是python中的关键字，注意大小写
• 复数类型：4+1i （很少用到）

（2）非数字类型

• 字符串（string）：使用引号引起来的就是字符串
• 列表（list）：[1,2,3,4]
• 元组（tuple）：(1,2,3,4)
• 字典（dict）：{‘name’ : ‘小明’,‘age’ :18 }

（3）type()函数

可以获取变量的数据类型

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

# 整形
age = 18
print(type(age))
# 浮点型
height = 1.82
print(type(height))
# 布尔类型
isMen = True
print(type(isMen))
# 字符串类型 使用引号引起来的就是字符串
name = "小明"
print(type(name))

age="20"
print(type(age))

运行结果：

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'str'>
<class 'str'>

6、python输入

获取用户使用键盘录入的内容

（1）input()函数

• 变量 = input（‘提示的信息’）
  • 代买从上到下执行，遇到input函数之后，会暂停执行，等待用户的输入，如果不输入会一致等待
  • 在输入的过程中，遇到回车，代表本次输入结束
  • 会将你输入的内容保存到等号左边的变量中，并且变量的数据类型，一定是str

result = input("请输入内容：")
print(type(result),result)   # 打印数据类型和数据值

运行结果：
请输入内容：hello workl
<class 'str'> hello workl

（2）类型转换

• 变量名 = 数据类型（变量名） 例如：age = int(age)
• int()：支持将float类型、整数类型的字符串转换为int类型
• float()：支持int、数字类型的字符串（包含整型、浮点型）转换为float类型
• str()：支持任何类型转换为str类型

age = input("请输入你的年龄：")
print("age本来的数据类型",type(age))
age1 = int(age)    # 将输入数据类型转换为整型
print("转换后age的类型：",type(age))
print("转换后age1的数据类型",type(age1))

运行结果：
请输入你的年龄：12
age本来的数据类型 <class 'str'>
转换后age的类型： <class 'str'>
转换后age1的数据类型 <class 'int'>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4B0ro4bQ-1659184224035)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220717143932805.png)]

7、python输出

（1）print（）函数

print("hello world")

name = xiaoming
age = 19
print(name,age)

（2）格式化输出

按照一定的格式输出内容，在字符串中指定的位置，输出变量中存储的值

• 在需要使用变量的地方，使用特殊符号占位
• 使用变量填充占位的数据
• %格式化输出占位符号
  • %d占位，填充整型数据digit
  • %f占位，填充浮点型数据float
  • %s占位，填充字符串数据string

# 定义变量   姓名、年龄、身高
# 也可以使用input输入
name = "小明"
age = 19
height = 1.70

# 使用格式化输出”我的名字是××，年龄是××，身高是×ד
print("我的名字是%s，年龄是%d，身高是%fm" % (name,age,height))
# 浮点型小数默认显示6位，%.nf为保留n位有效数
print("我的名字是%s，年龄是%d，身高是%.2fm" % (name,age,height))

stu_num = 1 # 学号
# 格式化输出"我的学号是000001"
print("我的学号是%d" % (stu_num))
# %0nd n表示需要换成具体的整数数字，表示整数一共占几位
print("我的学号是%06d" % (stu_num))

num = 90 #考试的及格率
# 格式化输出某次考试的及格率为90%
# 如果格式化中需要显示%，在书写时使用%%即可
print("某次考试的及格率为%d%%" % num)

运行结果：
我的名字是小明，年龄是19，身高是1.700000m
我的名字是小明，年龄是19，身高是1.70m
我的学号是1
我的学号是000001
某次考试的及格率为90%

• F-string（f字符串的格式化方法）
  • f-string格式化的方法，python版本 >= 3.6
  • 需要在字符串的前边加上f"“或者F”"
  • 占位符号统一变为{}
    • }}|需要填充的变量{}中

# 定义变量   姓名、年龄、身高、学号、及格率
# 也可以使用input输入
name = "小明"
age = 19
height = 1.70
stu_num = 1
num = 90

print(f"我的名字是{name}，年龄是{age}，身高是{height}m，学号是{stu_num}，及格率是{num}%")
print(f"我的名字是{name}，年龄是{age}，身高是{height:.2f}m，学号是{stu_num:06d}，及格率是{num}%")

运行结果：
我的名字是小明，年龄是19，身高是1.7m，学号是1，及格率是90%
我的名字是小明，年龄是19，身高是1.70m，学号是000001，及格率是90%

• 字符串格式化
  • 字符串.format()
  • 在需要使用变量的地方使用{}占位
  • “{}，{}，{}”.format(变量1,变量2,变量3)

# 定义变量   姓名、年龄、身高、学号、及格率
# 也可以使用input输入
name = "小明"
age = 19
height = 1.70
stu_num = 1
num = 90

print("我的名字是{}，年龄是{}，身高是{}m，学号是{}，及格率是{}%".format(name,age,height,stu_num,num))
print("我的名字是{}，年龄是{}，身高是{:.2f}m，学号是{:06d}，及格率是{}%".format(name,age,height,stu_num,num))

运行结果：
我的名字是小明，年龄是19，身高是1.7m，学号是1，及格率是90%
我的名字是小明，年龄是19，身高是1.70m，学号是000001，及格率是90%

• .lower() — 全部小写

  .upper() — 全部大写

  .title() — 各个字符的首字母大写

  .capitalize() — 首字母大写

  .strip() — 删除两边空格

  .lstrip() — 删除左边空格

  .rstrip() — 删除右边空格

  .replace(" “,”") — 删除所有空格

  .split() — 先切分，“”.join() — 再拼接

8、python运算符

（1）算术运算符

场景构建，假设有x,y两个变量，x=10,y=20

（2）比较运算符

场景搭建，a的值为10，b的值为20

（3）赋值运算符

（4）按位运算符

下表中变量 a 为 60，b 为 13二进制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

（5）逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

9、python判断（条件控制）

（1）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岁了，可以进入网吧了
  
  age = input("请输入你的年龄：")  # 输入类型为str字符串类型
  if int(age) >= 18:           #字符串和int类型不能比大小，先类型转换再比大小
      print("满18岁了，可以进入网吧了")
  elif int(age) < 18:
      print("未满18岁禁止入内")
  print("我与if判断无关，无论如何我都会执行")
  
  运行结果:
  请输入你的年龄：12
  未满18岁禁止入内
  我与if判断无关，无论如何我都会执行
  

（2）if else结构

• 基本语法

if 判断条件：
	书写条件成立（真），执行代码
	书写条件成立（真），执行代码
else:
	书写条件成立（真），执行代码
	书写条件成立（真），执行代码
	
1、else是关键字，后边需要冒号
2、冒号之后回车，同样需要缩进
3、处于else代码下方缩进中的内容，属于else的代码块
4、if和else的代码块，只会执行其中的一个
5、else需要结合if使用

示例：

age = input("请输入年龄：")
if int(age) >= 18:
    print("满18岁了，可以进入网吧了")
else:
    print("未满18岁不能入内")

print("我与if else语句无关，会执行")

• if和逻辑运算符结合使用

# 1、获取用户输入的用户名和密码
# 2、判断用户是admin并且密码是123456时，在控制台输出：登录成功！
# 3、否则再控制台输出：登录信息错误！

admin = input("请输入用户名：")
password = input("请输入密码：")
if admin =="admin" and password == "123456":
    print("登录成功！")
else:
    print("登录信息错误！")
    
运行结果：
请输入用户名：admin
请输入密码：123456
登录成功！

# 1、获取用户输入的用户名
# 2、判断用户名是admin时，在控制台输出：欢迎admin登录！
# 3、用户名是test时，在控制台输出：欢迎test登录！
# 4、如果是其他信息，在控制台输出：查无此人！
username = input("请输入用户名：")

if username == "admin"or username == "test!":
    print("欢迎" + username + "登录!")
else:
    print("查无此人!")

（3）if elif else结构

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

• 基本语法

  if 判断条件1:
  	判断条件1成立，执行代码
  elif 判断条件2：          #只有判断条件1不成立，才会判断条件2
  	判断条件2成立，执行代码
  elif 判断条件3：
  	判断条件1、2不成立，判断条件3成立，执行代码
  ...
  else:
  	以上条件都不成立，执行代码
  

  1、elif也是关键字，后边和判断条件之间许哟啊一个空格，判断条件之后需要冒号
  2、冒号之后回车需要缩进，处在这个缩进中的代码代表是elif的代码块
  3、在一个if判断中，可以有很多个elif
  4、只有if的条件不成立，才会去判断elif的条件
  5、在一个if中，如果有多个elif，只要有一个条件成立，后续的所有都不再判断
  
  if 判断条件1：
  	执行的代码
  if 判断条件2：
  	执行的代码
  if 判断条件3：
  	执行的代码
  ...
  
  6、多个if的结构，每个if都会进行判断，之间没有关联
  

  示例：

  # 1、定义score变量记录考试分数
  # 2、如果分数大于等于90分，显示成绩优秀
  # 3、如果分数大于等于80分且小于90分，显示成绩良好
  # 4、如果分数大于等于70分且小于80分，显示成绩中等水平
  # 5、如果分数大于等于60分且小于70分，显示成绩较差
  # 6、其他分数显示成绩不及格
  
  score = input("请输入分数：")
  if 0 <= int(score) <= 100:
      if int(score) >= 90:
          print("成绩优秀")
      elif 80 <= int(score) <90:
          print("成绩良好")
      elif 70 <= int(score) < 80:
          print("成绩中等水平")
      elif 60 <= int(score) <70:
          print("成绩较差")
      else:
          print("成绩不及格")
  else:
      print("输入分数格式错误！")
  

（4）if嵌套

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

• 语法

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

示例1：

# 取款机取钱的过程，假定你的密码是123456，账户余额为1000
# 1、提示用户输入密码
# 2、判断密码是否正确
# 3、密码正确后，提示输入取款的金额
# 4、判断取款的金额和余额的关系
password = int(input("请输入密码："))
SumMoney = 1000
if password == 123456:
    money = int(input("请输入取款金额："))
    if money > SumMoney:
        print("您的取款金额超出余额范围，请重试！")
    elif money < SumMoney:
        print(f"取款成功，余额剩余{SumMoney-money}")
else:
    print("密码错误！请重试！")
    
运行结果：
请输入密码：123456
请输入取款金额：900
取款成功，余额剩余100

示例2：

# 假定某网站用户名固定为admin，密码固定为123456，验证码固定为8888
# 1、获取用户输入的用户名，密码和验证码
# 2、先判断验证码是否正确，如果正确打印输出验证码正确，再判断用户名和密码是否正确
# 3、如果验证码不正确，直接输出 验证码不正确，请重新输入
user = input("请输入用户名：")
pwd = input("请输入密码：")
vcode = input("请输入验证码：")

if vcode == "8888":
    print("验证码正确！")
    if user == "admin" and pwd == "123456":
        print("登录成功")
    else:
        print("用户名或密码错误，请重新输入！")
else:
    print("验证码错误，请重新输入！")

示例2：猜拳游戏

剪刀石头布

案例步骤：
1、玩家出拳（石头（1）/剪刀（2）/布（3）） input  （player）
2、电脑随机出拳（待完成）（computer）
3、判断输赢：
	- 玩家胜利：
		- player == 1 and computer == 2
		- player == 2 and computer == 3
		- player == 3 and computer == 1
	- 平局：
		- player == computer
	- 玩家失败：
		- player == 1 and computer == 3
		- player == 2 and computer == 1
		- player == 3 and computer == 2
	

随机出拳：
在python中想要随机获取整数数字可以使用如下方法：
1、导入随机数工具包
import random
2、使用工具包中的工具产生指定范围内的数字
random.randint(a,b)   //产生[a,b]之间的随机整数，包含a,b

程序代码：

import random
# （石头（1）/剪刀（2）/布（3））
player = int(input("玩家输入："))
computer = random.randint(1,3)
print(f"电脑随机生成数：{computer}")
if (player == 1 and computer == 2) or (player == 2 and computer == 3) or (player == 3 and computer == 1):
    print("玩家胜利！")
elif player == computer:
    print("平局")
elif (player == 1 and computer == 3) or (player == 2 and computer == 1) or (player == 3 and computer == 2):
    print("玩家失败！")
else:
    print("输入错误！")

（5）Debug调试代码

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

• 打断点

  • 在pycharm中，代码和行号之间进行点击，出现小红点即打断点，再次带年纪小红点会取消断点
  • 断点的位置，一般来说会在代码的第一行（在程序运行的时候，想要在什么地方停下来）
  • 注意点：可能会出现的bug（pycharm软件的问题）：代码中只有一个断点的时候不能debug调试查看代码执行过程，解决方案，在代码其他任意地方多加一个断点

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MPAEI5SM-1659184224036)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220718122529182.png)]

• 右键debug运行代码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2gLyxpST-1659184224036)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220718122801791.png)]

• 单步执行代码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nq3IIibv-1659184224037)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220718122858441.png)]

10、python循环

（1）程序的三大流程

• 顺序：从上向下，顺序执行代码
• 分支：根据条件判断，决定执行代码的分支
• 循环：让特定代码 重复执行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TtfGo0i1-1659184224037)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220718152938276.png)]

（2）while循环

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

应用场景：让执行的代码按照指定的次数重复执行

• 基本语法
  • 设置循环的初始条件
  • 书写循环的判断条件

while 判断条件:
	需要重复执行的代码
	改变循环的初始条件
	
注意：while语句以及缩进部分是一个完整的代码块

示例

# 打印100次“hello world”
i = 1
while i <= 100:
    print("hello world")
    i = i + 1
print(f"循环结束后的i:{i}")

• 死循环和无限循环

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

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

while true:
	if 判断条件：
		break  # 终止循环，当代码执行遇到break，这个循环就不再执行了
	重复执行的代码

示例1：

while True:       # 可以无限玩，直到if判断循环结束为止
    player = int(input("玩家输入："))
    computer = random.randint(1,3)
    print(f"电脑随机生成数：{computer}")
    if player == 0:
        break     # 循环终止条件
    if (player == 1 and computer == 2) or (player == 2 and computer == 3) or (player == 3 and computer == 1):
        print("玩家胜利！")
    elif player == computer:
        print("平局")
    elif (player == 1 and computer == 3) or (player == 2 and computer == 1) or (player == 3 and computer == 2):
        print("玩家失败！")
    else:
        print("输入错误！")

示例2：

\


# 求1-100数字和
i = 1
sum = 0
while i <= 100:
    sum = i + sum
    i += 1
print(sum)

示例3

# 用循环求1-100偶数和

# 方法1
i = 2
sum = 0
while i <= 100:
	sum = sum + i
	i = i+2
print(sum)

# 方法2
i = 1
sum = 0
while i <= 100:
	if i % 2 == 0:
		sum = sum + i
	i = i + 1
print(sum)

（3）for循环

• 作用：

  • for循环可以让指定的代码重复执行
  • for循环可以遍历容器中的数据
    • 遍历：从容器中把数据一个一个取出
    • 容器：可以简单理解为盒子，盒子中可以存放很多的数据（字符串str、列表list、元组tuple、字典dict）
  • for循环也可以成为for遍历

• 基本语法：

  for 变量名 in 容器:
  	重复执行的代码
  	
  # 1、for 和 in 都是关键字
  # 2、容器中有多少个数据，循环会执行多少次（0个数据，执行0次）
  # 3、每次循环，会将容器中数据取出一个保存到in关键字前边的变量中去
  

  # 定义字符串
  my_str = "hello"
  # 遍历字符串  字符串中有5个字符，循环就会执行5次
  for i in my_str:     # 每次循环i的值为字符串中的字符
      print("我错了！",i)    # 重复执行的代码
      
  运行结果：
  我错了！ h
  我错了！ e
  我错了！ l
  我错了！ l
  我错了！ o
  

• for做指定次数的循环

for 变量 in range(n):
    重复执行的代码
    
# 1、range()是python中的函数，作用使用可以生成[0,n)之间的整数，不包含n的，一个有n个数字，所以这个循环循环n次
# 2、想让for循环循环多少次，n就写几
# 3、变量的值，也是每次循环从[0,n)取出一个值，第一次取的是0，最后取的是n-1(一共取了n次)

for i in range(3):     # 每次循环i的值为字符串中的字符
    print("我错了！",i)    # 重复执行的代码
    
运行结果：
我错了！ 0
我错了！ 1
我错了！ 2

• range()变形

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

（4）break 和 continue

• break 和 continue是python中的两个关键字，只能在循环中使用

• break

  • 终止循环，即代码执行遇到break，循环不在执行，立即结束

• continue

  • 跳过本次循环，即代码执行遇到break，本次循环剩下的代码不再执行，继续下一次循环

  # 1、获取输入的字符串
  # 2、遍历打印这个字符串
  result = input("请输入一个字符串：")
  for i in result:
      if i == 'e':    # 在遍历的时候，如果遇到字符e，则代码不再继续执行
          break
      if i == 'h':    # 本次循环遇到h，跳过，即不打印h
          continue
      print(i)
      
      
  运行结果：
  请输入一个字符串：abchijkelkf
  a
  b
  c
  i
  j
  k
  

（5）容器

容器：也可以成为是数据序列，或者高级数据类型，也是python中的数据类型

容器中可以存放多个数据

# 1、字符串、列表、元组支持加法运算
str = "hello" + "world"
list = [1,2,3] + [4,5,6]
tuple = (1,2,3) + (4,5,6)

# 2、字符串，列表，元组支持乘一个整数
"hello " * 3  # ==>"hello hello hello "
[1,2] * 3  # ==>[1,2,1,2,1,2]
(1,2) * 3  # ==>(1,2,1,2,1,2)

# 3、len()在容器中都可以使用
# 4、in 关键字在容器中都可以使用，注意，在字典中判断的是字典的键是否存在

11、python字符串

（1）字符串

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

• 定义：使用引号（单、双、三）引起来的内容都是字符串

• 字符串本身包含单（双）（三）引号，则在定义的时候不能使用单（双）（三）引号

  • 使用 \ 转义字符，将字符串本身的引号进行转义
    • \ ’ == ’ \ " == "

• 字符串前边加上r"" 原生字符串，字符串中的\不会作为转义字符，文件操作会用一下

• ord（字符）——获取字符对应的ASCII的值

• chr（ASCII值）——获取对应的字符

（2）下标

• 下标指字符在字符串中的位置编号，这个编号就是下标

• 这个编号一般来说都是从左到右进行编号，从0开始（python中支持负数下标（从-1开始））

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6QinS0wD-1659184224038)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220719095447773.png)]

• 下标作用：可以使用下标获取字符串中某个位置的字符
• 语法：字符串[下标] 获取指定位置的字符

str = "abcdefg"

print(str[0])   # 打印最开始位置的字符
print(str[-1])   # 打印最后一个字符
print(str[2])   #打印下标为2的字符

# 获取字符串中字符的个数（获取字符串的长度）
# len(字符串)  # length（字符串）
num = len(str)
print(num)
print(str[num-1])   #打印最后一个字符

运行结果：
a
g
c
7
g

（3）切片

• 切片：可以获取字符串中多个字符（多个字符的下标是有规律的，等差数列）
• 语法：
  • 字符串[开始下标：结束下标（不包含）：步长]
    • start是开始位置的下标，end是结束位置的下标（不能取到该位置），step步长，等差数列的差值，所取得相邻字符下标之间得差值，默认是1，可以不写
    • 例如：[1:5:1] # 1 2 3 4
    • [1:5:2] # 1 3
    • [1:5:3] # 1 4

str = "abcdefgh"

print(str[0:3:1])   # 获取abc字符
print(str[0:3])   # 如果步长是1可以不写，最后一个冒号也不写
print(str[:3])   # 如果开始位置为0，可以不写，但是冒号必须有

print(str[5:8])   # 获取fgh字符
print(str[-3:8])
print(str[5:])   # 如果最后一个字符也要取，可以不写，但是冒号要有
print(str[:])   # 如果开始和结束都不写，获取全部内容，但是冒号要有

print(str[0:8:2])   # 获取aceg,步长为2
print(str[::2])   # 如果是从头到尾遍历，可以不写头尾，但是冒号要有

# 特殊应用，步长为负数，开始和结束不写，意思全变，一般不用管，只有一种使用场景
# 反转（逆置）字符串
print(str[::-1])

运行结果：
abc
abc
abc
fgh
fgh
fgh
abcdefgh
aceg
aceg
hgfedcba

（4）查找—find

• 用法：
  • 字符串.find(sub_stu,start,end)
  • 作用：在字符串中查找是否存在sub_str这样的字符串
  • sub_str：要查找的小的字符串
  • start：开始位置，从哪个下标位置开始查找，一般不写，默认是0
  • end：结束位置，查找到哪个下标结束，一般不写，默认是len()
  • 返回（代码执行之后会得到什么，如果有返回，就可以使用变量保存）
    • 如果在字符串中找到了sub_str，返回sub_str第一次出现的下标（sub_str中第一个字符在大字符串中的下标）
    • 如果没有找到，则返回-1

mystr = "hello world and itcast and ithemia and python"
num = mystr.find("and")
print(num)   # 查找第一个and出现的下标

num1 = mystr.find("and",num + 1)
print(num1)   # 查找第二个and出现的下标，从第一次出现的后一位开始找

num2 = mystr.find("and",num1+1)
print(num2)   # 查找第三个and出现的下标，从第二次出现的后一位开始找

num3 = mystr.find("and",num2+1)
print(num3)   # 查找第四个and出现的下标，从第三次出现的后一位开始找

运行结果：
12
23
35
-1

（5）替换—replace

• 用法

  • 字符串.replace(old_str，new_str，count)
  • 作用：将字符串中old_str替换为new_str
  • old_str：被替换的内容
  • new_str：替换后的内容
  • count：替换的次数，一般不写，默认全部替换
  • 返回：替换之后的完整的字符串，原来的字符串没有发生改变

  str = "good good study"
  
  str1 = str.replace("g","G")  #蒋str中所有的g替换成G
  print("str:",str)
  print("str1:",str1)
  
  str2 = str.replace("good","GOOD",1)  # 将str中的第一个good改为GOOD
  print("str2:",str2)
  
  str3 = str.replace("good","GOOD")  # 将str中的第二个good改为GOOD，先将全部的good改为GOOD
  str3 = str3.replace("GOOD","good",1)   # 再将str3中的第一个GOOD改为good
  print("str3:",str3)
  
  运行结果：
  str: good good study
  str1: Good Good study
  str2: GOOD good study
  str3: good GOOD study
  
  

（6）拆分—split

• 用法：

  • 字符串.split（sep，max_split）
  • 作用：将字符串按照sep进行分割（拆分）
  • sep：字符串按照什么进行拆分，默认是空白字符（空格，换行、\n，tab键\t）
  • max_split：分割次数，一般不写，全部分割
  • 返回：将一个字符串拆分为多个，存到列表中
  • 如果sep不写，想要指定分割次数，则可以按照以下方式：
    • 字符串.split（max_split = n） # n代表分割次数

  mystr = "hello world and itcast and ithemia and python"
  
  str = mystr.split("and")   # 按照and字符进行拆分
  print(str)
  
  str = mystr.split("and",2)  #按照and字符拆分2次
  print(str)
  
  str = mystr.split()   # 按照空格字符进行拆分
  print(str)
  
  str = mystr.split(maxsplit=1)   # 按照空格字符拆分1次
  print(str)
  
  运行结果：
  ['hello world ', ' itcast ', ' ithemia ', ' python']
  ['hello world ', ' itcast ', ' ithemia and python']
  ['hello', 'world', 'and', 'itcast', 'and', 'ithemia', 'and', 'python']
  ['hello', 'world and itcast and ithemia and python']
  

（7）链接—join

• 用法：

  • 字符串.join（列表）
  • 括号中的内容主要是列表，可以是其他容器
  • 作用：将字符串插入到列表中每相邻的两个数据之间，组成一个新的字符串
    • 列表中的数据使用逗号隔开
    • 列表中的数据必须都是字符串，否则会报错

  list = ['hello', 'world', 'and', 'itcast', 'and', 'ithemia', 'and', 'python']
  print(list)
  
  str = " ".join(list)
  print(str)
  
  str2 = " and ".join(list)
  print(str2)
  
  运行结果：
  ['hello', 'world', 'and', 'itcast', 'and', 'ithemia', 'and', 'python']
  hello world and itcast and ithemia and python
  hello and world and and and itcast and and and ithemia and and and python
  

小总结：

字符串：

• 下标：str[3]
• 切片：字符串[开始下标：结束下标：步长]
• 查找：字符串.find[查找内容：开始下标：结束下标]
• 替换：字符串.replace[被替换内容：要替换内容：替换次数]
• 拆分：字符串.split[按照该内容拆分：拆分次数]
• 链接：字符串.join(列表)

12、python列表

列表 list，是使用最多的一种容器（数据类型）

列表中可以存储多个数据，每个数据之间使用逗号隔开

列表中可以存放任意类型的数据

• 定义：

  • 方式一：用[ ]定义，数据之间使用英文逗号分隔

  name_list = []
  name_list = ["zhangsan","lisi","wangwu"]
  

  • 方式二：通过类实例化方式定义

  data_list = list()
  

  # 1、类实例化的方式（不常用）
  # 定义空列表（没有任何数据的列表）
  list1 = list()
  print(type(list1),list1)
  
  # 类型转换list（容器） 将其他的容器转换为列表
  # 转换字符串会将字符串中的每个字符作为一个数据存入到列表中
  list2 = list("hello")
  print(list2)
  
  # 2、直接使用[]定义（常用）
  list3 = ["hello","world","heima","小明"]
  print(list3)
  print(list3[0:2])
  print(len(list3))   # 求列表元素个数
  
  运行结果：
  <class 'list'> []
  ['h', 'e', 'l', 'l', 'o']
  ['hello', 'world', 'heima', '小明']
  ['hello', 'world']
  4
  

• 列表支持下标和切片，使用方法和字符串一致

  • 区别：列表切片得到的是列表

（1）列表查询—index

• 用法1：用于查找列表中数据下标的方法

  • 列表.index（数据，start，end）
  • 找到返回第一次出现的下标，没有找到代码直接报错

  list3 = ["hello","world","heima","小明"]
  num = list3.index("hello",0,3)
  print(num)
  
  运行结果：
  0
  

• 用法2：判断是否存在

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

  # 查找3的下标
  list4 = [1,3,5,7,8,9,6,0]
  num = list4.index(3)
  print(num)
  
  # 查找数字4的下标
  if 4 in list4:
      num1 = list4.index(4)
      print(num1)
  else:
      print("该数字不存在！")
  # 统计数据 4 出现的次数
  if list4.count(4):
      num1 = list4.index(4)
      print(num1)
  else:
      print("该数字不存在2！")
      
  运行结果：
  1
  该数字不存在！
  该数字不存在2！
  

（2）列表添加数据—append、insert、extend

• 尾部添加（最常用）
  • 列表.append（数据）
  • 将数据添加到列表的尾部
  • 返回：返回的None（关键字，空），一般就不再使用变量来保存返回的内容
  • 想要查看添加后的列表，需要打印的是列表
  • 不支持 变量 = 列表.append（数据）
• 指定下标位置添加
  • 列表.insert（下标，数据）
  • 在指定的下标位置添加数据，如果指定的下标位置本来有数据，原数据会后移
  • 返回：返回的None（关键字，空），一般就不再使用变量来保存返回的内容
  • 想要查看添加后的列表，需要打印的是列表
• 列表合并
  • 列表1.extend（列表2）
  • 将列表2中的所有数据逐个添加到列表1的尾部

list1 = [1,3,5,7,9]
list2 = [2,4,6,8,0]
list1.append(11)
print(list1)

list1.insert(5,13)
print(list1)

list5 = list1.extend(list2)  # 会返回none，不需要变量保存
print(list5)

list1.extend(list2)
print(list1)  # 直接打印列表

# 将list2整体添加到list1中
list1.append(list2)
print(list1)

运行结果：
[1, 3, 5, 7, 9, 11]
[1, 3, 5, 7, 9, 13, 11]
None
[1, 3, 5, 7, 9, 13, 11, 2, 4, 6, 8, 0, 2, 4, 6, 8, 0]
[1, 3, 5, 7, 9, 13, 11, 2, 4, 6, 8, 0, 2, 4, 6, 8, 0, [2, 4, 6, 8, 0]]

（3）列表修改操作

• 用法：

  • 列表[下标] = 数据
  • 字符串中字符不能使用下标修改
  • 如果指定的下标不存在，则程序会报错

  my_list = [1,3,5,7]
  my_list[1] = 9
  print(my_list)
  
  # 修改最后一个位置的数据，改为“hello”
  my_list[-1] = 'hello'
  print(my_list)
  
  运行结果：
  [1, 9, 5, 7]
  [1, 9, 5, 'hello']
  

（4）列表删除操作—pop、remove、clear

在列表中删除中间的数据，后面的数据会向前移动

• 根据下标删除

  • 列表.pop（下标）
  • 删除指定下标位置对应的数据
  • 下标不写，默认删除最后一个数据（常用）
  • 返回：返回删除的数据
  • del 列表[下标]

• 根据数据值删除

  • 列表.remove（数据值）
  • 根据数据值删除
  • 返回：None
  • 如果删除的数据不存在，会报错
  • 如果有多个同样的数据，只删除第一个

• 清空数据（少用）

  • 列表.clear（）

  my_list = [1,3,5,7,9,11,13]
  
  num = my_list.pop(2)
  print("被删除的数据：",num)
  print(my_list)
  
  my_list.remove(13)
  print(my_list)
  
  my_list.clear()
  print(my_list)
  
  运行结果：
  被删除的数据： 5
  [1, 3, 7, 9, 11, 13]
  [1, 3, 7, 9, 11]
  []
  

（5）列表反转（倒置）—reverse

• 字符串中，反转倒置：字符串[::-1]
• 列表中，列表.reverse（）
• 字符串倒置会生成一个新列表，但不会改变原来列表
• 列表倒置会改变原列表

mylist = [1,2,3,4,5,6,7,8,9]
list = mylist[::-1]
print(list)

mylist.reverse()
print(mylist)

（6）列表复制—copy

将列表中的数据复制一份，给到一个新的列表

• 切片：变量 = 列表[ : ]
• copy：变量 = 列表.copy（）
• 使用场景：
  • 有一个列表，需要修改操作列表中的数据，修改之后，需要原数据进行对比，即原数据不能改

（7）列表排序—sort

列表的排序，一般来说都是对数字进行排序的

• 列表.sort（）

  • 按照升序排序，从小到大

• 列表.sort（reverse = True）

  • 降序排序，从大到小

• sorted(my_list) — 正序排列；

  sorted(my_list,reverse = True) — 倒叙排列；

  my_list.sort() — 正序排列；

  my_list.sort(reverse = True) — 倒叙排列；

  my_list.reverse() — 反转排列；

  reversed(my_list) — 反转排列；

list = [1,4,2,6,8,9,10,5,3]
# 升序排序
list.sort()
print(list)
# 降序排序
list.sort(reverse=True)
print(list)

运行结果：
[1, 2, 3, 4, 5, 6, 8, 9, 10]
[10, 9, 8, 6, 5, 4, 3, 2, 1]

（8）列表嵌套

person = [["张三","18","功能测试"],["李四","20","自动化测试"]]
print(len(person))
print(person[0])
print(person[0][1])
print(person[0][0][0])

person[0][1] = "19"
print(person)

# 给李四添加一个性别信息
person[1].append("男")
print(person)
# 将张三的年龄删除
person[0].pop(1)
print(person)

运行结果：
2
['张三', '18', '功能测试']
18
张
[['张三', '19', '功能测试'], ['李四', '20', '自动化测试']]
[['张三', '19', '功能测试'], ['李四', '20', '自动化测试', '男']]
[['张三', '功能测试'], ['李四', '20', '自动化测试', '男']]

（9）列表去重

• 列表去重：列表中存在多个数据，需求：取出列表中重复的数据

• 方法1：

  • 遍历原列表中的数据，判断在新列表中是否存在，如果存在，不管，如果不存在放入新的列表中
  • 遍历：for 循环实现
  • 判断是否存在：可以用 in
  • 存入数据：append（）

• 方法2：

  • 在python中还有一种数据类型，称为集合（set）

  • 特点：集合中不能有重复的数据（如果有重复的数据会自动去重）

  • 可以使用集合的特点对列表去重

    • 使用set（）类型转换将列表转换为集合类型
    • 再使用list（）类型转换将集合转换为列表
    • 缺点：不能保证数据再原列表中出现的顺序（一般可忽略）

    # 方法1：
    my_list = [1,2,3,4,2,3,7,9,4]
    my_list1 = []
    for i in my_list:
        if i not in my_list1:
            my_list1.append(i)
    
    # 方法2：
    print(my_list1)
    my_list = [1,2,3,4,2,3,7,9,4]
    my_list = set(my_list)
    my_list = list(set(my_list))
    print(my_list)
    
    

小总结

• 列表查询：
  • 列表.index(数据，开始下标，结束下标)
  • 数据 in 容器
• 列表添加数据：
  • 列表.append(数据) 添加到列表末尾
  • 列表.insert(下标，数据) 在下标位置插入
  • 列表.extend(列表2) 在列表1末尾合并列表2
• 列表修改：
  • 列表[下标] = 修改内容
• 列表删除：
  • 列表.pop（下标）
  • 列表.remove（数据）
  • 列表.clear（） # 清空列表
• 列表反转：
  • 列表[：：-1]
  • 列表.reverse（）
• 列表复制：
  • 列表[ : ]
  • 列表.copy（）
• 列表排序：
  • 列表.sort（） # 升序排序
  • 列表.sort（reverse = True） # 降序排序
• 列表嵌套：
  • 与多元数组原理一样

13、python元组

• 元组：tuple，元组的特点和列表非常相似

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

  区别：

  • 元组中的数据内容不能改变，列表中的可以改变
  • 元组使用（），列表使用[ ]

  应用

  • 在函数的传参或者返回值中使用，保证数据不会被修改

• 定义：

  • 使用类实例化方法
  • 直接使用（）方法

  # 1、类实例化方法：
  # 定义空元组（不会使用的）
  my_tuple = tuple()
  print(type(my_tuple),my_tuple)
  
  # 类型转换
  # 可以将列表转换为元组，只需将[],变为（）,同时将元组转换列表，健（）变为[]
  my_tuple2 = tuple([1,2,3])
  print(my_tuple2)
  
  # 转换字符串，和列表中一样，只是将列表的[]变为（）
  my_tuple3 = tuple("hello")
  print(my_tuple3)
  
  # 2、直接使用（）定义
  my_tuple4 = (1,"xiaowang",3.14,False)
  print(my_tuple4)
  
  # 特殊点，定义一个只有一个数据的元组时，数据后边必须有一个逗号
  my_tuple5 = (1,)
  my_tuple6 = (1)
  print(my_tuple5)
  print(my_tuple6)
  
  运行结果：
  <class 'tuple'> ()
  (1, 2, 3)
  ('h', 'e', 'l', 'l', 'o')
  (1, 'xiaowang', 3.14, False)
  (1,)
  1
  

• 常用方法：

  • 元组中的数据不能修改，所以只有查看的方法
  • 元组中可以使用下标和切片获取数据
  • 元组中存在index方法
  • 元组中存在count方法
  • 元组中可以使用 in 操作
  • 以上方法使用和列表list类似

14、python字典

• 字典dict，字典中的数据是由键（key）值（value）对组成的（键表示数据的名字，值就是具体的数据）

  • 在字典中一组键值对是一个数据，多个键值对之间使用逗号隔开

  • 变量 = {key：value，key：value，…}

  • 一个字典中的键是唯一的，不能重复的，值可以是任意数据

  • 字典中的键，一般都是字符串，可以是数字，不能是列表

# 1、使用类实例化方法
my_dict = dict()
print(type(my_dict),my_dict)

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

# 直接使用{}定义
# 空字典
my_dict1 = {}
print(type(my_dict1),my_dict1)
# 非空字典，小明（name）18(age)1.71(height) True(is_men) 抽烟 喝酒 烫头（hobby）
my_dict2 = {"name":"小明","age":18,"height":1.71,"is_men":True,"like":["抽烟","喝酒","烫头"]}
print(my_dict2)
print(len(my_dict2))

运行结果：
<class 'dict'> {}
<class 'dict'> {}
{'name': '小明', 'age': 18, 'height': 1.71, 'is_men': True, 'like': ['抽烟', '喝酒', '烫头']}
5

（1）字典添加

• 字典[键] = 数据值

  • 如果键已经存在，就是修改数据值
  • 如果键不存在，就是添加数据（即添加键值对）

  # 定义字典 小明 18 爱好
  my_dict = {"name":"小明","age":18,"hobby":["抽烟","喝酒","烫头"]}
  print(my_dict)
  
  my_dict["sex"] = "男"
  print(my_dict)
  
  my_dict["name"] = "小黄"
  print(my_dict)
  
  my_dict["hobby"].append("学习")
  print(my_dict)
  
  运行结果：
  {'name': '小明', 'age': 18, 'hobby': ['抽烟', '喝酒', '烫头']}
  {'name': '小明', 'age': 18, 'hobby': ['抽烟', '喝酒', '烫头'], 'sex': '男'}
  {'name': '小黄', 'age': 18, 'hobby': ['抽烟', '喝酒', '烫头'], 'sex': '男'}
  {'name': '小黄', 'age': 18, 'hobby': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}
  

（2）字典删除—del、clear

• 删除指定键值对

  • del 字典[键]

• 清空字典

  • 字典.clear（）

  my_dict = {"name":"小明","age":18,"hobby":["抽烟","喝酒","烫头"]}
  del my_dict["name"]
  print(my_dict)
  
  my_dict.pop("age")
  print(my_dict)
  
  my_dict["hobby"].pop(0)
  print(my_dict)
  
  my_dict.clear()
  print(my_dict)
  
  运行结果：
  {'age': 18, 'hobby': ['抽烟', '喝酒', '烫头']}
  {'hobby': ['抽烟', '喝酒', '烫头']}
  {'hobby': ['喝酒', '烫头']}
  {}
  

（3）字典查询—get

根据键获取对应的值

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

• 字典[键]

  • 如果键存在，返回键对应的数据值
  • 如果键不存在，会报错

• 字典.get(键)

  • 字典.get(键，数据值)
  • 数据值一般不写，默认是None
  • 返回：
    • 如果键存在，返回键对应的数据值
    • 如果键不存在，返回的是括号中书写的数据值（None）
  • 一般建议使用get方法

  my_dict = {"name":"小明","age":18,"hobby":["抽烟","喝酒","烫头"]}
  print(my_dict["name"])
  
  print(my_dict.get("name"))
  
  print(my_dict.get("name1","没有要查找的键就显示我！"))
  
  print(my_dict["hobby"][1])
  
  print(my_dict.get("hobby")[2])
  
  运行结果：
  小明
  小明
  没有要查找的键就显示我！
  喝酒
  烫头
  

（4）字典遍历—keys、values、items

• 对字典的键进行遍历

  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,"hobby":["抽烟","喝酒","烫头"]}

for i in my_dict:
    print(i)

print("-"*200)

for i in my_dict.keys():
    print(i)

print("-"*200)

for i in my_dict.values():
    print(i)

print("-"*200)

for i,j in my_dict.items():
    print(i,j)
    
运行结果：
name
age
hobby
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
name
age
hobby
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
小明
18
['抽烟', '喝酒', '烫头']
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
name 小明
age 18
hobby ['抽烟', '喝酒', '烫头']

小总结

• 字典添加：

  • 字典[键] = 数据值
  • 字典.append（数据值）

• 字典删除：

  • del 字典[键]
  • 字典.pop（键）
  • 字典.clear（） ——清空字典

• 字典查询

  • 字典[键]
  • 字典.get（键）

• 字典遍历

  • for i in 字典.keys（）——遍历键
  • for i in 字典.values（）——遍历值
  • for i,j in 字典.items（）——遍历键值

15、python函数

（1）概念

• 函数就是把具有独立功能的代码块组织为一个小模块，在需要的时候调用
• 通俗理解，将多行代码写在一块，起个名字，在需要这多行代码的时候，可以直接使用这个名字来代替
• 作用：减少代码的冗余（重复的代码不用多写），提高程序的编写效率

（2）定义

• 将多行代码放在一块，起名字的过程，称为函数定义

• 函数必须先定义后调用

• 语法

  def 函数名():
  	函数中的代码1
  	函数中的代码2
  

  • def是关键字，用来定义函数的 define的缩写
  • 函数名需要遵守标识符的规则是
  • 处于def缩进中的代码，称为函数体
  • 函数定义的时候，函数体中的代码不会执行，在调用的时候才会执行

• 函数定义小技巧

  • 在前期，书写不熟练的时候
    • 可以先不管函数，先把功能写出来
    • 给多行代码起名字
    • 选中多行代码，使用tab进行缩进

（3）调用

• 使用多行代码的时候，称为函数调用

• 语法

  函数名()
  

  • 函数调用的时候会执行函数体中代码
  • 函数调用的代码，要写在函数体外

（4）文档注释

• 文档注释的本质，还是注释，只不过书写的位置和作用比较特殊

• 书写位置，在函数名的下方使用三对双引号进行注释

• 作用：告诉别人这个函数如何使用的，干什么的

  • 查看，在调用的时候，将光标放在函数名上，使用快捷键CTRL P
  • CTRL+B转到函数声明中查看

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w2xCoyZJ-1659184224039)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220720165115189.png)]

（5）嵌套调用

• 在一个函数定义中调用另一个函数

  • 函数定义不会执行函数体中的代码
  • 函数调用会执行函数体中的代码
  • 函数体中代码执行结束会回到函数被调用的地方继续向下执行

  def func1():
      print(1)
      print("func1")
      print(2)
  
  def func2():
      print(3)
      func1()
      print(4)
  
  func2()
  
  运行结果:
  3
  1
  func1
  2
  4
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UrBtQvUo-1659184224040)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220720170551564.png)]

（6）函数参数

• 函数参数：在函数定义的时候，使用变量代替具体的数据值（进行占位），在函数调用的时候，传递具体的数据

• 好处：让函数更加通用，能够解决一类问题，而不是单纯的一个问题

• 形式参数：形参，使用变量代替具体的数据，在函数定义时起占位作用

• 实际参数：实参，具体的数据值，调用函数时，会传递给形参

• 调用函数时，形参个数必须等于实际参数，否则报错

  # 1、定义一个函数，求两个数字和
  # num1和num2是函数定义时的参数，起到占位的作用，没有具体的数据值，称为形式参数，简称形参
  def sum(num1,num2):
      num = num1 + num2
      print(num)
  
  sum(34,56)   # 在函数调用的时候，括号中的数据会传递给形参，时具体的数据值，称为实际参数，简称实参
  

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hQ6SI2fM-1659184224040)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220721094749308.png)]

• 函数的传参方式：

  • 位置传参
    • 在函数调用的时候，按照形参的顺序，将实参传递给形参
  • 关键字传参
    • 在函数调用的时候，指定数据值给到哪个形参
  • 混合使用
    • 关键字传参必须写在位置传参的后面
    • 不要给一个形参传递多个数据值

  def func(a,b,c):
      print(f"a:{a},b:{b},c:{c}")
  
  
  # 位置传参
  func(1,2,3)
  
  # 关键字传参
  func(a=2,b=3,c=1)
  
  # 混合使用
  func(1,5,c=4)
  
  运行结果：
  a:1,b:2,c:3
  a:2,b:3,c:1
  a:1,b:5,c:4
  

• 缺省参数

  • 缺省参数，默认参数
  • 定义方式：
    • 在函数定义的时候，给形参一个默认的数据值，这个形参就变为缺省参数
    • 缺省参数的书写要放在普通参数的后边
  • 特点（好处）;
    • 在函数调用的时候，可以传递实参值，也可以不传递实参值
    • 传参，则传递的实参值，不传参，使用的默认值

def show_info(name,sex="保密"):   # 此处sex的参数为默认值，在调用函数的时候，如果没有实参值，则默认值为”保密“
    print(name,sex)

show_info("小王")   # 此处没有给sex传递实参值
show_info("小王","男")  # 此处给sex传递的实参值为”男“

运行结果：
小王 保密
小王 男

• print（）函数中的形参（缺省参数）

  • sep’ '，多个位置参数之间的间隔

  • end=‘\n’ 每一个print函数结束，都会打印的内容，结束符

print定义函数：

def print(self,*args,sep=' ',end='\n',file=name)

• 多值参数[可变参数/不定长参数]

  • print(1)
    print(1,2)
    print(1,2,3)
    print(1,2,3,4)
    

  • *不定长位置参数（不定长元组参数）——(args)

    • 书写，在普通参数的前边 ，加上一个*，这个参数就变成不定长位置参数
    • 特点：这个形参 可以接收任意多个位置传参的数据
    • 数据类型：形参的类型是元组tuple
    • 不定长位置参数，要写在普通的参数的后面
    • 一般写法，不定长位置参数的名字为args，即（*args） # arguments

  • **不定长关键字参数（不定长字典参数）——****kwargs

    • 书写：在普通 参数的前边，加上两个*，这个参数就变成了不定长关键字参数
    • 特点：这个形参可以接收任意多个关键字传参的数据
    • 数据类型：形参的类型是字典dict
    • 不定长关键字参数，要写在所有参数的最后边
    • 一般写法：不定长关键字参数的名字为kwargs，即（**kwargs） # keyword arguments

  • 如果同时有位置参数和关键字参数，则位置参数分别传到*args，关键字**kwargs

  • 完整的参数顺序

  def 函数名（普通函数,*args,缺省参数,**kwargs）
  	pass
  
  #一般在使用的时候，使用1-2种，按照这种顺序挑选书写即可

def func(*args,**kwargs):
    print(type(args),args)
    print(type(kwargs),kwargs)
    print("-"*30)

func(1,2,3,4)  # 位置传参，数据都给*args
func(a=1,b=2,c=3,d=5)  # 关键字传参，数据都给**kwargs
func(1,2,3,a=6,b=7,c=9)  # 位置和关键字传参，位置给args，关键字给kwargs

运行结果：
<class 'tuple'> (1, 2, 3, 4)
<class 'dict'> {}
------------------------------
<class 'tuple'> ()
<class 'dict'> {'a': 1, 'b': 2, 'c': 3, 'd': 5}
------------------------------
<class 'tuple'> (1, 2, 3)
<class 'dict'> {'a': 6, 'b': 7, 'c': 9}
------------------------------

• 使用元组和字典进行传参
  • 将字典和列表中的数据使用my_sum函数进行求和，该如何传参？
  • 想要将列表（元组）中的数据，分别作为位置参数进行传参，需要使用*对列表进行拆包操作
    • my_sum（*my_list）
  • 想要将字典中的数据，作为关键字传参，需要使用**对字典进行拆包
    • my_sum（**my_dict）

def my_sum(*args,**kwargs):
    num = 0
    for i in args:
        num += i
    for j in kwargs.values():
        num += j

    print(num)

my_list = [1,2,3,4]
my_tuple = (2,3,4,5,6)
my_dict = {"a":1,"b":2,"c":5,"d":8}

my_sum(*my_list,**my_dict)
my_sum(*my_tuple,**my_dict)

运行结果：
26
36

（7）返回值

• 函数的返回值，可以理解为是函数整体执行的结果是什么

  • print（） ==》None
  • input（） ==》键盘输入的内容
  • type（） ==》类型
  • len（） ==》数据的长度（元素的个数）

• 在函数中想要将一个数据作为返回值返回，需要使用return关键字（只能在函数中使用）

  • 将数据值作为返回值返回
  • 函数代码执行遇到return，会结束函数的执行

• 想要将函数中返回的结果，在后续的代码中使用，即需要将这个数据保存下来，需要使用变量来保存函数的返回值（执行结果）

  • 变量 = 函数（）

  def sum(a,b):
      num = a + b
      # print(num) # 代码中没有返回值，只有print，这个结果只能在函数中用一次，不能后续使用
      return num # 将这个结果返回到调用的地方
  
  
  # sum(1,2)
  print(sum(1,2)) # 函数中没有print，只有return，想要查看结果，需要在调用的时候使用print
  
  
  # 想要将函数中返回的结果，在后续代码中使用，即需要将这个数据保存下来，需要使用变量来保存函数的返回值（执行结果）
  # 变量 = 函数（）
  result = sum(1,2)
  

• return返回值的说明

  def 函数名():  # 返回值None
      pass
  
  def 函数名():
      return  # return后边没有数据，返回值None
  
  def 函数名():
      return xx  # 返回值是xx
  
  

（8）变量进阶（理解）

• 变量的引用

  • 变量和数据都是保存在内存中的，python解释器会在内存中分两块空间存储

  • 在python中函数的参数传递以及返回值都是靠引用传递的

  • 本质是将数据的地址保存到变量对应的内存中

  • 变量中存储数据地址的行为就是引用（变量引用了数据的地址，简单说就是变量中存储数据），存储的地址称为引用地址

  • 可以使用id（），获取变量中的引用地址（即数据地址），如果两个变量的id（）获取的引用地址一样，即代表两个变量引用了同一个数据

  • 只有 赋值运算符=，可以改变变量的引用（等号左边数据的引用）

• 可变类型和不可变类型

  • 数据类型：int float bool str list tuple dict set

  • 可变和不可变：数据所在的内存是否允许修改，允许修改就是可变类型，不允许修改就是不可变类型

  • 可变类型：列表（list）、字典（dict）、集合（set）

    • 列表.append（）
    • 字典.pop（键）

  • 不可变类型：int float bool str tuple

• 只有 =，可以改变引用

• 可变类型 参数，在函数内部，如果不适用 = 直接修改形参的引用

def func(list1):  # list1 = my_list 此时两个变量的引用是相同的
    list11  = [2,1]  #  此时，list1变量的引用发生了变化，问，my_list的引用没有改变，数据不会变

my_list = [1,2]
func(my_list)
print(my_list)

运行结果：
[1, 2]

def func(list1):
    list1 += [1,2]  #对于列表来说，+=本质是extend（列表合并 ）操作

my_list = ["a","b"]
func(my_list)
print(my_list)

运行结果：
['a', 'b', 1, 2]

（9）交换两个变量值

# 方法1：常规方法，引用第三个变量
a = 10
b = 20

c = a # 将变量a中 的值先保存在c中
a = b # 将变量b中的值给a
b = c # 将变量c中的值给b

print(a,b)

# 方法2：不使用第三变量，使用数学中的方法
a = a + b  #  a的值为30
b = a - b  #  30 - 20  ==》10
a = a - b  #  30 - 10 ==》20
print(a,b)

# 方法3：重点掌握，python特有
a,b = b,a
print(a,b)

• 组包和拆包
  • 组包（pack）
    • 将多个数据值使用逗号连接的过程，组成元组
  • 拆包（unpack）
    • 将容器中多个数据值使用多个变量分别保存的过程
    • 变量的个数和容器中数据的个数要保持一致
  • 赋值运算符，都是先执行等号右边的代码，执行的结果，保存到等号左边的变量中

a = 10
b = 20
c = b,a   # 组包
print(type(c),c)

a,b = c  # 拆包
print(a,b)

运行结果：
<class 'tuple'> (20, 10)
20 10

（10）局部变量和全局变量

根据变量的定义位置，可以将变量分为局部变量和全局变量

1）局部变量

• 局部变量：在函数内部（函数的缩进中）定义的变量，称为是局部变量
• 特点：
  • 局部变量只能在当前函数内部使用，不能在其他函数和函数外部使用
  • 在不同函数中，可以定义名字相同的局部变量，两者之间没有影响
  • 生命周期（作用范围）——在哪能用
    • 在函数被调用的时候，局部变量被创建，函数调用 结束，局部变量的值被销毁（删除），不能使用
    • 所以函数中的局部变量的值，如果想要在函数外部使用，需要使用return关键字，将这个值及进行返回

def func1():
    num = 10
    print(f"func1中的局部变量值为:{num}")


def func2():
    num = 100   # 可以在不同函数中定义同一名字的局部变量
    print(f"func2中的局部变量值为:{num}")

func1()
func2()
func1()

运行结果：
func1中的局部变量值为:10
func2中的局部变量值为:100
func1中的局部变量值为:10

2）全局变量

• 全局变量：在函数外部定义的变量，称为是全局变量
• 特点：
  • 可以在任何函数中读取（获取）全局变量的值
  • 如何在函数中存在和全局变量名字相同的局部变量，在函数中使用的是，局部变量的值（就近）
  • 在函数内部想要修改全局变量的引用，需要添加global关键字，对变量进行生命为全局变量
  • 生命周期：
    • 代码执行的时候被创建，代码执行结束，被销毁（删除）

num = 10

def func1():
     print(num) # 在函数中可以读取全局变量的值


def func2():
    num = 20 # 定义局部变量，不会影响全局变量
    print(num)


def func3():
    global num  # 这个函数中使用的num都是全局变量，一般写在第一行
    num = 30    # 这里是把全局变量的num值改为了30，所以还是三十，前面对应的全局变量全部变为30
    print(num)

func1()
func2()
func3()
func1() # 因为func3()改变了全局变量的值

运行结果：
10
20
30
30

（11）返回多个数据值

• 返回一个数据值，使用return关键字
• 将多个数据值组成容器进行返回，一般是元组（组包）
• 变量 = 函数（数据1，数据2） 此时变量类型为元组类型

def func(a,b):
    num1 = a + b
    num2 = a - b
    return num1,num2
# 方法1：
result = func(10,5) # 此时result为元组
print(type(result),result,result[0],result[1])

# 方法2：直接拆包
x,y = func(20,13)
print(type(x),x,y)

运行结果：
<class 'tuple'> (15, 5) 15 5
<class 'int'> 33 7

（12）匿名函数—lambda

• 匿名函数：使用lambda关键字定义函数

  • 一般称为使用def关键字定义的函数为 标准函数

  • 匿名函数只能书写一行代码

  • 匿名函数的返回值不需要return ，一行代码（表达式）的结果就是返回值

  • 匿名函数一般不需要我们主动的调用

  • 一般作为函数的参数使用

  • 使用场景：作为函数的参数，这个函数比较简单，值使用一次，没有必要使用def定义

• 语法：lambda 参数：一行代码

  • 这一行代码称为表达式

# 1、无参无返回值
def func1():
    print("hello world")
func1()
################
lambda :print("hello lambda")
func11 = lambda :print("hello lambda")  #尽量不对lambda表达式赋值，使用def
# 2、无参有返回值
def func2():
    return 10

print(func2())
#################
lambda :10
func22 = lambda :10
print(func22)
# 3、有参无返回值
def my_sum(a,b):
    print(a + b)

my_sum(1,2)
#################
my_sum11 = lambda a,b:print(a+b)
my_sum11(10,29)

# 4、有参有返回值
def func4(a,b):
    return a + b

print(func4(1,2))
#################
func44 = lambda a,b:a+b
print(func44(1,2))

• 匿名函数作为函数的参数—列表中的字典排序
  • 列表.sort（key = lambda x：x['键 ']）——升序
  • 列表.sort（key = lambda x：x['键 ']，reverse = True）——降序

user_list = [
    {"name":"zhangsan","age":18},
    {"name":"lisi","age":19},
    {"name":"wangwu","age":12}
            ]
# user_list.sort()
# 列表的排序，默认是对列表中的数据进行比大小的，可以对数字类型和字符串进行比大小
# 但是对于字典来说，就不知道怎么比大小，此时，我们需要使用sort函数中的key这个参数，来指定字典比大小的方法
# key这个参数，需要传递一个函数，一般是匿名函数，字典的排序，其实要指定根据字典的什么键进行排序，我们只需要使用匿名函数返回字典的这个键对应的值即可

# 根据年龄排序
user_list.sort(key = lambda x: x["age"])
print(user_list)

# 说明：匿名函数中的参数x是列表中的（字典）数据，在sort函数内部，会调用key这个函数（将列表中每个数据作为实参传递给形参）
# 从列表中的获取函数的返回值，对返回值进行比较大小操作

三、python进阶

1、面向对象

（1）基本介绍

• 面向对象是一个编程思想（写代码的套路）
• 编程思想：
  • 面向过程
  • 面向对象
  • 都属于写代码的套路（方法），最终目的都是为了将代码书写出来 ，
  • 过程与思考方法不太一样
• 面向过程
  • 关注的是具体步骤的实现，所有的功能都自己书写
  • 亲历亲为
  • 定义一个个函数，最终按照顺序调用函数
• 面向对象
  • 关注的是结果，谁（对象）能帮我做这件事
  • 偷懒
  • 找一个对象，让对象去做

（2）类和对象

• 面向对象的核心思想是，找一个对象去帮我们处理事情

• 在程序代码中，对象是由类创建的

• 类和对象，是面向对象编程思想中非常重要的概念

• 类

  • 抽象的概念，对多个特征和行为相同或者相似事务的统称
  • 特征称为属性
  • 行为称为方法
  • 泛指的（指代多个，而不是具体的一个）

• 对象

  • 是由类创建的，具体存在的一个 事物，看得见摸得着的
  • 特指的，（指代一个）

• 类和对象的关系

  • 类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
  • 类只有一个，而对象可以有很多个
    • 不同的对象之间，属性可能会各不相同
  • 类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少

（3）类的组成

• 类名
  • 给这多个事物起一个名字
  • 在代码中，满足大驼峰命名法（每个单词的首字母大写）
• 属性
  • 事物的特征，一般文字中的名词
• 方法
  • 事物的行为，即能做什么事，一般是动词（一般函数定义）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x5imQGlC-1659184224041)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220722203241182.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zYNCGFWy-1659184224042)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220722203519023.png)]

（4）类的抽象（类的设计）

• 类的抽象，其实就是找到类的 类名、属性和方法

（5）面试代码的步骤

• 定义类，在定义类之前先设计类

  • 先定义简单的类，不包含属性，在python中定义类需要使用关键字class
  • 方法：方法的本质是在类中定义的函数，只不过，第一个参数是self

  class 类名
  	# 在缩进中书写的内容，都是类中的代码
  	def 方法名（self）:  # 就是一个方法
  		pass
  

• 创建对象，使用第一步定义的类创建对象

  • 创建对象使用类名（进行创建），即

  类名（） # 创建一个对象，这个对象在后续不能使用
   # 创建的对象想要在后续的代码中继续使用，需要使用一个变量，将这个对象保存起来
   
  变量 = 类名（） #这个变量中保存的是对象的地址，一般可以称为这个变量为对象
  
  # 一个类可以创建多个对象，只要出现 类名（）就是创建一个对象，每个对象的地址是不一样的
  

• 通过对象调用方法

对象.方法名（）

列表.sort()
列表.append()

class cat:
    def eat(self):   # self会自动出现，暂不管
        print("小猫爱吃鱼")
    def drink(self):
        print("小猫要喝水")
# 创建对象，可以创建无限个对象
small_cat = cat()
# 通过对象调用类中的方法
small_cat.eat()
small_cat.drink()

运行结果：
小猫爱吃鱼
小猫要喝水

（6）self的说明—对象

class cat:
    def eat(self):   # self会自动出现，暂不管
        print("小猫爱吃鱼")
        
small_cat = cat()
small_cat.eat()

• 从函数的语法上将，self是形参，就可以是任意的变量名，只不过我们习惯性将这个形参写作self
• self是普通的形参，但是在调用的时候没有传递实参值，原因是，python解释器在执行代码的时候，自动的将调用这个方法的对象传递给了self，即self的本质是对象
• 验证，只需要确定通过哪个对象调用，对象的引用和self的引用是一样的
• self是函数中的局部变量，直接创建的对象是全局变量

class cat:
    def eat(self):
        print(f"{id(self)},self地址")

blue_cat = cat()
blue_cat.eat()
print(f"{id(blue_cat)},blue_cat地址")

print("-"*50)
black_cat = cat()
black_cat.eat()
print(f"{id(black_cat)},black_cat地址")

运行结果：
2120273760016,self地址
2120273760016,blue_cat地址
--------------------------------------------------
2120273756992,self地址
2120273756992,black_cat地址

（7）对象的属性操作

• 添加属性

  • 对象.属性名 = 属性值
  • 类内部添加
    • 在内部方法中，self是对象
    • self.属性名 = 属性值
    • 在类中添加属性一般写在_ init _方法中
  • 类外部添加
    • 对象.属性名 = 属性值 # 一般不使用

• 获取属性

  • 对象.属性名
  • 类内部
    • 在内部 中，self是对象
    • self.属性名
  • 类外部
    • 对象.属性名 # 一般很少使用

class cat:
    def eat(self):
        print(f"{id(self)},self地址")
        print(f"小猫{self.name}爱吃鱼...")

blue_cat = cat()
print(f"{id(blue_cat)},blue_cat地址")
blue_cat.name = "蓝猫"
blue_cat.eat()


print("-"*50)
black_cat = cat()
print(f"{id(black_cat)},black_cat地址")
black_cat.name = "黑猫"
black_cat.eat()

运行结果：
2115323891568,blue_cat地址
2115323891568,self地址
小猫蓝猫爱吃鱼...
--------------------------------------------------
2115323891472,black_cat地址
2115323891472,self地址
小猫黑猫爱吃鱼...

2、魔法方法

• python中有一类方法，以两个下划线开头，两个下划线结尾，并且满足某个条件的情况下，回自动调用，这类方法称为魔法方法

（1）__ init __方法

• 什么情况下自动调用
  • 创建对象之后会自动调用
• 有什么用，用在哪
  • 给对象添加属性的（初始化方法，构造方法）
  • 某些代码，在每次创建对象之后，都要执行，就可以将这行代码写在__ init __方法
• 书写的注意事项
  • 注意不要写错（不要写成int）
  • 如果init方法中，存在除了self之外的参数，在创建对象的时候必须传参

# 猫类，属性 name,age,show_info(输出属性信息)
class Cat:
    def __init__(self,name,age):  # 创建对象之后会被调用
        self.name = name  # 给对象添加name属性
        self.age = age # 给对象添加age属性
        print("我是__ini  t__方法，被调用了")


    def show_info(self):
        print(f"小猫的名字是{self.name},年龄是{self.age}")


# 创建对象，不要在自己类缩进中创建
blue_cat = Cat("蓝猫",2)  # 创建对象，会调用__int__函数
blue = blue_cat   # 不是创建对象，不会调用，这里表示同一个对象，两个名字
blue.show_info()

输出结果：
我是__int__方法，被调用了
小猫的名字是蓝猫,年龄是2

（2）__ str __方法

• 什么情况下自动调用
  • 使用print（对象）打印对象的时候，会自动调用
• 有什么用，用在哪
  • 在这个方法中一般书写对象的属性信息的，即打印对象的时候想要查看什么信息，在这个方法中进行定义的额
  • 如果类中没有定义__ str __方法，print（对象），默认输出对象的引用地址
• 注意事项：
  • 这个方法必须返回一个字符串

# 猫类，属性 name,age,show_info(输出属性信息)
class Cat:
    def __init__(self,name,age):  # 创建对象之后会被调用
        self.name = name  # 给对象添加name属性
        self.age = age # 给对象添加age属性
        print("我是__init__方法，被调用了")

    def __str__(self):
        # 方法必须返回一个字符串
        return f"小猫的名字是{self.name},年龄是{self.age}"

    def show_info(self):
        print(f"小猫的名字是{self.name},年龄是{self.age}")


# 创建对象，不要在自己类缩进中创建
blue_cat = Cat("蓝猫",2)  # 创建对象，会调用__int__函数

print(blue_cat)  # 使用print（对象），会自动调用__str__
blue = blue_cat   # 不是创建对象，不会调用，这里表示同一个对象，两个名字
blue.show_info()

（3）__ del __方法

• 对象被删除销毁时，自动调用的（遗言，处理后事）（析构方法）
• 调用场景
  • 程序代码运行结束，所有对象都被销毁
  • 直接使用del删除对象（如果对象有多个名字（多个对象引用一个对象），需要把所有的对象删除才行）

class demo:
    def __init__(self,name):
        print("我是__init__，我被调用了")
        self.name = name

    def __del__(self):
        print(f'{self.name}没了，给它处理后事')

a = demo("a")
b = demo("b")
del a
print("代码运行结束！")

运行结果：
我是__init__，我被调用了
我是__init__，我被调用了
a没了，给它处理后事
代码运行结束！
b没了，给它处理后事

class demo:
    def __init__(self,name):
        print("我是__init__，我被调用了")
        self.name = name

    def __del__(self):
        print(f'{self.name}没了，给它处理后事')

a = demo("a")
c = a
b = demo("b")
del a,c
print("代码运行结束！")

3、封装

• 封装是面向对象编程的有一大特点

• 面向对象编程的第一步——将属性和方法封装到一个抽象的类中

• 外界使用类创建对象，然后让对象调用方法

• 对象方法的细节都被封装在类的内部

• 案例1：

  • 小明 体重 75.0公斤
  • 小明每次跑步会减肥0.5公斤
  • 小明每次吃东西体重增加1公斤
  • 类：人类 person 属性：姓名name，体重weight
  • 方法：跑步run()，吃东西eat(),添加属性__ init __ (),属性信息 __ str __

class person:
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight

    def __str__(self):   # 每当需要调用是，需要使用print（）函数输出
        return f"体重为：{self.weight}"

    def run(self):
        self.weight -= 0.5

    def eat(self):
        self.weight += 1

person1 = person("小明",75.0)
print(f"开始体重为：{person1}")
person1.run()
print(f"跑步后的体重为：{person1}")
person1.eat()
print(f"吃东西后的体重为：{person1}")

运行结果：
开始体重为：体重为：75.0
跑步后的体重为：体重为：74.5
吃东西后的体重为：体重为：75.5

• 案例2
  • 房子（House）有户型、总面积和家具名称列表
    • 新房子没有任何的家具
  • 家具（HouseItem）有名字和占地面积，其中
    • 席梦思（bed）占地 4 平米
    • 衣柜（chest）占地 2 平米
    • 餐桌（table）占地 1.5 平米
  • 将以上三件家具添加到房子中
  • 打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表
    • 剩余面积
      • 在创建房子对象时，定义一个剩余面积的属性，初始值和总面积相等
      • 当调用add_item方法，向房间添加家具时，让剩余面积 -=家具面积
  • 类名：房子House
  • 属性：户型name、总面积total_area、剩余面积free_area、家具名称列表item_list = [ ] (新房子)
  • 方法：__ init __ ， __ str __、添加家具方法add_item（）
  • 类名：家具类HouseItem
  • 属性：名字name，占地面积item_area
  • 方法：__ init __ ， __ str __、

class House:
    def __init__(self,house_name,total_area):
        self.house_name = house_name
        self.total_area = total_area
        self.free_area = total_area
        self.item_list = []

    def __str__(self):
        return f"户型：{self.house_name},总面积：{self.total_area}平米,剩余面积：{self.free_area}" \
                f"家具名称列表：{self.item_list}"

    def add_item(self,item):
        # 判断房子的剩余面积和家具的占地面积之间的关系
        # self表示的房子对象，缺少一个家具对象，使用传参解决
        if self.free_area > item.item_area:
            self.item_list.append(item.item_name)
            self.free_area -= item.item_area
        else:
            print("剩余面积不足，换个大房子吧")



class HouseItem:
    def __init__(self,item_name,item_area):
        self.item_name = item_name
        self.item_area = item_area

    def __str__(self):
        return f"家具名字：{self.item_name},占地面积:{self.item_area}平米"
# 创建家具对象
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家具名称列表：['席梦思']

• 案例3：
• 某web项目登录页面包含：用户名、密码、验证码、登录按钮和登录的方法
• 书写代码实现以上功能，登录方法中使用print输出即可
  • 类名：LoginPage
  • 属性：用户名username，密码password，验证码code，登录按钮button
  • 方法：登录（login） __ init __

class LoginPage:
    def __init__(self,username,password,code):
        self.username = username
        self.password = password
        self.code = code
        self.button  = "登录"

    def login(self):
        print(f"1、输入用户名：{self.username}")
        print(f"2、输入密码：{self.password}")
        print(f"3、输入验证码：{self.code}")
        print(f"4、点击登录：{self.button}")

user1 = LoginPage("小明","123456",9988)
user1.login()

运行结果:
1、输入用户名：小明
2、输入密码：123456
3、输入验证码：9988
4、点击登录：登录

4、私有和公有

• 在python中定义的方法和属性，可以添加访问控制权限（即在什么地方可以使用这个属性和方法）

• 访问控制权限分为两种，公有权限，私有权限

• 公有权限

  • 直接书写的方法和属性，都是公有的
  • 公有的方法和属性，可以在任意地方访问和使用

• 私有权限

  • 在类内部，属性名或者方法名前边加上两个下划线，这个属性或者方法就变为私有的
  • 私有的方法和属性，只能在当前类的内部使用
  • 私有的本质是python解释器执行代码，发现属性名或者方法名前有两个_，会将这个名字重命名
    • 例如，self.__ age ==> self. _person__age

• 什么时候定义私有

  • 某个属性或者方法，不想在类外部被访问和使用，就将其定义为私有即可
  • 测试中，一般不怎么使用，直接公有即可
  • 开发中，会根据需求文档，确定什么作为私有

• 如果想要在类外部操作私有属性，方法是在类内部定义公有的方法，通过这个方法去操作

• 对象.__ dict __ 魔法属性，可以将对象具有的属性组成字典返回

• 案例1

class person:
    def __init__(self,name,age):
        self.name = name   # 姓名
        # self.age = age   # 年龄  # 属于公有属性，外部可以调用
        # 私有的本质，是python解释器执行代码，发现属性名或者方法名前有两个_，会将这个名字重命名
        # 会在这个名字的前边加上 _类名前缀，即self.__age ==>self.person__age
        self.__age = age   # 年龄，将其定义为私有属性，属性名前加上两个_

    def __str__(self):
        return f"名字：{self.name}，年龄：{self.__age}"

person1 = person("小明",18)
print(person1)

print(person1.__dict__)
# 在类外部直接访问age属性
# print(self.age) # 公有属性时可以正常访问
# print(self.__age) #变为私有属性时访问失败，会报错
person1.__age = 20  # 这个不是修改私有属性，是添加了一个公有的属性__age
print(person1.__dict__)

print(person1)

print(person1._person__age) # 可以用但建议不要用
person1._person__age = 19
print(person1)

运行结果：
名字：小明，年龄：18
{'name': '小明', '_person__age': 18}
{'name': '小明', '_person__age': 18, '__age': 20}
名字：小明，年龄：18
18
名字：小明，年龄：19

5、继承

• 封装 根据职责将属性和方法封装到一个抽象的类中

• 继承 实现代码的重用，相同的代码不需要重复的编写

• 多态 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

• 继承的概念

  • 子类 拥有 父类的多有方法和属性
  • 继承描述的是类与类之间的关系
  • 好处：减少代码的冗余（相同的代码不需要多次重复书写），可以直接使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fuOpghux-1659184224042)(C:/Users/xiaohuang/AppData/Roaming/Typora/typora-user-images/image-20220724092437061.png)]

• 语法：

  • class 类名（父类名）：
  • 子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
  • 子类中应该根据职责，封装子类特有的属性和方法

  class A(object):   # 没有写父类，但也有父类，object,object类是python中最顶级（原始）的类
  	pass
  	
  class B(A):
  	pass
  	
  # A 类，称为是 父类（基类）
  # B 类，称为是 子类（派生类）
  # 子类（B）继承父类（A）之后，子类的对象可以直接使用父类中定义的公有属性和方法
  

• 单继承：一个类只继承一个父类，称为单继承

案例1：

# 1、定义一个动物类，吃
# 2、定义一个 狗类，继承动物类，吃，叫
# 3、定义一个 哮天犬类，继承狗类

class Animal:
    def eat(self):
        print("吃东西")

class Dog(Animal):
    def sound(self):
        print("汪汪叫...")

class XTQ(Dog):
    pass
    
A = Dog()
A.eat()
A.sound()

xtq = XTQ()
xtq.eat()  # 可以调用父类的父类的方法

运行结果：
吃东西
汪汪叫...
吃东西

• 结论

  • python中对象.方法（）调用方法
  • 先在自己的类中去找有没有这个方法，如果有，直接调用
  • 如果没有，去父类中查找，如果有，直接调用
  • 如果没有，去父类的父类中查找，如果有，直接调用
  • …
  • 如果object类中有，直接调用，如果没有，代码报错

• 重写

  • 在子类中定义了和父类中名字相同的方法，就是重写

  • 原因：父类中的方法，不能满足子类对象的需求

  • 特点：调用子类中的方法，不再调用父类中的方法

  • 重写方式：

    • 覆盖（父类中功能完全抛弃，不要，重新书写）

      • 直接在子类中定义和父类中名字相同的方法
      • 直接在方法中书写新的代码

      class dog:
          def bark(self):
              print("汪汪叫...")
      
      class xtq(dog):
          def bark(self):
              print("嗷嗷叫...")
      
      
      xtq1 = xtq()
      xtq1.bark()
      
      运行结果：
      嗷嗷叫...
      

    • 扩展（父类中功能还调用，只是添加一些新的功能）（使用较多）

      • 直接在子类中定义和父类中名字相同的方法
      • 在合适的地方调用父类中方法 super（）.方法（）
      • 书写添加的新功能

      class dog:
          def bark(self):
              print("汪汪叫...")
      
      class xtq(dog):
          # 1、先嗷嗷叫（新功能） 2、在汪汪叫（父类功能） 3、再嗷嗷叫
          def bark(self):
              print("嗷嗷叫...")
              super().bark()  # 调用父类中的代码
              print("嗷嗷叫...")
      
      xtq1 = xtq()
      xtq1.bark()
      
      运行结果：
      嗷嗷叫...
      汪汪叫...
      嗷嗷叫...
      

6、多态

• 是一种写代码，调用的技巧

• 不同的子类对象调用相同的父类方法，产生不同的执行结果

• 多态可以增加代码的灵活度

• 以 继承 和重写 父类方法 为前提

• 是调用方法的技巧，不会影响到类的内部设计

• 哪个对象调用的方法，就去自己的类中去查找这个方法，找不到去父类中找

# 1、定义 人类 person，方法work，输出：人需要工作
class person:
    def work(self):
        print("人需要工作")

# 2、定义开发工程师类coder继承person类，方法work，输出：开发的工作是写代码
class coder(person):
    def work(self):
        print("开发人员——工作是写代码")

# 3、定义 测试工程师类tester 继承person类，方法work,输出：测试的工作是测试项目...
class tester(person):
    def work(self):
        print("测试人员——工作是测试项目")

# 4、定义公司类company，定义方法show_work(查看不同岗位的工作)，参数人类对象，在这个方法中调用work方法
class company:
    def show_work(self,worker):  # worker参数需要传入一个对象，只要这个对象有work方法
        worker.work()   # worker是person类以及其子类的对象
# 创建一个company类的对象
c = company()
# 创建coder类的对象
coder1 = coder()
# 创建tester类的对象
tester1 = tester()
# 创建person类对象
person1 = person()

c.show_work(coder1)
c.show_work(tester1)
c.show_work(person1)

运行结果：
开发人员——工作是写代码
测试人员——工作是测试项目
人需要工作

7、属性和方法

• python 中一切皆对象，即使用class定义的类也是一个对象

（1）对象的划分

• 实例对象（实例）
  • 通过 类名（）创建的对象，我们称为实例对象，简称实例
  • 创建对象的过程称为是类的实例化
  • 我们平时所说的对象就是指实例对象（实例）
  • 每个实例对象，都有自己的内存空间，在自己的内存空间中保存自己的属性（实例属性）
• 类对象（类）
  • 类对象 就是 类，或者可以认为是 类名
  • 类对象是python解释器在执行代码的过程中创建的
  • 类对象的作用：①使用类对象创建实例 类名（），②类对象 也有自己的内存空间，可以保存一些属性值信息（类属性）
  • 在一个代码中，一个类，只有一份内存空间

（2）属性的划分

• 实例属性

  • 是实例对象具有的属性
  • 定义和使用
    • 在init方法中，使用self.属性 = 属性值定义
    • 在方法中使用self.属性名 来获取（调用）
  • 内存
    • 实例属性，在每个实例中，都存在一份
  • 使用时机
    • 基本上都是实例属性，即通过self去定义
    • 找多个对象，来判断这个值是不是都是一样的，如果都是一样的，同时变化，则一般定义为类属性，否则定义为实例属性

• 类属性

  • 是类对象具有的属性
  • 定义和使用
    • 在类内部，方法外部，直接定义的变量，就是类属性
    • 类对象.属性名 = 属性值 or 类名.属性名 = 属性值
    • 类对象.属性名 or 类名.属性名
  • 内存
    • 只有 类对象中存在一份

• 练习1

定义一个Dog类，定义一个类属性count，实例属性name，用来记录创建对类对象的个数，（即每创建一个对象，count的值就要加1）

class Dog:
    # 定义类属性
    count = 0

    # 定义实例属性，init方法中
    def __init__(self,name):
        self.name = name # 实例属性
        # 因为每创建一个对象，就会调用init方法，将个数加1的操作，写在init方法中
        Dog.count += 1

# 在类外部
# 打印输出目前创建几个对象
print(Dog.count)

# 创建对象
dog1 = Dog("小黄")
print(Dog.count)

dog2 = Dog("小花")
print(Dog.count)

dog3 = Dog  # 不是创建对象，个数不变
dog4 = dog1 # 不是创建对象，个数不变

# 补充，可以使用实例对象.类属性名 来获取类属性的值（原因，实例对象属性的查找顺序，先在实例属性中找，找到直接使用）
# 没有找到会去类属性中找，找到了可以使用，没有找到报错
print(dog1.count)

运行结果：
0
1
2
2

（3）方法的划分

方法，使用def关键字定义在类中的函数就是方法

• 实例方法（常用）——self

  • 定义

    • 在类中直接定义的方法就是实例方法

      class demo:

      ​ def func(self): # 参数一般写作self，表示的是实例对象

      ​ pass

  • 使用时机

    • 如果在方法中需要使用实例属性（即需要使用self），则这个方法必须定义为实例方法

  • 调用

    • 对象.方法名（） # 不需要给self传参

• 类方法（会用）——@classmethod

  • 定义

    • 在方法名字的上方书写 @classmethod装饰器（使用@classmethod装饰的方法）

      class demo:

      ​ @classmethod

      ​ def func(cls): # 参数一般写作cls，表示的是类对象（即类名）class

      ​ pass

  • 使用时机

    • 前提，方法中不需要使用实例属性（即self）
    • 用到了类属性，可以将这个方法定义为类方法（也可以定义为实例方法）

  • 调用

    • 通过类对象调用，类名.方法名（） # 也不需要给cls传参，python解释器自动传递
    • 通过实例对象调用，实例.方法名（） # 也不需要给cls传参，python解释器自动传递

• 静态方法（少用）——@staticmethod

  • 定义

    • 在方法名字的上方书写@staticmethod装饰器（使用@staticmethod装饰的方法）

      class demo:

      ​ @staticmethod

      ​ def func(): # 一般没有参数

      ​ pass

  • 使用时机

    • 前提，方法中不需要使用实例属性（即self）
    • 也不使用类属性，可以将这个方法定义为静态方法

  • 调用

    • 通过类对象调用，类名.方法名（）
    • 通过实例对象调用，实例.方法名（）

练习2

定义一个游戏类Game，包含玩家名字name

1、要求记录游戏的最高分top_score（类属性）

2、定义方法：show_help显示游戏的帮助信息，输出这是游戏的帮助信息

3、定义方法：show_top_score，打印输出游戏的最高分

4、定义方法：start_game，开始游戏，规则如下

​ （1）使用随机数获取本次游戏得分，范围（10-100）之间

​ （2）判断本次得分和最高分之间的关系

​ 如果本次得分比最高分高，修改最高分

​ 如果分数小于等于最高分，则不操作

​ （3）输出本次游戏得分

import random


class Game:
    top_score = 0  # 定义类属性

    def __init__(self, name):
        self.name = name  # 定义实例属性name

    @staticmethod
    def show_help():
        print("这是游戏的帮助信息")

    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

    @staticmethod
    def show_top_score():
        print(f"游戏的最高分为：{Game.top_score}")


player1 = Game("小明")
player1.start_game()
player1.show_top_score()
player1.start_game()
player1.show_top_score()
player1.show_help()

运行结果：
小明开始一局游戏
本次的游戏得分为：88
游戏的最高分为：88
小明开始一局游戏
本次的游戏得分为：74
游戏的最高分为：88
这是游戏的帮助信息

8、哈希算法

• 哈希（hash）：是一个算法，可以对数据产生一个唯一的值（指纹）
• is可以用来判断两个对象是不是同一个对象，即两个对象的引用是否相同
• a is b ==> id(a) == id(b)
• 面试题：is 和 == 的区别？
  • == 只判断数据值是否相同
  • is 判断引用是否相同

四、python文件操作

学习内容

• 文件操作
  • 普通文件操作
  • json文件操作（重点）
• 异常处理（程序代码运行时的报错）

1、文件的概念

（1）文件的概念和作用

• 计算机的文件，就是存储在某种长期储存的设备上的一段数据
• 长期存储设备包括：硬盘、U盘、移动硬盘、光盘
• 作用：将数据长期保存下来，在需要的时候使用

（2）文件的存储方式

• 在计算机中，文件是以二进制的方法保存在磁盘上的
• 计算机只认识二进制（0，1）
• 文件中存储的数据都是以二进制（0，1）的形式去存储的
• 可以根据文件中的二进制内容，能否使用记事本软件，将其转换为文字，将文件分为两种：文本文件和二进制文件
  • 文本文件
    • 能够使用记事本软件打开（能够使用技术本转换为文字）
    • txt，md，py，html，css，js，json
  • 二进制文件
    • 不能使用记事本软件打开的
    • exe，mp3，mp4，jpg，png

2、文件操作

（1）操作步骤

• 打开文件

  • 将文件从磁盘（硬盘）中读取到内存中
  • 语法
    • open（file，mode=‘r’，encoding=None）
    • 参数file：是要打开的文件，类型是字符串，文件的路径可以是相对路径（相当于当前代码文件所在的路径，./ …/），也可以是绝对路径（从根目录开始书写的路径），建议使用相对路径
    • 参数mode：默认参数（缺省参数），表示的是打开文件的方法
      • r：read只读打开
      • w：write只写打开
      • a：append追加打开，在文件的末尾写入内容
    • 参数encoding：编码方式，（文字和二进制如何进行转换的）
      • gbk：将一个汉字 转换为2个字节二进制
      • utf-8：常用，将一个汉字转换为3个字节的二进制
      • 返回值：返回的是文件对象，后续 对文件的操作，都需要这个对象

• 读或者写文件

  • 写文件：向文件中写入指定的内容

    • 前提：文件的打开方式是w或者a

    • 文件对象.write（“写入文件的内容”） # 返回值：写入文件的字符数，一般不关注

    • 文件不存在，会直接创建文件

    • 文件存在，会覆盖原文件（将原文件的内容清空）

    # 1、打开文件
    f = open("a.txt","w",encoding="utf-8")
    # 2、写文件
    f.write("day day up")
    # 3、关闭文件
    f.close()
    

  • 读文件：将文件中的内容读取出来

    • 前提：文件的打开方式需要是r
    • 文件对象.read（n）
      • 参数n表示读取多少个字符，一般不写，表示读取全部内容
      • 返回值：读取到的文件内容，类型，字符串

    # 1、打开文件
    # 2、读取文件
    # 3、关闭文件
    f = open("a.txt","r",encoding = 'utf-8')
    buf = f.read()
    print(buf)
    f.close()
    

• 关闭文件

  • 文件对象.close（）
  • 将文件占用的资源进行清理，同时会保存文件，文件关闭之后，这个文件对象就不能使用了