列表 VS 元组
 
一个 Python 初学者的普遍疑问：列表与元组的区别是什么？
 
答案是：它们之间有两点不同，并且二者之间有着复杂的相互作用。它们分别是”技术上”的差异和“文化上”的差异。
 
首先，有一点是相同的：列表与元组都是容器，是一系列的对象。
 
Python
 
 
 
 
1
 
2
 
3
 
4
 
5
 
6
 
 
>>> my_list = [1, 2, 3]
 
>>> type(my_list)
 
<class 'list'>
 
>>> my_tuple = (1, 2, 3)
 
>>> type(my_tuple)
 
<class 'tuple'>
 
二者都可以包含任意类型的元素甚至可以是一个序列，还可以包含元素的顺序（不像集合和字典）。
 
Python
 
 
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
 
>>> my_list[1] = "two"
 
>>> my_list
 
[1, 'two', 3]
 
>>> my_tuple[1] = "two"
 
Traceback (most recent call last):
 
  File "<stdin>", line 1, in <module>
 
TypeError: 'tuple' object does not support item assignment
 
现在来讲讲区别。列表和元组的“技术差异”是，列表是可变的，而元组是不可变的。这是在 Python 语言中二者唯一的差别。
 
尽管有好几种表现方式，但这是列表和元组唯一的“技术差异”。比如：列表有一个 append() 的方法来添加更多的元素，而元组却没有这个方法：
 
Python
 
 
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
 
>>> my_list.append("four")
 
>>> my_list
 
[1, 'two', 3, 'four']
 
>>> my_tuple.append("four")
 
Traceback (most recent call last):
 
  File "<stdin>", line 1, in <module>
 
AttributeError: 'tuple' object has no attribute 'append'
 
元组并不需要一个 append() 方法，因为元组不能修改。
 
“文化差异“是指二者在实际使用中的差异：在你有一些不确定长度的相同类型队列的时候使用列表；在你提前知道元素数量的情况下使用元组，因为元素的位置很重要。
 
举个例子，假设你有一个函数是用来在目录中查找结尾为 *.py 的文件。函数返回的应该是一个列表，因为你并不知道你会找到多少个文件，而这些文件都有相同的含义：它们仅仅是你找到的另一个文件。
 
Python
 
 
 
 
1
 
2
 
 
>>> find_files("*.py")
 
["control.py", "config.py", "cmdline.py", "backward.py"]
 
另一方面，让我们假设你需要存储五个值来代表气象观测站的位置：id ,城市，国家，纬度，经度。元组就比列表更适用于这种情况：
 
Python
 
 
 
 
1
 
2
 
3
 
 
>>> denver = (44, "Denver", "CO", 40, 105)
 
>>> denver[1]
 
'Denver'
 
(让我们暂时不要讨论使用类来表示的这种情况)。第一个元素是 id ，第二个元素是城市，等等。位置决定了它的意义。
 
把这种“文化差异”放到 C 语言来讲，列表像是数组，元组则像是 structs 结构体。
 
Python 采用了命名元组的方法来使含义更加明确：
 
Python
 
 
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
>>> from collections import namedtuple
 
>>> Station = namedtuple("Station", "id, city, state, lat, long")
 
>>> denver = Station(44, "Denver", "CO", 40, 105)
 
>>> denver
 
Station(id=44, city='Denver', state='CO', lat=40, long=105)
 
>>> denver.city
 
'Denver'
 
>>> denver[1]
 
'Denver'
 
对元组和列表之间“文化差异”的一个总结是：元组是不需要名字的命名元组。
 
“技术差异”和“文化差异”这种区分也并不准确，因为有时候他们并不稳定。为什么同种元素的序列可变，而不同元素的序列不可变呢？举个例子，我不能修改我的气象站，因为命名元组是不可变的元组。
 
Python
 
 
 
 
1
 
2
 
3
 
4
 
 
>>> denver.lat = 39.7392
 
Traceback (most recent call last):
 
  File "<stdin>", line 1, in <module>
 
AttributeError: can't set attribute
 
有时技术考量要比文化考量重要。比如你不能把列表当做字典的关键字，因为只有不可变的值才能进行哈希运算，因此只有不可变的值才能作为关键字。要使用列表做关键字，你需要把它转化为元组：
 
Python
 
 
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
>>> d = {}
 
>>> nums = [1, 2, 3]
 
>>> d[nums] = "hello"
 
