此Python3笔记仅为本人自学网络教学视频总结的笔记，初衷仅为个人的学习和复习使用，本人使用的编译器为Pycharm，内容仅供参考（俺是小白，有不对的地方希望各位大佬指出，谢谢！）
本笔记不是新手教程！不是新手教程！不是新手教程！俺也还是个宝宝呢！
"""可以输出数字"""
print(520)
print(13.14)
"""可以输出字符串"""
print('hello CSDN')
print("hello CSDN")
"""可以输出含有运算符的表达式"""
print(1+2)
"""不进行换行输出（输出内容在一行当中）"""
print('hello', 'CSDN', 'python')
==========输出结果==========
520
13.14
hello CSDN
hello CSDN
3
hello CSDN python
进程已结束,退出代码0"""
将数据输出到文件中
Tips：1.所指定的盘符得存在；
2.使用file =...的格式.
"""
fp = open('D:/text.txt', 'a+') # a+: 如果文件不存在就创建，存在就在文件内容的后面继续添加
print('helloworld', file=fp)
fp.close()
"""转义字符"""
print('hello\nworld') # \ +转义功能的首字母 n-->newline的首字符表示换行
print('hello\tworld')
print('helloooo\tworld') # 制表符\t 缺了的补齐四位，刚好的重开四位
print('hello\rworld') # world将hello进行了覆盖
print('hello\bworld') # \b是退一个格，将o退没了
print('http:\\\\www.baidu.com')
print('拉格朗日说:\"我爱你\"')
"""原字符：不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r或R"""
print(r'hello\nworld')
# 注意事项：最后一个字符不能是反斜杠
# print(r'hello\nworld\')
print(r'hello\nworld\\')
==========输出结果==========
hello
world
hello world
helloooo world
world
hellworld
http:\\www.baidu.com
拉格朗日说:"我爱你"
hello\nworld
hello\nworld\\
进程已结束,退出代码0二进制0,1--->ASCII--->GB2312--->GBK--->GB18030--->Unicode(几乎包括了全世界的字符)--->UTF-8
print(chr(0b100111001011000))
print(ord('乘'))
==========输出结果==========
乘
20056
进程已结束,退出代码0"""
保留字：有一些单词被赋予了特定的意义，这些单词在给你的任何对象起名字的时候都不能用
标识符：变量、函数、类、模块和其他对象起的名字就叫标识符
规则:1.字母、数字、下划线_
2.不能以数字开头
3.不能是保留字
4.严格区分大小写
"""
import keyword
print(keyword.kwlist) # 查看保留字
==========输出结果==========
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
进程已结束,退出代码0name = '拉格朗日'
print(name)
print('标识', id(name))
print('类型', type(name))
print('值', name)
==========输出结果==========
拉格朗日
标识 1777382838736
类型 <class 'str'>
值 拉格朗日
进程已结束,退出代码0name = '拉格朗日'
print(name)
name = '毕达哥拉斯'
print(name)
==========输出结果==========
拉格朗日
毕达哥拉斯
进程已结束,退出代码0整数类型 ---> int ---> 98
浮点数类型 ---> float ---> 3.141592
布尔类型 ---> bool ---> True，False
字符串类型 ---> str ---> '玛卡巴卡'
"""
整数类型
▪ 英文为integer，简写为int，可以表示正数、负数和零
▪ 整数的不同进制方式
1.十进制 ---> 默认的进制
2.二进制 ---> 以0b开头
3.八进制 ---> 以0o开头
4.十六进制 ---> 以0x开头
"""
n1 = 90
n2 = -65
n3 = 0
print(n1, type(n1))
print(n2, type(n2))
print(n3, type(n3))
# 整数可以表示为二进制、八进制、十进制、十六进制
print('十进制', 618)
print('二进制', 0b10101111)
print('八进制', 0o176)
print('十六进制', 0x1EAF)
==========输出结果==========
90 <class 'int'>
-65 <class 'int'>
0 <class 'int'>
十进制 618
二进制 175
八进制 126
十六进制 7855
进程已结束,退出代码0"""
浮点类型
▪ 浮点数是由整数部分和小数部分组成的
▪ 浮点数存储的不精确性
"""
a = 3.14159
print(a, type(a))
# 使用浮点数进行计算时，可能会出现小数位数不确定的情况
print(1.1+2.2) # 3.00000000000003
print(1.1+2.1) # 3.2
# 解决方案：导入模块decimal
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2')) # 3.3
==========输出结果==========
3.14159 <class 'float'>
3.3000000000000003
3.2
3.3
进程已结束,退出代码0"""
布尔类型
▪ 用来表示真或假的值
▪ True表示真，False表示假
▪ 布尔值可以转化为正数 Ture ---> 1 False ---> 0
"""
f1 = True
f2 = False
print(f1, type(f1))
print(f2, type(f2))
# 布尔值可以转成整数计算
print(f1+1) # 2 1+1的结果为2，True表示1
print(f2+1) # 1 0+1的结果为1，False表示0
==========输出结果==========
True <class 'bool'>
False <class 'bool'>
2
1
进程已结束,退出代码0
"""
字符串类型
▪ 字符串又被称为不可变的字符序列
▪ 可以使用单引号' '双引号" "三引号''' '''或""" """来定义
▪ 单引号和双引号定义的字符串必须在一行
▪ 三引号定义的字符串可以分布在连续的多行
"""
str1 = '人生苦短，我用Python'
str2 = "人生苦短，我用Python"
str3 = '''人生苦短，
我用Python'''
print(str1, type(str1))
print(str2, type(str2))
print(str3, type(str3))
==========输出结果==========
人生苦短，我用Python <class 'str'>
人生苦短，我用Python <class 'str'>
人生苦短，
我用Python <class 'str'>
进程已结束,退出代码0
name = '张三'
age = 20
print(type(name), type(age)) # 说明name与age的数据类型不相同
# print('我叫'+name+'今年'+age+'岁') 当将str类型与int类型进行连接时，报错，解决方案：类型转换
print('我叫'+name+'今年'+str(age)+'岁') # 将int类型通过str()函数转换成了str类型
==========输出结果==========
<class 'str'> <class 'int'>
我叫张三今年20岁
进程已结束,退出代码0print('----------int()函数将其他类型转成int类型----------')
s1 = '128'
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1), type(f1), type(s2), type(ff), type(s3))
print(int(s1), type(int(s1))) # 将str转成int类型，字符串为 数字串
print(int(f1), type(int(f1))) # 将float转成int类型，截取整数部分，舍掉小数部分
# print(int(s2), type(int(s2))) 将str转成int类型，报错，因为字符串为 小数串
print(int(ff), type(int(ff))) # 将bool转成int类型，True --> 1 False --> 0
# print(int(s3), type(int(s3))) 将str转成int类型，字符串必须为数字串（整数），非数字串是不允许转换的
==========输出结果==========
----------str()函数将其他类型转成str类型----------
<class 'int'> <class 'float'> <class 'bool'>
10 198.8 False <class 'str'> <class 'str'> <class 'str'>
进程已结束,退出代码0print('----------int()函数将其他类型转成int类型----------')
s1 = '128'
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1), type(f1), type(s2), type(ff), type(s3))
print(int(s1), type(int(s1))) # 将str转成int类型，字符串为 数字串
print(int(f1), type(int(f1))) # 将float转成int类型，截取整数部分，舍掉小数部分
# print(int(s2), type(int(s2))) 将str转成int类型，报错，因为字符串为 小数串
print(int(ff), type(int(ff))) # 将bool转成int类型，True --> 1 False --> 0
# print(int(s3), type(int(s3))) 将str转成int类型，字符串必须为数字串（整数），非数字串是不允许转换的
==========输出结果==========
----------int()函数将其他类型转成int类型----------
<class 'str'> <class 'float'> <class 'str'> <class 'bool'> <class 'str'>
128 <class 'int'>
98 <class 'int'>
1 <class 'int'>
进程已结束,退出代码0print('----------float()函数将其他类型转成float类型----------')
s1 = '128.98'
s2 = '76'
ff = True
s3 = 'hello'
i = 98
print(type(s1), type(s2), type(ff), type(s3), type(i))
print(float(s1), type(float(s1)))
print(float(s2), type(float(s2)))
print(float(ff), type(float(ff)))
# print(float(s3), type(float(s3))) 字符串中的数据如果是非数字串，则不允许转换
print(float(i), type(float(i)))
==========输出结果==========
----------float()函数将其他类型转成float类型----------
<class 'str'> <class 'str'> <class 'bool'> <class 'str'> <class 'int'>
128.98 <class 'float'>
76.0 <class 'float'>
1.0 <class 'float'>
98.0 <class 'float'>
进程已结束,退出代码0
# 单行注释 """ 多行注释 """ # 中文编码声明 #coding:utf-8
# 输入函数 input
present = input('大圣想要什么礼物呢？')
print(present, type(present))
# 从键盘录入两个整数，计算两个整数的和
a = int(input('请输入一个加数：'))
# a = int(a) # 将转换之后的结果存储到a中
b = input('请输入另一个加数：')
b = int(b) # 将转换之后的结果存储到b中
print(type(a), type(b))
print(a+b)
==========输出结果==========
大圣想要什么礼物呢？拉格朗日
拉格朗日 <class 'str'>
请输入一个加数：520
请输入另一个加数：1314
<class 'int'> <class 'int'>
1834
进程已结束,退出代码0print(1+1) # 加法运算
print(1-1) # 减法运算
print(2*4) # 乘法运算
print(1/2) # 除法运算
print(11//2) # 5 整除运算
print(11%2) # 1 取余运算
print(2**2) # 表示2的2次方
print(9//4) # 2
print(-9//-4) # 2
print(9//-4) # -3
print(-9//4) # -3 一正一负的整数公式，向下取整
print(9%-4) # -3 公式： 余数=被除数-除数*商
print(-9%4) # 3 -9-4*(-3) ---> 3
==========输出结果==========
2
0
8
0.5
5
1
4
2
2
-3
-3
-3
3
进程已结束,退出代码0# 赋值运算符：运算顺序从右到左
i = 3+4
print(i)
print('------支持链式赋值------')
a = b = c = 20 # 支持链式赋值
print(a, id(a))
print(b, id(b))
print(c, id(c))
print('------支持参数赋值------')
a = 20
a += 30
print(a)
a -= 10
print(a)
a *= 2
print(type(a))
print(a)
a /= 3
print(type(a))
print(a)
a //= 2
print(type(a))
print(a)
print('------支持系列解包赋值------')
a, b, c = 20, 30, 40
print(a, b, c)
# a, b = 20, 30, 40 报错，因为左边变量的个数和值的个数不对应
print('------交换两个变量的值------')
a, b = 10, 20
print('交换之前：', a, b)
# 交换
a, b = b, a
print('交换之后：', a, b)
==========输出结果==========
7
------支持链式赋值------
20 2475929043792
20 2475929043792
20 2475929043792
------支持参数赋值------
50
40
<class 'int'>
80
<class 'float'>
26.666666666666668
<class 'float'>
13.0
------支持系列解包赋值------
20 30 40
------交换两个变量的值------
交换之前： 10 20
交换之后： 20 10
进程已结束,退出代码0# 比较运算符
a, b = 10, 20
print('a>b吗？', a > b) # False
print('a<b吗？', a < b) # True
print('a<=b吗?', a <= b) # True
print('a>=b吗?', a >= b) # False
print('a==b吗?', a == b) # False
print('a!=b吗?', a != b) # True
"""
一个 = 称为赋值运算符， == 称为比较运算符
一个变量有三部分组成：标识，类型，值
== 比较的是值还是标识呢？ 值
比较对象的标识使用 is
"""
a = 10
b = 10
print(a == b) # True 说明：a与b的 value 相等
print(a is b) # Ture 说明：a与b的 id 标识相等
# 以下代码没学过
lst1 = [11, 22, 33, 44]
lst2 = [11, 22, 33, 44]
print(lst1 == lst2) # value ---> True
print(lst1 is lst2) # id ---> False
print(id(lst1))
print(id(lst2))
print(a is not b) # False a的id与b的id是不相等的
print(lst1 is not lst2) # True
==========输出结果==========
a>b吗？ False
a<b吗？ True
a<=b吗? True
a>=b吗? False
a==b吗? False
a!=b吗? True
True
True
True
False
1723825959808
1723825942656
False
True
进程已结束,退出代码0# 布尔运算符
print('------ and 并且 ------') # 相当于C中的"&&"逻辑“与”
a, b = 1, 2
print(a == 1 and b == 2) # True True and True ---> True
print(a == 1 and b < 2) # False True and False ---> False
print(a != 1 and b == 2) # False False and True ---> False
print(a != 1 and b != 2) # False False and False ---> False
print('------ or 或者 ------') # 相当于C中的“||”逻辑“或”
print(a == 1 or b == 2) # True True or True ---> True
print(a == 1 or b < 2) # True True or False ---> True
print(a != 1 or b == 2) # True False or True ---> True
print(a != 1 or b != 2) # False False or False ---> False
print('------ not 对运算取反------') # 相当于C中的“！”逻辑“非”
f = True
f2 = False
print(not f) # False not True ---> False
print(not f2) # True not False ---> True
print('------- in 与 not in ------')
s = 'helloworld'
print('w' in s) # True
print('k' in s) # False
print('w' not in s) # False
print('k' not in s) # True
==========输出结果==========
------ and 并且 ------
True
False
False
False
------ or 或者 ------
True
True
True
False
------ not 对运算取反------
False
True
------- in 与 not in ------
True
False
False
True
进程已结束,退出代码0
print(4 & 8) # 按位逻辑“与” &，同为1时结果为1，否则结果为0
print(4 | 8) # 按位逻辑“或” |，同为0时结果为0，否则结果为1
print(4 << 1) # 向左移动1位（移动1个位置），相当于乘以2
print(4 << 2) # 向左移动2位（移动2个位置），相当于乘以4
print(4 >> 1) # 向右移动1位（移动1个位置），相当于除以2
print(4 >> 2) # 向右移动2位（移动2个位置），相当于除以4
==========输出结果==========
0
12
8
16
2
1
进程已结束,退出代码0"""
* 指数 (最高优先级)
~ + - 按位翻转, 一元加号和减号
* / % // 乘，除，取模和取整除
+ - 加法减法
>> << 右移，左移运算符
& 位运算符
| 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
and or not 逻辑运算符
"""# 顺序结构
# 把大象装冰箱一共分几步
print('------程序开始------')
print('1.把冰箱门打开')
print('2.把大象放冰箱里')
print('3.把冰箱门关上')
print('------程序结束------')# 测试对象的布尔值
"""
以下对象的布尔值为False
▪ False
▪ 数值0
▪ None
▪ 空字符串
▪ 空列表
▪ 空元组
▪ 空字典
▪ 空集合
"""
print('----------以下对象的布尔值均为False----------')
print(bool(False)) # False
print(bool(0)) # False
print(bool(0.0)) # False
print(bool(None)) # False
print(bool('')) # False
print(bool("")) # False
print(bool([])) # 空列表
print(bool(list())) # 空列表
print(bool(())) # 空元组
print(bool(tuple())) # 空元组
print(bool({})) # 空字典
print(bool(dict())) # 空字典
print(bool(set())) # 空集合
print('----------其它对象的布尔值均为True----------')
print(bool(18))
print(bool(True))
print(bool('helloworld'))
==========输出结果==========
----------以下对象的布尔值均为False----------
False
False
False
False
False
False
False
False
False
False
False
False
False
----------其它对象的布尔值均为True----------
True
True
True
进程已结束,退出代码0money = 1000 # 余额
s = int(input('请输入取款金额')) # 取款金额
# 判断余额是否充足
if s <= money:
money = money - s
print('取款成功，余额为：', money)
==========输出结果==========
请输入取款金额520
取款成功，余额为： 480
进程已结束,退出代码0# 双分支结构if—else，二选一执行
"""
从键盘录入一个整数，编写程序让计算机判断是奇数还是偶数
"""
num = int(input('请输入一个整数：'))
# 条件判断
if num % 2 == 0:
print(num, '是偶数')
else:
print(num, '是奇数')
=========输出结果==========
请输入一个整数：7
7 是奇数
进程已结束,退出代码0score = int(input('请输入一个成绩：'))
# 判断
if 90 <= score <= 100:
print('A级')
elif 80 <= score <= 89:
print('B级')
elif 70 <= score <= 79:
print('C级')
elif 60 <= score <= 69:
print('D级')
elif 0 <= score <= 59:
print('E级')
else:
print('对不起，您输入的成绩有误，不在成绩的有效范围')
==========输出结果==========
请输入一个成绩：63
D级
进程已结束,退出代码0"""
会员 >=200 八折
>=100 九折
不打折
非会员 >=200 九五折
不打折
"""
answer = input('您是会员吗？y/n')
money = float(input('请输入您的购物金额：'))
# 外层判断是否是会员
if answer == 'y': # 会员
if money >= 200:
print('打八折，付款金额为：', 0.8 * money)
elif 100 <= money < 200:
print('打九折，付款金额为：', 0.9 * money)
else:
print('不打折，付款金额为：', money)
else: # 非会员
if money >= 200:
print('打九五折，付款金额为：', 0.95 * money)
else:
print('不打折，付款金额为：', money)
==========输出结果==========
您是会员吗？y/ny
请输入您的购物金额：120
打九折，付款金额为： 108.0
进程已结束,退出代码0"""从键盘录入两个整数，比较两个整数的大小"""
num_a = int(input('请输入第一个整数：'))
num_b = int(input('请输入第二个整数：'))
# 比较大小
"""
if num_a >= num_b:
print(num_a, '大于等于', num_b)
else:
print(num_a, '小于', num_b)
"""
print('使用条件表达式进行比较')
print(str(num_a) + '大于等于' + str(num_b) if num_a >= num_b else str(num_a) + '小于' + str(num_b))
==========输出结果==========
请输入第一个整数：14
请输入第二个整数：12
使用条件表达式进行比较
14大于等于12
进程已结束,退出代码0"""
pass语句
▪ 语句什么都不做，只是一个占位符，用在语法上需要语句的地方
pass语句什么时候使用：
▪ 先搭建语法结构，还没想好代码怎么写的时候
pass语句和那些语句一起使用
▪ if语句的条件执行体
▪ for-in语句的循环体
▪ 定义函数时的函数体
"""
answer = input('您是会员吗？y/n')
# 判断是否是会员
if answer == 'y':
pass
else:
pass
==========输出结果==========
您是会员吗？y/nn
进程已结束,退出代码0# range()函数用于生成一个整数序列
# range()的三种创建方式
"""第一种创建方式，只有一个参数（小括号中只给了一个数）"""
r = range(10) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]，默认从0开始，默认相差1为步长
print(r) # range(0, 10) 返回值是一个迭代器对象
print(list(r)) # 用于查看range对象中的整数序列 ---> list是列表的意思
"""第二种创建方式，给了两个参数（小括号中给了两个数）"""
r = range(1, 10) # 指定了起始值，从1开始，到10结束（不包含10），默认步长为1
print(list(r)) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
"""第三种创建方式，"""
r = range(1, 10, 2)
print(list(r)) # [1, 3, 5, 7, 9]
"""判断指定的整数，在序列中是否存在 in , not in"""
print(10 in r) # False，10不在当前的r这个整数序列中
print(9 in r) # True，9在当前的r这个整数序列中
print(10 not in r) # True
print(9 not in r) # False、
==========输出结果=========
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]
False
True
True
False
进程已结束,退出代码0a = 1
# 判断条件表达式
while a < 10:
# 执行条件执行体
print(a)
a += 1
# 计算0到4之间的累加
"""
四步循环法：
▪ 初始化变量
▪ 条件判断
▪ 条件执行体（循环体）
▪ 改变变量
总结：初始化的变量与条件判断的变量与改变的变量为同一个
"""
"""初始化变量为0"""
a = 0
sum = 0
"""条件判断"""
while a < 5:
"""条件执行体（循环体）"""
sum += a
"""改变变量"""
a += 1
print('和为', sum)
"""练习：计算1到100之间的偶数和"""
print(bool(0))
a = 1
sum = 0 # 用于存储偶数和
while a <= 100:
if not bool(a % 2): # if a % 2 == 0:
sum += a
a += 1
print('1到100之间的偶数和为：', sum)
==========输出结果==========
1
2
3
4
5
6
7
8
9
和为 10
False
1到100之间的偶数和为： 2550
进程已结束,退出代码0"""
========== for-in循环 ==========
▪ in表达从（字符串、序列等）中依次取值，又称为遍历
▪ for-in遍历的对象必须是可迭代对象
========== for-in的语法结构 ==========
▪ for 自定义的变量 in 可迭代对象:
循环体
"""
for item in 'Python': # 第一次取出来的是P，将P赋值给item，将item的值输出
print(item)
# range() 产生一个整数序列 ---> 也是一个可迭代对象
for i in range(10):
print(i)
# 如果在循环体中不需要使用到自定义变量，可将自定义变量写为“_”
for _ in range(5):
print('人生苦短，我用Python')
print('使用for循环，计算1到100之间的偶数和')
sum = 0 # 用于存储偶数和
for item in range(1, 101):
if item % 2 == 0:
sum += item
print('1到100之间的偶数和为：', sum)
"""练习：输出100到999之间的水仙花数"""
# 举例：153 = 3 ** 3 + 5 ** 3 + 1 * 3
for item in range(100, 1000):
if (item % 10) ** 3 + (item // 10 % 10) ** 3 + (item // 100) ** 3 == item:
print(item)
==========输出结果==========
P
y
t
h
o
n
0
1
2
3
4
5
6
7
8
9
人生苦短，我用Python
人生苦短，我用Python
人生苦短，我用Python
人生苦短，我用Python
人生苦短，我用Python
使用for循环，计算1到100之间的偶数和
1到100之间的偶数和为： 2550
153
370
371
407
进程已结束,退出代码0"""break语句：用于结束循环结构，通常与分支结构if一起使用"""
# 从键盘录入密码，最多录入三次，如果正确就结束循环
# ==========for循环==========
for item in range(3):
password = input('请输入密码：')
if password == '8888':
print('密码正确')
break
else:
print('密码不正确')
==========输出结果==========
请输入密码：8888
密码正确
进程已结束,退出代码0# ==========while循环==========
a = 1
while a < 4:
pwd = input('请输入密码：')
if pwd == '8888':
print('密码正确')
break
else:
print('密码错误')
a += 1
==========输出结果==========
请输入密码：1234
密码错误
请输入密码：4567
密码错误
请输入密码：5465
密码错误
进程已结束,退出代码0"""continue循环：用于结束当前循环，进入下一循环，通常与分支结构中的if一起使用"""
"""要求输出1到50之间所有5的倍数"""
# for循环
for item in range(1, 51):
if item % 5 == 0:
print(item)
print('==========使用continue语句==========')
for item in range(1, 51):
if item % 5 != 0:
continue
print(item)
==========输出结果==========
5
10
15
20
25
30
35
40
45
50
==========使用continue语句==========
5
10
15
20
25
30
35
40
45
50
进程已结束,退出代码0# ==========for循环==========
for item in range(3):
pwd = input('请输入密码：')
if pwd == '8888':
print('密码正确')
break
else:
print('密码不正确')
else:
print('对不起，三次密码均输入错误')
==========输出结果==========
请输入密码：1234
密码不正确
请输入密码：456
密码不正确
请输入密码：7890
密码不正确
对不起，三次密码均输入错误
进程已结束,退出代码0
# ==========while循环==========
a = 0
while a < 3:
pwd = input('请输入密码：')
if pwd == '8888':
print('密码正确：')
break
else:
print('密码错误')
a += 1
else:
print('对不起，三次密码均输入错误')
==========输出结果==========
请输入密码：1472
密码错误
请输入密码：5157
密码错误
请输入密码：5698
密码错误
对不起，三次密码均输入错误
进程已结束,退出代码0"""嵌套循环：循环结构中又嵌套了另外的完整的循环结构，其中内层循环做为外层循环的循环体执行"""
# 输入一个三行四列的矩形
for i in range(1, 4): # 行表，执行三次，一次是一行
for _ in range(1, 5):
print('*', end='\t') # 不换行输出
print() # 换行
# 打印一个直角三角形
for i in range(1, 10): # 行数
for j in range(1, i+1):
print('*', end='\t')
print()
# 打印九九乘法表
for i in range(1, 10):
for j in range(1, i+1):
print(i, '*', j, '=', i * j, end='\t')
print()
==========输出结果==========
* * * *
* * * *
* * * *
*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
进程已结束,退出代码0
"""流程控制语句break和continue在二重循环中的使用"""
for i in range(5): # 代表外层循环要执行五次
for j in range(1, 11):
if j % 2 == 0:
continue
# break
print(j, end='\t')
print()
==========输出结果==========
1 3 5 7 9
1 3 5 7 9
1 3 5 7 9
1 3 5 7 9
1 3 5 7 9
进程已结束,退出代码0