Python笔记（持续更新）

安装教程与初步

python的安装

（这里以Windows系统为例）

1.官方网址：www.python.org
进入后点击 Windows

2.选择一个版本安装。建议大家安装3.8以上的版本，同时也建议不要安装最新的版本，因为相对来说不太稳定，3.8以上就可以。再根据自己电脑的配置选择对应的版本。
下载时间会较长，等待一会儿。

3.下载完成后打开，下面两个都要勾选。（因为这个电脑已经下载过了，所以第一个无法勾选）然后再点击Install Now。接着等待安装完成即可。

4.按 win + r 键，输入cmd

5.输入 python。若弹出下图则说明安装成功

PyCharm的安装

（以Windows系统为例）

1.官方网站：www.jetbrains.com/pycharm/
进入后点击 DOWNLOAD

2.会进入下面这个界面，先选择系统，在Community里点击Download，就会开始下载。（这里有两种版本，分别是专业版和社区版，社区版就够用了，没必要下载专业版）

3.下载完成后打开，点击 Next

4.选择一个安装位置，再点击 Next

5.全部勾选，再点 Next

6.直接点 Install

7.正在安装…

8.安装完成，点 Finish

创建第一个项目

1.打开PyCharm，点击四道杠，在File里点击 New Project。这样就创建了一个新的工程

2.在第一个红框处右键，在 New 处 选择 Python File

3.给你的文件起个名字，最好是英文的。然后就可以编写代码啦

变量的使用

什么是变量

在程序运行过程中，值会发生变化的量

变量的定义

• 把程序运算的中间结果临时存到内存里，以备后面的代码继续调用，此名字的学名就叫 变量
• 变量名是独一无二的。可看成是容器，可大可小
• a=1 b=2 c=3 # a b c 是变量；名字分别叫做a b c；123代表的是这个变量的值
• 一个变量必须要有值，否则无意义
• 变量是统称，变量名是具体的

a = 1

b = hello	# 错误。因为内存中是没有 hello 的，但内存中有 1。所以第一行正确，第二行错误。

变量的作用

• 变量用于存储要在计算机程序中引用和操作的信息。它提供了一种用描述性名称标注数据的方法，这样可以更清晰地理解程序。
• 可以将变量理解为容器。目的是在内存中标注和存储数据。然后可以在整个程序中使用。

变量的创建

• python中无需声明变量类型
• 变量的赋值一定是从右往左
• 等于号 = 意思是赋值，并不是等于
• 引号：单引号 ‘’ 与 双引号 “” 必须是英文状态下的引号
• 按一下键盘上的 shift 键即可切换中英文
• 变量需要先赋值才能使用，否则报错
• 变量本身没有数据类型，数据类型指的是值的数据类型

a = '1'

b = "1"		#单引号与双引号都可。需要注意的是在英文状态下，并且要成对出现，即单引号要对应单引号，双引号要对应双引号

• python支持同时给多个变量赋值，并且按顺序赋值 例如：

 a, b, c, = 1, 2, 3	# a的值为1，b的值为2，c的值为3

例子：

a = 'Jack'

b = a

a = 'Tom'

print(a)

print(b)	# 输出结果分别为 Tom 和 Jack		因为第三行的代码里的 Tom 覆盖了第一行代码中的 Jack

• print(b) #打印的是变量名字叫b的容器
• print(‘b’) # 单纯的打印字符串b

变量的命名规则

1. 只能是由字母、数字或下划线组成，且第一个字符不能是数字
2. 严格区分大小写
3. 不能把关键字当成是变量名
   • 关键字举例：‘False’, ‘True’, ‘and’, ‘break’, ‘if’ …
4. 尽量做到见名知意 即看见变量名就可知道其意思
   • 建议用对应的英文单词（不知道单词就去搜索）
   • 虽然不报错，但强烈不建议：直接用中文（比如：姓名，性别，年龄）

注释

• 辅助理解对应的代码含义，并不包括在代码的运行当中，具有说明性质

• 单行注释：在开头添加一个井号 # shift+3 或者是选中该行按 ctrl+/

• 多行注释：选中需要注释的行，再按 shift+/ 或者 将需注释内容放在成对的三个引号里面，即 ‘’’ ‘’’ 或 “”" “”" ，快捷键 shift+"

• 将整个文件注释：全选（ctrl+a）再按 ctrl+/ 或 按三次 shift+"

快捷键

• ctrl+c 复制
• ctrl+v 粘贴
• ctrl+d 在pycharm里是复制上一行的代码
• ctrl+z 撤回
• a = 1 代码中的空格可有可无，但建议添加
• ctrl+alt+l 格式化代码

数据类型转换

输入函数 input() 与输出函数 print()

函数代表的是一个功能

通过 input() 函数 输入的值都是 str 字符串类型

---

name = '张三'
sex = '男'

