python基础——数据类型

一、变量

什么是变量？当你把值赋给一个名字时，它会存储在内存中，把这块内存称为变量。
使用变量时需要注意以下几点：

• 在使用变量之前，需要先对其赋值
• 变量名可以包括数字、字母、下划线，但变量名不能以数字开头
• 变量名中字母可以是大写或小写，但大小写是不同的
• 等号是赋值的意思，左边是名字，右边是值，不可弄反了
• 变量的命名可以是任意合法的名字，但尽量见名知义

二、数值类型

类型	英文简写
整型	int, 例：a=1
浮点型	float, 例：b=1.1
布尔型	bool, 例：c=True
复数型	complex, 例：d=1+2j

三、序列类型

python的序列类型非常丰富，下面我们着重介绍一下字符串、列表以及元组

字符串

1、字符串的定义

定义：字符串(str)也叫文本，创建字符串时，需在字符两边加上引号，可以是单引号或双引号，当然，如果是多行文本的情况下，可以使用三引号。

例：

>>> 5 + 8
13
>>> '5' + '8'
'58'

如果是直接让两个数字相加，那么Python会直接将数字相加后的结果告诉你，但是如果在数字的两边加上了引号，就变成了字符串的拼接，这正是引号带来的差别。

那么问题来了，如果字符串中需要出现单引号或双引号怎么办？？

>>> 'Let's go'
SyntaxError: invalid syntax

像上边这样写Python会误会你的意思，从而产生了语法错误。
第一种解决方法，也比较常用，使用转移符号()对字符串中的引号进行转义：

>>> 'Let\'s go'
"Let's go"

第二种方法，用双引号包含单引号：

>>> "Let's go"
"Let's go"

2、原始字符串

听起来反斜杠好像是个好东西，不妨打印下C:\now试试

>>> print('C:\now')
C:
ow

这个打印结果貌似和我们预期的不太一样呢，原因是反斜杠()和后边的字符(n)恰好转移之后构成了换行符(\n)

方法①(使用反斜杠转义反斜杠)：

>>> print('C:\\now')
C:\now

方法②(使用原始字符串)：

>>> string = r'C:\now'
>>> string
'C:\\now'
>>> print(string)
C:\now

注意：无论是否原字符串，都不能以反斜杠作为结尾，反斜杠放在字符串的末尾表示该字符串还没有结束，换行继续的意思。

3、字符串的常用方法

• 字符串可实现索引和分片

>>> str1 = 'I love you'
>>> str1[0]
'I'
>>> str[:6]
'I love'

• split()和join()方法：

 >>> str1 = 'I love you'
 >>> str1.split(' ')
 ['I', 'love', 'you']
 >>> str2 = '_'.join('hello')
 >>> str2
 'h_e_l_l_o'
 >>> str2.split('_')
 ['h', 'e', 'l', 'l', 'o']

方法	含义
count(sub)	返回sub在字符串里边出现的次数
find(sub)	检测sub是否包含在字符串中，如果有则返回索引值，否则返回-1
isdigit()	如果字符串中只包含数字字符，则返回True,否则返回False
replace(old, new)	把字符串中的old子字符串替换成new子字符串
lower()	转换字符串中所有大写字符为小写
upper()	转换字符串中所有小写字符为大写
startswith(pre)	检测字符串是否以pre开头，是则返回True,否则返回False
endswith(sub)	检测字符串是否以sub子字符串结束，是则返回True,否则返回False

4、格式化

格式化字符串：就是按统一的规格去输出一个字符串

• format()
  format()方法接受位置参数和关键字参数

>>> "{0} like {1} and {2}".format('I', 'rap', 'basketball')
'I like rap and basketball'

如上所示，字符串中的{0},{1},{2}应该跟位置有关，依次被format()的三个参数替换，那么format()的三个参数就叫位置参数，那位置参数又是什么呢？再来看一个例子

>>> "{a} love {b} and {c}".format(a='I', b='rap', c='basketball')
'I love rap and basketball'

{a},{b},{c}就相当于三个标签，format()将参数中等值的字符串替换进去，这就是关键字参数啦！也可结合位置参数和关键字参数一起使用：

>>> "{0} love {b} and {c}".format('I',  b='rap', c='bascketball')
'I love rap and basketball'

