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

Posted 2023-05-04

参考技术A 设为星标，第一时间获取更多干货

在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.add4, 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(列表)：将列表转换成集合

从 Python 列表创建字典数组

【中文标题】从 Python 列表创建字典数组

【英文标题】：Create an array of dictionaries from a Python list

【发布时间】：2019-06-02 16:29:21

【问题描述】：

我想将散布值列表转换为字典数组。

我正在尝试在 Python 中创建一个能够与 JSON API 一起使用的预测值列表。拿到字典后，我会在上面使用json.dumps。

my_list = [35, 2.75, 67, 3.45] # in form of: (value, score, value, score)

理想的结果：

my_array_of_dicts = ['value':35, 'score':2.75, 'value':67 'score':3.45]

这是我尝试过的。

第一次尝试：

d = dict(zip(my_list[::2], my_list[1::2]))

它会产生...

> 35: 2.75,
   67: 3.45

我不确定如何获取自定义键。或者将每一对作为自己的字典。

第二次尝试：

['value':i, 'score':i for i in my_list]]

> ['value':35, 'score':35, 'value':2.75, 'score':2.75, 
   'value':67, 'score':67, 'value':3.45, 'score':3.45] 

它很接近，但它并没有考虑到每一秒的值都是一个分数。

【参考方案1】：

你真的很接近zip 版本。您只需要制作对象并指定键即可。

my_list = [35, 2.75, 67, 3.45] 

['value': v, 'score': s for v, s in zip(my_list[::2], my_list[1::2])]

结果：

['value': 35, 'score': 2.75, 'value': 67, 'score': 3.45]

【参考方案2】：

在第二次尝试中，得分：i + 1。在循环中执行 for i in range(0, len(my_list), 2)。

【参考方案3】：

d = map(dict, map(lambda t:zip(('value','score'),t), zip(my_list[::2], my_list[1::2])))
print(list(d))

【参考方案4】：

试试这个：

my_list = [35, 2.75, 67, 3.45]
list_of_dicts = ['value': k, 'score': v for k, v in zip(iter(my_list), iter(my_list))]
print(list_of_dicts)

输出：

['value': 35, 'score': 2.75, 'value': 67, 'score': 3.45]

我的解决方案与其他使用列表切片的解决方案之间的时间比较：

In [1]: my_list = [35, 2.75, 67, 3.45] * 100 # making it longer for better testing results

In [2]: def zip_with_slice():
   ...:     return ['value': v, 'score': s for v, s in zip(my_list[::2], my_list[1::2])]
   ...:

In [3]: def zip_with_iter():
   ...:     return ['value': k, 'score': v for k, v in zip(iter(my_list), iter(my_list))]
   ...:

In [4]: %timeit zip_with_slice()
56.5 µs ± 1.27 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [5]: %timeit zip_with_iter()
93 µs ± 2.99 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

如您所见，我使用迭代器的解决方案比使用切片的解决方案快很多（5-6 倍）。

【讨论】：

@aws_apprentice 您必须拥有一台更快的计算机，因为我的测试显示您在57.8 µs 上进行了编辑。

@aws_apprentice 我找到了原因。我正在使用原始列表 * 100 进行测试以获得更准确的结果，而您正在使用原始列表进行测试。这是有道理的，因为您的解决方案看起来不像是改进。

@aws_apprentice 您确定您使用的是新的、更长的列表吗？此外，您的 timeit 似乎不公平，因为您事先进行了实际计算。

【参考方案5】：

单行使用理解：

['value': k, 'score': v for k, v in [my_list[i: i + 2] for i in range(0, len(my_list), 2)]]

['score': 2.75, 'value': 35, 'score': 3.45, 'value': 67]

使用您最初的尝试：

['value': k, 'score': v for k,v in zip(my_list[::2], my_list[1::2])]

另一种更详细的方式

from operator import itemgetter

getters = [itemgetter(slice(i, i + 2)) for i in range(0, len(my_list), 2)]
vals = [g(my_list) for g in getters]


def score_vals(s):
    k, v = s
    return 'value': k, 'score': v

list(map(score_vals, vals))

【讨论】：

%timeit list(map(score_vals, vals)) 实际上并没有为整个计算计时，只是其中的一小部分。

【参考方案6】：

使用列表理解：

>>> my_list = [35, 2.75, 67, 3.45]
>>> my_dict = ['value': my_list[i], 'score': my_list[i+1] for i in range(0, len(my_list), 2)]
>>> my_dict
['score': 2.75, 'value': 35, 'score': 3.45, 'value': 67]

【参考方案7】：

另一种方法，使用带有参数的dict (**kwargs**)：

>>> my_list = [35, 2.75, 67, 3.45]
>>> [dict(value=x,score=y) for x,y in zip(my_list[::2], my_list[1::2])]
['value': 35, 'score': 2.75, 'value': 67, 'score': 3.45]
>>> 

【参考方案8】：

class my_dictionary(dict):

    # __init__ function
    def __init__(self):
        self = dict()

    # Function to add key:value
    def add(self, key, value):
        self[key] = value


# Main Function
dict_obj = my_dictionary()

然后您可以使用以下代码将保存在tmpkey和tmpvalue中的值分配给字典中的键值对。

dict_obj.key = tmpkey
dict_obj.value = tmpvalue
dict_obj.add(dict_obj.key, dict_obj.value)

而要创建字典列表，您只需创建一个空列表并在列表的每个元素中分配字典的副本。

dicMatrix = []
dictionary_copy = dict_obj.copy()
dicMatrix.append(dictionary_copy)

通过这种方式，您的字典将动态增长，制作字典副本的原因是，如果您每次将新值添加到列表中时都更改字典的值，否则对字典的引用将被分配到列表中。