pythonlist类型如何转换成字典类型

一、列表

1、定义列表，取出列表中的值

1 names = [] #定义空列表
 2 names = ['a','b','c'] #定义一个非空列表
 3 
 4 # 取出列表中的值
 5 >>> names = ['a','b','c']
 6 >>> names[0]
 7 'a'
 8 >>> names[1]
 9 'b'
10 >>> names[2]
11 'c'
12 >>> names[-1]#倒着取最后一个值
13 'c'

2、切片

1 >>> names = ['a','b','c','d'] # 列表的下标值是从0开始取值的
 2 >>> names[1:3] #取1到3之间的元素，包括1，不包括3
 3 ['b', 'c']
 4 >>> names[1:-1] #取1到-1之间的元素，包括1，不包括-1
 5 ['b', 'c']
 6 >>> names[0:3]
 7 ['a', 'b', 'c']
 8 >>> names[:3] #从头开始取，0可以省略，效果等同于names[0:3]
 9 ['a', 'b', 'c']
10 >>> names[3:]  #想取到最后一个值，必须不能写-1，只能这么写
11 ['d']
12 >>> names[0::2] #后面的2表示：每隔一个元素就取一个
13 ['a', 'c']
14 >>> names[::2] #从头开始0可以省略，效果跟上一句一样
15 ['a', 'c']

切片小结：

①序列始终都是从左向右切片的，不能是从右向左

①列表切片时，起始位的元素是包括的，结束位的元素是不包括（又叫顾头不顾尾），最后一个位置表示步长（names[开始位:结束位:步长]）

②如果从0位置取值，0可以省略

③想取最后一个值时，结束位不能是-1，因为结束位的元素不包括，所以只能留空

3、列表函数&方法

函数：

序号	函数
1	cmp(list1, list2) #比较两个列表的元素
2	len(list) #列表元素个数
3	max(list) #返回列表元素最大值
4	min(list) #返回列表元素最小值
5	list(seq) #将元组转换为列表

方法：

序号	方法
1	list.append(obj)　　#在列表末尾添加新的对象
2	list.count(obj)　　#统计某个元素在列表中出现的次数
3	list.extend(seq)　　#在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj)　　#从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)　　#将对象插入列表
6	list.pop([index=-1])　　#移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj)　　#移除列表中某个值的第一个匹配项
8	list.reverse()　　#反向列表中元素
9	list.sort([func])　　#对原列表进行排序
10	list.clear()　　#清空列表
11	list.copy()　　#复制列表

演示：

1 # append 列表末尾添加新的对象
 2 >>>    names = ['a','b','c','d']
 3 >>>    names.append('e')
 4 >>>    print(names)
 5 ['a', 'b', 'c', 'd', 'e']#e是新加的元素
 6 
 7 #统计（count(元素)）
 8 >>> names = ['a','b','c','d','a']
 9 >>> print(names.count('a')) #统计'a'元素的个数
10 2
11 
12 #扩展（extend）names2的列表合并到names1中，但是，names2这个列表依然存在，如果想删除names2这个变量，则只需del names2即可
13 >>> names1 = ['a','b','c','d']
14 >>> names2 = [1,2,3,4]
15 >>> names1.extend(names2)
16 >>> print(names1)
17 ['a', 'b', 'c', 'd', 1, 2, 3, 4]
18 
19 # insert(下标值，插入的内容) 
20 >>> names = ['a','b','c','d']
21 >>> names.insert(0,'1') #0表示需要插入的下标值，'1'表示插入的内容
22 >>> print(names)
23 ['1', 'a', 'b', 'c', 'd'] #在下标值为0的地方插入'1'
24 
25 #翻转（reverse()）
26 >>> names = ['a','b','c','d']
27 >>> names.reverse()
28 >>> print(names)
29 ['d', 'c', 'b', 'a']  #将整个列表翻转过来
30 
31 #排序（sort()）
32 >>> names = [4,2,3,1]
33 >>> names.sort()
34 >>> print(names)
35 [1, 2, 3, 4]
36 
37 #清空列表（clear()）
38 >>> names = ['a','b','c','d']
39 >>> names.clear()
40 >>> print(names)
41 []
42 
43 #复制(copy())
44 >>> names1 = ['a','b','c','d']
45 >>> names2 = names1.copy()
46 >>> print(names2)
47 ['a', 'b', 'c', 'd']