但是要注意的是，如果将位置参数和关键字参数综合一起使用，那么位置参数必须在关键字参数之前，否则就会报错！

5、格式化操作符

• python格式化符号及含义

符号	含义
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e,用科学计数法格式化浮点数
%g	根据值的大小决定使用%f或%e
%G	作用同%g,根据值的大小决定使用%f或%E

6、python的转义字符及含义

符号	含义
\’	单引号
\"	双引号
\a	发出系统响铃声
\b	退格符
\n	换行符
\t	横向制表符(TAB)
\v	纵向制表符
\r	回车符
\f	换页符
\o	八进制代表的字符
\x	十六进制代表的字符
\0	表示一个空字符
\\	反斜杠

列表

有时候需要把一堆东西暂时存储起来，因为它们有某种直接或间接的联系，需要把它们放进某种“组”或“集合”中，因为将来可能用的上，大家应该听说过数组这个玩意儿吧，数组有一个基本要求，就是你所放在一起的数据必须类型一致。但是呢？python加入了更为强大的列表(list)。

python的列表有多强大？如果把数组比作是一个集装箱的话，那么python的列表就是一个工厂的仓库了！！！

1、创建列表

• 创建一个空列表

>>> temp = []

• 创建一个都是数字的列表

>>> number = [1, 2, 3, 4, 5]

• 创建一个鱼龙混杂的列表

>>> mix = [1, '哈哈', 3.1415926, [1, 2, 3]]

2、向列表添加元素

• append(): 只能向列表末尾添加一个

>>> number = [1, 2, 3]
>>> number.append(4)
>>> number
[1, 2, 3, 4]

可以看到，参数4已经被添加到列表number的末尾了

• extend(): 像列表中末尾添加多个，它的参数一般为一个列表

>>> number.extend([5, 6])
>>> number
[1, 2, 3, 4, 5, 6]

• insert(a, b): a代表在列表中的位置，b代表在这个位置要插入的元素
  不妨来试一下让数字0出现在列表number的最前边：

>>> number.insert(1, 0)
>>> number
[1, 0, 2, 3, 4, 5, 6]

啊哈？？这跟我们想要的不太一样啊，怎么插入后0还是在1的后边呢？其实是这样的：凡是顺序索引，python均从0开始，同时这也是大多数编程语言约定俗成的规范。
所以，正确的做法应该是：

>>> number = [1, 2, 3]
>>> number.insert(0, 0)
>>> number
[0, 1, 2, 3]

3、向列表获取元素

跟数组一样，可以通过元素的索引值(index)从列表获取单个元素，注意，列表的索引值是从0开始的。

>>> name = ['张三', '李四', '王五', '赵六']
>>> name[0]
'张三'
>>> name[3]
'赵六'

那按照这个方法让‘张三’和‘赵六’的位置互换

>>> name[0], name[3] = name[3], name[0]
>>> name
['赵六', '李四', '王五', '张三']

4、从列表中删除元素

• remove(): 指定删除列表中的单个元素，若元素不存在则报错

>>> number = [1, 2, 3]
>>> number.remove(1)
>>> number
[2, 3]

remove()方法并不能指定删除某个列表中某个位置的元素，这时候就要用del来实现

>>> number = [1, 2, 3]
>>> del number[1]
>>> number
[1, 3]

注意：del是一个语句，不是一个列表的方法，所以你不必在他后边加上小括号()。另外，如果你想删除整个列表，还可以直接用del加列表名删除。

>>> del number
>>> number
NameError: name 'number' is not defined

• pop(): 默认删除列表的最后一个元素

>>> number = [1, 2, 3]
>>> number.pop()
3
>>> number
[1, 2]

当你为它加上一个索引值作为参数的时候，它会删除这个索引值对应的元素

>>> num = [1, 2, 3]
>>> num.pop(0)
1
>>> num
[2, 3]

5、列表分片

利用索引值，每次只能从列表中获取一个元素，如果需要一次性获取多个元素，有没有办法实现呢？？这时候就要用到我们的分片(slice)啦！！！

>>> num = [1, 2, 3, 4, 5]
>>> num[0:2]
[1, 2]

很简单吧，只不过是用一个冒号隔开两个索引值，左边是开始位置，右边是结束位置，但是要注意，结束位置上的元素是不包含的，左开右闭。
python素以‘简洁’闻名于世，列表分片也是可以简写的。

