Python 自学笔记

前言

此Python3笔记仅为本人自学网络教学视频总结的笔记，初衷仅为个人的学习和复习使用，本人使用的编译器为Pycharm，内容仅供参考（俺是小白，有不对的地方希望各位大佬指出，谢谢！）

本笔记不是新手教程！不是新手教程！不是新手教程！俺也还是个宝宝呢！

---

第一章

1.输出函数print

"""可以输出数字"""
print(520)
print(13.14)

"""可以输出字符串"""
print('hello 优快云')
print("hello 优快云")

"""可以输出含有运算符的表达式"""
print(1+2)

"""不进行换行输出（输出内容在一行当中）"""
print('hello', '优快云', 'python')

==========输出结果==========
520
13.14
hello 优快云
hello 优快云
3
hello 优快云 python

进程已结束,退出代码0

"""
将数据输出到文件中
Tips：1.所指定的盘符得存在；
      2.使用file =...的格式.
"""
fp = open('D:/text.txt', 'a+')  # a+: 如果文件不存在就创建，存在就在文件内容的后面继续添加
print('helloworld', file=fp)
fp.close()

2.转义字符和原字符

"""转义字符"""
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

---

第二章

1.二进制与字符编码

二进制0,1--->ASCII--->GB2312--->GBK--->GB18030--->Unicode(几乎包括了全世界的字符)--->UTF-8

print(chr(0b100111001011000))
print(ord('乘'))

==========输出结果==========
乘
20056

进程已结束,退出代码0

---

2.Python中的标识符和保留字

"""
保留字：有一些单词被赋予了特定的意义，这些单词在给你的任何对象起名字的时候都不能用
标识符：变量、函数、类、模块和其他对象起的名字就叫标识符
规则: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']

进程已结束,退出代码0

---

 3.变量的定义和使用

name = '拉格朗日'
print(name)
print('标识', id(name))
print('类型', type(name))
print('值', name)


==========输出结果==========
拉格朗日
标识 1777382838736
类型 <class 'str'>
值 拉格朗日

进程已结束,退出代码0

---

4.变量的多次赋值 

name = '拉格朗日'
print(name)
name = '毕达哥拉斯'
print(name)


==========输出结果==========
拉格朗日
毕达哥拉斯

进程已结束,退出代码0

---

 5.Python中常见的数据类型

 整数类型 ---> 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

6.类型转换_str 函数、int 函数和float 函数

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岁

进程已结束,退出代码0

print('----------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'>

进程已结束,退出代码0

print('----------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'>

进程已结束,退出代码0

print('----------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

---

7.Python中的注释

# 单行注释
"""
多行注释
"""
# 中文编码声明
#coding:utf-8

---

第三章

1.input函数的使用

# 输入函数 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

进程已结束,退出代码0

---

2.运算符_算数运算符

print(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

---

3.运算符_赋值运算符

# 赋值运算符：运算顺序从右到左
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

---

4.运算符_比较运算符

# 比较运算符
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

---

5.运算符_布尔运算符

# 布尔运算符
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

---

6.运算符_位运算

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

---

7.Python运算符的优先顺序

"""

*	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位运算符
|	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
and or not	逻辑运算符

"""

---

第四章

1.程序的组织结构_顺序结构

# 顺序结构
# 把大象装冰箱一共分几步
print('------程序开始------')
print('1.把冰箱门打开')
print('2.把大象放冰箱里')
print('3.把冰箱门关上')
print('------程序结束------')

---

2.对象的布尔值

# 测试对象的布尔值
"""
以下对象的布尔值为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

进程已结束,退出代码0

---

3.分支结构_单分支结构

money = 1000  # 余额
s = int(input('请输入取款金额'))  # 取款金额
# 判断余额是否充足
if s <= money:
    money = money - s
    print('取款成功，余额为：', money)


==========输出结果==========
请输入取款金额520
取款成功，余额为： 480

进程已结束,退出代码0

---

4.分支结构_双分支结构

# 双分支结构if—else，二选一执行
"""
从键盘录入一个整数，编写程序让计算机判断是奇数还是偶数
"""

num = int(input('请输入一个整数：'))

# 条件判断
if num % 2 == 0:
    print(num, '是偶数')
else:
    print(num, '是奇数')


=========输出结果==========
请输入一个整数：7
7 是奇数

进程已结束,退出代码0

---

5.分支结构_多分支结构

score = 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

---

6.分支结构_嵌套if的使用

"""
会员  >=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

---

7. 条件表达式

"""从键盘录入两个整数，比较两个整数的大小"""
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

---

8.pass语句

"""
pass语句
▪ 语句什么都不做，只是一个占位符，用在语法上需要语句的地方
pass语句什么时候使用：
▪ 先搭建语法结构，还没想好代码怎么写的时候
pass语句和那些语句一起使用
▪ if语句的条件执行体
▪ for-in语句的循环体
▪ 定义函数时的函数体
"""

answer = input('您是会员吗？y/n')

# 判断是否是会员
if answer == 'y':
    pass
else:
    pass


==========输出结果==========
您是会员吗？y/nn

进程已结束,退出代码0

---

第五章

1.range()函数的使用

# 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

进程已结束,退出代码0

---

2.while循环

a = 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

---

3.for-in循环

"""
========== 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

---

4.流程控制语句break

"""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

---

5.流程控制语句continue

"""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

---

6.else语句

# ==========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

---

7.嵌套循环

"""嵌套循环：循环结构中又嵌套了另外的完整的循环结构，其中内层循环做为外层循环的循环体执行"""
# 输入一个三行四列的矩形

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

---

8.二重循环中的break和continue

"""流程控制语句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