文章目录
- 1、关于本文
- 2、对python 的个人看法以及后续
- 3、python解释器
- 4、pycharm安装
- 5、正片开始
1、关于本文
1.1文章适用人群
对编程感兴趣的零基础小白、回顾基础语法
1.2 文章目的
本人是一名大数据专业的普通学生，撰写这篇文章的目的是希望能将晦涩难懂的概念简单化，将严肃的词句变成大白话，让更多人感受到编程的乐趣。文章会有很多的例子，目的在于让大家将抽象的概念具象化，以达到更容易理解的效果，如果大家觉得举例不当，亦可置之不理。当然这也是本人的第一次尝试，希望能给大家带来一定帮助，多有疏漏望大家谅解，。
2、对python 的个人看法以及后续
python，一门被冠以蟒蛇之称的编程语言，因其开发效率之快而闻名。在学校中，对python的学习并不局限于计算机学院，大家对它的第一印象无非是上手简单，也正因如此往往会忽视其内核价值。当然，更深入与全面的学习可能就只会留给计算机学院的同学来进行了。但这并不意味着其他的同学不能很好的使用python工具解决实际问题，就像园林专业的同学亦可以使用CV技术对公园照片进行分析。
于我个人的拙见，如果是对编程感兴趣且希望以此谋生的小伙伴，我更建议将c语言摆在学习首位，也是因为万物起源于c，而编程语言的基础语法大多是互通的，因此不必要花很多时间与精力重复一样的东西，而忽略了更深层的学习。
这篇水文仅会提及基础语法，后续的 面向对象编程、numpy、pandas、matplotlib等基础库以及有关机器学习的内容，感兴趣的小伙伴可以留意一下，当然我也希望自己有能力学懂那些部分。
3、python解释器
3.1 解释器的作用（了解就好）
Python解释器作用：运行文件
Python解释器种类
1、CPython，C语言开发的解释器[官方]，应用广泛的解释器。
2、IPython，基于CPython的一种交互式解释器。
其他解释器
1、PyPy，基于Python语言开发的解释器。
2、Jython，运行在Java平台的解释器，直接把Python代码编译成Java字节码执行。
3、IronPython，运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。
3.2 解释器的安装（实操必装）
Python解释器的安装：链接: https://blog.csdn.net/weixin_43495473/article/details/103559812
因为文章时间比较早，大家亦可使用python3.12.xx的版本进行学习，安装流程是大致相同的。
安装流程的一些补充或解释:(下面的加粗开头是别人文章的第几个步骤)
C: 自定义安装可选择D盘或者其他分割出来的盘，就是不要放c盘
第三步 ：测试 打开命令行工具可用 win+R的快捷键再输入cmd打开终端
大家有任何的问题都可以在评论区留言， 尽力帮大家解决。
4、pycharm安装
（建议就装这个 因为别的我也没用过）
4 .1 pycharm介绍
pycharm只是一个多功能的python开发工具，是比较常用，也比较方便快捷的一个，python代码的解释与运行依赖于上面介绍的解释器。
简单来讲就是，具象化到厨房里面，
python代码就是一个马铃薯；
解释器就是对这颗土豆的烹饪方法，像油炸，烘烤等；
pycharm就是厨房的空气炸锅，它有替代油炸、烘烤、预热等功能，pycharm这个空气炸锅合成了油锅，微波炉等传统厨具的功能，使得烹饪更便利。
当然可以使用其他的开发工具，像vs或者你对自己的编程技术十分自信亦可以使用记事本（狗头保命），这里只给大家介绍pycharm这个常用的工具。
4.2 pycharm安装
链接: https://blog.csdn.net/weixin_43495473/article/details/103560198
安装过程的一些补充或解释：
配置解释器： 也是由于时间问题 新版的pycharm工具可能页面有所更改 “setting”可能变更到整体窗口的左上角的四条横线处“file”里面。
大家有任何问题欢迎在评论区留言
5、正片开始
配置环境的过程可能相对复杂繁琐，但是如果你已经坚持到这里了，相信你一定有毅力能继续学习下去。借用英雄哥的一句话 “你的放弃，或许会成就更多的人。” 希望大家都能成为被成就的那个人。
5.1 变量
5.1.1变量的作用
简单来说就是对计算机内部的存储空间进行命名并使用。
1、临时保存数据
2、便于后期维护代码
这里又不得不点一下python的一个弊端：如果你多次以同样的名字定义变量就像：
name='lys'
name='zjl'
name='xxx'
它并不会报错 而是会取最后一次定义这个变量的值，即输出 xxx。
5.1.2 认识标识符（了解就好）
命名规则是python中定义各种名字的统一规范要求，具体如下
- 可由字母、数字、下划线组成
- 不可由数字开头
- 不得使用关键字作为变量名称
- 区分大小写（就是a和A可以当作两个变量名字使用）
至于关键字，并不需要全文背诵，因为pycharm会提醒你。下面将关键字整理给大家
5.2 数据类型
变量在很多语言中都需要先定义类型，而类型又是什么呢？
如果有习得c语言和java等其他语言的同学，应该对此深有体会：char、int、float、bool等类型再熟悉不过了。对于这些语言，被亲切地定义为强类型语言，顾名思义就是要有类型才能定义变量。就像下面的c语言一样：
int a=1
float pi=3.14
举个例子： 香蕉被定义为水果， 而菠菜被定义为蔬菜。水果和蔬菜就是它们的类型，而大香蕉和菠菜就是变量。
讲了这么多，回归到python当中。之所以说python入门简单从这里就开始显现了。相对于其他语言，python在变量类型这一方面就有那么一点小聪明，它懂得自动识别你的变量是什么类型。就像这样：
age=18 # type=int
a=3.14 # type=float
name='sam' # type=str
因此，在定义变量的时候并不需要特地去对其进行类型定义。
那问题又来了，我要是想查看一个变量的类型应该怎么办呢？聪明的小伙伴其实已经通过上面的代码块猜到了，就是使用type语句。
type（）
常用的有以下几种：
下面是代码与输出结果：
a=1
print(type(a)) # <class 'int'> 整型
a2=1.1
print(type(a2)) # <class 'float'> 浮点型
a3="abc"
print(type(a3)) # <class 'str'> 字符串
a4=True
print(type(a4)) # <class 'bool'> 布尔型
a5=[1,2,3]
print(type(a5)) # <class 'list'> 列表
a6=(1,2,3)
print(type(a6)) # <class 'tuple'> 元组
a7={1,2,3}
print(type(a7)) # <class 'set'> 集合
a8={"num":"1","num2":"2"}
print(type(a8)) # <class 'dict'> 字典
5.3 输出
5.3.1 %输出
在上面的查看数据类型的时候，我们使用到一种 print（） 语句，对变量内容进行输出：
a=18.0225
b=1234
print("a=%.2f\n" %a) #a=18.02
print("b=%05d\n" %b) #b=01234
| 形式 | 对应的作用类型 （仅举三个常用例子） |
|---|---|
| %d | 整型变量 |
| %s | 字符串 |
| %f | 浮点型变量 |
！！ 留意到 % 后有 .2f和05d的字样；还有后面的 \n
其一 %.2f 就是保留该浮点型变量 值的小数点后 两位
其二 %05d 就是对整型变量取五位且用零补齐不够的位数 到该数字前面
其三 \n 是用来换行输出下一个结果
当然，你也可以仅使用字符串%s的接收形式，因为它们几个本质上都可以是字符串。以下是代码：
name=lys
age=18
weight=66
print('我的名字是%s，今年%s岁了，我的体重是%s公斤\n' % (name, age ,weight))
5.3.2 f-string输出
当然，如果只有这一种输出的形式，未免有点太单调了。
所以下面介绍第二种：f—string 来进行格式输出
f {表达式}
具体到代码上：
name='sam'
age=18
print(f"作者名字是{name}，年龄是{age+1}") #作者是sam，年龄是19岁。
！！ 留意到{}里面是表达式，所以我们也可以在里面整点活，就像例子里面使用算数表达式。
5.4 输入
大家c语言的线上老师是谁呢？
我记得浙大翁恺老师曾经在c语言的输入函数这节课讲过一句“计算机现有的东西都是人发明出来的，并不是什么黑魔法，就算现在不理解，总有一天你都会学会的”。希望这句话也能激励你我继续往下学习。
回归正题，前面讲到的输出可以基于已有的程序进行。 但是当你希望提供服务性的功能，就需要用到输入，来接收用户提供的信息。就拿最常见的输入法举例，就像我现在对键盘的每一次敲击都是一个个输入，拼音的组合就是对输入结果的整合，而放到python当中便是input（） 语句。
input（“这里面可填输出的话语，例如你希望用户输入ta的年龄就可以写 “请输入你的年龄：””）
当然input（）语句一般搭配变量使用，就是利用我们刚刚讲到的变量的暂时存储功能，就像这样：
age=input("请输入你的年龄：")
而接收到的内容python中默认是当作字符串，但是如果我希望它接收到的内容的类型是整型数字或者其他类型又应该怎么办呢？详情 请看下一标题。
5.5 类型转换
书接上回，当我们希望对接收到的内容有所形式上的规定时，便引出了本节类型转换。对类型的规定仅需要对input（）语句加以修饰即可，就像有人喜欢吃甜豆腐脑，有人喜欢吃咸豆腐脑，只是豆腐脑外面的汤汁有所不同 。那具体来讲的话，便要回顾一下我们在前面学习的数据类型了。
| 语句 | 类型 |
|---|---|
| int() | 整型 |
| float() | 浮点型 |
| list() | 列表 |
| tuple() | 元组 |
| set() | 集合 |
| str() | 字符串型 |
| eval () | 合理的类型 |
假设大家都记得数据容器里面存在五类，分别是：字符串、列表、元组、集合、字典。 但是你会发现我并没有将字典整合到类型转换的表格当中，这是为什么呢？ 留个悬念给大家思考一下 到后面的数据容器再揭晓答案。 在这里大家先知道一般不会使用到 转化成字典类型。 以下是一些举例：
# 整型
num1=int(input())
print(type(int(num1))) # <class 'int'>
# 浮点型
num2=float(input())
print(type(float(num2))) # <class 'float'>
#列表
tuple1=(1,2,3)
print(type(list(tuple1))) # <class 'list'>
#元组
list1=[1,2,3,4]
print(type(tuple(list1))) # <class 'tuple'>
#集合
list2=[2,3,4,4]
print(type(set(list2))) # <class 'set'>
#字符串
num3=123
print(type(str(num3))) # <class 'str'>
#合适的形式
a1='1234'
a2='[1,2,3]'
a3='(1,2,3)'
print(type(eval(a1))) # <class 'int'>
print(type(eval(a2))) # <class 'list'>
print(type(eval(a3))) # <class 'tuple'>
不出意外，你应该发现了一个我们没讲到过的语句eval()。
eval()语句 ：官方定义的大白话解释就是：对接收到的数据正确处理。再简单来讲就是防止输入的内容格式错误，让编译器误解。不理解没关系，举个例子你就明白了，520当天，我的班长想给他的女神发个红包 本来520的红包金额 他偏偏输入了字符串的格式‘520’ 但是如果在后端接收输入数据时使用了eval语句的话就能识别到 要输入的是520 这个数字了。从此班长和他的女神过上了幸福的生活。
5.6 数据容器
书接上回提到了数据容器的使用，那这一小节我们来介绍一下数据容器。
数据容器的格式类型各异，接下来会一一介绍
谈到数据容器的功能无非“增、删、改、查”，也会在下面的介绍中提及。
而在各类数据容器的方法都是通过 . 来应用的，现在看不懂没关系，看到具体例子就清晰了。
方法中的参数并不止于这些，只是举一些常用的参数例子方便大家了解。
5.6.1 字符串
定义字符串的格式： 变量名=‘xxx’
name=‘lys’
address=‘China’
一些字符串的用法：
“查”：
1、下标查找
str1=" stu in GZ"
print(str1[1])
这里还要补充一个点，在计算机中通常以0 作为下标的起始。所以例子中的 [1] 就是取字符串的第二个位置的元素，即s。
2、index（）
可用于按位置查找。
index(参数1)
参数1 就是想查找的字符串 记得是字符串。
index（‘想查找的子字符串’）
str2="abcefg"
print(str2.index('c'))
用index 语句可以查找具体的某个子字符串是否在字符串中。按 例子来讲就是 查找c这个子字符串是否在str2这个字符串内。 存在就返回True 否则False。
需要注意的一点是，index（）语句括号内只能接收字符串。
这两种方法分别对应：按位置查找、按内容查找。
“改”：
1、replace()：
可用于对字符串内的子字符串进行修改。
格式如下：
replace（参数1，参数2）
那参数1、参数2 分别应填入什么呢？
replace（‘想改哪个子字符串’，‘想改成哪个子字符串’）
具体实现如下：
str3='abcdef'
print(str3.replace('a','1')) #‘1bcdef’
replace（）语句亦是需要接收字符串进行处理。
2、split():
可用于对字符串的分割。
split（参数1）
split()语句就是根据参数1来进行分割的。所以同样的，需要传入的参数是一个字符串。举例如下：
str4='aabaabaa'
print(str4.split('b')) # 输出结果就是一个列表 ['aa','aa','aa']
还有一种特殊情况不知道大家有没有想到，没错就是当字符串中存在空格或者像逗号等标点符号的时候！！
str5='abc abd bhd'
print(str5.split(' ')) # ['abc','abd','bhd']
没错，解决的方法就是往参数1里传入一个空格或者你想分割的标点符号。
3、[]分割
实际上还有一种分割字符串（切片）的方法：
[参数1：参数2：参数3]
参数1为切片起点；参数2为切片终点，要注意的是切片结果不包含终点，参数3为步长，那什么是步长呢，直接看下面的例子你就明白了
str6='abcdefg'
new_str6=str6[0:3:2]
正如对str6的分割，从第一个元素a开始到第四个元素d结束，其中不包括d，所以分割出来的字符串便是 ‘abc’，又注意到我们的步长为2 ，说明我们取的字母之间要相隔一个元素，那就是取 ‘ac’ 为最终new_str6的结果。
那我们不妨再往下思考，如果我们想要对整个字符串操作怎么办？或者说我们还想**切片方向从右边往左边（反向切片）**走又该怎么办？
其实无非就是设定不一样的参数123。
整个字符串操作 ：str6[::]
对的没错就是参数1、2都不填，就会默认你从头到尾对整个字符串进行操作，你还会发现一点就是如果步长（参数3）不填，会有一个默认值为1 ，也就是对每一个元素进行操作。
反向切片：str6[::-1]
在对整个字符串操作的基础上，对参数3取一个 -1的值，你就会神奇的发现，切片的方向是反着来的。当然还可以有-2，-3这些隔位反向取值。
对于反向切片，如果有学过数据结构的同学亦可以类比到栈的后进先出这一特殊性质。
4、大小写修改：
(1）：capitalize()
capitalize() 语句 仅会使整个字符串的第一个子字符的头字母变大写
str7='hello world'
print(str7.capitalize()) # 'Hello world'
(2）：title()
那我要是想每个子字符串（例子里面的单词）的头个字母都变大写呢？
title()语句
str8='hello world'
print(str8.title()) # 'Hello World'
(3）：upper()
再往深一层想，如果我想每个字母都大写呢？
upper()
str9='hello world'
print(str9.upper()) # 'HELLO WORLD'
(4）：lower():
好了，我现在又不想要大写了，换个小写吧。
strx='Hello World'
print(strx.lower()) # ‘hello world’
“删”：
1、strip()
strip(参数1) 语句用于对字符串首尾的子字符串进行删除操作
就像这样：
str11=' hello world '
print(str11.strip()) # 'hello world'
当参数1 不传入任何值的时候，就是对字符串首尾的空格进行删除操作。当然参数1还可以接收其他字符串。那就留个大家去尝试了。
5.6.2 列表
列表的基本格式：列表名字（这个你随便起）=[元素]
分辨不同的数据容器主要是看 符号 不是起的名字，就像：
list1=[1,2,3,4]
set=[‘lys’,‘lgb’,‘zjl’]
tuple=[1,1,1,0]
这三个都是列表，由中括号括起来的组成一个列表
“增”：
1、append()
格式：append(参数1)
参数1 就是你希望传入的元素，数据类型还是要字符串的。
list_a=[1,2,3]
list_a.append('4')
# [1,2,3,4]
但是呢，这个append语句只适用于对数据进行尾插进列表中。那如果我想选定一个位置插入数据呢？那就是接下来要介绍的insert。
2、insert()
格式： insert(参数1，参数2)
参数1就是你要在列表中插入的位置，或者说下标位置更为准确（从0开始的），参数2就是你想传入的内容，当然类型也还是字符串。来看栗子。
list1=[1,3,4,5]
list1.insert(1,'2')
# [1,2,3,4,5]
那我们再接着想想，万一我们要传入的数据不只是一个元素，而是别的数据容器怎么办？ 欸 ，接下来的这个语句就是这个用法。
3、extend()
extend() 就是处理其他数据容器尾插进列表的方法。
格式：extend（参数1）
这里的参数1 就是你需要尾插的数据容器，就像另一个列表或者元组等。
亦可以从格式上理解为 数学的嵌套函数。
直接来看例子：
list1=[1,2,3,4,5,6]
list2=[7,8,9,10]
tuple1=(1,2,3)
list1.extend(list2)
print(list1)
# [1,2,3,4,5,6,7,8,9,10]
list1.extend(tuple1)
print(list1)
# [1,2,3,4,5,6,1,2,3]
错误例子！！
list3=list1.extend(list2)
print(list3)
# None
extend（）方法需要注意的是： 将其他数据容器（list2、tuple1）加入到原有的数据容器中后（list1）一般输出使用原来的数据容器即可 不用第三方数据容器进行输出 （因为会报None）
而原因也很简单 因为extend（）图省事直接就在原地对 list1 进行了修改 而不需要另外找一个 list 来接收修改后的数据 所以新创建的 list3 实质上并没接收到 list1 修改后的数据 反而是被赋值为 None。
“删”
1、pop（）
看到pop你有没有想起数据结构中的出栈时定义函数名 popstack（） 出栈就是是取出栈顶元素
同理 列表的pop（）方法亦可以是这样 取出尾部元素。欸 留意我的用词 可以是这样 说明也可以不这样。卖个关子，先讲取尾元素。
格式：pop(参数1)
list1=[1,2,3,4]
del_value=list1.pop()
print(del_value)
# 4
print(list1)
# [1,2,3]
回忆一下，我们前面提到的 如果不填参数1 则会对全部数据进行操作。
而pop（）方法 不填参数1 的情况下 是对尾部数据进行删除操作，这也是一个默认值。
那进一步来说，如果我想pop某一个位置的元素 是不是就可以在参数1 填入它的下标位置（下标是从零开始）
list1=[5,6,7,8,9]
del_value2=list1.pop(1)
print(del_value2)
# 6
print(list1)
# [5,7,8,9]
就像例子中 对第二个元素进行删除操作，便是填入下标到参数1的位置 而原来的 list1 里面就删除那个元素了。
2、remove():
前面的pop（）方法是针对位置进行删除 ，那如果是想对元素进行删除则可以用到remove（）方法
格式：remove（参数1）
参数1 需要填入的是你想要删除的元素。
list1=[1,2,3,3,4,4]
list1.remove(3)
print(list1)
# [1,2,3,4,4]
你会发现 每使用一次remove（）方法 只会对 list 1 内两个相同的元素 3 进行一次删除
当然你亦可以对那个你不喜欢的数字多用几次remove（）然后就能完全删掉它了。
言归正传，remove（）在面对多个相同的元素时，因为没有选择困难症，所以它会在那个元素第一次出现时进行删除操作。
3、clear（）
当你不喜欢整个列表时就可以使用clear（）方法 ，它能帮你删掉整个列表。
格式：clear（）
（好像是不用填入参数的）
直接看栗子：
list1=[1,2,3,3,4,5]
list1.clear()
print(list1)
# []
显而易见的一个方法，讨厌就删掉。
“改”：
1、下标修改
最常见的一个修改方法 需要先知道该元素的下标位置。
格式：list1[元素下标]=“（修改成什么）”
list1=[1,2,3,3,4,'a']
list1[5]='b'
print(list1)
# [1,2,3,3,4,'b']
也是非常清晰的一个方法，想改哪个改哪个。
2、reverse（）：
reverse（）方法，顾名思义反向的。所以它的作用就是对列表进行逆置。
list1=[1,2,3,4]
list1.reverse()
print(list1)
# [4,3,2,1]
reverse（）方法仅是对列表进行逆置，更深一层来说，如果想要对列表进行其他的排列方式呢？
3 、sort（）
承接上文，sort（）方法便是对列表进行其他排列方式。
格式：sort（参数1）
参数1 是对排列方式的设置
list1=[1,2,4,3,6,2]
list1.sort(reverse=False)
print(list1)
# [1,2,2,3,4,6]
list1.sort(reverse=True)
print(list1)
# [6,4,3,2,2,1]
是的，参数1就是上面的reverse
当reverse=False时表示列表升序排列
当reverse=True 时表示列表降序排列
“查”：
1、下标查找
格式：list[下标]
要注意下标从零开始。
list1=[3,2,1,56,7,9]
print(list1[1])
# 2
2、index（）
index（）方法其实可以有两种查找方式
格式1：index（参数1）
格式1 的参数1就是你想找的那个元素，而返回值就是元素的下标位置，要是不存在改元素会报错。那要是有相同的元素在列表内又会返回哪个元素的位置呢？
list1=[1,2,3,3，4,6]
loc=list1.index(2)
print(loc)
# 1
loc2=list1.index(3)
print(loc2)
# 2
你会发现 index（）方法与remove相似 面对相同元素时 都是对第一次出现的那个元素进行操作。
格式2： index（参数1，参数2，参数3）
而格式2则在查找位置上更详细，参数1是需要查找的元素，参数2 3 分别是开始与结束查找的下标位置（包含结束位置）。
当面对列表数据过多的时候可以使用格式2 进行查找操作，来看例子：
list2=[2,3,4,5,53,2,1,3,4,5,2]
loc2=list2.sort(1,3,7)
print(loc2)
# 6
例子中对元素 1 的查找就是从第四个元素开始到第八个元素为止，当然面对相同的元素时也符合上面的规则，找不到亦会报错。
5.6.3 元组
元组有一项异于常人的规定就是不能对它修改，因此可用于一些不改动的数据。但是它真的是一点都不能修改吗？看到后面你就知道了。
格式：tuple=（数据）
由 （） 构成一个元组。内部数据可以是各种数据容器。
“查” ：
前面提到 元组因为其特殊性不支持直接对元素进行修改，所以不存在“增”、“删”、“改”等直接方法。
1、下标查找
类似于前面两种数据容器。
tuple(下标位置)
直接看码：
tuple1=(1,2,3,4)
num=tuple1[2]
print(num)
# 3
2 、index（）
亦是与前面的index相类似，这里仅举一种格式的例子。
格式：index（参数1）
参数1 还是一样的 填入你想要查找的那个元素。
tuple1=(1,2,4,3)
loc=tuple1.index(2)
print(loc)
# 1
“增删改”
是的 没有看错 元组内部元素正常来讲的话是不能直接改变的，但是回顾我们前面讲到的 数据容器也存在嵌套 怎么理解呢？我要是将其他可对数据修改的数据容器作为元组的数据 那阁下又该如何应对？
a1=(3,4,5,7,[11,22,33,44])
a1[4].append(55)
print(a1)
# (3,4,5,7,[11,22,33,44,55])
a1[4].remove(22)
print(a1)
# (3,4,5,7,[11,33,44.55])
a1[4][1]=2
print(a1)
# (3,4,5,7,[11,2,44,55])
这种情况下 增删改的方法真可以对元组的数据进行操作。
当然，这是一种投机取巧的方法，希望大家只是了解就好，当作一个笑料别真用上了。
5.6.4 集合
这里的集合与大家高中数学的第一课是类似的。具有无序、去重等特性。
set={数据}
由 {} 组成集合。
“增”：
1、add()
add()方法仅适用于集合。
格式：add（参数1）
参数1 需填入 你想添加到集合的数据。
set1={1,2,5,3,4}
set1.add(6)
print(set1)
# {1,2,3,4,5,6}
因为无序性，所以得到的集合结果不一定是这个。add（）适用于单个数据的添加，那要是我还想添加些数据容器呢？
2、update（）
update（）方法只接收数据容器，像字符串，列表等。
格式：update（参数1）
参数1 就是要添加的序列。
set1={1,2,4,6,2,3}
set1.update([1,3,4,6])
print(set1)
# {1,2,3,4,6,[1,3,4,6]}
set1.update('abc')
print(set1)
# {1,2,3,4,6,'c','b','a'}
注意到对字符串的添加是拆成一个个子字符串进行添加，还要留意一开始的set1中存在两个2输出后仅会保留一个 即集合的去重功能。
“删”：
1、pop（）
集合中的pop（）方法，与列表中的pop有所不同，它比较任性，不喜欢哪个元素就把那个元素删除。
格式：pop（）
set1={1,2,3,3,4,5}
set1.pop()
print(set1)
# {1,2,3,5}
pop（）方法的随机性会让输出结果有很多种。
2、remove（）
与之前类似remove（）方法，对该元素进行删除操作，又因为集合里面没有重复的元素，因此会对该元素直接删除。
格式：remove（参数1）
参数1 就是想删除的元素。
set1={1,2,3,6,4}
set1.remove(1)
print(set1)
# {2,3,4,6}
3、clear（）
是的还是跟前面类似。clear（）方法是对整个集合进行清除操作。
格式：clear（）
set1={1,3,4,5,1,2}
set1.clear()
print(set1)
# set()
set()就是表示空集合的意思。
“改”：
因为集合的无序性，所以元素的下标位置是不确定的，因此不能通过下标的方式进行修改单个集合内的元素。但是存在对两个集合元素修改的方法，接下来介绍几个常见的。
1、difference（）：
格式：set3=set1.difference（set2）
怎么理解这个difference（）方法呢？ 首先具体作用就是将 set 1和 set 2两个集合的差集赋值给 set 3 。举个例子就是，李华有苹果和香蕉，小帅有香蕉和雪梨，他们两个都想给小美一个水果，于是李华送了苹果，小帅送了雪梨,那小美就有苹果和雪梨两种水果了，下面来看码：
set1={1,2,3,4}
set2={2,3,4,5}
set3=set1.difference(set2)
print(set3)
# {1,5}
比较符合difference的中文意思，反正也就是找不同嘛。
2、union（）
上面的difference是找不同，而union是放一起。
格式：union（参数1）
参数1 就是填入你想合并的那个集合。直接来看代码：
set1={1,2,3,4}
set2={3,4,5,6}
set3=set1.union(set2)
print(set3)
# {1,2,3,4,5,6}
不要忘了集合的去重功能，union简单来讲就是个对两个集合取并集，（如果大家还记得高中知识的话）。
“查”：
1、in
因为集合的无序性，所有的元素一般来讲都没有固定位置，因此不能使用下标索引。这里介绍一种返回布尔类型值的方法。（布尔类型值就是True、False）
直接来看代码：
set1={2,3,4,5}
print(1 in set1)
# False
当然有 in 就会有 not in 规则就是跟 in 相反，返回值亦是布尔类型值，这里就不作举例了。
对于集合来讲我们还可以利用它的去重功能结合我们前面提及的数据类型转换，对不同数据容器进行操作。具体就像这样：
list1=[1,2,2,3,3,4,4,5]
print(set(list1))
# {1,2,3,4,5}
这个方法是推荐使用的，不同于在元组内嵌套其他可修改的数据容器，利用各类数据容器本身的特性进行数据修改，亦是融会贯通的一种展现。
5.6.5 字典
字典顾名思义类似于我们日常生活中的实体字典，给一个字或词，并配有相对应的解释。python中的字典亦是如此，存在key和value两个参数，一般称呼它们为键值对。
格式 ：dict={“key1”：“value1”，“key2”：“value2”}
这里的key可以有很多选择 ，例如你想做一个学生的字典key可以是年龄，班级，性别等，而value就是每个学生相对应的数据，当然这里可能应用到了嵌套字典，我们后面再举这个例子。 还是先从简单的增删改查方法开始介绍。
“增”
1、[“key”]=“value”
格式如上面，字典的操作较其他四个数据容器复杂，操作都要包含整个键值对。来看例子：
dict1={"name":"sam","age":18}
dict1["address":"GZ"]
print(dict1)
# {"name":"sam","age":18,"address":"GZ"}
一般来讲这种方法是尾插到字典内，但是有一种情况我们没有考虑到，万一我们添加的那个键值对已经存在于字典内，那会发生什么，我们来试一下。
dict1={"name":"john","age":81}
dict1["name"]="sam"
print(dict1)
# {"name":"sam","age":81}
会看到这样起到了一个替换的作用，所以这个也可以归结到 “改”这一部分中，那后面我将不再解释这个方法了。
“删”
1、del
del就是delete的缩写。
格式：del dict[“key”]
key就填入你想删除的那个。
dict1={"age":18,"name":"sam"}
del dict1["age"]
print(dict1)
# {"name":"sam"}
2、clear（）
也是跟前面的一样，对字典进行清除操作。
格式：clear（）
直接来看：
dict1={"name":"lys","age":18}
dict1.clear()
print(dict1)
# None
“改”
改的话就是上”增“部分的额外思考。
“查”
1、对key查找：
格式：dict[“key”]
key 就是填入你想找的那个。
于代码：（查询不存在的“key”亦会报错）
dict1 = {'name': 'Tom', 'age': 18}
print(dict1['name']) # Tom
print(dict1['id']) # 报错
2、keys（）
键值对由key和value组成，而keys（）方法便是用于查找字典中所有的key。
格式：dict.keys()
dict1={"name":"sam","gender":"man"}
print(dict1.keys())
# ['name','gender']
3、values（）
相类似的 values（）方法就是对字典内的value进行查找。
格式：dict.values()
dict1={"name":"xxx","age":1}
print(dict1.values())
# ['xxx',18]
既然有分别查找，那也应该有一起查找吧
4、items（）
items（）方法就是对键值共同操作的，来看例子。
dict1={"name":"lys","gender":"man","address":"GZ"}
print(dict1.items())
# [("name","lys"),("gender","man"),("address":"GZ")]
注意到 使用items（）方法进行查找操作时，返回的键值对以元组的形式呈现。
嵌套字典
其他的数据容器当然亦有嵌套的形式存在，但都比较简单 留给大家思考，这里单独讲讲字典的嵌套，形式上看起来是有点点复杂的。
格式：dict1={”key1“：{”key11“：”value11“，”key12“：”value12“}，”key2“:{“key21”:“value21”,“key22”:“value22”}···}
从格式上看是不是还挺复杂的 直接看栗子就清晰了：
dict1={
"sam":{
"home":"GZ",
"age":18
},
"john":{
"home":"EP",
"age":21
}
}
首先外层字典的 key 就是 ”sam“和”john“，外层的value就是对应{}的全部内容，而”sam“内层的key就显而易见了：”home“和”age“，相对应的内层value就是 ”GZ“和18。
嵌套字典简单的使用场景就是像这些人员信息统计类的。
5.6.6 通用方法
1、len（）
len（）方法作用于对数据容器内的元素个数统计。举一个列表的例子，其他数据容器的方法留给大家思考。
list1=[1,2,3,4]
print(len(list1))
# 4
2、min（）、max（）
顾名思义用于查找最小值、最大值的，也是举一个元组的例子，其他留给大家。
tuple1=(1,2,3,4)
print(min(tuple1)) # 1
print(max(tuple1)) # 4
至此，大白话上集完结，下面给大家浏览下集的目录，有兴趣或者有需要的可以留意一下，当然这是我第一次尝试，以上的不管是内容还是排版也是一次尝试，望各位多多谅解，亦或你可以在评论区提出建议与疑问，我尽量解决。