python详解——数据类型与变量

Posted 2023-04-02 ¿¿¿¡¡¡

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python详解——数据类型与变量相关的知识，希望对你有一定的参考价值。

本文为原创作品，若与其他作品雷同，纯属巧合。请勿抄袭。

目录

🏆一、前言

🏆二、数据类型and变量

🚩1、数据类型（简单）

🚩2、变量（中等）

🏆三、数字（number）

🚩1、整型浮点型一起学（中等）

👍①、认识（简单）

👍②、整型运算（中等）

👍③、浮点型运算（困难）

👍④、整型、浮点型混合运算（简单）

🚩2、复数和布尔值一起学（中等）

🚩3、数据类型转换（简单）

🚩4、数学函数（干货）

🏆四、字符串（string）

🚩1、简单定义（简单）

🚩2、截取字符串（困难）

🚩3、转义字符（干货）

🚩4、字符串运算（中等）

🚩5、格式化字符串（困难）

🚩6、字符串函数（干货）

🏆五、列表（list）

🚩1、基本使用（中等）

🚩2、列表运算（中等）

🚩3、列表方法（干货）

👍①、列表函数（干货）

👍②、列表使用方法（干货）

🏆六、字典（Dictionary）

🚩1、把字典看成一本字典（简单）

🚩2、访问字典（中等）

🚩3、修改字典（中等）

🚩4、字典的函数以及使用（干货）

👍①、字典函数（干货）

👍②、字典使用方法（干货）

🏆七、元组（Tuple）（简单）

🚩1、基本介绍（简单）

🚩2、修改元组（简单）

🚩3、元组运算符（简单）

🚩4、元组内置函数（简单）

🏆八、集合（set）（中等）

🚩1、什么是集合（简单）

🚩2、集合基本用法（中等）

🚩3、集合的全部用法（干货）

🏆九、回顾与练习

🚩1、填空题（50分）

🚩2、代码题（50分）

🚩答案：

🏆十，尾声

🏆一、前言

（别问我为什么封面这么丑）

任何编程语言里都有很多的数据类型，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

这时，程序会先运算5*4为20，再a=20。

接下来看一段代码：

a=2
print(a)
a=3
print(a)

输出：2

让我们来理解一下这段代码。

赋值的意思就是：给一个变量他的值。

现在把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")

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	两数相减
: ab	18	两数相乘
/: a/b	2.0	两数相除
//: a//b	2	两数相除（向下取余）
%: a%b	0	两数整除余数
: ab	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)
小黑子树枝666

3.[]和[:]，见上文

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鸡你太美6666666666666

3.str.title(字符串)，返回将这个字符串的每个单词的首字母变成大写。

>>>print(str.title("zhi yin ni tai mei"))
Zhi Yin Ni Tai Mei

4.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）

详解Python变量在内存中的存储

这篇文章主要是对python中的数据进行认识，对于很多初学者来讲，其实数据的认识是最重要的，也是最容易出错的。本文结合数据与内存形态讲解python中的数据，内容包括：

引用与对象
可变数据类型与不可变数据类型
引用传递与值传递
深拷贝与浅拷贝

（id函数：你可以通过python的内置函数 id() 来查看对象的身份(identity)，这个所谓的身份其实就是对象的内存地址）

一、引用与对象：引用与对象的关系：
这里写图片描述

#创建两个对象
name1=\'wupeiqi\'
name2=\'alex\'

这里写图片描述

对象：当创建数据对象时，在内存中会保存对象的值，这个值就是对象自己；（字符串对象：”wupeiqi”）
引用：对象保存在内存空间，外部想要使用对象的值，需要使用引用，就是‘name1’,’name2’。内存会保存对象的引用数量，当某个对象的引用数量为0时，对象会被回收。

二、可变数据类型与不可变数据类型
1，数据分类：

可变数据类型：列表list和字典dict
不可变数据类型：整型int、浮点型float、字符串型string和元组tuple

这里的可变不可变，是指内存中的那块内容（value）是否可以被改变。如果是不可变类型，在对对象本身操作的时候，必须在内存中新申请一块区域(因为老区域不可变)。如果是可变类型，对对象操作的时候，不需要再在其他地方申请内存，只需要在此对象后面连续申请(+/-)即可，也就是它的address会保持不变，但区域会变长或者变短。

（1）python中的不可变数据类型，不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象，内部会有一个引用计数来记录有多少个变量引用这个对象；
（2）可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。”

2，不可变数据类型：不可变是指对象本身的值是不可变的（当你创建a=1整型对象，用a去引用它，内存中的对象1是不变得，当执行a=2时，只是重新创建了对象2，用a引用，如果1对象没有其他引用会被回收）

>>> x = 1
>>> id(x)
31106520
>>> y = 1
>>> id(y)
31106520
>>> x = 2
>>> id(x)
31106508
>>> y = 2
>>> id(y)
31106508
>>> z = y
>>> id(z)
31106508

解释：这里的不可变大家可以理解为x引用的地址处的值是不能被改变的，也就是31106520地址处的值在没被垃圾回收之前一直都是1，不能改变，如果要把x赋值为2，那么只能将x引用的地址从31106520变为31106508，相当于x = 2这个赋值又创建了一个对象，即2这个对象，然后x、y、z都引用了这个对象，所以int这个数据类型是不可变的，如果想对int类型的变量再次赋值，在内存中相当于又创建了一个新的对象，而不再是之前的对象。从下图中就可以看到上面程序的过程。
这里写图片描述

3，可变对象：可变是指对象本身的值是可变的（list,dict对象的值其实是引用了其他对象，当改变对象的值时，其实是引用了不同的对象）

>>> a = [1, 2, 3]
>>> id(a)
41568816
>>> a = [1, 2, 3]
>>> id(a)
41575088
>>> a.append(4)
>>> id(a)
41575088
>>> a += [2]
>>> id(a)
41575088
>>> a
[1, 2, 3, 4, 2]

解释：（1）进行两次a = [1, 2, 3]操作，两次a引用的地址值是不同的，也就是说其实创建了两个不同的对象，这一点明显不同于不可变数据类型，所以对于可变数据类型来说，具有同样值的对象是不同的对象，即在内存中保存了多个同样值的对象，地址值不同。
（2）我们对列表进行添加操作，分别a.append(4)和a += [2]，发现这两个操作使得a引用的对象值变成了上面的最终结果，但是a引用的地址依旧是41575088，也就是说对a进行的操作不会改变a引用的地址值，只是在地址后面又扩充了新的地址，改变了地址里面存放的值，所以可变数据类型的意思就是说对一个变量进行操作时，其值是可变的，值的变化并不会引起新建对象，即地址是不会变的，只是地址中的内容变化了或者地址得到了扩充。下图对这一过程进行了图示，可以很清晰地看到这一过程。
这里写图片描述