>>> num[:3]
[1, 2, 3]
>>> num[1:]
[2, 3, 4, 5]
>>> num[:]
[1, 2, 3, 4, 5]

如果没有开始位置，python会默认开始位置是0。同样道理，如果要得到从指定索引值到列表末尾的所有元素，把结束位置省去即可。如果没有放入任何索引值，而只有一个冒号，将得到整个列表的拷贝。

注意：列表分片就是建立原列表的一个拷贝(或者说副本)，所以如果你想对列表做出某些修改，但同时还想保持原来的那个列表，那么直接使用分片的方法来获取拷贝就很方便啦！

分片操作实际上还可以接收第三个参数，其代表的是步长，默认情况下，该值为1，来试试将其改为2会有什么效果？

>>> list1 = [1, 2, 3, 4, 5, 6, 7, 8]
>>> list1[0:5:2]
[1, 3, 5]

如上所示，本来去取出的应该是[1, 2, 3, 4, 5],当步长设置为2后变为[1, 3, 5]了，因为它是按每两个元素取前面一个的规则来选取的。
如果将步长设置为负数，例如-1,结果会怎样呢？？不妨试试看：

>>> list1[::-1]
[8, 7, 6, 5, 4, 3, 2, 1]

是不是很有意思？？这里步长设置为-1，就相当与复制一个反转的列表。

6、列表的一些常用方法补充

• count(): 计算它的参数在列表中出现的次数

>>> num = [1, 2, 1, 4, 1]
>>> num.count(1)
3
>>> num.count(0)
0

• index(): 返回它的参数在列表中的位置

>>> num = [1, 2, 3]
>>> num.index(1)
0

• reverse(): 将整个列表原地翻转

>>> num = [1, 2, 3]
>>> num.reverse()
>>> num
[3, 2, 1]

• sort(): 用指定的方式对列表的成员进行排序，默认不需要参数，从小到大，当使用参数reverse=True时，按从大到小排序

>>> num = [1, 0, 3, 4, 2]
>>> num.sort()
>>> num
[0, 1, 2, 3, 4]
>>> num.sort(reverse=True)
>>> num
[4, 3, 2, 1, 0]

7、关于分片拷贝概念的补充

前面提到过使用分片创建列表的拷贝：

>>> a = [1, 3, 2, 4]
>>> b = a[:]
>>> b
[1, 3, 2, 4]
>>> c = a
>>> c
[1, 3, 2, 4]

看似一样，对吧？？但事实上呢？？做以下修改后，大家再看看差别：

>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> b
[1, 3, 2, 4]
>>> c
[1, 2, 3, 4]

可以看到当a排序后，使用分片方式得到的b并没有发生改变，而通过直接赋值得到的c却随着a的改变而改变了，这是为啥呢？？我们用查看它们各自的id看看

>>> id(a)
2987563179272
>>> id(b)
2987563178696
>>> id(c)
2987563179272

可以看到，a和c的内存地址是一样的，而b却跟它两不一样，这下明白了把，通过赋值方式得到的c并没有给它分配新的内存地址，而是使用了原来a的，而通过切片方式得到的b分配到了新的内存地址，因此，真正的拷贝是要使用分片的方法！！！

元组

由于列表过分强大，python的作者觉得这样似乎不妥，于是发明了列表的“表亲”——元组(tuple)

元组和列表最大的区别就是你可以任意修改列表中的元素，可以任意插入或者删除一个元素，而对元组是不行的，元组是不可改变的(像字符串一样)，所以你也别指望对元组进行排序等高级操作了。

1、创建和访问一个元组

创建列表用的是中括号，而创建元组大部分用的是小括号

>>> tuple1 = (1, 2, 3, 4, 5)
>>> tuple1
(1, 2, 3, 4, 5)

访问元组的方式与列表无异

>>> tuple[1]
2
>>> tuple[2:]
(3, 4, 5)

也使用分片的方式来复制一个元组

>>> tuple2 = tuple1[:]
>>> tuple2
(1, 2, 3, 4, 5)

如果试图修改元组的一个元素，那么抱歉，python会很不开心：

>>> tuple1[0] = 0
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    tu[0] = 0
TypeError: 'tuple' object does not support item assignment

