Python3 中有六个标准的数据类型：
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）： List（列表）、Dictionary（字典）、Set（集合）。
1. 什么是序列
Python 序列（Sequence）是指按特定顺序依次排列的一组数据，它们可以占用一块连续的内存，也可以分散到多块内存中。
Python 中的序列类型包括列表（list）、元组（tuple）、字典（dict）和集合（set）
列表（list）和元组（tuple）比较相似，它们都按顺序保存元素，所有的元素占用一块连续的内存，每个元素都有自己的索引，因此列表和元组的元素都可以通过索引（index）来访问。
它们的区别在于：列表是可以修改的，而元组是不可修改的。
字典（dict） 和 集合（set） 存储的数据都是无序的，每份元素占用不同的内存，其中字典元素以 key-value 的形式保存。
在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。
1.1 序列索引
序列中，每个元素都有属于自己的编号（索引）。
从左往右正向索引：元素下标从0开始
| 元素1 | 元素2 | 元素3 | 元素4 | 元素5 |
|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 |
从右往左负向索引：元素下标从-1开始
| 元素1 | 元素2 | 元素3 | 元素4 | 元素5 |
|---|---|---|---|---|
| -5 | -4 | -3 | -2 | -1 |
索引实例：
str="ABCDEF"
print(str[0],"==",str[-6])
print(str[5],"==",str[-1])
运行结果：
A==A
F==F
1.2 序列切片
切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。
序列实现切片操作的语法格式如下：
list_name[start : end : step]
其中，各个参数的含义分别是：
list_name：表示序列的名称；
start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。
例如，对字符串“C语言中文网”进行切片：
str="C语言中文网"
#取索引区间为[0,2]之间（不包括索引2处的字符）的字符串
print(str[:2])
#隔 1 个字符取一个字符，区间是整个字符串
print(str[::2])
#取整个字符串，此时 [] 中只需一个冒号即可
print(str[:])
运行结果为：
C语
C言文
C语言中文网
注意：序列切片区间遵循“左闭右开，左小右大”的原则
1.3 序列相加
Python 中，支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
这里所说的“类型相同”，指的是“+”运算符的两侧序列要么都是序列类型，要么都是元组类型，要么都是字符串。
如下所示：
str="c.biancheng.net"
print("C语言"+"中文网:"+str)
输出结果为：
C语言中文网：c.biancheng.net
1.4 序列相乘
Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。例如：
str="C语言中文网"
print(str*3)
输出结果为：
'C语言中文网C语言中文网C语言中文网'
比较特殊的是，列表类型在进行乘法运算时，还可以实现初始化指定长度列表的功能。例如如下的代码，将创建一个长度为 5 的列表，列表中的每个元素都是 None，表示什么都没有。
list = [None]*5
print(list)
输出结果为：
[None, None, None, None, None]
1.5 检查元素是否包含在序列中
Python 中，可以使用 in 关键字检查某元素是否为序列的成员，其语法格式为：
value in sequence
其中，value 表示要检查的元素，sequence 表示指定的序列。
例如，检查字符‘c’是否包含在字符串“c.biancheng.net”中，可以执行如下代码：
str="c.biancheng.net"
print('c'in str)
运行结果为：
True
和 in 关键字用法相同，但功能恰好相反的，还有 not in 关键字，它用法检查某个元素是否不包含在指定的序列中，比如说：
str="c.biancheng.net"
print('c' not in str)
输出结果为：
False
1.6 序列相关内置函数和方法
2. Python list列表详解
从形式上看，列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，如下所示：
[element1, element2, element3, ..., elementn]
格式中，element1 ~ elementn 表示列表中的元素，个数没有限制，只要是 Python 支持的数据类型就可以。
从内容上看，列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。比如说：
["http://c.biancheng.net/python/", 1, [2,3,4] , 3.0]
可以看到，列表中同时包含字符串、整数、列表、浮点数这些数据类型。
2.1 Python创建列表
- 使用
[ ]直接创建列表
使用[ ]创建列表后，一般使用 = 将它赋值给某个变量，具体格式如下：
listname = [element1 , element2 , element3 , ... , elementn]
其中，listname 表示变量名，element1 ~ elementn 表示列表元素。
例如，下面定义的列表都是合法的：
num = [1, 2, 3, 4, 5, 6, 7]
name = ["C语言中文网", "http://c.biancheng.net"]
program = ["C语言", "Python", "Java"]
另外，使用此方式创建列表时，列表中元素可以有多个，也可以一个都没有，例如：
emptylist = [ ]
这表明，emptylist 是一个空列表。
- 使用
list()函数创建列表
除了使用[ ]创建列表外，Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。例如：
#将字符串转换成列表
list1 = list("hello")
print(list1)
#将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)
#将字典转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)
#将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)
#创建空列表
print(list())
运行结果：
['h', 'e', 'l', 'l', 'o']
['Python', 'Java', 'C++', 'JavaScript']
['a', 'b', 'c']
[1, 2, 3, 4, 5]
[]
2.2 访问列表元素
列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。
使用索引访问列表元素的格式为： listname[i]
其中，listname 表示列表名字，i 表示索引值。列表的索引可以是正数，也可以是负数。
使用切片访问列表元素的格式为：
listname[start : end : step]
其中，listname 表示列表名字，start 表示起始索引，end 表示结束索引，step 表示步长。
以上两种方式我们已在《Python序列》中进行了讲解，这里就不再赘述了，仅作示例演示，请看下面代码：
url = list("http://c.biancheng.net/shell/")
#使用索引访问列表中的某个元素
print(url[3]) #使用正数索引
print(url[-4]) #使用负数索引
#使用切片访问列表中的一组元素
print(url[9: 18]) #使用正数切片
print(url[9: 18: 3]) #指定步长
print(url[-6: -1]) #使用负数切片
运行结果：
p
e
['b', 'i', 'a', 'n', 'c', 'h', 'e', 'n', 'g']
['b', 'n', 'e']
['s', 'h', 'e', 'l', 'l']
2.3 Python删除列表
对于已经创建的列表，如果不再使用，可以使用del关键字将其删除。
实际开发中并不经常使用 del 来删除列表，因为 Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收。
del 关键字的语法格式为： del listname
其中，listname 表示要删除列表的名称。
Python 删除列表实例：
intlist = [1, 45, 8, 34]
print(intlist)
del intlist
print(intlist)
运行结果：
[1, 45, 8, 34]
Traceback (most recent call last):
File "C:\Users\mozhiyan\Desktop\demo.py", line 4, in
print(intlist)
NameError: name 'intlist' is not defined
3. Python list列表添加元素
3.1 Python append()方法添加元素
append() 方法用于在列表的末尾追加元素，该方法的语法格式如下：
listname.append(obj)
其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。
请看下面的演示：
l = ['Python', 'C++', 'Java']
#追加元素
l.append('PHP')
print(l)
#追加元组，整个元组被当成一个元素
t = ('JavaScript', 'C#', 'Go')
l.append(t)
print(l)
#追加列表，整个列表也被当成一个元素
l.append(['Ruby', 'SQL'])
print(l)
运行结果为：
['Python', 'C++', 'Java', 'PHP']
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go')]
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go'), ['Ruby', 'SQL']]
可以看到，当给 append() 方法传递列表或者元组时，此方法会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。
3.2 Python extend()方法添加元素
extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。
extend() 方法的语法格式如下：
listname.extend(obj)
其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。
请看下面的演示：
l = ['Python', 'C++', 'Java']
#追加元素
l.extend('C')
print(l)
#追加元组，元祖被拆分成多个元素
t = ('JavaScript', 'C#', 'Go')
l.extend(t)
print(l)
#追加列表，列表也被拆分成多个元素
l.extend(['Ruby', 'SQL'])
print(l)
运行结果：
['Python', 'C++', 'Java', 'C']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go', 'Ruby', 'SQL']
3.3 Python insert()方法插入元素
append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert() 方法。
insert() 的语法格式如下：
listname.insert(index , obj)
其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。
当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。
请看下面的演示代码：
l = ['Python', 'C++', 'Java']
#插入元素
l.insert(1, 'C')
print(l)
#插入元组，整个元祖被当成一个元素
t = ('C#', 'Go')
l.insert(2, t)
print(l)
#插入列表，整个列表被当成一个元素
l.insert(3, ['Ruby', 'SQL'])
print(l)
#插入字符串，整个字符串被当成一个元素
l.insert(0, "http://c.biancheng.net")
print(l)
输出结果为：
['Python', 'C', 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
['http://c.biancheng.net', 'Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
- insert() 主要用来在列表的中间位置插入元素
- 如果你仅仅希望在列表的末尾追加元素，那我更建议使用 append() 和 extend()。
4. Python list列表删除元素
在 Python 列表中删除元素主要分为以下 3 种场景：
- 根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
- 根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
- 将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法。
del：根据索引值删除元素
del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。
del 可以删除列表中的单个元素，格式为：
del listname[index]
其中，listname 表示列表名称，index 表示元素的索引值。
del 也可以删除中间一段连续的元素，格式为：
del listname[start : end]
其中，start 表示起始索引，end 表示结束索引。del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素。
【示例】使用 del 删除单个列表元素：
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
#使用正数索引
del lang[2]
print(lang)
#使用负数索引
del lang[-2]
print(lang)
运行结果：
['Python', 'C++', 'PHP', 'Ruby', 'MATLAB']
['Python', 'C++', 'PHP', 'MATLAB']
【示例】使用 del 删除一段连续的元素：
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
del lang[1: 4]
print(lang)
lang.extend(["SQL", "C#", "Go"])
del lang[-5: -2]
print(lang)
运行结果：
['Python', 'Ruby', 'MATLAB']
['Python', 'C#', 'Go']
pop()：根据索引值删除元素
Python pop() 方法用来删除列表中指定索引处的元素，具体格式如下：
listname.pop(index)
其中，listname 表示列表名称，index 表示索引值。如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作。
pop() 用法举例：
nums = [40, 36, 89, 2, 36, 100, 7]
nums.pop(3)
print(nums)
nums.pop()
print(nums)
运行结果：
[40, 36, 89, 36, 100, 7]
[40, 36, 89, 36, 100]
大部分编程语言都会提供和 pop() 相对应的方法，就是 push()，该方法用来将元素添加到列表的尾部，类似于数据结构中的“入栈”操作。但是 Python 是个例外，Python 并没有提供 push() 方法，因为完全可以使用 append() 来代替 push() 的功能。
remove()：根据元素值进行删除
除了 del 关键字，Python 还提供了 remove() 方法，该方法会根据元素本身的值来进行删除操作。
需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。
remove() 方法使用示例：
nums = [40, 36, 89, 2, 36, 100, 7]
#第一次删除36
nums.remove(36)
print(nums)
#第二次删除36
nums.remove(36)
print(nums)
#删除78
nums.remove(78)
print(nums)
运行结果：
[40, 89, 2, 36, 100, 7]
[40, 89, 2, 100, 7]
Traceback (most recent call last):
File "C:\Users\mozhiyan\Desktop\demo.py", line 9, in
nums.remove(78)
ValueError: list.remove(x): x not in list
最后一次删除，因为 78 不存在导致报错，所以我们在使用 remove() 删除元素时最好提前判断一下。
clear()：删除列表所有元素
Python clear() 用来删除列表的所有元素，也即清空列表，请看下面的代码：
url = list("http://c.biancheng.net/python/")
url.clear()
print(url)
运行结果： []
5. Python list列表修改元素
Python 提供了两种修改列表（list）元素的方法:
- 你可以每次修改单个元素
- 也可以每次修改一组元素（多个）。
修改单个元素
修改单个元素非常简单，直接对元素赋值即可。请看下面的例子：
nums = [40, 36, 89, 2, 36, 100, 7]
nums[2] = -26 #使用正数索引
nums[-3] = -66.2 #使用负数索引
print(nums)
运行结果：
[40, 36, -26, 2, -66.2, 100, 7]
使用索引得到列表元素后，通过=赋值就改变了元素的值。
修改一组元素
Python 支持通过切片语法给一组元素赋值。在进行这种操作时，如果不指定步长（step 参数），Python 就不要求新赋值的元素个数与原来的元素个数相同；这意味，该操作既可以为列表添加元素，也可以为列表删除元素。
下面的代码演示了如何修改一组元素的值：
nums = [40, 36, 89, 2, 36, 100, 7]
#修改第 1~4 个元素的值（不包括第4个元素）
nums[1: 4] = [45.25, -77, -52.5]
print(nums)
运行结果：
[40, 45.25, -77, -52.5, 36, 100, 7]
如果对空切片（slice）赋值，就相当于插入一组新的元素：
nums = [40, 36, 89, 2, 36, 100, 7]
#在4个位置插入元素
nums[4: 4] = [-77, -52.5, 999]
print(nums)
运行结果：
[40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]
使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的： nums[4: 4] = -77
但是如果使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素，请看下面的代码：
s = list("Hello")
s[2:4] = "XYZ"
print(s)
运行结果：
['H', 'e', 'X', 'Y', 'Z', 'o']
使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同，例如：
nums = [40, 36, 89, 2, 36, 100, 7]
#步长为2，为第1、3、5个元素赋值
nums[1: 6: 2] = [0.025, -99, 20.5]
print(nums)
运行结果：
[40, 0.025, 89, -99, 36, 20.5, 7]
4.6 Python list列表查找元素
Python 列表（list）提供了 index() 和 count() 方法，它们都可以用来查找元素。
index() 方法
index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。
index() 的语法格式为：listname.index(obj, start, end)
其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置。
start 和 end 参数用来指定检索范围：
-
start和end可以都不写，此时会检索整个列表； - 如果只写
start不写end，那么表示检索从start到末尾的元素； - 如果
start和end都写，那么表示检索start和end之间的元素。
index() 方法会返回元素所在列表中的索引值。
index() 方法使用举例：
nums = [40, 36, 89, 2, 36, 100, 7, -20.5, -999]
#检索列表中的所有元素
print( nums.index(2) )
#检索3~7之间的元素
print( nums.index(100, 3, 7) )
#检索4之后的元素
print( nums.index(7, 4) )
#检索一个不存在的元素
print( nums.index(55) )
运行结果：
3
5
6
Traceback (most recent call last):
File "C:\Users\mozhiyan\Desktop\demo.py", line 9, in
print( nums.index(55) )
ValueError: 55 is not in list
count()方法
count() 方法用来统计某个元素在列表中出现的次数，基本语法格式为：
listname.count(obj)
其中，listname 代表列表名，obj 表示要统计的元素。
如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。
count() 用法示例：
nums = [40, 36, 89, 2, 36, 100, 7, -20.5, 36]
#统计元素出现的次数
print("36出现了%d次" % nums.count(36))
#判断一个元素是否存在
if nums.count(100):
print("列表中存在100这个元素")
else:
print("列表中不存在100这个元素")
运行结果：
36出现了3次
列表中存在100这个元素
4.8 Python range() 快速初始化列表
实际场景中，经常需要存储一组数字。例如在游戏中，需要跟踪每个角色的位置，还可能需要跟踪玩家的几个最高得分。在数据可视化中，处理的几乎都是由数字（如温度、距离、人口数量、经度和纬度等）组成的集合。
列表非常适合用于存储数字集合，并且 Python 提供了 range() 函数，可帮助我们高效地处理数字列表，即便列表需要包含数百万个元素，也可以快速实现。
Python range() 函数能够轻松地生成一系列的数字。例如，可以像如下这样使用 range() 来打印一系列数字：
for value in range(1,5):
print(value)
输出结果为：
1
2
3
4
注意，在这个示例程序中，range() 只是打印数字 1～4，因为range() 函数的用法是：让 Python 从指定的第一个值开始，一直数到指定的第二个值停止，但不包含第二个值（这里为 5）
因此，如果想要上面程序打印数字 1~5，需要使用 range(1,6)。
另外需要指明的是，range() 函数的返回值并不直接是列表类型（list），例如：
>>> type([1,2,3,4,5])
>>> type(range(1,6))
可以看到，range() 函数的返回值类型为 range，而不是 list。而如果想要得到 range() 函数创建的数字列表，还需要借助 list() 函数，比如：
>>> list(range(1,6))
[1, 2, 3, 4, 5]
可以看到，如果将 range() 作为 list() 的参数，其输出就是一个数字列表。
不仅如此，在使用 range() 函数时，还可以指定步长。例如，下面的代码打印 1~10 内的偶数：
even_numbers = list(range(2,11,2))
print(even_numbers)
在这个示例中，函数 range() 从 2 开始数，然后不断地加 2，直到达到或超过终值，因此输出如下：[2, 4, 6, 8, 10]
注意，即便 range() 第二个参数恰好符合条件，最终创建的数字列表中也不会包含它。
实际使用时，range() 函数常常和 Python 循环结构、推导式（后续会讲，这里先不涉及）一起使用，几乎能够创建任何需要的数字列表。
例如，创建这样一个列表，其中包含前 10 个整数（即1~10）的平方，实现代码如下：
squares = []
for value in range(1,11):
square = value**2
squares.append(square)
print(squares)
运行结果为：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
4.9 Python list列表实现栈和队列
队列和栈是两种数据结构，其内部都是按照固定顺序来存放变量的，二者的区别在于对数据的存取顺序：
- 队列是，先存入的数据最先取出，即“先进先出”。
- 栈是，最后存入的数据最先取出，即“后进先出”。
考虑到 list 类型数据本身的存放就是有顺序的，而且内部元素又可以是各不相同的类型，非常适合用于队列和栈的实现。本节将演示如何使用 list 类型变量来实现队列和栈。
Python list实现队列
使用 list 列表模拟队列功能的实现方法是:定义一个 list 变量，存入数据时使用 insert() 方法，设置其第一个参数为 0，即表示每次都从最前面插入数据；读取数据时，使用 pop() 方法，即将队列的最后一个元素弹出。
如此 list 列表中数据的存取顺序就符合“先进先出”的特点。实现代码如下：
#定义一个空列表，当做队列
queue = []
#向列表中插入元素
queue.insert(0,1)
queue.insert(0,2)
queue.insert(0,"hello")
print(queue)
print("取一个元素：",queue.pop())
print("取一个元素：",queue.pop())
print("取一个元素：",queue.pop())
运行结果为：
['hello', 2, 1]
取一个元素： 1
取一个元素： 2
取一个元素： hello
Python list实现栈
使用 list 列表模拟栈功能的实现方法是:使用 append() 方法存入数据；使用 pop() 方法读取数据。
append() 方法向 list 中存入数据时，每次都在最后面添加数据，这和前面程序中的 insert() 方法正好相反。
举个例子：
#定义一个空 list 当做栈
stack = []
stack.append(1)
stack.append(2)
stack.append("hello")
print(stack)
print("取一个元素：",stack.pop())
print("取一个元素：",stack.pop())
print("取一个元素：",stack.pop())
输出结果为：
[1, 2, 'hello']
取一个元素： hello
取一个元素： 2
取一个元素： 1
collections模块实现栈和队列
前面使用 list 实现队列的例子中，插入数据的部分是通过 insert() 方法实现的，这种方法效率并不高，因为每次从列表的开头插入一个数据，列表中所有元素都得向后移动一个位置。
这里介绍一个相对更高效的方法，即使用标准库的 collections 模块中的 deque 结构体，它被设计成在两端存入和读取都很快的特殊 list，可以用来实现栈和队列的功能。
举个例子：
queueAndStack = deque()
queueAndStack.append(1)
queueAndStack.append(2)
queueAndStack.append("hello")
print(list(queueAndStack))
#实现队列功能，从队列中取一个元素，根据先进先出原则，这里应输出 1
print(queueAndStack.popleft())
#实现栈功能，从栈里取一个元素，根据后进先出原则，这里应输出 hello
print(queueAndStack.pop())
#再次打印列表
print(list(queueAndStack))
输出结果为：
[1, 2, 'hello']
1
hello
[2]