Traceback (most recent call last):
 
  File "<stdin>", line 1, in <module>
 
TypeError: unhashable type: 'list'
 
>>> d[tuple(nums)] = "hello"
 
>>> d
 
{(1, 2, 3): 'hello'}
 
技术和文化的另一个冲突是：在 Python 中元组使用的地方，列表也起着重要作用。当你定义一个带参函数，元组作为参数传入，即使这个值的位置并不显著，至少 Python 知道这是一个元组。你可能会说这是个元组因为你不能改变被传进来的值，但这只是重视了技术上的差异而非文化上的差异。
 
我知道：在参数数组中，位置很重要，因为他们是位置参数。但是在函数中，它会接收参数数组并传入另一个函数，它仅仅是一组参数，与其他参数并无不同。其中一些会在调用中变化。
 
Python 之所以在这里使用元组是因为元组比列表更节省空间。列表被重复分配使得在添加元素上更快。这体现了 Python 的实用性：相比于在参数数组上，列表/元组的语义差别，在这种情况下，使用这种数据结构更好。
 
大部分情况下，你应该根据文化差异来选择使用列表还是元组。思考下你数据的含义。如果实际上根据你的程序来计算，你的数据长度并不固定，那么可能用列表更好。如果在写代码时你知道第三个元素的含义，那么用元组更好。
 
另一方面，函数式编程强调使用不可变的数据结构来避免产生使代码变得更难解读的副作用。如果你喜欢使用函数式编程，那么你可能因为元组的不可变而更喜欢它们。

 
文章目录
 
Python列表和元组的详细区别
一、列表和元组的区别
二、列表（List）
三、元组（Tuple）
 

 
Python列表和元组的详细区别
 
一、列表和元组的区别
 
列表是动态数组，它们可变且可以重设长度（改变其内部元素的个数）。
元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变。
元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存。
 
这些区别结实率两者在设计哲学上的不同：
 
列表可被用于保存多个互相独立对象的数据集合
元组用于描述一个不会改不安的事务的多个属性
 
二、列表（List）
 
列表一旦创建了我们就可以根据自己的需要随意改变它的内容：
 
>>> l = [1, 2, 3, 4, 5, 6]
>>> l[0] = l[2] * l[3]
>>> l
[12, 2, 3, 4, 5, 6]
 
另外我们可以给列边添加新的数据来增加其大小：
 
>>> len(l)
6
>>> l.append(7)
>>> l
[12, 2, 3, 4, 5, 6, 7]
>>> len(l)
7
 
这是因为动态数组支持resize操作，可以增加数组的容量。当一个大小为N的列表第一次需要添加数据时，Python会创建一个新的列表，足够放原来的N个元素以及额外添加的元素。不过，实际分配的并不是N+1个元素，而是M个元素，M > N, 这是为了给未来的添加预留空间。然后旧列表的数据被复制到新列表中，旧列表则会被销毁。从设计理念上来说，第一次添加可能是后续多次添加的开始，通过预留空间的做法，我们就可以减少这一分配空间的操作次数以及内存复制的次数。这点非常重要，因为内存复制可能非常的昂贵，特别是当列表大小开始增长以后。
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GdQpXs7R-1599024560319)(./image/列表的添加操作.jpg)]
 
三、元组（Tuple）
 
元组是固定且不可改变的。这意味着一旦元组被创建，和列表不同，它的内容无法被修改或它的大小也无法被改变。
 
>>> t = (1, 2, 3, 4)
>>> t[0] = 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
 
虽然它们不支持改变大小，但是我们可以将两个元组合并成一个新元组。这一操作类似列表的resize操作，但我们不需要为新生的元组分配任何额外的空间：
 
>>> t1 = (1, 2, 3, 4)
>>> t2 = (5, 6, 7, 8)
>>> t1 + t2
(1, 2, 3, 4, 5, 6, 7, 8)
 
如果我们将其与列表的append操作比较，我们会看到它的复杂度是O(n)而不是列表的O(1)。这是因为对元组每添加一个新元素都会有分配和复制操作，而不是像列表那样仅在额外的空间耗尽时发生。所以元组并没有提供一个类似append的自增操作，任意两个元组相加始终返回一个新分配的元组。
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nIsaGxH8-1599024560321)(./image/元组的合并操作.jpg)]
 
该网站为Python Tutor,一个能够对python运行内存可视化的网站，非常适合初学者研究，在运行过程中内存发生了什么。
 
