本文为原创作品，若与其他作品雷同，纯属巧合。请勿抄袭。
目录
🏆一、前言
（别问我为什么封面这么丑）
任何编程语言里都有很多的数据类型，python也有。
不知道为什么自己贴个普通的代码浏览量都300多，写个超级长文才20多个浏览量，玄学热度就很无语。怎么才能有热度！！！
不过，这篇文章会对python3的所有数据类型进行超级详细的讲解。写文不易，求智齿！！！
🏆二、数据类型and变量
🚩1、数据类型（简单）
任何数字或数组都有自己的类型，举个数学里面的例子：数学有整数，小数，分数，复数，无理数，复数等等，这就是数学的数据类型。python里也有数据类型，每个数据类型都有自己的英文名称，一共有：
- 数字（Number）
- 字符串（String）
- 列表（List）
- 集合（Sets）
- 字典（Dictionary）
- 元组（Tuple）
而数字(number)又分为：
- 整型（int）
- 浮点型（float）
- 布尔型（bool）
- 复数（complex）
其实还有长整型（long），不过在python3已经废除了。
这些东西和他们的英文是一定一定要记住的，赶紧背吧！
🚩2、变量（中等）
接下来，讲变量。
为什么要有变量呢？
变量，说人话就是会变化的量。比如你登陆B站看蔡徐坤打篮球的视频，此时你鼠标的位置、蔡徐坤视频的播放时长、点赞、关注、收藏、投币，都是会变化的。所以，我们要用变量去记住这些数据。上面说的数据类型其实就是变量的不同种类。我们先了解一下变量的定义方法。
变量的定义方法，很简单。我们先讲一下=。
=，在数学里是说明左右相等，在编程里代表赋值，将右边的值传递给左边。
a=1这个语句生效后，变量a便是这个变量的名字，1就是变量的内容。
这叫做声明变量。
声明变量格式一定要记住：
变量名称 = 数字
变量的名字也有讲究，只能用英文字母，数字和下划线_，并且数字不能在第一位，区分大小写。
这里又有一个新的概念：关键字，比如这个变量名是if，写出来就是这样：
if=0程序看到if，就默认会判断后面的等式，不会把它当作变量，直接报错。if就是关键字。关键字还有好多，具体的上网查，不过只要名字正常点就行。
变量名不能为关键字。
另外，变量名要有可读性，以后写变量多的程序，容易自己都不知道设置这个变量干什么用。例如侦测鼠标的x坐标的变量，可以设置变量名为shubiaoweizhi_x，不想多写字就写sbwz_x，前提你能看懂。
赋值的时候，程序会先对等号右边进行运算。例如：
>>>a=5*4
>>>a
20
这时，程序会先运算5*4为20，再a=20。
接下来看一段代码：
a=2
print(a)
a=3
print(a)输出：2
3
让我们来理解一下这段代码。
赋值的意思就是：给一个变量他的值。
现在把a赋值为2，之后再把a赋值为3。
恭喜你，已经理解了变量，这就是基础使用方法。
=可以传递多个值，如：
a,b=1,2
print(a,b)输出：1 2
这就相当于把a赋值为1，把b赋值为2，不过是同时运算的。
接下来，试着来理解一下这段代码：
a,b=1,2
a,b=b,a
print(a,b)这是经典的两数互换。
解析：现在a是1，b是2，把a变成b的值，把b变成a的值便是两者互换。
有人问：诶诶诶，a=b执行之后a也变成2，为什么b=a之后b是1呢？
因为这是一行代码，是同时执行的，没有先后顺序。
总结：变量用来储存一个会变化的量，用=号来对其赋值。
再讲一个经典的自增。
a=a+1，+的意思是两数相加。
这在数学上是不可能的，但是在编程里=是赋值的意思，就相当于把a赋值给自己加一的值，就是a自己加一。
还有另一种写法，a+=1，这种写法虽然简便，但是在后面学的数组里，他与a=a+1是有不同的地方的。所以建议大家目前用第一种写法，理解也方便。
在后续的程序，我们随时可以改变和使用这个变量。
a=2
print(a)
a=3
print(a)
if a==3:
print("a是3")2,
3
a是3
解析：先将a赋值为2，输出a
再把a改变成3，输出a
如果a是3的话，输出a是3
这就是改变变量和使用变量的方法。
接下来，我们先讲数字，再讲字符串和数组，准备好了吗？
🏆三、数字（number）
学之前，我们要记住：任何类型的数字都可以用变量保存。
🚩1、整型浮点型一起学（中等）
👍①、认识（简单）
整型（int），说大白话就是整数。
浮点型（float），说大白话就是小数。
对于初学者来说，可以用这种理解方式来理解。
浮点数和整数都可以为负，在前面加一个减号就行。
让我们先看看什么是整型：
1，0，-3，这就都是整型。
浮点型呢？
3.6，-0.3，0.0，这些都是浮点型。虽然可以理解成小数，但在编程中我们要叫这些数是浮点数。
我们可以把变量设置为任何数据类型。例如：
a=3
b=1.1下面学的任何数据类型都同理。浮点数家族里有一名特殊的成员：0.0，在上一篇文章已经讲过了，0.0不等于0。
👍②、整型运算（中等）
我们先要了解一下算术运算符。顾名思义就是用于计算两个数的符号。
现在假设a=6，b=3：
| 符号/代码 | 结果 | 意义 |
| +: a+b | 9 | 两数相加 |
| -: a-b | 3 | 两数相减 |
| *: a*b | 18 | 两数相乘 |
| /: a/b | 2.0 | 两数相除 |
| //: a//b | 2 | 两数相除（向下取余） |
| %: a%b | 0 | 两数整除余数 |
| **: a**b | 216 | a的b次方 |
其中，有一个50%新手都会踩的坑：/和//的使用。
/的运算结果永远都是一个浮点数，即使可以整除也是浮点数。
//虽然运算结果虽然是整数，但是不能整除的时候会向下取整，四舍五入或者向上取整的方法见下文数学函数。并且如果除数或者被除数是浮点数，结果还是浮点数。
下面的代码是所有算术运算符的详细使用：
>>>a=6
>>>b=3
>>>a+b
9
>>>a-b
3
>>>a*b
18
>>>a/b
2.0
>>>a//b
2
>>>a%b
0
>>>a**b
216补充一句：交互式python就相当于一个小型的计算器，就算是更高级的运算也能用程序实现。
恭喜，你已经学会整型的运算了。
👍③、浮点型运算（困难）
浮点型呢？
这是有点特殊的。不过看看例子就学会了：
>>>a=6.3
>>>b=2.1
>>>a+b
8.4
>>>a-b
4.199999999999999
>>>a*b
13.23
>>>a/b
3.0
>>>a//b
3.0
>>>a**b
47.710630282209195
>>>6.3%2.1
2.0999999999999996果然冥白了···这都是啥玩意儿！
请把这些代码给你学数学的好朋友看看，他一定会气晕。
别急，我们慢慢讲。
加法，乘法，除法，幂还可以用数学运算解释，其他的就有点离谱了。
首先是a-b，众所周知，计算机都是二进制的，因为计算机运算的时候要经过五个步骤：对阶，尾数运算，规格化，舍入处理，溢出判断。这个我们不用学，只要知道：
当浮点数减法的时候，结果会转换成离他最近的浮点数。
如果想解决，见下文数字函数里的round。
之后6.3整除2.1怎么会是3.0呢？不是用的整除吗？
如上文所说，被除数或除数有一个是浮点数，就算用整除运算结果也是浮点数。
小数取余数运算教科书没有，不过也是可以运算的，之后同减法。
浮点数在实战中运用较少，所以不用记，只要记得，浮点数减法不能直接算。
👍④、整型、浮点型混合运算（简单）
如果将二者混合运算呢？
>>>a=3
>>>b=1.5
>>>a+b
4.5
>>>a-b
1.5
>>>a*b
4.5
>>>a/b
2.0
>>>a//b
2.0
>>>a**b
5.196152422706632
>>>a%b
0.0没有误区，和数学一样。
🚩2、复数和布尔值一起学（中等）
复数在实战作用不大，不讲了（绝对不是因为作者没上过高中不会）。
布尔值，上一篇文章python详解（1）——条件判断与布尔值已经进行了详细的讲解，可以去看看。
emm···好像没什么可以讲的了，那就直接跳过！
🚩3、数据类型转换（简单）
有时候，我们要让数据类型之间进行转换。
很简单，举个例子，我们要把0.0转换成0:，就要这样：
>>>print(int(0.0))
0这里int(0.0)的意思就是把0.0转换为整数。
先表明要转换为什么数据类型，在括号里填上要转换的数。
如果不能转换呢？
>>>print(int("鸡你太美"))
invalid literal for int() with base 10: '鸡你太美'鸡你太美字符串不能转换为整型，则会报错。
用float()，complex()同理，用complex要注意，如果只给一个值则是实数部分为这个值，虚数部分为0j。如果给两个值则是实数部分为第一个值，虚数部分为第二个值。
🚩4、数学函数（干货）
数学函数，除了几个另类的函数，都要用math模块调用。模块我们后面再去学，你只要知道：下文不用math模块的已经标注了，其他数学函数一定要用math模块，在程序的第一行写import math，并且在函数名前面加上math.。介绍后面表明了每个数的类型，使用的时候这个数只能是表明的类型，例如abs(a)表明了a是int，float，那么a就只能是整数或者浮点数。
注：下面里面有的函数有中括号，意思就是中括号里面的值想填填，不想填不填，都可以正确使用。不填的话中括号里面的值会有一个默认的值。
接下来干货来了：超详细数学函数。
1.abs(a)函数，返回a的绝对值，有些特殊，不用math模块。a为int，float。
print(abs(-10))
print(abs(-3.6))输出：10
3.6
2.math.ceil(a)函数，返回a的上取整数。a为int，float。
import math
print(math.ceil(3.1))
输出：4
3.math. floor(a)函数，返回a的下取整数。a为int，float。
import math
print(math.floor(2.9))输出：2
4.round函数，返回a的四舍五入值，若给出b则是舍入位数，若不给出则默认保留整数，不用math模块。a为int，float，b为int。
print(round(4.6),end=" ")
print(round(4.666,1))输出：5 4.
5.math.fabs(a)，返回a的绝对值。a为int，float，complex，与abs的区别是：fabs是math模块的，并且还可以用于复数。
6.math.exp(a)，返回e的a次方。a为int，float。咱也不知道，咱也不敢问为啥要有这个玩意儿，用math.e**a的结果还更精确。。。
import math
print(math.exp(2))
print(math.e**2)输出：7.38905609893065
7.3890560989306495
7.math.cmp(a,b)，已经在python3废弃，用来比较a，b大小，a<b返回-1，a==b返回0，a>b返回1。在python3，他的替代品是(a>b)-(a<b)，不用函数也能起到相同的作用。
8.math.log(a[,b])，返回a的自然对数，b为底数，不填默认以e为底数。a为int，float，大于0。返回值为float。
import math
print(math.log(10),end=" ")
print(math.log(100,10))返回：2.302585092994046 2.0
9.math.log10(a)，返回以10为底数的a的自然对数，返回值为float。a为int，float，大于0。
import math
print(math.log10(1000))输出：3.0
10.math.modf(a)，返回这个数的小数部分和整数部分（皆为float），小数部分和浮点数减法一样取的是最近值。a为int，float。
import math
a,b=math.modf(3.1415926)
print(a,b)输出：0.14159260000000007 3.0
11.math.pow(a,b)，返回a的b次方（就是a**b）咱也不知道会不会有人用。a，b为int，float。这玩意儿有个特殊地方，他如果直接调用还可以填c值（a**b%c）返回整数，如果从math模块调用就是不能填c值取浮点数。我们只要了解数学函数的pow的用法：只能填两个值，返回a的b次方（浮点数）。
import math
print(math.pow(10,2))返回：100.0
12.math.sqrt(a)，返回a的平方根（浮点数）。a为int，float。
import math
print(math.sqrt(9))
print(math.sqrt(1.21))返回：3.0
1.1
除此之外，math模块还有两个数学常量：π和e，math.pi和math.e，要通过数学函数方式调用。还有三角函数，这就不讲了。
🏆四、字符串（string）
除了Number之外还有五种数据类型：字符串，列表，字典，元组，集合。其中列表，字典，元组统称为数组。接下来，我们一起对这些数据类型进行详细讲解。第一个——字符串。
🚩1、简单定义（简单）
字符串是比较特殊的，不是数组，不是数字，又用单引号或者双引号表示，可以储存到变量。引号里可以填任何东西。
a="只因你太美"
a='你干嘛哈哈诶呦'也可以是三个双引号，变成多行字符串。
a="""只
因
你
太
美"""
print(a)输出：只
因
你
太
美
我们还可以用多行字符串画图，不用一遍一遍print。比如···
你干嘛~~~
🚩2、截取字符串（困难）
截取字符串是字符串的基本用法，有点难。
介绍2个概念：下标和索引。
在生活里，比如有一组1到9排列的数字，1的位置就是1,2的位置就是2。
但是在编程中，编程世界是从0开始的，我们要把它减一，1的位置就是0，2的位置就是1，这样减一就叫下标。
而下表之后的值就叫做索引。
在正序截取字符串的时候，要截取这个值的索引。
现在，假设变量a是"只因你太美"，我们要用中括号去截取。
>>>a[0]
只
>>>a[1]
因
>>>a[2]
你
>>>a[3]
太
>>>a[4]
美截取格式：
字符串名称[索引]
还可以逆序截取，这时候就不用索引了，直接按正常的排列：
>>>a[-1]
美
>>>a[-2]
太
>>>a[-3]
你
>>>a[-4]
因
>>>a[-5]
只如果我们想截取哪一位到哪一位的字符串呢？
这有些难，先说格式：
字符串名称[头索引:尾索引+1]，这叫做“左闭右开”原则。
别问我为啥有P图痕迹。例如上面的图片，有一个字符串为nums="123456789" ，截取他的[2:7]截取的就是第2位到第7-1位，就是2到6位，如图所示。
如果不表明头，默认从第0位开始截；如果不表明尾，默认截到最后一位。
是不是有点难理解？看例子：
>>>a[0:4]#根据头索引:尾索引+1的原则，头索引对应0，尾加1之前就是3，0到3位则是只因你太
只因你太
>>>a[:-3]#默认从字符串的第0位开始截，尾加一后是-3，加之前是-4，0到-4位则是只因
只因
>>>a[-3:]#默认截取到字符串的最后一位，头不变，尾加一后是5，原来是4，所以就是-3到4位则是你太美
你太美还可以有第三个值：步长。格式：字符串名称[头索引:尾索引+1:步长]
举个例子：
a="123456789"
print(a[2:7:2])输出：357
意思就是截取2到7-1也就是2-6位，是34567，之后隔两位取一个数，则是357。
总结：
字符串截取，截取一位用索引，中括号括起来，如果倒序就不用索引，用-代表倒序。要截取多个值用:，:前为起始索引，:后为结束索引+1，可以有第三个值，代表步长。
如果还是不懂，知道什么是面向搜索引擎编程吗？
🚩3、转义字符（干货）
我们了解一下斜杠\：
在字符串中，斜杠加上一个字母或一些特殊的标志可以转义。具体有：
| 符号 | 例子 | 输出 | 作用 |
| \n | print("鸡你\n太美") | 鸡你 太美 | 换行 |
| \\ | print("你\\干嘛") | 你\干嘛 | 在字符串里打出斜杠 |
| \" | print("荔枝\"点") | 荔枝"点 | 在字符串里打出双引号 |
| \' | print("香精\'煎鱼") | 香精'煎鱼 | 在字符串里打出单引号 |
| \a | print(香翅\a捞饭") | 香翅捞饭 | 执行后电脑响铃 |
| \ | print("树枝\ 666") | 树枝666 | 续行，与"""的差别是"""的输出结果也 会换行 |
| \v | print("只\v因") | 只 因 | 竖向制表符 |
| \t | print("哈哈\t诶呦"） | 哈哈 诶呦 | 横向制表符 |
| \f | print("ik\fun") | ik un | 换页 |
还有别的比较不常用的，这里不做讲解。
注意，转义字符在字符串里也有长度，为一，已经在上一篇文章讲过了。
🚩4、字符串运算（中等）
字符串是可以进行运算的。
1.加号+，连接两个字符串。例如：
>>>a="鸡你"+"太美"
>>>a
鸡你太美1.乘号*，重复输出字符串。例如：
>>>print("小黑子"*2)
小黑子小黑子注：在字符串运算中，也要先乘除后加减。
>>>print("小黑子树枝"+"6"*3)
小黑子树枝6663.[]和[:]，见上文
4.in，查询字符串内是否包含某字符串。例如：
if "鸡" in "鸡你太美":
print("你是ikun")
else:
print("你是小黑子")输出：你是ikun
5.not in，查询字符串内是否不包含某字符串。例如：
if "鸡" not in "鸡你太美":
print("你是小黑子")
else:
print("你是ikun")输出：你是ikun
6.r和R：用于让\的语句不发生转义，例如：
>>>print("鸡你\n太美")
鸡你
太美
>>>print(r"鸡你\n太美")
鸡你\n太美🚩5、格式化字符串（困难）
先来了解一下什么是格式化。
《面向搜索引擎编程》
字符串的格式化更倾向于规格化，符号用%。举个例子：
print("最美的动物是{%s},他会{%s}，练习了{%3.1f}年"%('鸡','唱跳rap篮球',2.5))输出：最美的动物是{鸡},他会{唱跳rap篮球}，练习了{2.5}年
这就是规格化。来解析一下：
首先，我们要知道格式化符号：
因为作者懒得写了，所以从网上查找的资料。插一句：菜鸟编程网站相对于新手学习还是很友好的，可以去看看。来源：Python3 字符串 | 菜鸟教程
接下来讲格式，将要填充的内容用大括号扩住，输入格式化符号%+对应类型代表的字母，之后在字符串后面加上百分号和一个小括号，小括号里写要依次填充的值，用逗号隔开。
接下来详细讲一下%f，用来格式化浮点数格式为：%a[.b]f。
a指的是长度，b指的是小数精度，如果只给一个值给的是a，小数精度默认5，如果长度和小数精度不符合就在前面补充空格。
不过在现实用途中，这种写法有点多此一举，因为在python3.6更新了f-string，不仅简便还没有大括号，看起来更美观，一起看看：
a="鸡"
b="唱跳rap篮球"
c=1.5
print(f"最美的动物是{a}，他会{b},练习了{c+1}年。")输出：最美的动物是鸡，他会唱跳rap篮球,练习了2.5年。
有没有似曾相识？
这就像r用来不发生转义一样，f用来让大括号里发生转义。这就等于：
输出：最美的动物是 鸡 他会 唱跳rap篮球 练习了 2.5 年。
可以发现，第一种的间隔处是大括号，第二种没有间隔，第三种的间隔是空格，实战中可以根据不同情况选择不同的方式。
另外还有format，这里先不讲。
🚩6、字符串函数（干货）
字符串也有自己的函数，接下来是纯干货，建议截图或者收藏。那么话不多说——
1.str.capitalize(a)，将a的第一个字母转换为大写，若不是字母则不做改动。a为str。
>>>print(str.capitalize("a鸡你太美"))
A鸡你太美2.c.center(a,b)，返回一个中心是c，长度为a，两边用b填充的字符串。c，b为str，a为int。
>>>print("鸡你太美".center(31,"6"))
66666666666666鸡你太美66666666666663.str.title(字符串)，返回将这个字符串的每个单词的首字母变成大写。
>>>print(str.title("zhi yin ni tai mei"))
Zhi Yin Ni Tai Mei4.str.upper(字符串)，返回将字符串的小写字母全部变成大写后的字符串。
>>>print(str.upper("zhi yin ni tai mei"))
ZHI YIN NI TAI MEI🏆五、列表（list）
🚩1、基本使用（中等）
先来简单介绍一下列表。
列表，是由一组有序的元素组成，可以用变量保存，用中括号[]标识。
元素就是列表里面可以放的值。
定义方式：
a=[]格式：列表名=[值1,值2…]
列表里面的值可以是字符串，数字，甚至可以列表套列表。这些值用逗号隔开。
a=[1,3.6,True,1+2j,"只因"]
b=[[1,2,3],[4,5,6]]既然可以列表套列表的话···
这招只能在中午用，因为：早晚会出事。
首先是列表的截取。
列表的截取与字符串截取是一样的，单个截取用下标。
多个值截取用[头下标:尾下标+1]，也可以有步长。 见下图：
>>>a=[1,2,3,4,5,6,7]
>>>a[0]
[1]
>>>a[0:4]
[1,2,3,4]
>>>a[:-2:2]
[1,3,5]是不是很简单？
🚩2、列表运算（中等）
列表和字符串一样，也可以进行运算。接下来看看运算符都有哪些：
1.加号+，用来连接两个列表，例如：
print([1,2,3]+[4,5,6])
输出：[1,2,3,4,5,6]
2.乘号*，用来重复列表。例如：
print([1,2,3]*4)
输出：[1,2,3,1,2,3,1,2,3,1,2,3]
3.in，用来判断列表里是否有某个值，例如：
if 1 in [1,2,3]:
print("yes")
输出：yes
4.len()，返回列表长度，其实len也算是函数。例如：
print(len([1,2,3]))
输出：3
🚩3、列表方法（干货）
接下来，学习列表的基本方法。
👍①、列表函数（干货）
首先来学习列表函数，全部都为内置函数，很少，只有四个，都是内置的函数。
1.len(a)函数，上文做过讲解了。
2.max(a)函数，返回列表a里面最大的值。a为列表且内容为整型或浮点型。
print(max([1,3.6,4.5,4]))输出：4.5
3.min(a)函数，返回列表a里面最小的值。a为列表且内容为整型或浮点型。
print(min([1,2,3,4.5,1.1]))输出：1
4.list(a)函数，把a转换为列表。a为Tuple。
a=(1,2,3,4,5)#定义一个元组，后面会学
list(a)
print(a)输出：[1, 2, 3, 4, 5]
👍②、列表使用方法（干货）
接下来是列表常见的改变、使用方法，建议截图收藏！
1.a.append(b)，在a列表的最后一位添加b。a为列表，b为number，list。
a=[1,2,3]
a.append(4)
print(a)输出：[1,2,3,4]
2.a.pop([b])，移出a列表里面的第b位元素，不填默认移出最后一位。a为list。
a=["只因你太美","我是小黑子","我是ikun"]
a.pop(2)
print(a)输出：['只因你太美', '我是小黑子']
3.a.remove(b)，移出列表a里面的b值。与pop的区分是：pop判断的是索引位置，remove判断的是这个值。a为list，b为number，list。
a=[1,2,3,4,5]
a.remove(1)
print(a)输出：[2,3,4,5]
4.a.count(b)，返回在列表a中b出现的次数。a为list，b为number，list。
a=[1,2,3,2,1]
print(a.count(1))输出：2
5.a.extend(b)，在列表a的基础上添加数组b，无返回值。a为list，b为dict，list，tuple，set。若b为dict则只添加键（key）。
a=[1,2,3,4,5]
b=[6,7,8,9]
a.extend(b)
print(a)输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]
6.a.index(b),在列表a里找到第一个b，返回他的索引位置。a为list，b为number，list。
a=["小黑子","树枝",6,6,6]
a.index(6)
print(a.index(6))#返回6的第一个所在索引位置输出：2
7.a.insert(b,c)，在列表a的b位置插入c。a为list，b为索引位置，无返回值。c为number，list。
a=[1,3,4,5]
a.insert(1,2)
print(a)输出：[1,2,3,4,5]
8.a.reverse()，将列表倒序排列。
a=[1,2,3,4,5]
a.reverse()
print(a)输出：[5,4,3,2,1]
9.a.sort([reverse=True])，列表正序排列，加上reverse=True则是倒序排列，还用更高级的用法，这里先不讲。a为list
a=[1,5,4,2,3]
a.sort()
print(a)
a.sort(reverse=True)
print(a)输出：[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
10.a.clear()，清空列表a。a为list。
a=[1,2,3,4,5]
a.clear()
print(a)输出：[]
11.a.copy()，复制列表a。a为list。
a=[1,2,3,4,5]
b=a.copy()
print(b)输出：[1, 2, 3, 4, 5]
🏆六、字典（Dictionary）
🚩1、把字典看成一本字典（简单）
字典是python3的数据类型，可以存储任意对象，存储到变量中，用大括号定义。
为什么要用字典？字典，顾名思义就是查找一个汉字，知道这个字的偏旁，部首，笔顺，释义等等。
a={}我们了解两个全新的概念：键（key），值（value）。键（key）就是字典的汉字，值（value）就是偏旁部首笔顺等，每个键（key）都对应着自己的值（value）。如下图：
键（key）和值（value）可以是任何类型，用冒号隔开，他们两个算是字典里的一个长度。
我们把字典看成一本字典，来理解一下下面的代码。
a={"key1":"value1","key2":"value2"}
print(len(a))输出：2
难理解吗？那我们用把字典看成一本字典的方法来理解这个程序：
a={"一":"一画，独体字","二":"两画，独体字"}
print(len(a))#len(a)求a的长度，后面会学。输出：2
这样是不是清楚多了？字典与其他数据类型的不同点就是它的两个值算一个长度。
有人说：诶诶诶，这本字典不行啊，可不可以一个键对应多个值？
我只能说，字典没有这种方法，但是我们可以把对应的值存到列表里再套用。
a={"一":"[一画，独体字]","二":"[两画，独体字]"}这样既可以对列表的每一项进行修改添加，他又完完全全是一个字典。
🚩2、访问字典（中等）
字典怎么用？就是查找汉字，知道汉字的信息。先举个例子：
a={"鸡":"又字旁，7画","鸭":"甲字旁，10话画"}
print(a["鸡"])输出：又字旁，7画
在中括号里放一个键，则会返回他的值。
格式：字典名称[键]，返回对应的值。
前面一定要放上字典名称，不然你怎么知道你查的是新华字典还是古代汉语词典？
如果键不在字典里呢？说人话就是字典没有收录这个汉字。
a={"鸡":"又字旁，7画","鸭":"甲字旁，10画"}
print(a["鹅"])输出：Traceback (most recent call last):
File "<string>", line 2, in <module>
KeyError: '鹅'
字典里面没有鹅，则会报错。
如果字典里面有两个同样的键呢？
a={"鸡":"又字旁，7画","鸭":"甲字旁，10画","鸡":"错误示范"}
print(a)输出：{'鸡': '错误示范', '鸭': '甲字旁，10画'}
前面的键会被删除。所以，键是不可以重复的。
🚩3、修改字典（中等）
如果字典的编辑出错了，是不是要进行信息的修改？
先举个例子吧：
a={"鸡":"又字旁，10画","鸭":"甲字旁，10画"}
a["鸡"]="又字旁，7画"
print(a)输出：{'鸡': '又字旁，7画', '鸭': '甲字旁，10画'}
上文说了，中括号返回的结果是对应的值，改变的自然就是对应的值。
你还可以删除键（key），用del。
a={"鸡":"又字旁，10画","鸭":"甲字旁，10画"}
del(a("鸡"))
print(a)输出：{'鸭': '甲字旁，10画'}
因为键和值是相连的关系，所以删除键了，对应的值也会删除。
如果想删除整个字典，直接del a就行。
有人说：但我想改变键（key）怎么办？
sorry，键是不可变的。
有人又说：键既然是不可变的，那我要是把键设置成列表不就可以变化了吗？
首先，我要夸赞你很聪明，但是键是不可以设置成列表的。
这就是字典的基本用法，更高级的请看下文字典的函数与用法。
如果你闲着没事，可以自己做出自己的一本网络字典，等你学的更高之后还可以去建设自己的网页，加油！
🚩4、字典的函数以及使用（干货）
下文又是超级干货，建议截图收藏！！！
👍①、字典函数（干货）
字典的函数少的可怜，皆为内置函数。
1.len(a)函数，返回a的长度。注意，一个键和一个值算一个长度。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子"}
print(len(a))输出：2
2.str(a)函数，将a转换成字符串。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子"}
a=str(a)
print(a)
print(a[0:2])#字符串的截取方法，意思就是证明字典变成了字符串输出：{'我喜欢我家哥哥': 'ikun', '你干嘛哈哈诶呦': '小黑子'}
{'
3.type(a)函数，返回a的类型。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子"}
print(type(a))
输出：<class 'dict'>
👍②、字典使用方法（干货）
以下是字典的详细使用方法，还是截图收藏。
1.a.clear()，删除字典的所有元素，注意和del的差别，del会直接删除这个变量，clear删除之后还会保留字典，成为空字典。a为dict。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子"}
a.clear()
print(a)输出：{}
2.a.copy()，复制字典。a为dict。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子"}
b=a.copy()
print(b)输出：{'我喜欢我家哥哥': 'ikun', '你干嘛哈哈诶呦': '小黑子'}
3.a.pop(b[,c])，删除字典里的b键并返回，b键对应的值也会删除。若有c则是检测不到b键时返回，若没有c且检测不到b键则报错。a为dict。b为number，str。c为任何。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子"}
b=a.pop("只因你太美","检测不到")
print(b)
a.pop("我喜欢我家哥哥")
print(a)输出：检测不到
{'你干嘛哈哈诶呦': '小黑子'}
4.a in b，检测字典b里面有没有键a，有返回True，没有返回False。a为number，str。b为dict。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子"}
if "只因你太美" in a:
print("你干嘛~~~")
else:
print("你是小黑子！！！")输出：你是小黑子！！！
5.dict.fromkeys(a[,b])函数，返回一个字典，将a里的所有值变成字典里的键，如果有b则是字典里的所有值都为b，值默认为None。a为number，str。b为任何。注意：创造的字典值都是一样的，值都是b。
list=[1,2,3]
a=dict.fromkeys(list)
print(a)
b=dict.fromkeys(list,1)
print(b)
c=dict.fromkeys(list,list)输出：{1: None, 2: None, 3: None}
{1: 1, 2: 1, 3: 1}
{1: [1, 2, 3], 2: [1, 2, 3], 3: [1, 2, 3]}
6.a.get(b[,c])，在字典a里返回键b对应的值，若没有b返回c，若没有设置c则返回None。是不是似曾相识？他和pop一个是删除，一个是返回。a为dict。b为；number，str。c为任何。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子"}
print(a.get("我喜欢我家哥哥"))
print(a.get("只因你太美"))
print(a.get("只因你太美","没有"))输出：ikun
None
没有
7.a.keys和a.items和a.values，这三个涉及高级一点的知识视图对象，先不讲
8.a.setdefault(b[,c])，和get差不多，区别是如果键不存在，则插入b键和c值，c默认为None。如果b在a里，返回b对应的值。如果不在返回c。a为dict。b为number，str。c为任何。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子"}
print(a.setdefault("我喜欢我家哥哥"))
print(a.setdefault("只因你太美"))
print(a.setdefault("小黑子树枝",666))
print(a)输出：ikun
None
666
{'我喜欢我家哥哥': 'ikun', '你干嘛哈哈诶呦': '小黑子', '只因你太美': None, '小黑子树枝': 666}
9.a.update(b)，在字典a的基础上添加字典b。a，b为dict。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子"}
b={"小黑子树枝":666}
a.update(b)
print(a)输出：{'我喜欢我家哥哥': 'ikun', '你干嘛哈哈诶呦': '小黑子', '小黑子树枝': 666}
10.a.popitem()，删除字典a的最后一组键和值。在python3.7之前返回的是被删除的值，在python3.7之后···
好吧我也看不懂。
a={"我喜欢我家哥哥":"ikun","你干嘛哈哈诶呦":"小黑子","小黑子树枝":666}
a.popitem()
print(a)输出：{'我喜欢我家哥哥': 'ikun', '你干嘛哈哈诶呦': '小黑子'}
🏆七、元组（Tuple）（简单）
🚩1、基本介绍（简单）
元组的用法和列表差不多，差别在于不能修改，用小括号()定义。
元组创建方法很简单：
a=(1,2.5,True,"鸡你太美",1+2j,[1,2,3])这是元组里面可以包含的值：number，str，list。
最基本的用法就是截取，和列表的截取方法一样。
a=("你干嘛哈哈诶呦","鸡你太美","小黑子树枝666")
print(a[1])
print(a[0])输出：鸡你太美
你干嘛哈哈诶呦
🚩2、修改元组（简单）
这时有人会问了：诶诶诶，刚不是说了不能修改元组，咋又冒出来个修改？
但是我们可以对元组进行整体删除，这也算修改。
我们只能直接删除整个元组。
a=(1,2,3,4,5,6)
del a这时候再去访问a，a就不存在了。
🚩3、元组运算符（简单）
我们可以对元组进行运算。现在a为(1,2,3)，b为(4,5,6)。
| 操作 | 返回 | 作用 |
| len(a) | 3 | 返回元组长度 |
| a+b | (1,2,3,4,5,6) | 两个元组相接 |
| a*4 | (1,2,3,1,2,3,1,2,3,1,2,3) | 复制元组 |
| 3 in a | True | 元组是否包含某个元素 |
还有for循环迭代，我们还没有学习循环，先不讲。
🚩4、元组内置函数（简单）
1.len(a)，见上。a为Tuple。
2.max(a)，求元组里面的最大值，a为number。
a=(1,2,3)
print(max(a))输出：3
3.min(a)，求元组里面的最小值，a为Tuple且内容为number。
a=(1,2,3)
print(min(a))输出：1
4.tuple(),将列表转换为元组。a为list。
a=[1,2,3]
print(tuple(a))输出：(1,2,3)
🏆八、集合（set）（中等）
接下来是最后一个数据类型——集合的学习。
🚩1、什么是集合（简单）
集合（set）是一个无序的不重复元素序列。
无序：没有顺序也没必要分清楚顺序。
不重复：里面的值不能重复。
我们要用一个大括号来创建集合。
a={1,2,3}不过我们如果要定义一个空的集合，不能用大括号，因为大括号是用来创建空字典的，要用set函数。
a=set()
a就是一个空集合了。
集合不能有重复的元素否则会自动删除。
a={1,2,3,1,2,3}
print(a)输出：{1,2,3}
🚩2、集合基本用法（中等）
我们可以把列表转换为集合来去重。
a=[1,2,3,1,2,3]
a=set(a)
print(a)
a=list(a)
print(a)输出：{1, 2, 3}
[1, 2, 3]
我们先转换成了集合，再转换成了列表，就去除了列表的重合项。
我们还可以检测集合里有没有一个元素，例如：
a={1,2,3,4,5}
if 3 in a:
print("yes")输出：yes。
接下来学习两个集合之间的运算。
a={1,2,4,6,8,9}
b={1,3,5,6,7,8}
print(a-b)
print(a|b)
print(a&b)
print(a^b)
输出：{9, 2, 4}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{8, 1, 6}
{2, 3, 4, 5, 7, 9}
来讲解一下吧。
首先，a-b的意思是a有b没有的元素，为2，4，9。
a|b的意思是a和b所有的元素，为1，2，3，4，5，6，7，8，9，就相当于连接两个集合。
a&b的意思是a和b都有的元素，为8，1，6。
a^b的意思是a有b没有的元素和a没有b有的元素加起来。
这种死概念只有多背，多敲，多用。
🚩3、集合的全部用法（干货）
1.a.add(b)，在集合里面添加b。a为set。b为number，str，list。
a={1,2,3,4,5}
a.add(6)
print(a)输出：{1,2,3,4,5,6}
2.a.clear()，清空集合，与del的区别是del是直接删除集合，而clear是变成空集合。a为set。
a={1,2,3}
a.clear()
print(a)输出：set()
3.a.copy()，复制a。a为set。
a={1,2,3}
b=a.copy()
print(a)输出：{1,2,3}
4.a.difference(b,c…)，返回所有在a里面，但不在b里面的元素（等于a-b）。可以检查多个值与a的差集，用逗号隔开。a，b…为set。
a={1,2,3}
b={1,4,5}
c={1,2,6}
d=a.difference(b,c)
print(d)
d=a.difference(b)
print(d)输出：{3}
{2, 3}
5.a.union(b,c…)，返回a与b的并集，可以检测多个值与a的并集，用逗号隔开。a，b…为set。
a={1,2,3}
b={1,4,5}
c={1,2,6}
print(a.union(b,c))输出：{1,2,3,4,5,6}
6.a.pop()，随机移除a里面的一个元素且返回这个元素。a为set。
a={1,2,3}
a.pop()
print(a)输出：{1,3}
7.a.difference_update(b,c…)，移除a和b同时存在的元素。可以检测多个集合。无返回值。a，b…为set。
a={1,2,3}
b={1,6,5}
c={1,2,6}
a.difference_update(b,c)
print(a,b,c)输出：{3} {1, 5, 6} {1, 2, 6}
8.a.discard(b)，删除a集合里面的b元素。若找不到该元素不做处理。a为set。b为number，str。
a={1,2,3}
a.discard(1)
print(a)
a.discard(4)
print(a)输出：{2,3}
{2,3}
9.a.remove(b)，同a.discard(b)，不过remove如果找不到元素会报错。a为set。b为number，str。
a={1,2,3}
a.remove(1)
print(a)
a.remove(4)
print(a)输出：{2, 3}
Traceback (most recent call last):
File "<string>", line 4, in <module>
KeyError: 4
因为找不到4所以会报错。
10.a.update(b)，同a.add(b)，不同的是update还可以两个集合相接。a为set。b为number，str，set。
a={1,2,3}
b={1,6,5}
a.update(b)
print(a)输出：{1,2,3,5,6}
11.a.intersection(b,c…)，返回二个集合的共有元素。可以检测多个集合。a，b，…为set。
a={1,2,3}
b={1,4,5}
c={1,2,6}
print(a.intersection(b,c))输出：1
12.a.intersection_update(b,c…)，a只保留二个集合的共有元素。可以检测多个集合。a，b…为set。
a={1,2,3}
b={1,4,5}
c={1,2,6}
a.intersection_update(b,c)
print(a,b,c)输出：{1} {1, 4, 5} {1, 2, 6}
13.a.isdisjoint(b)，判断ab是否有相同元素，没有返回True，有返回False。a，b为set。
a={1,2,3}
b={1,4,5}
if a.isdisjoint(b):
print("两者有相同元素。")输出：
14.a.issubset(b),判断a的元素b是不是全都有，是返回True，不是返回False。a，b为set。
a={1,2,3}
b={1,2,3,4,5}
if a.issubset(b):
print("yes")输出：yes
15.a.issuperset(b)，判断b的元素a是不是全都有，是返回True，不是返回False。a，b为set。
b={1,2,3}
a={1,2,3,4,5}
if a.issubset(b):
print("yes")输出：yes
16.a.symmetric_difference(b)，返回a有b没有和b有a没有的元素。a，b为set。
a={1,2,3}
b={1,4,5}
print(a.symmetric_difference(b))输出：{2, 3, 4, 5}
17.a.symmetric_difference_update(b)函数，名字超长有没有？把a有b没有和b有a没有的元素全部保存到a。a，b为set。
a={1,2,3}
b={1,4,5}
a.symmetric_difference_update(b)
print(a)输出：{2,3,4,5}
🏆九、回顾与练习
恭喜你，已经看完了这篇《数据类型和变量》，掌握了数据类型所有知识。
我们再宏观回顾一下。
我们一共学习了六个数据类型，对数字进行了详细讲解，其中浮点数运算为重难点。
之后学习了字符串，了解了下标，截取等重难点。
之后又学习了列表，这个最常用的数组，也是一个重难点。
接着是字典，我们用把字典当成一本字典的思维去理解，攻克了键，值的重难点。
接着是元组，有些冷门，不过正是因为冷门，难点···可以说是没有难点，这算是最简单的了，元组的标签作者是全标注的简单。
最后是集合，集合可以说是没有思考，就是纯干货，17个使用方法和几十个基础使用，就很离谱。
其实一共就这么多内容，还是很好学的。那就来考个试吧～～～
接下来，就是对学习成果的检验。准备好了吗？
🚩1、填空题（50分）
填写标准答案，一题五分，
1.请说出：python的六个数据类型和对应的英文。（5分）
2.请说出：Number的四个类型和对应的英文。（5分）
3.请问：变量a是不是一位小数？（5分）
a=1.1-1.04.0.0等于0吗？（5分）
5.a=a+1运行出来会报错吗？（5分）
6.返回列表的长度要用什么函数？（5分）
7.pow函数从数学函数里调用和直接当内置函数有差别吗？（5分）
8.字典的key和value哪个可以改变？（5分）
9.请用两种方法判断ab两个集合共同拥有的元素。（10分）
🚩2、代码题（50分）
请实现效果：
创造一个字典并且收录汉字“一”和“二”，并且收录对应信息。（获得10分）
判断对方查找的是“一”还是“二”，输入“一”则输出汉字一的对应信息，输入“二”则输出汉字二的对应信息，若都不是则发送字典还没有收录该汉字。（获得20分）
资料：一，汉语常用字 ，读作yī或yí或yǐ或yì，最早见于甲骨文，其本义为最小原始单位，最小的正整数，后引申为相同的，无二至的、整体的、全部的、整个的、所有的等。
二，汉语常用字 ，读作èr，最早见于甲骨文 ，其本义为由混沌分出的天、地两极，后引申为一加一的和、排列顺序中第二位的、不专一、不忠诚等。
如果输入的是114514则进入修改界面，询问对方要修改哪一个字典，如果有则询问对方的修改内容并且储存，如果没有则提示字典没有该汉字.（获得20分）
程序如下：
注：如果能额外完成一项功能再加20分:输入10086时，让用户输入要填写的汉字和释义，保存到字典，查找这个字的时候就会显示这个字的释义。
🚩答案：
1，Number数字，String字符串，List列表，Dictionary字典，Set集合，Tuple元组。
2，整型int，浮点型float，布尔类型bool，复数complex。
3，不是，浮点数减法会取离结果最近的数。
4，不等于。
5，不会，编程中=是赋值的意思，所以变量a会自己加一。
6，len()函数。
7，有差别，数学函数的pow只能填两个值，返回浮点数；内置函数的pow可以填三个值，返回整数。
8，value可以改变。
9，①，a&b。
②，a.intersection(b)。
代码题：
a={"一":"一，汉语常用字 ，读作yī，最早见于甲骨文，其本义为最小原始单位，最小的正整数，后引申为相同的，无二至的、整体的、全部的、整个的、所有的等。","二":"二，汉语常用字 ，读作èr，最早见于甲骨文 ，其本义为由混沌分出的天、地两极，后引申为一加一的和、排列顺序中第二位的、不专一、不忠诚等。"}
while True:
b=input("输入要查询什么")
if b=="一":
print(a["一"])
elif b=="二":
print(a["二"])
elif b=="114514":
c=input("要修改哪个汉字？")
if c=="一":
d=input("输出修改内容")
a["一"]=d
elif c=="二":
d=input("输出修改内容")
a["二"]=d
else:
print("该汉字没有收录。")
else:
print("该汉字没有收录。")
收录汉字为额外的扩展题，有兴趣的可以试试。
🏆十，尾声
我这学期写的作文加起来还没这篇文章多，可能是数据类型的讲解范围太大了，居然写了一篇20000字的超长文章，属实奇迹了。在想要是我分开发是不是热度更多一点呢···
咱就是说希望热度高一点吧，写的五六天也不白费。就很乌鱼的，散会！
———————————————————–end—————————————————————–
文章出处登录后可见！
