Question

我有以下字典，其中键是整数，值是浮点数：

foo = {1:0.001,2:2.097,3:1.093,4:5.246}

这本词典有第1,2,3和4个键。

现在，我删除了密钥'2'：

foo = {1:0.001,3:1.093,4:5.246}

我只剩下第1,3和4号钥匙。但我希望这些键被称为1,2和3。

函数'enumerate'允许我获取列表[1,2,3]：

some_list = []
for k,v in foo.items():
    some_list.append(k)
num_list = list(enumerate(some_list, start=1))

接下来，我尝试使用这些新键和旧值填充字典：

new_foo = {}
for i in num_list:
    for value in foo.itervalues():
        new_foo[i[0]] = value

但是，new_foo现在包含以下值：

{1: 5.246, 2: 5.246, 3: 5.246}

所以每个值都被'foo'的最后一个值取代。我认为问题来自我的for循环的设计，但我不知道如何解决这个问题。有什么提示吗？

Answer 1

使用类似list-comprehension的样式：

bar = dict( (k,v) for k,v in enumerate(foo.values(), start=1) )

但是，正如评论中所提到的，排序将是任意的，因为python中的dict结构是无序的。要保留原始订单，可以使用以下内容：

bar = dict( ( i,foo[k] ) for i, k in enumerate(sorted(foo), start=1) )

此处sorted(foo)返回foo的排序键列表。 i是已排序键的新枚举以及新dict的新枚举。

Answer 2

字典是错误的结构。使用清单;毕竟，将连续的整数映射到值。

将代码调整为从0开始而不是1，或者在索引0处包含填充值：

删除del foo[2]'密钥'就像这样简单：

found

让您自动重新编号其余的“密钥”。

Answer 3

这看起来很像你应该做的事情，但我会假设你正在简化MCVE的过程，而不是真正试图命名你的字典d = {1:0.001, 2:2.097, 3:1.093, 4:5.246} del d[2] # d == {1:0.001, 3:1.093, 4:5.246} new_d = {idx:val for idx,val in zip(range(1,len(d)+1), (v for _,v in sorted(d.items())))} # new_d == {1: 0.001, 2: 1.093, 3: 5.246}。