元组的静态特性的另一个好处体现在一些会在Python后台发生的事情：资源缓存。
 
Python是一门垃圾收集语言，这意味着当一个变量不再被使用时，Python会将该变量使用的内存释放回操作系统，以供其他程序（变量）使用。然而，对于长度为1~20的元组，即使它们不在被使用，它们的空间也不会立刻还给系统，而是留待未来使用。这意味着当未来需要一个同样大小的新的元组时，我们不再需要向操作系统申请一块内存来存放数据，因为我们已经有了预留的空间。
 
这看上去可能是个细微的好处，但是实际上是元组一个很神奇的地方：它们可以被轻松快速地创建，因为它们可以避免跟操作系统频繁的打交道，而后者会花很长的时间。
 
下面举个例子会非常直观的说明问题
 
In [1]: %timeit l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
93.7 ns ± 3.33 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [2]: %timeit t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
18.5 ns ± 1.19 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
 
上面的示例中显示了初始化一个列表比初始化一个元组慢了5.1倍——如果这是在一个循环中，这点差别会很快的累加起来。

小编典典
除了元组是不可变的之外，还应有语义上的区别来指导它们的用法。元组是异构数据结构（即，它们的条目具有不同的含义），而列表是同类序列。元组具有结构，列表具有顺序。
使用这种区别可以使代码更加明确和易于理解。
一个示例是成对的页和行号，以成对参考书中的位置，例如：
my_location = (42, 11) # page number, line number
然后，您可以将其用作字典中的键来存储有关位置的注释。另一方面，列表可用于存储多个位置。自然地，人们可能想在列表中添加或删除位置，因此使列表可变是有意义的。另一方面，从现有位置添加或删除项目没有意义-因此，元组是不可变的。
在某些情况下，您可能想更改现有位置元组中的项目，例如在页面的各行中进行迭代时。但是元组不变性迫使您为每个新值创建一个新的位置元组。从表面上看，这似乎很不方便，但是使用这样的不可变数据是值类型和函数式编程技术的基石，它可以具有很多优点。
关于此问题，有一些有趣的文章，例如“ Python元组不仅仅是常量列表”或“了解Python中的元组与列表”。官方Python文档也提到了这一点
“组是不可变的，并且通常包含一个异类序列…”。
在像Haskell这样的静态类型语言中，元组中的值通常具有不同的类型，并且元组的长度必须固定。在列表中，所有值都具有相同的类型，并且长度不是固定的。因此区别非常明显。
最后，Python中有一个namedtuple，这很有意义，因为一个元组应该已经具有结构。这强调了元组是类和实例的轻量级替代方案的思想。
2020-02-08

1.列表
列表是由一序列特定顺序排列的元素组成的。可以把字符串，数字，字典等都可以任何东西加入到列表中，列表中的元素之间没有任何关系。列表也是自带下标的，默认也还是从0开始。列表常用方括号表示，即：[]，元素用逗号隔开。
例子：
a = ["huangzhenping","laoma",123]
print(a)
print(type(a))
说明：list 里面的元素的数据类型也可以不同；list 元素也可以是另一个 list，例：
list2 = ['python', 'java', ['asp', 'php'], 'scheme']
常用功能：
append：追加
例子：
a = ["huangzhenping","laoma","laozhao"]
print(a)
a.append("song")
print(a)
index：返回下标位置
a = ["huangzhenping","laoma","laozhao"]
print(a[0],a[2])
print(a.index("laoma"))
insert：往什么位置插入对象
a = ["huangzhenping","laoma","laozhao"]
a.insert(1,"song")
print(a)
pop：删除末尾元素
a = ["huangzhenping","laoma","laozhao"]
a.pop()
print(a)
remove：自定义删除
a = ["huangzhenping","laoma","laozhao"]
a.remove("huangzhenping")
print(a)
sort：排序（升序）
a = [1,3,6,7,4]
a.sort()
print(a)
reverse：反序
a = [1,3,6,7,4]
a.reverse()
print(a)
切片：（从1至5，2为步长）
a = [1,2,3,4,5,6,7,8,9,10]
print(a[0:4:2])
2.元组
tuple 和 list 非常类似，但是 tuple 一旦初始化就不能修改，tuple唯一和list定义的区别就是[]变成了()，它也没有 append()，insert()这样的方法
例子：
a ="abcdefghijkmn"
print(tuple(a))
print(type(tuple(a)))
注：有逗号时，为元组类型
例子：
a = ("hello")
print(a)
print(type(a))
b = ("hello",)
print(b)
print(type(b))
结果：
hello

