小编Ada*_*kin的帖子

假设我有一个字典,我想检查一个键是否映射到非空值.执行此操作的一种方法是len函数:

mydict = {"key" : "value", "emptykey" : ""}
print "True" if len(mydict["key"]) > 0 else "False"  # prints true
print "True" if len(mydict["emptykey"]) > 0 else "False"  # prints false

但是,可以依赖Python的语义,以及如果定义了一个对象,它的计算结果为true,并省略了len调用:

mydict = {"key" : "value", "emptykey" : ""}
print "True" if mydict["key"] else "False"  # prints true
print "True" if mydict["emptykey"] else "False"  # prints false

但是,我不确定哪个更像Pythonic.第一种感觉"显性比隐性更好",然而第二种感觉"简单比复杂更好".

我也想知道,如果我正在使用的dict不一定包含字符串,但是可以包含其他可以使用的类型(列表,集合等),那么抛弃len调用是否会让我感到困惑.OTOH,在前者(使用len调用)如果None被存储为值,代码将被炸毁,而非len版本将按预期工作(将eval为false).

哪个版本更安全,更Pythonic？

编辑:澄清假设:我知道密钥在字典中,我知道值是可以使用的.我也无法避免让零长度值进入字典.

编辑#2:似乎人们忽略了我的问题.我不是要确定检查字典中是否存在键的最Pythonic /最安全的方法,我正在尝试检查值是否为零长度

在c我可以做的事情:

int minn(int n, int m){
 return (n<m)? n:m
}

但是在python中我无法实现相同的目标:

def minn(n,m):
    return n if n<m else return m

这给了 Syntax Error

我知道我可以这样做:

def minn(n,m):
    return min(n,m)

我的问题是,我不能在python中使用三元运算符.

所以我有一堆使用SQLAlchemy的表,它们被建模为从结果继承到调用的对象declarative_base().即:

Base = declarative_base()
class Table1(Base):
    # __tablename__ & such here

class Table2(Base):
     # __tablename__ & such here

等等.然后,我想为每个数据库表类提供一些常用功能,根据文档执行此操作的最简单方法是执行多重继承:

Base = declarative_base()

class CommonRoutines(object):
    @classmethod
    def somecommonaction(cls):
        # body here

class Table1(CommonRoutines, Base):
    # __tablename__ & such here

class Table2(CommonRoutines, Base):
     # __tablename__ & such here

我不喜欢这件事是A)多重继承一般有点狡猾(变得棘手解决诸如super()调用之类的东西等),B)如果我添加一个新表我必须记住从两者继承Base而且CommonRoutines,和C)实际上,"CommonRoutines"类在某种意义上是"一种"类型的表.真正CommonBase的是一个抽象基类,它定义了一组对所有表都通用的字段和例程.换句话说:"它是一个"抽象表.

那么,我想要的是:

Base = declarative_base()

class AbstractTable(Base):
    __metaclass__ = ABCMeta  # make into abstract base class

    # define common attributes for all …

我无法理解asyncio.create_task()Python 3.7 中引入的函数应该如何工作。如果我做：

import asyncio

async def helloworld():
    print("Hello world from a coroutine!")
    asyncio.create_task(helloworld())

def main():
    loop = asyncio.get_event_loop()
    loop.run_until_complete(helloworld())

if __name__ == "__main__":
    main()

我得到：

Hello world from a coroutine! Hello world from a coroutine!

作为输出（即协程运行两次）。这怎么不是无限递归呢？当我使用await关键字时，我希望看到我看到的内容：

import asyncio


async def helloworld():
    print("Hello world from a coroutine!")
    await helloworld()


def main():
    loop = asyncio.get_event_loop()
    loop.run_until_complete(helloworld())


if __name__ == "__main__":
    main()

有了这个，我得到：

Hello world from a coroutine! Hello world from a coroutine! Hello world from a coroutine! …

每次尝试获取或设置为使用configparserPython NoSectionError的部分时,如果该部分不存在,则抛出一个部分.反正有没有避免这个？另外,我还可以避免NoOptionError在获得选项时吗？

例如,使用字典,有setdefault选项:KeyError当键不存在时,字典会添加键,将键的值设置为默认值,然后返回默认值.

我目前正在执行以下操作来获取属性:

def read_config(section):
    config = configparser.ConfigParser()
    config.read(location)
    try:
        apple = config.get(section, 'apple')
    except NoSectionError, NoOptionError:
        apple = None
    try:
        pear = config.get(section, 'pear')
    except NoSectionError, NoOptionError:
        pear = None
    try:
        banana = config(section, 'banana')
    except NoSectionError, NoOptionError:
        banana = None
    return apple, pear, banana

