1、注释用法

注释就是打草稿，写的东西并不会真正出现在结果里。在Python语言中，注释是使用井号键 # 或三引号 “”" 来分别进行单行注释和多行注释。其中多行注释是以三引号开头，以三引号结尾。

例如，下列python代码，第一行用#注释了所以没有运行，第 2-3 行用三个引号进行注释了，是多行注释，所以也没有运行：

# print("HELLO World!")
"""print("Hello PYTHON!")
print("hELLO PYTHON!")"""
print("HELLO PYTHON!")

运行结果如下，注释内的内容被注释掉了所以没有显示：

2、python 中的命名规则

命名规则在考试中常考到，这里要注意，不仅是变量名、画笔名和函数名，或者列表名、元组名、字典名等等，都遵循下面这个规则！！！

（1）由字母、数字、下划线组成
（2）不能以数字开头
（3）区分大小写
（4）不能使用关键字

需注意要避免使用Python关键字（if、int、str、else、True、Flase、while、for、break、continue 等等）作为画笔名、变量名或函数名，以免产生冲突，代码出错。在图片中，第二条讲到的下划线要注意，负号（减号）是“-”，下划线是“_”，一个高一个矮，我们要看清楚。

3、数值运算操作符

四则运算中，要注意加减乘除，只有乘除的符号和数学中不一样，乘号是一个星号，除号是一个左斜杠（之前有同学写成右斜杠了，要注意），如下：

数字的四则运算，+ - × ÷，只有乘除不一样，是* /

以下是考试常考的数值运算操作符，要注意：
● x/y 除，即x与y的商，比如10/3的结果为3.3333……，省略号这里是代表除不断。
● x//y 整数除，即x与y的整数商，比如10//3的结果为3，它不会管余数，不会管是否除得断。
● x%y 取余数，即模运算，比如10%3的结果为1（商是 3，余数是 1）， 3%6=3（商是 0，余数是 3）。
● x ** y 幂运算，即x的y次幂（方），比如 2 ** 3 代表 2 的三次方，即 2×2×2=8。当y为小数时，表示开方运算，比如 4** 0.5的结果为 4 的二分之一次方，结果为 2，因为 2 的 2 次方为 4。

例如，下列python代码：

