（根据黑马教程整理）
第二章01-字面量
0.6数据的类型
1.掌握字面量的含义
代码中，被写在代码中的固定值，称之为字面量
2.常见的字面量类型
整数、浮点数、字符串
3.基于print语句完成各类字面量的输出
print(10)
print("今天是23年2月22日")
第二章02-注释
1.单行注释 ：#
2.多行注释 （""" """）
第二章03-变量
1.变量的作用：
在程序运行时，记录数据
2.变量的定义格式：
<变量名>=<变量值>
3.变量特征：
可以改变
4.print语句中如何输出多份内容？
print(内容1，内容2............)
第二章04-数据类型
1.使用什么语句可以查看数据类型？
type()
2.变量有无类型？
没有，字符串变量表示变量存储了字符串而不是表示变量就是字符串
第二章05-数据类型转换
1.字符串、整数、浮点数类型转换的语句是？
2.任何类型都可以转换为字符串吗？
对
3.字符串可以任意转换成数字吗？
不可以。字符串内必须只有数字才可以
4.浮点数转换为整数会丢失什么？
丢失精度
第二章06-标识符
1.什么是标识符？
用户编写代码时，对变量、类、方法等编写的名字
2.标识符的命名规则？
内容限定
中文、英文、数字、下划线
大小写敏感
不可使用关键字
3.变量的命名规范
见名知意
下划线命名法
英文字母全小写
第二章07-运算符
1.常见的算术（数学）运算符有：
加（+）、减（-）、乘（*）、除（/）、整除（//）、取余（%）、平方（**）
2.赋值运算符
运算符加=
第二章08-字符串的三种定义方式
1.字符串的三种定义方式：
单引号方式、双引号方式、三引号方式
2.引号的嵌套
可以使用：\来进行转义
单引号内可以写双引号或双引号内可以写单引号
第二章09-字符串的拼接
1.如何完成字符串的拼接？
使用“+”连接字符串变量或字符串字面量即可
2.注意事项
无法和非字符串类型进行拼接
第二章10-字符串格式化
1.字符串格式化的语法
“ %占位符 ” % （变量）
2.常用占位符有哪三个？
| 字符串 | %s |
| 整数 | %d |
| 浮点数 | %f |
第二章11-字符串格式化的精度控制
第二章12-字符串格式化2
1.可以通过
f " { 变量 } { 变量 } "的方式进行快速格式化
2.以上格式化方式
不会理会类型
不做精度控制（适合对精度没有要求的时候快速使用）
第二章13-对表达式进行格式化
1.表达式是什么？
是一个有明确结果代码的语句
2.如何格式化表达式？
f"{表达式}"
“%s \%d \ %f ”%(表达式，表达式，表达式....)
第二章15-数据输入(input语句)
1.语句功能：
获取键盘输入的数据
2.可以使用：
input(提示信息)
3.得到的类型永远是字符串类型
第三章01-布尔类型和比较运算符
1.python中，表示真假的数据类型是：
True （真） False （假）
2.除了定义布尔类型外，还可以通过 比较运算符 计算得到布尔类型。
第三章02-if语句的基本格式
.
第三章04-if-else组合判断语句
第三章06-if--elif-else组合判断语句
1.if--elif-else语句的作用是？
完成多个条件的判断
2.使用if--elif-else的注意点：
elif可以写多个
判断是互斥 并且 有序的，上一个满足后面的就不会判断（跳过）
可以在条件判断中，直接写input语句，节省代码量
第三章08-判断语句的嵌套
1.嵌套判断语句可以用于多条件、多层次的逻辑判断
2.嵌套判断语句可以根据需求，自由组合 if-elif-else来构建多层次判断
3.嵌套判断语句，一定注意空格缩进，python通过空格缩进决定层次关系
第三章09-判断语句综合案例
第四章01-while循环的基础应用
第四章03-while循环猜数字案例
第四章04-while循环的嵌套应用
第四章05-while循环案例--九九乘法表
# 九九乘法表
a = 1
while a <= 9:
b = 1
while b <= a:
print(f"{a}*{b}={a*b}\t",end = "")
b += 1
a += 1
print()第四章06-for循环的基础语法
注：同while循环不同，for循环是无法定义循环条件的。
只能从被处理的数据集中，依次取出内容进行处理
所以，理论上讲，python的for循环无法构建无限循环（被处理的数据不可能无限大）
1.for循环的语法格式是：
for 临时变量 in 待处理的数据集（序列）：
循环满足条件时执行的代码
2.for循环的注意点：
无法定义循环条件，只能被动取出数据处理
循环内的语句 ，需要空格的缩进
第四章07-for循环的案例
zhuzhuna = "she is a gril"
count = 0
for i in zhuzhuna:
if i == "s":
count += 1
print(f"被统计的s字母有{count}个")第四章08-range语句
第四章09-for循环临时变量作用域
1.for循环中的临时变量，其作用域限定为： 循环内部
2.这种规定：
不遵守也能正常运行，如需访问临时变量，可以预先在循环外定义它
i = 100 #与i的起始变量值无关
for i in range(5):
print(i)
print(i)逐行输出： 0 1 2 3 4 4
最后一行的print（）语句输出的内容为for的最后一次循环
第四章10-for循环的嵌套应用
第四章11-for循环打印九九乘法表
#用for循环打印9*9乘法表
i = 0
for i in range(1,10):
j = 1
for j in range(1,i+1):
print(f"{j}*{i}={j * i}\t", end="")
print()第四章12-break 和 continue
1.continue的作用是：（临时中断）
中断所在循环的当次执行，直接进入下一次内循环
for i in range(1,6):
print(1)
for i in range(1,6):
print(2)
continue
print(3)
print(4)2.break的作用是：（永久中断）
直接结束所在的循环 （对应当前的循环的整个语句块）
for i in range(1,6):
print(1)
for i in range(1,6):
print(2)
break
print(3)
print(4)3.注意事项：
continue 和 break，在for 和 while 循环中作用一致
在嵌套循环中，只能作用在所在的循环上，无法对上层循环起作用
第四章13-循环综合案例
#定义账户余额
money = 10000
# for循环对员工发放工资
for i in range(1,21):
import random
performance = random.randint(1, 10) #随机生成1-10的数字
if performance < 5:
print(f"员工{i}绩效分{performance}，不满足，不发了，下一位")
# continue跳过发放
continue
if money >=1000 : #使用elif也可以
money -= 1000
print(f"员工{i}，绩效分{performance},满足发放工资1000，账户余额是：{money}")
else :
print(f"余额不足，当前{money}元，不发了额，下个月再说")
# break结束发放
break第五章01-函数（初）
1.函数的定义
已经组织好的，可重复使用的，用来实现特定功能的代码段
2.使用函数的优点是：
将功能封装在函数内部，可随时重复使用
提高代码的复用性，减少重复的代码，提高开发效率
第五章02-函数的基础语法定义
1.函数的定义语法：
2.函数使用步骤：
先定义函数
后调用函数
#定义一个函数输出相关信息
def hi():
print("今天是2023年3月3日")
#调用函数，让定义的函数开始工作
hi()
hi()3.注意：
当参数不需要时，可省略
返回值不需要时，可以省略
第五章03-函数基础定义练习案例
def hello():
print("欢迎大家\n来到厦门")
hello()def hello():
print("""欢迎大家,
来到厦门""")
hello()第五章04-函数的传入参数
1.函数的传入参数的作用是？
在函数运行的时候，接受外部传入的数据
2.使用方法：
def add( a,b ):
resule = a**b
print(f"{a}的{b}次幂的结果是{resule}")
add (4,2)3.注意事项
函数定义中的参数，称之为形式参数
函数调用中的参数，称之为实际参数
函数的参数数量不限，使用逗号分隔开
传入参数的时候，要和形式参数一一对应，用逗号分开
第五章05-函数的参数练习案例
num = eval(input("您的体温是："))
def check(num):
print("欢迎来到这里，请出示您的身份信息以便核对")
if num > 37.3:
print(f"体温测量中，您的体温是：{num},需要隔离")
else:
print(f"体温测量中，您的体温是：{num}，不需要隔离")
check(num)第五章06-函数的返回值定义语法
1.什么是函数的返回值？
函数在执行完成后，返回给调用者的结果
2.返回值的应用语法：
使用关键字：return来返回结果
3.注意：
函数体在遇到return后就结束了，所以写在return后的代码就不会执行了
# 定义一个函数完成两数相加的功能
def add(x, y):
result = x + y
#通过返回值，将相加的结果返回给调用者
return result
#函数的返回值，可以通过变量去接收
r = add(6,18)
print(r)第五章07-函数返回值之None的类型
1.什么是None？
None是类型“NoneType”的字面量，用于表示：空的，无意义的
2.函数如何返回None
不使用return语句即返回None
主动return None
3.使用场景
函数返回值
if判断
变量定义
def check_age(age):
if age > 18:
return "SUCCESS"
else:
return None
result = check_age(15)
if not result:
#进入if表示result是None，也就是False
print('未成年禁止入内')
# 如果if后面跟的是字符串，则只要这个字符串不为空串，python就把它看作True
# 由于None的值是faDDlse，而if判断要为true才能执行，所以not None是非false,也就是为ture的意思,这样子if就能执行了注意
如果if后面跟的是字符串，则只要这个字符串不为空串，python就把它看作True
由于None的值是false，而if判断要为true才能执行，所以not None是非false,也就是为ture的意思,这样子if就能执行了
第五章08-函数的说明文档
1.函数说明文档的作用是？
对函数进行说明解释，帮助更好的理解函数功能
2.定义语法
def add(x ,y):
"""
add 函数可以接收两个参数，进行两数相加的功能
:param x: 形参x表示相加的其中一个数字
:param y: 形参y表示相加的其中一个数字
:return: 返回值是两数的相加的结果
"""
result = x + y
print(f"2数相加的结果是：{result}")
return result
add(6,15)param：用于解释参数
return：用于解释返回值
第五章09-函数的嵌套调用
1.什么是嵌套调用？
在一个函数中，调用另外一个函数
2.执行流程
函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容
# 定义函数func_b
def func_b():
print("---1---")
def func_a():
print("---2---")
#嵌套调用func_b
func_b()
print("---3---")
# 调用函数func_a
func_a()
#输出如下
#---2---
#---1---
#---3---第五章10-变量的作用域
1.什么是局部变量？
作用范围在函数内部，在函数外部无法使用
2.什么是全局变量？
在函数内部和外部都可以使用
3.如何将函数内定义的变量声明为全局变量呢？
使用global的关键字
numbers = 200
def test_a():
print(f"test_a:{numbers}")
def test_b():
global numbers #设置内部定义的变量是全局变量
numbers = 500 #没有上一行的话，还是属于局部变量
print(f"test_b:{numbers}")
test_a()
test_b()
print(numbers)第六章01-数据容器（入门）
1.什么是数据容器？
一种可以存储多个元素的python数据类型
2.python有哪些数据容器？
list （列表）、tuple（元组）、str（字符串）、dict（字典）
第六章02-列表的定义语法
1.列表的定义语法
[ 元素1，元素2，元素3，……]
2.什么是元素 ？
数据容器内的每一份数据，都称为元素
3.元素的类型有限制吗？
没有，元素也可以是列表 。这样就定义了嵌套列表
第六章03-列表的下标索引
第六章04-列表的常用操作方法
1.列表的常见方法有：
2.列表的特点
可以容纳多个元素（上限：2**63-1 个）
可以容纳不同类型的元素（混装）
数据是有序存储的（有下标序号）
允许重复数据存在
可以修改（增加 或 删除元素等）
第六章05-列表的常用操作课后练习讲解
1.for 循环
my_list = ["morning","afternoon","evening"]
for i in my_list:
print(f"对列表的元素是：{i}")2.while 循环
my_list = ["morning","afternoon","evening"]
index = 0
while index <= len(my_list)-1:
element = my_list[index]
print(f"列表对应的元素是：{element}")
index += 13.for & while 循环对比
4.什么是遍历？
将容器内的元素依次取出来，并处理
5.如何遍历列表中的元素
可以使用while 或 for 循环
6.for循环的语句
for 临时变量 in 数据容器：
对临时变量进行处理
第六章06-列表的遍历循环
代码错了，没有讲评
代码在596到609
第六章07-元组的定义和操作
1.元组的特点
可容纳多个数据
可容纳不同类型的数据（混装）
数据是有序存储的（下标索引）
允许重复数据存在
不可以修改（增加或删除元素）
支持for循环
总结：多数特性和list一致，不同点在于不可修改的特性
2.元组的定义方式：
（元素1，元素2，元素3，----）
3.元组的操作方法：
第六章08-字符串的定义和操作
1.字符串为什么说是数据的容器呢？
字符串可以看做是字符的容器，支持下标索引等 的特性
2.字符串常用的操作汇总
3.字符串的特点：（作为数据容器）
只可以存储字符串
长度任意
支持下标索引
允许重复字符串存在
不可以修改（增加 或 删除元素）
支持for循环
第六章09-字符串的课后练习
# 统计字符串中有多少个it字符
str = ("itheima itcast boxuegu")
count = str.count("it")
print(f"字符串{str}中有：{count}个it字符")# 将空格替换为|
str = ("itheima itcast boxuegu")
abs = str.replace(" ","|")
print(f"字符串{str},被替换空格后，结果是{abs}")# 按照|分割
str = ("itheima|tcast|boxuegu")
abs2 = str.split("|")
print(f"字符串{str},按照'|'分割后，得到的是{abs2}")第六章10-数据容器（序列）的切片
1.什么是序列？
内容连续，有序，支持下标索引的一类数据容器
2.哪些数据容器可以视为序列？
列表、元组、字符串
3.序列的切片方式
第六章11-序列切片的课后练习
str = "万过薪月，员序程马黑来，nohtyP学"
abs= str[-14:-9]
abs = abs[::-1] 方法1
abs = str[::-1][9:14] 方法2
abs = str[-10:-15:-1] 方法3
abs = str.split("，")[1].replace("来","")[::-1] 方法4
print(abs)第六章12-集合的定义和操作
1.集合定义方式
{元素1， 元素2， 元素------}
2.集合常用功能总结
3.集合的特点
可以容纳多个数据
可容纳不同类型的数据（混装）
数据是无序存储的（不支持下标索引）
不允许重复数据存在
可以修改（增加或删除）
支持for循环
如何遍历集合元素
可以使用for循环进行遍历
不可以使用while循环，因为不支持下标索引
第六章13-集合的课后练习
list =["tommorn", "will", "be", "better and better"]
my_set =set()
for i in list:
my_set.add(i)
print(my_set)
print(my_set)第六章14-字典的定义
1.为什么使用字典
字典可以提供基于Key 检索 Value场景的实现
类似于查字典
2.字典的定义用法
dict1 = {"年份":2023, "月份":2, "日期":25}
dict2 = {}
dict3 = dict()
print(dict3)
print(dict2)score_dict = {"王力宏":{"语文":77,"数学":66,"英语":33},
"周杰伦":{"语文":88,"数学":86,"英语":55,}}
print(score_dict)
score1 = score_dict["周杰伦"]["英语"]
print(score1)3.字典的注意事项
键值对的key 和 value可以是任意类型（key不可以为字典）
字典内key不允许重复，如果重复添加等同于覆盖原有的数据
字典不可以使用下标索引，而是通过key 检索value
第六章15-字典的常用操作
1.字典常用操作总结
***操作注意：新增和更新元素的语法一致，如果key不存在即新增
如果key存在 即更新（key不可重复）
2.字典的特点
可容纳多个数据
可容纳不同类型的数据
每一份数据是KeyValue键值对
可以通过Key获取到Value，Key不可重复（重复会覆盖）
不支持下标索引
可以修改（增加或删除）
支持for循环，不支持while循环
4.操作案例
# 空字符串输出
dict1 = {"年份":2023, "月份":2, "日期":25}
dict2 = {}
dict3 = dict()
print(dict3)
print(dict2)score_dict = {"王力宏":{"语文":77,"数学":66,"英语":33},
"周杰伦":{"语文":88,"数学":86,"英语":55,}}
print(score_dict)
score1 = score_dict["周杰伦"]["英语"]
print(score1)# 增加元素
dict1 = {"年份":2023, "月份":2, "日期":25}
dict1["时间"] = 9
print(dict1)
dict1["日期"] = 26
print(dict1)# 遍历循环 通过获取全部的key来完成遍历
dict1 = {"年份":2023, "月份":2, "日期":25}
score = dict1.keys()
print(score)
for key in score:
print({key})
print({dict1[key]})# 删除元素的操作
dict1 = {"年份":2023, "月份":2, "日期":25}
score = dict1.pop("年份")
print(score)
print(dict1)第六章16-字典的课后练习
第六章17-5类数据容器的总结
1.数据容器可以从以下视角进行简单的分类：
①是否支持下标索引
支持：列表、元组、字符串---序列类型
不支持：集合、字典---非序列类型
②是否支持重复元素：
支持：列表、元组、字符串---序列类型
不支持：集合、字典---非序列类型
③是否可以修改：
支持：列表、集合、字典
不支持：元组、字符串
2.特点的对比
3.使用场景
第六章18-数据类型的通用操作
第六章19-拓展-字符串大小的比较方式
1.字符串如何比较
从头到尾，一位位进行比较，其中一位大，则截止
2.单个字符之间如何确定大小？
通过*****码表，确定字符对应的码值数字来确定大小
print(f"abd大于abc，结果是:{'abd' > 'abc'}")
print(f"ab大于a，结果是：{'ab' > 'a' }")
print(f"a大于A，结果是:{'a' > 'A'}")第七章01-函数的多返回值
运用return可返回多个返回值
def test_return():
return 1,[456],{1,2}
x, y, z = test_return()
print(x)
print(y)
print(z)第七章02-函数的多种参数使用形式
1.掌握位置参数
根据参数位置来传递参数
2.掌握关键字参数
通过“ 键 = 值 ”的形式传递参数，可以不限制参数顺序
可以和位置参数混用，位置参数需要在前面
3.掌握缺省参数
不传递参数值时会使用默认的参数值
默认值的参数必须定义在最后
4.掌握不定长参数
位置不定长传递以 * 号标记一个形式参数，以元组的形式接收参数
规范：形参一般命名为：args
关键字不定长传输以 ** 号标记一个形式参数，以字典的形式接受参数
规范：形参一般命名为：kwargs
def user(name, age, gender):
print(f"姓名是：{name}，年龄是：{age}，性别是：{gender}")
#位置参数默认的使用形式
user("小王", 20, "女")
# 关键字参数
user(name='小江',age=22,gender='女')
user(name='小x',gender='男',age=28)
user('阿甜', gender='女', age=22)def user(name, age, gender='女'): #注意注意：设置默认值的时候，统一放在最后
print(f"姓名是：{name}，年龄是：{age}，性别是：{gender}")
user('小小陈',2)def user_info(*args):
print(f"{args}")
user_info(9,6,"小小酱")def user_info(**kwargs):
print(f"{kwargs}")
user_info(name='小x',gender='男',age=28) #以键值对的形式传入第七章03-函数作为参数传递
1.函数作为参数传递
左边 ：参数不确定 运算逻辑确定
右边：参数确定 运算逻辑不确定
def test_func(compute):
result = compute(5 ,6) #确定computer是函数
print(f"computer参数的类型是：{type(compute)}")
print(f"计算结果：{result}")
#定义一个函数，准备作为参数传入的另一个函数
def compute(x, y):
return x+y
#调用，并传入函数
test_func(compute)2.函数本身是可以作为参数，传入另一个函数中使用的
3.将函数传入的作用在于：传入计算逻辑，而并非传入数据
第七章04-lambad匿名函数
def test_func(compute):
result = compute(5, 6)
print(result)
#通过lambda匿名函数的形式，将匿名函数作为参数传入
test_func(lambda x,y: x*y)
test_func(lambda x,y: x*y)1.匿名函数使用lambda关键字进行定义
2.定义语法：
lambda 传入参数 ： 函数体（一行代码）
3.注意事项：
匿名函数用于临时构建一个函数，只用一次的场景
匿名函数的定义中，函数体只能写一行代码，如果函数体要多行代码，
不使用lambda，而用def。
第八章01-文件编码概念
1.什么是编码？
编码 是一种规则集合，记录了内容和二进制 间进行相互转换的逻辑。
编码有许多，常用的是 UTF-8编码
2.为什么需要使用编码？
计算机只认识 0，1。所以需要将内容翻译成0,1才能保存在计算机中。
同时也需要编码，将计算机保存的0和1，反向翻译回可以识别的内容。
第八章02-文件读取
1.操作文件需要通过open函数打开文件得到文件对象
2.文件对象有一下读取方法：
3.文件读取完成后，要使用文件对象.close()方法关闭文件对象，否则文件会被一直占用
第八章04-文件的写入操作
1.写入文件使用open函数的“W”模式进行写入
2.写入的方法：
write（），写入内容
flush（），刷新内容到硬盘中
3.注意事项
w模式，文件不存在时，会创建新的文件
w模式，文件存在 ，会清空原有的内容
close（）方法，自带有flush（）方法的功能
4.举例
# 打开文件 ，不存在的文件，r,w,a
import time
f = open("D:/test.txt","w",encoding="UTF-8")
# write写入
f.write("今天是2023年3月9日") #内容写入到内存中
# flush刷新
f.flush() # 将内存中积攒的内容，写入到硬盘的文件中
# time.sleep(600000)
#close关闭
f.close() #close方法，内置了flush的功能第八章05-文件的追加写入操作
1.追加文件使用open函数的“a”模式进行写入
2.追加写入的方法（和w模式一致）：
write（），写入内容
flush（），刷新内容到硬盘中
3.注意事项
a模式，文件不存在时，会创建新的文件
a模式， 文件存在 ，会在原有内容后面继续写入
可以使用“\n”来写出换行
4.举例
f = open("D:/test.txt","a",encoding="UTF-8")
f.write("2023年3月9日10:30:01")
f.close()第九章01-了解异常
1.什么是异常：
程序运行的过程中出现了错误
2.bug是什么意思？
异常
第九章02-异常的捕获
1.为什么要捕获异常？
在可能发生异常的地方，进行捕获。当异常出现的时候，提供解决方式，而不是任由其导致程序无法运行
2.捕获异常的语法
try：
可能发生异常的语句
except [ 异常 as 别名：]
出现异常的捕获手段
[else：]
未出现异常的准备手段
[finally：]
不管出不出现异常都必须一定会做的适应
3.如何捕获所有异常
异常的种类很多，不管什么类型都能捕获到，使用：
except：
except Exception：
第九章03-异常的传递
def func1():
print("func1 开始执行")
num = 1 / 0
print("func1 结束执行")
def func2():
print("func2 开始执行")
func1()
print("func2 结束执行")
def main():
try:
func2()
except Exception as e :
print(f"出现异常了，异常信息是：{e}")
main()第九章04-模块的概念和导入
1.什么是模块？
是python的代码文件，内部含有 类、函数、变量等，我们可以导入进行使用
2.模块的导入方式
模块在使用前需要先导入 导入的语法如下：
[ from 模块名 ] import [ 模块 | 类 | 变量 | 函数 | * ] [ as 别名 ]
3.常用的组合形式（不是很重要）：
import 模块名
from 模块名 import 类、变量、方法等
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名
4.注意事项
from可以省略，直接import
as别名可以省略
通过 . 确定层级关系
模块的导入一般写在代码文件的开头位置
# 使用import导入time模块使用sleep功能（函数）
import time #导入python内置的time模块（time.py这个代码文件）
print("今天是2023年的")
time.sleep(6) #通过.就可以使用模块内部的全部功能
print("三月二十四日")# 使用from导入time的sleep功能(函数）
from time import sleep
print("今天是2023年的")
sleep(6)
print("三月二十四日")# 使用 * 导入time模块的全部功能
from time import* # *表示全部的意思
print("今天是2023年的")
sleep(4)
print("三月二十四日")# 使用as给特定功能加上别名
from time import sleep as t
print("今天是2023年的")
t(3)
print("三月二十四日")第九章05-自定义模块并导入
1.如何自定义模块导入
在python 代码文件中正常写代码即可，通过import、from关键字和导入python内置模块一样导入即可
2._ _ main _ _变量的功能是什么
if _ main_ == "_main_"表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if 无法进入
3.注意事项
不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
_all_变量可以控制import * 的时候哪些功能可以被导入
标签：函数,Python,全网,字符串,循环,print,基础理论,def,定义 From： https://blog.csdn.net/2302_78901262/article/details/139799155