dusty estuary
so
my_dict = dict([('a', 1), ('b', 2)])
my_dict_2 = my_dict = dict([('a', 1)])```
these work just fine
```py
x = dict((['a', 1],['b', 2]))
y = dict((['a', 1]))```
but y here does not work. x does, however. All i changed was replaced replaced regular with square brackets. in other words at first put tuples in a list, worked. Put one tuple in a list, worked. Then put two lists in a tuple, worked. Then put one tuple in a list, does not work. Why is this?
vital edgeBOT
so
```py
my_dict = dict([('a', 1), ('b', 2)])
my_dict_2 = my_dict = dict([('a',...
@dusty estuary
Python help channel opened
unborn dawn
so
```py
my_dict = dict([('a', 1), ('b', 2)])
my_dict_2 = my_dict = dict([('a',...
In x, you are passing a tuple[list, list] to dict.
In y, because the comma is no longer present, you are actually just passing a list. The parenthesis become redundant without the comma, and it is equivalent to: ```py
y = dict(['a', 1])
If you want to make a 1 item tuple, you can do that by using a trailing comma, which makes the code work: ```py
y = dict((['a', 1],))
but what's the problem with a redundant parenthesis? i just put a tuple inside another tuple. Can i not do that? Or is more like its just ONE tuple inside another ONE tuple and that's redundant, if it was TWO tuples inside one that would have been fine
unborn dawn
but what's the problem with a redundant parenthesis? i just put a tuple inside a...
Maybe this will explain it better: ```py
x = dict( # Call dict parentheses
( # Tuple parentheses
['a', 1], # Tuple item
['b', 2] # Tuple item
) # Tuple parentheses
) # Call dict parentheses
y = dict( # Call dict parentheses
( # Redundant parentheses
['a', 1] # Call dict argument 1
) # Redundant parentheses
) # Call dict parentheses
y = dict( # Call dict parentheses
( # Tuple parentheses
['a', 1], # Tuple item with trailing comma that tells python this is a tuple item, and not part of grouping parentheses
) # Tuple parentheses
) # Call dict parentheses
also can you tell me if there's just a particular way to place arguments inside a function? Like can it be the case that dict() does not support lists inside of tuples or something like that which i need to know? Or can i just do whatever
dusty estuary
Maybe this will explain it better: ```py
x = dict( # Call dict parentheses
...
ahhh yes i understand what you mean
unborn dawn
What arguments a function accepts depends on the specifics of the function. You should read the docs of the function to figure out what it accepts https://docs.python.org/3/library/stdtypes.html#dict . In the case of dict, it can accept an iterable of two-length iterables, which a tuple of lists satisfies.
dusty estuary
ahh so every function has certain requirements of its own right?
unborn dawn
Yes
dusty estuary
when i create custom functions myself i can also set how many parameters it will accept not any more nor any less
unborn dawn
Yes. That is how functions operate by default
dusty estuary
and then what if my custom function can take in 3 parameters
and i give 3 parameters in the form of lets say 3 lists, but those lists also have other things inside. Would those be meaningless?
like would it show an error
unborn dawn
Python will throw an error if you give it the wrong number of arguments, but will not check that the arguments are of the right type. That is where static type checkers like mypy or pyright come in. They can use type hints on your function args to check that it is always called with the correct types. You can also manually make sure your arguments are the correct types inside the function using isinstance
vital edgeBOT
Python help channel closed for inactivity