chepner

这不是它抱怨的属性;这是参数名。标准惯例是附加一个 _ 以避免阴影。

def __init__(self, name: Optional[str], id_: Optional[int]) -> None:
    self.id = id_ if id_ else self.__class__.counter
    self.name = name if name else f"{self.__class__.__name__}-{self.id}"
    self.__class__.counter += 1

我发现修改参数的值比使用条件表达式要简单一些。

def __init__(self, name: Optional[str], id_: Optional[int]) -> None:
    if id_ is None:
        id_ = self.__class__.counter

    if name_ is None:
        name = f"{self.__class__.__name__}-{id_}"

    self.id = id_
    self.name = name
    self.__class__.counter += 1

在适当的情况下,这是一项针对 exec 作用

>>> exec("""def test(): \n print('success') \n return 'success' """, globals())
>>> test()
success
'success'

这个 function 类实现 descriptor protocol ,允许 os.path.join 充当实例方法。 os.listdir 不是一个 作用 ; 这是一个例子 builtin_function_or_method ,它不实现描述符协议。

curr.join(...) 相当于 Foo.join.__get__(curr, Foo)(...) . curr.listdir() 相当于 Foo.listdir() : curr.listdir 不存在,而且 Foo.listdir 只是打电话 listdir ,而不是不存在的 listdir.__get__ 这会帮你传球 curr 作为隐含的第一个论点。

首先,你不需要所有这些循环 地方,这意味着你不需要 break 完全

coords = []
with open('ADM2_hits.csv') as csvFile:
    csvReader = csv.reader(csvFile)
    next(csvReader)
    for line in csvReader:
        keyword = line[1]
        for dic in adm2_geonames:
            try:
                line.extend(dic['geonames']['name'][k] for k in ['lat', 'long'])
                coords.append(line)
            except KeyError:
                continue

只需创建一个子类。

class TestAnimal(Animal):
    def description(self):
        return "foo"


assert TestAnimal().zoo_str() == "fooGet more info at zoo.com!"

使用 operators.itemgetter :

from operator import itemgetter

f = itemgetter('title', 'impactLevel', 'severityLevel')
dataList.append(list(f(resp['problems'][0])))

你只需要使用 list 如果你特别需要一份清单; f 将返回一个元组。

如果你想从 resp['problems'] ,

dataList = list(map(f, resp['problems']))

这里,你只需要 列表 如果 DataFrame 需要列表,而不是任意的iterable。

你可以用一句简单的话来做到这一点:

message['data'].extend({'text': t, 'value': n} for t, n in my_list)

生成器表达式创建所需的 dict 价值观,以及 extend 将它们附加到 message['data'] 一次一个。

使用Numpy的一个原因是它在此类情况下的表现力。

>>> import numpy as np
>>> a = np.random.rand(10)
>>> a
array([0.94797029, 0.39628409, 0.64609633, 0.44994779, 0.23083464,
       0.60191075, 0.71651581, 0.78152364, 0.05516691, 0.22452054])
>>> a **2
array([0.89864768, 0.15704108, 0.41744046, 0.20245301, 0.05328463,
       0.36229656, 0.5133949 , 0.6107792 , 0.00304339, 0.05040947])

您不必迭代原始数组并逐步构建新数组:只需将数组本身“平方”。

这通常是通过上下文管理器完成的。

import contextlib

@contextlib.contextmanager
def with_preparation():
    prepare()
    yield
    done()

with preparation():
    xyz.foo(<args>)

with preparation():
    xyz.bar(<args>)

with preparation():
    xyz.foobar()

preparation 定义一个函数,该函数返回 上下文管理器 这个 with 语句通过调用上下文管理器的 __enter__ 方法,然后执行主体,然后确保上下文管理器 __exit__ 方法在继续之前被调用(无论是由于引发异常还是由于正文正常完成)。

contextlib.contextmanager 提供了一种使用生成器函数定义上下文管理器的简单方法,而不是使用显式 __进入__ 和 __退出__ 方法。

您提到,对于特定模块中的每个函数,都需要这个。如果没有关于该模块的确切细节,这可能并不完全正确,但您可能可以在其基础上进一步扩展。

class XYZWrapper:
    def __getattr__(self, name):
        # Intentionally let an AttributeError propagate upwards
        f = getattr(xyz, name)
        def _(self, *args, **kwargs):
            prepare()
            return f(*args, **kwargs)
            done()
        setattr(XYZWrapper, name, _)
        return _

prepared = XYZWrapper()

prepared.foo(<args>)
prepared.bar(<args>)
prepared.foobar()
        
        

简而言之,任何属性都可以访问 XYZWrapper 实例尝试在 xyz 模块,如果成功,则定义一个调用 prepare() 和 done() 根据需要进行修补 XYZWrapper 实例使用新包装器。

两者 in 和 == 是比较运算符,因此解析器处理

print("valley" in "hillside" == False)

一样

print("valley" in "hillside" and "hillside" == False)

请参阅 Comparisons 在《Python语言参考》中了解更多详细信息,特别是以下注意事项:

可以任意链接比较,例如x<y<=z等同于x<y和y<=z,但y只计算一次(但在这两种情况下,当x<y为false时,z根本不计算)。

你必须附加 L[x][1] 对于现有的列表,不要用新的单例列表替换其中的任何内容。

d={}
for x in range (len(L)):
    if L[x][0] not in d:
        d[L[x][0]] = []
    d[L[x][0]].append(L[x][1])
return d

一个 defaultdict

from collections import defaultdict

d = defaultdict(list)
for x in range(len(L)):
    d[L[x][0]].append(L[x][1])
return d

更习惯的写作风格是直接在 list 并立即打开密钥和值:

d = defaultdict(list)
for key, value in L:
    d[key].append(value)

检查的值 sys.argv[0] 若要查看在哪个名称下调用脚本,请构造适当的 ArgumentParser

if sys.argv[0].endswith("foo-ssh"):
    parser = ArgumentParser(epilog="For rsync, run foo-rsync")
    parser.add_argument(...)
    ...
elif sys.argv[0].endswith("foo-rsync"):
    parser = ArgumentParser(epilog="For ssh, run foo-ssh")
    parser.add_argument(...)
else:
    sys.exit("Must be invoked as foo-ssh or foo-rsync, not {}".format(sys.argv[0]))

args = parser.parse_args()

