首页 > 范文大全

python 中的列表解析和生成表达式

时间：2023年08月05日

来源：箕宿三

编辑：本站小编

收藏本文

下载本文

下面是小编整理的python 中的列表解析和生成表达式，本文共8篇，欢迎大家阅读分享借鉴，希望对大家有所帮助。本文原稿由网友“箕宿三”提供。

篇1：python 中的列表解析和生成表达式

热点排行

Python入门教程超详细1小时学会

python 中文乱码问题深入分析

比较详细Python正则表达式操作指

Python字符串的encode与decode研

Python open读写文件实现脚本

Python enumerate遍历数组示例应

Python 深入理解yield

Python+Django在windows下的开发

python 文件和路径操作函数小结

python 字符串split的用法分享

篇2：Python解析生成XMLElementTree VS minidom

本文介绍用Python解析生成以下XML：

LDL

China

1.创建一个xml文件名为src.xml，内容如上，放到c:\\temp

2.使用ElementTree读取src.xml，并创建一个内容相同的xml名为target-tree.xml，

ElementTreeSample.py如下：

# -*- coding: utf-8 -*-

“”“

Sample of xml.etree.ElementTree

@author: ldlchina

”“”

import os

import sys

import logging

import traceback

import xml.etree.ElementTree as ET

import time

def copy_node(src_node, target_node):

# Copy attr

for key in src_node.keys:

target_node.set(key, src_node.get(key))

if len(list(src_node)) >0:

for child in src_node:

target_child = ET.Element(child.tag)

target_node.append(target_child)

copy_node(child, target_child)

else:

target_node.text = src_node.text

def read_write_xml(src, target):

tree = ET.parse(src)

root = tree.getroot()

target_root = ET.Element(root.tag)

start_time = time.time() * 1000

copy_node(root, target_root)

end_time = time.time() * 1000

print('copy_node:' + str(end_time - start_time))

target_tree = ET.ElementTree(target_root)

target_tree.write(target)

logging.info(target)

def main():

try:

current_file = os.path.realpath(__file__)

# Configure logger

log_file = current_file.replace('.py', '.log')

logging.basicConfig(filename = log_file, filemode = 'w', level = logging.INFO)

# Create console handler

ch = logging.StreamHandler()

ch.setLevel(logging.INFO)

logger = logging.getLogger('')

logger.addHandler(ch)

#src = sys.argv[1]

#target = sys.argv[2]

# For debugging

src = 'C:/temp/src.xml'

target = 'C:/temp/target-tree.xml'

# Generate results

start_time = time.time() * 1000

read_write_xml(src, target)

end_time = time.time() * 1000

print('read_write_xml:' + str(end_time - start_time))

except:

logging.exception(''.format(traceback.format_exc()))

input('Press any key to exit...')

main()

3.使用minidom读取src.xml，并创建一个内容相同的xml名为target-dom.xml。

MinidomSample.py如下：

# -*- coding: utf-8 -*-

“”“

Sample of xml.dom.minidom

@author: ldlchina

”“”

import os

import sys

import logging

import traceback

import xml.dom.minidom as MD

import time

def get_text(n):

nodelist = n.childNodes

rc = “”

for node in nodelist:

if node.nodeType == node.TEXT_NODE or node.nodeType == node.CDATA_SECTION_NODE:

rc = rc + node.data

return rc

def copy_node(target_doc, src_node, target_node):

if not isinstance(src_node, MD.Document) and src_node.hasAttributes():

for item in src_node.attributes.items():

target_node.setAttribute(item[0], item[1])

for node in src_node.childNodes:

if node.nodeType == node.TEXT_NODE:

target_child = target_doc.createTextNode(node.nodeValue)

target_node.appendChild(target_child)

elif node.nodeType == node.CDATA_SECTION_NODE:

target_child = target_doc.createCDATASection(node.nodeValue)

target_node.appendChild(target_child)

elif node.nodeType == node.ELEMENT_NODE:

target_child = target_doc.createElement(node.nodeName)