print(name,sex)	 # , 用于分隔开值与值。
#并不会输出为 张三，男   中间的符号为空格，而不是逗号

---

name = input('请输入你的名字：')

#注意区分下面两行代码
print(name)  # name 代表的是一个变量，变量的值是 input 输入的值
print('name')  # 'name' 代表一个字符串数据，且这个值为name

---

a = 1  # 为整型 int
b = '1'  # 为字符串型 str

---

print(1 + 1)  # 数值运算 结果为 2
print('1' + '1' + '@')  # 拼接 结果为 11@

---

input()  # 等用户去输入
		 # 若不进行输入，则程序被阻塞，无法运行后面的代码
print('111')  

注意：一定要担心阻塞。因为阻塞后程序无法继续运行。可通过 debug 处理

在 pycharm 查看函数功能的方法：ctrl + 鼠标左击函数名

print('111')
print('111')
print('111')

# 输出结果为下面四行
# 111
# 111
# 111
#

# print() 函数会默认在末尾换行。因为 print() 有个默认参数 end='\n' 。\n 是换行符
# 但该参数可修改。例如：
print('111',end = '888')  # 如此就会在打印完 111 后，在末尾打印 888 ，而不会换行
a = 1
b = 2
# 仔细看：
print(a, b)  # 输出结果为 1 2  1和2之间有个空格
print(a, b, sep='')  # 输出结果为 12  1和2之间没有空格
# print() 函数默认在两个变量间添加空格。但可修改，方法如上一行。两个单引号之间什么都没有，则将两个值连在一起。

格式化输出

%格式化输出：在数据库语句中运用较多

format函数：平常使用较多

f表达式：目前使用最多 在python3.6 之后才出现

%格式化输出

%s 格式化字符串

%d 格式化整数

%f 格式化浮点数（也就是小数）

例如：

print('今天是%s现在是%d度'%('周四',20))  #严格按顺序对应
# %s 对应后面在第一个位置的 '周四'
# %d 对应后面在第二个位置的 20

%f 的用法

num1 = 987.654
print('保留四位小数是：%.4f'%num1)  # 结果是987.6540
print('保留一位小数是：%.1f'%num1)  # 结果是987.7
# 可以注意到 f 前面的数字是几就保留几位小数

format函数

name = '张三'
sex = '男'
age = 18

print('姓名是{},性别{},{}岁'.format(name,sex,age))
# 输出结果为 姓名是张三,性别男,18岁
# 按顺序一一对应。name对应第一个{};sex对应....

print('姓名是{2},性别{0},{1}岁'.format(name,sex,age))
# 输出结果为 姓名是18,性别张三,男岁
# 按编号对应，起始为 0，即 name 是 0，sex 是 1，age是 2

print('姓名是{name},性别{sex},{age}岁'.format(name = name,sex = sex,age = age))
# 开头定义的三行变量对应这里的等号的右边，赋值给左边，再一一对应{}里的

f 表达式（最方便）

print(f'姓名是{name},性别{sex},{age}岁')

数据类型之间的转换

函数	功能
int(x)	将 x 转化为整数
float(x)	将 x 转化为浮点数
str(x)	将 x 转化为字符串
eval(str)	将字符串中的数据转换成 Python 表达式原本类型
tuple(s)	将序列 s 转换为⼀个元组
list(s)	将序列 s 转换为⼀个列表

运算符

算数运算符

