Python
语言的分类
计算机只认识 二进制（0和1）
编程语言是人和计算机沟通的语言
编程语言分类：编译型语言，解释型语言
目标：
1，学习掌握python的基本语法
2，在代码中遇到常见的错误，自己能够动手解决
Python只是一个编程语言，在工作中需要结合其他的工具使用
Python + selenium web 自动化（功能测试转换为代码）
Python + appium 移动（手机端APP）自动化
Python + requests 接口
Python 环境配置
Python 解释器（必须有）;将我们书写的Python代码转换为二进制，建议 版本>=3.6
pycharm(选装)：是Python中最好用的IDE（集成开发环境）之一，是用来书写代码运行代码，调试代码的...
vscod,idle,记事本...
python解释器的安装
1，双击安装包
2，选择安装方式（可以默认安装，可以自定义），不要忘记勾选添加path环境变量
path环境变量：将一个软件或者程序添加到path环境变量之后，就可以使用
终端（cmd）在任意路径下使用 这个软件（如果没有环境变量，只能在安装目录使用
print函数的简单使用
print("hello world")
print()是python中自带的函数，作用在控制台中输出 括号中的内容
后续看到这个函数就是输出打印 数据的，或者想要在控制台中显示某个内容，就是要使用print（）函数
print()主要学习阶段使用，便于我们确认结果的正确性
在实际工作的代码中，基本不会使用print，会使用 其他的内容代替（日志模块）
print()函数中是什么内容，就会显示什么内容，里边的文字信息 可以使用单引号，也可以使用双引号
注释
1，注释是对代码解释说明的文字，不会执行，可以增加代码的可读性
2，PYthon中的注释分为两种，单行注释和多行注释
单行注释
使用 井号空格进行注释（单独一个# 也可以）
快捷键 Ctrl /
多行注释
多行注释中的内容 可以换行书写
多行注释可以使用3对 双引号或者3对单引号，三对引号包括的内容就是注释的内容
三对引号的注释，一般写在文件的最开始部分，或者文档注释处（函数）
Python代码中三中波浪线和PEP8
红色
红色波浪线是代码的错误，必须处理，代码才能执行
注意：在后续课程中，某些代码没有写完，也会出现红色波浪线
灰色
灰色波浪线，不会影响代码的正常执行，基本上所有的灰色波浪线都是PEP8造成的
PEP8：是Python代码的书写规范，如果不按照这个规范书写，会给灰色波浪线提示，建议的书写按照PEP8的规范书写
1，可以书写代码的时候注意PEP8的代码规范
2，可以在书写完之后，使用快捷键Ctrl Alt l来按照PEP的规范自动格式化代码
绿色
绿色波浪线，不会影响代码的正常执行，在引号中，认为你书写的内容不是一个单词，就会给你绿色提示。
变量
变量
作用：是用来存储数据的（在程序代码中出现的数据，想要保存下的使用，就必须使用变量），如：测试数据，用户名密码，验证码
变量注意事项;变量必须先定义（保存数据）后使用（取出数据）
定义变量
变量名=数据值 #可以理解为 是将数据值保存到变量中
#比如
name=‘张三’#定义一个变量name，存储的数据值是 张三
使用变量
变量定义后，想要是使用变量中的数据，直接使用变量名即可
#使用变量获取数据，打印
print（name）
变量名的命名规范
起名字的规范，标识符的规则
1，必须由字母，数字和下划线组成，并且不能以数字开头
2，不能使用Python中的关键字作为变量名
关键字;python自带的已经使用的标识符，具有特殊的作用
3，区分大小写
4，建议性的命名
驼峰命名法
大驼峰：每个单词的首字母大小写NyName
小驼峰：第一个单词的首字母小写，其余单词的首字母大写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（变量））
输入
获取用户使用键盘录入的内容
使用的函数是input（）
变量 = input（'提示的信息'）
1，代码从上到下执行，遇到input函数之后，会暂停执行，等待用户的输入，r
如果不输入会一直等待
2，在输入的过程中，遇到回车，代表本次输入结束
3，会将你输入的内容 保存到等号左边的变量中，并且 变量的数据类型 一定会是str
类型转换
根据代码的需要，将一种数据类型转换另一种数据类型（将 input 输入得到的 数字转换为整型 语法： 变量 = 要转换为的类型（原数据） 1，数据原来是什么类型 2，你要转换为什么类型 注意点：数据类型转换，不会改变原来的数据类型，会生成一个新的数据类型
int（）将其他类型转换为int类型
1，可以将float类型的数字转换为整数
2，可以将整数类型的字符串转换为整型3 123
float（）将其他类型转换为浮点型
1，可以将int类型转换为浮点型float（3） --->3.0
2, 可以将数字类型的字符串（整数类型和小数类型）转换为浮点型
str（）将其他类型转换为字符串类型
任何类型都可以使用str（）将其转换为字符换，一般都是直接加上引号
输出
输出使用的函数是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， 身高是 height m')
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)
# %0ed n 需要换成具体的整数数字， 表示整数一共占几位
print('我的学号是%06d' % stu_num)
num = 90 # 考试的几个率
# 某次考试的及格率为 90%， 如果在 格式化中需要显示%， 在书写的使用 需要使用 两个 %% 才可以
print('某次考试的及格率为 %d%%' % num)
快捷键
添加引号或括号：可以直接选中要添加引号或者括号的内容，书写即可 撤销：Ctrl Z 删除一行：Ctrl x 复制粘贴一行： Ctrl d 快速 在代码下方，新建一行： shift 回车
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} m, 学号 {stu_num}, 本次考试的及格率为 {num}%')
运算符
/ 除 得到的是浮点类型
// 求商 被除数+除数=商...余数
% 求余
** 幂运算 2**3=2 * 2 *2
优先级：先算谁，在算谁（不确定优先级，就使用（）） （）>**>* / // % > + -
比较运算符
比较运算符得到都是bool 类型 < > == =< >=
今日内容
字符串格式化的补充
运算符
判断语句 if elif else
循环语句基础while
字符串格式的补充
字符串.format()可以在任意版本中使用
1,在需要使用 变量的地方使用{}占位
2，'{},{}...'.format（变量，变量，。。。）
print('我的名字 {}, 年龄是 {}, 身高是 {} m, 学号 {}, 本次考试的及格率为 {}%'.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
运算符优先级
不需要刻意去记忆优先级，因为可以使用（）改变优先级
判断
日常生活中说的 如果...否则...，这个就是判断，在程序代码中需要使用 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获取用户的年龄
age = input('请输入你的年龄：')
# 2，判断年龄是否满足18岁
if int(age) >= 18:
print('满18岁了，可以进入网吧为所欲为')
# 3，如果年龄大于等于（满足）18岁，输出'满18岁了，可以进入网吧为所欲为'
print('我和if没有关系不管怎么样都会执行')
练习
1，获取用户输入的用户名信息 2，如果用户名信息是admin，就在控制台输出出来
# 1，获取用户输入的用户名信息
name = input('请输入你的用户名：')
if name == 'admin':
print('欢迎admin')
# 2，如果用户名信息是admin，就在控制台输出出来
if else 结构
如果 条件成立 做什么事 否则（条件不成立） 做另一件事
基本语法
if判断条件 ： 书写条件成立（真），执行的代码 书写条件成立（真），执行的代码 else： 书写条件不成立（假），执行的代码 书写条件不成立（假），执行的代码 # 1， else是关键字，后边需要冒号 # 2， 冒号之后回车，同样需要缩进 # 3， 处于else代码下方缩进中的内容，属于else的代码块 # 4， if 和else的代码块，只会执行其中的一个 # 5， else需要结合if使用
代码案例
1.使用 input获取用户的年龄 2.判断年龄是否满足18岁 3.如果年龄大于等于（满足）18岁，输出'满18岁了，可以进入网吧为所欲为' 4.如果不满足，输出'不满18 岁，回去写作业'
# 1，使用input获取用户的年龄
age = input('请输入你的年龄：')
# 2，判断年龄是否满足18岁
if int(age) >= 18:
print('满18岁了，可以进入网吧为所欲为')
# 3，如果年龄大于等于（满足）18岁，输出'满18岁了，可以进入网吧为所欲为'
else:
print('不满足回去写作了')
练习
1，获取用户输入的用户名信息 2，如果用户名信息是admin，就在控制台输出出来 3，如果用户名信息不是admin，就在控制台输出“用户名错误”
if和逻辑运算符结合使用
案例一
1，获取用户输入的用户名和密码 2，判断用户名是admin并且密码是123456时，控制台输出：登录成功！ 3，否则在控制台输出：登录信息错误
# 1，获取用户输入的用户名信息
name = input('请输入用户信息：')
pwd = input('请输入密码：')
# 2，如果用户名信息是admin，就在控制台输出出来
if name == 'admin' and pwd == '123456':
print('登录成功！')
# 3，如果用户名信息不是admin，就在控制台输出“用户名错误”
else:
print('登录信息错误')
案例二
1,获取用户输入的用户名 2，判断用户名是admin时，在控制台输出；欢迎admin登录！ 3，用户名是test时，在控制台：欢迎test登录！ 4，如果是其他信息，在控制台输入：查无此人
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，只要有一个条件成立，后续的所有都不在判断
if 判断条件1：
执行代码
if 判断条件2：
执行代码
if 判断条件3：
执行的代码
# 多个 if 的结构， 每个 if 都会进行判断，之间没有关联系
案例
1，定义score变量记录考试分数 2，如果分数是大于等于90分应该显示优 3，如果分数是大于等于80分并且小于90分应该显示良 4，如果分数是大于等于70分并且小于80分应该显示中 5，如果分数是大于等于60分并且小于70分应该显示差 6，其他分数1显示不及格
# 1，定义score变量记录考试分数
score = int(input('请输入你的分数'))
# 2，如果分数是大于等于90分应该显示优
if score >= 90:
print('优')
# 3，如果分数是大于等于80分并且小于90分应该显示良
elif (score >=80) and score < 90:
print('良')
# 4，如果分数是大于等于70分并且小于80分应该显示中
elif score >= 70:
print('中')
# 5，如果分数是大于等于60分并且小于70分应该显示差
elif score >= 60:
print('差')
# 6，其他分数1显示不及格
else:
print('不及格')
多个if的实现
# 1，定义score变量记录考试分数
score = int(input('请输入你的分数'))
# 2，如果分数是大于等于90分应该显示优
if score >= 90:
print('优')
# 3，如果分数是大于等于80分并且小于90分应该显示良
if (score >=80) and score < 90:
print('良')
# 4，如果分数是大于等于70分并且小于80分应该显示中
if score >= 70 and score < 80:
print('中')
# 5，如果分数是大于等于60分并且小于70分应该显示差
if score >= 60 and score < 70:
print('差')
# 6，其他分数1显示不及格
if score < 60:
print('不及格')
Debug 调试代码
debug 在代码中出现问题错误（bug），可以使用debug来调试代码，查找错误， 我们使用debug主要用来 查看代码的执行步骤
1，打断点
在pycharm中，代码和行号之间进行点击，出现小红点即打断点，再次点击小红点会取消断点 断点的位置，一般开说会在代码的第一行（在程序运行的时候，想要在什么地方停下来） 注意点：可能会出现的bug（pycharm软件的问题：代码中只有一个断点的时候不能debug调试查看代码执行过程，解决方案，在代码其他任意地方多加一个断点
if 嵌套
if嵌套，是指在一个if(elif else)中嵌套另一个if, 使用场景：判断条件存在递进关系（只有第一个条件满足了，才会判断第二个条件）
-
语法
if判断条件1： 判断条件1成立，执行的代码 if判断条件2： 判断条件2成立，执行的代码 else： 判断条件2不成立，执行的代码 else： 判断条件1不成立，执行的代码
-
练习
假定某网站用户名固定'admin',密码固定为‘123456’，验证码 固定为‘8888’ 1,获取用户输入的用户名，密码和验证码 2，先判断验证码是否正确，如果正确打印输出验证码正确，在判断用户名和密码是否正确 3，如果验证码不正确，直接输出，验证码不正确，请重新输入
money = 1000
pwd = '123456'
password = input('请输入密码')
if password == pwd:
print('密码正确，登录成功')
get_money = int(input('请输入取款金额'))
if money >= get_money:
print('取款成功')
else:
print('取款失败')
else:
print('密码错误')
案例：猜拳游戏
案例的步骤： 1，自己出拳（石头（1）/剪刀（2）/布（3））input （player） 2.电脑随机出拳（待完成） （computer） 3,判断输赢 3,1 玩家胜利 3,1,1 player==1 and computer== 2 or 3,1,1 player==2 and computer== 3 or 3,1,1 player==3 and computer== 1 3.2 平局 player == computer 3.3 玩家输了 else
随机出拳
案例中需要电脑随机出拳，即随机出 1 2 3 在Python中想要随机获得整数数字可以使用如下方法 # 1，导入随机数工具包 import random # 2， 使用工具包中的工具产生指定范围内的数字 random.randint(a,b) # 产生[a,b]之间的随机整数，包含a b 的
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 == (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，设置循环的初始条件（计数器） 2，书写循环的判断条件 while 判断条件： # 3.需要重复执行的代码 # 4.改变循环的初始条件（计数器）
-
代码
# 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
# 1，自己出拳（石头（1）/剪刀（2）/布（3））input （player）
while True:
player = int(input('石头（1）/剪刀（2）/布（3）/退出（0）')) # 不要忘了数据转换
# 2.电脑随机出拳（待完成） （computer）
if player == 0:
break
computer = random.randint(1, 3)
# 3,判断输赢
# 3,1 玩家胜利
if player == (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+4+....+100
# 1.定义变量 保存求和的结果
num = 0
# 2 定义循环获取1-100 之间的数字并求和
# 2.1定义初始条件
i = 1
# 2.2书写循环的条件
while i <=100:
num +=i
i +=1
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:
num +=i
i +=2
print('数字的和为：',num)
方法二
1,找1-100之间
num = 0
i = 1
while i<= 100:
if i%2 == 0:
num +=i
i += 1
print('求和的结果是：',num)
今日内容
-
循环
-
for循环
-
break和countinue
-
-
字符串的操作
-
列表介绍
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) -
for做指定次数的循环
for 变量 in range(n): 重复执行的代码 # 1，rang()是Python 中的函数， 作用使用可以生成[0,n)之间的整数，不包含n的， 一个有n个数字，所有这个循环循环n次 # 2，想让 for 循环循环多少次，n 就写几 # 3，变量的值也是每次循环从[0,n)取出一个值，第一次取得是0最后一次取得是n-1 -
range()变形
# 需求：使用 for 循环获取 5 到 10 之间的数字 for 变量 in range(a,b): 重复的代码 # range(a,b) 作用是生成[a,b)之间的整数数字，不包含b
break 和 continue
break 和 countinue 是Python中的两个关键字，只能在循环中使用 break：终止循环， 即代码执行遇到break，循环不在执行，立即结束 countinue：跳过本次循环，即代码执行遇到break，本次循环剩下的代码不在执行，继续下一次循环
# 获取你输入的字符串
result = input('请输入一个字符串：')
# 遍历打印这个字符串
for i in result:
# 在遍历的时候，如果这个字符是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开始） 下标作用：可以使用下标获取字符串某个位置的字符 语法： 字符串[下标] # 获取指定位置的字符 0 1 2 3 4 5 6 正数下标 a b c d e f g 字符串 -7 -6 -5 -4 -3 -2 -1 负数下标
str1 = 'qwerty' # 1.打印字符串中最开始位置的字符 print(str1[0]) # 2,打印最后一个位置的数据 print(str1[-1]) # 3,打印倒数第二个位置的字符 print(str1[-2]) # 打印下标为2的数据 print(str1[2]) # 获取字符串中字符的个数（获取字符串的长度） # len(字符串） # length（长度） num = len(str1) print(num) # 长度-1的下标位置是最后一个字符 print(str1[num-1]) # 最后一个字符，倒数第一个 print(str1[len(str1)-1])
切片
切片：可以获取字符串中多个字符（多个字符的下标是有规律的，等差数列） 语法： 字符串[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]) # 1.1 如果步长是1 可以不写，最后一个冒号也不写 print(str1[0:3]) # 1.2 如果开始位置为0 ，可以不写，但是冒号必须有 print(str1[:3]) # 2. 获取efg字符 print(str1[4:7]) print(str1[-3:7]) # 2.1 如果最后一个字符也要取，可以不写，但是冒号必须有 print(str1[4:]) # 2.2 如果开始和解释都不写，获取全部内容，但是冒号必须有 print(str1[:]) # 3. 获取 aceg # 0 2 4 6 ，所有步长为 2 print(str1[0:7:2]) print(str1[::2]) # 4.特殊应用，步长为负数，开始和结束不写，意思全变，一般不用管，只有一种使用场景 # 反转（逆置）字符串 字符串[::-1] print(str1[: :-1])
字符串的查找方法 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 intheima and python"
# 在字符串中查找 and
num = str1.find('and')
print(num)
# 在字符串中查找 第二个 and 出现的下标，从第一次出现的后一位开始找
num1 = str1.find('and',num+1)
print(num1)
字符串的替换方法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)
print('str2', str2)
# 2. 将str1中第一个 good 改为 GOOD
str3 = str1.replace('good','GOOD',1)
print('str3:', str3)
# 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)
字符串的拆分 split
字符串.split（sep, max_split) # 将字符串按照 sep进行分割（拆分） - sep,字符串按照什么进行拆分，默认是空白字符（空格，换行\n， tab键\t) - max_split,分割次数，一般不写，全部分割 - 返回：将一个字符串拆分为多个，存到列表中 - 注意: 如果sep 不写，想要指定分割次数 则需要按照如下方式使用 字符串.split(max_split=n) # n 是次数
str1 = "hello world and itcast and itheima and python"
# 1. 将str1 按照 and 字符进行拆分
result1 = str1.split('and')
print(result1)
# 2. 将 str1 按照 and字符进行拆分，拆分一次
result2 = str1.split('and',1)
print(result2)
# 3. 按照空白字符进行切割
result3 = str1.split()
print(result3)
# 4. 按照空白字符进行切割，拆分一次
result4 = str1.split(maxsplit=1)
print(result4)
字符串的链接 join
字符串.join(列表) # 括号中的内容主要是列表，可以是其他容器 # 作用：将字符串插入列表中每相邻的两个数据之间，组成一个新的字符串 -列表中的数据使用 逗号隔开的 -注意点： 列表的数据必须都是字符串，否则会报错
list1 = ['good', 'good','study'] # 1.将列表中的字符串使用空格连接起来 str1 = ' '.join(list1) print(str1) # 2. 将 列表中的字符串使用and连接起来 str2 = ' and '.join(list1) print(str2)
列表
type（）是把数据类型打印出来
列表 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_list = [1, '小明', 3.14, False]
print(my_list)
列表支持下标和切片
列表支持下标和切片操作，使用方法和字符串中的使用方法一致 区别：列表的切片得到的是列表
list1 = ['小明', 18, 1.71, True] # 获取第一个数据，名字 print(list1[0]) # 获取最后一个数据 print(list1[-1]) # 第一个第二个数据 print(list1[0:2]) # ['小明', 18] # 列表页支持 len()求长度的，求数据元素个数 print(len(list1))
查找列表中数据下标的方法
在字符串中使用的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)
# 找数据 4 出现的下标
# num =my_list.index(4) # 代码会报错
if 4 in my_list:
num1 = my_list.index(4)
print(num1)
else:
print('无此数字')
# my_list.count(4) 统计 数据4 出现的次数
if my_list.count(4)>0:
num1 = my_list.index(4)
print(num1)
else:
print('无此数字')
添加数据的方法
-
尾部添加（最常用）
列表.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.定义新的列表list1
list1 = ['吴吴','婷婷']
# 将list中数据逐个添加到my_list中
my_list.extend(list1)
print(my_list) # ['平平', '菟菟', '安安', '吴吴', '婷婷']
# 将list作为一个整体添加到my_list
my_list.append(list1)
print(my_list) # ['平平', '菟菟', '安安', '吴吴', '婷婷', ['吴吴', '婷婷']]
今日内容
-
列表
-
元组
-
字典
-
函数的基本概念
定义
变量 =[数据，数据，...]
添加
列表.append(数据)
查询
列表.index(数据) 列表.count(数据)
修改操作
想要修改列中的指定下标位置的数据，使用的语法是： 列表[下标] = 数据 # 字符串中字符不能使用下标修改
# 定义列表 my_list = [1, 3, 5, 7] # 想要将下标 1 的数据修改为 22 my_list[1] = 22 print(my_list) # 修改最后一个位置的数据， 改为 'hello' my_list[-1] = 'hello' print(my_list) # 不存在的小标就会报错
删除操作
在列表中删除中间的数据，那么后面的数据会向前移动
-
根据下标删除
列表.pop(下标) # 删除指定下标位置对于的数据 1.下标不写，默认删除最后一个数据（常用） 2.书写存在的下标，删除对于下标位置的数据 返回：返回的删除的数据
-
根据数据值删除
列表.remove（数据值） # 根据数据值删除 返回：None 注意：如果要删除的数据不存在，会报错
-
清空数据（一般不用）
列表.clear()
my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
# 1.删除最后一个位置的数据
num = my_list.pop()
print(my_list)
print('删除的数据为：',num) # [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.clear()
print(my_list) # []
列表的反转（倒置）
字符串中 反转倒置： 字符串[::-1] 列表中 反转和倒置： 1， 列表[::-1] # 使用切片的方法，会得到一个新列表，源列表不会发生改变 2， 列表.reverse() # 直接修改原列表，返回 None
my_list = [1, 3, 5, 7 , 8, 9]
# 使用切片的方法反转，会得到一个新列表
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[] = 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', '自动化测试', '男']]
元组
元组：tuple, 元组的特点和列表非常相似 1. 元组中可以存放任意类型的数据 2. 元组中可以存放任意多个数据 区别： 1.元组中的数据内容不能改变，列表中的可以改变的 2.元组使用（），列表 使用[] 应用：在函数的传参或者返回值中使用，保证数据不会被修改
定义
1. 使用类实例化的方式 2. 直接使用（）方式
常用方法
由于元组中的数据不能直接修改，所有只能查看的方法 1，在元组中也可以使用 下标和切片获取数据 2，在元组中存在 index 方法 3，在元组中存在 count 方法 4，在元组中可以使用 in 操作 以上方法的使用 和列表中一样的
# 1， 类实例化的方式
# 1.1 定义空元组（不会使用的）
mu_tuple1 = tuple()
print(type(mu_tuple1),mu_tuple1) # <class 'tuple'> ()
# 1.2 类型转换
# 可以将列表转换为元组， 只需要将[],变为（）， 同时 可以将元组转换列表， 将（） 变为[]
mu_tuple2 = tuple([1, 2, 3])
print(mu_tuple2) # (1, 2, 3)
# 转换字符串， 和列表中一样， 只是将列表[]变为（）
mu_tuple3 = tuple('hello')
print(mu_tuple3) # ('h', 'e', 'l', 'l', 'o')
# 2.直接使用（） 定义
mu_tuple4 = (1, "小王", 3.14, False)
print(mu_tuple4)
# 3.特殊点，定义只有一个数据的元组时，数据后边必须有一个逗号
mu_tuple5 = (1,)
print(mu_tuple5) # (1,)
print(mu_tuple4[1]) # 小王
字典
1.字典dict, 字典中的数据是由键（key)值（value)对组成的（键表示数据的名字，值就是具体的数据）
2.在字典中一组键值绝对是一个数据， 多个键值对之间使用 逗号隔开
变量 = {key: value, key: value,...}
3.一个字典中的键是唯一的，不能重复的，值可以是任意数据
4.字典中的键 一般都是 字符串，可以是数字， 不能是列表
定义
# 1. 使用 类实例化的方法
my_dict = dict()
print(type(my_dict),my_dict)
# dict() 不能转列表和元组，字符串
# 2. 直接使用{}定义
# 2.1 空字典
my_dict1 = {}
print(type(my_dict1),my_dict1) # <class 'dict'> {}
# 2.2 非空字典，"name": "小明", "age": 18, "height": 1.71, "is_men": True,"like": ["抽烟", "喝酒", "烫头"]}
my_dict2 ={"name": "小明", "age": 18, "height": 1.71, "is_men": True,"like": ["抽烟", "喝酒", "烫头"]}
print(my_dict2)
print(len(my_dict2))
增加和修改操作
语法： 字典[键] = 数据值 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 字典[键] 字典.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[键]
字典[键] 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.get['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)
容器部分 总结
# 1. 字符串， 列表， 元组 支持加法运算 str1 = 'hello' + 'world' # 'hello world' list1 = [1, 2] + [3, 4] # [1, 2, 3, 4] tuple1 = (1, 2) + (3, 4) # (1, 2, 3, 4) # 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 关键字在容器中都可以使用， 注意， 在字典中判断的是字典的键是否存在
函数
print() input()---> str type()
概念
函数，就是把 具有独立功能的代码块 组成为一个小模块， 在需要的时候 调用 函数，通俗理解， 将多行代码写在一块，起个名字， 在需要这多行代码的时候 可以直接使用这个名字来代替 函数好处：减少代码的冗余（重复的代码不用多写），提高程序的编写效率
def login():
print('1.输入用户名')
print('2.输入密码')
print('3.输入验证码')
print('4.点击登录')
login()
print('-'*30)
login()
函数定义
1, 将多行代码放在一块，起名字的过程，称为函数定义 2，函数必须先定义后调用
-
语法
def 函数名（）： 函数中的代码 函数中的代码 # 1. def 是关键字， 用来定义函数的 define的缩写 # 2. 函数名需要遵守标识符的规则 # 3. 处于 def 缩进的代码，称为函数体 # 4. 函数定义的时候，函数体中的代码不会执行， 在调用的时候才会执行 -
函数定义小技巧
在前期，书写不熟练的时候 1. 可以先不管函数，先把功能写出来 2. 给多行代码起名字 3. 选中多行代码， 使用 tab 键进行缩进
函数的调用
1.使用多行代码的时候，被称为函数调用
-
语法
函数（） # 1.函数调用的时候会执行函数体中代码 # 2.函数调用的代码，要写在 函数体外边
def say_hello(): print('hello 1') print('hello 2') print('hello 3') # 调用 say_hello() say_hello()
文档注释
文档注释的本质，还是注释，只不过书写的位置和作用比较特殊 1，书写位置，在函数名的下方使用 三对双引号进行的注释 2, 作用：告诉别人这个函数如何使用的， 干什么的 3. 查看， 在调用的时候， 将光标放到函数名上，使用快捷键 ctrl q(Windows) Mac (ctrl j) ctrl(cmd) B 转到函数声明中查看（按住Ctrl（cmd）鼠标左键点击）
函数的嵌套调用
在一个函数定义中调用另一个函数 1. 函数定义不会执行函数体中的代码 2. 函数调用会执行函数体中的代码 3. 函数体中代码执行结束会回到函数被调用的地方继续向下执行
def func1():
print(1)
print('func1')
print(2)
def fun2():
print(3)
func1()
print(4)
print(5)
fun2()
print(6)
今日内容
-
补充：列表去重
-
函数基本知识（返回值（返回），参数）
-
变量进阶（理解，Python底层原理，面试题）
-
函数进阶（返回值，参数）
列表去重
列表去重：列表中存在多个数据，需求， 去除列表中重复的数据， 方式1. 思路 遍历列表中的数据判断在新列表中说否存在，如果存在，不管，如果不存在放 入新的列表中 遍历： for 循环实现 判断是否存在： 可以 使用 in 存在数据;append() 方法 2: 在 Python 中国还有一种数据类型（容器），称为是 集合（set） 特点： 集合中不能有重复的数据（如果有重复的数据自动去重） 可以使用集合的特点对列表去重 1， 使用 set（）类型转换将列表转换为 集合类型 2， 在使用 list（） 类型转换集合 转换为列表 缺点： 不能保证数据在原列表中出现的顺序（一般来说，也不考虑这件事）
my_list = [1,2,3,4,1,2,3,4]
set(my_list)
{1,2,3,4}
list(set(my_list))
[1,2,3]
my_list = [3, 2, 4, 1, 2, 3, 3, 3 , 4, 1]
# print(list(set(my_list)))
#
# new_list = list(set(my_list))
# print(new_list)
new_list = []
for i in my_list:
# 判断新列表中是否存在 i
if i in new_list:
pass # continue
else:
new_list.append(i)
print(new_list)
for i in my_list:
if i not in new_list:
new_list.append(i)
函数基础
函数的参数
# 1.定义一个函数， my_sum ,对两个数字进行求和计算
def my_sum():
num1 = 10
num2 = 20
num = num1 + num2
print(num)
my_sum()
# 函数存在的问题，这个函数只能对 10 和 20 进行求和， 不能对任意的函数进行求和计算
# 问题的解决; 想要解决这个问题，可以使用函数参数来解决
函数参数： 在函数定义的时候，使用变量代替具体的数值（进行占位），在函数调用的时候传参具体的数据值
好处：让函数更加通用，能够解决以类问题，而不是单纯的一个
# 定义一个函数， my_sum ,对两个数字进行求和计算
# num1 和 num2 是函数定义时候的参数，起到占位的作用，没有具体的数据值，称为 形式参数， 简称 形参
def my_sum(num1, num2):
num = num1 + num2 # 在什么时候定义参数，函数中使用的数据会变化的时候，就可以定义为参数
print(num)
my_sum(1, 2) # 在函数调用的时候， 括号中的数据会传递给形参，是具体的数据值，称为实际参数，简称 实参
# 目前书写的函数，在定义的时候如果有形参，那么在调用的时候，必须传递实参值，个数要对应，否则会报错
#中间空两行 PEP8 建议在函数的定义前后 有两个空行，否则灰色波浪线提示
Ctrl alt L
函数的返回值
函数的返回值，可以理解为是 函数整体执行的结果是什么 什么上班需要书写返回值：函数中得到的数据在后续的代码中还要使用，这个时候就应该将这个数据 作为返回值返回，以供后续使用 print（） --->None input() --->键盘输入的内容 type() --->类型 len() ---数据的长度（元素的个数） 在函数中想要将一个数据作为返回值 返回， 需要使用return 关键字（只能在函数中使用） 作用： 1，将数据值作为返回值返回 2，函数代码执行遇到return，会结束函数的执行
def my_sum(a, b):
num = a + b
# print(num) # 代码中没有返回值，只有 print,这个结果只能在函数中用一次，不能后续使用
# 我们想要将这个求和的结果 在后续的代码中使用，需要使用 return 将求和的结果进行返回
return num #将这个结果返回到调用的地方法
# return 之后的代码会执行吗
print('我是 return 之后的代码， 我会执行吗 ---》不会执行')
# 1. 函数中没有 print,只有return，想要查看结果，需要在调用的时候使用print
print(my_sum(1, 2))
# 2,想要将函数中返回的结果，在后续代码中使用，即需要将这个数据保存下来，需要使用变量来接收（保存） 函数的返回值（执行结果）
# 变量 = 函数（）
result = my_sum(10, 20) #将求和的结果保存到变量 result 中， 可以在后续代码中使用
print('使用：1，直接打印：', result)
print('使用： 2,对数字 加 10：', result + 10)
-
返回值的说明
def 函数名（）： # 返回值 None pass # 代码中没有 return def 函数名()： return # return 后边没有数据，返回值 None def 函数名（）： return xx # 返回值是xx
变量进阶[理解 知道]
在这一部分 我们了解 Python 底层是如何处理数据的
变量的引用
1. 在定义变量的时候 变量 = 数据值， Python 解释器会在内存中开辟两块空间 2. 变量和数据都有自己的空间 3. 日常简单理解， 将数据保存到变量的内存中， 本质是 将 数据的地址保存到变量对应的内存中 4. 变量中存储数据地址的行为 就是引用 （变量引用了数据的地址，简单说就是变量中存储数据），存储的地址称为 引用地址 5. 可以使用id() 来获取变量中的引用地址（即数据的地址），如果两个变量的 ID（） 获取的引用地址一样，即代表着， 两个变量引用了同一个数据，是同一个数据 6. 只有 赋值运算符=， 可以改变变量的引用（等号左边数据的引用） 7. python 中数据的传递，都是传递的引用
可变类型和不可变类型
数据类型; Int float bool str list tuple dict set 可变不可变是指：数据所在的内存是否允许修改，允许修改就是可变类型，不允许修改就是不可变类型（不使用=，变量引用的数据中的内容是否会变化，会变化是可变的，不会变化是不可变的） 可变类型： 列表 list， 字典 dict，集合 set 列表.append() 字典.pop(键) 不可变类型：int float bool str tuple
my_list = [1, 2, 3]
my_list1 = [1, 2, 3]
print('my_list:', id(my_list), id(my_list[1]))
print('my_list:', id(my_list1))
my_list[1] = 10
print(my_list)
print('my_list :', id(my_list), id(my_list[1]))
my_tuple =(1, 2,[3, 4]) # 元组中存储的是 1 的地址，2 的地址， 和 列表地址
# 元组中的数据不能改变，是值 这个三个地址不能改变
print(my_tuple, id(my_tuple[-1]))
my_tuple[-1][0] = 10 # 修改的是列表中下标为 0 的位置的引用地址，列表的地址没变，元组中的内容没有变化
print(my_tuple, id(my_tuple[-1]))
题目4 交换两个变量的值
a = 10 b = 20 # 方法一： 常规方法 引入第三个变量 # c = a # a = b # b = c # print(a, b) # 方法二： 不使用第三个变量， 使用数学中的方法 # a = a + b # b = a - b # a = a - b # print(a, b) # 方法三，重点掌握，Python 特有 a, b = b, a print(a, b)
组包和拆包
组包（pack）：将多个数据值使用逗号连接，组成元组 拆包（UNpack）：将容器中的数据值使用多个变量分别保存的过程，注意：变量的个数和容器中数据的个数要保持一致 赋值运算符，都是先执行等号右边的代码，执行的结果，保持到等号左边的变量中
# 组包 c =b, a #组包 print(type(c), c) # <class 'tuple'> (20, 10 # 拆包 a, b = c print(a, b) x, y, z = [1, 2, 3] print(x, y, z)
局部变量和全局变量
变量：根据变量的定义位置， 可以将变量分为局部变量和全局变量 特点： 1， 局部变量只能在当前函数内部使用，不能在其他函数和函数外部使用 2， 在不同函数中，可以定义名字相同的局部变量， 两者之间没有影响 3， 生存周期（生命周期，作用范围）--> 在那 能用 在函数被调用的时候，局部变量被创建，函数调用结束，局部变量的值被销毁（删除），不能使用 所有函数中的局部变量的值，如果想要在函数外部使用，需要使用return 关键字，将这个值进行返回
def func1():
num = 10 # num 就是局部变量
print(f"func1 函数中 {num}")
def fun2():
num = 100 # 可以在不同函数中定义名字相同的局部变量，没有影响
print("func1 函数中 {num}")
fun2()
func1()
全局变量
局部变量： 在函数内部（函数的缩进中）定义的变量，称为是局部变量 特点： 1. 局部变量只能在当前函数内部使用，不能在其他函数和函数外部使用 2. 在不同函数中，可以定义名字相同的局部变量，两者之间没有影响 3.生命周期（生命周期， 作用范围）--->在那 能用 在函数被调用的时候，局部变量被创建， 函数调用结束， 局部变量的值被销毁（删除）， 不能使用 所以函数中的局部变量的值，如果想要在函数外部使用，需要使用 return 关键字，将这个值进行返回
g_num = 10 # 全局变量
def func1():
print(f'func1 中 {g_num}') # 在函数中可以读取全局变量的值
def func2():
g_num = 20 # 定义局部变量， 不会影响全局变量
print(f'func2 中 {g_num}')
def func3():
global g_num # 这个函数中使用的 g_num 都是全局变量
g_num = 30 # 修改了全局变量
print(f'func3 中 {g_num}')
func1() # 10
func2() # 20
func1() # 10
func3() # 30
func1() # 30
print(g_num)
函数进阶
返回值-函数返回多个数据值
函数中想要返回一个数据值， 使用return 关键字 将 多个数据值组成容器进行返回，一般是元组（组包）
def calc(a, b):
num = a + b
num1 = a - b
return num, num1
# 书写一
result = calc(10, 5)
print(result, result[0], result[1])
# 书写二， 直接拆包
x, y = calc(20, 10)
print(x, y)
函数参数
-
位置传参：
在函数调用的时候，按照形参的顺序，将实参值传递给形参
-
关键字传参
在函数调用的时候，指定数据值给到那个形参
-
混合使用
1，关键字传参必须写在位置传参的后面 2，不要给一个形参传递多个数据值
def func(a, b, c): print(f'a: {a}, b: {b}, c: {c}') # 位置传参 func(1, 2, 3) # 关键字传参 func(a=2, b=2, c=3) # 混合使用 func(1, 3, c=5)缺省参数
缺省参数，默认参数 列表.pop() # 不写参数，删除最后一个 列表.sort(reverse=True) 1.定义方式 在函数定义的时候，给形参一个默认的数据值，这个形参就变为缺省参数， 注意， 缺省参数的书写 要放在普通参数的后边 2. 特点(好处) 缺省参数，在函数调用的时候，可以传递参值，也可以不传递实参值 如果传参，使用的就是传参的实参值， 如果不传参，使用的就是默认值
def show_info(name, sex'保密')： print(name, sex) show_info('小王') show_info('小王', '男')
多值参数[可变参数/不定长参数]
print(1) print(1, 2) print(1, 2, 3) print(1, 2, 3, 4)
当我们在书写函数的时候， 不确定参数的具体个数时， 可以使用 不定长参数
-
不定长位置参数（不定长元组参数）
1.书写，在普通参数的前边，加上一个 *， 这个参数就变为不定长位置参数 2.特点，这个形参可以接受任意多个 位置传参的数据 3.数据类型，形参的类型是 元组 4.注意.不定长位置参数 要写在普通的参数的后面 5.一般书写，不定长位置参数的名字为 args, 即（*args） # arguments
-
不定长关键字参数（不定长字典参数）
1.书写，在普通参数的前边，加上 两个*， 这个参数就变为不定长关键字参数 2.特点，这个形参可以接受任意多个 关键字传参的数据 3.数据类型，形参的类型是 字典 4，注意， 不定长关键字参数，要写在所有参数的最后边 4.一般书写，不定长关键字参数的名字为kwargs,即（**kwargs), keyword arguments
-
完整的参数顺序
def 函数名（普通函数， *args, 缺省参数， **kwargs): pass # 一般在使用的时候， 使用 1-2中， 按照这个顺序挑选书写即可def func(*args, **kwargs): print(type(args), args) print(type(kwargs), kwargs) print('--'* 30) func() func(1, 2, 3) # 位置传参，数据都给args func(a=1, b=2, c=3) # 关键字传参， 数据都给 kwargs func(1, 2, 3, a=4, b=5, c=6)print解析
# print() # sep=' ', 多个位置参数之间的间隔 # end='\n' 每一个 print函数结束， 都会打印的内容 结束符 print(1, end='') print(2, end='') print(3) print(1, 2, 3, 4, 5, 6, sep='_') print(1, 2, 3, 4, 5, 6, sep='_*_')