(将对另一个脚本的引用放入 description 如果 epilog

这是一个真正的文本编辑器更好地处理的事情。

import subprocess

subprocess.run(['ed', original_file], input=b'1,2d\n+3,$d\nwq\n')

ed ,POSIX标准文本编辑器。

打开由其参数命名的文件。然后从标准输入读取命令。每个命令都是一个字符,有些命令使用一个或两个“地址”来指示要操作的行。

在每个命令之后,“当前”行号被设置为最后受命令影响的行。这和相对地址一起使用,稍后我们将看到。

• 1,2d 表示删除第1行到第2行;当前行设置为2
• +3,$d 删除从第5行(当前行是2,所以2+3==5)到文件结尾的所有行( $ 是表示文件最后一行的特殊地址)
• wq 将所有更改写入磁盘并退出编辑器。

“默认精度”意味着您可以选择不同的精度。你不能。

从 https://docs.python.org/3/reference/datamodel.html :

数字.实数(浮点数)

这些表示机器级别的双精度 浮点数。 你受底层机器的摆布 溢流处理。 Python不支持单精度 浮点数;节省的处理器和内存使用 使用它们的原因通常比 有两种浮点数的语言。

不能保证你 有 IEEE 754浮点值。

你在找类型提示 List[TideTime] ,其中 List typing 模块。

from typing import List
from models import TideTime

class Tides:
    def __init__(self, currentTide: str, movement: str, tideTimes: List[TideTime]):
        self.currentTide = currentTide
        self.movement = movement
        self.tideTimes = tideTimes

mypy 如果您试图在源代码中传递其他内容,则可以帮助捕获。如果没有别的,更准确的提示更好地记录 意图

在你最初的定义中, class D(C, A) ,呼叫 D.__init__ 决心 C.__init__ A.__init__ 从来没有打过电话 __foo 属性从未创建。

在修改后的定义中( class D(A, C) ),呼叫 决心 A、 初始化__ __福 .

调用父构造函数以确保实例正确初始化是很重要的,而且与Java不同,必须显式调用父构造函数。

对于多重继承,如果使用 super 确保每个班级 __init__

class A(object):
    def __init__(self):
        super(A, self).__init__()
        self.__foo = 1

    def bar(self):
        return self.__foo


class B(object):
    pass


class C(B):
    def __init__(self):
        super(C, self).__init__()
        self.test = 1


class D1(C,A):
    pass


class D2(A,C):
    pass


# Both will print 1
print D1().bar()
print D2().bar()

只要 全部的 超级的 正确地说,每个方法都将被调用一次,不管方法的解析顺序是D1 [C, B, A, object] 或D2 [A, C, B, object]

你只要打个电话 getDF 像其他方法一样,使用 self 作为应该调用它的对象。

self.df_raw = self.getDF(self.filename_rawdata)

也就是说,通过使这个类成为数据类,可以大大简化它。

from dataclasses import dataclass

@dataclass
class RawData:
    filename_rawdata: str
    filename_metadata: str
    path: str
    category: str

    def __post_init__(self):
        self.df_raw = self.getDF(self.filename_rawdata)
        self.df_meta = self.getDF(self.filename_metadata)

    @staticmethod
    def parse(path):
        with gzip.open(path, 'rb') as g:
            yield from map(eval, g)

    @staticmethod
    def getDF(filename):
        return pd.DataFrame.from_records(enumerate(RawData.parse(filename)))

自动生成的 __init__ 方法将为您设置四个定义的属性。 __post_init__ 将被调用 之后 __初始__ ,给你打电话的机会 getDF公司 在两个给定的文件名上。

只需去掉点,把字符串分成3位数的块,然后用点重新连接。

>>> from operator import itemgetter
>>> f = itemgetter(slice(0,3), slice(3,6), slice(6,9), slice(9,12))
>>> s = "0100.8900.0033"
>>> '.'.join(f(s.replace('.','')))
'010.089.000.033'

如果前导零真的是个问题,我不确定是否有有效的方法去除它们。我会和

>>> '.'.join(['0' if octet == '000' else octet.lstrip("0") for octet in f(s.replace('.', ''))])
'10.89.0.33'

或者,将每个字符串作为 int . (我不确定哪一个更节省时间或空间;使用字符串或往返于 str 到 内景 回到 str公司 ):

>>> '{}.{}.{}.{}'.format(*map(int, f(s.replace('.', ''))))
'10.89.0.33'

你是在假设 self.a 指 A.a 只是因为它发生在 A.b . 那不是真的;行为 自我。a 是由 运行时 类型 self .

自从 a 是 B , a.b() 与 type(a).b(a, b) 或 B.b(a, b) . 自从 B.b 未定义,属性查找过程返回到 A、 乙 . 内部 A、 乙 , self == a ,所以我们现在有了 a.a() ,这同样相当于 type(a).a(a) == B.a(a) . 因此, A、 一个 从来没人打过电话。

你只是从 power 你可能想提出一个例外。另外,你应该检查一下 n 和 p 之前 修改对象。(我不想进一步解释为什么 权力 正在设置属性。)

class Calculator:
    def power(self, n, p):
        if n < 0 or p < 0:
            raise ValueError("Both arguments should be non-negative")
        self.n = n
        self.p = p
        return self.n ** self.p

myCalculator = Calculator()
T = int(input())
for i in range(T):
    n, p = map(int, input().split())
    try:
        ans = myCalculator.power(n,p)
        print(ans)
    except Exception as e:
        print(e)

不需要显式求幂。每学期 -x 乘以上学期。

def seriesrun(x, n):
    result = 0
    term = 1

    for _ in range(n):
        result += term
        term *= -x  # -x == 1 * -x, x^2 == (-x) * (-x), -x^3 == x^2 * (-x), etc
    return result

切片是半开的间隔。您需要将每个上限增加一个。

>>> x[5:8,3:6]
array([[53, 54, 55],
       [63, 64, 65],
       [73, 74, 75]])

此外,指数从0开始,这就是为什么 x[:2,:2] 按你期望的方式工作,尽管你的期望值不高。 :2 是 0:2 ,不是 1:2 .

AcceptsTupleOnInit 不接受元组作为参数;它接受两个独立的参数。你需要先把元组解包。

a = AcceptsTupleOnInit(*r.return_tuple())

或者,定义 __init__ 接受元组

def __init__(self, t):
    self.s = t[0]
    self.z = t[1]

或者更好的方法是,定义一个额外的类方法来为您解包元组。

# usage:
# a = AcceptsTupleOnInit.from_tuple(r.return_tuple())
@classmethod
def from_tuple(cls, t):
    return cls(t[0], t[1])

在这三种情况下,您都有责任提供至少有两个值的元组。最初的定义 __初始__ 要求 return_tuple 提供一个元组 确切地 2个元素;修改的 __初始__ 类方法更灵活,简单地忽略其他元素。所以我更喜欢原版的 __初始__ (关于它需要什么和接受什么是精确的)使用一个类方法,该方法可以根据需要清理输入元组。你可以选择忽略 t[2:] ,或者如果它们存在,则可以引发异常。

使用 git commit 的 -e 如果您只想在提交消息中添加一些初始文本,则选项会简单得多。它还允许用户使用他们选择的文本编辑器,而不是强制 readline 在他们身上。

git commit -em "$(git rev-parse --abbrev-ref HEAD | sed 's|.*/||; s|_.*$||;' )"

(一个缺点是,它以包含 -m 参数,因此不保存就退出编辑器不足以中止提交。为此,必须显式保存空文件。)

因此,这更容易正确引用:

auto-message = !git commit -em "$(git rev-parse --abbrev-ref HEAD | sed 's|.*/||; s|_.*$||;')"

python没有真正的全局变量,只有 模块 -水平全局。这个 Z 那个 getZ 访问是 getZ.Z 不是 __main__.Z 你设置的 main2.py .

这将起作用:

#file name main2.py
import getZ

X=1     
Y=2
getZ.Z = 0  # Set the value of the variable `getZ.getZ` looks for.
print(getZ.Z)
getZ.getZ(X, Y)
print(getZ.Z)

分配给 word 不更改以前分配给的列表元素 单词 ;它只是改变了名称 单词 现在是指。

你想建立一个 新的 名单:

def normalize_text(file):
    # This could be defined once outside the function
    table = str.maketrans('','',string.punctuation)
    all_words = word_tokenize(file)
    return [word.lower().translate(table) for word in all_words]

类似的方法是直接分配给一个列表元素,这与分配给 单词 .

def normalize_text(file):
    all_words = word_tokenize(file)
    for i, word in enumerate(all_words):
        word = word.lower()
        all_words[i] = word.translate(str.maketrans('','',string.punctuation))

return all_words