我们都知道列表的标志性符号是中括号，那么元组呢？？你也许会觉得这还用问嘛，当然是小括号啦！那你可真是个小笨蛋呢，哈哈哈，记住，元组的标志性符号是逗号(,)，下面我来告诉你为什么：

>>> temp = (1)
>>> type(temp)
<class 'int'>
>>> temp = 1, 2, 3
>>> type(temp)
<class 'tuple'>

哦豁，发现了吧？就算没有小括号，temp还是元组类型，所以逗号才是关键！！！
如果你想创建一个空元组，那么你直接使用小括号即可：

>>> temp = ()
>>> type(temp)
<class 'tuple'>

所以这里要注意的是：如果要创建的元组中只有一个元素，请在这个元素后边加上一个逗号(,)，这样可以明确告诉python你要的是一个元组：

>>> temp = (1,)
>>> type(temp)
<class 'tuple'>
>>> temp1 = 1,
>>> type(temp1)
<class 'tuple'>

2、更新和删除元组

啊哈？？元组不是不可以改变嘛？？哼，确实，元组不能直接修改，但是我们可以用一种相对含蓄的做法来对它进行修改！！

>>> temp = ('猪', '鸡', '狗')
>>> temp = temp[:2] + ("鱼",) + temp[2:]
>>> temp
('猪', '鸡', '鱼', '狗') 

通过这样的方法，就可以成功的插入“鱼”啦！要注意这里逗号是必须的，小括号也是必须的！
间接的删除一个元素：

>>> temp = temp[:2] + temp[3:]
>>> temp
('猪', '鸡', '狗')

如果要删除整个元组，只要使用del语句即可显式的删除一个元组：

>>> del temp
>>> temp
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    temp
NameError: name 'temp' is not defined

其实在日常使用中，很少使用del去删除元组，因为python的回收机制会在这个元组不再被使用到的时候自动删除！

序列的内建方法

序列的共同点：

• 都可以通过索引得到每一个元素
• 默认索引值 总是从0开始
• 可以通过分片的方法得到一个范围内的元素集合
• 有很多共同的操作符(重复操作符、拼接操作符、成员关系操作符)

下面介绍一些序列常用的BIF(内建方法)。

• list([iterable])：将可迭代对象转换为列表

>>> # 创建一个空列表
>>> a = list()
>>> a
[]
>>> # 将字符串的每个字符迭代存放到列表中
>>> b = list('abcdef')
>>> b
['a', 'b', 'c', 'd', 'e', 'f']
>>> # 将元组中的每个元组迭代存放到列表中
>>> c = list((1, 2, 3, 4))
>>> c
[1, 2, 3, 4]

• tuple([iterable])：将可迭代对象转换为元组，具体用法和list()一样
• str(obj)：把obj对象转换为字符串

>>> a = 1
>>> a = str(a)
>>> type(a)
<class 'str'>

• len(sub)：用于返回sub参数的长度

>>> temp = [1, 2, 3, 4]
>>> len(temp)
4
>>> s = 'hahaha'
>>> len(s)
6

• max(…)：返回序列或者参数集合中的最大值

>>> list1 = [1, 4, 5, 7]
>>> max(list1)
7
>>> str1 = 'I like it'
>>> max(str1)
't'
>>> max(0, 1, 2)
2

• min(…)：用法跟max()一样，但效果相反：返回序列或者参数集合中的最小值。注意：使用max()方法和min()方法都要保证序列或参数的数据类型统一，否则会报错。

>>> min(1, 'a', 'haha')
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    min(1, 'a', 'haha')
TypeError: '<' not supported between instances of 'str' and 'int'

• sum(iterable[,start])：返回序列的总和，用法跟max()和min()一样。但sum()方法有一个可选参数(start)，如果设置该参数，表示从该值加起，默认值是0。

>>> tuple1 = (1, 2, 3, 4, 5)
>>> sum(tuple1)
15
>>> sum(tuple1, 10)
25

• sorted(iterable, key=None, reverse=False)：用于返回一个排序后的列表，默认从小到大排序。大家还记得列表的内建方法sort()嘛？它们的实现效果是一致的，但列表的内建方法sort()是实现列表原地排序；而sorted是返回一个排序后的新列表。

