这实际上是通过间接参数化在py.test中原生支持的。
在您的情况下，您将：

@pytest.fixture
def tester(request):
    """Create tester object"""
    return MyTester(request.param)

class TestIt:
    @pytest.mark.parametrize('tester', [['var1', 'var2']], indirect=True)
    def test_tc1(self, tester):
       tester.dothis()
       assert 1

**更新：**因为这是这个问题的公认答案，而且有时候仍然会得到支持，我应该添加一个更新。虽然我最初的答案（下面）是在旧版本的pytest中实现这一点的唯一方法，因为others有noted pytest现在支持fixture的间接参数化。例如，你可以这样做（通过@imiric）：

第一个
然而，尽管这种间接参数化形式是显式的，如@Yukihiko Shinoda points out，它现在支持一种隐式间接参数化形式（尽管我在官方文档中找不到任何明显的引用）：
第一次
我不知道这种形式的确切语义是什么，但pytest.mark.parametrize似乎认识到，尽管test_tc1方法没有接受名为tester_arg的参数，但它所使用的tester fixture接受，因此它通过tester fixture传递参数化的参数。
我也遇到过类似的问题--我有一个名为test_package的fixture，后来我希望在特定测试中运行它时能够向该fixture传递一个可选参数。

@pytest.fixture()
def test_package(request, version='1.0'):
    ...
    request.addfinalizer(fin)
    ...
    return package

