相关疑难解决方法(0)

是否有可能使Django的QueryDict保留原始查询字符串的排序？

>>> from django.http import QueryDict
>>> q = QueryDict(u'x=foo³&y=bar(potato),z=hello world')
>>> q.urlencode(safe='()')
u'y=bar(potato)%2Cz%3Dhello%20world&x=foo%C2%B3'

我正在尝试使用以下代码打印密钥和值:

data = {"Key1" : "Value1", "Key2" : "Value2"}
print(data.keys()[1])   
print(data.values()[1])

我收到了错误

'dict_keys' object does not support indexing

提到的代码有什么问题？

接受的输出:

Key2
Value2

我正在编写一些代码，以从输入 .txt 文件生成两个新的 CSV 文件。.txt 文件有 40 列数据，我正在编写两个新的 csv 文件，每个文件仅从 .txt 文件中获取 2 列。

我的代码运行良好，几乎完全符合我的需要。最后一步是重命名两个新 csv 输出中的原始标头。

这是我的代码：

import csv

QATargetHeaders = ['FNAME','LNAME']
FinalTargetHeaders = ['PROJECT_CODE','PHONE_NUMBER']

with open('TEST.txt','r') as csv_input, open('Test_QA2.csv','w') as csv_output:
    reader = csv.DictReader(csv_input, delimiter='^')
    writer = csv.DictWriter(csv_output, fieldnames=QATargetHeaders, extrasaction='ignore')
    writer.writeheader()
    for line in reader:
        writer.writerow(line)
with open('TEST.txt','r') as csv_input, open('Test_FINAL.csv','w') as csv_output:
    reader = csv.DictReader(csv_input, delimiter='^')
    writer = csv.DictWriter(csv_output, fieldnames=FinalTargetHeaders, extrasaction='ignore')
    writer.writeheader()
    for line in reader:
        writer.writerow(line)

对于 TEST_QA2.csv，我需要更改标题：

FNAME = First Name
LNAME = Last Name …

我已经尝试过使用HashMap并且BTreeMap为此而且没有工作:

use std::collections::{BTreeMap, HashMap};

fn main() {
    let mut btreemap = BTreeMap::new();
    println!("BTreeMap");
    btreemap.insert("Z", "1");
    btreemap.insert("T", "2");
    btreemap.insert("R", "3");
    btreemap.insert("P", "4");
    btreemap.insert("K", "5");
    btreemap.insert("W", "6");
    btreemap.insert("G", "7");
    btreemap.insert("C", "8");
    btreemap.insert("A", "9");
    btreemap.insert("D", "0");
    for (key, value) in btreemap {
        println!("{} {}", key, value);
    }
    println!("Hash Map");
    let mut hashmap = HashMap::new();
    hashmap.insert("Z", "1");
    hashmap.insert("T", "2");
    hashmap.insert("R", "3");
    hashmap.insert("P", "4");
    hashmap.insert("K", "5");
    hashmap.insert("W", "6");
    hashmap.insert("G", "7");
    hashmap.insert("C", "8");
    hashmap.insert("A", "9");
    hashmap.insert("D", "0");
    for (key, value) in hashmap …

我有以下程序.我正在尝试理解列表理解和设置理解

mylist = [i for i in range(1,10)]
print(mylist)

clist = []

for i in mylist:
    if i % 2 == 0:
        clist.append(i)


clist2 = [x for x in mylist if (x%2 == 0)]

print('clist {} clist2 {}'.format(clist,clist2))

#set comprehension
word_list = ['apple','banana','mango','cucumber','doll']
myset = set()
for word in word_list:
    myset.add(word[0])

myset2 = {word[0] for word in word_list}

print('myset {} myset2 {}'.format(myset,myset2))

我的问题是,为什么花括号为myset2 = {字[0]在WORD_LIST词}.我还没有碰到来设定中的细节.

我有一个已按出现次数排序的计数器.

counterlist = Counter({'they': 203, 'would': 138, 'your': 134,...}).

但是当我这样做时counterlist.keys(),返回列表是:

['wirespe', 'four', 'accus',...]

代替

['they', 'would', 'your',...].

为什么？

__init__为了清晰和组织原因,我试图总是在里面声明类属性.最近,我了解到严格遵循这种做法还有额外的非美学好处,这要归功于为Python 3.3添加了PEP 412.具体来说,如果在中定义了所有属性__init__,则对象可以通过共享其键和散列来减少空间.

我的问题是,当在被调用的函数中声明属性时,对象密钥共享是否会发生__init__？

这是一个例子:

class Dog:
    def __init__(self):
        self.height = 5
        self.weight = 25

class Cat:
    def __init__(self):
        self.set_shape()

    def set_shape(self):
        self.height = 2
        self.weight = 10

在这种情况下,所有实例都Dog将共享密钥height和weight.实例Cat也分享密钥height和weight(彼此之间,Dog当然不是s).

顺便说一句,你会如何测试？

请注意,Brandon Rhodes在他的词典甚至Mightier谈话中说这是关于密钥共享的:

如果添加的单个键不在原型键集中,则会松开密钥共享

这个问题来自于这个答案,其中一个用户使用d.keys()并d.values()单独初始化数据帧.

众所周知,3.6版本的python版本中的字典不是有序的.

考虑表单的通用字典:

d = {k1 : v1, k2 : v2, k3 : v3}

其中键k*是任何可清洗对象,值v*是任何对象.当然,订单无法保证,但顺序d.keys()和d.values()？

Python 2.x

两者d.keys()和d.values()返回列表.比如说,按顺序.keys()返回d键[k2, k1, k3].难道现在总是保证该d.values()返回相同的相对排序的[v2, v1, v3]？此外,无论调用这些函数多少次,顺序是否保持不变？

Python 3.x(<3.6)

我不是百分百肯定,但我相信.keys并且.values不保证这里有任何排序,因为它们是类似于集合的结构,因此没有按照定义的顺序,并且使您能够对它们执行类似集合的操作.但我仍然有兴趣知道在这个例子中两个调用之间是否存在任何相对排序.我猜不是.如果有人可以肯定或纠正我,我会很感激.

我有一个脚本，可以删除很多 dict 并最终对其进行迭代。

我设法将其简化为一个简单的基准：

> py -m timeit -s "a = {i:i for i in range(10000000)};[a.pop(i) for i in range(10000000-1)]" "next(iter(a))"
10 loops, best of 5: 30.8 msec per loop

为什么在删除所有以前的值后迭代单个键变得很慢？

我有一个像这样的字符串

a = "X1+X2*X3*X1"
b = {"X1":"XX0","X2":"XX1","X0":"XX2"}

我想使用 dict b 替换子字符串 'X1,X2,X3'。

但是，当我使用下面的代码替换时，

for x in b:
    a = a.replace(x,b[x])
print(a)

'XXX2+XX1*X3'

预期结果是 XX0 + XX1*X3*XX0

我知道这是因为子字符串在循环中被替换，但我不知道如何解决。