>>> list1 = [1, 4, 2, 3]
>>> list2 = list1[:]
>>> list1.sort()
>>> list1
[1, 2, 3, 4]
>>> sorted(list2)
[1, 2, 3, 4]
>>> list2
[1, 3, 2, 4]

• reversed(sequence)：用于返回逆向迭代序列的值。同样的道理，实现效果跟列表的内建方法reverse()一致。区别是列表的内建方法是原地翻转，而reversed()是返回一个翻转后的迭代器对象。你没看错，它不是返回一个列表，是返回一个迭代器对象：

>>> list1 = [1, 2, 3, 4]
>>> reversed(list1)
<list_reverseiterator object at 0x00000268191E15C0>
>>> for i in reversed(list1):
		print(i)

4
3
2
1

• enumerate(iterable)：生成二元组(二元组就是元素数量为二的元组)构成的一个迭代对象，每个二元组是由可迭代参数的索引号及其对应的元素组成的。举个例子你就明白了：

>>> str1 = 'abc'
>>> for i in enumerate(str1):
		print(i)

(0, 'a')
(1, 'b')
(2, 'c')

• zip(iter1[,iter2[…]])：用于返回各个可迭代参数共同组成的元组。

>>> list1 = [1, 2, 3]
>>> str1 = 'abc'
>>> for i in zip(list1, str1):
		print(i)

(1, 'a')
(2, 'b')
(3, 'c')

四、字典和集合

字典(dict)

字典是python中唯一的映射类型，映射是数学上的一个术语，指两个元素集之间相互对应的关系。

1、创建和访问字典

>>> dict1 = {'a': 1, 'b': 2, 'c': 3}
>>> dict1['a']
1
>>> dict1['b']
2
>>> dict1['c']
3

字典的使用非常简单，它有自己的标志性符号，就是用大括号定义({})。字典由多个键及其对应的值公共构成。每一对键值组合成为项。

需要注意：字典的键必须独一无二，而值可以取任何数据类型，但必须是不可变的(如字符串、数字、元组)

要声明一个空字典，直接用个大括号即可：

>>> empty = {}
>>> type(empty)
<class 'dict'>

也可使用dict()来创建字典：

>>> dict1 = dict(a=1, b=2, c=3)
>>> dict1
{'a': 1, 'b': 2, 'c': 3}

这里要注意的是键的位置不能加上字符串的引号，否则会报错。

>>> dict1 = dict('a'=1, 'b'=2, 'c'=3)
SyntaxError: keyword can't be an expression

还有一种方法是直接给字典的键赋值，如果键存在，则改写对应的值；如果不存在，则创建一个新的键并赋值：

>>> dict1
{'a': 1, 'b': 2, 'c': 3}
>>> dict1['d'] = 4
>>> dict1
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> dict1['d'] = 0
>>> dict1
{'a': 1, 'b': 2, 'c': 3, 'd': 0}

2、字典的各种内置方法

• fromkeys()：用于创建并返回一个新的字典，它有两个参数：第一个参数是字典的键，需为可迭代类型，第二个参数是可选的，是传入键对应的值。如果不提供，那么默认是None,举个例子来说明一下吧：

>>> dict1 = {}
>>> dict1.fromkeys([1, 2, 3])
{1: None, 2: None, 3: None}
>>> dict2 = {}
>>> dict2.fromkeys(['a', 'b', 'c'], 1)
{'a': 1, 'b': 1, 'c': 1}

• keys()：用于返回字典中所有的键,为可迭代对象。

>>> dict1 = {'a': 1, 'b': 1, 'c': 1}
>>> dict1.keys()
dict_keys(['a', 'b', 'c'])
>>> for i in dict1.keys():
	print(i)
	
a
b
c

• values()：用于返回字典中所有的值,为可迭代对象。

>>> dict1.values()
dict_values([1, 1, 1])

• items()：用于返回字典中所有的项,为可迭代对象。

>>> dict1.items()
dict_items([('a', 1), ('b', 1), ('c', 1)])

• get()：get()方法提供了更宽松的方式去访问字典项，当键不存在的时候，get()方法并不会报错，只是默默的返回了一个None，表示啥也没找到。

>>> dict1 = {'a': 1, 'b': 1, 'c': 1}
>>> dict1.get('d')
>>> 

如果希望找不到数据时返回指定的值，那么可以在第二个参数设置对应的默认返回值：

>>> dict1.get('d', '木有')
'木有'