print(7/3)
print(7//3)
print(7%3)
print(7*3)
print(7**3)    #7的3次方
print(4**0.5)  #10的二分之一次方，也就是开平方

运行结果如下：

另外，赋值运算符是可以简写的，加减乘除都可以进行简写。

i=i+1    //i+=1

4、逻辑运算符与比较运算符

（1）逻辑运算符
逻辑运算符就两个，即and和or，如下：
● and
● 意思是“和”，只有满足所有条件，才能成立。

例如，代码如下，例子：天气晴朗且作业写完，就出去玩，需要满足两个条件：

# 例子：天气晴朗且作业写完，就出去玩。
a = input('输入今天天气：')
b = input('输入作业是否写完：')

if a == '晴朗' and b == '是':
    print('可以愉快出去玩了！')
else:
    print('不能出去！')

运行结果如下：

● or
● 意思是“或（或者）”，只要满足一个条件，就能成立。

例如，代码如下，例子：天气晴朗或者作业写完，只要满足一项，你就可以出去玩：

# 例子：天气晴朗或者作业写完，只要满足一项，你就可以出去玩。
a = input('输入今天天气：')
b = input('输入作业是否写完：')

if a == '晴朗' or b == '是':
    print('可以愉快出去玩了！')
else:
    print('不能出去！')

运行结果如下，只要满足一项就可以了，但是两项都满足，那更加没问题了：

（2）比较运算符
要注意用在判断比较时，等于号是两个等于号（==）进行判断，这里非常容易出错！！！要注意不是一个（赋值是一个等号，判断是两个等号）。另外，不等于号是一个感叹号和一个等于号组成（!=），不是这个 ≠ 符号。

比较运算符将左边和右边的内容进行比较，例如，下面代码进行判断：

print(3 == 3.0)
print(5 < -2)
print("abc" == "abc")
print([1, 2] == [1, 2])

运行结果如下，True 是真，Flase 是假，其实也就是代码正不正确：

5、几种基本类型

在Python中，整数类型（int）、字符串类型（str）、浮点数类型（float）和布尔类型（bool）是 Python 中几个基本数据类型，用于表示不同形式的数据。

（1）整数类型（int）
● 描述：用于表示整数值（正数、负数或零），不包含小数部分。
● 示例：
a = 25 # 正整数
b = -10 # 负整数
c = 0 # 零

通过 int() 可将一个字符串或数字转换为整型，例如：

a = 0.2
b = 1.6666666
c = -2.5
print(int(a))
print(int(b))
print(int(c))

运行结果如下：

（2）字符串类型（str）
● 描述：用于表示文本数据（中文、英文、特殊符号等），可以由单引号（‘’）、双引号（“”）或三引号（‘’'或"“”）包起来，要注意这些引号都是成双成对出现的。

● 示例：

a = "iKun"                # 双引号字符串
b = 'Hello, 酷狗!'        # 单引号字符串
c = '''This is a
multi-line string.'''      # 多行字符串

通过 str() 可将一个其他类型转换为字符串类型，这里举例用了一个知识点 type() 查看类型，例如：

num1 = 42
num2 = 0.5
num3 = -3.1415

str_num1 = str(num1)
str_num2 = str(num2)
str_num3 = str(num3)

# 方式1：用 type() 查看类型
print(str_num1, type(str_num1))  # 输出: 42 <class 'str'>
print(str_num2, type(str_num2))  # 输出: 0.5 <class 'str'>
print(str_num3, type(str_num3))  # 输出: -3.1415 <class 'str'>

运行结果如下，这些数字不是整数类型，而是字符串类型：

（3）浮点数类型（float）
● 描述：用于表示带有小数部分的数值。

● 示例：

a = -3.14159      
b = 9.0     

通过 float() 可将一个其他类型转换为浮点数类型，例如：

x = "3.14"
y = "5"
z = "-2.7"

print(float(x))  # 输出: 3.14
print(float(y))  # 输出: 5.0
print(float(z))  # 输出: -2.7

运行结果如下：

（4）布尔类型（bool）
● 描述：Python中布尔类型只有两个，即True和False，可以说布尔类型是一种特殊的整型，即True和False对应整数类型型中的1和0，且所有的对象都可以转换为布尔类型。

例如，下面代码，进行判断括号里内容是否成立：

print(10 > 5)
print(3 == 4)
print(6.3 != 6.33333)
print('苹果'=='apple')

运行结果如下：

6、输入与输出

（1）input() 输入
input()用于 从键盘输入内容到控制台上，返回一个字符串类型数据，要注意通过 input() 返回的数据是字符串类型。一般将输入内容赋值给变量进行后续使用，例如 a=input()，把输入的内容给变量 a。此时就会在控制台显示：

另外，输入方法也常与整数类型 int ()结合使用，这样输入的内容就是数字，括号里面可以写文字，但是要用引号，例如a = int(input(‘请输入一个数字:’))：

（2）print() 输出
print()用于向控制台中输出内容，可以直接输出任何类型的数据。print()里面可以通过英文逗号隔开，输出变量或其他内容的值。例如 ，以下是一个账号密码的 Python 程序：

print()是默认换行的，若不需要换行输出，即在后面加上end=““就可以了（输出如果不需要换行加 end=””）。另外，括号里面也可以填其他东西来代替换行，例如下列Python代码：

a = input("输入：")
b = input("输入：")
print(a,end="")    # 打印a的内容，end=""表示末尾不加换行
print(a,b)         # 打印a和b，默认用空格隔开 
print(a,end="/")   # 打印a，末尾加/代替换行

运行结果如下：

7、if 条件语句

通过if语句，产生分支，根据条件结果执行不同的操作（True 成立或 False 不成立）。if语句中常用的大于小于或者小于或等于和上面讲到的是一样，这里要注意的等于表示为”==“，不等于表示为”!=“，符号的左右跟要比较的对象。另外，if 条件语句是可以嵌套的，通过缩进（4 个空格或 Tab 键）来进行嵌套。

（1）单分支
if语句的单分支，指只有if关键字的条件语句，可以理解为如果条件成立，则执行代码，而如果条件不成立，程序会跳过if语句，执行之后的语句。
例如下列Python代码：

x = int(input("请输入一个整数："))
if x < 0:
    print("输入的数字小于0！")

运行结果如下，当我们输入数字小于0时，满足if条件语句，输出提示：

（2）双分支
通过if……else语句可以产生双分支if语句，如下，当条件 1 成立时，执行代码块1，而当条件 1 不成立时，执行代码块2。

if 条件1:
    代码块1             # 条件1为True时执行的代码
else:
    代码块2             # 条件1为False时执行的代码

特点：
● 只有两个分支：条件为真或假
● else 是一个兜底选项，不包含任何条件判断（else 后面不用写任何东西，这里很容易出错！！！）

例如，下面代码是一个双分支语句：

x = int(input("请输入一个整数："))
if x <= 0:
    print("输入的数字小于等于0！")
else:
    print('输入的数字不小于0！')

运行结果如下：

另外，双分支也可以这样写，用 if 和 elif 这两个单词：

if 条件1:
    代码块1     # 条件1为True时执行的代码
elif 条件2:
    代码块2     # 条件1为False且条件2为True时执行的代码

特点：
● 用于检查两个条件，按顺序检查条件，只执行第一个满足条件的代码块（哪个成立执行哪个）。
● 从上到下依次检查条件，一旦某个条件为True，执行对应的代码块并跳过其余条件检查。

例如，下面代码是一个双分支语句：

x = int(input("请输入一个整数："))
if x < 0:
    print("输入的数字小于0！")
elif x > 0:
    print('输入的数字大于0！')

运行结果如下，我们输入了一个数字 0，因为只有两个条件判断（大于或者小于），没有等于，所以会跳过：

（3）多分支
多分支可以由两种格式来写，一种是 if-elif-elif-…-else 或 if-elif-elif-…，其中省略号代表可以有多个。

if 条件1:
    代码块1   # 条件1为True时执行的代码
elif 条件2:
    代码块2   # 条件1为False且条件2为True时执行的代码
elif 条件3:
    代码块3   # 条件1和2为False且条件3为True时执行的代码
……
else:
    代码块4   # 所有条件都为False时执行的代码

例如，下列Python代码，当输入小于0、大于0或不是大于小于 0 时，会有不同的输出结果：

x = int(input("请输入数字："))
if x < 0:
    print("该数字小于0")
elif x > 0:
    print("该数字大于0")
else:
    print("该数字等于0")

运行结果如下：

if 条件1:
    代码块1   # 条件1为True时执行的代码
elif 条件2:
    代码块2   # 条件1为False且条件2为True时执行的代码
elif 条件3:
    代码块3   # 条件1和2为False且条件3为True时执行的代码
elif 条件4:
    代码块4   # 条件1、2和3为False且条件4为True时执行的代码
……

下面是一个 if-elif-elif 的例子，里面有多个 elif，这里是两个：

x = int(input("请输入数字："))
if x < 0:
    print("该数字小于0")
elif x > 0:
    print("该数字大于0")
elif x == 0:
    print("该数字等于0")

运行结果如下：

8、循环语句

（1）for 循环
for循环有两种方法，第一种是可以通过range()函数来控制for循环中的循环次数，要注意是从 0 开始的。同时， for 循环也是可以嵌套的，通过缩进（4 个空格或 Tab 键）来进行嵌套。

for i in range(数字):    #括号里面是循环次数，循环体内容要缩进

第二种是，列表也可以对可迭代对象进行遍历，比如列表、字符串、元组、字典等这些就是可迭代对象，下面举例的是对列表进行循环。

for i in 列表名:     #i表示列表中的元素，依次从列表中取值

下列Python代码，通过for语句遍历输出该字符串每个字符以及遍历输出列表name的值，可迭代对象为number字符串以及列表name，然后遍历输出临时变量的值：

number = "first"
name = ["ab", "ad", "ac"]
for x in number:
    print(x)
for i in name:
    print(i)

运行结果如下：

另外，通过range()函数，因为它默认是每次循环序列加1，所以可通过添加一个参数来指定增量值，比如这里range(3, 20, 2)表示3到19每次循环增加2，这里为什么是 3-19，是因为从 0 开始的，例如 for i in range(5)，其中 i 就是从 0-4，一共循环五次：

for i in range(3, 20, 2):
    print(i)

运行结果如下：

（2）while() 循环
while 循环有两种，分别是有限循环和无限循环（while True一直执行下去，不停止）。要注意 while 循环的有限循环什么时候退出循环，即条件不成立时退出（while 的有限循环是条件不成立时退出），如下：

n=0
while n<5:    #直到n不小于5时，循环结束
	print(n)
	n+=1

下列Python 代码，通过while循环计算1+2+…+100的值（从 1 开始加，一直加到 100 等于多少），这里的 while 有限循环是当 i 大于 100 时候结束循环，因为当条件 i ＜=100 不满足时结束，所以就是当 i ＞ 100 时结束：

i = 1
sum = 0
while i <= 100:
    sum = i + sum
    i = i + 1
print("1+2+...+100的值为：", sum)

运行结果如下：

另外，while循环也是可以嵌套的，也是通过缩进（4 个空格或 Tab 键）来进行嵌套。

（3）跳出循环的两种方法
Python中有两个跳转语句，它们只能在循环中使用，不能单独使用（ for 循环或 while 循环，不能在 if 条件语句中适用），break语句表示跳出整个（所有）循环，continue语句表示跳出本次（一次）循环。

continue       #跳出本次循环
break          #跳出整个循环

例如，我们写一个判断成绩的程序，当输入的 a 等于 0 时候，退出整个无限循环结束，而当输入的 a 小于 0 或者大于 100 时，则跳出本次循环，继续下一次循环：

while True:  
    a = int(input('输入考试成绩：'))  
    if a == 0:  
        print('未参加考试，循环结束！')  
        break  
    elif a > 100 or a < 0:  # 添加分数范围检查  
        print('输入有误（0-100之间），请重新输入！')  
        continue  
    elif a >= 90:  # 先检查高分情况  
        print('优秀')  
    elif a >= 60:  
        print('及格')   
    else:  
        print('不及格')  # 更明确的反馈  

9、字符串

创建一个空字符串，就是引号里面什么都不加，例如：

a = ''     # 空字符串

（1）格式化输出
在Python中，可以通过占位符、format()格式化函数和f-strings方式三种来对字符串格式化输出。这里只需要掌握前两种就可以了。
第一种，是通过使用占位符%来为实际值预留位置，且可以说明该格式，下面是常用的占位符：

例如，下列Python代码，通过占位符占位输出字符串类型%s和十进制整数类型%d：

name = "A001"
num = 123456
print("请确认您的账号id和登陆密码！")
print("您的账号为：%s，登陆密码为：%d。" % (name, num))

运行结果：

第二种，也可以使用format()格式化函数来进行一些数字运算的格式化，比如：

name = "A001"
num = 123456
print("请确认您的账号id和登陆密码！")
print("hello! {}".format(name))
print("password is {}".format(num))

运行结果：

（2）字符串拼接和重复输出
通过运算符可以对字符串进行一系列的操作，比如要想将两个字符串拼接起来，可以使用加号 + 来实现字符串拼接。
● 数字 + 数字 是加法运算，字符串 + 字符串 是拼接，但是数字 + 字符串会报错！

我们可以通过使用星号 * ，来重复输出字符串（星号重复输出字符串），例如，下列Python代码：

a = "A001"
b = "三环路"
print(a+b)
print(a*3)

结果如下：

（3）split() 字符串分割
通过使用split()对字符串进行分割，并通过一个列表输出得到的结果（分割的结果是一个列表），括号里面填的是用什么来进行间隔分割。split()中的参数可以依次为分隔符（默认为空字符，也可以为空格、\n、\t等等）和分割数，例如下列Python代码：

a = "A B C D E F"
print(a.split())

运行结果如下：

（4）count() 搜索字符串出现次数
通过使用count()方法返回字符或字符串出现的次数，可以只带搜索的字符或字符串，也可以加上两个参数表示开始搜索和结束搜索的位置，它们默认为第一个字符和最后一个字符，若没有搜索到则为0。例如下列python代码：

x = "apple"
y = "longtolonglongto"
a = x.count('p')
b = y.count('o')
c = y.count('long',0,10)       # 搜索范围从0至10，但不包括10
print("字符p的出现次数为:",a)
print("字符p的出现次数为:",b)
print("字符p的出现次数为:",c)

运行结果如下：

（5）find() 搜索字符串下标
通过使用find()方法返回字符或字符串第一次出现时的下标（序号，从 0 开始），它也有可选参数，即在搜索的开始与结束位置。例如下列python代码：

x = "apple is too tasty!"
print(x.find("s"))
print(x.find("a", 11))  # 搜索范围为11到结尾

运行结果如下：

（6）join() 连接字符串
join ()用于连接字符串，既然是连接，是需要规定用什么进行连接，也就是“连接符”，用于连接序列中各个元素的字符串。另外，括号里面装的是要连接的元素的序列（如列表、元组等），这些元素必须是字符串类型。例如，下面代码，我们用*进行连接，将列表里面的字符串进行连接：

words = ['Hello', 'world', 'Python','!']
a = '*'.join(words)     # 用*进行连接
print(a)                # 输出: Hello*world*Python*!

运行结果如下：

（7）字符串的索引
当需要提取字符串中的特定字符或子字符串时，就可以通过索引和切片来实现。

通过索引，可以返回字符串中单个字符，索引分为正向索引和反向索引，正向即从0开始，从左至右依次递增；反向索引是从-1开始，但从右至左，依次递减（正是 0，从左到右，负是-1，从右到左）。例如下列Python代码：

a = "apple"
print("正向索引：")
print(a[2])
print("反向索引：")
print(a[-2])

运行结果如下：

字符串切片是从字符串中切取字符，并不会切去原字符串的部分，只是复制切取的部分得到一个新字符串。格式为：字符串名 [ 开始 : 结束 ]，索引可为空值，默认为首位或末位字符。（一句话概括：取头不取尾，尾数要加一）

a = "〇一二三四五"
print(a[0:3:1])
print(a[0:3:2])
print(a[0:-2:3])
print(a[:3])
print(a[3:])
print(a[2:3])

运行结果如下：

可以这样来理解，比如print(str_number[0:3:2])，起始位为0，结束位为3，步长为2，每2个取顺序的第二个，即第一个为”〇“，第二个为“二”：

10、列表

由于列表和元组比较相似，所以放在一起总结，它们的区别在于元组的内容是不可修改的，而列表能够被修改，即增删改查，增加删除修改查询（列表和元组都是从 0 开始，但是元组不能改）。

（1）列表的基础知识
● 列表（变量是盒子，而列表是带隔间的盒子，它们都可以装中文英文数字等）
● 使用中括号 [ ]表示，可以存储多个数据；也可以通过 list() 来创建列表。列表的元素使用英文逗号分隔开，其中字符串类型可以用单引号或双引号都可以表示。如下python代码，列表a中元素的类型为字符串，列表c是一个空列表：

a = ["A", "B", "C"]
b = [1, 2, 3.5, 6.66]
c = []
print(a)
print(b)
print(c)

运行结果如下：

如下python代码，也可以用 list()来创建含多个元素的列表：

a = list("abcd")
b = list("123456")
c = list([1, 2, "python", "java"])
d = list()
print(a)
print(b)
print(c)
print(d)

运行结果如下：

另外，也可以通过range()函数生成一个数字范围的对象，比如range(0,5)表示从0开始一直到4（不包括5），而range(0,5,2)添加了一个参数，叫 步长（间隔）变成2，该函数可与列表一起使用从而生成数字序列：

print(list(range(5)))
print(list(range(0,5)))
print(list(range(0,5,2)))#以列表形式输出数字0至5但不包括5，步长为2
print(list(range(5,0,-1)))#以列表形式输出数字5至0但不包括0，步长为1
print(list(range(5,0,-2)))#以列表形式输出数字5至0但不包括0，步长为2

运行结果如下：

（2）列表的索引和切片
可以通过索引和切片的方式访问列表元素的值，这里的两种方式与之前的字符串的索引和切片一样，索引也是从0开始，都是可以获取指定元素或部分元素。列表和字符串一样，它们都是可迭代对象（后面讲的元组、字典也是一样）。

例如，列表a = [＂Python＂，＂Java＂，＂c＂，＂c#＂]，其正向索引和反向索引:
正向索引：Python对应0，Java对应1，c对应2，c#对应3
反向索引：c#对应-1，c对应-2，Java对应-3，Python对应-4。

（3）index() 查找索引
另外，我们可以通过列表的 index() 方法来查找某个元素在列表中第一次出现的索引（位置），要注意索引是从 0 开始的，第一个应该是 0，然后第二个是 1……

fruits = ["apple", "banana", "cherry", "banana"]
print(fruits.index("banana"))      # 输出 1（第一个 "banana" 的索引）
print(fruits.index("banana", 2))   # 输出 3（从索引 2 开始找）

运行结果如下：

index()这个方法也可以用在字符串中，例如：

a = ["a", "b", "c"]
b = "abc"
print(a.index("a"))
print(b.index("c"))

运行结果如下：

（4）len() 取长度
len()取长度这个方法也是可以用在列表和字符串中，会返回一个数字代表长度，例如：

a = [1, 2, 3, 4]
b ='abc'
print(len(a))
print(len(b))

运行结果如下：

（5）in 检查是否包含
in 这个单词是一个关键字，也是可以用在列表和字符串中，可以检查一个东西是否包含在另外一个里面，如果在就输出 True，不在就输出 False，如下：

print("a" in ["a", "b"])    # 列表
print( 1 in ('1','2'))      # 元组
print("d" in "abc")         # 字符串

运行结果如下：

（6）列表的增删改查
添加列表元素
可以通过函数append()、extend()、insert()三个函数来添加新的列表元素。
（1）insert()函数用于将元素插入到列表的指定位置（指定位置数字插入）；
（2）append()函数用于在列表末尾添加新的元素（插到末尾）；
（3）extend()函数用于在列表末尾添加另一个列表（末尾加列表）。
示例如下python代码：

a = ["python", "java"]
a.insert(0, "c++")     # 在位置0，插入一个元素“c++”
a.insert(-1, "c")      # 在位置-1，插入一个元素“c”
print(a)
b = ["1班", "2班"]
b.append("3班")
print(b)
c1 = ["1班", "2班"]
c2 = ["3班", "4班", "5班"]
c1.extend(c2)
print(c1)

运行结果如下：

删除列表元素
可以通过del、remove()、pop()三种方法来删除列表中的元素。
（1）del 语句用于删除列表中指定元素，可以使用索引或切片来指定要删除的元素（指定列表索引进行删除）。
（2）remove()函数用于删除列表中指定元素，若有多个指定元素，则只删除第一个相同的指定元素（指定元素名字进行删除）；
（3）pop()函数用于删除列表中指定元素，可以通过索引来指定要删除元素，若不指定，则只删除该列表的末尾元素（指定位置数字进行删除）。
示例如下python代码：

a = ["python", "java", "c", "c++"]
del a[0]
print(a)
a.remove("java")
print(a)
a.pop(0)
print(a)

运行效果如下：

修改列表元素
可以通过索引访问元素并对该元素进行修改，即重新赋值该元素。其示例如下python代码：

a = ["python", "java", "c", "c++"]
a[3] = "c#"
print(a)

运行结果如下：

列表的遍历
由于列表是个可迭代对象，可以通过for循环来遍历列表中的元素。例如，下列Python代码，通过for循环遍历列表并依次输出临时变量：

a = ["Python", "CSS", "Java", "C++"]
for i in a:
    print(i)
b = [100, 200, 300]
for j in b:
    print(j)

运行结果如下：

11、元组

元组的创建方式也有两种，它的创建与列表差不多，但是相比列表，元组内的元素是不允许修改的，但是列表可以修改。
（1）第一种方式使用的是圆括号，即()来创建列表，元组内的元素也是使用英文逗号分隔开，字符串类型用单引号或双引号都可以表示。
不过也可以不需要圆括号来创建元组，但是一般最好加上（了解一下就行）。
例如，下列Python代码：

a = ()
b = ("b", "l", "u", "e")
c = (1, 2, 3, 4, 5, 6)
d = "第一", "第二", "第三", "第四"
print(a, b, c, d)

运行结果如下：

注：当元组只包含一个元素时，也要在元素后面加上逗号，表示这是个元组。

（2）第二种方式是通过tuple()函数来创建元组，该函数接收的元素是可迭代的，若函数内没有值，则创建一个空元组。例如，下列Python代码，其中元组d中元组的元素为一个列表，包含两个字符串：

a = tuple()
print(a)
b = tuple("tooth")
print(b)
c = tuple("123456")
print(c)
d = tuple(["对", "错"])
print(d)

运行结果如下：

可以使用 list() 和 tuple() 轻松实现 列表（list）和元组（tuple）之间的互相转换，使用 tuple() 将列表转为不可变的元组，而 list() 将元组转为可变的列表。

（3）和列表一样，也是可以通过索引和切片来访问元组的元素。

12、字典

（1）字典的基础知识
可以把字典想象成一个“新华字典”，里面存储了很多“词语”和“解释”。在 Python 里，字典它用 { } 大括号表示的，每个“词语”和“解释”用英文冒号 : 连接，不同的组合用 英文逗号, 进行隔开（冒号连接，逗号隔开）。
例如，下面这个字典创建后赋值给变量 score，字典中有三个键（词语）和三个值（解释），中间是通过英文逗号隔开的。

score = {'小明'：100，'小红':76,'小绿':99}

● 词语（键，key） → 解释（值，value）
● 苹果 → 一种甜甜的水果，红红的
● 老虎 → 一种凶猛的动物，有条纹

# 定义一个字典，存储水果和它们的颜色
fruits = {'苹果': '红色','香蕉': '黄色','葡萄': '紫色'}

其中， fruits 是这个字典的名字（就像一本单词本的名字）。而"苹果" 是 键（key），就像“词语”，“红色” 是 值（value），就像“解释”。

字典是以 键-值 的形式进行组合，字典的键是唯一的，但值可以不唯一，值可以为任何数据类型，且字典中的元素是无序的。另外，键可以用字符串、数字或元组，但不能是列表，即键必须是不可变的（因为列内的元素可变）。

# 定义一个字典，存储游戏玩家的姓名和积分
game = {'小刘':100,'小豪':'荣耀王者','小黑':0,'小熊':-66,'小智':'unbelievable!'}
●  词语（键，key） → 解释（值，value）
● "小龙" → 100
● "小齐" → 荣耀王者

若大括号内没有键值对，则会创建一个空字典，若字典中有重复键，则旧键会被覆盖。

（2）字典的增删改查
字典和列表的操作一样，字典也是可以进行增删改查，如下：

s={'a':'hello','b':'world'}
print(s)
s['c']='!'   #添加新的键c
print(s)
s['c']='你好'	#修改键c
print(s)

运行结果如下：

13、函数

将一些代码事先放在一起，需要的时候直接调用，这样可以简化代码书写，这个就叫做函数。它可以提高代码复用性、降低代码冗余（了解一下就行）。要注意一定要先定义函数，再调用函数，其实和之前创建画笔画画一样，画笔都没创建，怎么可能可以画画呢。

（1）函数的定义和调用
以下是函数的两个步骤，先定义，再调用，定义是用def 来定义的，同时，要注意函数里面的代码要缩进：

#定义函数
def 函数名()
	…

#调用函数
函数名()

例如，定义一个函数，它的名字叫 ikun_basketball，其中需要重复使用的代码是打印（第二行和第三行），定义和调用的过程如下：

def ikun_basketball():       # 定义函数
    print('egg1')
    print('egg2')

ikun_basketball()            # 调用函数    

运行结果如下：

不过一般建议名字我们起简单一些就可以了，没必要写这么长，比如 a()、b()、love()等等。

（2）带参数的函数
什么是参数？其实，函数括号里的内容（变量），就叫做参数，例如下面两个函数，一个带参数（有一个变量 a），一个不带参数：

def QAQ():                #不带参数的函数

def QAQ(a):               #带参数的函数，参数是变量a

● 也可以定义多个参数，用英文逗号隔开

def ABC(a):        # 带参数的函数，带一个参数

def ABC(b,c,d):    # 带参数的函数，带三个参数

（3）形参和实参

形参是定义函数括号内的内容，实参是调用函数括号内的内容。

● 调用函数时，参数的顺序和个数，必须要和定义函数时一样，顺序一定要写对。

下列python代码，input_number()函数是个无参函数，它通过input_number()来调用该函数，number_max()函数带有三个参数，在调用number_max()时向该函数传入了三个实参，该函数的功能是输出传入的参数：

def input_number():
    print("这是一个无参函数。")
def number_max(x, y, z):
    print(x, y, z)

input_number()
number_max(3, 0, 1)

运行结果如下：

另外，在调用带参数的函数时，我们要知道括号里的参数是可以变量、数字或者字符串。

（4）函数的参数传递
一般情况，都是将实参按照位置顺序传递给形参，如下代码，div()函数中的实际参数和形式参数有相应的位置关系，分别传递给不同的形参：

def div(num1, num2, num3):
    print(num3 + num1 - num2)
  
div(3,2,9)

运行结果如下：

第二种情况，也可以通过形参=实参的形式，根据形参的名称进行传递，如下python代码：

def info(name, sex, age):
    print(f"名字:{name}")
    print(f"性别:{sex}")
    print(f"年龄:{age}")

info(name="xiaoming", sex="男", age=18)

第三种情况，在调用函数时，若没有传递值给形参参数，则会使用默认参数，即参数的默认值。若对带有默认值的形参传递，则实参的值会覆盖设置的默认值。另外函数中，调用默认参数应放在其它实参后。例如下列python代码：

def info(name, sex, age, garde=1):       # 有四个参数的函数，garde是默认为1
    print("名字: ", name)
    print("性别: ", sex)
    print("年龄: ", age)
    print("年级: ", garde)

info(name="xiaoming", sex="男", age=18)

运行结果如下，调用该函数时，由于未给garde传参，形式参数garde使用默认值1，运行结果如下：

若形式参数garde使用传入值，则会覆盖设置的默认参数，python代码如下：

def info(name, sex, age, garde=1):
    print(f"名字:{name}")
    print(f"性别:{sex}")
    print(f"年龄:{age}")
    print(f"年级:{garde}")

info(name="xiaoming", sex="男", age=18, garde=2)

运行结果如下，输出的年级garde值为1，默认值garde=1被覆盖：

（5）return 返回

● return让函数具有返回值（可以有多个返回值），在带参数和不带参数的函数里都可以用。
例如，下面这个代码定义一个函数，return 后面写的是一段文字：

运行结果如下：

（6）递归函数
递归函数，它可直接或间接地调用函数自身。其中函数递归时，要有递归公式和边界条件，递归公式用于分解规模较大的问题为规模较小的问题，边界条件用于终止递归函数。例如下列python代码：

def f(x):      # 定义f()函数
    if x == 1:
        return 1   # 返回1
    else:
        return x + f(x - 1)

print(f(4))    # 调用f()函数

运行结果如下：

可以这样理解，这个递归函数 f(x) 计算的是从 1 加到 x 的和（即 1 + 2 + 3 + … + x），我们需要通过递归依次求得f(x-1)的值，从而得到f(x)的值，如下：
执行过程分析（以 f(4) 为例）：
f(4) → 4 ≠ 1，执行 return 4 + f(3)
f(3) → 3 ≠ 1，执行 return 3 + f(2)
f(2) → 2 ≠ 1，执行 return 2 + f(1)
f(1) → 1 == 1，返回 1（递归终止）
逐步返回计算：
f(1) = 1
f(2) = 2 + f(1) = 2 + 1 = 3
f(3) = 3 + f(2) = 3 + 3 = 6
f(4) = 4 + f(3) = 4 + 6 = 10【所以最终答案为 10】

（7）全局变量和局部变量
● 全局变量：在整个程序里都能用的变量（函数内外都有效）。
● 局部变量：只在某个函数内部才能用的变量，外面用不了。

x = 10         # 全局变量（哪里都能用）
def func():    # 定义func()函数
    y = 5      # 局部变量（只在func里能用）

另外，在变量的前面加上 global 可以能在函数内部修改全局变量，而不是新建一个同名的局部变量。比如，下面 func()函数内的 x 就是一个普通的变量，所以是无法修改的，虽然上面写了 x=10，下面我们将 x=20 进行重新赋值，但是仍未改变：

x = 10

def func():    # 定义func()函数
    x = 20     # 这里其实是创建了一个局部变量 x，不会影响外面的 x

func()         # 调用func()函数
print(x)       # 输出 10（全局变量没变）

运行结果如下：

然而，我们在变量 x 前面加一个 global（可以修改全局变量）即可将 x 变成全局变量【第五行】，如下代码：
x = 10

def func(): # 定义func()函数
global x # 声明要修改的是全局变量 x
x = 20 # 现在修改的是全局变量

func() # 调用func()函数
print(x) # 输出 20（全局变量被修改了）
运行结果如下：

再举一个例子，例如下列python代码，在fein()函数中修改全局变量a，首先要对它该变量使用global关键字声明：

a = 1
def fein():    # 定义fein()函数
    global a   # 通过global声明为全局变量
    a *= 2     # 这个和a=a*2是一样的，只是简写，a每次乘以2
    print(a)

fein()         # 调用fein()函数

运行结果如下：

14、其他知识点

（1）随机库
导入随机库的方法是 import random，使用之前需要先导入，这个 random 的中文意思就是随机。我们可以通过randint(最小值,最大值)来生成一定范围内的随机整数，其中是包括最小和最大值的。

import random
print(random.randint(0,360))

这里的意思是随机输出0~360之间的一个整数，包括0和360哦。

（2）数学计算方法
sorted() —— 排序
作用：可以用于对可迭代对象（如列表、元组、字符串等）进行排序，返回一个新的排序后的列表（原对象不变）。同时，我们可以指定 reverse= 说明来决定是否升序或者降序（也就是增大或减小），通过True 降序，False 升序来实现，默认情况是升序。如下代码：

nums = [3, 1, 4, 2]
print(sorted(nums))                # 输出 [1, 2, 3, 4]（默认升序）
print(sorted(nums, reverse=True))  # 输出 [4, 3, 2, 1]（降序）

运行结果如下：

round() —— 四舍五入
作用：对数字进行四舍五入，可以指定保留几位小数。

print(round(3.14159))       # 输出：3（默认取整）
print(round(3.14159, 2))    # 输出：3.14（保留2位小数）

max() —— 找最大值
作用：返回一组数字或列表中的最大值。

print(max(10, 20, 30))          # 输出：30
print(max([5, 2, 9, 1]))        # 输出：9（列表中的最大值）

min() —— 找最小值
作用：返回一组数字或列表中的最小值。

print(min(10, 20, 30))          # 输出：10
print(min([5, 2, 9, 1]))        # 输出：1（列表中的最小值）

sum() —— 求和
作用：计算列表中所有数字的总和。

print(sum([1, 2, 3, 4]))        # 输出：10（1+2+3+4）

abs() —— 绝对值
作用：返回数字的绝对值（正数）。

print(abs(-5))                  # 输出：5
print(abs(3.14))                # 输出：3.14

range() —— 生成数字序列
作用：生成一个数字范围（常用于循环）。

print(list(range(5)))           # 输出：[0, 1, 2, 3, 4]（0到4）
print(list(range(1, 6, 2)))     # 输出：[1, 3, 5]（1开始，步长2）

例如，range(2, 7, 2) 会生成一个整数序列，生成的序列：从 2 开始，每次增加 2，直到数值小于 7，结果为：[2, 4, 6]。

（3）进制表示
一般有以下常见的进制表示，例如，二进制、八进制、十进制和十六进制【这里只要知道二进制和十进制】。要注意它们是从0开始，可以简单描述为逢X进1（X为2、8、10、16），如下表：

我们在数学中默认是十进制（逢十进一）表示，而计算机是采用二进制的，也就是它只认识 0 和 1。
● 十进制（Decimal）：我们平时用的数字（0~9），比如 123。
● 二进制（Binary）：计算机用的数字（只有 0 和 1），比如 1011。

如果想二进制 → 十进制（按权展开法）：
● 规则：从右到左，每一位代表 2 的 n 次方（n从0开始），然后相加。
● 例子：1011（二进制） → ?（十进制）

可以得出， 1×8 + 0×4 + 1×2 + 1×1 = 8 + 0 + 2 + 1 = 11，所以1011（二进制）= 11（十进制）。
如果想十进制 → 二进制（除2取余法）：
● 规则：不断除以2，记录余数，最后把余数倒过来写。
● 例子：11（十进制） → ?（二进制）

可以得出，余数倒序：1011，所以11（十进制）= 1011（二进制）。

（4）异常处理
● try-except（捕获异常）
作用：尝试运行代码，如果出错就执行 except 处理错误。

try:
    print(10 / 0)  # 这里会报错（除零错误）
except:
    print("出错啦！")  # 捕获到异常后执行

● else（无异常时执行）
作用：当 try 代码块没有异常时执行。

try:
    print(10 / 2)  # 正常执行
except:
    print("出错啦！")
else:
    print("没出错，执行 else！")  # 输出这一行

● finally（无论是否异常都执行）
作用：不管有没有异常，最后一定会执行（比如关闭文件）。

try:
    print(10 / 0)  # 这里会报错
except:
    print("出错啦！")
finally:
    print("无论如何都会执行！")  # 永远输出

（5）文件处理
● 文件操作（open() 函数）
Python 用 open() 打开文件，可以读、写或追加内容。
● 文件打开模式
○ ‘r’：只读（默认，不能修改文件）。
○ ‘w’：写入（会清空原文件，重新写）。
○ ‘a’：追加（在文件末尾添加新内容，不删旧数据）。
例如，‘w’ 像新建一个本子（旧内容全没了），而’a’ 像在作业本最后一行继续写（前面的作业还在）。
● with 语句
自动管理文件，用完后自动关闭，避免忘记关文件导致错误。

（6）网站访问
需要提前导入 requests 库，from requests import *
● get() 像用浏览器打开百度（只看不提交），例如，requests.get(url)。
● post() 像登录账号（要提交用户名和密码），例如，requests.post(url, data={‘key’:‘value’})。
● text（获取网页内容），可以服务器返回的网页 HTML 代码。