pythonlist字典

A. python基础-列表 元组 集合 字典区别和用法

Python中有六个标准的数据类型：Number(数字)，String(字符串)，List(列表)，Tuple(元组)，Set(集合)，Dictionary(字典)。其中：Number(数字）、String(字符串)、Tuple（元组）是不可变数据，其余三种是可变数据。

转义字符

输出结果

布尔值
布尔值是一个逻辑值，只有真(True)和假（False)

输出结果

Python数据结构包括列表(list)、元组(tuple)、集合(set)、字典(dict)等，这里主要讲解列表，列表有两个特点：

输出结果

修改表中元素

输出结果

列表中插入元素

输出结果

输出列表中的元素

输出结果

元素是否在列表元素中及统计个数

输出结果

查找某个元素在列表中的位置

输出结果

顺序结构

输出结果

if 条件 1

输出结果

if 条件 2

输出结果

循环结构

输出结果

循环语句求和

输出结果

可重复，类型可不同。 类型不同也是跟数组最本质的区别。 python里的列表用“[]”表示：

对比a和b的结果

列表的 --- 增 -- 删 -- 改 -- 查

循环输出列表内容，在结尾添加指定的内容

字符串是 Python 中最常用的数据类型。 我们可以使用引号('或")来创建字符串。

元组与列表相似，不一样之处在于 元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组建立很简单，只须要在括号中添加元素，并使用逗号隔开便可。

字典是另外一种可变容器模型，且可存储任意类型对象。
字典的每一个键值(key=>value)对用冒号(:)分割，每一个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式以下所示：
d = {key1 : value1, key2 : value2 }

字典函数

集合（set）是一个 无序的不重复元素序列。
可使用大括号 { } 或者 set() 函数建立集合，注意：建立一个空集合必须用 set() 而不是 { }，由于 { } 是用来建立一个空字典。
它的主要做用以下： 1.去重，把一个列表变成集合，就自动去重了 。2.关系测试，测试两组数据以前的交集、差集、并集等关系。

关系测试

输出结果

元素的添加和删除

B. python字典转换为list后选中最后一个值

设为星标，第一时间获取更多干货

在python中，数据类型主要由以下几类组成：

列表(list): [a, b]

元组(tuple)：(a, b, )

集合(set)： {a, b}

字典(Dictonary): {a: ‘aaa’, b: ‘bbb’}

1. 列表

列表(List)

列表是Python中使用最频繁的数据类型，专门用于存储一串信息

列表是一种有序和可更改的集合。允许重复的元素

列表使用[]定义，元素之间使用，分隔。例：[1,2, ...]

列表的索引从位置0开始

索引就是元素在列表中的位置编号，索引又可以被称为下标

注意：从列表中取值时，如果超过索引范围，程序会报错

虽然列表可以存储不同类型元素，但是曰常中一般存储相同类型的元素

如何使用列表

列表[索引]: 从列表中取值，获取指定索引的元素

列表[开始索引:结束索引:步长]:

返回从开始索引到结束索引-1的列表，如果设置步长，按步长跳过元素

len(列表): 获取列表的长度

元素 in 列表: 判断元素是否在列表中

列表.count(元素): 返回指定元素在列表中的个数

列表.index(元素): 返回指定元素在列表中第一次出现的索引，查找失败时报错

列表.sort(): 从小到大排序，括号内增加reverse=True ,则是从大到小排序

列表_reverse(): 逆序(反转)列表

列表.clear(): 清空列表

Eg:

# 0 init listL = [1, 2, 3, 4, 5, 7, 6]# 1 index valueL[1] # --> 2# 2 stepL[2: 5: 2] # --> [3, 5]# 3 lengthlen(L) # --> 6# 4 in6 in L # ---> True8 in L # ---> False# 5 countL.count(1) # ---> 1# 6 indexL.index(2) # ---> 1# 7 sortL.sort() # ---> [1, 2, 3, 4, 5, 6, 7] 注意：会改变自己 返回None # 8 reverseL.reverse() # 由于第7步改变了自己， 这里变成[7, 6, 5, 4, 3, 2, 1] 会改变自己 返回None # 9. clearL.clear() # ---> []
列表特有的一些使用方法

L = [1, 2, 3, 4, 5]
列表[索引]=元素：修改指定索引的元素，索引不存在会报错

L[2] = 7 L # ---> [1, 2, 7, 4, 5]
列表 . append(元素)：在列表的末尾追加元素

L.append(6)L # ---> [1, 2, 7, 4, 5, 6]
列表 . insert(索引，元素)：在指定索引位置插入元素，索引不存在时在末尾追加

L.insert(3, 9)L # ---> [1, 2, 7, 4, 9, 5, 6]
列表.pop(索引)：

删除并返回指定索引的元素，未指定索引时删除最后一项，索引不存在时报错

L.pop(3) # 4, L 变成[1, 2, 7, 9, 5, 6]L.pop() # 6, L 变成[1, 2, 7, 9, 5]
列表 . remove(元素)：删除列表中第一个出现的指定元素，查找失败时报错

L.remove(2) # L 变成[1, 7, 9, 5]
del 列表[索引]: 删除指定索引位置的元素，索引不存在时报错

del L[3] # L 变成[1, 7, 9]
列表l.extend(列表2): 将列表2拼接在列表1后

L.extend([8, 9, 10]) L # L 变成[1, 7, 9, 8, 9, 10], 等价于 L = L + [8, 9, 10]
2. 元组

元组(Tuple)

元组是一种有序且不可更改的集合, 允许重复的成员

元组与列表的类似，不同之处在于元组元素不可修改

元组使用()定义，元素之间使用,分隔。例：(a, b, …)

元组中只包含一个元素时，可以省略()，只需要在元素后加逗号

init_tuple = 100,type(init_tuple) # ---> tuple# ---- 另外写法init_tuple = (100, ) # 逗号一定要加
注意：如果一个非元组类型的数据突然变成元组，检查是不是误加了逗号

集合与元组的通用方法

元组[索引]:从元组中取值，获取指定索弓丨的元素

元组[开始索引:结束索引:步长]:

返回从开始索引到结束索引-1的元组，如果设置步长，按步长跳过元素

len(元组)：获取元组的长度

元素in元组：判断元素是否在元组中

元组.count(元素)：返回指定元素在元组中的个数

元组.index(元素)：返回指定元素在元组中第一次出现的索引，查找失败会报错

元组和列表之间的转换

list(元组)：将元组转换成列表

tuple(列表): 将列表转换成元组

3. 集合

集合(Set)

集合是一种无序和无索引的序列。没有重复的元素

集合会自动删除重复的元素，一般应用于去重、交并差运算场景

集合使用{}定义，元素之间使用，分隔。例：{a, b, …}

集合与列表的通用方法

len(集合)：获取集合的长度

元素in集合：判断元素是否在集合中

集合.clear(): 清空集合

集合特有的使用方法

s = {1, 2, 3}

集合.add(元素)：将元素添加到集合中

s.add(5) # ---> {1, 2, 3, 5}
集合1.update(集合2): 添加新的元素或集合到当前集合中

s.add{4, 5, 6} # ---> {1, 2, 3, 5, 4, 6}
集合.remove(元素): 删除指定的元素，元素不存在时报错

s.remove(4) # ----> {1, 2, 3, 5, 6}
集合1&集合2 : 交集，获得由集合1和集合2中都存在的元素组成的新集合

s & {3, 4, 5} # ---> {3, 5}
集合1|集合2: 并集，获得集合1和集合2中所有元素的新集合

s | {8, 9, 10} # ---> {1, 2, 3, 5, 6, 8, 9, 10}
集合1 - 集合2 : 差集，获得在集合1中存在但是在集合2中不存在的元素集合

s - {9, 10} # ---> {1, 2, 3, 5, 6, 8}
集合和列表之间的转换(也可以和元组进行转换，方式类似)

list(集合)：将集合转换成列表

set(列表)：将列表转换成集合

C. 在python中，列表，字典的相互转换

列表、元组、集合、字典相互转换
一、列表元组转其他
1、列表转集合(去重)
list1
=
[6,
7,
7,
8,
8,
9]
set(list1)
#
{6,
7,
8,
9}
2、两个列表转字典
list1
=
['key1','key2','key3']
list2
=
['1','2','3']
dict(zip(list1,list2))
#
{'key1':
'1',
'key2':
'2',
'key3':
'3'}
3、嵌套列表转字典
list3
=
[['key1','value1'],['key2','value2'],['key3','value3']]
dict(list3)
#
{'key1':
'value1',
'key2':
'value2',
'key3':
'value3'}
4、列表、元组转字符串
list2
=
['a',
'a',
'b']
''.join(list2)
#
'aab'
tup1
=
('a',
'a',
'b')
''.join(tup1)
#
'aab'
二、字典转其他
1、
字典转换为字符串
dic1
=
{'a':1,'b':2}
str(dic1)
#
"{'a':
1,
'b':
2}"
2、字典key和value互转
dic2
=
{'a':
1,
'b':
2,
'c':
3}
{value:key
for
key,
value
in
a_dict.items()}
#
{1:
'a',
2:
'b',
3:
'c'}
三、字符串转其他
1、字符串转列表
s
=
'aabbcc'
list(s)
#
['a',
'a',
'b',
'b',
'c',
'c']
2、字符串转元组
tuple(s)
#
('a',
'a',
'b',
'b',
'c',
'c')
3、
字符串转集合
set(s)
#
{'a',
'b',
'c'}
4、字符串转字典
dic2
=
eval("{'name':'ljq',
'age':24}")
5、切分字符串
a
=
'a
b
c'
a.split('
')
#
['a',
'b',
'c']

D. 浅析Python中元祖，列表和字典的区别

1、列表（list）
list是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。
列表中的项目应该包括在方括号中，这样Python就知道你是指明一个列表。一旦你创建了一个列表，就可以添加、删除，或者是搜索列表中的项目。由于你可以增加或者删除项目，我们说列表是可变的数据类型，即这种类型是可以被改变的，且列表是可以嵌套的。
2、元祖(tuple)
元祖和列表十分相似，不过元祖是不可变的。即你不能修改元祖。
元祖通过圆括号中用逗号分隔的项目定义。元祖通常在使语句或者用户定义的函数能够安全的采用一组值得时候，即被使用的元祖的值不会改变。元祖可以嵌套。
3、字典(Dictionary)
字典类似于你通过联系人名称查找地址和联系人详细情况的地址簿，即我们把键（名字）和值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确信息。
键值对在字典中以这样的方式标记：d={key:value,key2:value2}.注意他们的键/值对用冒号分割，而各个队用逗号分隔，所有这些都包括在花括号中。另外，记住字典中的键/值是没有顺序的。如果你想要一个特定的顺序，那么你应该在使用前对他们排序。

E. python内置数据类型列表list和字典dict的性能

    我们来讨论下python的两种最重要的内置数据类型列表list和字典dict上，各种操作的复杂度。

list列表数据类型常用操作性能：

1、按索引取值和赋值（v=a[i]，a[i]=v）

由于列表的随机访问特性，这两个操作执行时间与列表大小无关，均为O（1）

2、列表的曾长，可以选择append()和_add_() "+"

list.append(v)的执行时间O(1)

list = list + [v]，执行时间是O(n+k)，因为新增了一个新的列表，其中k是被加的列表长度

举例：4种生成前n个整数列表的方法

如图：

我们可以计算一下这四个函数的耗时，如下

执行结果：

我们可以看到，4种方法运行时间差别很大，test1使用列表连接最慢，而test4使用list range最快，速度相差近200倍。

    如下图，我们总结下list基本操作的性能如何：

上图可知pop()从列表末尾移除元素O(1),但是pop(i)从列表中间移除元素要O(n)，为什么呢？

因为从中部移除元素，要把移除元素后面的元素全部向前挪一位，才保证了列表按索引取值和赋值很快，达到O(1)。

dict数据类型：

    字典和列表不同，dict根据key找到value，而list根据index。

    字典最常用的取值get和赋值set，其性能为O(1),而contain(in)操作判断字典是否存在某个key，其性能也是O(1)

list和dict的in操作对比：

    设计一个性能试验，验证list中检索一个值，对比dict中检索一个值的耗时对比。如下程序：

如果如下：

可见list的in操作复杂度为O(n)

PS：大家可以去python官方的算法复杂度网站看看：

https://wiki.python.org/moin/TimeComplexity

F. python 列表内有字典怎么使用

Python字典是另一种可变容器模型，且可存储任意类型对象，如字符串、数字、元组等其他容器模型。
一、创建字典
字典由键和对应值成对组成。字典也被称作关联数组或哈希表。基本语法如下：

复制代码代码如下:
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

也可如此创建字典：

复制代码代码如下:
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

注意：
每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中（{}）。
键必须独一无二，但值则不必。
值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。
二、访问字典里的值
把相应的键放入熟悉的方括号，如下实例:

复制代码代码如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];
#以上实例输出结果：
#dict['Name']: Zara
#dict['Age']: 7

