python基础大全【13万字】
Day01
- Python基础语法：标识符，关键字，变量，判断循环
- 容器类型（数据类型中的高级类型）
- 函数
- 文件处理
- 面向对象
- 包和模块
- 异常处理
1、Python概述
- 创始人：吉多·范罗苏姆 龟叔
- 为什么要学习Python：大势所趋，简单易学，使用范围广
- 我们本次学习使用Python3.x版本
- Python在大数据生态中应用非常广泛
2、Python解释器和pycharmIDE工具
-
Python解释器是将Python代码解释为机器语言（二进制文件）的一种工具
-
Python代码必须经过解释器解释，计算机才能够去执行命令
-
常见的解释器版本：
- CPython： 官方版本，稳定，持续更新
- Ipython：可交互，在CPython基础上进行了升级
- pypy：使用Python编写的解释器
- JPython：使用java编写的解释器，可以将Python便以为字节码文件，在java平台上运行
-
pycharm IDE：
- 语法高亮
- 工程管理
- 代码提示
- 错误检查
-
pychram基本设置
- 主题：file — settings—在搜索栏搜索 theme ----修改主题
- 字体：file — settings – 在搜索栏输入font ---- 修改字体
- 修改解释器：file — project：项目名称— Python interpreter --修改解释器
- 工程管理：file – open —选择工程
- this windows ： 在当前窗口打开
- new windows：在新窗口打开
- attach ：合并项目窗口
- 关闭工程： file – close project
3、Python中的注释
- 单行注释： # 注释的内容
- 可以在语句末尾注释
- 快捷键：ctrl+ /
- 多行注释：三对单引号，或者三对双引号
- 可以在注释内部换行
"""
我是文件开头的多行注释,颜色不一样,
但是功能没有区别
"""
# 注释:有提示作用,注释不参与代码执行,但是可以增加代码的可读性
# 语法规范:单行注释#号与注释内容之间存在一个空格, 如果在语句末尾注释,语句和#之间要有两个空格
# 单行注释
print('hello world')
# 我是一个优秀的单行注释
print('hello bigdata')
print('hello python') # 打印Python,可以添加在语句的末尾
print('hello itcast')
# 单行注释快捷键:ctrl + /
# 如果想要快捷注释多行内容,选中多行信息,使用ctrl+ /进行对多行代码依次进行单行注释
# print('hello itcast')
# print('hello itcast')
# print('hello itcast')
# 多行注释
'''
我是一个多行注释
在多行注释内,可以随意换行
换行后可以正常书写
'''
"""
在Python中单双引号不敏感,但要成对出现
双引号也可以构建多行注释
"""
# ???多行注释可以用在语句末尾么? 不能
# print('hello python') """ abc """
# 在文件开始位置,多行注释和文件中间的多行注释颜色不一样,效果一样么? 一样
4、变量
- 变量特性：
- 容器
- 临时
- 可变
- 变量定义的格式：
- 变量名 = 值
- 标识符的命名规则：
- 只能是数字字母下划线组成
- 首字母不能是数字
- 严格区分大小写
- 不能是关键字
- 在Python中定义变量必须赋值，否则报错
# 牛奶和可乐交换的案例
'''
交换方式:
获取一个空杯子
将牛奶倒入空杯子
将可乐倒入原牛奶现空杯子的杯子中.....
'''
'''
换一个方式进行描述:
# 开始
A杯子: 牛奶
B杯子: 可乐
C杯子: 空
# 过程
A >> C
B >> A
C >> B
# 结尾
A杯子: 可乐
B杯子: 牛奶
C杯子: 空
'''
a = '牛奶'
b = '可乐'
c = '空'
print(a, b)
c = a
a = b
b = c
print(a, b)
# 关键字: 系统定义的具有一定功能或者含义的字符组合.(关键字不要背诵,遇到了就记下来,如果记不下来,关键字有自己的高亮效果)
# 标识符: 程序员自己定义的具有一定功能或者含义的字符组合.
# 标识符的命名规则:
# 1/只能由数字,字母,下划线组成
# 2/首字母不能是数字
# 3/不能是关键字
# 4/严格区分大小写
# 什么地方使用了标识符:文件名,变量名, 函数名, 类型名 (只要是让程序员起名字,都是标识符)
# 文件名可以不遵循标识符的命名规则,但是在服务器中无法使用,不能当做模块进行导入,很多服务器工具或组件不支持非标识符文件.
'''
Python)abc 不能
_abc 可以
anc______ 可以
123abc _____ 不可以
and 不可以
ABC 可以
anc 可以
'''
# 在windows中文件名定义时,不严格区分大小写
# 程序员不可能定义变量出错
# aaa
# 在Python中创建变量必须赋值,否则将会报错
5、标识符的命名规范 ★
- 见名知意
- 类名使用大驼峰命名法
- ClassName
- 变量名，函数名，包名，模块名使用下划线命名法
- class_name
# 要见名知意
name = '小明'
age = 18
# abc = '小明'
# 见名知意不要写缩写,也不要写首字母,尤其是不要写拼音首字母,更不要写拼音全拼
# 命名法
# 大驼峰命名法:
# 首字母大写,如果由多个单词组成,所有单词的首字母大写
# 在Python中类名的书写使用大驼峰命名法
ClassName = 'Python+大数据54期'
# 小驼峰命名法:
# 首字母小写,如果由多个单词组成,第一个单词首字母小写,其余单词首字母大写
className = 'Python+大数据54期'
# 下划线命名法:
# 在Python中 变量,函数,文件名称(包和模块名称)使用下划线命名法
# 所有字母小写,多个单词中间用下划线连接
class_name = 'Python+大数据54期'
# 不满足命名规范一样不会报错,但是不利于协作开发
6、变量的使用
- 定义：变量名 = 值
- 调用：函数（变量名） 或者 使用变量名进行运算 变量名1 + 变量名2
- 变量必须先定义后调用
# 使用变量直接调用变量名即可,我们使用的是变量名,参与执行和运算的是变量中的数据(值)
name = 'xiaoming' # 定义
print(name) # 调用
a = 1 # 定义
b = 1 # 定义
print(a + b) # 调用
# 所有的变量,要先定义后调用
# 程序运行起来后,从上到下依次执行代码,解释一行运行一行,在打印方法被执行时,还不知道price已经被定义,会报错
# print(price)
# price = 15
7、Python中的数据类型 ★
- int 整型
- float 浮点型
- bool 布尔型
- str 字符型 字符串
- list 列表
- tuple 元组
- set 集合
- dict 字典
- 查看数据类型使用的函数是 type（）
# 数据类型查看的函数 type(数据/变量名)
# 基础数据类型:int float bool
# 容器类型: str list tuple set dict
# 整型
int1 = 12
print(type(int1)) # <class 'int'>
# 浮点型
float1 = 12.1
print(type(float1)) # <class 'float'>
# 布尔型 (True/False)
bool1 = True
print(type(bool1)) # <class 'bool'>
# 字符串型
str1 = 'hello Python'
print(type(str1)) # <class 'str'>
# 元组
tuple1 = (1, 2, 3, 4)
print(type(tuple1)) # <class 'tuple'>
# 列表
list1 = [1, 2, 3, 4]
print(type(list1)) # <class 'list'>
# 集合
set1 = {1, 2, 3, 4}
print(type(set1)) # <class 'set'>
# 字典
dict1 = {'name': 'xiaoming', 'age': 18}
print(type(dict1)) # <class 'dict'>
# 代码格式化的快捷键:ctrl + alt + L
# 练习:
a = 12
# a是什么数据类型? int
a = 'str'
# a是什么数据类型? str
a = '12'
# a是什么数据类型? str
a = True
# a是什么数据类型? bool
a = 13.4
# a是什么数据类型? float
# 通过上述演示,我们发现在Python程序执行过程中,可以随意改变变量的数据类型
8、Python中的bug和调试
- 常见的bug类型：
# 常见的bug
NameError: name 'a' is not defined (一般只变量名错误)
# 如果遇到此类错误,查看变量名是否被定义或者变量名是否书写错误
# print(a)
ZeroDivisionError: division by zero (零不能做分母)
# a = 10
# print(a / 0)
IndentationError: unexpected indent (缩进错误)
# 修改缩进,或者去调整函数关系
# a = 5
# b = 10
SyntaxError: unexpected EOF while parsing (语法错误)
# 找到报错位置,查看语法是否存在问题,最好的办法就是将其进行格式化
# print(123
TypeError: can only concatenate str (not "int") to str (数据类型错误)
# a = '123'
# print(a + 12)
Process finished with exit code 0 程序结束后 正常退出 code 为 0
# print('hello world')
Process finished with exit code 1 程序异常结束 code 为 1
# print(a)
- bug调试工具的使用
- 打断点：在行号后边点击出现小红点
- 右键debug进入调试模式，代码执行暂停到断点位置代码执行之前
- debugger ：查看参数及变量在执行过程中的变化情况
- console：查看控制台输出内容
- step over：单步执行代码
- resume ：执行到下一次断点位置或者程序结束
- stop：让程序终止
9、字符串的格式化及输出 ★
- 格式化是字符串所具有的功能，与print无关，哪怕不进行输出，也可以进行字符串的格式化
# 字符串格式化 :格式化是字符串所具有的功能
# print 输出: print函数只能将传入的内容显示到控制台中,与格式化没有任何关系
# 需求:想让小明的年龄,跟着age变量的变化,不断发生变化,那么我们应该怎么做?
age = 16
print('小明14岁')
# 字符串的格式化
# 格式化输出,到底是print 的功能还是字符串的功能呢?
print('小明 %d 岁' % age)
# 探索
str1 = '小明 %d 岁' % age
print(str1)
- 格式：
- 单占位符：‘要书写的内容，占位符’ % 变量名
- 多占位符: ‘要书写的内容，占位符1， 占位符’ % （变量1， 变量2，。。。。）
- %之前的占位符数量要和%之后的变量数量相匹配，一一对应否则会报错
# 格式: '字符串,占位符' % 变量
# 在上述格式中,格式化完成后,会将占位符位置填充上对应的变量
# 不同数据类型的变量,要使用不同的占位符进行占位
# 字符串数据使用 %s
# 浮点型数据使用 %f
# 整型数据使用 %d
name = 'xiaoming'
age = 18
height = 1.85
weight = 69.5
marriage = False
# 一个占位符的格式化输出
print('学员的姓名是 %s' % name)
print('学员的年龄是 %d' % age)
print('学员的身高是 %f' % height)
print('学员的体重是 %f' % weight)
print('学生的婚姻状况是 %s' % marriage)
# 有多个动态变量的时候,我们就需要使用多个占位符进行占位
# TypeError: not enough arguments for format string
# 如果前边有多个占位符,那后边的多个变量要使用括号进行包裹
print('学员的姓名是%s, 学员的年龄是%d岁, 学员的身高是%f米, 学员的体重是%fkg, 学员的婚姻状况是%s' % (name, age, height, weight, marriage))
# 括号内的变量数量不能少于占位符数量
# print('学员的姓名是%s, 学员的年龄是%d岁, 学员的身高是%f米, 学员的体重是%fkg, 学员的婚姻状况是%s' % (name, age, height, weight))
# not all arguments converted during string formatting
# 括号内的变量数量不能多于占位符的数量
# print('学员的姓名是%s, 学员的年龄是%d岁, 学员的身高是%f米, 学员的体重是%fkg, 学员的婚姻状况是%s' % (name, age, height, weight,marriage,name))
# 结论:占位符的数量,与%后的变量数量必须保持一致,如果是一个占位符,则可以使用一个变量,如果是多个占位符,那么多个变量必须使用括号包裹起来
# 能否控制变量输出的结果的样式:可以
name = 'xiaoming'
age = 18
height = 1.85
weight = 69.5
id = 12
# 需求:1.身高保留两位小数,体重保留三位小数
# 需求:2.学员的id共占用6位,不足位用0填充
# 使用ctrl + d 可以整行复制
print('学员的姓名是%s, 学员的年龄是%d岁, 学员的身高是%f米, 学员的体重是%fkg, 学员的编号是%d' % (name, age, height, weight, id))
# 浮点型保留n位小数: %.nf
# 整型占用n位数据,不足位用0补齐 %0nd
print('学员的姓名是%s, 学员的年龄是%d岁, 学员的身高是%.2f米, 学员的体重是%.3fkg, 学员的编号是%06d' % (name, age, height, weight, id))
10、转译字符
- \n:换行符
- \t：制表符
- %%：在字符串格式化拼接时输出%
# \n 换行符
# 为什么两个print之间可以自动换行
# 在print定义时自动在结尾加上了'\n'所以每次打印结束后,会自动换行
print(123)
print('hello world \n')
print(456)
# 如果不想让其自动换行, 在字符串输入结束后,使用end = '结束符' 可以修改print打印结束后插入的字符
print(123, end='$$$')
print(456)
# \t 制表符
print('3 4\t5')
# %% 输出%
# 在不适用字符串格式化拼接时,可以进行%的单独输出
print('我的业绩增长了100%')
score = 100
# 在使用字符串格式化的时候,字符串中的%不能单独输出,必须配合占位符,或者使用%%进行输出
print('我的成绩增加了%d%%' % score)
# 转译字符:在字符串中,一般情况下n 或者 t这类字母没有特殊含义,如果想给他赋予特殊含义,则需要使用\进行转译
知识点回顾
- 能够完成Python环境的搭建以及Pycharm的安装
- 能够说明注释的作用以及怎么使用单行注释和多行注释
- 能够说明在Python中变量的作用
- 能够说出变量的类型(数字型、布尔类型、字符串、列表、元组、字典)
- 能够知道什么是标识符？以及标识符命名的规则
- 能够使用
print函数完成输出
随堂练习
- 说出 Python 语言的作者，以及该语言的优缺点和应用场景都有哪些？
- 使用 Pycharm 创建一个新的工程，再创建一个新的 py 文件，在该文件中输出
hello world。 - 在第四题的基础上，使用单行注释和多行注释写明该文件中代码的作用。
- 描述出变量的作用，以及变量都有哪些类型
- 什么是标识符？标识符的命名规则是什么？
- 使用 print 函数完成输出
每日练习
题目1（简答+实操题）
题干：注释的作用是什么？Python中的注释有什么？使用代码表示出来注释的使用
考察知识点：
注释的作用以及使用
参考答案
- 注释的作用就是起到解释说明的作用
题目2（实操题）
题干：
- 打开Pycharm，创建一个新的工程，工程名称为自己的名字
- 创建一个新的文件，名为
hello_py - 在文件中使用代码完成输出；
人生苦短，我用Python
考察知识点：
Pycharm的使用以及创建 py 文件和 print 函数的使用。
参考答案
# 同学能根据步骤操作出来即可
print("人生苦短，我用Python")
拓展提高
题目3（实操题）
题干：
按照定义变量的语法要求，定义变量，存储个人信息。 例如：姓名、年龄、体重。
训练目标
- 定义变量的语法；
- 标识符命名规则；
- 字符串、整型、浮点型数据书写方法。
训练提示
- 定义变量的语法规则是什么？
- 标识符命名规则具体要求是什么？
- 用户个人信息的姓名、年龄、体重分别是什么数据类型，如何书写？
参考方案
- 定义变量的语法：
变量名 = 值； - 标识符命名规则：由数字、字母、下划线组成；不能数字开头，可以以数字结尾；严格区分大小写；不能使用内置关键字；
- 用户的姓名是字符串数据类型；年龄是整型数据类型；体重为浮点型数据类型。
参考步骤:
- 定义3个变量，分别存储用户姓名、年龄、体重数据；
参考答案
name = "MrSun"
age = 20
weight = 75.5
题目4 （实操题）
题干：
已知用户姓名、年龄、体重数据，要求在控制台格式化输出用户信息，例如：姓名: TOM, 年龄：18, 体重: 66.6公斤。
name = "TOM"
age = 18
weight = 66.6
训练目标
- 格式化输出写法与格式化符号或f格式化字符串。
训练提示
- 字符串、整型、浮点型数据分别使用哪种格式化符号？
- 如果书写程序做到一次性格式化多个数据？
参考方案
- 字符串数据格式化符号：
%s； 整型数据格式化符号：%d；浮点型数据格式化符号：%f; - 一次性格式化多个数据写法`%(x1, x2, x3…) 。
参考步骤
- 根据不同数据的类型格式化输出数据；
- 处理保留小数位数等细节。
参考答案
name = "TOM"
age = 18
weight = 66.6
print("姓名: %s, 年龄：%d, 体重: %.1f公斤" % (name,age,weight))
自主预习
题目5 （实操题）
题干：
用户登录系统：用户输入用户名和密码， 并控制台格式化输出用户输入的用户名和密码。
训练目标
- 输入和输出功能的结合使用
- 使用变量存储用户输入的值
训练提示
- 在Python中，接收用户输入的数据要使用什么函数？
- 使用输入功能接收到的用户输入的数据是什么数据类型？ 如何格式化输出？
参考方案
- 在Python中，接收用户输入的数据使用
input()函数。 input()函数接收到的用户输入的数据是字符串类型；使用格式化符号%s格式化输出。
参考步骤
- 书写2个
input()，分别接收用户输入的用户名和密码。 - 格式化输出用户输入的用户名和密码数据。
参考答案
user = input("请输入用户名：")
password = input("请输入密码")
print("用户名: %s 密码: %s" % (user,password))
题目6 （实操题）
题干：
书写程序，制作一个加法计算器。
用户依次输入2个整数，系统自动进行加法运算，并打印结果。
训练目标
- 运算符的使用；
input()接收到的数据的数据类型；- 转换数据类型。
训练提示
- 加法运算符号是什么？加法运算的数据要求的数据类型是什么？
input()接收到的数据是什么数据类型？- 如何把
input()接收到的数据转换成int整型？
参考方案
- 加法运算符是
+，加法运算的数据要求的数据类型是整数或浮点数； input()接收到的数据是字符串类型；- 字符串转整型使用
int()。
参考步骤
- 书写2个
input()，分别接收2个整数的输入； - 将接收到的2个数据分别转换成整型， 并进行加法运算；
- 打印结果。
参考答案
# 接收用户输入的2个数字
num1 = input("请输入第一个数字: ")
num2 = input("请输入第二个数字: ")
# 把接收到的数字从字符串转化成int类型，便于参与计算
num1 = int(num1)
num2 = int(num2)
# 计算结果
result = num1+num2
# 打印计算结果
print("计算结果是: %d" % result)
day02
1、转译字符
- \n:换行符
- \t：制表符
- %%：在字符串格式化拼接时输出%
# \n 换行符
# 为什么两个print之间可以自动换行
# 在print定义时自动在结尾加上了'\n'所以每次打印结束后,会自动换行
print(123)
print('hello world \n')
print(456)
# 如果不想让其自动换行, 在字符串输入结束后,使用end = '结束符' 可以修改print打印结束后插入的字符
print(123, end='$$$')
print(456)
# \t 制表符
print('3 4\t5')
# %% 输出%
# 在不适用字符串格式化拼接时,可以进行%的单独输出
print('我的业绩增长了100%')
score = 100
# 在使用字符串格式化的时候,字符串中的%不能单独输出,必须配合占位符,或者使用%%进行输出
print('我的成绩增加了%d%%' % score)
# 转译字符:在字符串中,一般情况下n 或者 t这类字母没有特殊含义,如果想给他赋予特殊含义,则需要使用\进行转译
2、f-string ★
- f-string是Python3.6之后出现的格式化语法
- 格式：f’要输出的字符串{要拼接的变量}’
- f可以是大写，也可以是小写，
- 引号可以是单引号，也可以是双引号
- 精度控制
- {浮点型变量：.nf} 保留n位小数，四舍五入
- {整型变量：0nd} 保留n位，不足位用0补齐，如果超出则原样显示
- %可以单独输出
# f-string是Python3.6以后推出的格式化方式
name = 'xiaoming'
age = 18
height = 1.85
weight = 69.5
score = 98
id = 12345678
# 格式化拼接上述变量
# 传统拼接方式
print('学员的姓名是%s, 学员的年龄是%d, 学员的身高是%f, 学员的体重是%f, 学员的分数是%d%%, 学员的学号是%d' % (name, age, height, weight, score, id))
# 使用f-string进行字符串拼接
# 格式:f'要输出的内容{变量}'
print(F'学员的姓名是{name}, 学员的年龄是{age}, 学员的身高是{height}, 学员的体重是{weight}, 学员的分数是{score}%%, 学员的学号是{id}')
# 修改格式:
print('学员的姓名是%s, 学员的年龄是%d, 学员的身高是%.2f, 学员的体重是%.3f, 学员的分数是%d%%, 学员的学号是%06d' % (name, age, height, weight, score, id))
# 如果需要调整精度
# {整数型变量:06d} 整型占六位,不足位用0补齐 d可以省略
# {浮点型变量:.2f} 浮点型保留两位小数, 四舍五入
# %可以单独输出
print(F'学员的姓名是{name}, 学员的年龄是{age}, 学员的身高是{height:.2f}, 学员的体重是{weight:.3f}, 学员的分数是{score}%, 学员的学号是{id:06d}')
print(F'学员的姓名是{name}, 学员的年龄是{age}, 学员的身高是{height:.2f}, 学员的体重是{weight:.3f}, 学员的分数是{score}%, 学员的学号是{id:06}')
# 练习:
# 输出自己的信息包括,姓名,年龄,身高(保留两位小数),学号(保留6位,不足位用0补齐),使用f-string进行拼接
3、数据类型转换
-
数据类型转换是为了不同类型数据之间可以进行拼接或运算
-
格式：数据类型（要转化类型的变量或值）
-
int和float类型直接可以随意转换
- float转换为int类型只保留整数部分
- int转换为float类型在末尾添加。0
-
如果数值型转换为str类型，可以随意转换
-
如果str类型转换为数值型
- float 必须保证str引号内部是浮点型数据或整型数据
- int 必须保证str引号内部是整型数据
# 需求: 在超市中有两种水果,苹果和橘子
# 让售货员输入苹果的单价,苹果的重量,橘子的单价,橘子的重量,在控制台输出购买详情以及总价
# apple_price = input('请输入苹果的单价:')
# apple_weight = input('请输入苹果的重量:')
# orange_price = input('请输入橘子的单价:')
# orange_weight = input('请输入橘子的重量:')
# TypeError: can't multiply sequence by non-int of type 'str'
# 不同类型间的数据无法相乘
# 在此情况下,我们需要进行数据类型转换(input接收的数据默认为字符串类型),需要转化为float
# print(f'您购买了苹果{apple_weight}kg, 单价{apple_price}元, 橘子{orange_weight}kg, 单价{orange_price}元, 总共需要付款{apple_price * apple_weight + orange_price * orange_weight}')
# 如果需要将数据转换为float 就给其穿上float类型的衣服
# 格式: float(需要转换数据类型的变量或者值)
# apple_price = float(input('请输入苹果的单价:'))
# apple_weight = float(input('请输入苹果的重量:'))
# orange_price = float(input('请输入橘子的单价:'))
# orange_weight = float(input('请输入橘子的重量:'))
#
#
# print(f'您购买了苹果{apple_weight}kg, 单价{apple_price}元, 橘子{orange_weight}kg, 单价{orange_price}元, 总共需要付款{apple_price * apple_weight + orange_price * orange_weight}元')
int1 = 12
float1 = 14.9
str1 = '12'
str2 = '14.3'
str3 = 'python'
# 数据类型转换的细节
# int float str类型之间的转换
# int >> float
# int类型转换为float类型将会在整数末尾加.0
print(float(int1))
print(type(float(int1)))
# float >> int
# float转换为int类型,将会将小数部分去除,只保留整数部分
print(int(float1))
# int >> str
# int类型可以随意转换为str类型,但是输出结果不发生改变,转化为str类型后可以使用str类型的各种函数
print(str(int1))
# str >> int
# 字符串中是int类型数据,可以转换为int类型
print(int(str1))
# ValueError: invalid literal for int() with base 10: '14.3'
# 字符串中是float类型数据,不可以转换为int类型
# print(int(str2))
# ValueError: invalid literal for int() with base 10: 'python'
# 字符串中是字符型数据,不可以转换为int类型
# print(int(str3))
# float >> str
# float类型可以随意转换为str类型,但是输出结果不发生改变,转化为str类型后可以使用str类型的各种函数
print(str(float1))
# str >> float
# 字符串中是int类型数据,则可以转换为float类型数据,并且在末尾加.0
print(float(str1))
# 字符串中是float类型数据,可以转换为float类型数据
print(float(str2))
# ValueError: could not convert string to float: 'python'
# 字符串中是字符型数据则不能转换为float类型数据
print(float(str3))
4、算数运算符
+ - * / // % **//取商%取余**幂次运算
# + - * / % // **
# 案例:求梯形的面积
# a = float(input('请输入梯形的上底长度:'))
# b = float(input('请输入梯形的下底长度:'))
# h = float(input('请输入梯形的高:'))
#
# print(f'梯形的面积为{(a + b) * h / 2}')
# 算数运算符优先级可以使用小括号控制, 先乘除后加减,同级运算从左至右依次运算
float1 = 10.2
int1 = 4
int2 = 11
# +
# 数值型数据(float, int, bool)之间可以进行算数运算
print(int1 + float1)
# 了解 bool 可以参与算数运算 True 代表1 false 代表0
# print(int1 + True)
# -
# 同加法运算一致
# *
print(int1 * int2)
print(int1 * float1)
# /
print(int1 / int2)
print(int1 / float1)
# //(整除) 两个数据相除 取商
# 11 / 4 商 2 余 3
print(int2 // int1) # 2
# %(取模 取余) 两个数相除 取余
# 11 / 4 商 2 余 3
print(int2 % int1) # 3
# ** (幂次运算)
# 幂次运算就是求变量的多少次方
# 扩展int1 开根号等于几 int1 ** 0.5
print(int1 ** 2)
# 在除法运算中,结果必定为浮点型
print(9 / 3) # 3.0
# 浮点型参与运算后,结果一定是浮点型
# 商 3 余 2.2
print(11.2 // 3) # 3.0
print(9.9 // 3.3) # 3.0
# print(0.1 + 0.2) # 0.30000000000000004
-
结论算数运算符优先级: + - < * / // % < **
-
如果忘记了也没关系使用()提高运算符优先级即可
print(1 + 2 * 3)
# 先乘除 后加减
# //运算 优先级
print(2 + 11 // 3 ) # 优先级高于+ -
# // 与 * / 平级
print(2 * 11 // 3)
print(11 // 3 * 2)
# % 也和 * / 平级
print(2 + 11 % 3) # 优先级高于+ -
print(2 * 11 % 3)
print(11 % 3 * 2)
# ** 优先级 高于 * /
print(2 * 3 ** 2)
# 结论算数运算符优先级: + - < * / // % < **
# 如果忘记了也没关系使用()提高运算符优先级即可
5、赋值符号
- = ：将等号右侧的值赋值给等号左侧的变量
- 可以给单个变量赋值： 变量= 值
- 可以给多个变量赋不同的值 ： 变量1， 变量2. 变量3 = 值1， 值2， 值3
- 可以给多个变量赋相同的值：变量1 = 变量2 = 变量3 = 值
# = (在Python中等号不是判断相等的而是赋值使用)
# 赋值格式: 变量名 = 值
# 给单个变量赋值
a = 1
# 同时给多个变量赋值
# 等号左侧的变量数量一定要等于等号右侧的值的数量, 否则报错
name, age, gender = 'xiaoming', 18, '男'
# ValueError: not enough values to unpack (expected 3, got 2)
# name, age, gender = 'xiaoming', 18
print(name, age, gender)
# 同时给多个变量赋相同的值
# 此种情况前边可以有多个变量,但是最后只能有一个值,否则报错
a = b = c = 10
# a = b = c = 10 = 20
print(a, b, c)
# 等号左侧一定要是变量,右侧可以是值或者已经被定义的变量
int1 = 2
int2 = int1
print(int1, int2)
6、复合赋值运算符
-
+= -= *= /= //= %= **= -
复合赋值运算符等号左侧一定是已经被定义的变量
-
复合赋值运算符右侧是已经被定义的变量或者值
# += -= *= /= //= %= **=
a = 1
# a += 1 >>> a = a + 1 将a中的变量取出与1相加得到的数值赋值给a
a += 1
print(a)
# 符合赋值运算符等号左侧只能是已经定义的变量
# 符合赋值运算符等号右侧可以是已经定义的变量或者值
# NameError: name 'b' is not defined
# b必须已经被定义 b = b - 1 先计算b - 1 此时b必须存在
# b -= 1
# print(b)
# 复合赋值运算符不能连续使用
# a += 1 += 2
# 练习
a = 2
a *= 2
print(a)
b = 12
b //= 5
print(b)
7、比较运算
< > <= >= == !=- 比较运算就是比较数据值的大小
- 比较运算可以连续使用
- 比较运算中比较相等使用== 而 不能使用 = （赋值运算符）
# < > <= >= != ==
# 比较运算符运算结果为bool值,如果成立,则返回True 如果不成立则返回False
print(1 < 2) # True
print(5 > 6) # False
print(1 >= 0) # True
print(4 != 4) # False
# 比较运算符可以连续使用(Python中的特性)
age = 13
print(12 < age < 30) # True
# 不等号也可以连续使用
print(12 < age != 13) # False
# <> 不可以使用
# print(1 <> 3)
# 判断是否相等使用==
print(age == 13) # True
print(age == 11) # False
# TypeError: 'age' is an invalid keyword argument for print()
# =是赋值运算不能判断是否相等
# print(age = 12)
8、逻辑运算 ★
- and 同真即真
- or 同假即假
- not 真变假 假变真
# and 同真即真
print(True and False) # False
print(True and True) # True
print(False and True) # False
print(False and False) # False
# or 同假即假
print(True or False) # False
print(True or True) # True
print(False or True) # False
print(False or False) # False
# not 真变假, 假变真
print(not True) # False
print(not False) # True
# 结论:逻辑运算符的运算结果都是bool类型数据
# 练习:
print(not(1 > 2 and 4 < 5))
9、短路运算
# 短路运算:
a = 1
b = 2
# 当逻辑运算的第一个表达式已经可以决定整个逻辑运算的值的时候,后边的表达式将不会被运行
print(a > b and a < b)
# 在数值型数据中,非0即真
# 在容器型数据中,非空即真
# None 代表False
print(False and 1) # False
print(0 and True) # 0
print(12 or False) # 12
print(None and True) # None
print(True and False) # False
print(True and 15) # 15
print(False or "") # ""
10、分支语句
- 单一条件判断
if 条件：
条件成立时执行的代码
# 格式:
'''
if 条件:
条件成立时执行的代码
'''
age = int(input('请输入你的年龄:'))
# 上网
if age >= 18:
print('小帅哥快来玩啊')
print('回家睡觉')
- 对立条件判断
if 条件：
条件成立时执行的代码
else：
条件不成立时执行的代码
# if ... else ...
'''
if 条件:
条件成立时执行的代码
else:
条件不成立时执行的代码
'''
# 使用分支语句,只有一个分支内的代码会被执行
age = int(input('请输入你的年龄:'))
if age >= 18:
print('小帅哥,快来玩啊')
else:
print('老板我就进去看别人玩')
print('回家睡觉')
- 多条件判断
if 条件1：
条件1成立时执行的代码
elif 条件2：
条件2成立时执行的代码
elif 条件3：
条件3成立时执行的代码
else：
所有条件均不成立时执行的代码
# 格式;
'''
if 条件1:
条件1成立时执行的代码
elif 条件2:
条件2 成立时执行的代码
elif 条件3:
条件3成立时执行的代码
else:
所有条件均不成立时执行的代码
'''
# 需求:搭讪,主要是为了问路
age = int(input('请输入对方的年龄:'))
if age > 100 or age < 0:
print('数据错误')
elif 0<= age <= 18:
print('小妹妹你真可爱')
print('叔叔 我们不约而同的认为我很可爱')
elif 18< age <= 30:
print('美女,你真漂亮')
print('流氓')
elif 30 < age <= 60:
print('阿姨,我不想努力了')
print('瞧你长那样')
else:
print('老奶奶,您真慈祥')
print('我北京三套房')
- 注意事项：
- 分支语句中条件可以是bool值或者能够转换为bool值的数据或者表达式
- 分支语句中只能执行其中一个分支的命令，如果一个条件符合则后续条件均不会进行判断
# 什么样的内容可以作为条件出现?
# bool值或者可以转换为布尔值的数据或表达式
# 表达式:经过运算或者执行后,可以得到一个值的代码块或语句都是表达式
# 分支结构,循环结构,赋值,函数定义 不能作为条件出现
# if a = 1:
# print('qqwe')
# a = 1
# if if a==1:
# print()
# 分支语句中只有一个分支的命令会被执行
# 如果运行过程中其中一个条件成立,则后续所有条件不会进行判断
age = int(input('请输入对方的年龄:'))
if age > 100 or age < 0:
print('数据错误')
elif age <= 18:
print('小妹妹你真可爱')
print('叔叔 我们不约而同的认为我很可爱')
elif age <= 30:
print('美女,你真漂亮')
print('流氓')
elif age <= 60:
print('阿姨,我不想努力了')
print('瞧你长那样')
else:
print('老奶奶,您真慈祥')
print('我北京三套房')
11、分支语句嵌套
- 在分支语句中包含其他分支语句
# 嵌套:在if语句控制的代码块中存在其他的if语句
# 需求: 如果有钱可以上车(money) 如果上车了又座位可以坐下(seat)
money = 12
seat = True
if money >= 2:
print('快上车,里边有大座')
if seat == True:
print('快坐下吧,别累着')
else:
print('我骗你的你能咋办')
else:
print('穷鬼,跟着车跑吧,不等你')
# 判断时正数负数 还是正奇数正偶数,负奇数,负偶数
# num = 12
# if num < 0:
# print('负数')
# if num % 2 == 0:
# print('负偶数')
# else:
# print('负奇数')
# else:
# print('正数')
# if num % 2 == 0:
# print('正偶数')
# else:
# print('正奇数')
num = -13
if num < 0:
print('负', end='')
if num % 2 == 0:
print('偶数')
else:
print('奇数')
else:
print('正', end='')
if num % 2 == 0:
print('偶数')
else:
print('奇数')
12、猜拳游戏
# 需求:
# 玩家键入拳型,电脑随机出拳
# 比对玩家和电脑的拳型,如果玩家胜则输出玩家获胜,如果电脑获胜则输出电脑获胜,如果平局则输出平局
# # 玩家键入拳型
# player = int(input('请输入您要出的拳型:(0 石头 1 剪刀 2 布)'))
# # 电脑随机出拳
# computer = 2
# # 比对拳型
# # 玩家获胜情况: p: 0 c: 1 | p: 1 c: 2 | p : 2 c : 0
# if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0):
# # 输出结果
# print('玩家获胜')
# elif player == computer:
# # 输出结果
# print('平局')
# else:
# # 输出结果
# print('电脑获胜')
'''
p c 差值
0 0 0 平局
0 1 -1 p
0 2 -2 c
1 0 1 c
1 1 0 平局
1 2 -1 p
2 0 2 p
2 1 1 c
2 2 0 平局
找规律: 结果为0 平局
结果为 -1 或 2 玩家获胜
结果为 -2 或 1 电脑获胜
'''
# 玩家键入拳型
player = int(input('请输入您要出的拳型:(0 石头 1 剪刀 2 布)'))
# 电脑随机出拳
# 在计算机中如果想要生成随机数据可以使用random模块进行生成
import random # 导入模块
# 生成随机数 random.randint(m,n) 生成[m, n]区间内的任意一个整数
computer = random.randint(0,2)
result = player - computer
# 比对拳型
# 玩家获胜情况: p: 0 c: 1 | p: 1 c: 2 | p : 2 c : 0
if result == -1 or result == 2:
# 输出结果
print('玩家获胜')
elif result == 0:
# 输出结果
print('平局')
else:
# 输出结果
print('电脑获胜')
13、三目运算 ★
- 格式：条件成立时返回的数据 if 条件 else 条件不成立时返回的数据
# 三元运算符又叫三目运算
# 格式: 条件成立时返回的数据 if 条件 else 条件不成立时返回的数据
# 需求输出a和b中的最大值
a = 4
b = 5
max1 = a if a > b else b
print(max1)
当天知识点回顾
- 能够使用算数运算符
+(加) -(减) *(乘) /(除) //(取整余) %(取余) **(指数)完成数值的运算 - 能够使用赋值运算符完成数据的赋值
- 能够完成 Python 中数据类型的转换
- 能够掌握
if判断语句的语法格式和完成逻辑的判断 - 能够掌握比较运算符的使用
==(相等) !=(不等) >(大于) <(小于) >=(大于等于) <=(小于等于) - 能够掌握逻辑运算符的使用
and(与) or(或) not(非) - 能够掌握
if .. else语句的使用 - 能够掌握
if .. elif .. else语句的使用 - 能够使用
if嵌套语句的使用
随堂练习
- 能够说出课上学过的几种Python的运算符
- 在Pycharm中练习所有的运算符操作(算术、赋值、复合赋值)
- 在Pycharm中练习实现字符串转换为数字，以及数字转换为字符串
- 在Pycharm中计算 7 和 3 的商数和余数并打印
- 写出 if 语句的几种判断格式
- 写出 if 语句和 比较运算符和逻辑运算符结合使用
- 完成课上的猜拳游戏的代码
每日练习
题目1（实操题）
题干：
开发程序：购物车功能。
已知A网站苹果和橘子两种水果单价(具体如下)，用户根据自己的需求输入斤数， 系统计算总价并打印结果。
# 水果单价
apple_price = 6.6
orange_price = 5
训练目标
-
input()接收到的数据是字符串类型，按需求转换数据类型； - 运算符的使用。
训练提示
- 用户根据自己的需要数据购买水果的斤数，这个斤数可能是小数，可能是整数，如何转换数据类型计算总价？
- 计算总价需要使用到哪些运算符？
参考方案
- 用户输入的斤数可能是小数也可能是整数形式的字符串数据，需要转换数据类型为浮点型才能做总价结果运算。因为， 如果用户输入小数，使用
int()转换的时候程序会报错； 并且，一个工作中，购物钱数需要精确到小数点后2位。 - 计算总价需要使用乘法运算符
*和 加法运算符+。
参考步骤
- 用户分别输入购买苹果和橘子的斤数，并转换数据类型为浮点型；
- 计算总价： 总价 = 苹果单价 * 苹果斤数 + 橘子单价 * 橘子斤数；
- 打印结果
参考答案
# 水果单价
apple_price = 6.6
orange_price = 5
# 接收用户输入的苹果重量, 主要要转化成浮点数
apple_weight = float(input("请输入你要购买的苹果重量（kg）: "))
# 接收用户输入的橘子数量
orange_weight = float(input("请输入你要购买的橘子重量（kg）: "))
# 计算总价格
total = apple_price * apple_weight + orange_price * orange_weight
# 打印结果, 可以保留指定的小数位
print("购买水果共消费: %.1f" % total)
题目2（实操题）
题干：用户输入年龄，如果年龄满60岁，输出：“可以退休了”， 否则，输出：“小伙子，加油干！”
训练目标
if…else语法
训练提示
题目描述了2种情况(年龄满60岁和不满60岁)，涉及到2中情况需要判断的时候，使用哪种if语句格式？
参考方案
在Python中，能够判断两种情况的时候需要使用if…else…语句。
操作步骤
input()接收用户输入的年龄，并转换数据类型为int；- 如果用户输入的年龄满60，则输出"可以退休了"； 条件不成立则输出：小伙子，加油干！
参考答案
# 1. 用户输入年龄
age = input("请输入您的年龄: ")
# 2. 把年龄转化成int, 1、2 步骤也可以合并成一个
age = int(age)
#3. 判断年龄是否大于60,满60可以退休了，否则就是满60接着干
if age >= 60:
print("可以退休了")
else:
print("小伙子，加油干!")
题目3（实操题）
题干
用户输入年龄，按照如下标准书写程序，判断用户处于哪个年龄阶段，并提示：您的年龄是xx: 青少年/青年/中年/老年。
年龄段划分标准：0-17岁（包含0、17）为青少年；18-34岁为青年；35-59为中年，满60为老年。
训练目标
- elif多重判断写法；
- 逻辑运算符的使用方法。
训练提示
- 本题中年龄段分为青少年、青年、中年、老年四种情况需要判断，在Python中，判断多种情况需要使用哪种if语句格式？
- 每个年龄段有最低和最高年龄限制，使用哪种运算符能完成对最低和最高年龄同时判断？
参考方案
- 在Python中，判断多种情况需要使用elif多重判断写法；
- 对每个年龄段的最低和最高年龄同时限制。
操作步骤
input()接收用户输入的年龄，并转换数据类型为int；if…elif对不同的年龄段进行判断。
参考答案
# 1. 用户输入年龄，并转化成int
age = int(input("请输入年龄: "))
# 2. 判断是 青少年、青年、中年、老年。 注意比较过程中的年龄范围
if 0<=age<18:
print("青少年")
elif 18<=age<35:
print("青年")
elif 35<=age<60:
print("中年")
elif age>=60:
print("老年")
else:
print("你输入的年龄不正常!")
题目4（实操题）
题干
坐公交：假设坐公交需要买票上车，书写程序要求如下：
-
- 如果有票则可以上车，否则不能上车
-
- 上车后，如果有座位可以坐下，否则不能坐下。
已有程序如下，请补全程序：
# ticket取值为1表示有票，取值为0表示无票
ticket = 1
# seat取值为1表示有座位，取值为0表示无座位
seat = 1
训练目标
if嵌套书写方法
训练提示
本题判断流程如下：判断能上车后，才能判断是否能坐下，如何书写程序完成这种判断流程？
参考方案
当ticket == 1条件成立的时候才判断是否能坐下，所以这里是if嵌套的写法
操作步骤
- 书写ticket是否和1相等，如果条件成立表示可以上车；否则不能上车；
- 当
ticket == 1条件成立的时候，书写判断能否坐下的if语句。
参考答案
# ticket取值为1表示有票，取值为0表示无票
ticket = 1
# seat取值为1表示有座位，取值为0表示无座位
seat = 1
# 判断是否有票
if ticket==1:
print("乘坐公交车")
# 判断是否有座位
if seat==1:
print("坐上座位")
else:
print("站立")
else:
print("没有票，不能乘车!")
拓展提高
题目5（实操题）
题干
制作用户登录系统：已知A用户注册的用户名为aaa，密码是123456。具体要求如下：
登录时需要验证用户名、密码、验证码(固定验证码为qwer)。
提示：系统先验证验证码是否正确，正确后再验证用户名和密码。
训练目标
- if…else语句格式
- 比较运算符
==和 逻辑运算符 - if嵌套语句格式
训练提示
- 如何书写程序可以先验证验证码的正确性，验证码正确后再验证用户名和密码？
- 如何判断用户输入的验证码的正确性？
- 如何判断用户名和密码的正确性？
参考方案
- 先判断验证码的正确性，再验证用户名和密码，需要使用if嵌套写法；
- 判断用户输入的验证码/用户名/密码的正确性要使用到比较运算符
==。 - 登录功能要求用户名和密码必须同时正确，所以这里要使用到逻辑运算符
and。
操作步骤
- 准备用户名、密码、验证码等数据；
- 用户输入用户名、密码、验证码；
- 判断验证码是否为
qwer； - 如果验证码为
qwer，再验证用户名和密码的正确性。
参考答案
# 1.准备用户名、密码、验证码等数据；
user = 'aaa'
pwd = '123456'
code = 'qwer'
#2. 获取用户输入的用户名、密码、验证码信息
username = input("请输入用户名：")
password = input("请输入用户密码：")
user_code = input("请输入验证码：")
#3. 判断验证码
if user_code==code:
#4. 判断用户名与密码是否正确
if username==user and pwd==password:
print("欢迎登陆系统！")
else:
print("用户名或密码错误！")
else:
print("验证码错误")
题目6 （实操题）
题干：
编写一段代码，要求依次输入语文、数学、英语三门课的成绩（输入范围0到100，包括0和100），
如果三门成绩的平均分小于60，打印"不及格",
如果平均分大于90, 打印优秀，
其他则打印"良"。
训练目标
- 获取用户输入 input 函数，以及数据类型的转换
- 算术运算符的使用
- if判断语句的使用
训练提示
- 定义变量接收用户的输入(input)的成绩，并将获取到的数据转换成int类型
- 判断输入分数是否在0~100的范围
- 三门成绩先相加在取平均值
- 判断
参考步骤
- 定义三个变量分别获取用户输入的三门成绩，并使用int函数将数据转换成int类型
- 三门成绩先求总和(+), 再 除以 3去平均成绩(总成绩/3)
- 判断平均成绩是属于 不及格、优秀、良 并打印出结果
参考答案
# 1. 等待用户输入成绩
math = int(input("请输入数学成绩："))
english = int(input("请输入英语成绩："))
chinese = int(input("请输入语文成绩："))
# 2. 判断输入的数字范围
if 0<=math<=100 and 0<=english<=100 and 0<=chinese<=100:
# 3. 都满足要求说明分数合理，接下来计算成绩
total = math+english+chinese
# 计算平均值
avg = total/3
# 4. 判断属于优秀还是其他？
if avg < 60:
print("不及格")
elif 60<=avg<90:
print("良")
else:
print("优秀")
else:
print("输入的成绩不满足要求")
题目7 （实操题）
题干：
编写一段代码，需要输入要一个有效年份，判断该年份是否是闰年，如果是闰年，则打印“xx年是闰年”；否则打印“xx年不是闰年”
如输入"2019"，将打印“2019年不是闰年”
提示：闰年年份是能被4整除，但不能被100整除的；或者能被400整除的年份，如1900年能被4整除，但是也能被100整除，所以不是闰年，而2000虽然既能被4整除又能被100整除，但是2000能被400整除，所以是闰年。
训练目标
- 判断的使用
- 算数运算符和逻辑运算符的使用
训练提示
- 怎么获取用户的输入，获取到的数据是什么类型？是否可以直接用于计算？
- 当满足什么条件的使用是闰年?
参考步骤
- 先获取用户输入的年份，并转化成整数类型，使用变量进行存储
- 判断用户输入的年份，如果能被4整除，但不能被100整除的；或者能被400整除的年份是闰年，否则就不是闰年
参考答案
#1. 接收用户输入的年，并转化成整数
year = int(input("请输入要计算的年份："))
#2. 按照规则计算是否是瑞年
# 优先判断是否能被400整除，能整除肯定是闰年
if year%400 ==0:
print("%d 是闰年" % year)
else:
# 我们接着判断是否满足另一个规则
# 注意，我们利用取余来判断是否能被整除。能被整除余数是0
if year%4==0 and year%100!=0:
print("%d 是闰年" % year)
else:
print("%d 不是闰年" % year)
题目8 （实操题）
题干：
输入一个人的身高(m)和体重(kg)，根据BMI公式（体重除以身高的平方）计算他的BMI指数。
- 例如：一個52公斤的人，身高是155cm，则BMI为 :
52(kg)/1.55*1.55(m)= 21.6
- BMI指数：
低于18.5：过轻
18.5-25：正常
25-28：超重
28-32：肥胖
高于32：严重肥胖
训练目标
- 运算符的使用；
- 判断的使用
参考步骤
- 获取用户输入的身高和体重
- 根据 BMI 公式计算出该用户的 BMI 指数
- 判断该用户的 BMI 指数属于哪一个等级
参考答案
# 1. 获取用户输入的身高和体重
weight = int(input("请输入你的体重(KG): "))
height = int(input("请输入你的身高(CM): "))
# 2. 把厘米转化成米
height = height/100
#3. 计算BMI值
bmi = weight / (height * height)
#4. 判断BMI等级
'''
低于18.5：过轻
18.5-25：正常
25-28：超重
28-32：肥胖
高于32：严重肥胖
'''
if bmi<18.5:
print("过轻")
elif 18.5<=bmi<25:
print("正常")
elif 25<=bmi<28:
print("超重")
elif 28<=bmi<32:
print("肥胖")
else:
print("严重肥胖")
自主预习
题目9 （实操题）
题干：
使用循环打印5次 hello world
训练目标
- 循环语句的基本使用
训练提示
- 循环语句的语法是：
while 条件:
条件满足时，做的事情1
参考步骤
- 定义初始的变量
i = 0 - 当 i 的值 小于 5的使用执行循环
- 每循环一次 让 i 加 1
参考答案
i = 0
while i<5:
print("hello world")
i+=1
题目10 （实操题）
题干：
计算1~100之间偶数的累积和（包含1和100）。
训练目标
- while循环的使用
- 判断的使用
训练提示
- 1-100之间偶数的和，我们要先得出所有的偶数
- 循环不断的让偶数相加
参考步骤
- 定义循环的起始值 i = 1 和 初始的总和 sum = 0
- 循环，当 i <= 100 时执行循环
- 判断当前循环的 i 是否是偶数，如果是偶数就累加到sum上，如果不是则 i += 1
参考答案
# 1. 定义循环起始值，求和变量sum
i = 1
sum = 0
# 2. 循环遍历数字
while i <=100:
#3. 判断数字是不是偶数，如果是则累加
if i % 2==0:
sum+=i
i+=1 # 记得累加循环因子值
# 4. 循环结束打印下计算结果
print("1~100之间的偶数和是： %d" % sum)
day03
1、循环介绍
- 有条件的重复做相似的事情
- Python中循环分为while 和for
2、while循环的使用
-
格式： while 条件： 循环体
-
while 循环的三个必要元素
- while 关键字
- 循环条件
- 循环体
-
构造循环要想的四件事
- 初始状态
- 循环条件
- 要重复做的事情
- 循环控制
-
案例
# 需求:求1-100的累加和
# 初始状态
i = 1
sum1 = 0
while i <= 100:
# 求累加和
# sum1 = sum1 + i
sum1 += i
# 为下一次循环做准备,自增
i += 1
print('1-100的累加和是%d' % sum1)
# 需求:输出10以内的所有奇数
# 初始状态
i = 1
# 循环结束条件
while i <= 10:
# 要循环做什么
if i % 2 != 0:
print(i)
# 为下一次循环做准备 自增
i += 1
# 需求: 1-100的偶数累加和
# 初始状态:
i = 1
sum1 = 0 # 累加器
# 循环条件
while i <= 100:
# 要做什么?
if i % 2 == 0:
sum1 += i
# 为下一次循环做准备 累加
i += 1
print(f'1-100的偶数累加和是{sum1}')
# 练习 :计算 1-20 的奇数累乘积.
# 初始状态
i = 1
mult1 = 1
# 循环条件
while i <= 20:
# 要做什么
if i % 2 != 0:
mult1 *= i
# 自增
i += 1
print(f'1-20的奇数累乘积是{mult1}')
3、continue和break
- continue ：跳出本次循环，进入下一次循环
# continue: 跳出本次循环,继续执行下一次循环(不会影响循环的次数)
# 需求: 吃苹果,一个五个.吃到第三个 有个虫子,扔掉第三个,继续吃第四个第五个
# 注意,在循环结构中使用continue要在continue之前添加循环变量的自增,否则可能会造成无法跳出循环(死循环)
i = 1
while i <= 5:
if i == 3:
print('这个苹果有虫子,给女朋友吃吧')
i += 1
continue
print(f'我吃了{i}个苹果')
i += 1
# 写法二
# 可以先进行自增,再进行i的调用,此时,就不用担心continue的问题了
i = 0
while i < 5:
i += 1
if i == 3:
print('这个苹果有虫子,给女朋友吃吧')
continue
print(f'我吃了{i}个苹果')
# 输出1-10 的数字
# 在循环体中,continue所在的分支中,continue之后不要书写任何代码,永远不可能被执行
i = 1
while i <= 10:
print(i)
continue
i += 1
# break 和continue只能用在循环体中
# if True:
# print('123')
# break
# continue
- break ： 结束当前循环，后续循环次数不再执行
# break:跳出循环,终止此次循环之后的所有循环
# 吃苹果案例 吃到第三个 吃出半条虫子,后续无心再吃
i = 1
while i <= 5:
print(f'我吃了{i}个苹果')
if i == 3:
print('吃不下了 虫子个太大吃撑了')
# break之后的所有代码均不执行
break
i += 1
print('吃苹果完成')
# 输出1-10 十个数字
# 在循环体中,break所在的分支中,break之后不要写任何代码,不可能执行
# i = 1
# while i <= 10:
# print(i)
# break
# i += 1
- break 和continue 只能在循环体中使用
4、死循环
- 死循环不是bug，是程序的一种特殊运行状态，程序员可以用死循环做很多事情
- 死循环就是循环条件永远满足的一种循环
# 什么是死循环? 循环条件永远满足,可以持续循环的代码
# 死循环是bug么? 死循环不是bug可以利用死循环做很多事情
# 死循环可以退出么? 可以,死循环就是循环条件永远成立,但是在程序内部可以有很多方法跳出循环, break
# 猜拳游戏 (死循环进阶版)
# 需求:在原来猜拳游戏的基础上,让电脑和玩家进行猜拳,一方达到3分则退出游戏,宣布获胜方,否则游戏持续进行
# 普通循环
# player_score = 0
# computer_score = 0
# while player_score < 3 and computer_score < 3:
# # 获取玩家拳型
# player1 = int(input('请输入您要出的拳型:(0 石头 1 剪刀 2 布)'))
# # 获取电脑随机拳型
# import random
# computer = random.randint(0, 2)
# result = player1 - computer
# # 拳型比对 # 输出结果
# if result == -1 or result == 2:
# player_score += 1
# print('玩家获胜')
# elif result == 0:
# print('平局')
# else:
# computer_score += 1
# print('电脑获胜')
# print(f'当前比分为{player_score}:{computer_score}')
# 死循环
player_score = 0
computer_score = 0
while True:
# 获取玩家拳型
player1 = int(input('请输入您要出的拳型:(0 石头 1 剪刀 2 布)'))
# 获取电脑随机拳型
import random
computer = random.randint(0, 2)
result = player1 - computer
# 拳型比对 # 输出结果
if result == -1 or result == 2:
player_score += 1
print('玩家获胜')
elif result == 0:
print('平局')
else:
computer_score += 1
print('电脑获胜')
print(f'当前比分为{player_score}:{computer_score}')
if player_score >= 3:
print('玩家取得最终胜利')
break
if computer_score >= 3:
print('电脑取得最终胜利')
break
5、循环嵌套
- 循环体中包含其他循环结构的状态叫做循环嵌套
- 外层循环执行一次，内层循环将全部执行完成
# 需求:锻炼身体:跑步四圈,做深蹲10分钟,此为一组训练,要做三组
# 在循环嵌套中,外层循环执行一次,内层循环全部执行完成
# 做三组训练的初始状态
i = 1
# 做三组训练后退出循环
while i <= 3:
print(f'第{i}组训练开始')
# 跑圈初始状态
j = 1
# 跑四圈后退出循环
while j <= 4:
print(f'我跑了{j}圈')
# 内层循环自增变量
j += 1
print('我做了10分钟深蹲')
# 外层循环自增变量
i += 1
- 注意：break 和continue 控制的是当前所在的循环结构
# 需求:锻炼身体:跑步四圈,做深蹲10分钟,此为一组训练,要做三组
# break 和continue 只能控制本身所在的循环结构
# 在循环嵌套中,外层循环的break和cotinue可能会影响内层循环, 但是内层循环中的break和continue不会影响外层循环
# 做三组训练的初始状态
i = 1
# 做三组训练后退出循环
while i <= 3:
print(f'第{i}组训练开始')
# 跑圈初始状态
j = 1
# 跑四圈后退出循环
if i== 2:
print('我女朋友来找我了 先休息一下')
i += 1
continue
while j <= 4:
print(f'我跑了{j}圈')
# 内层循环自增变量
if j ==3 and i == 2:
print('太累了 休息下')
break
j += 1
print('我做了10分钟深蹲')
# 外层循环自增变量
i += 1
6、循环嵌套案例：
# 需求:打印五行五列的一个*组成的矩形
"""
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
"""
# 打印一行*号,使用while循环实现?
# i = 1
# while i <= 5:
# print('*', end=' ')
# i += 1
# 使用while循环将刚才打印的* 输出5次,每次分别占用一行
# i 控制外层循环的次数
i = 1
while i <= 5:
# j 控制内层循环的次数
j = 1
while j <= 5:
# 打印* 后更换结束符, 防止打印后自动换行
print('*', end=' ')
j += 1
# 一行结束后,强制换行
print()
i += 1
# 结论:外层循环控制的是行数, 内层循环控制的是列数 ,外层循环的i变量就是打印时的行号,内层循环的j变量就是打印列时的列号
# 如果现在要打印6行8列的矩阵 i = 6 j = 8
# 使用while语句打印三角形,第一行一个* 第二行两个* .....
"""
*
* *
* * *
* * * *
* * * * *
"""
# 外层循环的数量:5 该图形有5行,所以i <= 5
# 内层循环的数量:根据行号进行设定, 第一行 j <= 1 第二行 j <= 2.......
i = 1
while i <= 5:
j = 1
while j <= i:
print('*', end=' ')
j += 1
print()
i += 1
# 使用while循环的嵌套打印九九乘法表
"""
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
.......
"""
# 打印一个九行九列的直角三角形
# 外层循环控制行
i = 1
while i <= 9:
# 内层循环控制列
j = 1
while j <= i:
# 九九乘法表中,公式规则就是 列 * 行 = 值
print(f'{j} * {i} = {i * j}', end='\t')
j += 1
print()
i += 1
7、for循环
- for循环时遍历数据序列，每次获取一个元素，直到元素全部被获取，结束循环。
# for循环的语法结构
"""
for 临时变量 in 数据序列(容器):
要重复执行的代码
"""
# 循环逻辑:for循环会依次提取数据序列中的元素,每次提取一个,放入临时变量中储存,在循环体中可以使用临时变量,数据序列中有多少个元素,for循环的循环体将会被执行多少次
str1 = 'helloPython'
# 循环遍历str1 遍历:依次提取每一个元素
for i in str1:
print(i)
# for循环和while循环的区别:
# 1/for循环数据序列,元素提取完成自动停止,不需要使用循环变量
# 2/for循环不需要循环条件,所以也不会有循环条件成立喝不成立的说法
# 3/在开发中我们使用for循环的比例居多,while循环主要是构造死循环结构
# 4/for循环需要配合容器类型(数据序列)进行使用
8、for循环中的break 和continue
- 和while循环中使用方法一致
- break：打破循环，后续循环不再执行
- continue： 结束本次循环，进入下一次循环，不会影响循环次数
# break 打破循环,后续循环不会执行
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e了,结束循环')
break
print(i)
# continue 跳出本次循环,进入下一次循环,不会影响循环次数
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e了,进入下一次循环')
continue
print(i)
'''
案例：用for循环实现用户登录
① 输入用户名和密码
② 判断用户名和密码是否正确（username='admin'，password='admin888'）
③ 登录仅有三次机会，超过3次会报错
'''
# 循环三次
for i in range(3):
# 获取用户名和密码
username = input('请输入您的用户名:')
password = input('请输入您的密码:')
# 比对用户名和密码
if username == 'admin' and password == 'admin888':
print('登录成功')
break
else:
print('用户名或密码错误')
if i == 2:
print('三次机会已经用完,账号被冻结')
9、for循环嵌套
# 打印一个直角三角形
for i in range(1, 10):
for j in range(1, i+1):
print(f'{j} * {i} = {i * j}', end='\t')
print()
# 在for循环之外还可以调用i 或者j 么? 能
# 在Python中for循环中创建的临时变量可以被外界调用,但是不要用
# print(i)
# print(j)
# 使用for循环临时变量可能会出现报错
# for i in range(1,1):
# print(123)
# 当for循环执行后,没有一次进入循环体内,也就是遍历的序列是一个空序列,那么临时变量将不会被定义,所以不要使用
# NameError: name 'i' is not defined
# print(i)
知识点回顾
- 能够说出while循环语句的作用和语法格式
- 能够使用while语句完成循环
- 能够说出while语句嵌套的格式
- 能够说出for循环语句的作用和语法格式
- 能够使用 for 和 range函数完成循环
- 能够说出 break和continue的使用和区别
随堂练习
- 说出while循环的应用场景和语法格式
- 完成循环打印5次
hello world - 使用循环计算出 1-100 所有数字累加的和
- 使用循环计算出 1-100 之间偶数的和
- 使用while循环打印三角形
- 使用while循环完成九九乘法表
- 使用for循环完成 1-100之间偶数的和
- 说出 break和continue的区别
每日练习
题目1 （实操题）
题干
使用while循环计算1~100的累加和（包含1和100）
训练目标
- whlie循环的基本使用
训练提示
- whlie循环的基本格式是什么？
- while循环的条件（次数）和累加值的关系？
- 求和后重新赋值
参考方案
- 用一个“sum”的变量来存储求和后的数值
- 定义变量，控制循环次数
- 使用while循环，进行求和运算
操作步骤
- 定义一个变量“sum”，初始化赋值为“0”，保存求和的值
- 定义变量“i” ，用于控制循环次数
- while循环，当"i<=100"时跳出循环
- 累加和
- 变量“i”自增，确保循环能够正常跳出
参考答案
# 1. 定义循环起始值，求和变量sum
i = 1
sum = 0
# 2. 循环遍历数字
while i <=100:
#3. 累加数字
sum+=i
i+=1 # 记得累加循环因子值
# 4. 循环结束打印下计算结果
print("1~100之间的数字和是： %d" % sum)
题目2（实操题）
题干
使用while嵌套循环打印如下图形
*
* *
* * *
* * * *
* * * * *
训练目标
- while嵌套循环的使用
训练提示
- 使用while嵌套的形式打印图形
- 哪个循环控制的是行数，哪个循环控制的是列数？
- 内层循环的条件是什么？
- 如何让打印后不自动换行
参考方案
- while嵌套循环，外层循环代表的是行数，内层循环代表的是每行的个数（列）
- 内层循环个数是外层循环行数的值
- 打印print(" “,end=” ") end代表的是每次打印的时候以什么结尾，默认是“\n” 换行
操作步骤
- 定义外层循环，循环5次
- 定义内层循环，循环条件是外层循环的循环次数
- 打印“*” 设置 end=" " 修改自动换行
- 内层循环结束后打印一个换行
参考答案
# =================================== 嵌套循环版本 =====================
#1. 定义外循环因子
i = 1
while i<=5:
# 内层循环打印星号
j = 1 # 定义内存循环控制因子
while j<=i:
print("*",end=" ")
j+=1
# 打印换行,什么不指定利用缺省的打印换行
print()
i+=1
# =================================== 简化版本 =====================
# 1. 定义循环因子i
i = 1
# 2. 循环打印星号
while i<=5:
# 打印星号 字符与数字相乘则是重复当前字符指定次数
print("* " * i)
# 循环增加1
i+=1
题目3（实操题）
题干
编写代码模拟用户登陆。要求：用户名为 python，密码 123456，如果输入正确，打印“欢迎光临”，程序结束，如果输入错误，提示用户输入错误并重新输入
训练目标
- while中的break的使用
训练提示
- 定义变量，用户名和密码采用什么格式存储
- 循环没有次数限制，那么我们使用while循环的时候条件是什么？
- 判断用户名和密码是否相同，我们的条件采用“or"还是“and”？
- break的作用是什么
参考方案
- 首先我们要自己定义用户名和密码保存
- 如果用户错误那么就需要重新循环，我们就需要采用什么方式进行循环？
- 提示用户输入信息
- 判断输入信息，根据不同的结果进行不同的执行方式
操作步骤
- 定义名户名和密码分别为name = “python”，pwd = “123456”
- 使用循环，循环条件是True
- 提示用户输入用户名和密码
- 判断用户名和密码是否正确
- 如果正确跳出循环，不正确提示输入错误
参考答案
# 1. 初始用户名与密码
name = "python"
pwd = "123456"
# 2. 循环判断用户输入
while True:
# 3. 等待用户输入
user = input("请输入用户名: ")
password = input("请输入用户密码: ")
# 4. 判断用户输入匹配则登录成功结束，失败提示错误信息并让用户重新输入
if user==name and pwd == password:
print("欢迎光临")
break
题目4（实操题）
题干
设计“过7游戏”的程序, 打印出1-100之间除了7和7的倍数之外的所有数字，如果遇见7和7的倍数则打印“哈~”跳过本次循环。
训练目标
- while中的continue的使用
训练提示
- continue的作用是什么？
- 如何判断一个数是7的倍数
- 如果是7的倍数我们需要跳过本次循环进入到下一次循环
参考方案
- 我们如果打印1~100的数字？
- 当遇见了7的倍数，我们打印“哈~”后还如何做？
- 注意“i”的位置，不要放到continue的下面，会造成死循环
操作步骤
- 定义循环次数
- 使用while循环
- 判断当前值是否是7的倍数
- 如果是7的倍数那么我们需要打印“哈~”，并且跳过本次循环
参考答案
# 1. 初始化循环值
i = 1
# 2. 循环判断数字是否是7 的倍数
while i<=100:
# 3. 判断当前数字是否是7的倍数,则打印信息，继续下一轮循环
if i%7==0:
print("哈~")
i+=1 # 注意循环下次之前要对i增加1
continue
# 4. 打印数字
print(i)
# 5. 循环因子增加1
i+=1
拓展提高
题目5（实操题）
题干
已知变量如下：
a = "itheima"
从键盘上输入一个字母，判断此字母 是否在变量 a 中，如果在则输出 找到了， 如果不在 则输出 查无此字母
训练目标
- for…else的使用
训练提示
- 遍历此变量，判断这个 “i”,是否 等于 遍历得到的每个结果，如果等于，则说明 在变量 a中
- 注意在循环中 执行了break 后，else则不会执行
操作步骤
-
使用for 循环遍历变量a
-
判断遍历的结果是否 == 于 “i”， 如果等于， 则输出找到了，执行break
-
如果没找到， 则执行 else，输出 查无此字母
参考答案
#1. 定义变量
a = "itheima"
# 2. 接收用户输入
s = input("请输入查找的字符: ")
#3. 判断s是否在a中
for ss in a:
if ss==s:
print("找到了")
break
else:
print("查无字母")
题目6 （实操题）
题干
使用for循环计算从0到用户输入的值的累加和
训练目标
range()的使用
训练提示
- range()方法的作用
- for循环如何使用
- 累加重新辅助
参考方案
- 使用for寻遍遍历0~用户输入的值
- 进行累加重新赋值
操作步骤
- 定义变量sum，初始化sum=0
- 遍历0~用户输入的值 的所有的值
- 进行累加和
参考答案
#1. 接收用户输入 并转化成int
num = int(input("请输入数字: "))
# 2. 定义tatal计算数字和
total = 0
# 3. 循环累加
for i in range(num):
total+=i
# 4. 打印计算结果
print("计算结果是: ",total)
自主预习
题目7 （实操题）
题干：
获取用户输入的用户名和密码，用户名要求长度5-15位，密码要求 6-20位，如果不满足条件打印出对应的提示信息(比如：用户名不符合，打印出 用户名要求长度5-15位)，如果满足条件，输出用户输入的用户名密码，格式如下：
您输入的用户名是：xxx，密码为：xxxxxxx
训练目标
- 获取用户的输入
- 判断字符串的长度
参考步骤
- 定义变量获取用户输入的用户名和密码
- 使用len方法获得用户输入的字符串的长度
- 判断长度是否符合规则
参考答案
while True:
# 等地用户输入用户名与密码
username = input("请输入用户名: ")
if len(username)<5 or len(username)>15:
print("用户名不符合, 用户名要求长度5-15位")
continue
pwd = input("请输入密码: ")
if len(pwd)<6 or len(pwd)>20:
print("密码不符合, 密码要求长度6-20位")
continue
# 最后打印满足用户名密码要求
print("您输入的用户名是：%s，密码为：%s" % (username,pwd))
break
day04
1、循环中的else ★
- for…else…
- while…esle…
- 如果循环正常结束，则执行else中的代码，如果循环异常结束，不执行else中的代码
- break 可以打破循环造成循环异常结束
- continue不会造成循环异常结束
# 语法结构
'''
while 循环条件:
条件满足,则循环执行此代码
else:
循环条件不成立执行此代码,执行后循环结构终止
'''
# 需求: 下载一个视频 从0% - 100%,下载完成后,显示下载完成 否则不显示
# 循环条件成立,则反复执行循环体中的代码,如果循环条件不成立,则执行else中的代码
# break打破了循环结构,循环异常终止,没有执行到循环条件不成立的那一刻,所以else不会被执行
# continue没有打破循环结构,循环正常进入循环条件不成立的状态后才会终止,此时执行else中的命令
i = 0
while i <= 100:
if i == 60:
print('下载非法文件,已经将你举报,下载终止')
# break # 会造成循环异常终止,不会执行else中的代码
i += 1
continue # 不会造成循环异常终止,会执行else中的代码
print(f'下载进度:{i}%')
i += 1
else:
print('下载完成')
# 语法结构
'''
for 临时变量 in 数据序列(容器):
循环执行的代码
else:
所有元素遍历完成后执行的代码
'''
# 需求: 下载一个视频 从0% - 100%,下载完成后,显示下载完成 否则不显示
for i in range(0, 101):
if i == 60:
# print('别下了,网费用光了')
# break # 打破循环,造成循环异常结束,不会执行else 中的命令
print('丢包,这里没有下载好继续下载别的吧')
continue # 结束本次循环,进入下一次循环,不会造成循环异常结束,会执行else中的命令
print(f'下载进度:{i}%')
else:
print('下载完成')
2、字符串的定义以及输入输出
- 字符串定义方式
- 一对单引号
- 一对双引号
- 三对单引号
- 三对双引号
- 如果我们想输出单引号或者双引号，直接在最外层包裹其他的字符串定义形式即可
- 输入： input
- 输出：print
- 字符串可以进行格式化处理： f-string 传统占位符形式拼接
# 字符串的定义方式
# 单引号
str1 = 'hello world!!!' # <class 'str'>
print(type(str1))
# 双引号
str2 = "hello python" # <class 'str'>
print(type(str2))
# 三对单引号
str3 = '''hello bigdata''' # <class 'str'>
print(type(str3))
# 三对双引号
str4 = """hello china""" # <class 'str'>
print(type(str4))
# 一对引号和三对引号的区别
# 在一对引号内部进行手动换行,无法修改其字符串的格式,必须使用转义字符\n \t等
str1 = 'hello ' \
'world'
print(str1)
# 在三对引号内进行手动换行,可以在打印时输出换行格式,无需使用转义字符
str3 = '''hello
bigdata'''
print(str3)
str4 = """
弃我去者昨日之日不可留
乱我心者今日之日多烦忧
长风万里送秋雁
对此可以酣高楼
......
"""
# 三对引号可以作为多行注释
# 需求 : 输出 I'm Jake.
# 如果字符串被双引号包裹,则内部可以单独使用单引号
print("I'm jake")
# 需求:输出"鲁迅说:I'm a 周树人"
print('''"孔子说:I'm a 文豪"''')
# 输入 input
user_name = input('请输入你的用户名')
# 输出
print(f'您的用户名是{user_name}')
print('您输入的用户名是%s' % user_name)
3、字符串索引 ★ [ ]
- 索引就是系统给字符串中每一个元素的编号
- 正数索引：从0开始，从左至右依次递增
- 负数索引：从-1来时，从右至左依次递减
- 使用索引可以获取字符串中的元素
- 字符串[元素的索引]
# 什么是字符串索引?
# 就是保存字符串时,将所有字符依次存入字符串所在空间,并且按照顺序将元素依次存放, 为了方便存取数据,我们讲元素进行编号,从0开始依次递增
# 通过下标索引,可以获取元素,或者进行切片等操作
str1 = 'itheima'
# 通过索引获取元素的格式: 字符串[元素索引]
# 需求:想获取第5个元素
print(str1[4])
# 需求:获取t
print(str1[1])
'''
i t h e i m a
# 正数索引
0 1 2 3 4 5 6
# 负数索引
-7 -6 -5 -4 -3 -2 -1
'''
# 结论:字符串中的索引,正数索引从0开始,从左至右依次递增, 负数索引,从-1开始从右至左依次递减
# 需求:使用负数索引取 m
print(str1[-2])
print(str1[-4])
4、字符串切片 ★ [ ]
- 字符串切片就是讲字符串中的一部分数据按照指定规则进行分隔得到的新的字符串
- 字符串切片的格式
字符串[起始位置索引：终止位置索引：步长]
- 起始位置可以省略：
- 步长为正：起始位置默认为字符串开始
- 步长为负：起始位置默认为字符串结束
- 终止位置可以省略：
- 步长为正：终止位置默认为字符串结束
- 步长为负：终止位置默认为字符串开始
- 步长可以省略，省略后默认为1，并且可以省略冒号
- 复制字符串：str[:]
- 反转字符串：str[::-1]
- 注意：如果步长为正，则起始位置在终止位置左侧，如果步长为负，则起始位置在终止位置右侧
# 切片:就是按照一定的索引位置和步长将字符串分割出一部分就是切片
# 切片的格式:数据序列[起始位置索引:结束位置索引:步长] 字符串,列表,元组,都可以进行切片
str1 = 'itheima'
# 需求:将the切片出来
# 字符串切片以及其他容器类型的切片操作,都会重新生成一个新的数据序列,不会对原有数据序列产生影响
str2 = str1[1:4:1]
print(str2)
# 切片逻辑
# 起始位置: 字符串切片的起点(包含)
# 结束位置:字符串切片的终点(不包含)
# 在开发中绝大多数范围区间是左闭右开区间,其余内容单独记忆(例如 randint是一个闭区间)
# 步长:步长就是每一次查找数据的间隔(相邻两个索引的差值就是步长)
str2 = '我爱北京天安门,天安门上太阳升!'
# 获取"北京天安门"
print(str2[2:7:1])
# 如果步长为1 可以被省略
# 步长省略后,:也可以省略
print(str2[2:7])
# 起始位置也可以省略
# 如果起始位置省略,步长为正数,则起始位置为字符串开始
print(str2[:7:1]) # 我爱北京天安门
# 如果起始位置省略,步长为负数,则起始位置为字符串末尾
print(str2[:7:-1]) # !升阳太上门安天
# 为什么为空? 字符串切片起点 是索引为2 的位置, 步长是-1 切片区间[2,7),此时从2的位置从右向左步长为1 切片此区域没有数据.
print(str2[2:7:-1]) # 空字符串
# 结论: 如果步长是负数,开始位置要在结束位置右侧,否则没有数据
# 结束位置可以省略
# 如果结束位置省略,步长为正数,则结束位置为字符串末尾
print(str2[8::1]) # 天安门上太阳升!
# 下方表达式和上一行是否含义相同? 不相同,因为结束位置写-1不包含结束位置
print(str2[8:-1:1]) # 天安门上太阳升
# 如果结束位置省略,步长为负数,则结束位置为字符串开始
print(str2[8::-1]) # 天,门安天京北爱我
# 如果结束位置写0 含义也不相同
print(str2[8:0:-1]) # 天,门安天京北爱我
# 需求:在字符串中截取"天门天门"
print(str2[4: 11: 2]) # 天门天门
# 在使用字符串切片进行非1步长书写时,要注意起始位置和结束位置,并且查看间隔
# Python中优雅的字符串反转方式
print(str2[::-1]) # !升阳太上门安天,门安天京北爱我
# python中复制数据序列的方法
str3 = str2[:]
print(str3) # 我爱北京天安门,天安门上太阳升!
5、字符串查询 ★ index find rindex rfind
- index：查找字符串中子字符串所在位置i，如果有该字符串，查询其从左至右第一次出现的位置的正数索引，否则报错。
- find：查找字符串中子字符串所在位置i，如果有该字符串，查询其从左至右第一次出现的位置的正数索引，否则返回-1。
- rindex：查找字符串中子字符串所在位置i，如果有该字符串，查询其从右至左第一次出现的位置的正数索引，否则报错。
- rfind：查找字符串中子字符串所在位置i，如果有该字符串，查询其从右至左第一次出现的位置的正数索引，否则返回-1。
- count：查询子字符串在指定字符串中出现的次数。
str1 = 'hello python'
# index
# 需求:查找p所在的索引位置
# 格式: 字符串.index(self(不用传值), sub(子字符串), start(起始位置), end(结束位置))
print(str1.index('p')) # 6
# 如果字符串中含有多个子字符串,则会返回指定范围内的从左至右的第一个查找到的子字符串位置索引
print(str1.index('o')) # 4
# 查询指定范围内的字符串,虽然指定了范围,但是计算索引是从左至右依次递增的
print(str1.index('o', 5, 12)) # 10
# ValueError: substring not found
# 结论:找不到对应的子字符串,则会报错,如果能够查找到数据返回当前子字符串的正数索引
# 指定查找范围是左闭右开区间
# print(str1.index('o', 5, 10)) # 10
print(str1.index('o', 10, 12)) # 10
# find
str1 = 'hello python'
# 需求:查找p所在的索引位置
# 格式: 字符串.find(self(不用传值), sub(子字符串), start(起始位置), end(结束位置))
print(str1.find('p')) # 6
# 如果字符串中含有多个子字符串,则会返回指定范围内的从左至右的第一个查找到的子字符串位置索引
print(str1.find('o')) # 4
# 指定范围查找
# 需求:查找o 指定范围为 5,10 10,12
# 结论:使用find进行查询时,如果查询的子字符串不存在,则返回-1,如果存在则返回指定正数索引
# find的查询范围是左闭右开区间
print(str1.find('o', 5, 10))
print(str1.find('o', 10, 12))
# 查询的子字符串可以是单个字符可以是多个字符
print(str1.find('python')) # 6
# rfind
# 和find使用方式完全相同,只是在查询时,从右至左查询,返回第一次查询到的字符索引,返回的依然是正数索引
print(str1.rfind('o')) # 10
# rindex
# 和index使用方式完全相同,只是在查询时,从右至左查询,返回第一次查询到的字符索引,返回的依然是正数索引
print(str1.rindex('o'))
# 结论:index 和 find 使用方法完全一致,只是,index 在查询不到子字符串时会报错,find会返回-1
# count() 计数
# 使用count 可以返回当前子字符串在指定字符串中出现的次数
# 需求:查询o在str1 中出现的多少次
# 提示:在大多数编程语言中, 计数从1开始数, 索引或编号,从0开始编号
# 格式: 字符串.count(self(不用传值, x(要查询个数的子字符串), start(开始位置), end(结束位置)))
print(str1.count('o'))
# 需求,查询指定范围内h的个数 从1-9 9-12
# 结论:1.count查询的范围是一个左闭右开区间
# 2.如果没有查询到子字符串则返回0 不会报错
print(str1.count('h', 1, 9)) # 0
print(str1.count('h', 9, 12)) # 1
6、字符串替换 ★ replace
- replace：将旧值替换指定字符串中的新值
# replace
str1 = 'hello python'
# 需求: 将o 替换为 $
# 格式: replace(self(不用传值), old(旧值), new(新值), count(替换次数))
print(str1.replace('o', '$')) # hell$ pyth$n
# 指定替换次数
# 如果不指定替换次数,默认将所有的制定字符全部替换
print(str1.replace('o', '$', 1)) # hell$ python
# 如果指定的替换次数大于出现的次数,则也是只替换出现的次数
print(str1.replace('o', '$', 10)) # hell$ python
7、字符串的拆分和合并 ★ split join
- split：字符串按照指定分隔符进行拆分
- 拆分后得到的结果是有拆分后的字符串组成的一个列表
- 拆分后，所有的分隔符消失
- join：将字符串序列（容器类型中所有元素均为字符串）按照指定分隔符进行合并
# split 字符串拆分
str1 = 'I love Python and java and c and lixiaolong'
# 需求: 将所有的单词按照空格为分隔符进行拆分,拆分为多个字符串
# split 会按照指定分隔符进行拆分,拆分完成后 会将所有的拆分后的结果以字符串形式保存到列表中
# split(self(不用传值), sep(分隔符), maxsplit(最大分割次数))
print(str1.split()) # ['I', 'love', 'Python', 'and', 'java', 'and', 'c', 'and', 'lixiaolong']
# 指定最大分割次数
# 可以把split看成一把刀,字符串看成一条线,砍一刀分成两份,砍两刀分成3分以此类推
print(str1.split(' ', 3)) # ['I', 'love', 'Python', 'and java and c and lixiaolong']
# 需求:按照以'a'为分割符进行拆分,将str1 最大拆分次数60次
# 使用谁作为分隔符,则拆分后该分隔符消失,
# 最大拆分次数如果超过可以拆分的上限,则保持拆分上线即可,不会报错
print(str1.split('a', 60)) # ['I love Python ', 'nd j', 'v', ' ', 'nd c ', 'nd lixi', 'olong']
# join 字符串合并
list1 = str1.split()
list2 = [1,2,3,4,'abc']
print(list1)
# 将list1 按照指定分隔符❤ 合并为一个字符串
# 格式:分隔符.join(iterable(可迭代类型))
print('❤'.join(list1)) # I❤love❤Python❤and❤java❤and❤c❤and❤lixiaolong
# 进行join合并时,要注意可迭代类型中全部元素都要是字符串类型,否则无法合并
print('❤'.join(list2)) # TypeError: sequence item 0: expected str instance, int found
8、字符串转换 ★ capitalize title upper lower
- capitalize：将字符串首字母大写，其余字母小写
- title： 将字符串中每个单词首字母大写（任何非字母字符都可以作为单词分隔符）
- upper：将字符全部变为大写
- lower：将字符全部变为小写
# 字符串中各种大小写转换
str1 = 'hello woRld aNd Python'
# capitalize 将字符串的第一个字母大写,同时讲其余全部字母小写, 对数字和汉字等不做处理
print(str1.capitalize()) # Hello world and python
# title 将所有的单词首字母大写,其余字母变为小写
# 在Python中怎样对单词进行辨别, 非字母字符都可以作为分隔符
str2 = 'hello中国python'
print(str1.title()) # Hello World And Python
print(str2.title()) # Hello中国Python
# upper()将数据全部变为大写
print(str1.upper()) # HELLO WORLD AND PYTHON
# lower()将字符全部变为小写
print(str1.lower()) # hello world and python
9、字符串两侧指定字符删除 ★ strip rstrip lstrip
- strip：删除字符串两侧的指定字符
- rstrip：删除字符串右侧的制定字符
- lstrip：删除字符串左侧的指定字符
# strip 去重字符串左右两侧指定字符
str1 = ' hello python\t \n '
# strip中如果不传参数,则去除字符串左右两侧的空白(包括空格,换行,制表位等)
print(str1.strip()) # hello python
# 格式:字符串.strip(self(不传值), chars(可以传一个字符或多个字符))
str2 = '$$$hello Python$$$'
# 删除字符串左右两侧的$符号
# 删除一个指定字符
print(str2.strip('$')) # hello Python
# 删除多个指定字符
str3 = '13214123123hello Python12314123123123'
print(str3.strip('12')) # 314123123hello Python12314123123123
print(str3.strip('123')) # 4123123hello Python12314
print(str3.strip('4231')) # hello Python
# 结论:如果在strip中填写多个字符,等号左右两侧出现的字符如果在传入的字符串中,则删除,否则保留
# 传入多个字符时,和传入的顺序没有任何关系,只要是传入的字符就不能出现在指定字符串左右两侧,直到出现不属于其内容的字符删除结束
# rstrip 删除字符串右侧指定的字符
print(str3.rstrip('1234'))
# lstrip 删除字符串左侧指定的字符
print(str3.lstrip('1234'))
# TypeError: lstrip arg must be None or str
# strip, lstrip, rstrip 只能接收str类型参数或者None
# print(str3.lstrip(1234))
10、字符串对齐 ★ just center
- rjust：右对齐
- ljust：左对齐
- cneter： 居中对齐
str1 = 'python'
# rjust 右对齐
# 字符在右侧,不足位置用空格补齐
# 如果不指定填充字符,则自动用空格补齐
print(str1.rjust(10)) # python
# 格式:字符串.rjust(self(不用传值), width(字符宽度), fillchar(填充字符))
# 指定填充字符 为$
print(str1.rjust(10, '$')) #$$$$python
# ljust 左对齐
# 和rjust使用方式一致,只不过字符在左侧
print(str1.ljust(10)) # python
print(str1.ljust(10, '$')) # python$$$$
# center 居中对齐
# 格式: center(self(不用传值), width(字符宽度), fillchar(填充字符))
print(str1.center(10)) # python
print(str1.center(10, '*')) # **python**
11、字符串判断 ★
- 所有的字符串判断结果都是布尔型数据
- isalnum：判断是否都为字母或数字
- isalpha：判断是否都为字母
- isdigit：判断是否都为数字
- isspace：判断是否都为空格
- endswith：是否以。。结尾
- startswith：是否以。。开头
- 其余内容自己测试学习
# 判断字符串内的数据是否符合某种规则
str1 = 'hello itcast'
# startswith 判断是否以...开头
# 需求:判断当前字符串是否以he开头
# 结果是布尔值
print(str1.startswith('he')) # True
print(str1.startswith('al')) # False
# 指定范围 左闭右开区间
print(str1.startswith('he', 6, 12)) # False
print(str1.startswith('it', 6, 12)) # True
# endswith 判断是否以...结尾
print(str1.endswith('st')) # True
print(str1.endswith('al')) # False
# 指定范围的方式与startswith一致,不在赘述
# is 判断
# isalnum 判断是否全部为数字或字母 不能有空格
print(str1.isalnum()) # False
# isspace 判断是否全部为空格
str2 = ' '
print(str2.isspace()) # True
# isnumeric isdecimal isdigit 都是判断是否为数字的
str3 = '1234'
print(str3.isnumeric()) # True
print(str3.isdecimal()) # True
print(str3.isdigit()) # True
# 判断中文数字
str4 = '123四肆④亖零〇'
print(str4.isnumeric()) # True 这个方法可以判断中文数字和罗马数字和阿拉伯数字
print(str4.isdecimal()) # False
print(str4.isdigit()) # False
# isidentifier判断是否为标识符
str5 = '2abc'
str6 = 'apple'
print(str5.isidentifier()) # False
print(str6.isidentifier()) # True
# isalpha 判断是否全部为字母
print(str6.isalpha()) # True
print(str5.isalpha()) # False
str7 = 'abc中国'
# 默认将中文当做字母来看
print(str7.isalpha()) # True
# 如果强制判断字母和汉字区分开(了解即可)
print(str7.encode('utf-8').isalpha()) # False
print(str6.encode('utf-8').isalpha()) # True
当天知识点回顾
- 能够知道常用的 Python 容器有 字符串、列表、元组、字典
- 能够知道知道在Python中 单引号或者双引号或者三引号中的数据，就是字符串。
- 能够使用
s% 和 f-strings语法完成字符串的输出 - 能够知道使用 input 函数 获取到的数据类型是字符串
- 能够字符串的下标的使用和知道下标是从 0 开始的。
- 能够知道切片的语法
[起始:结束:步长] - 能够记住五个字符串常见的操作方法
find、replace、split、strip、join
随堂练习
- 写出字符串的几种格式。
- 使用字符串格式化操作符完成名片的打印。
- 使用
f-strings完成名片的打印 - 使用 input 函数实现用户输入两个数字，计算出两个数字的和。
- 给定字符串 “abcdefghi”，使用切片取出 下标 0-4 的字符。
- 根据课件练习字符串常见操作的方法。
每日练习
题目1（实操）
题干
如果需要使用变量保存以下字符串，我们该如何书写代码
鲁迅说:"我没有说过这句话"
训练目标
让学员知道含有字符串嵌套的方式
训练提示
在python中，有两种表现形式都可以定义为字符串类型，是哪两种方式，是否可以混合使用呢
参考方案
使用 " " 和 ’ ’ 都可以对字符串进行定义
操作步骤
使用""嵌套’'嵌套的方式定义字符串
参考答案
words = '鲁迅说:"我没有说过这句话"'
题目2（实操题）
题干
做一个简单的用户信息管理系统：
提示用户依次输入姓名，年龄和爱好
并且在输入完成之后，一次性将用户输入的数据展示出来
训练目标
字符串的声明
字符串的输入
字符串的输出
训练提示
- 在python中，通过 “” 或者 ‘’ 声明一个字符串类型的变量
- 使用input（）函数从键盘获取数据
- 通过%s 的格式化操作符来输出字符串类型
参考方案
- 通过input函数进行字符串数据的录入
- 使用 string 类型保存录入的数据
- 使用 %s 格式化输出保存的数据
操作步骤
- 通过input函数进行字符串数据的录入
- 使用 string 类型保存录入的数据
- 使用 %s 格式化输出保存的数据
参考答案
# 1. 通过input函数进行字符串数据的录入
name = input("请输入您的姓名: ")
age = input("请输入你的年龄: ")
love = input("请输入你的爱好: ")
# 2. 使用 %s 格式化输出保存的数据
print("姓名: %s\t年龄: %s\t爱好: %s" % (name,age,love))
题目3（实操题）
题干
现有字符串如下，请使用切片提取出ceg
words = “abcdefghi”
训练目标
字符串的切片使用
训练提示
1， 切片的语法：[起始:结束:步长]
2， 选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，
3， 步长表示选取间隔，默认步长是正值，即从左到右选取，如果步长为负值，则从右向左选取
参考方案
1，使用切片进行截取，起始位置是-7，结束位置是-1
2，反向选取，步长为2
操作步骤
- 起始位置为-7，结束位置是-1，步长为2
参考答案
words = "abcdefghi"
print(words[2:-1:2]) # 正向
print(words[-7:-1:2]) # 反向
题目4（实操题）
题干
james有一个关于爬虫的项目，他需要在一个字符串中查找python这个关键字，
当前他通过index()函数进行查找，虽然可以实现查找的需求，但是总会在
没有查找到关键字的时候报错，为什么会报错，如何优化？
训练目标
- 理解find函数和index函数的区别
训练提示
- find函数如果查找到则返回索引值，如果查不到，则返回-1
- index函数如果查找到则返回索引值，如果查不到，则报错
参考方案
- 通过使用find函数的方式替换掉index
操作步骤
- 通过使用find函数的方式替换掉index
参考答案
# 注意index 没有找到会报错误，这个需要等我们学了异常以后就可以处理
s= "agagagag"
loc = s.find("python")
if loc>0:
print(loc)
else:
print("没有找到")
题目5 (实操题)
题干
1，判断单词great是否在这个字符串中，如果在，则将每一个great后面加一个s， 如果不在则输出 great不在该字符串中
2，将整个字符串的每一个单词都变成小写，并使每一个单词的首字母变成大写
3，去除首尾的空白，并输出处理过后的字符串
训练目标
- 字符串的相关操作
训练提示
- 字符串的相关操作来解决上述问题
- 使用判断语句来判断语句成立的条件
参考方案
- 使用in判断某一个子字符串是否在母字符串中
- 使用replace函数替换子字符串
- 使用lower函数将字符串变为小写
- 使用title函数将单词的首字母大写
- 使用strip函数去除字符串首尾的空白
操作步骤
- 使用in判断某一个子字符串是否在母字符串中
- 使用replace函数替换子字符串
- 使用lower函数将字符串变为小写
- 使用title函数将单词的首字母大写
- 使用strip函数去除字符串首尾的空白
参考答案
# 1. 要处理的字符串
s = " wlcome tO XXxxx, great abc efg haha! "
# 2. 去除收尾空格
s = s.strip()
print("去除空格后:%s" %s)
# 3. 替换great为greats
if 'great' in s:
s = s.replace("great","greats")
print("great->greats:%s" % s)
# 4. 字符都转化成小写
s = s.lower()
print("转化字母为小写:%s" % s)
# 5. 首字母大写
s = s.title()
print("最后处理效果: %s" % s)
自主预习
题目8 （实操题）
题干
将下列两个列表合并，将合并后的列表去重，之后降序并输出
list1 = [11, 45, 34, 51, 90]
list2 = [4, 16, 23, 0]
训练目标
列表操作方法的使用
训练提示
1， 列表直接可以直接拼接，元素会合并到同一个列表中
2， 可以使用sort对列表进行排序
参考方案
1，使用 + 对列表进行拼接
2，使用set方法将列表转变成集合，以便于去重，
3，使用sort函数，参数reverse=True对列表进行倒序排序
操作步骤
1，使用 + 对列表进行拼接
2，使用set方法将列表转变成集合，以便于去重，
3，使用sort函数，参数reverse=True对列表进行倒序排序
参考答案
list1 = [11, 45, 34, 51, 90]
list2 = [4, 16, 23, 0]
# 1. 合并列表
list3 = list1+list2
# 2. 利用set特点去重列表
list3 = list(set(list3))
#3. 排序列表
list3.sort(reverse=True)
#4. 打印下结果
print(list3)
题目9 （实操题）
题干
有如下两行代码：
tuple1 = (2)
tuple2 = (2,)
请问tuple1与tuple2有什么不同
训练目标
让学生知道含有元素的元组的定义的方式
训练提示
通过肉眼能看到的只是一个逗号的区别，那么在python里面他是怎么理解的呢？
参考方案
用type（）方法来分别对这两个变量进行区别
操作步骤
用type(tuple1),与type(tuple12)的结果进行比较
参考答案
tuple1 = (2)
tuple2 = (2,)
print(type(tuple1)) # int
print(type(tuple2)) # tuple
Day05
1、列表的查询 ★
- index：从左至右查询元素在列表中所处的位置，如果查询到该元素返回其第一次出现所在位置的正向下标，如果不存在则报错
- count：查询指定元素在列表中出现的次数
- in：查询指定元素是否在列表中
- not in：查询指定元素是否不在列表中
# 索引查询
name_list = ['Bob', 'Jack', 'Rose']
# print(name_list[0]) # Bob
# print(name_list[1]) # Jack
# print(name_list[2]) # Rose
# print(name_list[-1]) # Rose
# print(name_list[-2]) # Jack
# print(name_list[-3]) # Bob
# 结论: 列表中的索引和字符串中完全一致,
# 正向索引从0开始,从左至右依次递增
# 负向索引,从-1开始,从右至左依次递减
# index 查询指定元素在列表中的索引,如果查询成功则返回该元素的正向索引,否则报错
# index 是从左至右查询,返回第一次出现的索引位置
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 5]
# 会返回从左至右第一次查询到的数据索引
print(num_list.index(5)) # 4
# ValueError: 9 is not in list
# 如果没有查询到数据则会报错
# print(num_list.index(9))
# rindex 在列表中没有这个方法
# AttributeError: 'list' object has no attribute 'rindex'
# print(num_list.rindex(5))
# find 在列表中没有这个方法
# AttributeError: 'list' object has no attribute 'find'
# print(num_list.find(5))
# count 计数, 查询指定元素在列表中出现的次数
print(num_list.count(5)) # 2
# in 判断数据元素是否在列表内 如果在 True 如果不在False
# TypeError: argument of type 'int' is not iterable
# print(num_list in 5)
# 注意使用in或者not in 数据元素在左边, 列表或者其他数据序列在右侧
print(5 in num_list) # True
print(9 in num_list) # False
# not in 判断数据元素是否不在列表内 如果不在 True 如果在False
print(5 not in num_list) # False
print(9 not in num_list) # True
2、列表的增加 ★
- append： 在类表的末尾追加数据
- extend：将数据序列进行迭代依次提取出每一个元素添加到列表末尾
- insert：在指定位置追加数据元素
# append 在列表末尾追加数据
num_list = [1, 2, 3, 4]
# 能够打印出1,2,3,4,5么?
# print(num_list.append(5)) # None
# 如果直接打印append方法的调用,将不会输出任何内容
# list类型在使用append 方法时不会产生新的列表,而是在原有列表上进行修改
num_list.append(5)
# append 追加的数据,默认追加到列表末尾,追加完成后在原有数据上修改
print(num_list) # [1, 2, 3, 4, 5]
# # str
# str1 = 'abc'
# # str类型数据,调用replace方法时,不会修改原有数据,而是产生了一个新的字符串
# str2 = str1.replace('abc', 'cba')
# print(str1)
# print(str2)
# extend 追加数据序列
# 格式: 列表1.extend(数据序列)
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 追加数据序列后,调用extend的列表发生变化, 括号内的数据序列不变
# 其实底层逻辑就是讲括号内的数据序列迭代,依次放入调用该方法的列表中
list1.extend(list2)
print(list1) # [1, 2, 3, 4, 5, 6]
print(list2) # [4, 5, 6]
# 追加字符串序列时,会将字母依次拆分并放入列表中
str1 = 'itcast'
list2.extend(str1)
print(list2) # [4, 5, 6, 'i', 't', 'c', 'a', 's', 't']
# 如果括号内填写的数据,不是数据序列会怎样?
# TypeError: 'int' object is not iterable 括号内必须是可迭代对象
# list2.extend(4)
# 字符串累心哪怕只有一个值,或者只有一个空字符串,都是可迭代类型,同理可知,列表,元组等 哪怕只有以数据或者为空类型也是可迭代类型
list2.extend('3')
print(list2)
# insert 插入
num_list = [1, 2, 3, 4]
# 格式:列表.insert(要插入位置的索引, 要插入的对象)
# 在insert中第一个参数是要插入位置的索引,所以如果插入了数,则该被插入数据的索引变为第一参数所显示的索引
# 原来该位置的元素以及之后的元素下标+1(向后移动一位)
# 如果使用insert进行 插入,可能会造成索引混乱,原来引用的索引发生错误
# 在开发中除非明确所有的索引引用都修改完成,否则不要使用insert
# append 插入数据,要比insert插入数据更安全
num_list.insert(1, 5)
print(num_list)
# extend 和append 进行对比
list1 = [1, 2, 3, 4]
list2 = [5, 6, 7, 8]
# append将list2 当做一个元素追加到列表末尾
# list1.append(list2) # [1, 2, 3, 4, [5, 6, 7, 8]]
# extend将list2 当做多个元素进行拆分后追加
list1.extend(list2) # [1, 2, 3, 4, 5, 6, 7, 8]
print(list1)
3、列表中的删除 ★
-
del 先对列表中的元素进行查找（使用下标），找到后使用del删除
-
pop：删除类表中指定下标位置的元素，如果不指定默认删除最后一个，并且返回被删除的值
-
remove：删除指定值的下标，只删除丛左至右的第一次出现的该值元素
-
clear：清空列表，和重新赋值为空有逻辑上的区别。
# del 将数据引用切断
list1 = [1, 2, 3, 4]
# del list1
# NameError: name 'list1' is not defined
# del不仅可以删除元素,也可以删除任何变量,非常强大,但是有些不安全
# print(list1)
# 那del 怎样删除元素呢? 通过索引获取当前元素,并删除
del list1[2]
# IndexError: list assignment index out of range
# 使用下标查找数据时,下标索引不能不存在
# del list1[9]
print(list1) # [1, 2, 4]
# 如果要是循环中能够删除么?
# 此处并没有删除,因为i是临时变量,我们使用del是在讲i和2的引用关系删除,但是list1 和 2 的引用关系没有删除
# for i in list1:
# if i == 2:
# del i
#
# print(list1)
# pop 删除指定索引的元素,并且返回该元素
list1 = [1, 2, 3, 4]
# 删除后可以返回被删除的对象
print(list1.pop(2))
# IndexError: pop index out of range
# 使用pop进行删除的元素下标一定要存在
# print(list1.pop(12))
# 删除后,指定索引位置的元素消失后边的元素统一向左移动一位
# pop也会造成索引变换
print(list1)
# 如果不给pop进行传值,默认删除最后一个元素
print(list1.pop())
# 查看删除后结果
print(list1)
# remove 删除指定的元素(从左至右第一次出现的元素)
list1 = [1, 2, 3, 3, 4, 2, 1]
# 删除列表中的2
# 将从左至右查询第一次遇到的2进行了删除,并不能删除类表中所有的的2
list1.remove(2)
print(list1) # [1, 3, 3, 4, 2, 1]
# remove会返回被删除的内容? 不会
print(list1.remove(3)) # None
# remove删除的内容不存在会怎样?
# list1.remove(123) # ValueError: list.remove(x): x not in list
# clear 清空列表
# 就是讲列表置为[],但是与list1 = [] 有本质区别
list1.clear()
print(list1) # []
4、列表的修改 ★
- 使用索引修改： 列表[索引] = 新值
- 查询列表索引值必须在列表中存在
- reverse: 列表的反转
- sort：列表的排序，默认为升序
- reverse：可以进行列表倒排，降序
- key:添加函数，使排序规则更加复杂多变
# 通过索引进行修改
list1 = [1, 2, 3, 4]
# 通过索引查找到指定位置的数据,并进行修改
list1[1] = 6
# IndexError: list assignment index out of range
# 获取的元素位置,必须是存在的
# list1[6] = 6
print(list1)
# 通过索引修改可以同时修改多个值么? 不能
# list1[(2,3)] = 6,7
# 可以使用对多变量赋值的形式修改多个值
list1[2], list1[3] = 6, 7
print(list1)
# reverse 列表的反转
list1 = [1, 2, 3, 4]
# 列表反转后,索引倒置,并且在原数据上修改,没有产生新的列表
print(list1.reverse()) # None
print(list1) # [4, 3, 2, 1]
# sort 排序
list2 = [2, 6, 43, 2, 41, 421]
# sort是对原有的数据进行了排序,没有产生新的列表.同时,默认排序规则为升序
# print(list2.sort()) # None
# print(list2) # [2, 2, 6, 41, 43, 421]
# 如果我想让列表降序排列怎么办?
# 方法一:可以先排序再反转
# list2.sort()
# list2.reverse()
# print(list2) # [421, 43, 41, 6, 2, 2]
# 方法二: 可以直接使用倒叙排列
# list2.sort(reverse=True) # [421, 43, 41, 6, 2, 2]
# print(list2)
# list2.sort(key=排序规则函数)可以帮助我们进行更加复杂的排序
# 根据每个元素 % 7 的余数大小进行排序
# 了解, 不要求掌握 后续会讲
list2.sort(key=lambda x: x % 7)
print(list2)
5、列表遍历 ★
- for遍历
- while遍历
# while遍历列表
# len()函数可以查询列表的长度
list1 = [12, 123, 1, 1, 1234, 12, 34, 8]
# print(len(list1))
i = 0
while i < len(list1):
print(list1[i])
i += 1
# for 遍历列表
# 推荐使用for循环遍历容器类型(数据序列)
for i in list1:
print(i)
6、列表的嵌套
- 列表中嵌套其他的子列表，就是列表的嵌套
- 嵌套后的列表可以使用循环嵌套来进行遍历
# 列表的嵌套: 在一个列表中包含其他的列表元素
name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]
# 需求:想要获取李四的值
# 获取李四所在的子列表的索引,并通过索引获取该子列表值
print(name_list[2])
# 再从子列表中通过李四所在的索引获取其值
print(name_list[2][1])
# 如果我们想要获取嵌套列表中的每一个值,我们需要怎么做?
# 如果进行一次循环,每次循环所得到的都一级列表中的元素,也就是每一个子列表
for i in name_list:
print(i)
# 如果想要对嵌套后的列表进行输出,需要进行循环嵌套
for sub_list in name_list:
for name in sub_list:
print(name)
# 这样就可以进行所有名称的输出了
# 如果当前的列表内的数据不都是子列表,有其他数据类型的数据,则不能直接使用循环嵌套,需要先进行类型判断
7、元组的定义 ★
- 单元素元组： 变量 = （数据，）
- 多元素元组：变量 = （数据1， 数据2， 数据3…）
# 元组:可以储存多个数据,但是元组内的数据不能被修改(元定义后只能被查询)
# 元组的定义:变量 = (数据1, 数据2, 数据3......)
tuple1 = (1, 2, 3, 4)
# 打印后可以展示元组中的全部信息
print(tuple1) # (1, 2, 3, 4)
# 查询数据类型
print(type(tuple1)) # <class 'tuple'>
# 如果元组中只有一个元素怎么办? 在单一元素后添加逗号
tuple2 = (10)
print(type(tuple2)) # <class 'int'>
tuple3 = ('10')
print(type(tuple3)) # <class 'str'>
tuple4 = (10,)
print(type(tuple4)) # <class 'tuple'>
# 如果小括号包裹单一元素数据不添加逗号,则小括号的意义是提升算术运算符优先级
# 在定义元素或者传值时,元组的括号可以省略
tuple5 = 1, 2, 3, 4, 5
print(tuple5) # (1, 2, 3, 4, 5)
print(type(tuple5)) # <class 'tuple'>
tuple6 = 5,
print(tuple6) # (5,)
print(type(tuple6))
tuple7 = (1,2,3,)
print(tuple7)
8、元组的相关操作 ★
- 元组中的数据不能增删改，所以只能查询
- 元组的查询方式
- 索引查询：和列表的使用方式一致
- index ：从左至右查询指定元素在元组中第一次出现的位置索引，如果存在则返回正向索引，如果不存在则报错
- count：查询指定元素在元组中出现的次数
- len：查询元组的长度：也就是查询元组中元素的个数
# 元组的增删改:由于元组中的数据不可修改,所以元组中的数据不能进行增删改操作
tuple1 = (1, 2, 3, 4)
# 修改
print(tuple1[2])
# TypeError: 'tuple' object does not support item assignment
# 元组中的数据不能修改
# tuple1[2] = 6
# 删除
# TypeError: 'tuple' object doesn't support item deletion
# 元组中的数据不能删除
# del tuple1[2]
# 查询
# 通过索引进行查询
# 查询方法和列表一致
# 正向索引,从0开始,从左至右依次递增
# 负向索引,从-1开始,从右至左依次递减
tuple1 = (1, 2, 3, 4, 3)
# 需求:通过正向索引取出3
print(tuple1[2])
# 需求:通过负向索引取出3
print(tuple1[-2])
# index 查询指定元素在元组中所在的位置索引
# 需求:查询3所对应的索引值
# index是从左至右依次查询,返回第一个查到的数据的正向索引值
print(tuple1.index(3)) # 2
# 如果查询的内容不存在,则报错
# print(tuple1.index(8)) # ValueError: tuple.index(x): x not in tuple
# count 查询指定元素在元组中出现的次数
print(tuple1.count(3)) # 2
print(tuple1.count(1)) # 1
# len 查询元组的长度(对所有容器适用) 长度就是计算当前容器中有多少个元素
print(len(tuple1)) # 5
# 其实len()就是调用了括号内对象的__len__方法
print(tuple1.__len__()) # 5
9、字典的定义 ★
- 格式：变量 = {key1 : value1, key2: value2…}
- 空字典定义：
- {}
- dict（）
- 字典中键不能重复，是唯一的，但是值可以重复
- 字典中的键要见名知意，体现字典可以见名知意的特性
# 字典:储存多个数据,以键值对形式存储,方便快速存取
# 字典的键要见名知意
# 字典定义格式: 变量 = {键1:值1, 键2:值2.....}
dict1 = {'name': 'xiaoming', 'age': 18, 'gender': '女'}
# 使用print打印可以显示字典中的所有数据
print(dict1)
# 查看字典类型
print(type(dict1)) # <class 'dict'>
# 空字典定义方法
dict2 = {}
# 或者
dict3 = dict()
print(dict2, dict3)
print(type(dict2), type(dict3))
# 见名知意的重要性
# 需求: 使用字典保存一个人的信息 xiaoming 18 男 001
# 保存方式一:
# dict4 = {'name': 'xiaoming', 'age': 18, 'gender': '男', '学号': '001'}
# print(dict4)
# 保存方式二:
# 字典的优势是快速存取,注意命名键的时候要见名知意,并且易于记忆
# 字典占用空间远大于列表,使用字典存储数据本来就是牺牲空间确保时间,所以要尽量利用字典快速存取的特性,而不要想空间的节省
# dict5 = {'xiaoming':18, '男':'001'} # 不建议这样写
# 定义字典时 ,不能有重复的键,否则后定义的键值对会覆盖先定义的
dict6 = {'name': 'xiaoming', 'age': 18, 'name': 'rose'}
# 字典中的键是惟一的,后定义的内容值会覆盖先定义的
print(dict6)
# 字典中键是唯一的但是值可以随意重复
dict7 = {'name': '小明', 'age': 18, 'id': 18}
print(dict7)
10、字典的增加 ★
- 字典[新的key] = 值
- 如果key在原字典中已经存在则为修改原key对应的值
# 增 使用新的键 = 值的形式增加键值对
dict1 = {'name':'xiaoming', 'age': 18}
# 使用新的键= 值
# 格式:字典变量[key] = 值 如果为新增,则key在原字典中不存在
dict1['gender'] = '男'
print(dict1) # {'name': 'xiaoming', 'age': 18, 'gender': '男'}
# 如果原字典中存在该key 则为修改原key所对应的值
dict1['name'] = 'xiaowang'
print(dict1) # {'name': 'xiaowang', 'age': 18, 'gender': '男'}
# update
# 一般用于两个字典间的拼接
# 如果update中添加的键已经存在则修改原有的值
dict1.update({'id': '001', 'color': 'yellow', 'name': 'rose'})
print(dict1)
11、字典的删除 ★
- del 查找到字典的键所对应的值进行删除
- clear（）清空字典所在数据空间中的多有键值对
- pop：删除指定键所对应的键值对，会将删除的键值对所对应的值进行返回
- popitem： 删除随机一个键值对，尝试后发现总是删除最后一个，会将删除的键值对以元组的形式进行返回
# del
# 使用del删除键值对,先要找到dict所对应的键,进行删除
# 注意,在字典中键值对是成对出现的,删除键值也就消失了,不能出现单独的键或者单独的值
dict1 = {'name': 'xiaoming', 'age': 18}
del dict1['age']
print(dict1) # {'name': 'xiaoming'}
# clear() 清空字典
# 使用clear将字典所对应的内存空间中的数据进行了清空
dict1.clear()
print(dict1) # {}
# 通过之前的学习经验我们猜测 pop是删除简直对用的
dict2 = {'name': 'xiaoming', 'age': 18, 'gender': '男'}
# 使用pop可以根据指定的key删除键值对
# 使用pop删除键值对后会将其键对应的值进行返回
# print(dict2.pop('name')) # xiaoming
# print(dict2) # {'age': 18, 'gender': '男'}
# 猜测:popitem也是删除键值对使用的
# 随机删除一个键值对,一般都是删除最后一个
# 删除后会将我们所删除的键值对以元组的形式进行返回
print(dict2.popitem()) # ('gender', '男')
print(dict2.popitem()) # ('age', 18)
print(dict2) # {'name': 'xiaoming'}
# dict 无序的 因为其不能通过索引进行键值对的获取(了解)
# Python3.5以后,字典中键值对的顺序和我们插入键值对的顺序保持一致,但是该顺序没法被利用(了解)
12、字典的修改 ★
- 字典[key] = 值
- 字典中key必须存在
- update：
- update（键 = 值）
- update（{键：值}）
- 对应的键一定存在
# 通过索引修改字典中的键值对
dict1 = {'name':'小明', 'age':18}
dict1['name'] = '小红'
print(dict1)
# update
# 可以进行制定字段值的修改
# dict1.update(name='小绿')
dict1.update({'name': '小绿'})
print(dict1)
13、字典的查询 ★
- 使用键查询值：字典[key]
- 查询的键不存在时则报错
- get：字典.get(key)
- 查询的键不存在时，不报错，可以默认返回None，或者手动设置返回内容
- keys：获取所有的键
- values：获取所有的值
- items：获取所有的键值对组成的元组
# 直接使用key进行查询
dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
# 查询学员的名称?
print(dict1['name'])
# get查询
# 如果我们查询的键不存在会真么样??? 报错
# KeyError: 'apple' 会出现keyerror 表示查询的键不存在 报错
# print(dict1['apple'])
# 使用get进行查询,只需要在get中传入对应的键即可
# 如果使用get查询的键不存在,则不会报错,会默认返回一个None
print(dict1.get('name')) # 小明
print(dict1.get('apple')) # None
# 如果查询的键不存在,get可以自定义默认返回值
# 格式 字典.get(要查询的键, 查询的键不存在时返回的数据)
print(dict1.get('apple', '小刚'))
print(dict1.get('apple', 9))
# keys 获取当前字典中所有的键
print(dict1.keys()) # dict_keys(['name', 'age', 'gender', 'id'])
# keys返回的内容不是列表,而是dict_keys,该数据类型不能直接使用索引查询数据,但是可以进行for遍历
print(type(dict1.keys())) # <class 'dict_keys'>
keys_1 = dict1.keys()
# 不能使用索引查询
# TypeError: 'dict_keys' object is not subscriptable
# print(keys_1[1])
# 可以被迭代
for i in keys_1:
print(i)
# values 获取当前字典中所有的值
print(dict1.values()) # dict_values(['小明', 18, '男', '001'])
# dict_values不能使用索引查询,但是可以迭代
print(type(dict1.values())) # <class 'dict_values'>
# items 获取当前字典中所有的键值对,键值对以元组形式展示
print(dict1.items()) # dict_items([('name', '小明'), ('age', 18), ('gender', '男'), ('id', '001')])
# dict_items不能使用索引查询,但是可以迭代
print(type(dict1.items())) # <class 'dict_items'>
14、字典的遍历 ★
# 字典的遍历
dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
# 使用for循环对字典进行遍历,默认获取的是字典的每一个键
for i in dict1:
print(i)
'''
name
age
gender
id
'''
# 获取的是字典的每一个键
for i in dict1.keys():
print(i)
'''
name
age
gender
id
'''
# 获取的是字典的每一个值
for i in dict1.values():
print(i)
'''
小明
18
男
001
'''
# 获取的是字典中每一个键值对组成的元组
for i in dict1.items():
print(i)
'''
('name', '小明')
('age', 18)
('gender', '男')
('id', '001')
'''
# 有没有办法可以分别拿到字典的键和值呢?
for i in dict1:
print(i, dict1[i])
for key, value in dict1.items():
print(key, value )
15、集合的定义 ★
- 变量 = {数据1， 数据2， 数据3.。。。}
- 空集合：set（）
- 集合是一个无序的 不重复的数据序列
# 集合: 集合是一个无序,不重复的数据序列
# 无序: 程序员无法控制其排不顺序, 程序员无法使用索引查找或修改数据
# 不重复:没有办法在字典中放入相同的值,会自动去重,类似于字典的键
# 无序:
set1 = {1, 2, 5, 6, 3, 4}
# 程序员无法利用其顺序,有顺序也无用
# 了解:在集合中会使用数据的值计算哈希值,根据哈希值顺序进行排序
print(set1) # {1, 2, 3, 4, 5, 6}
# 不重复
set2 = {1, 2, 3, 4, 5, 6, 7, 2, 3}
# set会自动去重
print(set2) # {1, 2, 3, 4, 5, 6, 7}
# 定义空集合
set3 = set()
# {} 是定义空字典的
print(set3)
# 集合中能够储存什么数据?
# 布尔值在进行计算时 True == 1 Fasle == 0
# 基础数据类型 int float bool 字符串 都可以用集合储存
set4 = {1, 12.3, True, 0, False, ''}
print(set4)
# TypeError: unhashable type: 'list'
# 列表数据无法用集合储存
# set5 = {1, 12.3, True, 0, False, '', [1, 2]}
# print(set5)
# 元组类型可以放入集合内储存
set6 = {1, 12.3, True, 0, False, '', (1, 2)}
print(set6)
# TypeError: unhashable type: 'dict'
# 字典类型无法用集合储存
# set6 = {1, 12.3, True, 0, False, '', {1:2}}
# TypeError: unhashable type: 'set'
# 集合类型同样不能使用集合嵌套
# set6 = {1, 12.3, True, 0, False, '', {1,2}}
# 结论:列表 字典 集合,不能放入集合中,作为元素出现
# 拓展:不能作为集合元素的数据类型,同样不能作为字典的键出现
dict1 = {(1, 2): 3}
print(dict1)
# TypeError: unhashable type: 'list'
# 列表 字典 集合不能作为字典的键出现
dict2 = {[1, 2]: 3}
print(dict2)
16、集合的相关操作 ★
- 集合的增加
- add：添加一个元素，如果值已存在，则去重
- update： 更新元素（在括号中添加可迭代类型），如果值已存在则去重
# add 增加
set1 = {1, 2, 3, 4}
# set 在使用add命令后,不会产生新的数据,而是原集合中进行修改
set1.add(5)
print(set1) # {1, 2, 3, 4, 5}
# update 更新
# TypeError: 'int' object is not iterable
# update内部只能填写容器类型(数据序列)
# set1.update(6)
set1.update([6, 7])
print(set1) # {1, 2, 3, 4, 5, 6, 7}
# 如果更新的数据已经存在,则去重
set1.update([1,2])
print(set1) # {1, 2, 3, 4, 5, 6, 7}
- 集合的删除
- remove：根据元素值进行删除，如果元素不存在则报错
- discard：根据元素值进行删除，如果元素值不存在则不报错
- pop：删除任意元素，并返回被删除的值
# remove
set1 = {1, 2, 3, 4}
# 使用remove可以删除指定值的元素
# set1.remove(3)
# print(set1) # {1, 2, 4}
# pop 随机删除一个元素,并且将删除的元素返回
# print(set1.pop())
# print(set1)
# discard
# 如果使用remove删除的元素不存在会怎样? 报错
# set1.remove(13) # KeyError: 13
# 如果使用discard删除元素呢? 不会报错
set1.discard(3)
print(set1) # {1, 2, 4}
set1.discard(13)
print(set1)
- 集合判断：
- in
- not in
# 数据是否在集合中
set1 = {1, 2, 3, 4}
# in 判断元素是否在集合中出现
print(4 in set1) # True
print(5 in set1) # Fasle
# not in 判断元素是否不在集合中
print(4 not in set1) # False
print(5 not in set1) # True
# 注意:格式 元素 in 集合
# 判断的数据必须要在集合中能够被储存
# TypeError: unhashable type: 'list'
# print([1, 2] in set1)
- 集合可以使用for循环遍历，但是遍历顺序随机
# for 遍历
set1 = {1, 2, 3, 4}
for i in set1:
print(i)
# 注意遍历集合,顺序不定
name_set = {'Tom', 'Bob', 'Rose'}
for i in name_set:
print(i)
'''
Rose
Tom
Bob
'''
当天知识点回顾
- 能够使用列表的添加元素的三个方法(append、insert、extend)
- 能够使用列表的下标来对列表中的元素进行修改
- 能够使用列表的查询方法(in、not in、index、count)
- 能够使用列表中删除元素的方法(del, pop, remove)
- 能够使用 sort 和 reverse 完成对列表的排序。
- 能够知道列表嵌套的格式
- 能够知道元组的定义格式(当元组中只有一个元素的时候，定义格式是： a = (18, ) )
- 能够知道元组和列表的区别( 元组定义使用小括号
()， 列表使用中括号｀｀［］｀｀，元组中的元素不可修改不可删除) - 能够知道元组可以使用 for 循环遍历，可以使用下标来获取元组中的某一个元素
- 能够知道字典的定义格式
{key1:value1, key2:value2, .....} - 能够知道字典在取值的时候是使用 key 来取值
dict[key] - 能够知道字典在修改值的时候使用 key 来修改
dict[key] = new_value - 能够知道字典新增数据
dict[key] = new_value如果 key 存在表示修改数据，如果key不存在，表示新增数据 - 能够知道字典删除数据的方法
del dict['key'] 根据键删除对应的值， del dict 删除整个字典， dict.clear() 清空字典 - 能够知道查看字典的长度的方法
len(), 取出所有key的列表keys(),取出所有值的列表values(),取出包含所有键值的元组的列表items() - 能够使用for循环遍历字典
随堂练习
- 定义一个列表，列表中的元素有
张三、李四、王五、赵六 - 分别使用for循环和while循环打印出 练习7 列表中的元素
- 向练习7的列表中追加一个名字
小明 - 将 练习7 列表中名字
李四改为赵四 - 将练习7 列表中的
赵六删除 - 给定一个列表
[32, 17, 28, 90, 11]完成对该列表的升序和降序的排序 - 创建一个元组，元组中只有一个元素
zhangsan - 创建一个空字典 变量名为
info - 接上一题，向字典 info 中添加新的键值对，保存如下信息：姓名是张三
- 接上一题，存在字典 info = {‘name’:‘张三’},怎样访问字典中元素 name 的值
- 接上一题，存在字典 info = {‘name’:‘张三’},怎样修改字典中的元素 ‘name’ 的值为 ‘李四’
- 接上一题，存在字典 info = {‘name’:‘李四’}, 删除元素 name
- 存在字典 info = {‘name’:‘张三’},清空整个字典
- 存在字典 info = {‘name’:‘张三’},删除整个字典
- 存在字典 info = {‘name’:‘张三’},怎样测量键值对个数
- 怎样测量键值对个数
- 怎样获取字典中的所有key
- 怎样获取字典中的所有value
每日练习
题目1（实操题）
题干
给定一个列表，首先删除以s开头的元素，删除后，修改第一个元素为"joke"，并且并且把最后一个元素复制一份，放在joke的后边
my_list = [“spring”, “look”, “strange”, “curious”, “black”, “hope”]
训练目标
列表包含的操作
列表的相关操作
训练提示
- 通过for循环遍历列表，获取到每一个元素
- 通过列表的操作方法对列表进行修改
参考方案
- 通过for循环获取每一个元素
- 通过remove删除列表中的元素
- 通过insert函数在指定位置插入元素
操作步骤
- 通过for循环获取每一个元素，并使用startswith方法判断是否以某字符串开头
- 如果条件成立，则通过remove删除选中的元素
- 获取到最后一个元素，通过insert将元素放在指定的位置上
参考答案
my_list = ["spring", "look", "strange", "curious", "black", "hope"]
#1. 提取要删除的元素
remove_list = []
for s in my_list:
if s.startswith("s"):
remove_list.append(s)
#2. 删除对应的元素
for s in remove_list:
my_list.remove(s)
# 3. 修改第一个元素
my_list[0] = "joke"
# 4. 插入一个元素
my_list.insert(1,my_list[-1])
# 5. 打印
print(my_list)
题目2 （实操题）
题干
将下列两个列表合并，将合并后的列表去重，之后降序并输出
list1 = [11, 45, 34, 51, 90]
list2 = [4, 16, 23, 0]
训练目标
列表操作方法的使用
训练提示
1， 列表直接可以直接拼接，元素会合并到同一个列表中
2， 可以使用sort对列表进行排序
参考方案
1，使用 + 对列表进行拼接
2，使用set方法将列表转变成集合，以便于去重，
3，使用sort函数，参数reverse=True对列表进行倒序排序
操作步骤
1，使用 + 对列表进行拼接
2，使用set方法将列表转变成集合，以便于去重，
3，使用sort函数，参数reverse=True对列表进行倒序排序
参考答案
list1 = [11, 45, 34, 51, 90]
list2 = [4, 16, 23, 0]
# 1. 合并列表
list3 = list1+list2
# 2. 利用set特点去重列表
list3 = list(set(list3))
#3. 排序列表
list3.sort(reverse=True)
#4. 打印下结果
print(list3)
题目3（实操）
题干
现有：typle1 = ("tom","kaisa","alisi","xiaoming","songshu")
我想获得“alisi”这个内容，你能否想到三种方法来做？
训练目标
元组按下标取值
元组的切片操作
元组的遍历操作
训练提示
- 在元组里面，可以按照下标来取值
- 在元组里面，也是可以支持切片（与字符串类似）操作的
- 在元组里面，可以通过遍历取到每一个元素
参考方案
- 用元组取下标为2的值
- 可以利用切片从下标2开始取到下标3之前
- 可以用for循环来遍历所有的值，判断，如果有一个是alisi，那就输出
操作步骤
- typle1[2]
- typle1[2:3]
- for x in typle1先执行遍历，再进行判断
参考答案
typle1 = ("tom","kaisa","alisi","xiaoming","songshu")
print(typle1[2])
print(typle1[2:3])
# 循环查找
for name in typle1:
if name=="alisi":
print(name)
break
题目4（实操题）
题干
有如下元组：
typle1 = ("tom","kaisa","alisi","xiaoming","songshu")
求出他的长度
训练目标
- 元组中内置方法len的使用
训练提示
- 对于这个题目要求，我们可以用到自己学过的知识，比如遍历这个元组，并且同时记录元素个数
- 但是对于我们强大的python来说，有没有什么最直接的方式呢？
参考方案
- 参考len用法
操作步骤
- 直接将元组放入len（）中即可
参考答案
typle1 = ("tom","kaisa","alisi","xiaoming","songshu")
print(len(typle1))
题目5（实操题）
题干
现有字典dict1 = {'name':'python'}，将键为'name'的值更改为'chuanzhi'
训练目标
字典中键值对的更改操作
训练提示
- 已经有了一个键值对，要对其进行更改值
- 此时只需要使用’='来执行赋值操作就行
参考方案
- 先指定要更改的键
- 使用“=”符号，给这个键赋值一个值为python的字符串
操作步骤
- dict1[“name”]来指定键的名称，用‘=’来赋值要更改的值（‘chuanzhi’）
参考答案
dict1 = {'name':'python'}
dict1["name"] = "chuanzhi"
拓展提高
题目6（实操题）
题干
现有字典dict1 = {'name':'chuanzhi','age':18}
要求：
1.删除age：18这个键值对
2.将整个字典里面的所有键值对，清空
训练目标
- 对于字典中删除的操作
- del的使用
- clear() 的使用
训练提示
- 有给定的字典，我们要怎么来完成删除操作？
- 在删除操作中，del与clear有怎么样的区别？
参考方案
- 删除一个指定的键值对，要用到del。
- 清空整个字典，要用到clear（）方法。
操作步骤
- del 要删除的键
- 调用字典字典的clear的方法即可。
参考答案
dict1 = {'name':'chuanzhi','age':18}
del dict1['age'] # 删除指定的键值对
print(dict1)
dict1.clear() # 清空字典
print(dict1)
题目 7实操题）
题干
现有字典dict1 = {'name':'chuanzhi','age':18}
要求：
1.使用循环将字典中所有的键输出到屏幕上
2.使用循环将字典中所有的值输出到屏幕上
3.使用循环将字典中所有的键值对输出到屏幕上
输出方式：
name：chuanzhi
age:18
训练目标
- for循环的使用复习
- 学会如何获取字典所有的键
- 学会如何获取字典所有的值
- 学会如何获取字典所有的键值对
训练提示
- 用for来实现循环
- 用字典.keys()来获取所有的键
- 用字典.values()来获取所有的值
- 用字典.items()来获取所有的键值对
参考方案
用for来实现循环，让字典.keys()取到所有的键并控制循环次数，依次打印出每一个值，值与键值对同理；
操作步骤
- 让字典.keys()获取所有的值，将所有的值进行循环遍历，并依次print（）
- 让字典.keys()获取所有的值，将所有的值进行循环遍历，并依次print（）
- 让字典.items()获取所有的值，将所有的值进行循环遍历，并依次print（key, “:”, value）
参考答案
dict1 = {'name':'chuanzhi','age':18}
# 1. 输出所有的key
for key in dict1.keys():
print(key)
# 2. 输出所有的value
for value in dict1.values():
print(value)
# 3. 输出键值对
for key,value in dict1.items():
print("%s:%s" % (key,value))
题目8 (实操题)
题干
有这样的一个列表
product = [
{"name": "电脑", "price": 7000},
{"name": "鼠标", "price": 30},
{"name": "usb电动小风扇", "price": 20},
{"name": "遮阳伞", "price": 50},
]
然后小明一共有8000块钱，那么他能不能买下这所有商品？
如果能，请输出“能”，否则输出“不能”
训练目标
if判断语句的复习使用
列表与字典的复合使用
遍历列表与遍历字典的使用
训练提示
题目中给了“能不能”三个字，那么这时候用什么语句来实现呢？
题目中数据是用列表来套字典来存储的，那么获取数据是不是要遍历呢？
在判断能不能买下的时候，那么要用那两个数据进行判断呢，这两个数据分别是什么？
参考方案
使用双层for循环来遍历每一个数据，找到价格进行累计，之后判断
操作步骤
- 双层for循环来循环数据
- 在每一层循环中来判断并累计所有的价格
- 在循环结束之后，用总价格进行与总钱数进行比较
参考答案
product = [
{"name": "电脑", "price": 7000},
{"name": "鼠标", "price": 30},
{"name": "usb电动小风扇", "price": 20},
{"name": "遮阳伞", "price": 50},
]
# 1. 定义一个变量计算总价格
total = 0
# 2. 遍历获取里面的价格 并累加
for item in product:
# 提取价格
price = item['price']
# 累加计算
total+=price
print("共需要: %d元" % total)
# 3. 判断是否有能力购买
if total>8000:
print("无能力购买")
else:
print("可以购买")
自主预习
题目9 （实操题）
题干
定义一个简单的函数run，函数的功能是输出"我在跑步" 以及 “管住嘴，迈开腿”，并调用此函数。
训练目标
- 如何定义一个函数
- 调用函数的方式
训练提示
- 定义函数的形式是什么？声明函数的关键字是什么？
- 怎么让函数运行？
参考方案
- 用def关键字定义函数
- 用函数名+小括号的方式来调用函数
操作步骤
- def run(): …
- run()
参考答案
def run():
print("我在跑步")
print("管住嘴，迈开腿")
run()
day06
1、公共方法
+- 加法运算适用于所有的基础数据类型（int float bool）
- 加法运算所有两侧要是同种数据类型
- 加法运算再容器类型中是拼接的意思，不是相加计算值
# +法运算,都可以用于哪些数据类型之间
# int float bool 肯定可以用于加法运算,不再赘述
print(1 + 12.3) # 13.3
# str 可以相加么? 可以
str1 = 'hello'
str2 = ' python'
# 字符串相加,可以快速将字符串进行拼接
print(str1 + str2)
# 相加过后,str1 和str2 没有发生变化,可以推断+法运算产生了新的数据,源数据不变化
print(str1, str2, sep='\n')
# list 可以相加么? 可以
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 列表相加可以将列表进行拼接,效果类似于extend
print(list1 + list2) # [1, 2, 3, 4, 5, 6]
# list相加后,原数据不发生变化,将产生一个新的数据
print(list1) # [1, 2, 3]
print(list2) # [4, 5, 6]
# tuple 可以相加么? 可以
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
print(tuple1 + tuple2) # (1, 2, 3, 4, 5, 6)
# 由于元组内部元素不能修改,索引相加肯定没有对源数据产生影响,而是生成了新的数据
# set
# set1 = {1, 2, 3}
# set2 = {4, 5, 6}
# # TypeError: unsupported operand type(s) for +: 'set' and 'set'
# # set之间不能进行加法运算
# print(set1 + set2)
# dict
# TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
# dict 类型间不能进行加法运算
# dict1 = {'name': '小明'}
# dict2 = {'age':18}
# print(dict1 + dict2)
# 结论: 基础数据类型都可以进行加法运算,容器类型间只有列表,元组,字符串可以进行加法运算
# 不同容器类型间可以相加么?
list1 = [1,2,3]
tuple1 = (1,2,3)
set1 = {1,2,3}
dict1 = {'name': 'xiaoming'}
# TypeError: can only concatenate list (not "tuple") to list
# print(list1 + tuple1)
# TypeError: can only concatenate list (not "set") to list
# print(list1 + set1)
# TypeError: can only concatenate tuple (not "set") to tuple
print(tuple1 + set1)
# 结论,数据类型布偶无法进行加法运算(特指容器类型之间)
*- 基础数据类型（int float bool）都可以进行乘法运算
- 容器类型只能和int类型数据进行乘法运算
- 容器类型进行乘法运算，就是将容器复制指定次数，并进行拼接
# * 效果是设么?
# * 什么容器类型可以使用*
# 基础数据类型 int float bool都可以使用*法运算
print(12.1 * 2)
# 容器类型的乘法运算
# 格式: 容器类型 * int类型数据
# 乘法运算的 效果,就是讲容器类型复制指定次数,并拼接到一起
# list 可以使用*法运算么? 可以
list1 = [1, 2, 3]
# 将list1 复制3次并进行拼接
print(list1 * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
# 使用list 类型乘以float类型可以实现么?
# TypeError: can't multiply sequence by non-int of type 'float'
# 乘法运算不能让容器与非int类型相乘
# print(list1 * 1.3)
# list 能乘以负数么? 可以相乘,但是结果为空列表
print(list1 * -3) # []
# 可以与0 相乘,结果为空列表
print(list1 * 0) # []
# tuple 可以使用*法运算么? 可以
tuple1 = (1, 2, 3, 4)
print(tuple1 * 2) # (1, 2, 3, 4, 1, 2, 3, 4)
# tuple 只能与int类型相乘
# set可以使用 * 法运算么? 不可以
set1 = {1, 2, 3}
# TypeError: unsupported operand type(s) for *: 'set' and 'int'
# 集合类型数据不能做乘法运算
# print(set1 * 3)
# dict 能够使用 * 法运算么? 不可以
dict1 = {'name': 'jack'}
# TypeError: unsupported operand type(s) for *: 'dict' and 'int'
# 字典不能做乘法运算
# print(dict1 * 3)
# 乘号左右两侧的数据可以互换位置么? 可以
print(3 * list1) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
in和not in- 判断元素是否在数据序列当中
- 字符串，列表，元组，集合 ，字典都可以使用
# in 判断元素是否存在于容器当中
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
set1 = {1, 2, 3}
print(3 in list1) # True
print(3 in tuple1) # True
print(3 in set1) # True
# 如果要判断是否在set当中,要注意被判断的元素必须可以保存在set当中,如果是列表,字典,集合,则不能判断
# print([1, 2] in list1) # False 可以判断,引为[1,2] 可以保存在list1当中
# print([1, 2] in set1) # TypeError: unhashable type: 'list' 不能判断,因为[1,2]不能保存到set1当中
# str类型可以使用in么? 可以
str1 = '123'
# TypeError: 'in <string>' requires string as left operand, not int
# 字符串判断时,左侧的元素只能是字符串类型,否则报错
# print(1 in str1)
print('1' in str1) # True
# dict 是否可以使用in???
dict1 = {'name': 123}
# dict使用in判断的是当前元素是否是dict中存在的键
print(123 in dict1) # False
print('name' in dict1) # True
# 如果使用此方法则不能判断字典 列表 集合
# TypeError: unhashable type: 'list'
# print([1,2] in dict1)
# not in : 所有用法和in相同,只是取反而已
# 结论:
# 1.使用in 和not in 被判断的元素在关键字左侧, 数据序列在关键字右侧
# 2.如果想要判断该元素是否在容器内,该元素必须能保存到容器内,比如集合不能保存列表,字典,集合 所以就不能判断其类型的元素是否在集合内
# 3.字典判断的是元素是否在keys内,也就是是否是其中的键
- 切片
- 通过切片按照规则获取数据序列中的一部分元素
- tuple list str 可以使用切片
- dict set 不可以使用切片
# 切片:通过切片方法可以按照一定规则截取容器的一部分数据
# str切片
str1 = 'abcde'
# 格式:[起始位置:终止位置:步长]
# 不会修改原有字符串,而是产生了一个新的字符串
print(str1[2:]) # cde
# list可以切片么?
list1 = [1, 2, 3, 4]
# list切片方式方法和str完全相同
# list切片后不会在原有数据上进行修改,而是产生了一个新的列表
print(list1[1:3:1]) # [2, 3]
print(list1)
# tuple 可以切片么?
tuple1 = (1, 2, 3, 4)
# tuple1切片方式方法和str完全相同
# 切片后不会在原有数据上进行修改,而是产生了一个新的列表
print(tuple1[1:3:1]) # (2, 3)
print(tuple1)
# dict可以切片么? 肯定不行,因为不能使用索引获取数据
# set 可以切片么? 肯定不行,因为不能使用索引获取数据
# 结论:
# 1.list str tuple 可以使用切片,格式是:[起始位置:终止位置:步长],三者使用方式完全一致
# 2.所有的切片都不会在原有的数据上进行修改,而是产生一个新的数据序列
# 3.集合和字典无法切片,因为不能使用索引获取数据元素
2、公共函数
- len ：获取容器内元素个数
- del：删除容器内元素
- max ：获取容器内数据的最大值
- min ： 获取容器内元素的最小值
- enumerate ： 获取容器内元素时可以携带序号
- range：根据一定规则获取整数序列
# len 获取容器类型的元素个数, 或者说获取容器的长度
str1 = '123'
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
set1 = {1, 2, 3}
dict1 = {'name': 123, 'age': 18}
# 使用len可以获取list str tuple set中的元素个数
print(len(str1))
print(len(list1))
print(len(tuple1))
print(len(set1))
# 使用len可以获取dict中的键值对的个数
print(len(dict1))
# len() 可以写成 容器.__len__()
print(list1.__len__())
# del
# 删除容器内指定的元素
# list
# del list1[0]
# print(list1)
# tuple
# del tuple1[0]
# TypeError: 'tuple' object doesn't support item deletion
# 元组内元素不能被删除
# print(tuple1)
# set
# for i in set1:
# del i
# dict
# del dict1['name']
# del 在dict中删除的是键值对
print(dict1)
# str
# TypeError: 'str' object doesn't support item deletion
# str 不能够使用del 删除内部元素
# 注意 :str内部的元素也是不可修改的,类似于元组
# del str1[0]
# print(str1)
# 结论:
# 1.列表,字典可以使用del删除内部元素,但是,列表中是删除元素,字典中是删除键值对
# 2.使用del 没法循环遍历删除set中的元素,因为引用机制问题
# 3.str tuple内部的元素都不可更改所以不能使用del删除元素
# max min
# list tuple set str可以使用max min获取容器内的最大最小值
print(max(list1))
print(max(tuple1))
print(max(set1))
print(max(str1))
# dict是使用max和min获取键的最大最小值
print(max(dict1))
# enumerate 枚举函数:获取容器内数据时添加序号(默认序号从0开始可以作为索引使用)
list2 = [1, 2, 3, 4, 5, 6, 7, 8]
for i in list2:
print(i)
# 可不可以同时获取元素的值和元素的索引? 可以 使用enumerate
# for i in enumerate(list2):
# # 直接打印,获取的是以(索引,值)组成的元组
# print(i)
# list
for index, value in enumerate(list2):
print(index, value, sep=' : ')
# tuple
for index, value in enumerate(tuple1):
print(index, value, sep=' : ')
# set
for index, value in enumerate(set1):
print(index, value, sep=' : ')
# str
for index, value in enumerate(str1):
print(index, value, sep=' : ')
# dict
for index, value in enumerate(dict1):
print(index, value, sep=' : ')
# 结论:所有的容器和课迭代类型都可以使用enumerate,并且产生序号,这个序号并不是索引值,而是在生成序号时默认从0开始,碰巧可以在list,str,tuple中当做索引使用
3、推导式
- 列表推导式
- 格式：[要插入的值 for 临时变量 in 数据序列 if 条件]
- 集合推导式
- 格式：{要插入的值 for 临时变量 in 数据序列 if 条件}
- 字典推导式
- 格式：{要插入的键：要插入的值 for 临时变量 in 数据序列 if 条件 }
- 没有元组推导式和字符串推导式，因为其内部元素无法被修改
# 推导式:通过一定的规则快速构建数据序列
# 列表推导式
# 获取从0 到9的数据序列
# while
list1 = []
i = 0
while i < 10:
list1.append(i)
i += 1
print(list1)
# for
list2 = []
for i in range(10):
list2.append(i)
print(list2)
# 推导式
# 格式: [要插入列表的表达式 for 临时变量 in 数据序列]
list3 = [i for i in range(10)]
print(list3)
# 使用推导式,创建一个从1-100的偶数的数据序列
# for
list4 = []
for i in range(1, 101):
if i % 2 == 0:
list4.append(i)
print(list4)
# 推导式
# 格式: [要插入列表的表达式 for 临时变量 in 数据序列 if 条件]
list5 = [i for i in range(1, 101) if i % 2 == 0]
print(list5)
# 练习:
# 用推导式进行九九乘法表的生成,将所有的算式放入列表中
list6 = []
for i in range(1, 10):
for j in range(1, i + 1):
list6.append(f'{j} * {i} = {j * i}')
print(list6)
# 改写为推导式:
list7 = [f'{j} * {i} = {j * i}' for i in range(1, 10) for j in range(1, i + 1)]
print(list7)
# 集合推导式
# 集合推导式和列表推导式完全一致,只不过使用推导式时,外层用{}包裹,并且在序列中会去重
set1 = {i for i in range(10)}
print(set1)
# 获取从1-10 的偶数集合
set2 = {i for i in range(1, 11) if i % 2 == 0}
print(set2)
# 字典推导式
keys = ['name', 'age', 'gender', 'id']
values = ['xiaoming', 18, '女', '001']
# 需求想将key 和value以一对应,形成一个字典
dict1 = {}
for i in range(len(keys)):
dict1[keys[i]] = values[i]
print(dict1)
# 改写推导式
# 格式:{要插入的键:要插入的值 for 临时变量 in 数据序列 if 条件}
dict2 = {keys[i]: values[i] for i in range(len(keys))}
print(dict2)
# 所有的推导式都可以使用for循环改写,所以我们进行推导式的时候先不要急于求成,多改写几次就不用再改写了直接可以写出推导式
4、函数介绍
-
函数的定义：
-
def 函数名（参数）：
函数体
return 返回值
-
-
函数的调用：函数名（参数）
# 函数: 将特定的功能所对应的代码片段进行打包,封存在一个函数内,如果我们想要重复使用该功能,就直接调用函数即可
# 函数的作用: 提高代码复用率,提高开发效率,易于维护
'''
函数定义的格式:
def 函数名(参数1, 参数2,参数3....):
函数体
return 返回值
函数调用的格式:
函数名(参数1,参数2,参数3.....)
# 函数名:绝大多数函数都有函数名,没有函数名的函数不能被复用
# 参数:为了让函数灵活性更高,更容易被复用,会动态对函数进行传值,传递的值可以在函数体内部进行使用
# 函数体: 特定功能的代码,写在函数内部,调用函数时可全部执行
# 返回值: 写在return之后,将函数内部计算或运行得到的数据传递到函数体外部
'''
# 定义的时候可以不传参,如果不传调用的时候也不用传参
def run():
print('我跑的老快了,没人追的上我,钱包在我手里')
print('我跑的老快了,没人追的上我,手机在我手里')
print('我跑的老快了,没人追的上我,女朋友在我手里')
# 调用时可以将函数内的代码全部执行一遍
run()
run()
- 函数的调用顺序：从上到下依次执行，先键函数名保存到函数列表中，调用的时候去类表中查询，如果存在则调用其中的代码，如果不存在则报错
# NameError: name 'sing' is not defined
# 函数需要先定义后调用否则会报错
# sing()
# 定义一个唱歌方法
def sing():
print('我再唱青藏高原')
# 定义一个跳舞方法
def dance():
print('我再跳广场舞')
sing()
dance()
# 执行顺序: 先讲所有函数的函数名执行一遍将其储存到缓存中的方法列表中,后续调用函数时去方法列表中查询,如果函数名存在,则调用函数内部的代码,如果函数名不存在将报错
5、函数参数
- 函数的参数可以增加代码的灵活性
- 在定义时传入的参数是形参，只能在函数体内部使用
- 在调用的时候传入的参数是实参，可以传入到函数体内部被形参接收
# 定义一个eat方法,通过传入不同的参数,可以输出不同的生物吃不同的食物
def eat_cat():
print('猫吃鱼')
def eat_dog():
print('狗吃肉')
def eat_person():
print('人吃藕')
# 上述函数定义方法不太方便,因为如果有更多的生物去吃不同的东西,就要重复书写函数不利于函数的复用
# 改进 >> 传参
# 通过传入参数,可以控制函数体内部的执行结果发生变化,让函数更加灵活
def eat(who, food): # 在定义时传入的参数叫做形参,只能在函数体内部使用
print(f'{who}吃{food}')
# 在调用的时候传入的参数叫做实参,会传入到函数内部被形参接收
eat('猫', '
标签：__,13,name,python,self,使用,print,def,大全
From： https://blog.csdn.net/m0_63571404/article/details/139867104