耗时600小时整理《Python教程全套》完全入门版，分享一起学习_高清附字幕

〇、前言

1. 关于笔记

笔记从WPS复制到B站的，没有文字大小和颜色

笔记中前面带#的是注释内容

目前已完结(P6-P169)

因为B站笔记只能记20000字，这里的笔记从原笔记删去近一半内容。几乎没有示例内容，没有二十四章、函数及以后内容

关于WPS笔记和一些其他内容，可以通过下面的百度网盘链接下载

https://pan.baidu.com/s/1fTwjyoM81_OOAccPNhGE9Q?pwd=h3fg

笔记中如果有错误的地方欢迎在评论区指正

2. 关于扩展

2.1. 扩展大多数只扩展基本概念和用法

2.2. 一部分注释也可以当做扩展

2.3. 关于扩展的内容

部分内容转摘或摘编自以下网站：

菜鸟教程：https://www.runoob.com/

C语言中文网：http://c.biancheng.net/

部分内容来源网络、来源视频或自我理解

一、输出函数print()

1. print()函数输出内容

数字

字符串

含有运算符的表达式

2. print()函数输出目的地

显示器

文件

3. print()函数输出形式

换行

不换行

4. 补充

a+的含义：如果文件不存在就创建，存在就在文件内容的后面继续追加

内置函数：不需要前面加任何前缀，直接可以使用的函数

二、转义字符与原字符

(1)、转义字符

1. 组成

反斜杠(\)+想要实现的转义功能首字母

2. 作用