如果用字典里没有的键访问数据，会输出错误如下：

复制代码代码如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print "dict['Alice']: ", dict['Alice'];

#以上实例输出结果：
#dict['Zara']:
#Traceback (most recent call last):
# File "test.py", line 4, in <mole>
# print "dict['Alice']: ", dict['Alice'];
#KeyError: 'Alice'[/code]
三、修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

复制代码代码如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry

print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
#以上实例输出结果：
#dict['Age']: 8
#dict['School']: DPS School

四、删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：

复制代码代码如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

del dict['Name']; # 删除键是'Name'的条目
dict.clear(); # 清空词典所有条目
del dict ; # 删除词典

print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
#但这会引发一个异常，因为用del后字典不再存在：
dict['Age']:
#Traceback (most recent call last):
# File "test.py", line 8, in <mole>
# print "dict['Age']: ", dict['Age'];
#TypeError: 'type' object is unsubscriptable

五、字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

复制代码代码如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};

print "dict['Name']: ", dict['Name'];
#以上实例输出结果：
#dict['Name']: Manni

2）键必须不可变，所以可以用数，字符串或元组充当，所以用列表就不行，如下实例：

复制代码代码如下:
#!/usr/bin/python

dict = {['Name']: 'Zara', 'Age': 7};

print "dict['Name']: ", dict['Name'];
#以上实例输出结果：
#Traceback (most recent call last):
# File "test.py", line 3, in <mole>
# dict = {['Name']: 'Zara', 'Age': 7};
#TypeError: list objects are unhashable

六、字典内置函数&方法
Python字典包含了以下内置函数：
1、cmp(dict1, dict2)：比较两个字典元素。
2、len(dict)：计算字典元素个数，即键的总数。
3、str(dict)：输出字典可打印的字符串表示。
4、type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。
Python字典包含了以下内置方法：
1、radiansdict.clear()：删除字典内所有元素
2、radiansdict.()：返回一个字典的浅复制
3、radiansdict.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4、radiansdict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值
5、radiansdict.has_key(key)：如果键在字典dict里返回true，否则返回false
6、radiansdict.items()：以列表返回可遍历的(键, 值) 元组数组
7、radiansdict.keys()：以列表返回一个字典所有的键
8、radiansdict.setdefault(key, default=None)：和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
9、radiansdict.update(dict2)：把字典dict2的键/值对更新到dict里
10、radiansdict.values()：以列表返回字典中的所有值