演示 

删除（del、remove(元素)、pop()）

1 #根据下标值删除元素
 2 >>> names = ['a','b','c','d']
 3 >>> del names[0] 
 4 >>> print(names)
 5 ['b', 'c', 'd']
 6 
 7 #根据元素删除
 8 >>> names = ['a','b','c','d']
 9 >>> names.remove('a')
10 >>> print(names)
11 ['b', 'c', 'd']
12 
13 #删除最后一个
14 >>> names = ['a','b','c','d']
15 >>> names.pop()
16 'd'
17 >>> print(names)
18 ['a', 'b', 'c']
19 
20 #pop返回从列表中移除的元素对象
21 >>> names = ['a','b','c','d']
22 >>> names_pop=names.pop(-1)
23 >>> print(names_pop)
24 d

del、remove、pop 

二、元组

元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表

元组使用小括号，列表使用方括号

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

用途：一般情况下用于自己写的程序能存下数据，但是又希望这些数据不会被改变，比如：数据库连接信息等

1.访问元祖

1 >>> name = ('a','b','c','d')
2 #下标值跟列表一样，也是从0开始
3 >>> print(name[0])
4 'a'
5 >>> print(name[1])
6 'b'
7 #访问最后一个元素
8 >>> print(name[-1])
9 'd'

2，count（统计） 与 index（索引）

# count 统计元素数量
>>> name = ('a','b','c','a')
>>> print(name.count('a'))
2

# index 查看元素下标
>>> name = ('a','b','c','a')
>>> print(name.index('b'))
1

3、修改元组 删除元祖

1 #元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
 2 >>> tup1 = (12, 34.56);
 3 >>> tup2 = ('abc', 'xyz')
 4 
 5 # 以下修改元组元素操作是非法的。
 6 # tup1[0] = 100
 7 
 8 # 创建一个新的元组
 9 >>> tup3 = tup1 + tup2;
10 >>> print (tup3)
11 (12, 34.56, 'abc', 'xyz')
12 
13 
14 
15 #元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
16 >>> tup = ('Google', 'Runoob', 1997, 2000)
17 
18 >>> print (tup)
19 >>> del tup;
20 >>> print ("删除后的元组 tup : ")
21 >>> print (tup)
22 
23 #以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
24 Traceback (most recent call last):
25     print (tup) # NameError: name 'tup' is not defined
26 NameError: name 'tup' is not defined
27 ('Google', 'Runoob', 1997, 2000)
28 删除后的元组 tup :

小结：

