What programming/technical projects have you been working on?

A bunch of advice (a lot of this will be overkill for such a simple script, but I'm assuming you're interested in more general Python/programming advice):

Generally, you should try not to write code in Python at the "top level"—that is, almost everything should all be inside a function or class. The main reason for this is that if something else imports your code (similar to the way you did import secrets), all of the top-level code in the imported module (file) gets executed at that point. So hypothetically, if someone imported your program into a different one to use one of its functions, it would run the code (and almost certainly cause the other program to crash). The "proper"/idiomatic way to structure the program is to have a function named main() and call it like this:

def main():
    # main program code goes in here
    ...

if __name__ == "__main__":
    main()

The two lines at the bottom are a (totally unintuitive) way of saying "if this program is being executed directly (not imported), call main()". Almost every program that's intended to be run as a script should be structured this way.

Similarly, you should try to avoid global variables, and especially be careful about modifying them. In this case, a lot of it is just because you wrote the program globally like I described above, but you should still be careful about doing things like removing words from allWords by using .pop(), especially when you're making changes inside a function that didn't create those variables itself. It's hard to keep track of what's happening in a program if functions are changing "outside" variables without them being passed in or returned.

For example, imagine that you decided to change the program to be able to generate multiple passwords. This would be awkward with your current method, because each time you generate a password, all of the words used in it get removed from allWords, and you might end up with any further passwords losing access to those words (or needing to re-generate the word list each time). It would be better to try to keep all the words in the list. I'll come back to this later with specific advice about what to do instead.

Also, be careful about putting too much into one function, especially when it makes the function's name no longer describe what it's doing. Your only function is createDict(), but it's doing a lot more than creating a dict. It also generates the password, so it would be much better to have at least two functions: one for generating the word list, and one that uses that word list to generate a password.

Try to make sure you're using the most appropriate types as much as possible too, since Python has a very good standard library and it will generally have useful functions available as long as your data is in the right type. For example, you're using a dict for the word list, but should just be using a list, since the keys aren't really needed for anything. That makes it easy to use the secrets.choice() function to get a random word, instead of needing to generate a random number for the key.

Without getting off into the weeds and messing around with some of the more tangential stuff like command-line arguments, here's how I'd write the program:

import secrets
import sys


def build_word_list(filename):
    word_list = []

    with open(filename) as words_file:
        for line in words_file:
            word = line.strip()

            # only include words without a hyphen and at least 4 characters long
            if "-" not in word and len(word) >= 4:
                word_list.append(word)

    return word_list


def generate_password(word_list, num_words, sep="-"):
    chosen_words = []

    for _ in range(num_words):
        random_word = secrets.choice(word_list)

        # keep choosing words until we get one that we haven't already chosen
        while random_word in chosen_words:
            random_word = secrets.choice(word_list)

        chosen_words.append(random_word)

    return sep.join(chosen_words)


def main():
    words_filename_by_language = {
        "en": "words.txt",
        "br": "palavras.txt",
    }

    # display help and exit if not called with a valid language code
    if len(sys.argv) != 2 or sys.argv[1] not in words_filename_by_language:
        script_name = sys.argv[0]
        print(f"""Usage:
            {script_name} br (brazilian portuguese)
            {script_name} en (english)
        """)
        exit()

    word_list = build_word_list(words_filename_by_language[sys.argv[1]])
    password = generate_password(word_list, num_words=4)

    print(password)


if __name__ == "__main__":
    main()

I tried to write it in a straightforward way and not change anything significantly from how your program currently works. There would definitely be fancier ways to do some of this stuff (for example, if you want to see how to do command-line arguments "properly", take a look at the argparse module).

I could write a bunch more about why I did things a certain way or the specific changes I made, but I've already rambled a lot. Feel free to ask questions about anything though, and I'll be happy to explain more.