目录
Python学习笔记
-
第一部分——入门知识
（一）初识python
1.输出内容
print(“要输出的内容”)
如果要求print语句输出不换行在后面加上,end=''就好
例如：
print("Hello ",end='')
print("world!",end='')2.退出程序
exit()
3.运行python文件中的代码
cmd中输入“python+空格+文件地址”（文件地址不能有空格，不然会出错）
4.pycharm快捷键
5.制表符\t
制表符\t，效果等同于在键盘上按下：tab键，它可以让我们的多行字符串进行对齐
（二）字面量
1.字面量含义
写在代码中固定的值
2.python中常用的值
3.利用print输出各种字面量
字符串需要双引号，其他类型的值不用
（三）注释
1.单行注释
#开头，右边的都是注释，不会被当作代码执行
规范要求：#后加一个空格再加注释内容
2.多行注释
"""注释内容,支持换行,多行注释"""
英文状态下的三对双引号
（四）变量
1.定义
变量：在程序运行时，能储存计算结果或表示值得抽象概念
2.格式
变量名=变量值
变量名：变量名称，也就是变量本身
=：赋值，表示将等号右侧的值赋予等号左侧的变量
变量值：每一个变量都有自己存储的值（内容），称为变量值。
# 定义一个变量，用于记录钱包余额
money = 420
# 通过print语句，输出变量记录的内容
print("钱包余额为: ", money ,"元")
# 买了仙那度巡回演唱会蓝光DVD（399元），输出目前余额
money = money - 399
print("钱包余额为: ", money ,"元")（五）数据类型
1.type()语句
语法：type(被查看类型的数据)，type查看的时变量存储的数据的类型，本质是查看的数据的类型。在python中，变量是没有类型的。
使用方法：
（1）在print语句中，直接输出类型信息
print(type("XANADU"))
print(type(420))
print(type(2004.0408))运行结果
（2）用变量存储type()的结果（返回值）
string_type = type("XANADU")
int_type = type(420)
float_type = type(2004.0408)
print(string_type)
print(int_type)
print(float_type)运行结果
（3）使用type()语句，查看变量中存储的数据类型信息
name = "XANADU"
name_type = type(name)
print(name_type)运行结果：
2.数据类型转换
int(x)—将x转换为整数
float(x)—将x转换为浮点数
str(x)—将x转换为字符串
注意：①万物皆可字符串：任何类型都可以转变成字符串
②字符串不一定能转化为整型或浮点型
③将浮点型转化为整型会丢失精度，直接舍弃小数部分（而不是四舍五入）
（六）标识符
1.标识符定义
标识符：用户在编程的时候使用的一系列名字，用于给变量、类、方法等命名。
2.标识符命名规则
（1）内容限定
在标识符的命名中，只允许出现英文、中文、数字、下划线（_）这四类元素，其余任何内容都不被允许。
注意事项：
①不推荐使用中文
②数字不可以作为开头
（2）大小写敏感
例如XANADU和xanadu在python“眼”中是两个不一样的变量
（3）不可以使用关键字
Python中有一些单词称为关键字，关键字在python中都有特定用途，我们不可以使用它们作为标识符。常见的关键字有False、True、in、is、while、for等等，后续会陆续用到，不必死记。
3.变量命名规范（类、方法在后面）
（1）明了：见名知意，看到变量名就知道什么意思
（2）简洁：在保证“明了”前提下减少名字的长度
（3）多个单词组合变量名，要用下划线做分割
（4）命名变量中的英文字母，应全部小写
（七）运算符
1.算术运算符
2.赋值运算符
（1）标准赋值运算符
（2）复合赋值运算符
（八）字符串
1.字符串的三种定义方式
（1）单引号定义法
string1= '我爱python'（2）双引号定义法
string2= "我爱python"（3）三引号定义法
string3 = '''我爱python'''需要注意的是，对于三引号定义法，如果使用变量接受，它就是字符串，并且支持换行。如果未使用变量接受，它就是注释
（4）字符串的引号嵌套
①单引号内使用双引号（针对字符串包含双引号的情况）
# 在字符串内包含双引号
string1 = '"我爱python"'
print("string1="+string1)②双引号内使用单引号（针对字符串包含单引号的情况）
# 在字符串内包含单引号
string2= "'我爱python'"
print("string2="+string2)③使用转义字符（通用）
# 使用转义字符/进行转义
string3 = "\'我爱python\""
print("string3="+string3)运行结果
2.字符串的拼接(+)
（1）字面量之间的拼接
# 进行字面量的拼接
name = "Python小白"
print("我是"+name)（2）字面量与变量之间的拼接
如果变量是字符串，可以通过+拼接。如果不是字符串就不能使用+。
# 进行字面量与变量的拼接
age = 19
print("我的年龄是",age)（3）字符串格式化
①.方法1—占位
Python中最常用的三类数据类型占位：
| 格式符号 | 转化 |
| %s | 将内容转化为字符串，放入占位位置 |
| %d | 将内容转化为整数，放入占位位置 |
| %f | 将内容转化为浮点型，放入占位位置 |
！！！注意：多个变量占位，变量要用括号括起来，并按照占位的顺序来填入
代码示例:
# 通过占位的形式，完成字符串拼接
name = "Python小白"
print("我是%s" % name)
# 通过占位形式，完成数字和字符串的拼接
name = "Python小白"
telephone_number = 19970420233
print("我是%s,我的手机号码是:%s"%(name,telephone_number))
# %d、%f的使用
name = "AMG"
setup_year = 2000
stock_price = 19.99
message = "%s,成立于%d,股价是：%f"%(name,setup_year,stock_price)
print(message)
运行结果
方法2—f（没有类型要求，不做精度控制）
格式：f”内容{变量}”
代码示例：
name = "AMG"
setup_year = 2000
stock_price = 19.99
print(f"我是{name},我成立的年份是{setup_year},我的股价是{stock_price}")运行截图：
②.格式化的精度控制
方法：使用辅助符号“m.n”来控制数据的宽度和精度
m：控制宽度，要求是数字（很少使用），设置的宽度小于数字自身不生效
.n：控制小数点精度，要求是数字，会进行小数的四舍五入
小数点和小数部分也算入宽度计算。如，对11.35设置了%7.2f后，结果是：[空格][空格]11.35，两个空格补足宽度，小数部分限制2位精度后进行四舍五入。
代码演示：
num1=11
num2=11.345
print("数字11宽度限制5，结果：%5d"%num1)
print("数字11宽度限制1，结果：%1d"%num1)
print("数字11.345宽度限制7，小数精度2，结果：%7.2f"%num2)
print("数字11.345不限制宽度，小数精度2，结果：%.2f"%num2)运行结果：
③.对表达式进行字符串格式化
表达式就是一条具有明确执行结果的代码语句，在无需使用变量存储数据的时候可以直接格式化表达式简化代码。
方法：f"{表达式}"或"%s/%d/%f"%(表达式)
代码示例:
print("1+1的结果是：%d"%(1+1))
print(f"1*2的结果是{1*2}")
print("字符串在python中的类型名是%s"%(type("string")))字符串格式化练习题：
参考代码:
name = "AMG"
stock_price = 19.99
stock_code = "003032"
stock_price_daily_growth_factor = 1.2
growth_days = 7
after_growth_price = stock_price*stock_price_daily_growth_factor**7
print(f"公司：{name},股票代码：{stock_code},当前股价：{stock_price}")
print("每日增长系数是：%.1f,经过%d的增长后，股价达到了：%5.2f"%(stock_price_daily_growth_factor,growth_days,after_growth_price))运行结果:
（九）数据输入（input语句）
1.input()语句的功能是获取键盘输入的数据
2.可以使用：input(提示信息)，用以在使用者输入内容之前显示提示信息
3.注意：无论键盘输入什么类型的数据，获取到的数据永远是字符串类型
# 输入数字类型
num = input("请告诉我你的银行卡密码：")
print("你的银行卡密码的类型是：",type(num))运行结果：
如果要得到数字类型，就要进行数据类型转换
# 输入数字类型
num = input("请告诉我你的银行卡密码：")
# 数据类型转换
num = int(num)
print("你的银行卡密码的类型是：",type(num))运行结果：
（十）布尔类型
1.自行定义布尔类型
布尔类型的字面量：
- True：表示真（是、肯定）
- False：表示假（否、否定）
定义变量存储布尔类型数据
变量名称 = 布尔类型字面量
代码演示：
# 定义变量存储布尔类型的数据
bool_1 = True
bool_2 = False
print(f"bool_1变量的内容是{bool_1}，类型是{type(bool_1)}")
print(f"bool_2变量的内容是{bool_2}，类型是{type(bool_2)}")
运行结果：
2.通过比较运算符得到布尔类型的结果
布尔类型的数据不仅可以通过定义得到，还可以通过比较运算符进行内容比较得到
代码演示：
# 比较运算符的使用 ==,!=,>,<,>=,<=
# 演示进行内容相等的比较（注意是两个等号）
num1 = 10
num2 = 10
print(f"10==10的结果是：{num1 == num2}")
num1 = 10
num2 = 15
print(f"10!=15的结果是：{num1 != num2}")
name1 = "XANADU"
name2 = "xanadu"
print(f"XANADU==xanadu的结果是：{name1 == name2}")
# 演示“>,<,>=,<=”的比较运算
num1 = 10
num2 = 5
print(f"10>5的结果是：{num1 > num2}")
print(f"10<5的结果是：{num1 < num2}")
num1 = 10
num2 = 10
print(f"10>=10的结果是：{num1 >= num2}")
print(f"10<=10的结果是：{num1 <= num2}")运行结果：
（十一）判断语句
1.if语句的基本格式
基本语法：
if 要判断的条件:
条件成立时，要做的事情
注意：①.冒号不要丢
②.归属于if语句的代码块，需在前方填充4个空格缩进
# 定义变量
age = 26
# 进行判断
if age>=18:
print("已成年")小练习：
参考代码：
# 欢迎语句
print("欢迎来到黑马儿童游乐场，儿童免费，成人收费。")
# 获取键盘输入
age = input("请输入你的年龄:")
age = int(age)
# 通过if判断是否为成年人
if age>=18:
print("您已成年，游玩需要补票10元。")
print("祝您游玩愉快")2.if else语句
基本语法:
if 条件:
满足条件时要做的事情1
满足条件时要做的事情2
满足条件时要做的事情3
...（省略）...
else:
不满足条件时要做的事情1
不满足条件时要做的事情2
不满足条件时要做的事情3
...（省略）...
注意：①else后的代码块，需在前方填充4个空格缩进
②else不需要判断条件
③冒号不要丢
代码示例：
# 欢迎语句
print("欢迎来到儿童游乐场，儿童免费，成人收费。")
# 获取键盘输入
age = input("请输入你的年龄:")
age = int(age)
# 通过if判断是否为成年人
if age>=18:
print("您已成年，游玩需要补票10元。")
else:
print("您未成年，可以免费游玩。")
print("祝您游玩愉快！")3.if elif else语句
基本语法：
if 条件1:
满足条件1时要做的事情
满足条件1时要做的事情
......
elif 条件2:
满足条件2时要做的事情
满足条件2时要做的事情
. .....
elif 条件n:
满足条件n时要做的事情
满足条件n时要做的事情
......
else:
所有条件都不满足应做的事情
所有条件都不满足应做的事情
......
注意：①判断是互斥且有顺序的，上一个满足后面就不会进行判断了
②else可以省略不写，效果等同于前面n个独立的if判断
③空格缩进仍然要有，冒号不要忘记
④可以在条件判断中直接写input语句节省代码量
代码示例：
# 定义一个变量数字
guess_number = 10
#通过键盘输入猜想的数字，通过多次if和elif的组合进行猜想比较
if int(input("请输入第一次猜想的数字：") == guess_number):
print("恭喜你猜对啦！我想的就是10")
elif int(input("不对，再猜一次：") == guess_number):
print("恭喜你猜对啦！我想的就是10")
elif int(input("不对，再猜最后一次：") == guess_number):
print("恭喜你猜对啦！我想的就是10")
else:
print("Sorry，全部猜错啦，我想的是10")运行结果：
4.判断语句嵌套
基础语法格式：
if 条件1:
满足条件1做的事情1
满足条件1做的事情2
if 条件2:
满足条件2做的事情1
满足条件2做的事情2
如上，第二个if，属于第一个if内，只有第一个if满足条件才会执行第二个if
注意：①.嵌套判断语句可以用于多条件、多层次的逻辑判断
②.嵌套判断语句可以根据需求，自由组合if elif else来构建多层次判断
③.嵌套判断语句一定要注意空格缩进，Python通过空格缩进来决定层次关系
代码示例：
# 构建一个随机的数字变量
import random
num = random.randint(1,10)
guess_number = int(input("请输入你猜测的数字:"))
# 通过if判断语句将进行数字猜测
if guess_number == num:
print("恭喜第一次就猜中了！")
else:
if guess_number > num:
print("你猜测的数字大了")
else:
print("你猜测的数字小了")
guess_number = int(input("再次输入你猜测的数字:"))
if guess_number == num:
print("恭喜猜中了！")
else:
if guess_number > num:
print("你猜测的数字大了，还有最后一次机会")
else:
print("你猜测的数字小了，还有最后一次机会")
guess_number = int(input("再次输入你猜测的数字（注意这是最后一次机会）:"))
if guess_number == num:
print("恭喜猜中了！")
else:
if guess_number > num:
print("三次机会用完了，没有猜中")运行截图：
（十二）循环语句
1．While循环
（1）while循环基础知识
基础语法：
while 条件：
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...（省略）...
注意：①只要条件满足，循环就会一直进行
②while的循环条件需得到布尔类型，True表示继续循环，False表示结束循环
③需要设置循环终止的条件，如i += 1配合i<100，就能确保100次后停止（i初始值为0），否则将无限循环
④空格缩进和if判断一样，都需要设置
代码示例：
i = 1
sum = 0
while i<=100:
sum += i
i+=1
print("sum is %s"%sum)运行结果：
（3）案例使用—打印九九乘法表
代码示例：
# 定义外层循环的控制变量
i = 1
while i <= 9:
# 定义内层循环的控制变量
j = 1
while j<=i:
# 内层循环的print语句不换行，通过\t进行对齐
print(f"{j}*{i}={i*j}\t",end='')
j += 1
i += 1
print() # print空内容，就是输出一个换行运行结果：
2.for循环
（1）基础语法
for 临时变量 in待处理的数据集：
循环满足条件时执行的代码
注意：①for循环是将字符串的内容：依次取出
②同while循环不同，for循环无法定义循环条件，只能从被处理的数据集中依次取出内容进行处理。
③循环内的语句需要有空格缩进。
示例代码：
name = "All I have to do is nothing but to be brave."
# 定义一个变量用于记录name中o出现的次数
count = 0
# for循环统计
for temp in name:
if temp == 'o':
count +=1
print(f"name中共有{count}个字母o")运行结果：
（2）range语句
功能：获取一个数字序列，与for循环结合可以确定for循环的执行次数
语法：①range（num）
表示从0开始，到num结束（不含num本身）
②range（num1，num2）
表示从num1开始，到num2结束（不含num2本身）
③range（num1，num2，step）
表示从num1开始，到num2结束（不含num2本身），步长以step为准
（3）嵌套使用
基础语法：
for 临时变量 in待处理的数据集：
循环满足条件时执行的代码1
循环满足条件时执行的代码2
循环满足条件时执行的代码3
……
for 临时变量 in待处理的数据集：
循环满足条件时执行的代码1
循环满足条件时执行的代码2
循环满足条件时执行的代码3
……
注意：①注意空格缩进，嵌套for循环同样通过索金莱确定层次关系
②for循环和while循环可以相互嵌套使用
# 通过外层循环控制行数
for x in range(1,10):
# 通过内层循环控制每一行的输出
for y in range(1,x+1):
print(f"{y}*{x}={x*y}\t",end='')
print()（4）continue（临时中断）和break（直接结束）
①continue
continue的嵌套使用：
如下，语句1、语句2和语句4都可以执行，但是语句3不行
②break
（5）综合练习
参考代码：
# 练习案例：发工资
import random
# 定义账户余额
count_money = 10000
# 利用for循环发放工资
for i in range(1,21):
if count_money == 0:
print("工资发完了，下个月领取吧。")
break
score = random.randint(1, 10)
# 判断绩效
if score < 5:
print(f"员工{i},绩效分{score},不发工资，下一位。")
# 跳过绩效分不足的员工
continue
else:
count_money -= 1000
print(f"向员工{i}发放工资1000元，账户余额还剩{count_money}")运行结果：
（十三）函数
1.基础知识
函数：组织好的可重复使用的，用来实现特定功能的代码块。
为什么使用函数：为了得到一个针对特定需求、可供重复利用的代码段提高程序的复用性，减少重复代码，提高开发效率。
（1）函数的基础定义语法
函数的定义：
def 函数名（传入参数）：
函数体（函数要做的事情）
return 返回值
函数的调用：函数名（参数）
注意事项：①参数如不需要，可以省略
②返回值如不需要，可以省略
③函数必须先定义后使用
2.函数的传入参数
功能：在函数进行计算的时候，接受外部（调用时）提供的数据
基于函数的定义语法(注意缩进）：
def 函数名（传入参数）：
函数体
return 返回值
代码示例：
# 定义两数相加的函数，通过参数接受被计算的两个数字
def add(x,y):
result = x + y
print(f"{x}+{y}的结果是{result}")
# 调用函数，传入被计算的2个数字
add(1997,420)解析：
函数定义中，提供的x和y称为形式参数（形参），表示函数声明将要使用2个参数，参数之间使用逗号进行分隔。
函数调用中，提供的1997和420，称之为实际参数，表示函数执行时真正使用的参数值，传入的时候按照顺序传入数据使用逗号分隔。
注意：传入参数的数量是不受限制的，可以不使用参数，也可以使用n个参数。
练习案例：
参考代码：
# 定义体温监测函数
def check(x):
if x <= 37.5:
print(f"体温监测中，您的体温是:{x}，体温正常请进！")
else:
print(f"体温监测中，您的体温是:{x}，需要隔离！")
# 调用函数
print("请输入您的体温：")
x = input()
x = float(x)
check(x)3.函数的返回值
（1）基本定义
解释：程序中函数完成事情过后给调用者的结果
语法格式：
def 函数（参数…）
函数体
Return 返回值
变量 = 函数（参数）
注意：函数体在遇到return语句后就结束了，所以写在return后的代码不会执行。
（2）None类型
Python中特殊的字面量：None，其类型是：<class.'NoneType'>
无返回值的函数实际上就是返回了None这个字面量。
应用场景：
- 用在函数无返回值上
- 在if判断中，None等同于False
一般用于在函数中主动返回None，配合if判断做相关处理
示例代码：
# None用于if判断
def check_age(age):
if age > 18:
print("SUCCESS")
else:
return None
result = check_age(16)
if not result:
# 进入if表示result是None值，也就是False
print("未成年不可以进入")运行结果：
未成年不可以进入
- 用于声明无内容的变量上
定义变量，但赞数不需要变量有具体值，可以用None来代替
示例代码：name = None
4.说明文档
对函数进行说明解释，帮助更好理解函数的功能
：param用于解释参数
：return用于解释返回值
示例代码：
def add(x,y):
"""
add函数可以接受两个参数，进行两数相加的功能
:param x: 形参x表示相加的其中一个数字
:param y: 形参y表示相加的另一个数字
:return: 返回值是两数相加的结果
"""
result = x+y
print(f"x+y=:{result}")
return (result)（十四）数据容器
1.基础知识
数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素可以是任意类型的数据，如字符串、数字、布尔等。
数据容器的分类：数据容器根据特点的不同，如“是否指出重复元素”、“是否可以修改”等分为五类，分别是：列表（list）、远组（tuple）、字符串（str）、集合（set）、字典（dict）。
2.列表（list）
（1）列表的定义
基本语法：
# 字面量
[元素1，元素2，元素3，元素4……]
# 定义变量
变量名称=[元素1，元素2，元素3，元素4……]
# 定义空列表
变量名称=[]
变量名称=list()
注意：①列表内的每一个数据称为元素，以[]作为标识，列表内的每一个元素用逗号隔开
②元素类型没有任何限制，甚至可以是列表，这样就构成了嵌套列表
示例代码：
# 定义一个列表list
my_list=["Xin Liu",26,"女"]
print(my_list)
print(type(my_list))
# 定义一个嵌套的列表
my_list=[[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))运行结果：
（2）列表的下标（索引）
正向：
示例代码：
# 通过下标索引取出对应位置的元素
my_list = ["Tom","Lily","Rose"]
# 列表[下标索引],从前往后从0开始，每次+1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范，不能超出范围！！！
print(my_list[3])
运行结果：
反向：
示例代码：
# 通过下标索引取出对应位置的元素
my_list = ["Tom","Lily","Rose"]
# 列表[下标索引],从后往前开始。从-1开始，每次-1
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])运行结果：
嵌套：
示例代码：
# 取出嵌套列表的元素
my_list = [[1,2,3],[4,5,6]]
print(my_list[1][1])运行结果：5
（3）列表的常用操作
方法和函数功能一样，有传入参数和返回值，只是方法的使用格式不同
函数的使用：num = add(1,2)
方法的使用：student=Student()
num = student.add(1,2)
a.查询某元素的下表
功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表.index（元素）
index就是列表对象（变量）内置的方法（函数）
示例代码：
my_list = ["Tom","Lily","Rose"]
# 查找某元素在列表内的下标索引
index1 = my_list.index("Tom")
print(f"Tom在列表中的下标索引是：{index1}")
# 若查找的元素不存在
index2 = my_list.index("XANADU")
print(f"XANADU在列表中的下标索引是：{index2}")运行结果：
②修改特定位置（索引）的元素值
示例代码：
my_list = ["Tom","Lily","Rose"]
# 修改特定下标的元素值
my_list[1]="XANADU"
print(f"列表被修改后结果是：{my_list}")运行结果：
c.插入元素
语法：列表.insert(下标，元素),在指定的下标位置插入指定的元素
示例代码：
my_list = ["Tom","Lily","Rose"]
# 插入元素
my_list.insert(0,"XANADU")
print(f"列表插入元素后结果是：{my_list}")运行结果：
d.追加元素
语法：列表append（元素），将指定元素追加到列表尾部
示例代码：
my_list = ["Tom","Lily","Rose"]
# 追加元素
my_list.append("XANADU")
print(f"列表追加元素后结果是：{my_list}")运行结果：列表追加元素后结果是：['Tom', 'Lily', 'Rose', 'XANADU']
追加元素方法2：
语法：列表.extend(其他数据容器)，将其他数据容器的内容取出来，依次追加到列表尾部
示例代码：
my_list = ["Tom","Lily","Rose"]
# 追加元素2
my_list2 = [1,2,3]
my_list.extend(my_list2)
print(f"列表追加新的列表后结果是：{my_list}")运行结果：列表追加新的列表后结果是：['Tom', 'Lily', 'Rose', 1, 2, 3]
e.删除
语法1 ：del列表[下标]
语法2 ：列表.pop（下标）—可以得到返回值
示例代码：
my_list = ["Tom","Lily","Rose"]
# 删除元素
# 方法1:del列表[下标]
del my_list[1]
print(my_list)
#方法2:列表.pop（下标）
element = my_list.pop(0)
print(f"取出的元素是{element}，取出后列表为{my_list}")运行结果：
['Tom', 'Rose']
取出的元素是Tom，取出后列表为['Rose']
f.删除某元素在列表中的第一个匹配项
语法：列表.remove（元素）
示例代码：
my_list = ["Tom","Lily","Rose","Tom","Lily","Rose"]
# 删除某元素在列表中的第一个匹配项
my_list.remove("Lily")
print(my_list)运行结果：['Tom', 'Rose', 'Tom', 'Lily', 'Rose']
g.清空列表
语法：列表.clear()
示例代码：
my_list = ["Tom","Lily","Rose","Tom","Lily","Rose"]
# 清空列表
my_list.clear()
print(my_list)运行结果：[]
h.统计某元素在列表中的数量
语法：列表.count()
示例代码：
my_list = ["Tom","Lily","Rose","Tom","Lily","Rose"]
count = my_list.count("Rose")
print(f"列表中Rose的数量是{count}")运行结果：列表中Rose的数量是2
i.统计列表内元素个数
语法：len(列表)
示例代码：
my_list = ["Tom","Lily","Rose","Tom","Lily","Rose"]
print(f"列表中元素个数为{len(my_list)}")运行结果：列表中元素个数为6
（4）列表特点
①可容纳多个元素
②可容纳不同类型的元素
③数据是有序存储的（有下标序号）
④允许重复数据存在
- 可以修改元素
（5）列表的遍历
①while循环
示例代码：
# while循环遍历列表元素
# 定义函数
def list_while_func(my_list):
index = 0
while index < len(my_list):
element = my_list[index]
index += 1
print(element)
# 调用函数
my_list = ["战斗到最后！","GoGo!!!","下一个绿洲！","HopeHope!!!"]
list_while_func(my_list)运行结果：
战斗到最后！
GoGo!!!
下一个绿洲！
HopeHope!!!
②for循环
语法：
for 临时变量 in 数据容器：
对临时变量进行处理
表示从容器内依次取出元素并赋值到临时变量上。在每一次循环中，我们可以对临时变量（元素）进行处理。
示例代码：
# for循环遍历列表元素
# 定义函数
def list_for_func(my_list):
for element in my_list:
print(element)
# 调用函数
my_list = ["战斗到最后！","GoGo!!!","下一个绿洲！","HopeHope!!!"]
list_for_func(my_list)运行结果：与上一个代码运行结果一致
③for循环与while循环比较：
a.while循环和for循环，都是循环语句，但细节不同在循环控制上:while循环可以自定循环条件，并自行控制。for循环不可以自定循环条件，只可以一个个从容器内取出数据在无限循环上。
b.while循环可以通过条件控制做到无限循环，for循环理论上不可以，因为被遍历的容器容量不是无限的在使用场景上。
c.while循环适用于任何想要循环的场景for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
3.元组
元组和列表一样，都是可以封装多个、不同类型的元素在内，但是元组一旦定义完成就不可以被修改
（1）基础知识
定义语法：元组使用小括号定义，且使用逗号隔开各个数据，数据可以是不同的数据类型。
# 定义元组字面量
（元素，元素，元素，元素，元素，元素……元素，元素）
# 定义元组变量
变量名称 = （元素，元素，元素，元素，元素，元素……元素，元素）
# 定义空元组
变量名称 = （） #方式1
变量名称 = tuple（） #方式2
示例代码：
# 定义元组
t1 = (420,"XinLiu",True)
t2 = ()
t3 = tuple()
# 打印出来
print(f"t1的类型是：{type(t1)},内容是{t1}")
print(f"t2的类型是：{type(t2)},内容是{t2}")
print(f"t3的类型是：{type(t3)},内容是{t3}")
# 定义单个元素的元素:一定要在后面加一个单独的逗号！！！
t4 = ("hello",)
print(f"t4的类型是：{type(t4)},内容是{t4}")
# 元组的嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的类型是：{type(t5)},内容是{t5}")
# 下标索引去取出内容
element = t5[1][2]
print(element)运行结果：
t1的类型是：<class 'tuple'>,内容是(420, 'XinLiu', True)
t2的类型是：<class 'tuple'>,内容是()
t3的类型是：<class 'tuple'>,内容是()
t4的类型是：<class 'tuple'>,内容是('hello',)
t5的类型是：<class 'tuple'>,内容是((1, 2, 3), (4, 5, 6))
6
（2）元组的相关操作
示例代码：
# 定义元组
t1 = (420,"XinLiu",True,420,"XinLiu",True)
# 元组的操作：index查找方法
index = t1.index("XinLiu")
print(f"在t1中查找XinLiu对应的下标是{index}")
# 元组的操作：count查找方法
count = t1.count("XinLiu")
print(f"在t1中统计XinLiu的数量是{count}")
# 元组的操作：len统计元组中元素数量
num = len(t1)
print(f"t1中元素数量是{num}")运行结果：
在t1中查找XinLiu对应的下标是1
在t1中统计XinLiu的数量是2
t1中元素数量是6
（3）元组的遍历
for循环和while循环
示例代码：
# 定义元组
t1 = (420,"XinLiu",True)
# for循环
print("-----for循环-----")
for element in t1:
print(element)
# while循环
print("----while循环----")
index = 0
while index<len(t1):
print(t1[index])
index += 1运行结果：
-----for循环-----
420
XinLiu
True
----while循环----
420
XinLiu
True
（4）特点
①可容纳多个元素
②可容纳不同类型的元素
③数据是有序存储的（有下标序号）
- 允许重复数据存在
- 元组的元素是不可以修改的！也有特例，可以修改内部list内的元素
4.字符串（数据容器视角下）
（1）字符串的下标索引
（2）字符串的修改
同元组一样，字符串是一个无法修改的数据容器。
所以:修改指定下标的字符(如:字符串[0]=“a”)、移除特定下标的字符(如:del字符串[0]、字符串.remove()、字符串.pop()等)、追加字符等(如:字符串.append())均无法完成。
（3）字符串的常用操作
①查找特定字符串的下标索引值
语法:字符串.index(字符串)
②字符串的替换
语法:字符串.replace(字符串1，字符串2)
功能:将字符串内的全部:字符串1，替换为字符串2
注意:不是修改字符串本身，而是得到了一个新字符串哦
示例：
my_str = "XANADU永不落幕"
# replace方法
my_new_str = my_str.replace("XANADU","仙那度")
print(f"\"{my_str}\"进行替换后得到\"{my_new_str}\"")运行结果："XANADU永不落幕"进行替换后得到"仙那度永不落幕"
③字符串的分割
语法:字符串.split(分隔符字符串)
功能:按照指定的分隔符字符串，将字符串划分为多个字符串，并存列表对中
注意:字符串本身不变，而是得到了一个列表对象
示例：
my_str = "hello python fighting!"
# split方法
my_new_str = my_str.split(" ")
print(f"\"{my_str}\"进行split切分后得到\"{my_new_str}\"，类型是{type(my_new_str)}")运行结果：
"hello python fighting!"进行split切分后得到"['hello', 'python', 'fighting!']"，类型是<class 'list'>
④字符串的规整操作(去前后空格或回车符)
语法:字符串.strip()
my_str =" itheima and itcast "
print(my_str.strip())
#结果:"itheima and itcast
字符串的规整操作(去前后指定字符串)
语法:字符串.strip(字符串)
my_str ="12itheima and itcast21"
print(my_str.strip("12"))
#结果:"itheima and itcast"
注意，传入的是“12”其实就是:“1”和“2”都会移除，是按照单个字符。
示例：
my_str = " hello python and fighting! "
# strip方法
my_new_str = my_str.strip()
print(f"\"{my_str}\"进行strip操作后得到\"{my_new_str}\"")
my_str2 = "33hello python and fighting!3"
my_new_str2 = my_str.strip("33")
print(f"\"{my_str2}\"进行strip操作后得到\"{my_new_str2}\"")运行结果：
" hello python and fighting! "进行strip操作后得到"hello python and fighting!"
"33hello python and fighting!3"进行strip操作后得到" hello python and fighting! "
⑤利用count方法统计字符串中某字符串出现次数
my_str = "hello python and fighting!"
# count方法
count = my_str.count("h")
print(f"{my_str}中\"h\"出现的次数是{count}")运行结果：
hello python and fighting!中"h"出现的次数是3
⑥length方法统计
my_str = "hello python and fighting!"
# len方法
num = len(my_str)
print(f"{my_str}的长度是{num}")运行结果：
hello python and fighting!的长度是26
（4）字符串的特点
只可以存储字符串
长度任意(取决于内存大小)
支持下标索引
允许重复字符串存在不可以修改(增加或删除元素等)
支持for循环
5.数据容器（序列）的切片操作
序列支持切片，即:列表、元组、字符串，均支持进行切片操作
切片:从一个序列中，取出一个子序列
语法:序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾
步长表示，依次取元素的间隔
- 步长1表示，一个个取元素
- 步长2表示，每次跳过1个元素取
- 步长N表示，每次跳过N-1个元素取
- 步长为负数表示，反向取(注意，起始下标和结束下标也要反向标记)
注意，此操作不会影响序列本身，会得到新的序列。
示例代码：
# 对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5]
result1 = my_list[1:4] # 步长默认为1 ，可以不写
print(f"结果1：{result1}")
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:] # 起始和结束不屑表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")
# 对字符串进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")
# 对字符串进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1] # 等同于将序列反转
print(f"结果4：{result4}")
# 对list进行切片，从3开始，1结束，步长-1
my_list = [0,1,2,3,4,5]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")
# 对tuple进行切片，从头开始，到最后结束，步长-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")运行结果：
结果1：[1, 2, 3]
结果2：(0, 1, 2, 3, 4, 5, 6)
结果3：0246
结果4：76543210
结果5：[3, 2]
结果6：(6, 4, 2, 0)
6.set集合
（1）基本语法
# 定义集合字面量
{元素，元素，……，元素}
# 定义集合变量
变量名称 = {元素，元素，……，元素}
# 定义空集合
变量名称 = set（）
示例：
# 定义一个基础的集合
my_set = {"one","two","three","one","two","three","one","two","three"}
print(my_set)
my_set_empty = {}
print(my_set_empty)运行结果：
{'two', 'one', 'three'}
{}
结论：①集合时无序的 ②集合有去重功能
（2）集合的常用操作
①修改
代码示例：
# 定义一个基础的集合
my_set = {"one","two","three","one","two","three","one","two","three"}
# 添加新元素
my_set.add("four")
my_set.add("one")
print(my_set)运行结果：
{'two', 'one', 'three', 'four'}
②移除元素
③从集合中随机取出元素
语法：集合.pop()
功能：从集合中随机取出一个元素
结果：会得到一个元素的结果，同时集合本身被修改，元素被移除
示例：
# 定义一个基础的集合
my_set = {"one","two","three","one","two","three","one","two","three"}
# 随机取出元素
element = my_set.pop()
print(f"集合被取出的元素是{element}")
print(f"集合现在的内容是：{my_set}")运行结果：
集合被取出的元素是three
集合现在的内容是：{'one', 'two'}
③清空集合
语法：集合.clear()
④取出两个集合的差集
语法：集合1.difference（集合2）
功能：取出两个集合的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变
示例：
# 取两个集合的差集
set1 = {0,1,2,3,4}
set2 = {1,3}
set3 = set1.difference(set2)
print(f"取出差集后的结果是{set3}")
print(f"取出差集后，set1的结果是{set1}")
print(f"取出差集后，set2的结果是{set2}")运行结果：
取出差集后的结果是{0, 2, 4}
取出差集后，set1的结果是{0, 1, 2, 3, 4}
取出差集后，set2的结果是{1, 3}
⑤消除2个集合的差集
语法：集合1.difference_update（集合2）
功能：对比两个集合，在集合1内删除与集合2相同的元素
结果：集合1被修改，集合2不被修改
示例：
# 消除两个集合的差集
set1 = {0,1,2,3,4}
set2 = {1,3}
set1.difference_update(set2)
print(f"消除差集后，set1的结果是{set1}")
print(f"消除差集后，set2的结果是{set2}")运行结果：
消除差集后，set1的结果是{0, 2, 4}
消除差集后，set2的结果是{1, 3}
⑥合并集合
语法：集合1.union（集合2）
功能：将两集合合并成新集合
结果：得到新集合，集合1与集合2不变
示例：
# 消除两个集合的差集
set1 = {0,1,2,4}
set2 = {1,3}
set3 = set1.union (set2)
print(f"合并集合后，新集合set3的结果是：{set3}")
print(f"合并差集后，set1的结果是{set1}")
print(f"合并差集后，set2的结果是{set2}")运行结果：
合并集合后，新集合set3的结果是：{0, 1, 2, 3, 4}
合并差集后，set1的结果是{0, 1, 2, 4}
合并差集后，set2的结果是{1, 3}
⑦统计集合元素数量
语法：集合.len()
示例：
set1 = {0,1,2,4,0,1,2,4}
num = len(set1)
print(f"集合的元素个数是{num}")运行结果：
集合的元素个数是4
⑧集合的遍历
可以使用for循环，while不可以（存疑）
示例：
set1 = {0,1,2,4,0,1,2,4}
for element in set1:
print(f"集合的元素有{element}")运行结果：
集合的元素有0
集合的元素有1
集合的元素有2
集合的元素有4
（3）集合的特点
①可以容纳多个数据
②可以容纳不同类型的数据
③数据时无序存储的（不支持下标索引）
④不允许重复数据存在
⑤可以修改（增加或删除元素等）
⑥支持for循环
目录
扫一扫
176
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