①元组中的数据不可以被修改，不可以被添加，不可以被删除(当然除非是元组中嵌套列表或者字典，列表和字典中的值是可以被更改的）

②元组的获取元素的方式和列表一样，都是通过下标值访问，下标值都是从0开始

③由于元组只能读，不能写，所以元组只有count和index两个方法

④元组的切片功能和列表一样

4、元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x	1 2 3	迭代

 

5、元祖内置函数

序号	方法
1	len(tuple)　　#计算元组元素个数
2	max(tuple)　　#返回元组中元素最大值
3	min(tuple)　　#返回元组中元素最小值
4	tuple(seq)　　#将列表转换为元组

 

三、字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

一、特征：

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行

1、字典是无序的；

2，字典的key是唯一的,不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

1 >>> dict = {'Name': 'QQ', 'Age': 7, 'Name': 'DD'}
2 >>> print ("dict['Name']: ", dict['Name'])
3 dict['Name']:  DD

3、键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例:

1 >>> dict = {['Name']: 'Runoob', 'Age': 7}
2 >>> print ("dict['Name']: ", dict['Name']) 
3 
4 #错误如下
5 Traceback (most recent call last):
6     dict = {['Name']: 'Runoob', 'Age': 7}
7 TypeError: unhashable type: 'list'

二、基本用法：增加、查看、修改、删除

1、增加

1 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
2 #新增
3 >>> stu_info["wanger"] = 30
4 #输出结果
5 >>> print(stu_info)
6 {'zhangsan': 23, 'lisi': 18, 'qigao': 18, 'wanger': 30}

2、查看

通过key查找value

1 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
 2 #存在key返回value
 3 >>> print(stu_info["qigao"])
 4 18
 5 
 6 #不存在key提示报错
 7 >>> print(stu_info["wanger"])
 8 Traceback (most recent call last):
 9     print(stu_info["wanger"])
10 KeyError: 'wanger'

通过get(key) 查找value

>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#存在则返回对应的value
>>> print(stu_info.get("qigao"))
18

#不存在返回None
>>> print(stu_info.get("wanger"))
None

注：get(k)不存在key值，则返回None，通过key直接访问会报错，所以建议推荐用get(k)这个方法获取value

通过key in 字典判断  key是否存在与字典中

1 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
2 >>> print("qigao"  in stu_info ) #标准用法,在Python3和Python2.7都可以用
3 True

3、修改

1 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
2 #修改'qigao'对应的value值，由18改为23
3 >>> stu_info["qigao"] = 23
4 #输出
5 >>> print(stu_info)
6 {'wanger': 30, 'lisi': 18, 'zhangsan': 23, 'qigao': 23}

4、删除(del、pop、popitem)

1 #del 
 2 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
 3 >>> del stu_info['qigao']
 4 #结果输出
 5 >>> print(stu_info)
 6 {'zhangsan': 23, 'lisi': 18}
 7 
 8 注：如果是del stu_info的话，则是删除stu_info这个变量
 9 
10 
11 #pop
12 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
13 #删除时给出提示
14 >>> print(stu_info.pop("qigao"))
15 18
16 #输出结果
17 >>> print(stu_info)
18 {'zhangsan': 23, 'lisi': 18}
19 
20 
21 #popitem
22 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
23 #删除时给出提示
24 >>> print(stu_info.popitem())
25 ('qigao', 18)
26 #输出结果
27 >>> print(stu_info)
28 {'zhangsan': 23, 'lisi': 18}

三、字典内置函数&方法

内置函数

序号	描述
1	len(dict) #计算字典元素个数，即键的总数
2	str(dict) #输出字典可打印的字符串表示
3	type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型

1 #返回字典的元素个数(len )
 2 >>> dict = {'Name': 'zhangsan', 'Age': 7};
 3 >>> print (len (dict))
 4 2
 5 
 6 
 7 #返回字符串(str)
 8 >>> dict = {'Name': 'zhangsan', 'Age': 7};
 9 >>> print (str (dict))
10 {'Name': 'zhangsan', 'Age': 7}
11 
12 
13 #返回输入的变量类型(type)
14 >>> dict = {'Name': 'zhangsan', 'Age': 7};
15 >>> print (type (dict))
16 <class 'dict'>

方法

序号	描述
1	dict.clear() #删除字典内所有元素
2	dict.copy() #返回一个字典的浅复制
3	dict.fromkeys(seq[, val]) #创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4	dict.get(key, default=None) #返回指定键的值，如果值不在字典中返回default值
5	dict.items() #以列表返回可遍历的(键, 值) 元组数组
6	dict.keys() #以列表返回一个字典所有的键
7	dict.setdefault(key, default=None) #和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
8	dict.update(dict2) #把字典dict2的键/值对更新到dict里
9	dict.values() #以列表返回字典中的所有值
10	pop(key[,default]) #删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出.否则，返回default值
11	popitem() #返回并删除字典中的最后一对键和值

1 #删除字典内所有元素   clear()  
  2 >>> dict = {'Name': 'Zara', 'Age': 7}
  3 
  4 >>> print ("字典长度 : %d" %  len(dict)) 
  5 >>> dict.clear()
  6 >>> print ("字典删除后长度 : %d" %  len(dict))
  7 
  8 #输出：
  9 字典长度 : 2
 10 字典删除后长度 : 0
 11 
 12 
 13 #-----------------------------------------------------------------------------------
 14 
 15 
 16 ##返回一个字典的浅复制   copy()
 17 >>> dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
 18 
 19 >>> dict2 = dict1  # 浅拷贝: 引用对象
 20 >>> dict3 = dict1.copy()  # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
 21 
 22 >>> # 修改 data 数据
 23 >>> dict1['user'] = 'root'
 24 >>> dict1['num'].remove(1)
 25 
 26 >>> # 输出结果
 27 >>> print(dict1)
 28 >>> print(dict2)
 29 >>> print(dict3)
 30 
 31 #输出：
 32 {'user': 'root', 'num': [2, 3]}
 33 {'user': 'root', 'num': [2, 3]}
 34 {'user': 'runoob', 'num': [2, 3]}
 35 
 36 
 37 #-----------------------------------------------------------------------------------
 38 
 39 
 40 #函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值    fromkeys()
 41 >>> seq = ('name', 'age', 'sex')
 42 
 43 >>> dict = dict.fromkeys(seq)
 44 >>> print ("新的字典为 : %s" %  str(dict))
 45 
 46 >>> dict = dict.fromkeys(seq, 10)
 47 >>> print ("新的字典为 : %s" %  str(dict))
 48 
 49 #输出：
 50 新的字典为 : {'name': None, 'age': None, 'sex': None}
 51 新的字典为 : {'name': 10, 'age': 10, 'sex': 10}
 52 
 53 
 54 #-----------------------------------------------------------------------------------
 55 
 56 
 57 #函数返回指定键的值，如果值不在字典中返回默认值   get() 
 58 >>> dict = {'Name': 'Runoob', 'Age': 27}
 59 
 60 >>> print ("Age 值为 : %s" %  dict.get('Age'))
 61 >>> print ("Sex 值为 : %s" %  dict.get('Sex', "NA"))
 62 
 63 #输出：
 64 Age 值为 : 27
 65 Sex 值为 : NA
 66 
 67 
 68 #-----------------------------------------------------------------------------------
 69 
 70 
 71 #方法以列表返回可遍历的(键, 值) 元组数组   items() 
 72 >>> dict = {'Name': 'Runoob', 'Age': 7}
 73 
 74 >>> print ("Value : %s" %  dict.items())
 75 
 76 #输出：
 77 Value : dict_items([('Name', 'Runoob'), ('Age', 7)])
 78 
 79 
 80 #-----------------------------------------------------------------------------------
 81 
 82 
 83 #返回一个字典所有的键值   keys()
 84 >>> dict = {'Name': 'QQ', 'Age': 7}
 85 
 86 >>> print ("字典所有的键为 : %s" %  dict.keys())
 87 >>> print ("字典所有值为 : ",  list(dict.values()))
 88 
 89 #输出：
 90 字典所有的键为 : dict_keys(['Name', 'Age'])
 91 字典所有值为 :  ['QQ', 7]
 92 
 93 
 94 #-----------------------------------------------------------------------------------
 95 
 96 
 97 #和get()方法类似，如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值    setdefault() 
 98 >>> dict = {'Name': 'Runoob', 'Age': 7}
 99 
100 >>> print ("Age 键的值为 : %s" %  dict.setdefault('Age', None))
101 >>> print ("Sex 键的值为 : %s" %  dict.setdefault('Sex', None))
102 >>> print ("新字典为：", dict)
103 
104 #输出：
105 Age 键的值为 : 7
106 Sex 键的值为 : None
107 新字典为： {'Name': 'Runoob', 'Age': 7, 'Sex': None}
108 
109 
110 #-----------------------------------------------------------------------------------
111 
112 
113 #把字典dict2的键值对更新到dict里   update() 
114 >>> dict = {'Name': 'Runoob', 'Age': 7}
115 >>> dict2 = {'Sex': 'female' }
116 
117 >>> dict.update(dict2)
118 >>> print ("更新字典 dict : ", dict)
119 
120 #输出：
121 更新字典 dict :  {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}
122 
123 
124 #-----------------------------------------------------------------------------------
125 
126 
127 #返回字典中的所有值    values()
128 >>> dict = {'Name': 'Zara', 'Age': 7}
129 
130 >>> print ("Value : %s" %  dict.values())
131 
132 #输出：
133 Value : dict_values(['Zara', 7])

四、循环字典

1 #方法一
2 for key in dict:
3     print(key,dict[key])
4 
5 #方法二
6 for k,v in info.items(): #会先把dict转成list,数据量大时莫用
7     print(k,v)

注：

①方法1的效率比方法2的效率高很多

②方法1是直接通过key取value

③方法2是先把字典转换成一个列表，再去取值

④当数据量比较大的时候，用第二种方法时，字典转换成列表的这个过程需要花大量的时间老转换，当然数据量不大，没有关系，效率差不多