相关疑难解决方法(0)

我有一个包含100多个元素的可迭代列表.我希望在每个第10个可迭代元素之后做一些事情.我不想使用计数器变量.我正在寻找一些不包括计数器变量的解决方案.

目前我喜欢这样:

count = 0
for i in range(0,len(mylist)):
    if count == 10:
        count = 0
        #do something
    print i
    count += 1

有什么办法可以省略反变量吗？

这是现在的用户2486之后的代码.

def romanMap():
    map=(("M",  1000),("CM", 900),("D",  500),("CD", 400),("C",  100),("XC", 90),("L",  50),("XL", 40),("X",  10),("IX", 9),("V",  5),("V", 4),("I",  1))
    return map
firstNum=ns([0])
secondNum=ns([1])
def main():
    ns=str(input("Enter a roman numeral"))
    total=0
    result=0
    while ns:
        firstNum=(romanMap(ns[0]))
         secondNum=(romanMap(ns[1]) 
        if firstNum is len(ns)>1 or secondNum-1:
                        total=total+firstNum
            ns=ns[1:]
        else:
                        total=total+ns[1]-ns[0]
            ns=ns[2:]
      print (total)
main()

我收到此错误的同时ns:UnboundLocalError:在赋值之前引用的局部变量'ns'

试图为pystruct模块中的并行化做出贡献,并在讨论中试图解释我为什么要尽可能早地在执行中实例化池并尽可能长时间地保留它们,重用它们,我意识到我知道它最适合这样做,但我不完全知道为什么.

我知道*nix系统上的声明是池工作器子进程在写入时从父进程中的所有全局变量复制.总的来说情况确实如此,但我认为应该补充说,当其中一个全局变量是一个特别密集的数据结构,如numpy或scipy矩阵时,似乎任何引用都被复制到工作者中实际上是漂亮的即使整个对象没有被复制也是相当大的,因此在执行后期产生新池会导致内存问题.我发现最好的做法是尽早产生一个池,这样任何数据结构都很小.

我已经知道了一段时间并在工作中的应用程序中围绕它进行了设计,但我得到的最好的解释是我在帖子中发布的内容:

https://github.com/pystruct/pystruct/pull/129#issuecomment-68898032

从下面的python脚本看,基本上,你会期望第一次运行中创建的池中的空闲内存和第二次运行中创建的矩阵步骤基本相同,就像在最终池终止的调用中一样.但是它们从来都不是,当你首先创建池时,总会有(除非机器上还有其它东西)更多的空闲内存.在创建池时,这种影响会随着全局命名空间中数据结构的复杂性(和大小)而增加(我认为).有没有人对此有一个很好的解释？

我用bash循环和下面的R脚本来制作这个小图片来说明,在创建池和矩阵之后显示整体的可用内存,具体取决于顺序:

pool_memory_test.py:

import numpy as np
import multiprocessing as mp
import logging

def memory():
    """
    Get node total memory and memory usage
    """
    with open('/proc/meminfo', 'r') as mem:
        ret = {}
        tmp = 0
        for i in mem:
            sline = i.split()
            if str(sline[0]) == 'MemTotal:':
                ret['total'] = int(sline[1])
            elif str(sline[0]) in ('MemFree:', 'Buffers:', 'Cached:'):
                tmp += int(sline[1])
        ret['free'] = tmp
        ret['used'] = int(ret['total']) - int(ret['free'])
    return ret

if __name__ == '__main__':
    import argparse
    parser = …

我遇到了以下代码(有点):

my_list = [1, [2, 3, 4], 5]
my_list[1:2] = my_list[1]

运行这两行后,变量my_list将是[1, 2, 3, 4, 5].对扩展嵌套列表非常有用.

但为什么它实际上做它做的事情呢？

我会假设该声明my_list[1:2] = my_list[1]将执行以下操作之一:

• 简单地放入[2, 3, 4]列表中的第二个位置(它已经存在)
• 从尝试将三个值(即2,3,4)放入仅长度为1(即my_list[1:2])的容器中,给出某种"解压缩的值太多"错误.(使用Numpy数组而不是列表重复上述操作会导致类似的错误.)

其他问题(例如,赋值如何与python列表切片一起使用)往往不太注意要替换的切片大小与要替换它的项目的大小之间的差异.(更别说解释它为什么会这样运作了.)

这是一个很短的,但非常恼人.我知道我可以计算字符串在另一个字符串中出现的次数,如下所示:

'banana'.count('a')
>>>3

意思是banana包含"a"3次字母.

这是一种奇怪的地方.

我的第一个困惑是 - 当我这样做时'foo'.count(''),Python会寻找什么？

是''==无==什么？

情况似乎并非如此,但从''逻辑上讲,这又是什么呢？更重要的是,为什么呢

'test'.count('')
>>>5

返回一个多于字符串的长度？

什么到底是什么包含在一个总是比字母数量高1的字符串？虚空？

编辑:'角色两次看起来像一个"角色.我在'这里谈两次,以避免混淆

编辑2:似乎有一些关于如何''发生的混乱.请参阅以下评论.

当对 dict 类型的变量进行类型注释时，通常您会像这样注释它：

numeralToInteger: dict[str, int] = {...}

不过我用冒号而不是逗号重写了它：

numeralToInteger: dict[str : int] = {...}

这也有效，不会引发 SyntaxError 或 NameError。

检查__annotations__全局变量后：

colon: dict[str : int] = {...}
comma: dict[str, int] = {...}

print(__annotations__)

输出是：

{'colon': dict[slice(<class 'str'>, <class 'int'>, None)],
 'comma': dict[str, int]}

因此，冒号被视为切片对象，逗号被视为普通类型提示。

我应该对 dict 类型使用冒号还是应该坚持使用逗号？

我使用的是 Python 版本 3.10.1。

我知道[end:start:-1]以相反的顺序切割列表.

例如

a = range(20)
print a[15:10:-1] # prints [15, ..., 11]
print a[15:0:-1] # prints [15, ..., 1]

但你无法到达第一个元素(示例中为0).似乎-1是一个特殊值.

print a[15:-1:-1] # prints []  

有任何想法吗？

我是Python的新手.我知道这已经被问到了,我道歉,但这种新情况的不同之处在于字符串之间的空格不相等.我有一个名为coord的文件,它包含以下空格分隔的字符串:

   1  C       6.00    0.000000000    1.342650315    0.000000000
   2  C       6.00    0.000000000   -1.342650315    0.000000000
   3  C       6.00    2.325538562    2.685300630    0.000000000
   4  C       6.00    2.325538562   -2.685300630    0.000000000
   5  C       6.00    4.651077125    1.342650315    0.000000000
   6  C       6.00    4.651077125   -1.342650315    0.000000000
   7  C       6.00   -2.325538562    2.685300630    0.000000000
   8  C       6.00   -2.325538562   -2.685300630    0.000000000
   9  C       6.00   -4.651077125    1.342650315    0.000000000
  10  C       6.00   -4.651077125   -1.342650315    0.000000000
  11  H       1.00    2.325538562    4.733763602    0.000000000
  12  H       1.00    2.325538562   -4.733763602    0.000000000
  13  H       1.00   -2.325538562    4.733763602 …

该行在del taglist[:]下面的代码中做了什么？

import urllib
from bs4 import BeautifulSoup
taglist=list()
url=raw_input("Enter URL: ")
count=int(raw_input("Enter count:"))
position=int(raw_input("Enter position:"))
for i in range(count):
    print "Retrieving:",url
    html=urllib.urlopen(url).read()
    soup=BeautifulSoup(html)
    tags=soup('a')
    for tag in tags:
        taglist.append(tag)
    url = taglist[position-1].get('href', None)
    del taglist[:]
print "Retrieving:",url

问题是"编写一个扩展到http://www.pythonlearn.com/code/urllinks.py的Python程序.该程序将使用urllib从下面的数据文件中读取HTML,从锚点中提取href = vaues标签,扫描相对于列表中第一个名称的特定位置的标签,按照该链接重复该过程多次并报告您找到的姓氏".示例问题:从http://python-data.dr-chuck.net/known_by_Fikret.html开始 查找位置3的链接(名字是1).请关注该链接.重复此过程4次.答案是您检索的姓氏.姓名序列:Fikret Montgomery Mhairade Butchi Anayah姓氏顺序:Anayah

Numpy试探性教程表明这a[ : :-1]是相反的a.有人可以解释我们是如何到达那里的吗？

我理解这a[:]意味着每个元素a(轴= 0).接下来:应该表示从我的理解中跳过(或句点)的元素数量.