timgeb

你可能想要 loc 使用布尔索引。如果没有显示样本输入和输出数据,请。

drop_boats.loc[drop_boats['Currency'].eq('EUR'), 'Price'] *= 1.10

您添加了相同的列表,表示内存中的相同对象, len(M[0]) 是时候 b 排队 b.append(a) . b、 附加(a) 不复制a。

把那行改成 b.append(a[:]) 或 b.append(a.copy()) .

简化的代码演示:

>>> a = [0, 0, 0]
>>> b = []
>>> b.append(a)
>>> b.append(a)
>>> a[-1] = 1
>>> a
[0, 0, 1]
>>> b
[[0, 0, 1], [0, 0, 1]]
>>> b[0] is a
True
>>> b[1] is a
True

你拿到第一本字典

>>> s = "Hello"
>>> d = dict.fromkeys(s.upper(), 0)
>>> d
>>> {'E': 0, 'H': 0, 'L': 0, 'O': 0}

注意钥匙 'L' 只出现一次,因为字典键是唯一的。

因此,您想要的第二本词典是不可能创建的。

但如果只关心最后一个字符串,则不必创建任何dict,因为:

>>> ''.join(c*i for i, c in enumerate(s.upper(), 1))
>>> 'HEELLLLLLLOOOOO'

如果这看起来很复杂,就用一个简单的 for 循环。

>>> to_join = []
>>> for i, c in enumerate(s.upper(), 1):
...:    to_join.append(c*i)
...:    
>>> result = ''.join(to_join)
>>> result
>>> 'HEELLLLLLLOOOOO'

首先是一些术语:这里讨论的是列表(而不是数组),它总是存储对其元素的引用。

检查列表中的所有引用是否引用不同对象的快速方法是

>>> l1 = [[0, 1], [0, 1]]
>>> l2 = [[0, 1]]*2
>>> 
>>> len(set(map(id, l1))) == len(l1) # no duplicates
True
>>> len(set(map(id, l2))) == len(l2) # duplicates
False

它只是检查是否有 n 长度列表中对象的唯一ID n .

如果您的列表包含大量元素,那么惰性地执行此操作并返回 False 在第一个重复的id上。

def all_unique(lst):
    seen = set()
    for x in lst:
        id_ = id(x)
        if id_ in seen:
            return False
        seen.add(id_)
    return True

…工作方式如下:

>>> all_unique(l1)
True
>>> all_unique(l2)
False

我觉得你不懂装潢师。让我们举个简单的例子。

def my_decorator(some_function):        
    def new_function(*args, **kwargs):
        'announces the result of some_function, returns None'
        result = some_function(*args, **kwargs)
        print('{} produced {}'.format(some_function.__name__, result))
    return new_function # NO FUNCTION CALL HERE!

@my_decorator
def my_function(a, b):
    return a + b

my_function(1, 2) # will print "my_function produced 3"

我们有一个简单的函数 my_function 它返回它的两个参数和一个decorator的总和,decorator将只打印出它所修饰的任何函数的结果。

请注意

@my_decorator
def my_function(a, b):
    return a + b

相当于

def my_function(a, b):
    return a + b

my_function = my_decorator(my_function)

自从 my_decorator 接受函数作为参数(这里我们给出 我的函数 )并返回 新功能 new_function (不打电话!),我们有效地覆盖 我的函数 因为我们把名字重新分配给 我的装饰师 返回。

行动中:

>>> my_function(1, 2)
my_function produced 3

请注意,在调用函数的示例中的每一点上,都会出现括号语法。下面是我发布的第一段代码中发生的所有函数调用,顺序如下:

1. my_decorator(my_function) 调用并将返回值重新分配给名称 我的函数 . 这要么发生在 @ 语法或更明确地在等效代码段中。
2. my_function(1, 2) 被称为。在这一点上, 我的函数 是 新函数 是装修工送回来的。大脑将其解析为 new_function(1, 2) .
3. 体内 新函数 ,我们提出的论点 我的装饰师 被称为( result = some_function(*args, **kwargs) )这正好是 我的函数 在步骤1中发生的重新分配之前 。
4. print 被称为。

如果你想了解 新函数 坚持住了 some_function 尽管 我的装饰师 已经从电话里回来了,我建议你调查一下 自由变量 和 关闭 。

这有点毫无意义 __gt__ 和 __eq__ 因为 object 具有这些属性。

@提姆盖布:没想到这是实话,说得对。问题真的是关于记录这种类型的鸭子打字,所以让我们假设不是这样的?:)

在一般情况下,我想你可以给自己写一个实现 __subclasshook__ 然后键入提示该类。

from abc import ABCMeta, abstractmethod

class FooAndBar(metaclass=ABCMeta):
     @abstractmethod
     def foo(self):
         raise NotImplementedError

     @abstractmethod
     def bar(self):
         raise NotImplementedError

     @classmethod
     def __subclasshook__(cls, C):
         if cls is FooAndBar:
             has_foo = any('foo' in X.__dict__ for X in C.__mro__)
             has_bar = any('bar' in X.__dict__ for X in C.__mro__)
             if has_foo and has_bar:
                 return True
         return NotImplemented

class Foo:
    def foo(self):
        pass

class FooBar:
    def foo(self):
        pass

    def bar(self):
        pass

print(isinstance(Foo(), FooAndBar)) # False
print(issubclass(Foo, FooAndBar)) # False
print(isinstance(FooBar(), FooAndBar)) # True
print(issubclass(FooBar, FooAndBar)) # True

def func(arg: FooAndBar):
    pass

注意,定义 foo 和 bar 在里面 FooAndBar 对于您的特定用途(不管怎样,子类书籍触发器)是不需要的,但是省略这些方法对我来说非常奇怪,而且可能是任何代码的阅读器。