$('.kol-vid-select').click(function(){
    var clicked = $(this);
    $('.kol-vid-select').removeClass('vid-active');
    clicked.addClass('vid-active');

    if($('.vid-active').hasClass('overview')){
        $('#myvid').attr('src', 'http://player.vimeo.com/video/108161058?api=1&player_id=player1');
        counter=0;
        //alert('overview');
    }

    if($('.vid-active').hasClass('analysis')){
        $('#myvid').attr('src', 'https://player.vimeo.com/video/125471793?api=1&player_id=player1');
        counter=0;
        //alert('analysis');
    }

    if($('.vid-active').hasClass('compelling')){
        $('#myvid').attr('src', 'https://player.vimeo.com/video/125478290?api=1&player_id=player1');
        counter=0;
        //alert('compelling');
    }

    if($('.vid-active').hasClass('practical')){
        $('#myvid').attr('src', 'https://player.vimeo.com/video/125483119?api=1&player_id=player1');
        counter=0;
        //alert('practical');
    }

    if($('.vid-active').hasClass('proven')){
        $('#myvid').attr('src', 'https://player.vimeo.com/video/125483160?api=1&player_id=player1');
        counter=0;
        //alert('proven');
    }
});
//------------------------------------------------------
var counter = 0;
$(function() {
    //alert('in here');
var player = $('iframe');
var playerOrigin = '*';
var status = $('.status');

// Listen for messages from the player
if (window.addEventListener) {
    window.addEventListener('message', onMessageReceived, false);
}
else {
    window.attachEvent('onmessage', onMessageReceived, false);
}

// Handle messages received from the player
function onMessageReceived(event) {
    //alert('lept going');
    // Handle messages from the vimeo player only
    if (!(/^https?:\/\/player.vimeo.com/).test(event.origin)) {
        return false;
    }

    if (playerOrigin === '*') {
        playerOrigin = event.origin;
    }

    var data = JSON.parse(event.data);

    switch (data.event) {
        case 'ready':
            onReady();
            break;

        case 'playProgress':
            onPlayProgress(data.data);
            break;
    }
}

// Helper function for sending a message to the player
function post(action, value) {
    var data = {
      method: action
    };

    if (value) {
        data.value = value;
    }

    var message = JSON.stringify(data);
    player[0].contentWindow.postMessage(data, playerOrigin);
}

function onReady() {
    post('addEventListener', 'playProgress');
}


function onPlayProgress(data) {
    //alert('Hello!');
    if (true) {};
    if (true) {};
    if (true) {};
    if (true) {};
    if (true) {};
    alert(counter);

    if ($(".vid-active").hasClass("overview")&&(counter==0)) {
        alert("This");
        counter = counter + 1;
        ga('send','event', 'KOL Video', 'Start', 'Chapter 1 - Overview');
    };
    if ($(".vid-active").hasClass("analysis")) {
        alert("is");
        counter = counter + 1;
        ga('send','event', 'KOL Video', 'Start', 'Chapter 2 - Compounding');
    };
    if ($(".vid-active").hasClass("compelling")) {
        alert("SPARTA");
        counter = counter + 1;
        ga('send','event', 'KOL Video', 'Start', 'Chapter 3 - FDA-Approved');
    };
    if ($(".vid-active").hasClass("practical")) {
        alert("AAAAA!");
        counter = counter + 1;
        ga('send','event', 'KOL Video', 'Start', 'Chapter 4 - Co-pay');
    };
    if ($(".vid-active").hasClass("proven")) {
        alert("!!!!!!!");
        counter = counter + 1;
        ga('send','event', 'KOL Video', 'Start', 'Chapter 5 - Epaned');
    };
}

Answer 4

同意列表实现您描述的行为的其他响应，因此它可能更合适，但无论如何我都会提出答案。

代码的问题在于您使用数据结构的方式。只需枚举字典中剩下的项目：

OxyPalettes

Answer 5

尝试：

plotView.Model.DefaultColors = OxyPalettes.Jet(plotView.Model.Series.Count).Colors;

但是，我建议您使用普通列表，它专为快速查找无间隙数字键而设计：

new_foo = {}
for key, (old_key, value) in enumerate( sorted( foo.items() ) ):
    key = key+1  # adjust for 1-based
    new_foo[key] = value

Answer 6

像其他人所说的那样，最好使用列表而不是字典。但是，如果你喜欢坚持使用词典，你可以做到

foo = {j+1:foo[k] for j,k in enumerate(sorted(foo))}

Answer 7

您可以将dict转换为list，删除特定元素，然后将list转换为dict。对不起，这不是一个班轮。

In [1]: foo = {1:0.001,2:2.097,3:1.093,4:5.246}
In [2]: l=foo.values()  #[0.001, 2.097, 1.093, 5.246]
In [3]: l.pop(1) #returns 2.097, not the list
In [4]: dict(enumerate(l,1))
Out[4]: {1: 0.001, 2: 1.093, 3: 5.246}

Answer 8

一个过滤序列的衬垫，然后重新枚举并构造一个字典。

In [1]: foo = {1:0.001, 2:2.097, 3:1.093, 4:5.246}
In [2]: selected=1

In [3]: { k:v for k,v in enumerate((foo[i] for i in foo if i<>selected), 1) }
Out[3]: {1: 2.097, 2: 1.093, 3: 5.246}

Answer 9

我有一个更紧凑的方法。

我认为它更具可读性和易懂性。您可以参考如下：

foo = {1:0.001,2:2.097,3:1.093,4:5.246}
del foo[2]
foo.update({k:foo[4] for k in foo.iterkeys()})
print foo

所以你可以得到你想要的答案。

{1: 5.246, 3: 5.246, 4: 5.246}

如何使用枚举列表填充字典？

9 个答案: