小编Sha*_*ger的帖子

我现在正在使用Python 3.5解释器,发现了非常有趣的行为:

>>> (1,2,3,"a",*("oi", "oi")*3)
(1, 2, 3, 'a', 'oi', 'oi', 'oi', 'oi', 'oi', 'oi')
>>> [1,2,3,"a",*range(10)]
[1, 2, 3, 'a', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> ('aw','aw',*range(10),*(x**2 for x in range(10)))
('aw', 'aw', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 4, 9, 16, 25, 36, 49, 64, 81)
>>> {"trali":"vali", **dict(q=1,p=2)}
{'q': 1, 'p': 2, 'trali': 'vali'}
>>> {"a",1,11,*range(5)}
{0, 1, 2, 3, 4, 11, 'a'}

尽管我有多年的Python经验,但我从未在文档和示例中以及任何源代码中看到过这种情况.我发现它非常有用. …

我编写Python脚本来复制文件; 不幸的是它因为文件名太长(> 256)而一直失败.无论如何要处理这个问题？

我正在使用Python 2.5.4和Windows XP.

干杯,

打印没有换行符或空格的变量python3通过print(x,end ='')如何在python 2.5中执行它

在写入内存(/ dev/mem)时,我在python中使用mmap时遇到了一个奇怪的问题.要清楚,阅读是以同样的方式完成的,并且工作正常.但是当涉及到写入时,似乎每个第二个字节都是不可写的.

恩.

 when I read i get 
 addr 0x200 val 0x1234
 but when I try to write
 addr 0x200 val 0x4321
 what really is written is
 addr 0x200 val 0x0021

当我尝试逐字节写入时,同样的情况发生.恩.

write:
addr 0x200 0x43
addr 0x201 0x21
I get
addr 0x200 0x00
addr 0x201 0x21

码:

class Pydump:
    def __init__(self, addr, length = 1, word_size = 4, filename = '/dev/mem'):
        if addr < 0 or length < 0: raise ValueError('Address or length invalid')
        self._verbose = verbose

        self.word_size = …

哪个更好？(为什么？)

if somevalue == False:

要么

if somevalue is False:

如果somevalue是字符串,你的答案会改变吗？

我在一些函数中看到过这行代码

__traceback_hide__ = True 

它有什么作用？它似乎试图压制错误追溯.在什么情况下应该隐藏回溯？

我正在尝试获取包含文件路径和文件名的字符串列表。目前我只将文件名放入列表中。

代码：

hamFileNames = os.listdir("train_data\ham")

输出：

['0002.1999-12-13.farmer.ham.txt', 
 '0003.1999-12-14.farmer.ham.txt', 
 '0005.1999-12-14.farmer.ham.txt']

我想要一个类似于这样的输出：

['train_data\ham\0002.1999-12-13.farmer.ham.txt',
 'train_data\ham\0003.1999-12-14.farmer.ham.txt',
 'train_data\ham\0005.1999-12-14.farmer.ham.txt']

我一直在试图理解内置视图对象被退回.items()，.values()，.keys()在Python 3或类似的.viewitems()，.viewvalues()，.viewkeys()。关于该主题还有其他线程，但没有一个（甚至doc）似乎描述了它们在内部是如何工作的。

与listPython 2 中返回的类型副本相比，这里的主要收益似乎是高效的。经常将窗口与字典项进行比较（如在此线程中）。

但是那个窗口是什么，为什么它更有效？

我唯一能看到的是，视图对象似乎是 类似集合的对象，对于成员资格测试来说，它们通常更快。但这是唯一的因素吗？

代码示例

>>> example_dict = {'test':'test'}
>>> example_dict.items()
dict_items([('test', 'test')])
>>> type(example_dict.items())
<class 'dict_items'>

所以，我的问题是关于这dict_items门课的。这在内部如何运作？

我想定义一个类,以便它的实例可以转换为tuple和dict.一个例子:

class Point3:
    ...

p = Point(12, 34, 56)

tuple(p)  # gives (12, 34, 56)
dict(p)   # gives { 'x': 12, 'y': 34, 'z': 56 }

我发现如果我定义__iter__为一个产生单个值的迭代器,那么实例可以被转换为tuple,如果它产生双值,那么它可以被转换为dict:

class Point3:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    # This way makes instance castable to tuple
    def __iter__(self):
        yield self.x
        yield self.y
        yield self.z

    # This way makes instance castable to dict
    def __iter__(self):
        yield …

传递给多处理的 apply_async() 的函数内的 print() 不会打印出任何内容。

我想最终使用 apply_async 来处理大块的文本文件。因此，我希望脚本在屏幕上打印出已经处理了多少行。但是，我根本没有看到任何打印输出。

我附上了一个玩具代码。每个 foo() 调用都应该告诉我正在使用哪个进程。在我的实际代码中，我将在每个块上调用 foo() ，它会告诉我已经处理了该块中的多少行文本。

import os
from multiprocessing import Pool

def foo(x,y):
    print(f'Process: {os.getpid()}')
    return(x*y)

def bar(x):
    p = Pool()
    result_list = []
    for i in range(30):
        p.apply_async(foo, args=(i,i*x), callback=result_list.append)
    p.close()
    p.join()
    return(result_list)

if __name__ == '__main__':
    print(bar(2))

我得到了 x*y 乘法结果的打印结果，但没有看到任何打印结果告诉我进程 ID。

有人可以帮我吗？