如果不知道一个键是否在字典中，那么可以使用成员资格操作符(in或not in)来判断：

>>> 'd' in dict1
False
>>> 'a' in dict1
True

• clear()：清空字典中所有的项

>>> dict1 = {'a': 1, 'b': 1, 'c': 1}
>>> dict1.clear()
>>> dict1
{}

• copy()：复制字典

>>> dict1 = {'a': 1, 'b': 1, 'c': 1}
>>> dict2 = dict1.copy()
>>> dict2
{'a': 1, 'b': 1, 'c': 1}
>>> id(dict1)
2646121581520
>>> id(dict2)
2646121910208

• pop()：给定键弹出对应的值，同时字典中这个键所对应的项也会被删除。

>>> dict1.pop('a')
1
>>> dict1
{'b': 1, 'c': 1}

• popitem()：弹出一个项，同时字典中的这一项也会被删除

>>> dict1.popitem()
('c', 1)
>>> dict1
{'b': 1}

• setdefault()：和get()方法相似，但是setdefault()在字典中找不到相应的键时会自动添加：

>>> a = {'a': 1, 'b': 1, 'c': 1}
>>> a.setdefault('a')
1
>>> a.setdefault('d')
>>> a
{'a': 1, 'b': 1, 'c': 1, 'd': None}

• update()：更新字典

>>> dict1 = {'a': 1, 'b': 2, 'c': 3}
>>> dict1.update(c=4)
>>> dict1
{'a': 1, 'b': 2, 'c': 4}

集合(set)

集合的特点是无序性和唯一性，它和字典长得很像，来看看它长啥样吧！

>>> num1 = {}
>>> type(num1)
<class 'dict'>
>>> num2 = {1, 2, 3, 4}
>>> type(num2)
<class 'set'>

好，说回主题，集合在python中几乎起到的所有作用就是两个字：唯一。举个例子：

>>> num = {1, 2, 1, 4, 5, 3, 4, 2, 5, 3}
>>> num
{1, 2, 3, 4, 5}

可以看到，我们根本不需要做什么，集合就会帮我们把重复的数据清理掉，很方便对吧？
记得有一道面试题是实现列表去重，好，那么集合此刻就派上用场啦！！！

>>> list1 = [1, 2, 3, 1, 2, 3]
>>> list1 = list(set(list1))
>>> list1
[1, 2, 3]

注意：集合是无序的，不能通过索引去访问元素！否则会报错：

>>> set1 = {1, 2, 3}
>>> set1[0]
Traceback (most recent call last):
  File "<pyshell#50>", line 1, in <module>
    set1[0]
TypeError: 'set' object is not subscriptable

1、创建集合

创建集合有两种方法：一种是直接把一堆元素用大括号({})括起来；另一种是用set()。

>>> set1 = {1, 2, 3}
>>> set2 = set([1, 2, 3])
>>> set1 == set2
True

2、访问集合

由于集合中的元素是无序的，所以并不能像序列那样用下标来进行访问，但是可以使用迭代把集合中的数据一个个读取出来：

>>> set1 = {1, 2, 3, 4, 1}
>>> for i in set1:
		print(i)

1
2
3
4

当然也可使用in和not in来判断一个元素是否在集合中已经存在：

>>> set1 = {1, 2, 3, 4}
>>> 0 in set1
False
>>> 1 in set1
True

• add()：为集合添加元素

>>> set1.add(5)
>>> set1
{1, 2, 3, 4, 5}

• remove()：删除集合中存在的元素

>>> set1.remove(5)
>>> set1
{1, 2, 3, 4}

3、定义不可变集合

有时候希望集合中的数据具有稳定性，也就是说，像元组一样不能随意的增加或删除集合中的元素。那么我们可以定义不可变集合，这里使用的是frozenset()函数，没错，就是把集合给frozen(冰冻)起来。

>>> set1 = frozenset({1, 2, 3, 4})
>>> set1.add(5)
Traceback (most recent call last):
  File "<pyshell#56>", line 1, in <module>
    set1.add(5)
AttributeError: 'frozenset' object has no attribute 'add'

好啦，python的数据类型咱们就先聊到这里，下一节我们将介绍python中的函数和类，觉得看了有收益的话记得给博主点赞加关注呦！！！感谢观看！！咱们下期再见！