target_node.appendChild(target_child)

copy_node(target_doc, node, target_child)

def read_write_xml(src, target):

doc = MD.parse(src)

target_doc = MD.Document()

start_time = time.time() * 1000

copy_node(target_doc, doc, target_doc)

end_time = time.time() * 1000

print('copy_node: ' + str(end_time - start_time))

# Write to file

f = open(target, 'w')

f.write(target_doc.documentElement.toxml())

f.close()

logging.info(target)

def main():

try:

current_file = os.path.realpath(__file__)

# Configure logger

log_file = current_file.replace('.py', '.log')

logging.basicConfig(filename = log_file, filemode = 'w', level = logging.INFO)

# Create console handler

ch = logging.StreamHandler()

ch.setLevel(logging.INFO)

logger = logging.getLogger('')

logger.addHandler(ch)

#src = sys.argv[1]

#target = sys.argv[2]

# For debugging

src = 'C:/temp/src.xml'

target = 'C:/temp/target-dom.xml'

# Generate results

start_time = time.time() * 1000

read_write_xml(src, target)

end_time = time.time() * 1000

print('read_write_xml: ' + str(end_time - start_time))

except:

logging.exception(''.format(traceback.format_exc()))

input('Press any key to exit...')

main()

4.运行ElementTreeSample.py，得到XML如下：

LDLcdata text

Chinacdata text

5.运行MinidomSample.py，得到XML如下：

LDL

China

ElementTree VS minidom：

1.ElementTree执行速度会比minidom快一些，

2.ElemenTree不能分析XML的转行和缩进。minidom可以。

3.ElemenTree不支持CDATA，minidom可以。

篇3：python中 ? : 三元表达式的使用介绍

热点排行

Python入门教程超详细1小时学会

python 中文乱码问题深入分析

比较详细Python正则表达式操作指

Python字符串的encode与decode研

Python open读写文件实现脚本

Python enumerate遍历数组示例应

Python 深入理解yield

Python+Django在windows下的开发

python 文件和路径操作函数小结

python 字符串split的用法分享

篇4：详解Python中列表和元祖的使用方法

作者：廖雪峰字体：[增加减小] 类型：

这篇文章主要介绍了详解Python中列表和元祖的使用方法,代码基于Python2.x版本,元祖和列表是Python学习当中的基础知识,需要的朋友可以参考下

list

Python内置的一种数据类型是列表：list，list是一种有序的集合，可以随时添加和删除其中的元素。

比如，列出班里所有同学的名字，就可以用一个list表示：

>>>classmates = [‘Michael‘, ‘Bob‘, ‘Tracy‘]>>>classmates[‘Michael‘, ‘Bob‘, ‘Tracy‘]

变量classmates就是一个list。用len函数可以获得list元素的个数：

>>>len(classmates)3

用索引来访问list中每一个位置的元素，记得索引是从0开始的：

>>>classmates[0]‘Michael‘>>>classmates[1]‘Bob‘>>>classmates[2]‘Tracy‘>>>classmates[3]Traceback (most recent call last): File “”, line 1, in IndexError: list index out of range

当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1。

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

>>>classmates[-1]‘Tracy‘

以此类推，可以获取倒数第2个、倒数第3个：

>>>classmates[-2]‘Bob‘>>>classmates[-3]‘Michael‘>>>classmates[-4]Traceback (most recent call last): File “”, line 1, in IndexError: list index out of range

当然，倒数第4个就越界了。

list是一个可变的有序表，所以，可以往list中追加元素到末尾：

>>>classmates.append(‘Adam‘)>>>classmates[‘Michael‘, ‘Bob‘, ‘Tracy‘, ‘Adam‘]

也可以把元素插入到指定的位置，比如索引号为1的位置：

>>>classmates.insert(1, ‘Jack‘)>>>classmates[‘Michael‘, ‘Jack‘, ‘Bob‘, ‘Tracy‘, ‘Adam‘]

要删除list末尾的元素，用pop()方法：