以下是设置它们:

def save_to_config(section, apple, pear, banana):
    config = configparser.ConfigParser()
    if not os.path.exists(folder_location):
        os.makedirs(folder_location)

    config.read(location)
    if section not in config.sections():
        config.add_section(section)

    config.set(section, 'apple', apple)
    config.set(section, …

我觉得Bitbucket非常方便的一件事就是当你把一个新的分支推到Bitbucket托管的repo时,它打印出(到终端屏幕)一个你可以点击的URL来创建你刚刚推出的那个分支的PR .例如:

$ git push origin someBranch
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 313 bytes | 0 bytes/s, done.
Total 3 (delta 2), reused 0 (delta 0)
remote:
remote: Create pull request for someBranch:
remote:   https://bitbucket.mydomain.com/projects/PRO/repos/someRepo/compare/commits?sourceBranch=refs/heads/someBranch
remote:
To ssh://bitbucket.mydomain.com:7999/pro/somerepo.git
f6718d4..410cbcb  someBranch -> someBranch

我发现这比去Bitbucket,导航到回购,找到"创建拉动请求"按钮等节省了大量时间.因此,当我使用在Github上托管的回购时,我想要类似的东西 - 在推出新分支后,让它打印到终端上我可以点击的URL到达Github上的创建PR屏幕.有人知道这样的事吗？

我知道Github有一个带有pull-request命令的CLI ,但每次都会提示你输入密码非常烦人,TBH我喜欢在实际创建PR之前查看UI中的差异.

我有一个我创建的容器,但我不记得docker run我用来启动它的确切命令.有什么办法可以检索吗？

这与在Docker中查看运行/停止容器的完整命令不同 我想要知道的是生成容器的完整docker命令,而不是容器内的命令.

这个问题询问了Django SECRET_KEY值的用途. 该问题的答案之一表示"它需要具有加密强大的entopy(sp)(计算机难以猜测)并且在所有Django实例之间是唯一的."

这有点模棱两可:如果我说例如将一个Django应用程序部署到负载均衡器后面的多个Web服务器上,那么每个应用程序是否都有自己的不同SECRET_KEY,或者应该SECRET_KEY在所有实例之间共享？

我有一个具有以下目录结构的Python项目:

project/
project/src/
project/src/somecode.py
project/src/mypackage/mymodule.py
project/src/resources/
project/src/resources/datafile1.txt

在mymodule.py中,我有一个类(让我们称之为"MyClass"),它需要加载datafile1.txt.当我这样做时,这种方式有效:

打开("../resources/datafile1.txt")

假设创建MyClass实例的代码是从somecode.py运行的.

但问题是我对mymodule.py进行了单元测试,这些测试是在该文件中定义的,如果我保留上面描述的相对路径名,则单元测试代码会爆炸,因为现在代码正在从project/src/mypackage运行project/src和相对文件路径无法正确解析.

有关最佳实践类型方法的任何建议可以解决此问题吗？如果我将我的测试用例移动到project/src,它会使主要源文件夹与测试用例混乱.

我有一个需要同时支持Python 2和3的setup.py.

代码当前可以工作,可以在Python 2.x中安装

如果我将该use_2to3 = True子句添加到我的setup.py中,那么该模块可以安装在Python 3中,但是,执行以下操作:

python setup.py test

导致失败,因为其中一个测试使用StringIO类,并且导入行在Python 3 from StringIO import StringIO中蠢(目前,在Python3中它应该是from io import StringIO

我想虽然一旦你添加use_2to3关键字,所有测试(包括unittes)都会在测试之前由2to3处理.

我错过了什么？如果它有帮助,我的setup.py的大部分看起来像:

from setuptools import setup

setup(
    name='myproject',
    version='1.0',
    description='My Cool project',
    classifiers = [
        'Programming Language :: Python',
        'Programming Language :: Python :: 3',
    ],

    py_modules=['mymodule'],
    test_suite='test_mymodule',
    zip_safe=False,
    use_2to3 = True,
)

编辑:我觉得2to3没有运行的原因python setup.py test是它爆炸了,堆栈跟踪的底部是:

File "/home/aparkin/temp/mymodule/test_mymodule.py", line 18, in <module>
    from StringIO import StringIO

但是如果我在test_mymodule.py上运行2to3,那么该导入行应该被重新编写为:

from io import StringIO

而且(最坏的情况下)测试应该单独失败.