Since you eventually combine the different char sets anyway, you might as well do that right away, with one if per char set. And random.choices saves a loop.

class password:
    def __init__(self, length, string_method, numbers=True, special_chars=False):
        self.length = length
        self.chars = ''
        if string_method != 'lower':
            self.chars += string.ascii_uppercase
        if string_method != 'upper':
            self.chars += string.ascii_lowercase
        if numbers:
            self.chars += string.digits
        if special_chars:
            self.chars += string.punctuation

    def generate(self, iterations):
        for _ in range(iterations):
            print(''.join(random.choices(self.chars, k=self.length)))

Nomenclature

Your class is called password. A password is usually a string representing a secret. Your class, however, does not represent such a thing. It merely stores information about how a password should be generated. Hence a better name would be PasswordGenerator.

Stop writing classes

Your class has two methods, one of which is __init__. This is usually a sign, that you should not be writing a class in the first place. Try an imperative approach instead.

Separate your concerns

Most of your business logic is done in generate(). It, however does multiple things, that we can split up into different functions.

import random
import string
from typing import Iterator


def get_pool(*, upper: bool = True, lower: bool = True,
             numbers: bool = False, special: bool = False) -> str:
    """Returns a character pool for password generation."""
        
    pool = []
    
    if upper:
        pool.append(string.ascii_uppercase)
    
    if lower:
        pool.append(string.ascii_lowercase)
    
    if numbers:
        pool.append(string.digits)
    
    if special:
        pool.append(string.punctuation)
    
    if pool:
        return ''.join(pool)

    raise ValueError('Pool is empty.')
        

def generate(length: int, pool: str) -> str:
    """Generates a password with the given length from the given pool."""

    return ''.join(random.choices(pool, k=length))
        

def generate_multiple(amount: int, length: int, pool: str) -> Iterator[str]:
    """Generates a password with the given length from the given pool."""

    for _ in range(amount):
        yield generate(length, pool)
        
       
def main():
    """Showcase the above code."""
 
    pool = get_pool(upper=False, lower=True, numbers=True, special=False)

    for password in generate_multiple(3, 20, pool):
        print(password)
    
    
if __name__ == '__main__':
    main()

Document your code

Your use case is a good example why code documentation is important. The user could be lead to believe, that e.g. numbers=True guarantees that the password will contain numbers, which it does not. It merely extends the password generation pool with numbers, so that the likelihood of generating a password with a number in it is > 0. However, by chance, an arbitrarily generated password might still contain no number. Those kind of behavioral quirks should be documented.