>>>classmates.pop()‘Adam‘>>>classmates[‘Michael‘, ‘Jack‘, ‘Bob‘, ‘Tracy‘]

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

>>>classmates.pop(1)‘Jack‘>>>classmates[‘Michael‘, ‘Bob‘, ‘Tracy‘]

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

>>>classmates[1] = ‘Sarah‘>>>classmates[‘Michael‘, ‘Sarah‘, ‘Tracy‘]

list里面的元素的数据类型也可以不同，比如：

>>>L = [‘Apple‘, 123, True]

list元素也可以是另一个list，比如：

>>>s = [‘python‘, ‘java‘, [‘asp‘, ‘php‘], ‘scheme‘]>>>len(s)4

要注意s只有4个元素，其中s[2]又是一个list，如果拆开写就更容易理解了：

>>>p = [‘asp‘, ‘php‘]>>>s = [‘python‘, ‘java‘, p, ‘scheme‘]

要拿到‘php‘可以写p[1]或者s[2][1]，因此s可以看成是一个二维数组，类似的还有三维、四维……数组，不过很少用到，

如果一个list中一个元素也没有，就是一个空的list，它的长度为0：

>>>L = []>>>len(L)0

tuple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：

>>>classmates = (‘Michael‘, ‘Bob‘, ‘Tracy‘)

现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

>>>t = (1, 2)>>>t(1, 2)

如果要定义一个空的tuple，可以写成()：

>>>t = ()>>>t()

但是，要定义一个只有1个元素的tuple，如果你这么定义：

>>>t = (1)>>>t1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