2.1. 当字符串中包含反斜杠(\)、单引号和双引号(' ")等有特殊用途的字符时、必须使用反斜杠(\)进行转义（转换一个含义）

示例：

反斜杠:\\

单引号:\'

双引号:\"

2.2. 当字符串中包含换行、回车、水平制表位或退格等无法直接表示的特殊字符时，也可以使用转义字符

示例：

换行:\n (newline)

回车:\r (return)

水平制表位:\t (tab)

# \t占4个字符的位置

退格:\b (back space)

(2)、原字符

1. 含义

不希望字符串中的转义字符起作用,让转义字符不起作用的叫原字符

2. 使用

在字符串之前加上r或R

示例：

print(r'hello\nworld')

print(R'hello\nworld')

3. 注意事项

最后一个字符不能是反斜杠(\)

示例：

错误示范:print(r'hello\nworld\')

正确示范:print(r'hello\nworld\\')

三、二进制与字符编码

(1)、二进制

1. 计算机换算单位

8位(8bit)->1字节(1byte)  # 8位指8个位置

1024字节(1024byte)->1千字节(1KB)

1024千字节(1024KB)->1兆字节(1MB)

1024兆字节(1024MB)->1吉字节(1GB)

1024吉字节(1024GB)->1太字节(1TB)

扩展：

1024太字节(1024TB)->1拍字节(1PB)

1024拍字节(1024PB)->1艾字节(1EB)

位(bit)<字节(byte)<千字节(KB)<兆字节(MB)<吉字节(千兆字节GB)<太字节(TB)<拍字节(PB)<艾字节(EB)

2. 二进制的转换

2.1. 什么是位

在计算机中的二进制数系统中，每个0或1就是一个位(bit)

2.2. 8位

二位用0和1组合可表示4种状态，八位用0和1组合可以表示256种状态(28)，八位的256种状态对应现实生活中的256种符号(ASCII码表)

2.3. 十进制的转换

使用电脑上的计算器（或在运行里输入calc），在查看里点击程序员型

2.4. 使用python进行字符转换

二进制转字符:

print(chr(0b二进制))

字符转十进制:

print(ord('字符'))

(2)、字符编码

1. 二进制与字符编码

二进制0和1->ASCII码表

    ->GB2312(80后)->GBK(90后)->GB18030(00后)

# 80后只能表示简体中文，90后能表示繁体中文，00后能表示少数民族文字

    ->其他国家的字符编码

——>(统一)Unicode(中英都用2个字节)->UTF-8(中文3个字节，英文1个字节)

2. 字符的表示

字符可以用二进制、八进制、十进制或十六进制表示，但最终到计算机会变成二进制，因为计算机只识别二进制

四、Python中的标识符和保留字

(1)、保留字

1. 什么是保留字

有些单词被python赋予特定的意义，这些单词在给python文件命名或给变量起名时不允许使用

2. 保留字有哪些

在python中输入：

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']

(2)、标识符

1. 什么是标识符

在给变量、函数、类、模块和其他对象起名字的名字就叫标识符（需要你自己命名字的）

2. 标识符的规则

可以使用字母、数字、下划线

不可以使用数字开头

不可以使用保留字

严格区分大小写

# Python3中可以使用汉字作为标识符，但不建议使用或避免使用

五、变量的定义和使用

1. 定义

可以改变的量

2. 使用

变量名(标识符)+赋值运算符+值

3. 组成

# obj->对象

标识：表示对象所储存的内存地址，使用内置函数id(obj)来获取

类型：表示对象的数据类型，使用内置函数type(obj)来获取

值：表示对象所储存的具体数据，使用print(obj)可以将值进行打印输出

六、变量的多次赋值

1. 什么是多次赋值

多次赋值指给一个变量多次赋值

2. 多次赋值的结果

当多次赋值之后，变量名会指向新的空间

七、数据中常见的数据类型

(1)、整数类型(int)

1. 表示

表示正数、负数和零

表示进制：

十进制->默认的进制

二进制->以0b开头

八进制->以0o开头

十六进制->以0x开头

(2)、浮点数类型(float)

1. 组成

浮点数是由整数部分和小数部分组成

2. 问题

浮点数储存不精确，原因是计算机是使用二进制存储的，所以在存储浮点数时不精确

# 不是所有浮点数计算都有问题

3. 解决办法

通过导入模块decimal来解决浮点数的问题

(3)、布尔类型(bool)

1. 表示

表示真或假的值

True表示真，False表示假

布尔值可以转化为整数

True->1 False->0

(4)、字符串类型(str)

1. 定义

· 字符串又被称为不可变的字符序列

· 可以使用单引号''双引号''''三引号''''''或""""""来定义

· 单引号和双引号定义的字符串必须在一行

· 三引号定义的字符串可以分布在连续的多行

八、数据类型转换

(1)、为什么需要数据类型转换

将不同数据类型的数据拼接在一起

(2)、str()函数与int()函数

1. 不同类型进行连接时报错

str与int连接时会报错

2. 解决方案

2.1. 将其他数据类型转成字符串类型：str()函数

2.2. 将其他数据类型转成整数类型：int()函数

(3)、float()函数

1. 作用

将其他数据类型转成浮点数类型

2. 注意事项

· 文字类无法转成整数

· 整数转成浮点数，末尾为“.0”

(4)、总结

将其他数据转成字符串

str()

将其他数据转成整数

int()

将其他数据转成浮点数

float()

扩展：

将其他数据转成布尔值

bool()  # 值是True或False，具体在“十三、对象的布尔值”会讲

九、Python中的注释

1. 注释是什么

· 在代码中对代码的功能进行解释说明的标注性文字，可以提高代码的可读性

· 注释内容会被Python解释器忽略

2. 注释的类型

2.1. 单行注释

以“#”开头，直到换行结束

示例：

# 单行注释

2.2. 多行注释

并没有单独的多行注释标记，将一对三引号(''''''或"""""")之间的代码称为多行注释

示例：

'''多行

注释'''

"""多行

注释"""

2.3. 中文编码声明注释

在文件开头加上中文声明注释，用以指定源码文件的编码格式

python中默认的存储编码是UTF-8

更改：

在前面写上一句代码

# coding:编码

示例：

# coding:utf-8

十、input()函数

(1)、input()函数的基本使用

1. 作用

接收来自用户的输入

2. 使用

变量+赋值运算符+input(提问)

# 提问是在输入之前程序给你的一个提示语，根据提示语输入一个数据

(2)、input()函数的高级使用

录入两个整数，计算两个整数的和

a = input('请输入第一个加数')

b = input('请输入第二个加数')

方法1：

print(int(a)+int(b))

方法2：

a = int(a)

b = int(b)

print(a+b)

运行结果：

请输入第一个加数100

请输入第二个加数200

300

十一、Python中常用的运算符

(1)、算术运算符

1. 标准算术运算符

加(+)、减(-)、乘(*)、除(/)、整除(//)

# 整除是指两个数相除，结果为向下取整

2. 取余运算符(取模运算)

%  # 取模，返回两个数相除的余数

3. 幂运算符

**

4. 一正一负的整除和取余

4.1. 整除时结果向下取整

4.2. 取余时要公式：余数=被除数-除数*商

(2)、赋值运算符(=)

1. 执行顺序

从右到左

2. 支持内容

2.1. 支持链式赋值：a = b = c = 10

# 实际只有一个整数对象，却有三个引用

2.2. 支持参数赋值：+=、-=、*=、/=、//=、%=

2.3. 支持系列解包赋值：a, b, c = 1, 10, 100

# 等号左右两边的个数要相同

# 实际上为将100赋值给c，10赋值给b，1赋值给a

交换两个变量的值：

a, b = b, a

(3)、比较运算符

1. 作用

对变量或表达式的结果进行大小、真假等比较，结果为布尔类型bool(True,False)

2. 比较运算符（比较值value）

>：大于

<：小于

>=：大于等于

<=：小于等于

!=：不等于  # 不等于为True，等于为False

==：等于  # ==比较的是值(value)

# 一个等号为赋值运算符，两个等号为比较运算符

3. 比较运算符（比较标识id）

is：是

is not：不是

(4)、布尔运算符

1. 作用

对布尔值(True,False)之间进行运算

2. 布尔运算符

and：当两个运算数都为True才为True，其余为False

or：当两个运算数都为False才为False，其余为True

not：如果运算数为True/False，运算结果为False/True

in：如果x在x里面为True，反之False

not in：如果x不在x里面为True，反之False

(5)、位运算符

1. 作用

将数据转成二进制进行计算

2. 位运算符

按位与(&)：对应数位都是1，结果数位为1，否则为0

按位或(|)：对应数位都是0，结果数位为0，否则为1

左移位(<<)：高位溢出舍弃，低位补0

右移位(>>)：低位溢出舍弃，高位补0

(6)、运算符的优先级

1. 优先级

算术运算【(**)->(*,/,//,%)->(+,-)】

->位运算【(<<,>>)->(&)->(|)】

->比较运算【(>,<,>=,<=,==,!=)】

->布尔运算【(and)->(or)】

->赋值运算符【(=)】

2. 有括号()

有括号的时候会先计算括号中的内容

十二、程序的组织结构

1. 顺序结构

程序从上到下顺序地执行代码，中间没有任何的判断和跳转，直到程序结束

2. 分支结构（选择结构）

3. 循环结构

# 分支结构（选择结构）和循环结构后面会说

十三、对象的布尔值

1. 对象

Python中一切皆对象，所有对象都有一个布尔值(True,False)

2. 获取对象的布尔值

使用内置函数bool()

3. 布尔值为False的对象

False

数值0

None

空字符串

空列表

空元组

空字典

空集合

# 除以上的对象，其他对象的布尔值都为True

十四、分支结构(选择结构)

(1)、单分支结构

1. 什么是分支结构(选择结构)

程序根据判断条件的布尔值选择性地执行部分代码，明确的让计算机知道在什么条件下，该去做什么

2. 单分支结构的语法

中文语义：如果......就......

语法结构：

if 条件表达式:

    条件执行体

# 如果条件表达式为True就执行条件执行体，如果为False就不执行

(2)、双分支结构

1. 中文语义

如果......不满足......就......

示例：

如果n>1为True,不是就为False

2. 语法结构

if 条件表达式:

    条件执行体1

else:

    条件执行体2

# 如果条件表达式为True就执行条件执行体1，如果为False就执行条件执行体2

(3)、多分支结构

1. 中文语义

是...... 不是

是...... 不是

......

是...... 是

2. 语法结构

if 条件表达式1:  # 注意冒号

    条件执行体1

elif 条件表达式2:  # elif是else和if的简写

    条件执行体2

elif 条件表达式N:

    条件执行体N

else:

条件执行体N+1

# 如果条件表达式1为True就执行条件执行体1，后续的不作判断。如果为False就判断条件表达式2，以此类推

扩展：elif与if的区别：

if判断完条件表达式1后，后续的继续判断

elif判断完条件表达式1后，后续的不作判断

两者判断条件表达式都为False才会执行else的语句

(4)、嵌套if的使用

1. 语法结构

if 条件表达式1:

if 内层条件表达式:

内存条件执行体1

else:

内存条件执行体2

else:

条件执行体

# 红色的是一对，称为Y分支结构。蓝色的是一组，蓝色的是给红色if为Ture的时候去做的一个条件执行体

(5)、条件表达式

1. 什么是条件表达式

条件表达式是if......else的简写  # 用于简化代码

2. 语法结构

x if 判断条件 else y  # 这里空格随意,但至少空一格

3. 运算规则

如果判断条件的布尔值为True，条件表达式的返回值为x。否则条件表达式的返回值为False

十五、pass语句

1. 作用

pass语句什么都不做，只是一个占位符，用在语法上需要语句的地方

2. 什么时候用

在搭建语法结构时，还没想好代码怎么写的时候使用

3. 跟那些语句一起使用

if语句的条件执行体

for-in语句的循环体

定义函数时的函数体

十六、range()函数的使用

1. 作用

用于生成一个整数序列出 # 序列指的是被排成一列的对象

2. 创建range对象的三种方式

2.1. range(stop)：创建一个[0,stop)之间的整数序列，步长为1

2.2. range(start,stop)：创建一个[start,stop)之间的整数序列，步长为1

2.3. range(start,stop,step)：创建一个[start,stop)之间的整数序列，步长为step

# [指的是大/小于等于，(指的是大/小于，所以在这个整数序列中包含start但不包含stop，也就是半开半闭区间。步长指的是相邻的两个数相差多少，默认为1。start、stop和step必须为整数。

3. in与not in

可以使用in与not in判断整数序列中是否存在(不存在)指定的整数

4. range类型的优点

不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为只需要存储start、stop和step，只有当用到range对象时，才会去计算序列中的相关元素

十七、循环结构

(1)、循环

反复做同一件事情的情况，称为循环

(2)、while循环

1. 语法结构

while 条件表达式:

    条件执行体(循环体)

# 如果条件表达式的值为True，就执行条件执行体，然后继续判断条件表达式。如果为Fasle就结束循环

2. if与while的区别

if只判断一次，条件为True执行一行

while判断N+1次，条件为True执行N次

3. 四步循环法

· 初始化变量

· 条件判断

· 条件执行体(循环体)

· 改变变量

(3)、for-in循环

1. in

in表达从(字符串、序列等)中依次取值，又称为遍历

for-in遍历的对象必须是可迭代对象

# 目前已学的当中，只有两个可迭代对象：字符串与序列

2. 语法结构

for 自定义的变量 in 可迭代对象:

循环体

# 每一次循环取一个值，依次取值，直到结束

# 如果不需要自定义变量，可将自定义变量写为下划线_

十八、流程控制语句

(1)、break语句

1. 作用

用于结束循环结构，通常与分支结构if一起使用

# 执行到break会跳出循环，叫做非正常结束循环

2. 示意图

2.1. for-in：

2.2. while：

(2)、continue语句

1. 作用

用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用

2. 示意图

2.1. for-in:

2.2. while:

(3)、else语句

1. else语句配合使用的两种情况

1.1. 与if配合使用：if条件表达式不成立时执行else

1.2. 与while或for-in配合使用：没有碰到流程控制语句时执行else

# 第二种情况也可以不用else，直接在后面写

# 以下内容属于"十七、循环结构"

(4)、嵌套循环

1. 什么是嵌套循环

循环结构中又嵌套了另外的完整的循环结构，其中内层循环做为外层循环的循环的循环体执行

# 在循环中执行循环

扩展：

end='\t'

print()函数默认是end='\n'(末尾换行)。end='\t'把末尾改为TAB，从而使不换行。同样也可以改为end=' '，使末尾加一个空格字符，也不会换行。

(5)、二重循环中的break与continue

二层循环中的break和continue用于控制本层循环

# 内层循环中的break和continue不影响外层循环的继续执行

十九、列表

(1)、为什么需要列表

1. 存储

变量可以存储一个元素(对象)，列表可以存储N多个元素(对象)，程序可以方便地对这些数据进行整体操作

2. 在其他语言中

列表相当于其他语言中的数组

(2)、列表对象的创建

1. 使用中括号创建

列表对象名+赋值号+中括号  # 元素之间使用英文的逗号进行分隔

示例：

A = [1, 2.0, '3']

2. 调用内置函数list()

list([])

示例：

A = list([1, 2.0, '3'])

3. 空列表

创建一个空列表

列表对象名=[]

列表对象名=list()

(3)、列表的特点

1. 列表元素按顺序有序排序

列表中每个元素有序排序，不会无序排序

2. 索引映射唯一一个数据

列表中每个元素通过索引去获取，索引从0开始(从前往后)，或从-1开始(从后往前)，通过索引可定位唯一一个元素

3. 列表可以存储重复数据

列表可以存储重复的数据，不论多少个

4. 任意数据类型可以混存

列表可以存储不同的数据类型，具有更大的包容性

5. 根据需要动态分配和回收内存

无论存多少个元素，都会根据多少动态分配内存空间

(4)、列表元素的查询操作

1. 获取列表中指定元素的索引

使用index()来获取：列表名.index(元素)

1.1. 如查列表中存在N个相同元素,只返回相同元素中的第一个元素的索引

1.2. 如查询的元素在列表中不存在，则会抛出ValueError

1.3. 还可以在指定的start和stop之间进行查找(在指定范围查找)

# index(元素,start,stop) 不包括stop

2. 获取列表中的单个元素

列表名[]

2.1. 正向索引

从0到N-1  # N为元素的个数

2.2. 逆向索引

从-N到-1

2.3. 指定索引不存在

抛出IndexError

3. 获取列表中的多个元素(切片操作)

3.1. 语法格式

列表名[start:stop:step]

# 关于strat,stop和step到十六、range()函数的使用查看

# 切片在列表的增加操作、删除操作与修改操作也有涉及

3.2. 切片的结果

原列表片段的拷贝  # 新切出来的是一个新的列表对象

3.3. 切片的范围

[strat,stop)

3.4. 切片中的step

step默认为1  # 简写为[start:stop]

3.4.1. step为正数：

[:stop:step]

strat不写，切片的第一个元素默认是列表的第一个元素

[strat::step]

stop不写，切片的最后一个元素默认是列表的最后一个元素

# 以上都是从start开始往后计算切片的

3.4.2. step为负数：

[:stop:step]

strat不写，切片的第一个元素默认是列表的最后一个元素

[strat::step]

stop不写,切片的最后一个元素默认是列表的第一个元素

# 以上都是从start开始往前计算切片的，而且不包括stop

4. 判断指定元素在列表中是否存在

使用in或not in：

元素 in 列表名

元素 not in 列表名

5. 列表元素的遍历

使用for-in循环：

for 自定义变量 in 列表名(可迭代对象):

    操作

(5)、列表元素的增加操作

# 以下操作是在原列表的基础上增加元素，不会产生新的列表对象

1. append()

在列表的末尾添加一个元素

列表名.append(元素)

2. extend()

在列表的末尾添加至少一个元素

列表名.extend(元素)

3. append与extend的区别

append是向末尾只添加一个元素，而extend是向末尾添加多个元素

4. insert()

在列表的任意位置添加一个元素

列表名.insert(索引,元素)

5. 切片

在列表的任意位置添加至少一个元素

列表名[start:stop:step]=元素  # 不包括stop

6. insert与切片的区别

insert是只向任意位置添加一个元素，而切片是切掉一部分元素换成另外一部分元素

(6)、列表元素的删除操作

1. remove()

· 一次删除一个元素

· 重复元素只删除第一个

· 元素不存在抛出ValueError

· 不会产生新的列表对象

列表名.remove(元素)

2. pop()

· 删除一个指定索引位置上的元素

· 指定索引不存在抛出IndexError

· 不指定索引，删除列表中最后一个元素

· 不会产生新的列表对象

列表名.pop(索引)

3. 切片

· 一次至少删除一个元素

· 会产生新的列表对象，原列表不会改变

· 用[](空列表)进行替掉时，不产生新的列表对象，而是删除原列表中的内容

新列表名=原列表名[start:stop:step]

原列表名[start:stop:step]=[]

4. clear()与del

clear是清除列表，将列表中的元素清除掉

列表名.clear()

del是删除列表，会删除整个列表对象

del 列表名

(7)、列表元素的修改操作

1. 指定索引的元素赋予一个新值

列表名[索引]=元素(新值)

2. 指定的切片赋予一个新值

列表名[start:stop:step]=元素(新值)

# 这里的start、stop和step与前面切片操作相同

(8)、列表元素的排序操作

对列表当中的元素进行由小到大，或由大到小的一个排序操作

常见的两种方式：

1. 调用sort()方法

对列表中的所有元素默认按照从小到大的顺序进行排序

列表名.sort()

2. 调用内置函数sorted()

对列表中的所有元素默认按照从小到大的顺序进行排序，原列表不发生改变，会产生新的列表对象

sorted(列表名)

3. reverse

· 可以指定reverse=True来进行降序排序

· reverse默认为False，为升序排序

列表名.sort(reverse=True)

sorted(列表名,reverse=True)

4. 注意事项

int类型与str类型，str类型与bool类型之间不能进行排序

(9)、列表生成式

1. 什么是列表生成式

生成列表的一个公式的简称

2. 语法格式

[i*i for i in range(1,10)]

[表示列表元素的表达式 for 自定义变量 in 可迭代对象]

# “表示列表元素的表达式”中通常包含“自定义变量”

二十、字典

(1)、什么是字典

1. 字典

· 字典是Python内置的数据结构之一，与列表一样是一个可变序列

# 可变序列指数据结构可执行增删改操作

· 字典是由花括号{}定义的

· 以键值对(键:值)的方式存储数据，字典是一个无序(无顺序排列)的序列

# 键值对指的是一对一对存储的元素

字典名={键:值,键:值......}

2. 字典示意文本

hash(key3) key3->value3

hash(key4) key4->value4

 

hash(key1) key1->value1

hash(key5) key5->value5

hash(key2) key2->value2

# key1,2,3,4,5指的是第几个放入字典中的键

# 字典是无序的序列，因为要经过hash函数的工序(->把键放在hash函数之中去计算(计算：你要进行存储的位置))，所以键的位置是通过hash函数计算得来的

# 因为是hash函数计算得来的，所以要求放在字典中的键必须是一个不可变序列(创建之后不可修改),否则具有不确定因素(键改变)，例如整数序列和字符串就是不可变序列

(2)、字典的实现原理

字典的实现原理与查字典类似，Python中的字典是根据key查找value所在的位置

# hash函数类似查字典时的找部首和算笔画

(3)、字典的创建

1. 使用花括号创建

字典名={键:值,键:值......}

2. 使用内置函数dict()创建

dict(键=值,键=值......)

# 这里的键由于是赋值形式，所以左侧的键不加任何符号

3. 空字典

创建一个空字典

字典名={}

字典名=dict()

# 相同的键会变成一个，也就是不能重复

(4)、字典的常用操作

1. 字典中元素的获取

1.1. []

字典名[键]

1.2. get()方法

字典名.get(键)

1.3. []与get()的区别

如果查找的键不存在，[]会报错(KeyError)，get()不会报错，会输出一个None，如果指定了默认值，就会在键值不存在时返回默认值

字典名.get(键,默认值)

2. 字典元素的增删改以及判断操作

2.1. key的判断

使用in或not in判断指定的键在字典中是否存在

键 in 字典名/键 not in 字典名

2.2. 字典元素的删除

使用del语句删除指定的键值对

del 字典名[键]

# 同样可以用clear清空字典的元素与del删除字典：字典名.clear(),del 字典名

# 也可以使用 字典名.pop(键) 与del的区别是pop有返回值，del直接删除

2.3. 字典元素的新增和修改

字典名[键]=值

3. 获取字典视图

3.1. keys()

获取字典中所有key，数据类型为dict_keys

字典名.keys()

3.2. values()

获取字典中所有value，数据类型为dict_values

字典名.values()

3.3. items()

获取字典中所有key,value对，数据类型为dict_items

字典名.items()

# items()获取的键值对是元组形式的

# 可以使用list函数将字典视图转为列表

4. 字典元素的遍历

for item in 字典名:

    print(item)

# item(自定义变量)获取的是字典当中的键，如果要获取值，可以使用 字典名[item] 或 字典名.get(item)

(5)、字典的特点

· 字典中的所有元素都是一个key-value对(键值对)，key不允许重复，重复将会覆盖，value可以重复

· 字典中的元素是无序的

· 字典中的key必须是不可变对象

· 字典也可以根据需要动态地伸缩，内存随着元素的加或减而加或减

· 字典会浪费较大的内存，但查询速度快，是一种使用空间换时间的数据结构

(6)、字典生成式

1. 内置函数zip()

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表，返回的元素个数以少的那个为基准

2. 字典生成式

将两个列表中的第一个(items)作为字典中的key，第二个(prices)作为字典中的value

{表示字典key的表达式:表示字典value的表达式 for 自定义表示key的变量,自定义表示value的变量 in zip(可迭代对象,可迭代对象)}

{item.upper():price for item,price in zip(items,prices)}

二十一、元组

(1)、什么是元组

1. 元组

元组是Python内置的数据结构之一，是一个不可变序列

元组名=(元素对象,元素对象,元组对象......)

2. 不可变序列与可变序列

不可变序列：字符串、元组等，没有增、删、改操作

可变序列：列表、字典等，可以对序列执行增、删、改操作，对象地址不发生更改

(2)、元组的创建方式

1. 创建方式

1.1. 直接使用小括号()

元组名=(元素对象,元素对象,元组对象......)

1.2. 使用内置函数tuple()

元组名=tuple((元素对象,元素对象,元组对象......))

# 如果是单层括号，里面要是可迭代对象(列表、元组、字典、字符串)：

元组名=tuple(可迭代对象)

1.3. 空元组

创建一个空元组

元组名=()

元组名=tuple()

2. 注意事项

如果元组当中只包含一个元素，需要使用逗号和小括号(如果没逗号会被认为是本身的数据类型)

元组名=(元素对象,)

3. 关于元组的索引与切片

元组也有索引与切片，其用法与列表相同，用于获取元素或索引

(3)、元组为什么要设计成不可变序列

1. 原因

· 避免由于修改数据而导致出错

· 在多任务环境下，同时操作对象时不需要加锁

# 多个操作同时进行，不需要依次进行

· 因此，在程序中尽量使用不可变序列

2. 注意事项

元组中存储的是对象的引用

· 如果元组中对象是不可变对象，则不能再引用其它对象

· 如果元组中对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

(4)、元组的遍历

元组是可迭代对象，所以可以使用for...in进行遍历

for item in 元组名:

print(item)

# item是自定义变量

二十二、集合

集合的概述与创建

1. 集合的概述

· Python语言提供的内置数据结构

· 与列表、字典一样都属于可变类型的序列

· 集合是没有value的字典，所以集合也是一个无序的序列

· 集合也是由花括号{}定义的

2. 示意文本

hash(dataE)->dataE

hash(dataB)->dataB

 

hash(dataA)->dataA

hash(dataC)->dataC

hash(dataD)->dataD

# ABCDE是向集合中添加元素的顺序，同样也是hash函数计算位置

3. 集合的创建

3.1. 使用花括号{}创建

集合名={元素,元素,元素......}

# 集合中的元素不允许重复，否则重复的变为一个

3.2. 使用内置函数set()

集合名=

set(range(4))  # range

set([1,2,3])  # 列表

set((1,2,3))  # 元组

set('ABC')  # 字符串，元素为'A','B','C'

set({1,2,3})  # 集合

3.3. 空集合

定义一个空集合

集合名=set()  # 如果是={}，类型为字典

(1)、集合的相关操作

1. 集合元素的判断操作

使用in或not in检查集合中是否存在指定的元素

2. 集合元素的新增操作

2.1. 调用add()方法，添加一个元素

集合名.add(元素)

2.2. 调用update()方法，至少添加一个元素

· 集合名.update({元素,元素......}) # 集合

· 集合名.update([元素,元素......]) # 列表

...... # 与上面set创建类似，也可以添加字符串和元组等

# 关于一个和至少一个，可以参照列表元素的增加操作

3. 集合元素的删除操作

3.1. 调用remove()方法，一次删除一个指定元素，如果不存在抛出KeyError

集合名.remove(元素)

3.2. 调用discard()方法，一次删除一个指定元素，如果不存在不会抛异常

集合名.discard(元素)

3.3. 调用pop()方法，一次只删除一个任意元素

集合名.pop()

3.4. 调用clear()方法，清空集合

集合名.clear()

3.5. 调用del方法，删除集合

del 集合名

(2)、集合间的关系

1. 判断两个集合是否相等

可以使用运算符==或!=进行判断

集合A ==/!= 集合B

2. 判断一个集合是否是另一个集合的子集

# 子集定义：一般地，对于两个集合A，B，如果集合A中任意一个元素都是集合B中的元素，我们就说这两个集合有包含关系，称集合A为集合B的子集，

记作A⊆B（或B⊇A），读作“A含于B”（或“B包含A”）

注：子集定义转摘自《数学 必修1A版/普通高中课程标准实验教科书》，下面的交集定义、并集定义同上

可以调用方法issubset进行判断

集合A.issubset(集合B) # 集合A是否是集合B的子集，返回布尔值

3. 判断一个集合是否是另一个集合的超集

# 超集定义：集合A中的每一个元素都在集合B中，且集合A中可能包含B中没有的元素，那么集合A就是集合B的超集，相当于子集反过来

可以调用方法issuperset进行判断

集合A.issuperset(集合B)  # 集合A是否是集合B的超集，返回布尔值

4. 判断两个集合是否没有交集

# 交集定义：一般地，由属于集合A且属于集合B的所有元素组成的集合，称为A与B的交集，记作A∩B（读作“A交B”）

可以调用方法isdisjoint进行判断

集合A.isdisjoint(集合B)  # 集合A与集合B是否没交集，返回布尔值

(3)、集合的数学(数据)操作

1. 两个集合的交集操作

调用方法intersection或&进行交集操作

集合A.intersection(集合B)/集合A & 集合B

# &在Python集合中是求交集的意思

# 输出集合A与集合B的交集部分

2. 两个集合的并集操作

# 并集定义：一般地，由所有属于集合A或属于集合B的元素组成的集合，称为集合A与集合B的并集，记作A∪B（读作“A并B”）

调用方法union或|进行并集操作

集合A.union(集合B)/集合A | 集合B

# |在Python集合中是并集的意思

# 输出集合A与集合B所有的元素，去掉重复元素

3. 两个集合的差集操作

# 差集定义：设A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A与集合B的差集，记作A-B

调用方法difference或-进行差集操作

集合A.difference(集合B)/集合A-集合B

# -在Python集合中是差集的意思

# 输出集合A与集合B的差集部分(集合A中的元素-与集合B交集的部分)

4. 两个集合的对称差集操作

# 对称差集定义：设A，B是两个集合,则集合A与集合B中所有不属于A与B并集的元素构成的集合为集合A与集合B的对称差集(A∪B)—(A∩B)，记作A△B

调用方法symmetric_difference或^进行对称差集操作

集合A.symmetric_difference(集合B)/集合A^集合B

# ^在Python集合中是对称差集的意思

# 输出集合A与集合B的对称差集(集合A与集合B的并集和集合A与集合B的交集的差集)

5. 集合生成式

# 集合生成式跟列表生成式类似，就是将[]改成{}

5.1. 概念

用于生成集合的公式

5.2. 语法格式

{i*i for i in range(1,10)}

{表示集合元素的表达式 for 自定义变量 in 可迭代对象}

(4)、列表、元组、字典、集合总结

Python四种常用的数据结构

数据结构

是否可变

是否重复

是否有序

定义符号

列表(list)

可变

可重复

有序

[]

元组(tuple)

不可变

可重复

有序

()

字典(dict)

可变

key不可重复

无序

(key:value)

value可重复

集合(set)

可变

不可重复

无序

{}

二十三、字符串

(1)、字符串的创建与驻留机制

1. 字符串

在Python中字符串是基本数据类型，是一个不可变的字符序列

2. 定义(创建)字符串

使用单引号(')、双引号(")以及三引号进行定义

3. 字符串驻留机制

仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量

3.1. 驻留机制的几种情况（使用交互模式）

# win+r输入cmb再输入py进入（PyCharm里Alt+F12再输入py也可以进入）

· 字符串的长度为0或1时

· 符合标识符的字符串 # 有关标识符可在前面第四章找到

· 字符串只在编译时进行驻留，而非运行时

· [-5,256]之间的整数数字 # 包括256

扩展：join()方法：

将序列中的元素以指定的字符连接生成一个新的字符串

字符串.join(序列)

# 具体在本章（2）中的6.2查看

3.1.1. sys中的intern方法强制2个字符串指向同一个对象

import sys # 导入sys模块

变量A=sys.intern(变量B)

3.1.2. PyCharm对字符串进行了优化处理

将一些原本不驻留的处理成驻留的

4. 字符串驻留机制的优缺点

· 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。

· 在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只创建一次对象，效率要比“+”效率高

(2)、字符串的常用操作

1. 字符串的查询操作

1.1. index()

查找子串(substr)第一次出现的位置，如果查找的子串不存在时，则抛出ValueError

字符串.index(字符串)

1.2. rindex()

查找子串(substr)最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError

字符串.rindex(字符串)

1.3. find()

查找子串(substr)第一次出现的位置，如果查找的子串不存在时，则返回-1

字符串.find(字符串)

1.4. rfind()

查找子串(substr)最后一次出现的位置，如果查找的子串不存在时，则返回-1

字符串.rfind(字符串)

2. 字符串的大小写转换操作

2.1. upper()

把字符串中所有字符都转成大写字母

字符串.upper()

2.2. lower()

把字符串中所有字符都转成小写字母

字符串.lower()

2.3. swapcase()

把字符串中所有大写字母转成小写字母，把所有小写字母都转成大写字母

字符串.swapcase()

2.4. capitalize()

把第一个字符转换为大写，把其余字符转换为小写

字符串.capitalize()

2.5. title()

把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写

字符串.title()

# 字符串是不可变序列，转换后产生一个新的字符串对象

3. 字符串内容对齐操作

3.1. center()

居中对齐

字符串.center(整数,字符串)

第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于等于实际宽度则返回原字符串

3.2. ljust()

左对齐

字符串.ljust(整数,字符串)

第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于等于实际宽度则返回原字符串

3.3. rjust()

右对齐

字符串.rjust(整数,字符串)

第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于等于实际宽度则返回原字符串

3.4. zfill()

右对齐，左边用0填充

字符串.zfill(整数)

该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身

# zfill()在字符串前有“-”或“+”时，0加在符号右边

4. 字符串的劈分

4.1. split()

· 从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表

· 通过参数sep指定劈分字符串的劈分符

· 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部分

字符串.split(sep=字符串,maxsplit=整数)   

# ()里可选，默认劈分符和劈分次数，并且sep和maxsplit可以不写：

字符串.split(字符串,整数)

4.2. rsplit()

· 从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表

· 通过参数sep指定劈分字符串的劈分符

· 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部分

字符串.rsplit(sep=字符串,maxsplit=整数)

5. 字符串的判断操作

5.1. isidentifier()

判断指定的字符串是不是合法的标识符

字符串.isidentifier()

5.2. isspace()

判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）

字符串.isspace()

5.3. isalpha()

判断指定的字符串是否全部由字母组成

字符串.isalpha()

# 由汉字组成也返回True

5.4. isdecimal()

判断指定的字符串是否全部由十进制的数字组成

字符串.isdecimal()

5.5. isnumeric()

判断指定的字符串是否全部由数字(字符)组成

字符串.isnumeric()

# 罗马数字，汉字数字等也属于数字

5.6. isalnum()

判断指定的字符串是否全部由字母和数字组成

字符串.isalnum()

6. 字符串的替换与合并操作

6.1. 字符串的替换：replace()

字符串.replace(字符串,字符串,整数)

# 整数参数可选，默认最大次数

第1个参数指定被替换的子串，第2个参数指定替换子串的字符串，第3个参数指定最大替换次数，该方法返回替换后得到的字符串，替换前的字符串不发生变化

6.2. 字符串的并合：join()

将列表或元组中的字符串以指定的字符合并成一个新字符串

字符串.join(序列)

# 序列还可以是字典、集合或字符串，但字典只对键进行连接，集合是无序的，字符串作为字符串序列

(3)、字符串的比较操作

1. 运算符

>,>=,<,<=,==,!=

2. 比较规则

首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较

3. 比较原理

两个字符进行比较时，比较的是其ordinal value(原始值)，调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value可以得到其对应的字符

ord(字符串)

chr(整数)

4. ==与is的区别

==比较的是value是否相等

is比较的是id是否相等

(4)、字符串的切片操作

# 索引和切片具体可以到第十九章（4）中的2、3查看

· 字符串是不可变序列

· 不具备增、删、改等操作

· 切片操作将产生新的对象

字符串[start:end:step]

(5)、格式化字符串

1. 格式化字符串

按一定格式输出的字符串，实际上就是一个字符串的拼接操作

2. 为什么需要格式化字符串

减少内存空间浪费

3. 格式化字符串的方式

3.1. %作占位符

定义的格式化字符串%(实际值,实际值...)

定义的格式化字符串每个%的位置与后面的实际值的位置相对应

%s：字符串

%i或%d：整数

%f：浮点数

3.2. {}作占位符

定义的格式化字符串.format(实际值,实际值...)

定义格式化字符串每个{}里的数字与后面实际值的正向索引相对应

# {}未指定索引时，与%方式一样{}位置与实际值位置相对应

3.3. Python 3以上的f-string

f定义的格式化字符串

定义格式化字符串{}里填写实际值

4. 指定宽度和精度

%[宽度][精度][格式]

{[索引]:[宽度][.精度]} # {}做占位符时索引可不写

[宽度]：总宽度

[精度]：%做占位符里是精确到小数点后几位；{}做占位符里是一共几位数，后面加上f是小数点后

(6)、字符串的编码转换

1. 为什么需要字符串的编码转换

字符串在网络当中需要使用字节进行传输时，需要先转换成二进制数据进行传输，再转换成字符串类型进行显示

2. 编码与解码的方式

2.1. 编码

将字符串转换为二进制数据(bytes)

字符串.encode(encoding=编码格式)

# 编码格式有GBK,UTF-8等。GBK一个中文占两个字节，UTF-8占三个字节

2.2. 解码

将bytes类型的数据转换成字符串类型

二进制数据.decode(encoding=编码格式)

扩展：len()内置函数

返回对象（包括上面介绍的五种数据类型等）长度或项目个数

len(对象)

# 这里到达B站20000字上限了，具体内容详见WPS笔记