你可以使用海象操作符 := :

def main():
    return [res for el in some_list if (res := transform(el)) is not None]

这样一来,调用 transform 函数存储在 res 然后你可以在你的理解列表的表达部分使用它。

这只是一个有趣的解决方法:

lst = "[xyx],[abc].[cfd],[abc].[dgr],[abc]"

count = 1
var = 1
for char in range(0, len(lst), 6):
    if var % 2:
        print(f"{count}.{lst[char:char + 5]}")
        count += 1
    var += 1

输出:

1.[xyx]
2.[cfd]
3.[dgr]

说明: "[" 出现在这些索引中:0、6、12等。 var 是为了跳过下一对。 count 是计数变量。

在这里,我们可以使用列表理解和切片来压缩上述代码,而不是使用那些标志变量。现在它更像蟒蛇了:

lst = "[xyx],[abc].[cfd],[abc].[dgr],[abc]"

lst = [lst[i:i+5] for i in range(0, len(lst), 6)][::2]

res = (f"{i}.{item}" for i, item in enumerate(lst, 1))

print("\n".join(res))

我想到了三个选择:

1-从你当前的范围(在模块级别, locals() 和 globals() (同一本字典)

list1 = ["hi", "hello", "bye"]
print(locals()['list1'])

2-使用字典将字符串映射到实际对象:

list1 = ["hi", "hello", "bye"]
d = {'list1': list1}
print(d['list1'])

3.使用 eval (当输入来自其他地方时,不推荐使用。)

list1 = ["hi", "hello", "bye"]
print(eval("list1"))

我会和你一起去 第二 如果你问的话,解决方案。

有几件事我们应该在这里讨论。我将试着解释不同的场景,给你们一个概览,看看发生了什么。

首先让我们看看你的最后一行:

my_obj.first_func(a, b) + my_obj.second_func(a, b)

你是想得到 first_func 来自实例的属性 my_obj .它(或它的班级)有吗? 不
第一_func 是全局模块中的一个变量。 我的obj 对此一无所知。

所以你的例外是因为这个。。。

现在考虑一下你的方法:
first 和 second 方法是类中的常规方法。当你说 MyClass.first ,您将获得一个函数对象 不是一种方法 .此函数接受两个参数 a 和 b .

但是如果你说 my_obj.first_func 你得到一个 方法对象 它有一个绑定实例对象。Python用对调用此方法的实例的引用来填充第一个参数。现在,您的方法对象只接受一个参数 B (这就是描述符的工作原理)

话虽如此,你在这里有一些选择:

1-仅从类而不是实例调用它们:

否则会出现异常,因为Python已经用实例对象填充了第一个参数。

class MyClass:
    def first(a, b):
        return a + b

    def second(a, b):
        return a * b

first_func = MyClass.first
second_func = MyClass.second
print(first_func(2, 3) + first_func(2, 3))

2.用绿色装饰 staticmethod :

现在可以从实例或类调用,Python不会为您填充第一个参数。

class MyClass:
    @staticmethod
    def first(a, b):
        return a + b

    @staticmethod
    def second(a, b):
        return a * b

first_func = MyClass.first
second_func = MyClass.second
print(first_func(2, 3) + first_func(2, 3))

class MyClass:
    @staticmethod
    def first(a, b):
        return a + b

    @staticmethod
    def second(a, b):
        return a * b

my_obj = MyClass()
first_func = my_obj.first
second_func = my_obj.second
print(first_func(2, 3) + first_func(2, 3))

3-添加一个 self 参数(其名称不是规则,而是强烈建议的约定):

这一次,如果从实例调用它们,则不需要将实例传递给第一个参数,但如果从类调用它们,则需要将其作为第一个参数传递。

class MyClass:
    def first(self, a, b):
        return a + b

    def second(self, a, b):
        return a * b


my_obj = MyClass()
first_func = my_obj.first
second_func = my_obj.second
print(first_func(2, 3) + first_func(2, 3))

class MyClass:
    def first(self, a, b):
        return a + b

    def second(self, a, b):
        return a * b


my_obj = MyClass()
first_func = MyClass.first
second_func = MyClass.second
print(first_func(my_obj, 2, 3) + first_func(my_obj, 2, 3))

尝试使用 .groupby() :

from itertools import groupby

txt = "assdggg"

print(''.join(str(l) + k if (l := len(list(g))) != 1 else k for k, g in groupby(txt)))

输出:

a2sd3g

从列表中删除项目很简单:从列表末尾开始:

li = range(1,15)
print li,'\n'

for i in xrange(len(li)-1,-1,-1):
    if li[i] < 6:
        del li[i]

print li

后果

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] 

[6, 7, 8, 9, 10, 11, 12, 13, 14]

你可以这样做:

n = 3
values = []
with open("log.txt") as f, open("output.txt", 'w') as g:
    for line in f:
        lst = line.rstrip().split()
        for i in zip(*[lst[i:i + n] for i in range(0, len(lst), n)]):
            print(*i, file=g)

内容 output.txt :

1.9849207e-01 9.6169322e-02 1.5000000e-02
1.9993099e-01 9.6354487e-02 1.6090730e-02
2.0150793e-01 1.0630896e-01 1.5000000e-02
1.9993099e-01 9.6354487e-02 1.6090730e-02
2.0261176e-01 1.0536750e-01 1.6090730e-02
2.0150793e-01 1.0630896e-01 1.5000000e-02

您需要将返回的列表从 line.rstrip().split() 到 n 大块。然后 zip 您可以并行地遍历它们。