>>>t = (1,)>>>t(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

最后来看一个“可变的”tuple：

>>>t = (‘a‘, ‘b‘, [‘A‘, ‘B‘])>>>t[2][0] = ‘X‘>>>t[2][1] = ‘Y‘>>>t(‘a‘, ‘b‘, [‘X‘, ‘Y‘])

这个tuple定义的时候有3个元素，分别是‘a‘，‘b‘和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？

别急，我们先看看定义的时候tuple包含的3个元素：

当我们把list的元素‘A‘和‘B‘修改为‘X‘和‘Y‘后，tuple变为：

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向‘a‘，就不能改成指向‘b‘，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

小结

list和tuple是Python内置的有序集合，一个可变，一个不可变。根据需要来选择使用它们。

篇5：Python中if name == ‘main‘作用解析

这篇文章主要介绍了Python中if __name__ == ‘__main__‘作用解析,这断代码在Python中非常常见,它有作用？本文就解析了它的作用,需要的朋友可以参考下

当你打开一个.py文件时,经常会在代码的最下面看到if __name__ == ‘__main__‘:,现在就来介绍一下它的作用.

模块是对象，并且所有的模块都有一个内置属性 __name__，一个模块的 __name__ 的值取决于您如何应用模块。如果 import 一个模块，那么模块__name__ 的值通常为模块文件名，不带路径或者文件扩展名。但是您也可以像一个标准的程序样直接运行模块，在这种情况下, __name__ 的值将是一个特别缺省“__main__”。

///////////////////////////////////////////////////////////////////////////////////////////////////

在cmd 中直接运行.py文件,则__name__的值是‘__main__‘;

而在import 一个.py文件后,__name__的值就不是‘__main__‘了;

从而用if __name__ == ‘__main__‘来判断是否是在直接运行该.py文件

如:

代码如下:

#Test.py

class Test:

def __init(self):pass

def f(self):print ‘Hello, World!‘

if __name__ == ‘__main__‘:

Test().f()

#End

你在cmd中输入:

代码如下:

C:>python Test.py

Hello, World!

说明:“__name__ == ‘__main__‘”是成立的

你再在cmd中输入:

代码如下:

C:>python

>>>import Test

>>>Test.__name__ #Test模块的__name__

‘Test‘

>>>__name__ #当前程序的__name__

‘__main__‘

无论怎样,Test.py中的“__name__ == ‘__main__‘”都不会成立的!

所以,下一行代码永远不会运行到!

篇6：Python中列表和元组的相关语句和方法讲解

作者：一线涯字体：[增加减小] 类型：时间：-08-20

这篇文章主要介绍了Python中列表和元组的相关语句和方法讲解,是Python入门学习中的基础知识,需要的朋友可以参考下

列表(list):

首先，列表属于序列，那么序列类型可用如下内建函数――

list(iter)：把可迭代对象转换为列表，

str(obj)：把obj对象转换为字符串，即用字符串来表示这个对象。

tuple(iter)：把一个可迭代对象转换为一个元组。

unicode(obj)：把对象转换成Unicode字符串。

basestring：抽象工厂函数，其作用仅仅是为str和unicode函数提供父类，所以不能被实例化，也不能被调用。

enumerate(iter)：接受一个可迭代对象作为参数，返回一个enumerate对象，该对象生成由iter每个元素的index值和item值组成的元组。

len(seq)：返回seq的长度。

max(iter,key=None)、max(arg0,arg1...,key=None)：返回iter或(arg0,arg1...)的最大值，如果指定了key，这个key必须是一个可以传给sort()方法的，用于比较的回调函数。

min(iter,key=None)、min(arg0,arg1...,key=None)：返回iter或(arg0,arg1...)的最小值，如果指定了key，这个key必须是一个可以传给sort()方法的，用于比较的回调函数。

reversed(seq)：接受一个序列作为参数，返回一个以逆序访问的迭代器。

sorted(iter,cmp=None,key=None,reverse=False)：接受一个可迭代对象作为参数，返回一个有序的列表，可选参数cmp、key和reverse和list.sort()内建函数含义一样。

sum(seq,init=0)：返回seq和可选参数init的总和，其效果等同于reduce(operator.add,seq,init)。

zip([it0,it1...])：返回一个列表，其第一个元素是it0、it1...这些元素的第一个元素组成的一个元组，其它元素依次类推。

列表就像一个线性容器，但是比C++的 lis t扩展多得多

列表里的元素可以是相同类型，也可以包含各种类型，比如列表里嵌套另一个列表

列表示例：

>>>L1 = [1,2,3] >>>type(L1) >>>L1 = [1,‘a‘,2,1.4] >>>L1 [1, ‘a‘, 2, 1.4] >>>L1 = [ [‘sub‘],1,‘n‘] >>>L1 [[‘sub‘], 1, ‘n‘]

list的索引是也是从0开始，但也可以从后访问，L1[-1] 表示L1中的最后一个元素

>>>L1 [[‘sub‘], 1, ‘n‘] >>>L1[0] [‘sub‘] >>>L1[-1] ‘n‘

对列表可以进行切片，切片的操作类似于对函数的调用，返回值一个新的列表

切片 L1[ x : y : z ] 是半开闭区间（z通常不用写），如L1[1:3] 返回的是一个从 L1[1] 开始到 L1[2] 结束的列表，不包含L1[3]

x 不写表示从头开始，y 不写表示直到列表结束，z 用于表示步长，默认是1，可以认为是在这个区间里每 z 个元素取一个（取第一个），可以是负数，表示从后到前遍历

>>>L1 = [1,2,3,4,5,6] >>>L1[1:3] [2, 3] >>>L1[:3] [1, 2, 3] >>>L1[1:] [2, 3, 4, 5, 6] >>>L1[-3:-1] [4, 5] >>>L2 = L1[:] >>>L2 [1, 2, 3, 4, 5, 6] >>>L1[::2] [1, 3, 5] >>>L1[::-1] [6, 5, 4, 3, 2, 1]

列表可以做加法，做乘法，字符串也可以看做一个字符的列表

>>>L1 = [1,2] >>>L2 = [3,4] >>>L1 + L2 [1, 2, 3, 4] >>>5 * L1 [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

in语句，判断一个对象是否在一个字符串/列表/元组里

not 语句表示对后面的否定

len 可以检测字符串/列表/元祖/字典的元素个数

max 可以返回最大元素，min 返回最小元素

>>>L1 [1, 2, 3, 4, 2] >>>3 in L1 True >>>5 in L1 False >>>3 not in L1 False >>>5 not in L1 True >>>len(L1) 5 >>>max(L1) 4 >>>min(L1) 1

操作：

>>>#赋值 >>>L1[1] = 5 >>>L1 [1, 5, 3, 4, 2] >>>#删除 >>>del L1[1] >>>L1 [1, 3, 4, 2] >>>#分片赋值 >>>L1[2:] = [6,7,8] >>>L1 [1, 3, 6, 7, 8] >>>L1[1:3] = [] >>>L1 [1, 7, 8]

list 的函数：

append( x ) 是将 x 作为一个元素添加到列表的末尾，即使 x 是一个列表

>>>L1 [1, 2, 7, 8] >>>L1.append(3) >>>L1 [1, 2, 7, 8, 3] >>>L1.append([4,5]) >>>L1 [1, 2, 7, 8, 3, [4, 5]] >>>4 in L1 False

count( x) 统计 x 在列表中出现的次数

>>>L1 = [1, 2, 7, 8] >>>L1.count(2) 1 >>>L1.count(3) 0

extend( x ) 将x 作为一个列表与原列表合并，添加到末尾，

若不是列表，则编译器尝试将 x 转换为列表然后执行操作，不成功就会报错

>>>L1 [1, 2, 7, 8] >>>L1.extend([4,5]) >>>L1 [1, 2, 7, 8, 4, 5] >>>4 in L1 True

index ( x ) 返回 x 在列表中的坐标，若 x 不在列表中会出错

>>>L1.index(2) 1

insert( i , x) 在位置i 插入元素x

>>>L1 [1, 2, 7, 8, 4, 5] >>>L1.insert(0,‘a‘) >>>L1 [‘a‘, 1, 2, 7, 8, 4, 5] >>>L1.insert(-1,‘b‘) >>>L1 [‘a‘, 1, 2, 7, 8, 4, ‘b‘, 5]

pop( i ) 删除位置 i 的元素并将它返回，默认可以不写 i ，删除最后一个元素，不存在会出错

>>>L1 = [1, 2, 7, 8] >>>L1.pop(1) 2 >>>L1 [1, 7, 8] >>>L1.pop() 8 >>>L1 [1, 7]

remove( x ) 移除在列表中 x 的第一个匹配项，x 不存在会出错

>>>L1.remove(2) >>>L1 [1, 7, 8]

reverse() 将列表逆序

>>>L1 = [1, 2, 7, 8] >>>L1.reverse() >>>L1 [8, 7, 2, 1]

sort 将原列表排序，返回None，有两个可选参数，key 和 reverse，默认为升序排列

>>>L1 [8, 7, 2, 1] >>>L1.sort() >>>L1 [1, 2, 7, 8] >>>L1.sort(reverse = True) >>>L1 [8, 7, 2, 1] >>>L1 = [‘a‘,‘ccc‘,‘abcd‘,‘bc‘,‘cd‘,‘abc‘] >>>L1.sort(key = len) >>>L1 [‘a‘, ‘bc‘, ‘cd‘, ‘ccc‘, ‘abc‘, ‘abcd‘]

元组(tuple)

元组也属于序列，但元组为不可修改的列表。所以元组没有以上序列通用方法可用！

一个元素的元组表示为 ( 1 , )

>>>x = (1,) >>>type(x) >>>x = (1) >>>type(x)

元组可转换成列表，反之亦然。

内建的 tuple() 函数接受一个列表参数，并返回一个包含同样元素的元组，而 list() 函数接受一个元组参数并返回一个列表。

从效果上看， tuple() 冻结列表，而 list() 融化元组。

>>>x = [1,2,4,3,1] >>>y = (1,2,4,3,1) >>>type(x) >>>type(y) >>>z = tuple(x) >>>z (1, 2, 4, 3, 1) >>>z = list(y) >>>z [1, 2, 4, 3, 1]

可以用列表或元组进行一次多赋值：

>>>L1 = (1,2,4) >>>(x, y, z) = L1 >>>x 1 >>>y 2 >>>z 4 >>>L1 = [1,2,4] >>>(x,y,z) = L1 >>>x 1 >>>y 2 >>>z 4

[] ，和 () 在布尔值中表示 False

篇7：Python去除列表中重复元素的方法

作者：ijoy_360 字体：[增加减小] 类型：转载

这篇文章主要介绍了Python去除列表中重复元素的方法,实例分析了Python中去除列表重复元素的使用技巧,需要的朋友可以参考下

本文实例讲述了Python去除列表中重复元素的方法，分享给大家供大家参考。具体如下：

比较容易记忆的是用内置的set

l1 = [‘b‘,‘c‘,‘d‘,‘b‘,‘c‘,‘a‘,‘a‘]l2 = list(set(l1))print l2

还有一种据说速度更快的，没测试过两者的速度差别

l1 = [‘b‘,‘c‘,‘d‘,‘b‘,‘c‘,‘a‘,‘a‘]l2 = {}.fromkeys(l1).keys()print l2

这两种都有个缺点，祛除重复元素后排序变了：

[‘a‘, ‘c‘, ‘b‘, ‘d‘]

如果想要保持他们原来的排序：

用list类的sort方法

l1 = [‘b‘,‘c‘,‘d‘,‘b‘,‘c‘,‘a‘,‘a‘]l2 = list(set(l1))l2.sort(key=l1.index)print l2

也可以这样写

l1 = [‘b‘,‘c‘,‘d‘,‘b‘,‘c‘,‘a‘,‘a‘]l2 = sorted(set(l1),key=l1.index)print l2

也可以用遍历

l1 = [‘b‘,‘c‘,‘d‘,‘b‘,‘c‘,‘a‘,‘a‘]l2 = []for i in l1: if not i in l2: l2.append(i)print l2

上面的代码也可以这样写

l1 = [‘b‘,‘c‘,‘d‘,‘b‘,‘c‘,‘a‘,‘a‘]l2 = [][l2.append(i) for i in l1 if not i in l2]print l2

这样就可以保证排序不变了：

[‘b‘, ‘c‘, ‘d‘, ‘a‘]

希望本文所述对大家的Python程序设计有所帮助，

篇8：Python中使用copy模块实现列表(list)拷贝

这篇文章主要介绍了Python中使用copy模块实现列表(list)拷贝,本文讲解了简单列表的复制和复杂列表复制的解决方法,需要的朋友可以参考下

引用是指保存的值为对象的地址，在 Python 语言中，一个变量保存的值除了基本类型保存的是值外，其它都是引用，因此对于它们的使用就需要小心一些。下面举个例子：

问题描述：已知一个列表，求生成一个新的列表，列表元素是原列表的复制

代码如下:

a=[1,2]

b=a

这种做法其实并未真正生成一个新的列表，b指向的仍然是a所指向的对象。这样，如果对a或b的元素进行修改，a,b的值同时发生变化。

解决的方法为：

代码如下:

a=[1,2]

b=a[:]

这样修改a对b没有影响。修改b对a没有影响。

但这种方法只适用于简单列表，也就是列表中的元素都是基本类型，如果列表元素还存在列表的话，这种方法就不适用了。原因就是，象a[:]这种处理，只是将列表元素的值生成一个新的列表，如果列表元素也是一个列表，如：a=[1,[2]]，那么这种复制对于元素[2]的处理只是复制[2]的引用，而并未生成 [2]的一个新的列表复制。为了证明这一点，测试步骤如下：

代码如下:

>>>a=[1,[2]]

>>>b=a[:]

>>>b

[1, [2]]

>>>a[1].append(3)

>>>a

[1, [2, 3]]

>>>b

[1, [2, 3]]

可见，对a的修改影响到了b，

如果解决这一问题，可以使用copy模块中的deepcopy函数。修改测试如下：