Python是一种「基于C语言」实现的，「开源」的，「面向对象的」的，「动态数据类型」的「解释型」语言。
Python的语法「简单」且「优雅」，相对于其他语言学习「难度较低」，入门非常快。
Python的上升趋势非常明显，20年来首次超过C语言和Java，成为「最受欢迎」的程序语言。
许多PC和Mac默认已经安装了python，在 cmd 运行以下命令检查是否安装了python
C:\Users\zhangsan>python --version
已安装python则会显示出python的「版本」
Python 3.8.6
如果你的电脑没装Python，就先安装Python的开发工具。
每学习一门新语言，第一件事当然是输出"Hello, World!"
第一步：「新建」一个文本文件，「输入」以下内容，「修改」文件名为 hello.py
print('Hello, Python!')
第二步： 在文件所在目录的地址栏中输入 cmd （当前目录打开 cmd ）
第三步：「执行」python文件
恭喜，你已经编写并执行了第一个python程序，点击 ↓↓↓ 安装集成开发工具。
Python中使用缩进（而不是{}）来控制代码块，即代码行开头的「空格」
同一代码块中必须使用「相同数量」的空格（默认使用两个空格）
if 2 > 1:
print('Hello, Python!')
输出：
Hello, Python!
如果「没有缩进」，则会报错
if 2 > 1:
print('Hello, Python!')
输出：
File "E:/data/PrCharm/test/test.py", line 2
print('Hello, Python!')
^
IndentationError: expected an indented block
# 缩进错误：此处需要缩进
注释是给人看的，用来「解释」代码的作用，注释的内容「不会被执行」
Python的注释以 # 开头
# 注释不会被执行
print('Hello, Python!')
输出：
Hello, Python!
「未分配」给变量的字符串不会被执行，可当做注释使用
'字符串注释'
print('Hello, Python!')
输出：
Hello, Python!
一对引号只能包含一行内容，三引号可包含「多行内容」，起到多行注释的作用
'''
多行注释
多行注释
'''
print('Hello, Python!')
输出：
Hello, Python!
变量用来「存放数据」
Python的变量在被赋值时「创建」，不需要声明变量
text = 5
print(text)
输出：
5
Python会根据变量内容自动确定「变量类型」，不需要「声明」变量类型，可随意「修改」数据类型
text = 5
text = '张三'
print(text)
输出：
张三
变量命名规则：
Python可以同时为「多个变量赋值」，变量与值的「位置」一一对应
x, y, z = '张三', '李四', '王五'
print(x, y, z)
输出：
张三 李四 王五
x = y = z = '张三'
print(x, y, z)
输出：
张三 张三 张三
函数「外部」创建的变量称为全局变量，函数内部和外部都能使用
name = '张三' # 全局变量
def hello():
print(name)
hello()
输出：
张三
函数「内部」 创建的变量成为局部变量，只能在函数内部使用
def hello():
name = '张三' # 局部变量
print(name)
hello()
输出：
张三
def hello():
name = '张三' # 局部变量
hello()
print(name)
输出：
Traceback (most recent call last):
File "E:/data/PrCharm/test/test.py", line 4, in <module>
print(name)
NameError: name 'name' is not defined
# 名称错误，变量‘name’没有被定义
global 可以将局部变量更改为全局变量
def hello():
global name # 定义全局变量
name = '张三' # 赋值
hello()
print(name)
输出：
张三
def hello():
name = '张三' # 赋值
global name # 定义全局变量
hello()
print(name)
输出：
File "E:/data/PrCharm/test/test.py", line 3
global name # 定义全局变量
^
SyntaxError: name 'name' is assigned to before global declaration
# 语法错误：变量‘name’在全局声明之前被赋值
Python变量的数据类型有8种：
其中数字、字符串、元祖是不可变类型；列表、字典、集合是可变类型。
数字类型（Numbers）用来存储数值，比如整数、小数等。
「创建」数字类型变量
num1 = 1
num2 = 1.1
del可以「删除」对象的引用
del num1
删除后的对象，再引用会报错
num1 = 1
print('删除前：', num1)
del num1
print('删除后：', num1)
输出：
Traceback (most recent call last):
File "C:\Users\dell\PycharmProjects\pythonProject1\test1.py", line 7, in <module>
print('删除后：', num1)
NameError: name 'num1' is not defined
删除前： 1
数字类型是不可变的，值「修改」以后，会分配一个新的对象。
num1 = 1
print('改变前：', id(num1))
num1 = 2
print('改变后：', id(num1))
输出：
改变前： 140729117181600
改变后： 140729117181632
字符串是由数字、字母、下划线组成的一串字符，用单/双引号包裹。
「创建」字符串变量
str1 = '123_abc'
str2 = "123_abc"
del可以「删除」字符串，删除后，再引用会报错 NameError: name ‘str1’ is not defined
str1 = 'abc'
print('删除前：', str1)
del str1
print('删除后：', str1)
输出：
字符串是不可变类型，当值被「修改」，就会分配一个新的对象，内存地址发生改变。
str1 = 'abc'
print('修改前：', id(str1))
str1 = 'def'
print('修改后：', id(str1))
输出：
修改前： 2035775820080
修改后： 2035778983344
字符串相当于一种特殊的数组，可以通过索引来「读取」字符串中的字符，索引从0开始
比如，读取单个字符（读取第4个字符）
str1 = '123_abc'
print(str1[4])
输出：
a
「读取多个」字符（读取第4~6个字符），含头不含尾
str1 = '123_abc'
print(str1[4:6])
输出：
ab
字符串之间可以通过一些「运算符」来简化操作。
| 运算符 | 描述 |
|---|---|
| + | 拼接字符串 |
| * | 重复字符串 |
| in | 成员运算符，字符串中包含指定字符串时返回True |
| not in | 成员运算符，字符串中不包含指定字符串时返回True |
| r/R | 输出原始字符串（转义符不生效） |
print('hello' + 'world')
print('hello' * 3)
print('a' in 'abcd')
print('a' not in 'abcd')
print(r'a\'')
输出：
helloworld
hellohellohello
True
False
a\'
字符串中，使用反斜杠\来转译特殊字符。
| 转义字符 | 描述 |
|---|---|
\ | 反斜杠 |
\' | 单引号 |
\" | 双引号 |
\n | 换行 |
\v | 纵向制表符 |
\t | 横向制表符 |
\f | 换页 |
print('hello world')
print('hello \ world')
print('hello \' world')
print('hello \" world')
print('hello \n world')
print('hello \v world')
print('hello \t world')
print('hello \t world')
输出：
hello world
hello \ world
hello ' world
hello " world
hello
world
hello world
hello world
hello world
想让转义符不生效，可以在字符串前面加上 r
str1 = r'abc\ndef'
print(str1)
输出：
abc\ndef
布尔类型只有两个值：True 和 False。
「创建」布尔类型变量
a = True
b = False
首字母必须大写，否则会报错 NameError: name ‘true’ is not defined
a = true
print(a)
输出：
True会被当做 1，False 会被当做 0。
print(int(True))
print(int(False))
输出：
1
0
bool() 可以把其他类型「转换」成布尔类型
print(bool(1))
print(bool(0))
print(bool(''))
print(bool([]))
print(bool({}))
输出：
True
False
False
False
False
列表用中括号[]包裹，元素之间使用逗号,分隔。
创建列表类型的变量
list1 = [1, 2, 3]
读取整个列表
list1 = [1, 2, 3]
print(list1)
输出：
[1, 2, 3]
通过索引，读取列表中的某个元素，索引从 0 开始。
list1 = [1, 2, 3]
print(list1[1])
输出：
2
读取第1~3个元素，含头不含尾[1~3)
list1 = [1, 2, 3, 4, 5]
print(list1[1:3])
输出：
[2, 3]
列表中的元素可以修改。
比如，修改一个元素
list1 = [1, 2, 3, 4, 5]
list1[1] = '张三'
print(list1)
输出：
[1, '张三', 3, 4, 5]
修改多个元素
list1 = [1, 2, 3, 4, 5]
list1[1:3] = '张三', '李四'
print(list1)
输出：
[1, '张三', '李四', 4, 5]
列表可以配合一些「运算符」，简化列表的操作
| 运算符 | 描述 |
|---|---|
| list[] + list[] | 拼接列表 |
| list[] * n | 重复列表 |
| k in list[] | 判断元素是否在列表中 |
| for k in list[]：print( k ) | 迭代 |
加号 + 可以拼接两个列表，返回一个新的列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
new_list = list1 + list2
print(new_list)
输出：
[1, 2, 3, 4, 5, 6]
乘号 * 可以将列表重复拼接多次，返回一个新的列表
list1 = [1, 2, 3]
new_list = list1 * 3
print(new_list)
输出：
[1, 2, 3, 1, 2, 3, 1, 2, 3]
in 可以判断列表中是否存在某个元素，存在返回True，不存在返回False
list1 = [1, 2, 3]
print(1 in list1)
输出：
True
使用「迭代」的方式，可以更简洁的遍历列表的每一个元素
list1 = [1, 2, 3]
for k in list1:
print(k)
输出：
1
2
3
元组用小括号()包裹，元素之间用逗号,分隔。
创建元组类型的变量
tuple1 = (1, 2, 3, 4)
和列表、字符串一样，也能通过索引读取。
tuple1 = (1, 2, 3, 4)
print(tuple1)
print(tuple1[1])
print(tuple1[1:3])
输出：
(1, 2, 3, 4)
2
(2, 3)
元组是不可变类型，元素不可以修改，否则会报错 TypeError: ‘tuple’ object does not support item assignment
tuple1 = (1, 2, 3, 4)
tuple1[1] = 3
输出：
虽然元组不可变，但可以配合一些「运算符」，改成新的元组。
| 操作符 | 描述 |
|---|---|
| tuple() + tuple() | 拼接元组 |
| tuple() * n | 重复元组 |
| k in tuple() | 元组中是否包含某个值 |
| for k in tuple() : print( k ) | 迭代遍历 |
加号 + 可以将两个元组「拼接」成一个新的元组
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
new_tuple = tuple1 + tuple2
print(new_tuple)
输出：
(1, 2, 3, 4, 5, 6)
乘号 * 可以将元组的内容「复制」多次，并生成一个新的元组
tuple1 = (1, 2, 3)
new_tuple = tuple1 * 3
print(new_tuple)
输出：
(1, 2, 3, 1, 2, 3, 1, 2, 3)
关键字 in 可以判断指定值是否在元组中存在，存在返回True，不存在返回False
tuple1 = (1, 2, 3)
print(1 in tuple1)
print(10 in tuple1)
输出：
True
False
使用「迭代」的方式，快速「遍历」列表中的元素
tuple1 = (1, 2, 3)
for k in tuple1:
print(k)
输出：
1
2
3
集合用大括号{}包裹，元素之间用逗号,分隔。
创建集合类型的变量
set1 = {1, 2, 3, 4}
集合没有下标，不能通过索引的方式读取，只能全部读取
set1 = {1, 2, 3, 4}
print(set1)
输出：
{1, 2, 3, 4}
集合的元素不允许重复，这个特点常被用来去重。
set() 函数可以将其他类型转成集合类型。
比如，给列表中的元素去重
list1 = [1, 1, 2, 2]
set1 = set(list1)
print(set1)
输出：
{1, 2}
集合有一些「操作符」，可以简化操作
| 操作符 | 描述 |
|---|---|
| k in set() | 判断集合中是否存在指定内容 |
| for k in set() : prin( k ) | 迭代遍历 |
关键字 in 可以判断某个值是否在集合中存在，存在返回True，不存在返回False。
set1 = {1, 2, 3}
print(1 in set1)
print(10 in set1)
输出：
True
False
使用「迭代」的方式快速「遍历」集合中的元素
set1 = {1, 2, 3}
for k in set1:
print(k)
输出：
1
2
3
字典用大括号{}包裹，元素由键值对key:value组成，元素之间用逗号,分隔，键和值之间用冒号:分隔
创建字典类型的变量
dict1 = {1: 1, 'key1': 'value1'}
字典可以根据键来读取值，和索引有些类似。
dict1 = {1: 1, 'key1': 'value1'}
print(dict1)
print(dict1['key1'])
输出：
{1: 1, 'key1': 'value1'}
value1
字典可以修改值，但不能修改键。并且键唯一，不可重复。
dict1 = {1: 1, 'key1': 'value1'}
dict1['key1'] = 1
print(dict1)
输出：
{1: 1, 'key1': 1}
bytes类型使用单双引号包裹，并在前面加上 b
bytes类型常用来处理二进制数据，比如视频、图片等。
创建bytes类型的变量
bytes1 = b'12345'
bytes类型也可以通过索引读取
bytes1 = b'12345'
print(bytes1)
print(bytes1[1])
print(bytes1[1:3])
输出：
b'12345'
50
b'23'
这里需要注意：bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。
type() 函数可以查看数据的「类型」，比如下面这个就是字符串类型（str）
str1 = 'abc'
print(type(str1))
输出：
<class 'str'>
数据之间可以进行类型转换，转换的方式有两种：「隐式类型转换」、「显式类型转换」。
在运算等场景时，Python会「自动」将一种数据类型转换成另一种数据类型，这种自动发生的类型转换，就是「隐式类型转换」。
比如整数和浮点数进行运算时，会先将整数转换成浮点数，再进行运算
int1 = 2
float1 = 2.01
result = int1 + float1
print('整数：', type(int1))
print('浮点数：', type(float1))
print('运算结果是浮点数：', type(result))
输出：
整数： <class 'int'>
浮点数： <class 'float'>
运算结果是浮点数： <class 'float'>
隐式类型转换只能转换「一小部分」，比如数字和字符串进行运算时，字符串就不能自动转换成数字
int1 = 2
str1 = '3'
print('整数：', type(int1))
print('字符串：', type(str1))
int1 + str1
输出：
整数： <class 'int'>
字符串： <class 'str'>
Traceback (most recent call last):
File "E:/data/PrCharm/pythonProject1/test.py", line 8, in <module>
int1 + str1
TypeError: unsupported operand type(s) for +: 'int' and 'str'
这种情况下，我们可以使用「显式类型转换」。
「显式类型转换」需要使用「函数」来转换数据类型，Python「内置」了一些类型转换的函数：
提示：点击列表中蓝色「函数名」可直达函数解析区域
| 函数名 | 作用 | 使用 |
|---|---|---|
| int | 转换为整型 | int( value ) |
| float | 转换为浮点型 | float( value ) |
| str | 转换为字符串 | str( value ) |
| bool | 转换为布尔类型 | bool( value ) |
| list | 转换为列表 | list( value ) |
| tuple | 转换为元祖 | tuple( value ) |
| set | 转换为集合 | set( value ) |
int() 可以将一个「字符串」或「数字」转成「整型」
语法
int( value )
参数
浮点型（ float）转换为整型，「只取整数」，不关心小数位（不存在四舍五入）
float1 = 1.1
float2 = 1.9
print('小数位小于5时：', int(float1))
print('小数位大于5时：', int(float2))
输出：
小数位小于5时： 1
小数位大于5时： 1
例：’111‘可以转，’111a’或‘3.14’不可以转
str1 = '111'
print('内容为纯整数的字符串：', int(str1))
输出：
内容为纯整数的字符串： 111
其他数据类型可以使用 float() 函数转换为「浮点型」（ float类型）
语法
float( value )
参数
「整型」（ int 类型）转换为浮点型
int1 = 111
print('整型（int类型）：', float(int1))
输出：
整型（int类型）： 111.0
str1 = '111'
str2 = '111.11'
print('内容为纯整型的字符串：', float(str1))
print('内容为纯浮点型的字符串：', float(str2))
输出：
内容为纯整型的字符串： 111.0
内容为纯浮点型的字符串： 111.11
str() 可以将「任意类型」转成「字符串」。
语法
str( value )
参数
int1 = 111
float1 = 11.1
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
set1 = {1, 2, 3}
dict = {'name': 'value'}
print('整型：', str(int1))
print('浮点型：', str(float1))
print('列表：', str(list1))
print('元祖：', str(tuple1))
print('集合：', str(set1))
print('字典：', str(dict))
输出：
整型： 111
浮点型： 11.1
列表： [1, 2, 3]
元祖： (1, 2, 3)
集合： {1, 2, 3}
字典： {'name': 'value'}
其他数据类型可以使用 bool() 函数转换为「布尔」类型
语法
bool( value )
参数
空值（ None , 0 , " " , () , [] , {} ）转换为 False，其他值转为 True
None1 = None
int1 = 0
str1 = ""
list1 = []
tuple1 = ()
set1 = {}
print('None：', bool(None1))
print('数字 0：', bool(int1))
print('空字符串：', bool(str1))
print('空列表：', bool(list1))
print('空字典：', bool(tuple1))
print('空集合：', bool(set1))
输出：
None： False
数字 0： False
空字符串： False
空列表： False
空字典： False
空集合： False
list() 可以将「元组」或「字符串」转成「列表」
语法
list( value )
参数
「可迭代对象」（ str, tuple, set, dict ）可以转换为列表
str1 = '111'
tuple1 = (1, 2, 3)
set1 = {1, 2, 3}
print('字符串：', list(str1))
print('元祖：', list(tuple1))
print('集合：', list(set1))
输出：
字符串： ['1', '1', '1']
元祖： [1, 2, 3]
集合： [1, 2, 3]
tuple() 可以将「可迭代序列」转换成「元组」
语法
tuple( value )
参数
「可迭代对象」（str, list, set, dict ）可以转化为元祖
str1 = '111'
list1 = [1, 2, 3]
set1 = {1, 2, 3}
dict1 = {'name': 'value'}
print('字符串：', tuple(str1))
print('列表：', tuple(list1))
print('元祖：', tuple(set1))
print('字典：', tuple(dict1))
输出：
字符串： ('1', '1', '1')
列表： (1, 2, 3)
元祖： (1, 2, 3)
字典： ('name',)
其他数据类型可以使用 set() 函数转换为「集合」（set类型）
语法
set( value )
参数
「可迭代对象」可以转换为集合
str1 = '111'
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
dict1 = {'name': 'value'}
print('字符串：', set(str1))
print('列表：', set(list1))
print('元祖：', set(tuple1))
print('字典：', set(dict1))
输出：
字符串： {'1'}
列表： {1, 2, 3}
元祖： {1, 2, 3}
字典： {'name'}
运算符用来对变量和值「执行操作」
| 运算符 | 作用 | 使用 |
|---|---|---|
| + | 加 | 1 + 2 |
| - | 减 | 2 - 1 |
| * | 乘 | 1 * 2 |
| / | 除 | 1 / 2 |
| % | 取余 | 1 % 2 |
| ** | 幂 | 1 ** 2 |
| // | 取整除 | 1 // 2 |
a = 2
b = 3
print('a加b的结果是：', a + b)
print('a减b的结果是：', a - b)
print('a乘b的结果是：', a * b)
print('a除b的结果是：', a / b)
print('a除b的余数是：', a % b)
print('a的b次方是：', a ** b)
print('a除b取整是：', a // b)
输出：
a加b的结果是： 5
a减b的结果是： -1
a乘b的结果是： 6
a除b的结果是： 0.6666666666666666
a除b的余数是： 2
a的b次方是： 8
a除b取整是： 0
| 运算符 | 作用 | 使用 |
|---|---|---|
| == | 等于 | a == b |
| != | 不等于 | a != b |
| > | 大于 | a > b |
| < | 小于 | a < b |
| >= | 大于或等于 | a >= b |
| <= | 小于或等于 | a <= b |
a = 2
b = 3
print('a是否等于b：', a == b)
print('a是否不等于b：', a != b)
print('a是否大于b：', a > b)
print('a是否小于b：', a < b)
print('a是否大于或等于b：', a >= b)
print('a是否小于等于b：', a <= b)
输出：
a是否等于b： False
a是否不等于b： True
a是否大于b： False
a是否小于b： True
a是否大于或等于b： False
a是否小于等于b： True
| 运算符 | 作用 | 使用 |
|---|---|---|
| and | 逻辑与，两个条件都为真，则返回 True | a > 1 and a < 3 |
| or | 逻辑或，只要有一个条件为真，就返回 True | a > 1 or a < 3 |
| not | 逻辑非，反转结果 | not( a > 1) |
a = 2
b = 3
print('两个条件都成立：', a > 1 and a > b)
print('只有一个成立：', a > 1 or a > b)
print('结果取反：', not( True ))
输出：
两个条件都成立： False
只有一个成立： True
结果取反： False
| 运算符 | 作用 | 使用 |
|---|---|---|
| is | 同一个对象，则返回 True | a is b |
| is not | 不是同一个对象，则返回 True | a is not b |
a = 2
b = 3
print('a和a是否是同一个对象：', a is a)
print('a和b是否是同一个对象：', a is b)
print('a和a是否不是同一个对象：', a is not a)
print('a和b是否不是同一个对象：', a is not b)
输出：
a和a是否是同一个对象： True
a和b是否是同一个对象： False
a和a是否不是同一个对象： False
a和b是否不是同一个对象： True
| 运算符 | 作用 | 使用 |
|---|---|---|
| in | 对象中存在指定内容，则返回 True | a in b |
| not in | 对象中不存在指定内容，则返回 False | a not in b |
成员运算符常用来判断对象中是否「包含」指定内容
a = 'a'
b = 'abc'
print('b中是否包含a：', a in b)
print('b中是否不包含a：', a not in b)
``
输出：
```powershell
b中是否包含a： True
b中是否不包含a： False
| 运算符 | 作用 | 使用 |
|---|---|---|
| & | 位与， | 如果两个位均为 1，则将每个位设为 1 |
| | | 位或， | 如果两位中的一位为 1，则将每个位设为 1 |
| ^ | 位异或， | 如果两个位中只有一位为 1，则将每个位设为 1 |
| ~ | 位求反， | 反转所有位 |
| << | 左移位 | 通过从右侧推入零来向左移动，推掉最左边的位 |
| >> | 又移位 | 通过从左侧推入最左边的位的副本向右移动，推掉最右边的位 |
| 运算符 | 作用 | 使用 |
|---|---|---|
| = | 赋值 | name = ‘张三’ |
赋值运算符常用于给变量「赋值」，可配合算术运算符「叠加」运算
a = 3
print('给a赋值3后，a的值：', a)
a += 3
print('a += 3 等价于 a = a+3，a的值：',a)
a *= 3
print('a *= 3 等价于 a = a*3，a的值：', a)
输出：
给a赋值3后，a的值： 3
a += 3 等价于 a = a+3，a的值： 6
a *= 3 等价于 a = a*3，a的值： 18
函数就是把具有「独立功能」的代码块封装成一个小模块,可以直接调用,从而提高代码的编写「效率」以及重用性
语法
def 函数名（ 参数1, 参数2, ……）:
代码块（函数调用时执行）
使用 def 关键字创建函数，根据「函数名」调用函数
注意：Python中的函数调用必须在函数定义之后
def fun():
print('函数内容')
fun() # 调用函数
输出：
函数内容
def fun1():
print('函数1被执行了')
def fun2():
print('函数2被执行了')
fun1()
输出：
函数1被执行了
函数可以接收参数，并在函数内使用，参数「数量不限」，多个参数之间使用「逗号」分隔
text1 = '参数1'
text2 = '参数2'
def fun(text1, text2):
print(text1)
print(text1)
fun(text1, text2)
输出：
参数1
参数1
list1 = [1, 2, 3]
def fun(list1):
print('列表类型的参数：', list1)
fun(list1)
输出：
列表类型的参数： [1, 2, 3]
Python中的变量遵守「就近原则」，比如函数里面和外面有两个名字相同的变量，函数就会使用「里面」的变量，而不是外面的变量。
# 函数外面的变量
money = 18
def function1():
# 函数里面的变量
money = 20
print(money)
function1()
开发时，如果搞混了这些「名字相同」的变量，可能会出现意料之外的情况。为了避免出现这类问题，函数采用了参数传递的方式。
给函数传两个参数，并在函数内调用
name = 'ZhangSan'
money = 18
def function1( name, money):
print('我的名字是', name, '我有', money, '块钱！')
function1( name, money)
输出：
我的名字是 ZhangSan 我有 18 块钱！
函数创建时，括号里的参数叫「形参」（形式参数），用来接收参数。
函数调用时，括号里的参数叫「实参」（实际参数），用来实际使用。
形参和实参的「名字」可以「不同」。
比如，我把参数名字随便改成其他的名字，仍然可以正常调用。当然，实际开发时，建议根据作用来命名参数。
name = 'ZhangSan'
money = 18
# 1、函数定义时，接收形参
def function1( a, b):
print('我的名字是', a, '我有', b, '块钱！')
# 2、函数调用时，传入实参
function1( name, money)
输出：
我的名字是 ZhangSan 我有 18 块钱！
函数调用时，参数的「数量」和「位置」必须和函数创建时一样。
name = 'ZhangSan'
money = 18
def function1( a, b):
print('第一个参数：', a)
print('第二个参数：', b)
function1( name, money)
输出：
第一个参数： ZhangSan
第二个参数： 18
如果参数的「数量不对」，会报错 TypeError。
如果参数的「位置不对」，会不符合预期。
name = 'ZhangSan'
money = 18
def function1( a, b):
print('我的名字是：', a, '我有', b, '快钱！')
function1( money, name)
输出：
我的名字是： 18 我有 ZhangSan 快钱！
缺省参数也叫「默认参数」，在函数定义时，给参数指定「默认值」。
拥有默认值的参数，在函数调用时可以「不传值」：
name = 'ZhangSan'
money = 18
# 1、参数设置默认值
def function1( a, b = 28):
print('我的名字是：', a, '我有', b, '块钱！')
# 2、传值
function1( name, money)
# 3、不传值
function1( name)
输出：
我的名字是： ZhangSan 我有 18 块钱！
我的名字是： ZhangSan 我有 28 块钱！
Python变量的类型中，整型、字符串、元组属于「不可变类型」，列表、字典等属于「可变类型」。
str1 = 'ZhangSan'
list1 = [1, 2, 3]
# 修改传入的参数
def function1( str, list):
str * 2
list.append(4)
function1( str1, list1)
print(str1)
print(list1)
输出：
ZhangSan
[1, 2, 3, 4]
函数调用时，可以按照「参数关键字」给参数「赋值」。使用这种方式，可以不受参数顺序的限制。
name = 'ZhangSan'
money = 18
def function1( a, b):
print('我的名字是', a, '我有', b, '块钱！')
# 关键字参数传参
function1( b=money, a=name)
输出：
我的名字是 ZhangSan 我有 18 块钱！
匿名函数不需要 def 来声明函数，而是用 lambda 表达式来创建函数。常用于处理简单的场景。
语法
函数名 = lambda [参数] : 代码块
lambda 表达式的格式是固定的，因此只能封装有限的代码进去。
实例：创建一个匿名函数，返回两个数相加之和。
function1 = lambda num1, num2: num1 + num2
result = function1(1, 2)
print(result)
输出：
3
关键字 return 可以让函数返回一个值，比如将函数的执行结果返回，或者返回一个自定义的值。
返回多个值需要用逗号间隔；如果不指定值，就返回None。
def function1(a, b):
return a + b
def function2(a, b):
return '自定义的值'
def function3(a, b):
return '第一个值', '第二个值'
def function4(a, b):
return
print(function1(1, 2))
print(function2(1, 2))
print(function3(1, 2))
print(function4(1, 2))
输出：
3
自定义的值
('第一个值', '第二个值')
None
return 还有退出函数的作用， return 后面的代码不会被执行；如果一个函数内有多个 return ，则只返回第一个 return 的返回值。
def function1(a, b):
return a + b
print('return后面的代码')
return '第二个返回值'
print(function1(1, 2))
输出：
3
函数可以「自己调用自己」，即递归调用
注意：「单程递归」将耗尽计算机的算力，慎用
i = 1
def fun(i):
print(i, '函数被调用了')
i += 1
fun(i) # 递归调用
fun(i)
输出：
996 函数被调用了
……
RecursionError: maximum recursion depth exceeded while calling a Python object
# 递归异常： 达到最大递归深度（一种保护机制，防止算力耗尽）
| 函数 | 描述 |
|---|---|
| max() | 返回序列中的最大值 |
| min() | 返回序列中的最小值 |
| abs() | 返回数字的绝对值 |
| round() | 四舍五入 |
max() 可以返回「最大值」。可接收多个参数，参数可以是「任意类型」。
「一个参数」时，参数必须是「可迭代对象」，会返回对象中最大的一个「元素」。
print(max('1234'))
print(max([1, 2, 3, 4]))
print(max((1, 2, 3, 4)))
# 字典返回最大的键，值不参与计算
print(max({1: 10, 2: 20}))
输出：
4
4
4
2
「多个参数」时，参数的类型必须「相同」，会返回最大的一个「参数」
print(max(10, 20, 30))
print(max([1, 2], [3, 4]))
print(max((1, 2), (3, 4)))
输出：
30
[3, 4]
(3, 4)
min() 可以返回「最小值」，用法跟 max() 一样。
abs() 可以返回数字的「绝对值」。对于小数，只保留小数点后一位。
print(abs(-10))
print(abs(-10.100000))
输出：
10
10.1
print(round(1.6))
print(round(1.5))
print(round(1.4))
输出：
2
2
1
字符串是不可变类型，所以函数都会返回一个「新值」，原来的字符串则不会被「改变」。
| 函数名 | 描述 | 使用详解 |
|---|---|---|
| capitalize() | 首字母大写 | 文章链接：capitalize() 函数使用详解 |
| center() | 字符串居中 | 文章链接： center() 函数使用详解 |
| count() | 统计字符出现次数 | 文章链接： count() 函数使用详解 |
| encode() | 字符串编码/解码 | 文章链接： encode() 函数使用详解 |
| endwith() | 是否以指定字符结尾 | 文章链接：endswith()函数使用详解 |
| startwith() | 是否以指定字符开头 | 点我直达：startwith() 函数使用详解 |
| fiind() | 查找字符串 | 文章链接：find() 函数使用详解 |
| isalnum() | 是否只包含字母或数字 | 文章链接：isalnum() 函数使用详解 |
| isalpha() | 是否只包含字母和中文 | 文章链接：isalpha() 函数使用详解 |
| isdigit() | 是否只包含数字 | 文章链接：isdigit() 函数使用详解 |
| islower() | 是否只包含小写字母 | 文章链接：islower() 函数使用详解 |
| isupper() | 是否只包含大写字母 | 点我直达：isupper() 函数使用详解 |
| join() | 拼接字符串 | 文章链接： join() 函数使用详解 |
| len() | 字符串长度 | 点我直达： len() 函数使用详解 |
| lower() | 转为小写 | 点我直达：lower() 函数使用详解 |
| upper() | 转为大写 | 点我直达：upper() 函数使用详解 |
| max() | 返回最大的字符 | 点我直达：max() 函数使用详解 |
| min() | 返回最小的字符 | 点我直达： min() 函数使用详解 |
| replace() | 替换字符串 | 文章链接：replace() 函数使用详解 |
| split() | 分割字符串 | 文章链接： split() 函数使用详解 |
| strip() | 去除首尾的空格 | 点我直达：strip() 函数使用详解 |
| swapcase() | 大小写反转 | 点我直达：swapcase() 函数使用详解 |
startwith() 可以检查字符串否以指定字符「开头」
语法
str.startwith( str, start, end)
参数
返回值
实例
str1 = 'hello world'
print('是否以h开头：', str1.startswith('h'))
print('是否以he开头：', str1.startswith('he'))
print('第[1~结尾]个字符中，是否以e开头：', str1.startswith('e', 1))
print('第[1~3]个字符中，是否以e开头：', str1.startswith('e', 1, 3))
输出：
是否以h开头： True
是否以he开头： True
第[1~结尾]个字符中，是否以e开头： True
第[1~3]个字符中，是否以e开头： True
isupper() 可以检查字符串的「字母」是否全部都是「大写」
语法
str.isupper()
返回值
实例
# 有区分大小写的字符，并全部大写
print('ABC'.isupper())
print('A 12 !@ 汉字'.isupper())
# 有区分大小写的字符，但不全是大写
print('aA'.isupper())
print('Aa 12 !@ 汉字'.isupper())
# 没有区分大小写的字符(数字、汉字、空格、特殊符号等)
print('123456 !@#$%^&* 汉字'.isupper())
输出：
True
True
False
False
False
len() 可以返回字符串的「长度」，如果是可迭代对象，就返回「元素个数」。
语法
len( element )
返回值
实例
# 汉字也算一个字符
print(len('abc'))
print(len('汉字'))
# 列表、元组等返回元素个数
print(len([1, 2, 3]))
print(len((1, 2, 3)))
# 字典返回键的个数
print(len({'key1': 1, 'key2': 2}))
输出：
3
2
3
3
2
lower() 可以将字符串中的字母转成「小写」，不区分大小写的字符不会改变。
语法
str.lower()
返回值
实例
print('ABC'.lower())
print('ABc'.lower())
print('123 !@# ABc'.lower())
输出：
abc
abc
123 !@# abc
upper() 可以将字符串中的字母转成「大写」，不区分大小写的字符不会改变。
语法
str.upper()
返回值
print('abc'.upper())
print('abC'.upper())
print('123 !@# ABc'.upper())
输出：
ABC
ABC
123 !@# ABC
max() 可以返回给定参数的「最大值」。参数的「类型」必须相同。
语法
max( iterables )
参数
返回值
实例
# 一个参数，返回最大的元素
print(max('abc'))
print(max([1, 2, 3]))
print(max((1, 2, 3)))
# 多个元素，返回最大的参数
print(max('123', '456'))
print(max([1, 2], [3, 4]))
print(max((1, 2), (3, 4)))
输出：
c
3
3
456
[3, 4]
(3, 4)
min() 可以返回给定参数的「最小值」。参数「类型」必须相同。
语法
min( iterables )
参数
返回值
实例
# 一个参数，返回最小的元素
print(min('abc'))
print(min([1, 2, 3]))
print(min((1, 2, 3)))
# 多个元素，返回最小的参数
print(min('123', '456'))
print(min([1, 2], [3, 4]))
print(min((1, 2), (3, 4)))
输出：
a
1
1
123
[1, 2]
(1, 2)
strip() 可以「删除」字符串「两边」的指定字符，常用来去除两边的「空格」。
语法
str.strip( str )
参数
返回值
实例
print(' hello world '.strip())
print('aahello worldaaa'.strip('a'))
输出：
hello world
hello world
swapcase() 可以「反转」字符串的「大小写」。不区分大小写的字符不会改变。
语法
str.swapcase()
返回值
实例
print('aaa'.swapcase())
print('AAA'.swapcase())
print('a 123 !@# '.swapcase())
输出：
AAA
aaa
A 123 !@#
| 函数 | 描述 | 使用详解 |
|---|---|---|
| append() | 末尾添加元素 | 文章链接：append()函数使用详解 |
| count() | 统计元素出现次数 | 文章链接： count() 函数使用详解 |
| extend() | 末尾添加序列 | 文章链接：extend()函数使用详解 |
| index() | 查找元素的索引 | 点击直达： index() 函数使用详解 |
| insert() | 指定位置插入元素 | 文章链接：insert() 函数使用详解 |
| pop() | 按照索引移除元素 | 文章链接： pop() 函数使用详解 |
| remove() | 按照内容移除元素 | 文章链接：remove() 函数使用详解 |
| sort() | 列表元素排序 | 文章链接： sort() 函数使用详解 |
| reverse() | 反转列表中元素的顺序 | 点我直达：reverse() 函数使用详解 |
| clear() | 清空列表 | 点我直达：clear() 函数使用详解 |
| copy() | 复制列表 | 点我直达：copy() 函数使用详解 |
| len() | 返回列表中元素的个数 | 点我直达：len() 函数使用详解 |
| max() | 返回列表中最大的元素 | 点我直达：max() 函数使用详解 |
| min() | 返回列表中最小的元素 | 点我直达：min() 函数使用详解 |
| list() | 将元组转换成列表 |
index() 可以返回「元素」第一次出现的「索引」位置。
语法
list.index( element, start, end)
参数
实例
list1 = ['a', 'b', 'c']
print(list1.index('b'))
输出：
1
reverse() 可以「反转」列表中的「元素」顺序。
语法
list.reverse()
返回值
实例
list1 = [1, 2, 3]
list1.reverse()
print(list1)
输出：
[3, 2, 1]
clear() 可以「清空」列表。清空后变成「空列表」，且内存地址不变，并不是删除列表。
语法
list.clear()
实例
list1 = [1, 2, 3]
print('清空前的内存地址：', id(list1))
list1.clear()
print('清空后变成空列表：', list1)
print('清空后的内存地址：', id(list1))
输出：
清空前的内存地址： 1709999787200
清空后变成空列表： []
清空后的内存地址： 1709999787200
copy() 可以「复制」列表，属于「浅拷贝」，元素引用的序列发生改变时，列表中的元素会同步改变。
语法
list.copy()
返回值
实例
list1 = [1, 2, 3]
list2 = [1, list1, 3]
print('复制前的内存地址：', id(list2))
new_list = list2.copy()
print('复制后的内存地址：', id(new_list))
print('复制后的列表：', new_list)
list1[1] = 'abc'
print('元素引用的列表改变时，列表的元素同步改变：', new_list)
输出：
复制前的内存地址： 2291942231232
复制后的内存地址： 2291942607424
复制后的列表： [1, [1, 2, 3], 3]
元素引用的列表改变时，列表的元素同步改变： [1, [1, 'abc', 3], 3]
len() 可以返回列表的「长度」。与元素类型无关，只计算「元素」的个数。
语法
list.len()
返回值
实例
list1 = [1, 2, 3]
list2 = [1, list1, 3]
print(len(list1))
print(len(list2))
输出：
3
3
max() 可以返回列表中「最大」的元素。列表中所有的元素，必须是「相同」的类型。
实例
list1 = [1, 2, 3]
print(max(list1))
输出：
3
min() 可以返回列表中「最小」的元素。列表中所有元素的「类型」，必须「相同」。
实例
list1 = [1, 2, 3]
print(min(list1))
输出：
1
list() 可以将「元组」或「字符串」转成列表。
语法
list list( iterable )
参数
返回值
实例
print(list('abc'))
print(list((1, 2, 3)))
输出：
['a', 'b', 'c']
[1, 2, 3]
| 函数 | 描述 | 使用详解 |
|---|---|---|
| add() | 添加元素 | 文章链接：add() 函数使用详解 |
| clear() | 清空集合 | 点我直达： clear() 函数使用详解 |
| copy() | 拷贝集合 | 点我直达：copy() 函数使用详解 |
| difference() | 返回多个集合的差集 | 点我直达：difference() 函数使用详解 |
| difference_update() | 删除多个集合的交集 | 点我直达：difference_update() 函数使用详解 |
| discard() | 删除元素 | 点我直达： discard() 函数使用详解 |
| intersection() | 返回多个集合的交集 | 点我直达： intersection() 函数使用详解 |
| intersection_update() | 删除多个集合的差集 | 点我直达： intersection_update() |
| isdisjoint() | 判断两个集合是否包含相同的元素 | 点我直达： isdisjoint() 函数使用详解 |
| issubset() | 判断集合是否是另一个集合的子集 | 点我直达： issubset() 函数使用详解 |
| issuperset() | 判断集合是否是另一个集合的父集 | 点我直达： issuperset() 函数使用详解 |
| pop() | 随机删除元素 | 文章链接：pop() 函数使用详解 |
| remove() | 删除指定元素 | 文章链接：remove() 函数使用详解 |
| symmetric_difference() | 返回两个集合中不同的元素 | 点我直达： symmetric_difference() 函数使用详解 |
| symmetric_difference_update() | 删除与另一个集合重复的元素 | 点我直达： symmetric_difference_update() 函数使用详解 |
| union() | 随机删除元素 | 文章链接：union() 函数使用详解 |
| update() | 修改集合 | 点我直达： update() 函数使用详解 |
set1 = {1, 2, 3}
set1.clear()
print(set1)
输出：
set()
语法
set.copy()
返回值
set1 = {1, 2, 3}
set2 = set1.copy()
print(set2)
输出：
{1, 2, 3}
这里的拷贝是浅拷贝，拷贝前后的两个集合内存地址不同，并且其中一个集合发生变化时，另一个集合不受影响。
set1 = {1, 2, 3}
set2 = set1.copy()
print('拷贝前的内存地址：', id(set1))
print('拷贝后的内存地址：', id(set2))
print('修改原列表前：', set2)
set1.add(4)
print('修改原列表后：', set2)
输出：
拷贝前的内存地址： 2150779800704
拷贝后的内存地址： 2150779798016
修改原列表前： {1, 2, 3}
修改原列表后： {1, 2, 3}
语法
set.difference( set )
参数
返回值
差集指的是：第一个集合里有，但第二个集合里没有的元素。
set1 = {1, 2, 3}
set2 = {1, 4, 5}
print(set1.difference(set2))
print(set2.difference(set1))
输出：
{2, 3}
{4, 5}
语法
set.difference_update( set )
参数
set1 = {1, 2, 3}
set2 = {1, 4, 5}
set1.difference_update(set2)
print(set1)
输出：
{2, 3}
{1, 4, 5}
语法
set.discard( value)
参数
set1 = {1, 2, 3}
set1.discard(2)
set1.discard(10)
print(set1)
输出：
{1, 3}
语法
set.intersection( set )
参数
返回值
set1 = {1, 2, 3}
set2 = {1, 3, 5}
print(set1.intersection(set2))
print(set2.intersection(set1))
输出：
{1, 3}
{1, 3}
语法
set.intersection_update( set )
参数
删除第一个集合里有，但第二个集合里没有的元素
set1 = {1, 2, 3}
set2 = {1, 3, 5}
set1.intersection_update(set2)
print(set1)
print(set2)
输出：
{1, 3}
{1, 3, 5}
语法
set.isdisjoint( set )
参数
返回值
注意判断逻辑，不要搞混了。
set1 = {1, 2, 3}
set2 = {1, 3, 5}
set3 = [10, 20, 30]
print(set1.isdisjoint(set2))
print(set1.isdisjoint(set3))
输出：
False
True
语法
set.issubset( set )
参数
返回值
set1 = {1, 2, 3, 4}
set2 = {1, 2, 3}
print(set2.issubset(set1))
输出：
True
语法
set.issuperset( set )
参数
返回值
set1 = {1, 2, 3, 4}
set2 = {1, 2, 3}
print(set1.issuperset(set2))
语法
set.symmetric_difference( set )
参数
返回值
set1 = {1, 2, 3, 4, 5, 6}
set2 = {1, 2, 3}
new_set = set1.symmetric_difference(set2)
print(new_set)
输出：
{4, 5, 6}
语法
set.symmetric_difference_update( set )
参数
返回值
set1 = {1, 2, 3, 4, 5, 6}
set2 = {1, 2, 3}
set1.symmetric_difference_update(set2)
print(set1)
print(set2)
输出：
{4, 5, 6}
{1, 2, 3}
语法
set.update( iterable )
参数
返回值
往集合中添加另一个集合的元素
set1 = {1, 2, 3}
set2 = {4, 5, 6}
set1.update(set2)
print(set1)
输出：
{1, 2, 3, 4, 5, 6}
| 函数 | 描述 |
|---|---|
| len() | 返回元组长度 |
| max() | 返回最大的元素 |
| min() | 返回最小的元素 |
| tuple() | 将可迭代序列转成元组 |
len() 可以返回元组的「长度」，实际上是返回元组中元素的个数
tuple1 = (1, 2, 3)
print(len(tuple1))
输出：
3
max() 可以返回元组中「最大」的一个元素，可以同时传入多个参数，但参数的元素的类型必须全部相同。
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
# 一个参数返回最大的元素
print(max(tuple1))
# 多个参数返回最大的参数
print(max(tuple1, tuple2))
输出：
3
(4, 5, 6)
min() 可以返回元组中「最小」的元素，用法和 max() 一样。
tuple() 可以将可迭代序列「转成」元组类型
print(tuple('abc'))
print(tuple([1, 2, 3]))
print(tuple({'key1': 1, 'key2': 2}))
输出：
('a', 'b', 'c')
(1, 2, 3)
('key1', 'key2')
Python中提供了一些函数以方便我们「操作文件」
open() 函数用来打开文件
语法
open( name, mode )
参数
在 E 盘创建文件 a.txt ，使用 open() 函数打开该文件
file = open('E://a.txt')
print(file)
输出：
<_io.TextIOWrapper name='E://a.txt' mode='r' encoding='cp936'>
文件路径分为两种：
相对路径是指「相对于当前文件」的路径
打开当前目录下的 a.txt 文件
file = open('a.txt')
print(file)
输出：
<_io.TextIOWrapper name='a.txt' mode='r' encoding='cp936'>
绝对路径是指文章在「电脑」中的位置
打开 E 盘 Python 目录下的 a.txt 文件
file = open('E://python/a.txt')
print(file)
输出：
<_io.TextIOWrapper name='E://python/a.txt' mode='r' encoding='cp936'>
修改参数 mode 的值，可以指定文件的「打开方式」
「打开模式」
file = open('a.txt', 'rt')
print(file)
输出：
<_io.TextIOWrapper name='a.txt' mode='rt' encoding='cp936'>
在当前目录创建文件 b.txt
open('b.txt', 'x')
检查左侧目录，会多出一个文件 b.txt
read() 函数用来读取文件内容
语法
read( n )
参数
读取文件 a.txt 的全部内容
file = open('a.txt', encoding='utf-8')
text = file.read()
print(text)
输出：
第一行
第二行
第三行
第四行
……
读取文件 a.txt 的前 6个字符
file = open('a.txt', encoding='utf-8')
text = file.read(6)
print(text)
输出：
第一行
第二
readline() 函数可以读取一行内容
读取文件 a.txt 第一行内容
file = open('a.txt', encoding='utf-8')
text = file.readline()
print(text)
输出：
第一行
file = open('a.txt', encoding='utf-8')
i = 0
while i < 3:
text = file.readline()
print(text)
i += 1
输出：
第一行
第二行
第三行
使用 for 循环遍历文件，「逐行读取」文件内容
file = open('a.txt', encoding='utf-8')
for text in file:
print(text)
输出：
第一行
第二行
第三行
第四行
……
close() 函数可以关闭文件，如果文件未关闭，对文件的「修改」可能会「不生效」
file = open('a.txt', encoding='utf-8')
print(file.read(3))
file.close()
输出：
第一行
write() 函数可以向文件中写入内容
修改文件内容时，需要指定 open() 函数的参数
向文件 a.txt 中追加内容
file = open('a.txt', 'a', encoding='utf-8')
file.write('新添加的内容')
file.close()
# 修改模式的文件不可读，需重新打开文件
file = open('a.txt', 'r', encoding='utf-8')
print(file.read())
输出：
第一行新添加的内容
file = open('a.txt', 'w', encoding='utf-8')
file.write('新添加的内容')
file.close()
# 修改模式的文件不可读，需重新打开文件
file = open('a.txt', 'r', encoding='utf-8')
print(file.read())
输出：
新添加的内容
exists() 函数可以判断「文件是否存在」
remove() 函数可以根据文件名「删除文件」
import os
if os.path.exists('a.txt'):
print('文件存在，删除文件')
os.remove('a.txt')
else:
print('文件不存在，无法删除')
输出：
文件存在，删除文件
rmdir() 函数可以删除目录（文件夹）
import os
os.rmdir('mulu')
观察左侧目录，文件夹 mulu 已被删除
一个程序往往包含多条代码，流程控制就是控制这些代码的「执行顺序」和「是否能够执行」的规则
在程序开发中,一共有三种「执行流程」
if 是分支执行的一种语句，「满足条件」时才会执行代码，「不满足条件」则不执行
语法
if 条件:
代码块(条件成立时执行)
a = 2
b = 1
if a > b:
print('条件成立：a>b')
if a < b:
print('条件不成立，不会执行')
输出：
条件成立：a>b
a = 1
b = 2
c = 3
if a<b and b<c:
print('条件成立，a<b<c')
输出：
条件成立，a<b<c
if 语句的代码块中可以「嵌套」 if 语句，无限套娃
a = 1
b = 2
if a<b:
print('第一层if的条件成立了，进入下一层if')
if b>a:
print('第二层if的条件成立了')
输出：
第一层if的条件成立了，进入下一层if
第二层if的条件成立了
if else
语法
if 条件：
代码块（条件成立时执行）
else:
代码块（条件不成立时执行）
a = 2
b = 1
if a < b:
print('条件成立：a>b')
else:
print('条件不成立：a<b')
输出：
条件不成立：a<b
a = 2
b = 1
print('条件成立：a>b') if a<b else print('条件不成立：a<b')
输出：
条件不成立：a<b
el if
elif 关键字可以进行「多次条件判断」
a = 1
b = 2
if a>b:
print('第一个条件成立：a>b')
elif a==b:
print('第二个条件成立：a=b')
elif a<b:
print('第三个条件成立：b<a')
else:
print('以上条件都不成立')
print('以上条件都不成立')
输出：
第三个条件成立：b<a
while 是循环执行的一种语句，条件成立时「多次执行」代码，不成立则不执行，常用来「重复」处理相同的任务。
语法
while 条件：
代码块（条件成立时执行）
执行 3 次打印☆的操作
注意：用于判断的条件最好有一个「不满足」的可能性，否则循环会一直进行
i = 1
while i <7:
print('☆')
i += 1
输出：
☆
☆
☆
for 是循环执行的一种语句，常用于「迭代序列」，类似其他语言中的迭代器
for 循环可以遍历字符串、列表、元祖、集合、字典等序列
list1 = [1, 2, 3]
for l in list1:
print(l)
输出：
1
2
3
break 关键字可以结束整个循环，不执行剩余代码块
循环执行 i+1 的操作，当 i>3 时，结束循环
i = 1
while True:
print('i的值是：', i)
i += 1
if i >3:
print('结束整个循环')
break
输出：
i的值是： 1
i的值是： 2
i的值是： 3
结束整个循环
continue 关键字可以结束本次循环，不执行剩余代码块
循环执行 i+1 的操作，打印 1~4，但不打印 3
i = 0
while i < 4:
i += 1
if i == 3:
print('i的值为3，跳过本次循环')
continue
print(i)
输出：
1
2
i的值为3，跳过本次循环
4