大数据第二阶段Python基础编程学习笔记（待完善）
第二阶段笔记已经完成并上传，但是图片还是没有上传成功。感兴趣的见下方链接
https://blog.csdn.net/m0_58761957/article/details/128306911?spm=1001.2014.3001.5502
第一章 Python基础语法 3.8
1-1Python概述
python基础部分：
●Python基础语法: 标识符，关键字，变量，判断循环。。。。
●容器类型(数据类型中的高级类型)
●函数
●文件处理
●面向对象
●包和模块
●异常处理
知道自己能够解决什么问题
能够解决自己没有遇到过的问题
坚信自己能够解决自己没有遇到的这个问题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XHdcLRTv-1668173397866)(img/image-20221108211931165.png)]
1、为啥学Python？
1.技术趋势，要用。
2.简单易学。
3.应用广泛。Python语言涉及IT行业70%以上的技术领域。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1EGcsJjr-1668173397868)(img/image-20221111180533540.png)]
Python语言的创始人 吉多·范罗苏姆 龟叔
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1h1ui0si-1668173397868)(img/20171018174524234)]
2、Python 2.x与Python 3.x版本对比
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FEHTCscJ-1668173397869)(img/image-20221110154034531.png)]
3、本次学习3.8版本
Python是一种跨平台的计算机程序设计语言。是一个高层次的结合了解释性、编译性、互动性和面向对象的语言。最初被设计用于编写自动化脚本Shell (适用于Linux操作系统)，随着版本的不断更新和语言新功能的添加，逐渐被用于独立的，大型项目的开发。
其实目前很多知名的机器学习，人工智能以及深度学习框架也都是基于Python语言进行开发的:
●Google开源机器学习框架: TensorFlow
●开源社区主推学习框架: Scikit-learn
●百度开源深度学习框架: Paddle
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H4c85Guk-1668173397869)(img/image-20221108212948034.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vDS0lymX-1668173397869)(img/image-20221108213144902.png)]
1-2Python环境搭建
1、Python解释器的作用
Python解释器的作用：将python语言编程的代码解释为机器语言（二进制文件）的一种工具。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EKYTKTOY-1668173397870)(img/image-20221109135011212.png)]
2、Python解释器种类
①CPython, C语言开发的解释器[官方],应用广泛的解释器。官方版本，稳定，持续更新
②lPython,基于CPython的一种交互式解释器。可交互，在CPython基础上进行了升级
③其他解释器
PyPy,基于Python语言言开发的解释器。
JPython,运行在Java平台的解释器，直接把Python代码编译成Java字节码文件。
lronPython,运行在微软.Net平台上的Python解释器，可直接把Python代码编译成.Net的字节码。
3、下载Python解释器 python-3.10.0-amd64.exe
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Aj6zPKxg-1668173397870)(img/image-20221110162203469.png)]
4、Pycharm
4.1 PyCharm是-种Python IDE (集成开发环境) ,带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，内部集成的功能如下:
Project管理
智能提示
语法高亮
代码跳转
调试代码
4.2Pycharm分为专业版和社区版。我们下载安装社区版本就够用了。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8dk3hNET-1668173397871)(img/image-20221110162619264.png)]
4.3 去官网下载安装pycharm社区版。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qyRx6DCW-1668173397871)(img/image-20221110162751744.png)]
4.4新建新项目
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vJB0Ttd2-1668173397871)(img/image-20221110162917022.png)]
4.5创建新python文件
test01.py
4.6 HelloWorld
print('Hello World!')
4.7 pycharm配置
主题配置（不配置也不影响）、
字体配置（不配置也不影响）、
项目解释器配置、
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VapyFcNy-1668173397871)(img/image-20221110164226430.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ghjOmalf-1668173397871)(img/image-20221110163937799.png)]
4.8 项目管理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nVQmBFOw-1668173397872)(img/image-20221110164122977.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hYi0S6tv-1668173397872)(img/image-20221110164153272.png)]
1-3变量与注释
1.注释
单行注释：# 注释内容（单行注释在一行的开头要留一个空格。单行注释在行末要留两个空格。）
多行注释：三对单引号或三对双引号。
# 这个就是单行注释（注意要有空格）
"""
这是个多行注释
"""
'''
这也是个多行注释
'''
ctrl+/ 单行注释快捷键
多行注释不能放在一行的。末尾都用单行注释，这种了解就行。
单行注释和多行注释颜色不一样，其他都一样。
2.变量
变量，就是存放数据的，一个有名字的盒子。
变量名就是盒子的名字，数据装在盒子中。
变量定义的基本语法：
变量名 = 变量值
=两边都要保留一个空格，变量名可以自定义，但是要满足标识符命名规则。
在python中变量必须赋值否则报错。
3.标识符的命名规则
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UyDfZqHA-1668173397872)(img/image-20221108220858464.png)]
标识符和关键字：
标识符是自己定义的名字。关键字是提前定义好的名字，我们新起的名字不能与其重名。
在windows中文件名定义时不严格区分大小写。
1-4变量与debug工具
1、标识符命名规范
1。变量命名，一定要做到见名知义
2。大驼峰:即每个单词首字母都大写，例如: MyName （类名）
3。小驼峰:第二个(含)以后的单词首字母大写，例如: myName
4。划线:例如: my_name (变量名、函数名、包名、模块名使用下划线命名法)
name = '小明'
num = 10
2、变量的使用
所有的变量要先定义再调用。
3、变量的数据类型
注意：
布尔类型的值只能是True或False,其他的都不行，大小写不一致也不行。TRUe、TRUE等都不行。
●int 整型 ---------123，12，33 …
●float 浮点型-----12.202,32.98 …
●bool 布尔型-----True、False
●str 字符串-------‘Hello’,“Hello” …
●list 列表-----------name[‘Tom’,‘Jerry’,‘zhangsan’] …
●tuple 元组---------test1 = (10, 20, [‘aa’, ‘bb’, ‘cc’], 50, 30)、test2 = (10, 20, 50, 30) …
●set 集合-----------s1 = {10, 20, 30, 40, 50} …
●dict 字典-----------dict1 = {‘name’: ‘Tom’, ‘age’: 20, ‘gender’: ‘male’} …
# 数据类型查看的函数
type(数据/变量名)
# 例如：
int1 = 12
print(type(int1)) # pycharm 格式化快捷键( ctrl + alt + L)
4、Bug 和 Debug
1、bug：程序中的错误
2、Debug：Debug工具是PyCharm IDE中集成的专门用来调试程序的工具，在这里程序员可以查看程序的执行细节和流程，以方便我们快速找出程序的Bug
Debug工具使用二步走:①打断点②Debug调试
2.1、打断点
断点位置：断点要定位在Python代码段的第一行即可
打断点的方法：在需要调试代码行的行号位置右侧的空白处单击即可
2.2、Debug调试
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MwjNA55h-1668173397873)(img/image-20221109144047980.png)]
Debug输出面板分类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xLbDXJne-1668173397873)(img/image-20221109144121516.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j3FdffJe-1668173397873)(img/image-20221109145358184.png)]
●bug调试工具的使用
。打断点:在行号后边点击出现小红点
。右键debug进 入调试模式，代码执行暂停到断点位置代码执行之前
■debugger: 查看参数及变量在执行过程中的变化情况
■console: 查看控制台输出内容
■stepover: 单步执行代码
■resume:执行到下一次断点位置或程序结束
■stop:让程序终止
易错点
进入Debug模式之前一定要先打断点。否则程序直接全部执行。
1-5格式化输出
1、输出
程序输出给用户
2、格式化输出
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f2Hv4otW-1668173397874)(img/image-20221109151431456.png)]
字符串格式化：格式化是字符串所具有的功能
print输出：print函数只能将传入的内容显示到控制台中，与格式化没有任何关系。
age = 16
str1 = '小明 %d 岁'% age
print(str1)
# 输出
# 小明 16 岁
# 格式："字符串，占位符"%变量
# 在上述格式中，格式化完成后，会将占位符位置上填充上对应的变量。
# 不同数据类型的变量，要使用不同的占位符
# 字符串数据使用 %s
# 浮点型数据使用 %f
# 浮点型数据使用 %.2f，浮点数精确到小数点后两位。
# 整形数据使用 %d
# 整形数据使用 %6d，控制int型数值为6为，不足补0。
name = "xiaoming"
age = 18
height = 1.85
weight = 61.5
marrage = False
print("小明的姓名是%s，今年%d岁，身高为%f,体重为%f,婚姻状态为%s" %(name,age,height,weight,marrage))
注意
自动换行效果：点击View -> Active Editor -> 点击soft-wrap
一个输出中引用多个变量，%后面的所有变量名要放在小括号中。否则报错。
TypeError: not enough arguments for format string
占位符的数量和变量的数量和顺序都要保持一致。否则报错。
f-格式化字符串是Python3.6中新增的格式化⽅法，该方法更简单易读。
1-6输入与类型转化
1、转义字符
\n ：换行符
\t ：制表符，一个tab键（4个空格）的距离
%% ：输出%
为什么print的输出自带换行效果？
按住 Ctrl键 鼠标点击 print,进入print的源码界面。
def print( self , *args , sep=' ' , end='\n' , file=none ):
通过源码可以看出，print在结尾自动加入了\n。
end='$$$'
# 此操作可以使此print的无法自动换行。而是直接输出$$$
print(123,'sf',end='$$$')
"""
实现原理：
end='$$$'
此操作将print运行中的end的值由"/n"换成了"$$$"
"""
2、f-string (Python3.6以后推出的格式化方式)
f-string是Python3.6以后推出的格式化方式。
格式：f'要输出的内容{变量}'
print("小明的姓名是%s，今年%d岁，身高为%f,体重为%f,婚姻状态为%s" %(name,age,height,weight,marrage))
上式，用f-string表示，等价于
print(f"小明的姓名是{name}，今年{age}岁，身高为{height},体重为{weight},婚姻状态为{marrage}" )
如果需要调整精度：
print(f"小明的姓名是{name}，今年{age:03d}岁，身高为{height:.2f},体重为{weight:.2f},婚姻状态为{marrage}" )
3、input输入
# 输入使用的是input函数
# 格式：input(提示字符)
# 使用功input函数会造成程序阻塞，等待输入信息。按enter键输入
input('请输入一个字母：')
num = input('请输入一个数字')
print(num)
练习：按要求输入账号和密码，并将账号和密码打印
account = input('请输入您的账号：')
password = input('请输入您的密码：')
print('您的账号是%s,您的密码是%d' %account,password)
4、数据类型转换
| 函数 | 说明 |
|---|---|
| int(x [,base ]) | 将x转换为一个整数 |
| float(x) | 将x转换为一个浮点数 |
| complex(real [,imag ]) | 创建一个复数，real为实部，imag为虚部 |
| str(x) | 将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| chr(x) | 将一个整数转换为一个Unicode字符 |
| ord(x) | 将一个字符转换为它的ASCII整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |
| bin(x) | 将一个整数转换为一个二进制字符串 |
int类型的数据转换成float类型的数据，在整数末尾加.0。
int类型的数据转换成字符串类型的数据，可以随意转换。
float类型的数据转换成int类型的数据，只保留整数部分。
float类型的数据转换成字符串类型的数据，可以随意转换。
字符串型数据想要转化成int类型，字符串中的数据必须是int类型。其他类型都不行。
字符串型数据想要转化成float类型数据，字符串中的数据必须是数值类型数据。
1-7Python运算符
在除法运算中结果必定是浮点数。
浮点型参与运算后结果一定是浮点型。
算术运算符
赋值运算符
复合赋值运算符
比较运算符
逻辑运算符
1、算数运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 1 + 1 输出结果为 2 |
| - | 减 | 1 - 1 输出结果为 0 |
| * | 乘 | 2 * 2 输出结果为 4 |
| / | 除 | 10 / 2 输出结果为 5 |
| // | 整除 | 9 // 4 输出结果为2 |
| % | 取余（取模） | 9 % 4 输出结果为 1 |
| ** | 幂指数 | 2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2 |
| () | 小括号 | 小括号用来提高运算优先级，即 (1 + 2) * 3 输出结果为 9 |
2、算数运算符优先级
混合运算优先级顺序：( ) 高于 ** 高于 * / // % 高于 + -
3、赋值运算符
给变量赋值
a = 10
给多个变量赋值
a,b,c = 10,"计算机",12.8
给多个变量赋相同值
a = b = c = 10
4、符合赋值运算符
+= a += b 相当于 a = a+b
-= a -= b 相当于 a = a-b
*= a *= b 相当于 a = a*b
/= a /= b 相当于 a = a/b
//= a //= b 相当于 a = a//b
%= a %= b 相当于 a = a%b
**= a **= b 相当于 a = a**b
5、比较运算符
<
>
==
!=
>=
<=
<>不可以使用
6、逻辑运算符
and
or
not
7、短路运算
python 把 0、none、空字符串，看成False，其他数值和非空字符串都看成True:
a and b :如果a是False那结果必为False,因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
8、运算符的优先级
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p4RH2JJX-1668173397874)(img/image-20221111182902768.png)]
不用太过纠结，自己编程时不太确定的可以直接打括号提升优先级
1-8Python分支语句
1、if
if基本语法
if 条件:
条件成立执行的代码1
条件成立执行的代码2
......
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bitR8qxv-1668173397874)(img/image-20221111183251696.png)]
2、if…else…
if 条件:
条件成立，执行的代码1
else:
条件不成立，执行的代码2
age = int(input('请输入您的年龄：'))
if age >= 18:
print(f'您的年龄是{age},已经成年，可以上网')
else:
print(f'您的年龄是{age},未成年，请自行回家写作业')
print('系统关闭')
3、if…elif…else多重判断语句
if 条件1:
条件1成立执行的代码1
条件1成立执行的代码2
......
elif 条件2：
条件2成立执行的代码1
条件2成立执行的代码2
......
......
else:
以上条件都不成立执行的代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5ScQd9hW-1668173397875)(img/image-20221111183551550.png)]
4、if嵌套结构
if 条件1：
条件1成立执行的代码
条件1成立执行的代码
if 条件2：
条件2成立执行的代码
条件2成立执行的代码
"""
如果有钱，则可以上车
如果没钱，不能上车
"""
# 假设用 money = 1 表示有钱, money = 0表示没有钱
money = 1
if money == 1:
print('土豪，不差钱，顺利上车')
else:
print('没钱，不能上车，追着公交车跑')
"""
1. 如果有钱，则可以上车
2. 上车后，如果有空座，可以坐下
上车后，如果没有空座，则站着等空座位
如果没钱，不能上车
"""
# 假设用 money = 1 表示有钱, money = 0表示没有钱; seat = 1 表示有空座，seat = 0 表示没有空座
money = 1
seat = 0
if money == 1:
print('土豪，不差钱，顺利上车')
if seat == 1:
print('有空座，可以坐下')
else:
print('没有空座，站等')
else:
print('没钱，不能上车，追着公交车跑')
5、三目运算符
三目运算符也叫三元运算符。
语法如下：
值1 if 条件 else 值2
# 求两个数的最大值:
a = 1
b = 2
c = a if a > b else b
print(c)
今日作业：
1.从键盘中输入三个任意数值，求最大值
2.期末考试结束了，根据学员成绩求学员等级：90分及以上则为A，60分及60分到90之间则为B，小于60分则为C。
3.红绿灯案例：手动输入红绿灯状态如state="红灯"，根据红绿灯状态，输出小汽车的运行状态。正常通行、停车等待、观察并慢行。
4.有一物，不知其数，三三数之余二，五五数之余三，七七数之余二，问物几何？（100以内数值）
for i in range(1,100):
if(i % 3 == 2 and i % 5 == 3 and i % 7 == 2):
print(i)
break
else:
print("没有符合要求的数")
# 23
1-9分支总结与复习
1-10while循环
程序是为了解决实际问题的，实际问题中存在着重复动作，那么程序中也应该有相应的描述，这就是循环。
在Python中，循环结构分为while和for两种。
1、while循环基本语法
while 条件:
条件成立重复执行的代码1
条件成立重复执行的代码2
......
# print任务循环执行5次，因为此5次循环print的内容都没有变化，所以现实的效果为print重复执行5次。
i = 0
while i < 5:
print('老婆大人，我错了')
i += 1
print('任务结束')
2、循环成立条件
看不明白，就多写几次循环的程序。找到感觉就OK了。
（1）初始状态（可选）
（2）循环条件
（3）循环体（要重复做的事情）
（4）为下次循环作准备（）
# 求 1~100的总和5050
i = 1
result = 0
while i <= 100:
result += i
i += 1
print(result)
# 方法二
sum1= 0
for i in range(1,101):
sum1 += i
print (sum1)
1-11while循环嵌套
1、死循环
死循环就是循环条件永远成立。不是bug。
2、循环嵌套
循环体中包含其他循环叫做循环嵌套
外层循环执行一次，内层循环，循环执行一遍。
# 三组训练，一组训练要跑4圈+做10分钟深蹲
i = 0
while(i < 3):
print(f"第{i+1}组训练开始:")
j = 0
while(j < 4):
print("跑" + str(j+1) + "圈")
j += 1
print("深蹲十分钟")
i += 1
3、break 和 continue
break结束整个循环
continue结束此次循环
练习
# 有3只兔子，第二年的数量为第一年的两倍，以此类推。求，输入n年后，输出兔子数量
one_year_sum = 3
year = 0
while (year != -1):
print("请输入第几年：")
year = int(input())
if( year <= 0):
break
print(f"您输入的是第 {year} 年")
print(f"今年兔子的数量为 {one_year_sum * 2 ** (year - 1)}")
# 需求：猜你相亲对象的年龄，3次机会。猜对输出成功，猜错say byebye
# 先输入一个20到35之间的整数。3次猜的机会。猜对输出成功，猜错say byebye
run = 1
j = 0
while (run == 1):
print("girl please input your age:")
gril_age = int(input())
if(gril_age < 20 or gril_age > 35):
print("Oh,Come on ! Are you kidding me?")
else:
run = 2
print("Boy,try it,i believe with you:")
while (j < 3):
number = int(input())
if(number == gril_age):
print("You are right.")
break
else:
if(j == 2):
print("Bye bye")
break
print(f"你还有{4-j-2}次机会")
j +=1
# 打印九九乘法表
i = 1
while (i < 10):
j = 1
while (j < 10):
print(f"{i} x {j} = {i*j:02}",end = " ")
j +=1
print()
i += 1
# 打印九九乘法表
i = 1
while (i < 10):
j = 1
while (j < i+1):
print(f"{j} x {i} = {i*j:02}",end = " ")
j +=1
print()
i += 1
# 倒直角三角(5行5列)
raw = 0
while(raw < 5):
line = 0
while( line < 5 - raw ):
print("*",end=" ")
line += 1
print()
raw += 1
# 倒等腰三角(六行六列)
i = 0
num = 6
while(i < num):
j = 0
while(j < num):
if(j < i or j >= num - i):
print(" ", end=" ")
else:
print("*", end=" ")
j += 1
print()
i += 1
1-12for循环
1、基本语法
for循环时遍历数据序列，每次获取-个元素，直到元素全部被获取，结束循环。
for临时变量in序列: :
重复执行的代码1
重复执行的代码2
…
案例演示:
str1 = 'itcast'
for i in str1:
print(i)
"""
i
t
c
a
s
t
"""
for循环和while循环的区别:
1、for循环数据序列，元素提取完成自动停止,不需要使用循环变量
2、for循环不需要循环条件,所以也不会有循环条件成立喝不成立的说法
3、在开发中我们使用for循环的比例居多, while循环主要是构造死循环结构
4、for循环需要配合容器类型(数据序列)进行使用
2 、range
Python2 range()函数返回的是列表，而在Python3中 range()函数返回的是一个可迭代对象(类型是对象) ,而不是列表类型，所以打印的时候不会打印列表。( 由于我们还未学习面向对象,为了方便大家理解,你可以简单的将其理解为一个序列结构)
基本语法：
range(stop)
range(start,stop[,step]) # 包含起始位置不包含结束位置
start:计数从start开始。默认是从0开始。例如range (5 )等价于range (0，5) ;
stop:计数到stop结束，但不包括stop.例如: range (0，5)是[0,1,2,3, 4]没有5
step:步长，默认为1。例如:range(0,5)等价于range(0,5,1)
案例演示：
for i in range(5):
print(i)
怎样打印range中的所有元素呢？list(range类型)
print(list(range(0,5,1)))
# [0,1,2,3,4]
步长为1可以省略
起始位置为0时可以省略，但起始位置省略时，步长也必须省略。
小案例
# sum(1~100)
sum = 0;
for i in range(1,101):
sum += i
print(sum)
# 1~100偶数和
sum = 0;
for i in range(2,101,2):
sum += i
print(sum)
#
3、break 和 continue
break和continue是循环中满足一定条件退出循环的两种不同方式
和while中的一样
4、for循环嵌套
所谓for循环嵌套，就是一个for循环里面嵌套另外一个for循环的写法。当循环结构相互嵌套时，位于外层的循环结构常简称为外层循环或外循环,位于内层的循环结构常简称为内层循环或内循环。
# for 九九乘法表
for i in range(1,10):
for j in range (1,i+1):
print(f" {j} x {i} = {i*j:02}",end=" ")
print()
# 过7游戏
# 在1~100中 ,7和7的倍数、所有带有7的数字。换成输出“哈”
#
for i in range(1,101):
if(i % 20 == 0):
print()
if(i//10 == 7):
print("ha", end=" ")
continue
if(i % 10 == 7):
print("ha", end=" ")
continue
if(i % 7 == 0):
print("ha",end=" ")
continue
else:
print(f"{i:02}",end=" ")
-----------------------------------
01 02 03 04 05 06 ha 08 09 10 11 12 13 ha 15 16 ha 18 19
20 ha 22 23 24 25 26 ha ha 29 30 31 32 33 34 ha 36 ha 38 39
40 41 ha 43 44 45 46 ha 48 ha 50 51 52 53 54 55 ha ha 58 59
60 61 62 ha 64 65 66 ha 68 69 ha ha ha ha ha ha ha ha ha ha
80 81 82 83 ha 85 86 ha 88 89 90 ha 92 93 94 95 96 ha ha 99
100
# 过7游戏
# 在1~100中 ,7和7的倍数、所有带有7的数字。换成输出“哈”
#
for i in range(1,101):
if(i % 20 == 0):
print()
if(i//10 == 7 or i % 10 == 7 or i % 7 == 0):
print("ha",end=" ")
continue
else:
print(f"{i:02}",end=" ")
1-13else
wile循环else结构
else在过7游戏中已经有使用了。
循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码。
1-14字符串定义、切片
1、字符串的定义
字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。
a = 'hello world'
b = "abcdefg"
print(type(a))
print(type(b))
注意：控制台显示结果为``， 即数据类型为str(字符串)。
- 一对引号字符串
str2 = 'Tom'
name2 = "Rose"
- 三引号字符串
name3 = ''' Tom '''
name4 = """ Rose """
a = '''I am Tom,
nice to meet you! '''
b = """ I am Rose,
nice to meet you! """
注意：三引号形式的字符串支持换行。
2、字符串的输入
在Python中，使用input()接收用户输入。
username = input('请输入您的名字：')
print(f'您输入的名字是{username}')
print(type(username))
password = input('请输入您的密码：')
print(f'您输入的密码是{password}')
print(type(password))
3、字符串的输出
在Python中，我们可以使用print()函数进行输出。
print('hello world')
name = 'heima'
print('我的名字是%s' % name)
print(f'我的名字是{name}')
4、字符串的底层存储结构
在计算机底层，Python中的字符串是一段连续的内存地址。
str1 = 'itheima'
底层存储结构：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kJprSMdx-1668173397875)(img/image-20221111192508494.png)]
注意：索引下标从0开始。
5、聊聊索引下标
索引下标，就是编号。比如火车座位号，座位号的作用：按照编号快速找到对应的座位。同理，下标的作用即是通过下标快速找到对应的数据。
案例：字符串name = "abcdef"，取到不同下标对应的数据。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6C9J22CL-1668173397875)(img/image-20221111192629009.png)]
name = "abcdef"
print(name[1]) # 'b'
print(name[0]) # 'a'
print(name[2]) # 'c'
print(name[-1]) # 'f'
4、字符串切片
1、基本语法
什么是切片？
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作
序列[开始位置下标:结束位置下标:步长]
① 不包含结束位置下标对应的数据， 正负整数均可；
② 步长是选取间隔，正负整数均可，默认步长为1。
2、切片的使用
记口诀：切片其实很简单，只顾头来尾不管，步长为正正向移，步长为负则逆向移
1-15字符串查找、替换、合并
1、字符串查找
所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。
find()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。
字符串序列.find(子串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
案例演示：
mystr = "hello world and hello python"
print(mystr.find('hello'))
print(mystr.find('hello', 10))
print(mystr.find('heima'))
"""
0
16
-1
"""
index()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。
基本语法：
字符串序列.index(子串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
案例演示：
mystr = "hello world and hello python"
print(mystr.index('hello'))
print(mystr.index('hello', 10, 27))
print(mystr.index('heima'))
rfind()： 和find()功能相同，但查找方向为右侧开始。
rindex()：和index()功能相同，但查找方向为右侧开始。
字符串序列.rfind(子串, 开始位置下标, 结束位置下标)
字符串序列.rindex(子串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
案例演示：
mystr = "python.png"
print(mystr.rfind('.png'))
print(mystr.rindex('.png'))
count()：返回某个子串在字符串中出现的次数
基本语法：
字符串序列.count(子串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
案例演示：
mystr = "hello world and hello python and hello itheima"
print(mystr.count('and')) # 2
print(mystr.count('ands')) # 0
print(mystr.count('and', 0, 20)) # 1
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | find() | 检测某个子串是否包含在这个字符串中，如果在就返回这个子串第一次找到的位置下标，否则则返回-1。 |
| 2 | index() | 检测某个子串是否包含在这个字符串中，如果在就返回这个子串第一次找到的位置下标，否则则报异常。 |
| 3 | rfind() | 和find()功能相同，但查找方向为右侧开始。找到就返回第一次找到的位置下标 。 |
| 4 | rindex() | 和index()功能相同，但查找方向为右侧开始。找到就返回第一次找到的位置下标 。 |
| 5 | count() | 返回某个子串在字符串中出现的次数 。 |
2、字符串修改
所谓修改字符串，指的就是通过函数的形式修改字符串中的数据。
replace()：返回替换后的字符串
基本语法
字符串序列.replace(旧子串, 新子串, 替换次数)
注意：替换次数如果超出子串出现次数，则替换次数为该子串出现次数。
因为字符串是不可变数据类型，所以用过replace()之后的结果需要再声明一个变量来接一下。也就是说，即使是用了replace()原字符串中的值也是不变的。除非是将replace()过后的数据再次赋值给原字符串变量。split()，join(),capitalize()...同理。如下。
mystr = 'apple,orange,banana'
s1 = mystr.replace(',','*')
print(mystr)
print(s1)
mystr = mystr.replace('apple','苹果')
print(mystr)
"""
apple,orange,banana
apple*orange*banana
苹果,orange,banana
"""
案例演示：
mystr = "hello world and hello python"
# 结果：hello world & hello python
print(mystr.replace('and', '&'))
# 结果：hi world and hi python
print(mystr.replace('hello', 'hi', 2))
# 结果：hello world and hello python
print(mystr)
注意：数据按照是否能直接修改分为可变类型和不可变类型两种。由于字符串属于不可变类型，所以修改的时候不能改变原有字符串。
split()：按照指定字符分割字符串。
基本语法：
字符串序列.split(分割字符, num)
注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。
案例演示：
mystr = 'apple,orange,banana'
# 结果：['apple', 'orange', 'banana']
print(mystr.split(','))
# 结果：['apple', 'orange,banana']
print(mystr.split(',', 1))
# 结果：['apple,orange,banana']
print(mystr.split('*'))
join()：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。
基本语法：
list1 = ['it', 'heima']
tuple1 = ('hello', 'python')
# 结果：itheima
print(''.join(list1))
# 结果：hello-python
print('-'.join(tuple1))
capitalize()：将字符串第一个字符转换成大写
基本语法：
mystr = 'student'
mystr2 = 'stuDENT'
# 结果：Student
print(mystr.capitalize())
# 结果：Student
print(mystr2.capitalize())
注意：capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写
title()：将字符串每个单词首字母转换成大写
基本语法：
mystr = 'i love python'
# 结果：I Love Python
print(mystr.title())
upper()：将字符串中小写转大写
lower()：将字符串中大写转小写
基本语法：
mystr = 'i love python'
print(mystr.upper())
print('-' * 10)
mystr = 'I LOVE PYTHON'
print(mystr.lower())
1-16字符串删除、判断
1、字符串删除
lstrip()：删除字符串左侧空白字符
rstrip()：删除字符串右侧空白字符
strip()：删除字符串两侧空白字符
username = ' admin'
password = 'admin888 '
print(len(username))
# lstrip去除左侧空格print(username.lstrip())
print(len(username.lstrip()))
print(len(password))
# rstrip去除左侧空格print(password.rstrip())
print(len(password.rstrip()))
print(username.strip())
print(password.strip())
注：len()方法主要用于获取字符串的长度
ljust()：返回一个原字符串左对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串。
rjust()：返回一个原字符串右对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串，语法和ljust()相同。
center()：返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度的新字符串，语法和ljust()相同。
基本语法：
字符串序列.ljust(长度, 填充字符)
案例演示：
mystr = "python"
print(mystr.ljust(10, '.'))
print('-' * 10)
print(mystr.rjust(10, '.'))
print('-' * 10)
print(mystr.center(10, '.'))
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | replace() | 返回替换后的字符串 |
| 2 | split() | 返回切割后的列表序列 |
| 3 | capitalize() | 首字母大写 |
| 4 | title() | 所有单词首字母大写 |
| 5 | upper()与lower() | 返回全部大写或小写的字符串 |
| 6 | lstrip()、rstrip()与strip() | 去除左边、右边以及两边的空白字符 |
| 7 | ljust()、rjust()与center() | 返回原字符串左对齐、右对齐以及居中对齐 |
2、字符串判断
所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。
startswith()：检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
endswith()：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
基本语法：
mystr1 = 'python program'
print(mystr1.startswith('python'))
print('-' * 10)
mystr2 = 'avater.png'
print(mystr2.endswith('.png'))
isalpha()：测字符串是否只由字母组成，如果字符串（至少有一个字符）所有字符都是字母则返回 True, 否则返回 False。
mystr1 = 'hello'
mystr2 = 'hello12345'
# 结果：True
print(mystr1.isalpha())
# 结果：False
print(mystr2.isalpha())
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
基本语法：
mystr1 = 'aaa12345'
mystr2 = '12345'
# 结果： False
print(mystr1.isdigit())
# 结果：False
print(mystr2.isdigit())
isalnum()：检测字符串是否由字母和数字组成，如果字符串（至少有一个字符）所有字符都是字母或数字则返 回 True,否则返回 False。
mystr1 = 'aaa12345'
mystr2 = '12345-'
# 结果：True
print(mystr1.isalnum())
# 结果：False
print(mystr2.isalnum())
isspace()：如果字符串中只包含空白，则返回 True，否则返回 False。
基本语法：
mystr1 = '1 2 3 4 5'
mystr2 = ' '
# 结果：False
print(mystr1.isspace())
# 结果：True
print(mystr2.isspace())
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | startswith() | 检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。 |
| 2 | endswith() | 检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。 |
| 3 | isalpha() | 如果字符串所有字符(至少有一个字符)都是字母则返回 True, 否则返回 False。 |
| 4 | isdigit() | 如果字符串只包含数字则返回 True 否则返回 False。 |
| 5 | isalnum() | Python isalnum() 方法检测字符串是否由字母和数字组成。如果字符串所有字符(至少有一个字符)都是字母或数字则返 回 True,否则返回 False。 |
| 6 | isspace() | 如果字符串中只包含空白，则返回 True，否则返回 False |
1-17列表定义
1、为什么需要列表
一次操作中需要定义同类型的多个变量。一个一个定义变量太麻烦。
例如：
统计全班50位同学的姓名，普通操作则需要手动分别定义50个变量。要是将人数上升到全校、全市。。。
2、列表的定义
基本语法：
列表名称 = [数据1, 数据2, 数据3, 数据4, ...]
案例演示：
name_list = ['Tom', 'Lily', 'Rose’]
print(name_list) # ['Tom', 'Lily', 'Rose']
print(type(name_list)) # 注意：列表可以一次存储多个数据且可以为不同的数据类型
1-18列表的操作运用
1、列表的常用操作
列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。
查询
索引下标
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose
列表的底层存储形式和字符串都是一样的，其也是通过索引下标来对其进行引用的。
index()方法：指定数据所在位置的下标
列表序列.index(数据, 开始位置下标, 结束位置下标)
案例演示：
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1
count()方法：统计指定数据在当前列表中出现的次数
列表序列.count(数据)
案例演示：
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) # 1
in：判断指定数据在某个列表序列，如果在返回True，否则返回False
name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False
name_list = ['Tom', 'Lily', 'Rose']
# 结果：False
print('Lily' not in name_list)
# 结果：True
print('Lilys' not in name_list)
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | index() | 指定数据所在位置的下标 |
| 2 | count() | 统计指定数据在当前列表中出现的次数 |
| 3 | in | 判断指定数据在某个列表序列，如果在返回True，否则返回False |
| 4 | not in | 判断指定数据不在某个列表序列，如果不在返回True，否则返回False |
增加
append()方法：增加指定数据到列表中
name_list = ['Tom', 'Lily', 'Rose']
name_list.append('Jennifer')
print(name_list)
注意：列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据。
extend()方法：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表
列表序列.extend(数据)
单个数据演示：
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('Smith')
# 结果：['Tom', 'Lily', 'Rose', 'S', 'm', 'i', 't', 'h']
print(name_list)
序列数据演示：
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend(['Smith', 'Jennifer'])
# 结果：['Tom', 'Lily', 'Rose', 'Smith', 'Jennifer']
print(name_list)
insert()方法：指定位置新增数据
列表序列.insert(位置下标, 数据)
案例演示：
name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'Smith')
# 结果：['Tom', 'Smith', 'Lily', 'Rose']
print(name_list)
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | append() | 增加指定数据到列表中 |
| 2 | extend() | 列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表 |
| 3 | insert() | 指定位置新增数据 |
删除
del：删除列表中的某个元素
del 目标
删除列表，案例演示：
name_list = ['Tom', 'Lily', 'Rose']
del name_list[0]
print(name_list)
pop()方法：删除指定下标的数据(默认为最后一个)，并返回该数据。
列表序列.pop(下标)
案例演示：
name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)
# 结果：Lily
print(del_name)
# 结果：['Tom', 'Rose']
print(name_list)
remove()方法：移除列表中某个数据的第一个匹配项。
列表序列.remove(数据)
案例演示：
name_list = ['Tom', 'Lily', 'Rose']
name_list.remove('Rose')
# 结果：['Tom', 'Lily']
print(name_list)
clear()方法：清空列表，删除列表中的所有元素，返回空列表。
列表序列.clear()
案例演示
name_list = ['Tom', 'Lily', 'Rose']
name_list.clear()
print(name_list) # 结果： []
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | del 列表[索引] | 删除列表中的某个元素 |
| 2 | pop() | 删除指定下标的数据(默认为最后一个)，并返回该数据 |
| 3 | remove() | 移除列表中某个数据的第一个匹配项。 |
| 4 | clear() | 清空列表，删除列表中的所有元素，返回空列表。 |
修改
修改指定的元素值
列表[索引] = 修改后的值
案例演示：
name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'Smith'
# 结果：['Smith', 'Lily', 'Rose']
print(name_list)
reverse()：将数据序列进行倒叙排列
列表序列.reverse()
案例演示：
num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)
sort()方法：对列表序列进行排序
列表序列.sort( key=None, reverse=False)
注意：reverse表示排序规则，reverse = True降序， reverse = False升序（默认）
案例演示：
num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)
copy()方法：对列表序列进行拷贝
列表序列.copy()
案例演示：
name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 结果：['Tom', 'Lily', 'Rose']
print(name_li2)
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | 列表[索引] = 修改后的值 | 修改列表中的某个元素 |
| 2 | reverse() | 将数据序列进行倒叙排列 |
| 3 | sort() | 对列表序列进行排序 |
| 4 | copy() | 对列表序列进行拷贝 |
2、列表的循环遍历
1、while循环遍历
name_list = ['Tom', 'Lily', 'Rose']
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
2、for循环遍历
name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
print(i)
3、列表的嵌套
所谓列表嵌套指的就是一个列表里面包含了其他的子列表。
应用场景：要存储班级一、二、三三个班级学生姓名，且每个班级的学生姓名在一个列表。
name_list = [[‘小明’, ‘小红’, ‘小绿’], [‘Tom’, ‘Lily’, ‘Rose’], [‘张三’, ‘李四’, ‘王五’]]
思考： 如何查找到数据"李四"？
# 第一步：按下标查找到李四所在的列表
print(name_list[2])
# 第二步：从李四所在的列表里面，再按下标找到数据李四
print(name_list[2][1])
1-19元组定义使用
1、为什么需要元组
如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？
答：列表？列表可以一次性存储多个数据，但是列表中的数据允许更改。
num_list = [10, 20, 30]
num_list[0] = 100
那这种情况下，我们想要存储多个数据且数据不允许更改，应该怎么办呢？
答：使用元组，元组可以存储多个数据且元组内的数据是不能修改的。
2、定义元组
元组特点：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)
注意：如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型。
t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str
3、元组的相关操作
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | 元组[索引] | 根据索引下标查找元素 |
| 2 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同 |
| 3 | count() | 统计某个数据在当前元组出现的次数 |
| 4 | len() | 统计元组中数据的个数 |
元组内的数据如果直接修改则立即报错，但是如果元组里面有列表，修改列表里面的数据则是支持的，故这个特点非常重要。
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)
4、元组的相关操作演示
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa
tuple2 = ('aa', 'bb', 'cc', 'bb')
print(tuple2.index('aa')) # 0
tuple3 = ('aa', 'bb', 'cc', 'bb')
print(tuple3.count('bb')) # 2
tuple4 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple4)) # 4
1-20字典定义使用
1-21集合定义使用
1-22公共方法与推导式
1-23函数基本使用
1-24函数作用域
1-25总结复习
1-26不定长参数与组包解包
1-27引用类型
1-28案例-学员管理系统
1-29递归与复习
1-30文件基本操作
1-31文件操作案例
第二章 Python面向对象编程
使用
1、为什么需要元组
如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？
答：列表？列表可以一次性存储多个数据，但是列表中的数据允许更改。
num_list = [10, 20, 30]
num_list[0] = 100
那这种情况下，我们想要存储多个数据且数据不允许更改，应该怎么办呢？
答：使用元组，元组可以存储多个数据且元组内的数据是不能修改的。
2、定义元组
元组特点：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)
注意：如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型。
t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str
3、元组的相关操作
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | 元组[索引] | 根据索引下标查找元素 |
| 2 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同 |
| 3 | count() | 统计某个数据在当前元组出现的次数 |
| 4 | len() | 统计元组中数据的个数 |
元组内的数据如果直接修改则立即报错，但是如果元组里面有列表，修改列表里面的数据则是支持的，故这个特点非常重要。
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)
4、元组的相关操作演示
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa
tuple2 = ('aa', 'bb', 'cc', 'bb')
print(tuple2.index('aa')) # 0
tuple3 = ('aa', 'bb', 'cc', 'bb')
print(tuple3.count('bb')) # 2
tuple4 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple4)) # 4