符号	描述	实例
+	加	print(1 + 1) 输出结果为 2
-	减	print(1 - 1) 输出结果为 0
*	乘	print(1 * 2) 输出结果为 2
/	除	print(4 / 2) 输出结果为 2.0
//	整除	print(9 // 4) 输出结果为 2
%	取余	print(9 // 4) 输出结果为 1
**	乘方	print(2 ** 4) 输出结果为 16
（）	优先级	print((1 + 1) * 3) 输出结果为 6

赋值运算符

a = 1  # 将 1 赋值给 a
b = 2  # 将 2 赋值给 b

# 多变量赋值
a,b,c,d = 1,2,3,4  # 将 1 赋值给 a，将 2 赋值给 b....

复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	a += 1 等价于 a = a + 1
-=	减法赋值运算符	a -= 1 等价于 a = a - 1
*=	乘法赋值运算符	a *= 1 等价于 a = a * 1
/=	除法赋值运算符	a /= 1 等价于 a = a / 1
//=	整除赋值运算符	a // = 1 等价于 a = a // 1
%=	取余赋值运算符	a %= 1 等价于 a = a % 1
**=	次方赋值运算符	a **= 1 等价于 a = a * 1 * 1

比较运算符

运算符	功能
==	等于。如 a = 1, b = 1, 则 a == b 为 True
!=	不等于。如 a = 1, b = 2, 则 a != b 为 True
>	等于。如 a = 1, b = 2, 则 a > b 为 False
>=	等于。如 a = 1, b = 1, 则 a >= b 为 True
<	等于。如 a = 1, b = 2, 则 a < b 为 True
<=	等于。如 a = 1, b = 1, 则 a <= b 为 True

布尔类型

and or not

非 0 非 空 即为真（分别对应 int （包括 float ） 型和 str 型）

零散知识点：无论单引号双引号，都是成对出现并找最近的

例如：

print("abcd'abcd'abcd")  # 输出结果为字符串型的 abcd'abcd'abcd

---

a = True
b = True
c = False

# and 与
print(a and b)  # 输出结果为 True
print(a and c)  # 输出结果为 False
print(c and b)  # 输出结果为 False
# 总结：二者全为真即为真，一者为假即为假

# or 或
print(a or b)  # 输出结果为 True
print(a or c)  # 输出结果为 True
print(c or b)  # 输出结果为 True
# 总结：其中一者为真即为真，二者都为假即为假

# not 取反
print(not a)  # 输出结果为 False
print(not c)  # 输出结果为 True
# 总结：真取反为假，假取反为真

# 注意：可以同时使用多个 and 、 or 或 not

# 短路现象 （ or 特有）
print(a and b or c or False)  # 当运行到第一个 or 时，结果为 True，因为后面还是 or，根据 or 的规则，可以不用继续往后看，所以结果为 True。
# 这里会有个优先级 () > not > and > or

# 当 and 前后都为一个不等于 0 的值时，输出后者
a = 1
b = 2
print(a and b)  # 输出结果为 2

成员运算符

in / not in

a = 1
b = 2
list1 = [2,3,4,5,6]

print(a in list1)  # 输出结果为 False，因为 1 不在 list1 里面，但用得是 in
print(b not in list1)  # 输出结果为 False，因为 2 在 list1 里面，但用得是 not in

身份运算符

a = 1
b = 1
print(id(a),id(b))  # 输出的两串数字一样。涉及到可变和不可变，后面会介绍
print(a is b)  # 输出结果为 True

---

a = [1,2,3]
b = [1,2,3]
print(id(a),id(b))  # 输出的两串数字不一样。涉及到可变和不可变，后面会介绍
print(a is b)  # 输出结果为 False。因为比较得是内存地址
print(a == b)  # 输出结果为 True。因为比较得是值

if 语句

if 双分支语句

单分支语句就是只有 if，去掉 else

	# 四个空格为缩进。可按 Tab 键控制缩进。作用是疏通代码结构

---

sex = input('请输入你的性别（男/女）')
if sex = '男':
    print('男生请走左边')  # 这里有缩进，表示该语句属于 if，只有 if 后面的条件为 True，才会执行该行代码。
else:
    print('女生请走右边')  # 当 if 语句为 False 时，执行该行语句，否则不执行。

if 多分支语句

fruit = input('请输入你想吃的水果的编号')
if fruit == 1:  # 注意两个等号之间不能有空格
    print('1号水果是苹果')  # 如果输入的数字为 1，则运行该行代码；下面两个 elif 同理。
elif fruit == 2：
	print('2号水果是香蕉')
elif fruit == 2：
	print('3号水果是梨')
else:
    print('很抱歉，没有这个编号')  # 如果输入的都不符合前条件，则运行该行代码
# 可以看到， elif 需要加条件，而 else 不用加条件

if 嵌套

例子：俄罗斯套娃。大娃套中娃，中娃套小娃

babyK = input('请先拿掉大娃（已拿掉/未拿掉）')
if babyK == '已拿掉':
    print('你已经成功拿掉了大娃')
    babyQ = input('接着请拿掉中娃（已拿掉/未拿掉）')
    if babyQ == '已拿掉':
        print('你已经成功拿掉了中娃')
        print('恭喜你成功拿到小娃 babyJ')
    elif babyQ == '未拿掉':
        print('请先拿掉中娃才能拿到小娃')
else:
    print('请先拿掉大娃才能拿到中娃')

三目运算符

用于处理比较的 if 判断

a = 1
b = 2
c = a if a > b else b
print(c)

# 上面四行代码的意思可以理解为以下代码
if a > b:
    print(a)
else:
    print(b)

循环

while 循环

例1：打印 1 到 100 之间的整数

i = 0
while i <= 100:  # 判断条件。 当 i < 100 时，执行缩进的代码
	i += 1  # i = i + 1
	print(i)  # 上面两行的代码称为循环体。只有循环结束才能打印后面的代码
print('循环结束')
# 输出结果为0，1，2...98，99，100  循环结束

---

例2：计算 1 到 100 之间的整数和

i = 0  # 控制每次的整数
sum1 = 0  # 存放每次求和的值
while i < 100:  # 当 i < 100 时执行代码块
    i += 1  # 等价于 i = i + 1 以便每次输出的数比之前大一
    sum1 += i  # 等价于 sum1 = sum1 + i # 每次求和的值，直到最后一次求和完毕 
print(sum1)  # 输出 1 到 100 之间的整数和

---

例3：计算 1 到 100 之间的所有偶数的和

方法一：

i = 1
sum1 = 0
while i < 100:
    i += 1
    if i % 2 == 0:  # 每个 1 到 100 之间的数除以 2 取余，如果余数为 0，则为偶数，该数加到 sum1 里
    # if i % 2 == 1:  # 若将右边的值改为 1，则求地是所有奇数的和
    	sum1 += i
print(sum1)
# 部分代码与例2相同，可参考理解

例3：计算 1 到 100 之间的所有偶数的和

方法二：

i = 0
sum1 = 0
while i < 100:
	i += 2  # 从 0 开始，每次加 2，则跳过了奇数
	sum1 += i
print(sum1)

循环控制语句

break 终止循环，并跳出循环

continue 终止当前循环，跳出该次循环，执行下一次循环

pass pass是空语句，是为了保持程序结构的完整性

break

i = 1
while i <= 100:
    i += 1
    if i == 10:
    	print('完成今天的任务')
        break  # 当满足条件，即当 i == 10 时，终止循环，不再继续执行后面次数的循环
print(f'今天跑了{i}圈')

continue

i = 1
while i < 20:
    if i == 10:
        print(f'已经跑了{i}圈，走一圈再接着跑')
        i += 1
        continue  # 当满足条件，即当 i == 10 时，跳出本次循环，继续执行下次的循环
    print(f'今天一共跑了{i}圈')
    i += 1

pass

i = 0
while i < 100:
    pass  # 这里要写东西，但暂时不知道些什么，先用 pass 代替

while 循环嵌套

i = 1
while i <= 3:
	j = 1
    while j <= 10:  # 内循环完毕才会执行外循环
    	print(f'已经跑了{j}圈')
        j += 1
    print(f'已经跑了{i}天')
    i += 1

例：九九乘法表

i = 1
while i <= 9:  # i 为行数
    j = 1
    while j <= i:  # j 为列数，在第几行就循环几次
        print(f'{j} X {i} = ',i * j,end='\t')  # 每次输出一个等式时，输出一个制表符
        j += 1
    print()  # 内循环结束一次需要换行
    i += 1

while…else

while 条件语句:
    条件成立时重复执行的代码
else:
    条件不成立时执行的代码

例：

i = 0
while i < 5:
    print('条件成立，执行这块代码')
    i += 1
else:
    print('条件不成立，执行这块代码')

for … in 循环

python 的 for 循环可以遍历任何序列的项目，如一个列表或一个字符串

for 临时变量 in 待处理数据集:
    重复执行代码

例1：

a = '123456'
for i in a:  # 每次循环的一个值都会存到 i 临时变量中，然后再执行代码 print(i)
    print(i)  # 输出每个值

例2：求某个字符出现的次数（以 h 为例）

str1 = 'hello python hello world'
count = 0
for i in str1:  # 遍历字符串 'hello python hello world'
    if i == 'h':
        count += 1  # 当遍历到 h 时，count + 1
print(count)  # 输出结果为 3 

range() 函数

for i in range(1,6,2):
    print(i)  # 输出结果为 1,3,5 默认不写从 0 开始（但可以设置，这里设置为 1 ），取到最后一个值的前一个值。即取不到 6，而是取到 5，但是，最后一个参数是步长，默认不写为 1，这里设置为 2.所以输出结果为 1,3,5

for 循环的嵌套

尽量不要嵌套三次及以上

for i in range(1,6):  # 输出 5 次
    print(f'这是第{i}天')
    for i in range(1,11):  # 每次输出 10 遍，共 50 遍
        print(f'这是第{i}圈')

continue

跳过本次循环，继续下一次循环

例：输出 1-100 的整数，但跳过 7 的倍数

for i in range(1,101):
    if i % 7 == 0:  # 当遇到 7 的倍数，跳过本次循环
        continue
    print(i)

break

终止循环，不再执行循环

例：当遇到 7 时，停止循环

li = [1,2,3,4,5,6,7,8,9]  # 定义一个 1-9 的列表，后面会讲到列表
for i in li:  # 遍历这个列表
    if i == '7':  # 当遇到 7 时，终止循环
        print('遇到了 7')
        break
    print('还没遇到 7')

练习

例1：求 1-100 偶数的和

sum1 = 0
for i in range(1,101):  # 遍历 1-100 的整数
    if i % 2 == 0:  # 便利的每个值除以 2 取余，若余数为 0，则将该数加入 sum1
        sum1 += i
print(sum1)
# 输出结果为 2550

例2：求任意数的阶乘

num = int(input('请输入任意一个整数'))  # 将输入的整数转换为数值型
sum1 = 1
for i in range(1,num + 1):
    sum1 *= i  # 等价于 sum1 = sum1 * i
print(sum1)

例3：九九乘法表

for i in range(1,10):
    for j in range(1,i+1):  # 内层循环次数不能超过外层循坏
        print(f'{j} X {i} = {j * i}',end='\t')
    print()

例4： 1，2，3，4能组成多少个各个位数都不重复的三位数

count = 0
# 将 i, j, k 范围限制在一定范围
for i in range(1,5):
    for j in range(0,5):
        for k in range(0,5):
            if i != j and i != k and j != k:  # 各个位数都不相等
                print(f'{i}{j}{k}')
                count += 1
print(count)  # 一共有 48 个

字符串

字符串的定义

被 单引号 ‘’ 双引号 “” 三引号 “”“”“” 包裹起来的数据，就是字符串。但是都要成对出现。

str1 = '字符串1'
str2 = "字符串2"
str3 = """    字符串3   
                        """  # 也叫注释，也是字符串，且保留原有格式
print(str1,str2,str3)
print(type(str1),type(str2),type(str3))  # 都是 str 类型

字符串的下标

又称索引，每个下标对应一个值。python的下标从左往右从 0 开始，从右往左从 -1 开始。

方式： str1[下标的值]

例：取到第二个 h

str1 = 'hello python'
print(str1[9])
print(str1[-3])  # 两行代码皆能取到第二个 h

字符串的切片

str1[起始索引值 : 终止索引值 : 步长]

三个值正负数都可。

取不到最后一个值，只能取到指定值的前一个值。

例：

str1 = 'hello python'
print(str1[:12])  # 等价于 print(str1[0:12])
print(str1[::])  # 都为默认 从头取到尾，包括尾，步长为 1
print(str1[::-2])  # 逆序输出，步长为2
print(str1[-4:-1:-1])  # 输出为空 因为从 -4 开始从左往右取，但步长为 -1，即从 -4 开始从右往左取。故取不到值。取值方向与步方向不一致则取不到值

字符串查找

find() 检测某个字符或字符串是否包含在这个字符串中，若在，返回这个字符串开始的位置下标，否则返回 -1

str1 = 'hello python hello world'
print(str1.find('hello'))  # 返回第一个 hello 的起始位置，即 0
print(str1.find('hello',6,30))  # 返回在第 6 个位置到第 30 个位置第一次出现的 hello，即 13
print(str1.find('hi'))  # str1 中找不到 hi，返回 -1

index() 检测某个字符或字符串是否包含在这个字符串中，若在，返回这个字符串开始的位置下标，否则报错

str1 = 'hello python hello world'
print(str1.index('hello'))  # 返回第一个 hello 的起始位置，即 0
print(str1.index('hello',6,30))  # 返回在第 6 个位置到第 30 个位置第一次出现的 hello，即 13
print(str1.index('hi'))  # str1 中找不到 hi，程序报错

count() 返回某个字符或字符串出现的次数

list1 = [1,2,3,[1,2,3]]  # 列表，后面会讲
print(list1.count(1))  # 只能得到一个，因为后面的[1,2,3]做为一个整体出现
print(list1[-1].count(1))  # 这种方法能得到第二个列表里的 1，但也是只能得到一个

str1 = 'hello python hello world'
print(str1.count('hello'))  # 返回 2，因为有两个都被统计
print(str1.count('hello',6,30))  # 在第 6 个位置到第 30 个位置只出现了一次 hello，所以返回 1
print(str1.count('hi'))  # str1 中找不到 hi，返回 0

字符串修改

对字符串当中的内容进行修改

replace() 替换

语法：变量名.replace(旧的,新的,替换次数)

str1 = 'hello python hello world'
print(str1.replace('hello','hi'))  # 将第一个出现的 hello 替换为 hi
print(str1.replace('hello','hi',2))  # 将前两个出现的 hello 替换为 hi

不会改变原来的字符串，因为字符串是不可变类型，所以会开出新的内存。后面会讲

split() 可指定字符分隔字符串

str1 = 'hello python hello world'
print(str1.split('hello',1))  # 以 hello 为界，分隔开其他字符串，返回一个列表，且只分割一次。不写分割次数默认包含全部

字符串连接

join() 用一个字符或字符串连接成为一个新的字符串。

join() 参数必须为可迭代对象。

可迭代对象：能够从一个序列中一个一个取出数据的，能够使用 for 循环遍历的肯定是一个可迭代对象

str1 = '1234'
print('a'.join(str1))  # 分隔符可为空。join 连接的是字符串

字符串删除

strip() 删除两侧空格

str1 = '     hello python hello world  '  # 默认情况只会删除两侧空格，并不会删除中间的空格。或删除两侧指定字符或字符串

列表与元组

列表中可以存放任何数据类型的元素

列表的创建

# 两种方法都可
list1 = [1,2,3,4]
list2 = list('1234')  # 这种方法建立的列表里的值是字符串

列表的查找

通过索引查找。可类比字符串的索引查找

list1 = ['张三','李四','王五']
print(list1[0])  # 输出结果为张三
print(list1[1])  # 输出结果为李四
print(list1[2])  # 输出结果为王五

通过切片访问。可类比字符串的切片。这里不做过多说明

list1 = ['张三','李四','王五']
print(list1[::])  # 从左往右全部输出

index() 函数和 count() 函数可参考字符串中的笔记。使用方法相同。

len() 统计长度。无论是列表还是字符串都可统计。但一定要是可迭代对象

# 输出结果都为 4
print(len('1234'))
print(len([1,2,3,4]))

in 与 not in

直接看例子即可理解

list1 = ['张三','李四','王五']
name = input('请输入你要查找的名字：')
if name in list1:
    print('该名字存在')
else:
    print('该名字不存在')

列表的添加

append() 在列表末尾添加元素

list1 = ['张三','李四','王五']
list1.append('刘六')
print(list1)

append() 添加的如果是序列，则添加整个序列

list1 = ['张三','李四','王五']
list2 = ['刘六','林七']
list1.append(list2)
print(list1)

extend() 在列表末尾追加或扩展元素

若是一个元素，则逐一添加

list1 = ['张三','李四','王五']
list1.extend('刘六')
print(list1)

若是一个序列，则整个添加

list1 = ['张三','李四','王五']
list2 = ['刘六','林七']
list1.extend(list2)
print(list1)

insert() 在指定索引插入数据

list1 = ['张三','李四','王五']
list1.insert(1,'刘六')  # 在索引为 1 的位置插入刘六
print(list1)

列表的删除

del 它是关键字。可删除整个列表，也可删除部分元素

list1 = ['张三','李四','王五']
del list1  # 结果不是空列表，而是整个列表被删除
print(list1)  # 会报错，因为 list1 已经被删除

list1 = ['张三','李四','王五']
del list1[1]  # 删除索引为 1 的元素
print(list1)

pop() 删除指定索引的数据（默认为最后一个），并返回

list1 = ['张三','李四','王五']
list1.pop(1)  # 删除索引为 1 的元素
print(list1)

remove() 删除指定元素

list1 = ['张三','李四','王五']
list1.remove('张三')  # 删除值为'张三'的元素
print(list1)

clear() 清空列表，并不是删除列表

list1 = ['张三','李四','王五']
list1.clear()  # 清空列表里的值
print(list1)

列表的修改

修改单个值

list1 = ['张三','李四','王五']
list1[1] = '刘六'  # 修改列表下标为 1 的值为刘六
print(list1)

批量修改值

list1 = ['张三','李四','王五']
list1[1:2] = ['刘六','林七']
print(list1)

reverse() 倒序输出

list1 = ['张三','李四','王五']
list1.reverse()
print(list1)

sort()

list1 = [7,4,1,2]
list1.sort(reverse = True)  # 默认为 False，升序。可以改为 True，降序
print(list1)

列表的复制

copy()

list1 = ['张三','李四','王五']
list2 = list1.copy()
print(list2)
print(id(list1),id(list2))  # 复制只是将内容复制，id 值并不同

列表的循环遍历

此处可参考 循环 的笔记。用法相同

二维列表

list1 = [[1,2,3],[4,5,6],[7,8,9]]
print(list1[1][2])  # 输出下标为 1 的一维列表里的下标为 2 的值，即 6

元组的创建

元组与列表类似。列表使用方括号，而元组使用小括号

tuple1 = (1,2,3)
tuple2 = (1)  # 创建的序列必须至少含有两个值才可以创建。或是在后面加个 , 即 tuple2 = (1,) 

元组的查找

元组里可以存放任意类型的值。

元组并不支持修改，只支持查找。但若元组里有列表，也可修改里面的值

下标查找、index() 查找、count() 查找、len() 求长度 都与列表类似。

元组的删除

元组支持 del 删除

可变数据类型与不可变数据类型

可变数据类型：列表，字典，集合。当值改变，若对应的内存地址不改变，则是可变数据类型

不可变数据类型：数值，字符串，元组。当值改变，若对应的内存地址也改变，则是不可变数据类型

list1 = ['张三','李四','王五']
print(list1,id(list1))
list1.append('刘六')
print(list1,id(list1))
# 列表是可变数据类型，所以当值发生改变时，内存地址并不会发生改变

字典与集合

字典

字典由键（key）值（value）对构成，键和值中间用冒号（:）隔开，整个字典由大括号 {} 包裹

字典的创建

在字典中，键是唯一的，并且必须是不可变数据类型；值可以是任意数据类型

# 手动
dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
print(dict1)

# 自动
dict1 = dict(name='张三', sex='男', age='20')
print(dict1)

字典的查找

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
print(dict1['age'])
# print(dict1['age1'])  # 若未找到则报错
print(dict1.get('age1'))  # 若未找到则会返回None，而不会报错

keys() 查找所有的键

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
print(dict1.keys())  # 输出所有的键

values() 查找所有的值

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
print(dict1.values())  # 输出所有的值

items() 查找所有的键值对

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
print(dict1.items())  # 输出所有的键值对

字典的增加与修改

字典中的键无法修改，只能修改值

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
dict1['height'] = 180  # 若此键值对不存在就添加，存在则修改
print(dict1)
dict1['name'] = '李四'  # 修改 name 的值为李四
print(dict1)

update() 添加键值对

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
dict1.update({'height':180,'weight':140})  # 添加键值对
print(dict1)

字典的删除

del 删除字典或删除字典中指定的键值对

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
del dict1['sex']  # 删除对应的键值对
print(dict1)

del(dict1)  # 删除字典
print(dict1)  # 该字典已被删除，所以会报错

clear() 清空字典

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
dict1.clear()
print(dict1)  # 清空字典里的键值对，只剩空壳

pop() 删除指定的键值对

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
dict1.pop('sex')  # 删除指定的键值对
print(dict1)

for 循环遍历字典

遍历所有的键

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
for i in dict1.keys():
    print(i)  # 遍历所有的键

遍历所有的值

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
for i in dict1.values():
    print(i)  # 遍历所有的值

遍历所有的键值对

dict1 = {'name': '张三', 'sex': '男', 'age': '20'}
for i,j in dict1.items():
    print(i,j)  # 遍历所有的键值对

集合

集合是无序且不会重复的序列。集合可以去除重复的元素

集合的创建

# 手动创建
set1 = {1,2,3,4,5}  # 如果创建的集合元素在 0-9 之间，则会从小到大排序
print(set1)

# 自动创建
set1 = set()  # 创建空集合只能使用此方法
# dict1 = {}  # 此方法是创建空字典，而并不是空集合
print(set1)

集合的增加

add() 只能增加不可变数据类型

set1 = {1,2,3}
set1.add(4)  # 增加 4
print(set1)

update()

set1 = {1,2,3}
set1.update([4])  # 增加 4。可用列表、元组、字典和字符串
print(set1)

集合的删除

remove() 删除指定数据，删除不存在的数据则报错。用法类似，可参考之前的笔记

discard() 删除指定数据，若不存在则返回一个集合，而不会报错

set1 = {1,2,3}
set1.discard(4)  # 删除 4。不存在 4，但不会报错，而是返回一个集合
print(set1)

pop() 随机删除一个数据

set1 = {15,25,35}
pop_num = set1.pop()  # 随机删除一个元素
print(pop_num)  # 输出被删除的元素
print(set1)

公共操作

运算符

加号 + 合并 字符串、列表、元组

乘号 * 复制 字符串、列表、元组

in 是否存在 字符串、列表、元组、字典、集合

not in 是否不存在 字符串、列表、元组、字典、集合

# 加号 +
str1 = '1'
str2 = '2'
str3 = str1 + str2
print(str3)  # 结果为 12
# 列表和元组同理

# 乘号 *
print('-' * 3)
# 列表和元组同理

# in 与 not in
print('1' in '123')  # 返回 True，因为字符串 '1' 在字符串 '123' 中是正确的
print('4' not in '123')  # 返回 True，因为字符串 '4' 不在字符串 '123' 中是正确的

公共方法

max() 求最大值

str1 = 'abcde'
print(max(str1))  # 比较ASCII码值  结果为 e  min() 同理

min() 求最小值

list1 = [1,2,3,4,5]
print(min(list1))  # 输出最小值  结果为 1  max() 同理

enumerate() 返回值对应的下标

list1 = [1,2,3,4,5]
for i in enumerate(list1):
    print(i)  # 输出的第一个值为下标，第二个值为下标对应的值

zip() 将元素打包成元组，返回该元组组成的列表。用 * 可将元组解压为列表

# 打包
list1 = [1,2,3]
list2 = [4,5,6]
zip1 = zip(list1,list2)  # 将 list1 和 list2 打包成元组
print(list(zip1))  # 按照列表输出

# 解压
list1 = [1, 2, 3]
list2 = [4, 5, 6]
zip1 = zip(list1, list2)
tuple1, tuple2 = list(zip(*zip1))  # 解压。用 list 转换，即可看到效果，也可用 tuple
print(tuple1, tuple2)

数据类型转换

list1 = [1,2,3,4,5]
tuple1 = (1,2,3,4,5)
set1 = {1,2,3,4,5}
print(tuple(list1))  # 将列表转换成元组
print(set(tuple1))  # 将元组转换成集合
print(list(set1))  # 将集合转换成列表
# 三者之间可相互转换

推导式

当所要求条件很少时，推荐使用推导式

语法：

[ 表达式 for 变量 in 列表 if 条件 ]

{ 键:值 for 变量 in 字典.items() if 条件 }

{ 表达式 for 变量 in 集合 if 条件 }

( 表达式 for 变量 in 元组 if 条件 )

例：输出 1-10 之间的偶数

list1 = []
for i in range(1,11):
    if i % 2 == 0:
        list1.append(i)
print(list1)
# 以上等价于以下代码
list2 = [i for i in range(1,11) if i % 2 == 0]
print(list2)
# 字典、集合和元组同理

函数

自定义函数

• 函数必须先定义，后使用

• 自定义函数以 def 开头，然后写函数名和圆括号 ()，最后加上英文的冒号 :

• 括号内可放形式参数

• 冒号换行后要加缩进

• 函数体内可写 return [表达式] ，表示返回一个值，不写表达式相当于返回 None

def add(num1, num2):  # 自定义了一个名为 add 的函数，形式参数分别为 num1 和 num2
    num = num1 + num2
    print(num)

add(1, 2)  # 实际参数为 1 和 2。实际参数会传递给形式参数，再运行自定义函数 add 的代码

def add(num1, num2):
    num = num1 + num2
    return num  # 这里加了 return，即有返回值，可输出结果

print(add(1, 2))  # print 输出的是 return 的结果

def add(num1, num2):
    num = num1 + num2

print(add(1, 2))  # 相比上一个代码，这里没有返回值，所以用 print() 会输出 None

函数的参数

def add(num1, num2):  # 形式参数分别为 num1 和 num2。参数之间用逗号隔开
    num = num1 + num2
    print(num)

add(1, 2)  # 实际参数分别为 1 和 2。参数之间用逗号隔开。实际参数会传递给形式参数

位置参数（未命名参数）

def add(num1, num2):  # 形式参数分别为 num1 和 num2。参数之间用逗号隔开
    num = num1 + num2
    print(num)

add(1, 2)  # 第一个实际参数 1 传递给第一个形式参数 num1，第二个实际参数 2 传递给第二个形式参数 num2。从位置关系上看是一一对应的

关键字参数（命名参数）

def add(num1, num2, num3): 
    num = num1 + num2
    print(num)

add(1, num3 = 2, num2 = 3)  # 第一个实际参数 1 传递给第一个形式参数 num1；命名参数 c = 2 传递给形式参数 c；命名参数 b = 3 传递给形式参数 b。而不再是位置上的一一对应的关系
# 注意1：必须先写位置参数，再写关键字参数，否则报错
# 注意2：关键字参数的命名必须和形式参数的命名一致，否则报错

默认参数

def add(num1, num2, num3 = 3): 
    num = num1 + num2
    print(num)

add(1, num2 = 2)  # 当未指定实际参数时，使用默认参数 num3 = 3

函数的返回值

def add(num1, num2):
    num = num1 + num2
    return num  # 这里加了 return，即有返回值，可输出结果

print(add(1, 2))  # print 输出的是 return 的结果

函数的多个返回值

def print1(num1, num2):
    # return num1
	# return num2  不能写成这两行的样子，要写成下面这行的样子
    return num1, num2  # 这行代码是正确的,且返回类型为元组

print(print1(1,2))

函数的嵌套调用

一个函数内部还有函数，若不先调用外函数，则不会执行内函数

# 方法一
def func1():
    print('这是外部函数')
    def func2():
        print('这是内部函数')
    func2()
func1()  # 必须先调用外部函数，才会再调用内部函数

# 方法二
def func1():
    print('这是外部函数')
    def func2():
        print('这是内部函数')
    return func2
func1()()  # 等价于 func2()

函数的作用域

函数内部定义的变量名和外部定义的变量名不冲突

全局变量和局部变量

• 在函数内部定义的，为局部变量；在函数外部定义的，为全局变量
• 局部变量只能在函数内部使用；而全局变量可在整个程序内使用
• 局部变量的优先级高于全局变量

a = 1  # 全局变量 a = 1

def func1():
    a = 2  # 局部变量 a = 2
    print(a)  # 输出的是函数内部的 a，所以是 2
    return a

func1()  # 调用函数，使用局部变量 a = 2
print(a)  # 输出的是全局变量的 a = 1

提升变量作用域

a = 1

def func1():
    global a  # 将局部变量 a 声明为全局变量。所以输出结果为 2
    a = 2
    print(a)
    return a

func1()
print(a)

高阶函数

一个函数的函数名作为参数传给另一个函数，或者一个函数的返回值为另一个函数（若返回值为该函数本身，则为递归），满足其一即为高阶函数

# 一个函数的函数名作为参数传给另一个函数
def func1():
    print('这是一个普通函数')
    
def high_func1(func1):
    print('这是一个高阶函数')
    func1()

high_func1(func1)  # 该参数名为函数名 func1

# 一个函数的返回值为另一个函数
def func1():
    print('这是一个普通函数')
    
def high_func1(func1):
    print('这是一个高阶函数')
    return func1  # 该返回值为另一个函数 func1

result = high_func1(func1)
result()