('hello',)

tuple常用方法：
count：统计元组中相同元素的个数
a = ("a","b","c","a")
print(a.count("a"))
index：元组中某元素第一次出现的下标
a = ("a","b","c","d")
print(a.index("d"))
3.字典
字典是由花括号{}来包含其数据的，花括号内包含键(key)和其对应的值(value)，一对键和值成为一个项，键和值用冒号:隔开，项和项之间用逗号,隔开，空字典就是不包含任何项的字典，也可理解为空字典就是花括号内不包含任何内容，直接使用花括号{}表示.
字典赋值有三种方式:
例子：
a = {'name':'huang','age':'20'}
b =dict(name="huang",age=20)
c=dict([('name','huang'), ('age',20)])   #序列中也是一个序列或元组
print(type(a))
print(type(b))
print(type(c))
结果：



例子：
a =dict(name="li",age=28)
print(a)
print(type(a))
说明：避免 key 不存在的错误的两种办法：
一是通过 in 判断 key 是否存在：
'Thomas' in dict1   #
二是通过 dict 提供的 get 方法：
如果 key 不存在，可以返回 None（无结果）
自动识别为dict类型，把等于号和逗号看成冒号
例子：
a =dict({("name","li"),("age",28)})
print(b)
print(type(b))
字典常用功能：
clear：清空字典
copy：复制
get：获取信息，没有则返回为空
例子：
a = {"name":"li","age":28}
print(a.get("name"))
setdefault：存在则不变，不存在则设置一个值
例子：
a = {"name":"li","age":28}
print(a.setdefault("name","huangzhenping"))
print(a.setdefault("address","shenzhen"))
print(a)
keys：获取所有键（对象）
例子：
a = {"name":"li","age":28}
print(a.keys())
values：获取所有对象的值
例子：
a = {"name":"li","age":28}
print(a.values())
iteritems：一般用于for循环，一个一个取出来（避免占内存）
例子：
a = {"name":"li","age":28}
print(a.iteritems())
forx,yina.iteritems():
print(x,y)
pop：删除对象key，实际上对应的值没有被删
例子：
a = {"name":"li","age":28}
a.pop("name")
print(a)
字典的高级操作
fromkeys：将一个列表引入字典中，并设置一个默认值
例子：
list1=["a","b","c"]
dict1={}
n=dict.fromkeys(list1,"test")
print(n)
print(type(n))
zip：将两个列表叠加成一个列表，如果要变成字典，则dict(zip(l1,l2))
list1=["a","b","c"]
list2=["d","e","f"]
list3=zip(list1,list2)
print(list3)
print(type(list3))
print(dict(list3))
update：将dirct_test字典和k字典合并
dict1={"a":"zhang","b":"huang"}
dict2={"c":"zhao","d":"sun"}
dict1.update(dict2)
print(dict1)
sorted：对字典排序，lambda是一个匿名函数，reverse = False 升序
dict1=dict(a=1,c=3,d=4,b=2,e=5)
print(dict1)
printsorted(dict1.iteritems())
printsorted(dict1.iteritems(),key=lambdad:d[1],reverse=False)
4.set集合
set 和 dict 类似，也是一组 key 的集合，但不存储 value。由于 key 不能重复，所以，在 set 中，没有重复的 （key重复元素在 set 中自动被过滤）
add(key)方法可以添加元素到 set 中
例子：
s = set([1, 1, 2, 2, 3, 3])
s.add(4)
remove(key)方法可以删除元素
例子：
s.remove(4)
说明：set 可以看成数学意义上的无序和无重复元素的集合，因此，两个 set 可以做数学意义上的 交集、并集等操作
5.帮助
查看数据类型：print(type(variable))
查看属性：dir(variable)
查看帮助：help(sorted)
看具体源码： Ctrl + 鼠标左键
6.变量的强制转换
例子：
把list1作为key，list2作为value，生成一个新的字典
a = [1,2,3,4,5,6,7]
b = ['a','b','c','d','e','f','g']
dict(zip(a,b))
例子：
两个字典的合并
dict1={1:[1,11,111],2:[2,22,222]}
dict2={3:[3,33,333],4:[4,44,444]}
dictMerged1=dict(dict1.items()+dict2.items())
dictMerged2=dict(dict1,