(It fixture做什么或者返回的package）是什么类型的对象并不重要。
然后，希望以某种方式在测试函数中使用这个fixture，这样我也可以指定version参数给那个fixture，以便在测试中使用。这目前是不可能的，尽管可能会成为一个很好的特性。
与此同时，让我的fixture返回一个 function 非常简单，它完成fixture以前完成的所有工作，但允许我指定version参数：

@pytest.fixture()
def test_package(request):
    def make_test_package(version='1.0'):
        ...
        request.addfinalizer(fin)
        ...
        return test_package

    return make_test_package

现在，我可以在测试函数中使用它，例如：

def test_install_package(test_package):
    package = test_package(version='1.1')
    ...
    assert ...

和/或其他信息。
OP尝试的解决方案方向是正确的，正如@hpk42的answer所建议的，MyTester.__init__可以存储对请求的引用，如下所示：

class MyTester(object):
    def __init__(self, request, arg=["var0", "var1"]):
        self.request = request
        self.arg = arg
        # self.use_arg_to_init_logging_part()

    def dothis(self):
        print "this"

    def dothat(self):
        print "that"

然后使用此方法实现夹具，如下所示：

@pytest.fixture()
def tester(request):
    """ create tester object """
    # how to use the list below for arg?
    _tester = MyTester(request)
    return _tester

如果需要的话，MyTester类可以重新构造一点，这样它的.args属性可以在创建之后更新，从而调整各个测试的行为。

但是我找不到任何文件
正如@chilicheech指出的那样，
至少从pytest 6.2（2020年12月13日发布）开始，官方记录了这种方式：

• 使用直接测试参数化覆写fixture|如何使用fixture- pytest文档
• pytest Documentation Release 6.2

它似乎在最新版本的pytest中工作。

@pytest.fixture
def tester(tester_arg):
    """Create tester object"""
    return MyTester(tester_arg)

class TestIt:
    @pytest.mark.parametrize('tester_arg', [['var1', 'var2']])
    def test_tc1(self, tester):
       tester.dothis()
       assert 1

你也可以使用闭包，这将给予你更全面的命名和对参数的控制。它们比 * 隐式参数化 * 中使用的request参数更“显式”：

@pytest.fixture
def tester():
    # Create a closure on the Tester object
    def _tester(first_param, second_param):
        # use the above params to mock and instantiate things
        return MyTester(first_param, second_param)
    
    # Pass this closure to the test
    yield _tester 

@pytest.mark.parametrize(['param_one', 'param_two'], [(1,2), (1000,2000)])
def test_tc1(tester, param_one, param_two):
    # run the closure now with the desired params
    my_tester = tester(param_one, param_two)
    # assert code here

我用它来构建可配置的设备

你可以从fixture函数（也就是你的Tester类）访问请求的模块/类/函数，参见从fixture函数与请求的测试上下文交互。所以你可以在类或模块上声明一些参数，测试器fixture可以拾取它。

imiric's answer稍微改进一下：解决这个问题的另一个优雅的方法是创建“参数fixture”，我个人更喜欢它而不是pytest的indirect特性，这个特性可以从pytest_cases获得，最初的想法是由Sup3rGeo提出的。

import pytest
from pytest_cases import param_fixture

# create a single parameter fixture
var = param_fixture("var", [['var1', 'var2']], ids=str)

@pytest.fixture
def tester(var):
    """Create tester object"""
    return MyTester(var)

class TestIt:
    def test_tc1(self, tester):
       tester.dothis()
       assert 1

请注意，pytest-cases还提供了@fixture，允许您直接在fixture上使用参数化标记，而不必使用@pytest.fixture(params=...)

from pytest_cases import fixture, parametrize

@fixture
@parametrize("var", [['var1', 'var2']], ids=str)
def tester(var):
    """Create tester object"""
    return MyTester(var)

和@parametrize_with_cases，它允许您从“case函数”中获取参数，这些函数可能被分组在一个类中，甚至是一个单独的模块中。）

我做了一个有趣的装饰器，它允许编写如下的固定装置：

@fixture_taking_arguments
def dog(request, /, name, age=69):
    return f"{name} the dog aged {age}"

在这里，/的左边是其他fixture，右边是使用提供的参数：

@dog.arguments("Buddy", age=7)
def test_with_dog(dog):
    assert dog == "Buddy the dog aged 7"

这和函数参数的工作方式是一样的。如果你没有提供age参数，默认的69参数会被使用。如果你没有提供name，或者省略了dog.arguments装饰器，你会得到常规的TypeError: dog() missing 1 required positional argument: 'name'。如果你有另一个fixture使用name参数，它不会和这个fixture冲突。
还支持异步装置。
此外，这还为您提供了一个很好的设置计划：

$ pytest test_dogs_and_owners.py --setup-plan

SETUP    F dog['Buddy', age=7]
...
SETUP    F dog['Champion']
SETUP    F owner (fixtures used: dog)['John Travolta']

完整示例：

from plugin import fixture_taking_arguments

@fixture_taking_arguments
def dog(request, /, name, age=69):
    return f"{name} the dog aged {age}"

@fixture_taking_arguments
def owner(request, dog, /, name="John Doe"):
    yield f"{name}, owner of {dog}"

@dog.arguments("Buddy", age=7)
def test_with_dog(dog):
    assert dog == "Buddy the dog aged 7"

@dog.arguments("Champion")
class TestChampion:
    def test_with_dog(self, dog):
        assert dog == "Champion the dog aged 69"

    def test_with_default_owner(self, owner, dog):
        assert owner == "John Doe, owner of Champion the dog aged 69"
        assert dog == "Champion the dog aged 69"

    @owner.arguments("John Travolta")
    def test_with_named_owner(self, owner):
        assert owner == "John Travolta, owner of Champion the dog aged 69"

装饰器的代码：

import pytest
from dataclasses import dataclass
from functools import wraps
from inspect import signature, Parameter, isgeneratorfunction, iscoroutinefunction, isasyncgenfunction
from itertools import zip_longest, chain

_NOTHING = object()

def _omittable_parentheses_decorator(decorator):
    @wraps(decorator)
    def wrapper(*args, **kwargs):
        if not kwargs and len(args) == 1 and callable(args[0]):
            return decorator()(args[0])
        else:
            return decorator(*args, **kwargs)
    return wrapper

@dataclass
class _ArgsKwargs:
    args: ...
    kwargs: ...

    def __repr__(self):
        return ", ".join(chain(
               (repr(v) for v in self.args), 
               (f"{k}={v!r}" for k, v in self.kwargs.items())))

def _flatten_arguments(sig, args, kwargs):
    assert len(sig.parameters) == len(args) + len(kwargs)
    for name, arg in zip_longest(sig.parameters, args, fillvalue=_NOTHING):
        yield arg if arg is not _NOTHING else kwargs[name]

def _get_actual_args_kwargs(sig, args, kwargs):
    request = kwargs["request"]
    try:
        request_args, request_kwargs = request.param.args, request.param.kwargs
    except AttributeError:
        request_args, request_kwargs = (), {}
    return tuple(_flatten_arguments(sig, args, kwargs)) + request_args, request_kwargs

@_omittable_parentheses_decorator
def fixture_taking_arguments(*pytest_fixture_args, **pytest_fixture_kwargs):
    def decorator(func):
        original_signature = signature(func)

        def new_parameters():
            for param in original_signature.parameters.values():
                if param.kind == Parameter.POSITIONAL_ONLY:
                    yield param.replace(kind=Parameter.POSITIONAL_OR_KEYWORD)

        new_signature = original_signature.replace(parameters=list(new_parameters()))

        if "request" not in new_signature.parameters:
            raise AttributeError("Target function must have positional-only argument `request`")

        is_async_generator = isasyncgenfunction(func)
        is_async = is_async_generator or iscoroutinefunction(func)
        is_generator = isgeneratorfunction(func)

        if is_async:
            @wraps(func)
            async def wrapper(*args, **kwargs):
                args, kwargs = _get_actual_args_kwargs(new_signature, args, kwargs)
                if is_async_generator:
                    async for result in func(*args, **kwargs):
                        yield result
                else:
                    yield await func(*args, **kwargs)
        else:
            @wraps(func)
            def wrapper(*args, **kwargs):
                args, kwargs = _get_actual_args_kwargs(new_signature, args, kwargs)
                if is_generator:
                    yield from func(*args, **kwargs)
                else:
                    yield func(*args, **kwargs)

        wrapper.__signature__ = new_signature
        fixture = pytest.fixture(*pytest_fixture_args, **pytest_fixture_kwargs)(wrapper)
        fixture_name = pytest_fixture_kwargs.get("name", fixture.__name__)

        def parametrizer(*args, **kwargs):
            return pytest.mark.parametrize(fixture_name, [_ArgsKwargs(args, kwargs)], indirect=True)

        fixture.arguments = parametrizer

        return fixture
    return decorator

另一种方法是使用request对象访问在定义测试函数的模块或类中定义的变量。
这样，如果您想为类/模块的所有测试函数传递相同的变量，就不必在测试类的每个函数上重用@pytest.mark.parametrize()装饰器。
使用类变量的示例：

@pytest.fixture
def tester(request):
    """Create tester object"""
    return MyTester(request.cls.tester_args)

class TestIt:
    tester_args = ['var1', 'var2']

    def test_tc1(self, tester):
       tester.dothis()

    def test_tc2(self, tester):
       tester.dothat()

这样，test_tc1和test_tc2的tester对象将使用tester_args参数进行初始化。
您也可以用途：

• request.function访问函数test_tc1，
• request.instance来访问TestIt类示例，
• request.module访问模块TestIt在
• 等（请参阅request文档）

另一种方法是使用自定义标记。它看起来比代码中的参数化更好，不反映在测试名称中，并且也是可选的（如果不存在这样的标记，可以通过引发失败将其定义为非可选的）
例如：

@pytest.fixture
def loaded_dll(request):
    dll_file = None
    for mark in request.node.iter_markers("dll_file"):
        if mark.args:
            if dll_file is not None:
                pytest.fail("Only one dll_file can be mentioned in marks")
            dll_file = mark.args[0]
    if dll_file is None:
        pytest.fail("dll_file is a required mark")
    return some_dll_load(dll_file)

@pytest.mark.dll_file("this.dll")
def test_this_dll(loaded_dll):
    ...

当我需要一个模拟ssh客户机的fixture，并且想要测试不同的可能输出时，我就使用这个标记来决定每个测试的输出。
请注意，如果是个人使用，则不需要测试失败的故障保存机制。