3 years programming in Python. Almost all my implementations in for loop were just like if key in d.keys(): d[key] = ["value"] else: d[key].append("value") Where each search for key is O(n). If only I had known about fromkeys() before! That would simplify my code to complexity O(n) on the creation and just O(1) for searching and updating, like that: keys = ("abc", "def") d = d.fromkeys(keys, []) d["abc"].append("value") Thank you very much for this video! This was very helpful!
Great channel, learned about you via Shorts... Re: popitem: (a) popitem removes the *last* item, but the last item is defined by the last item inserted in the dict. The example in the video uses items that happen to be in numerical order by key. Such an example could give the impression that popitem will always remove the key with the largest value; however, if the example was users: dict = {0: 'Mario', 2: 'James', 1: 'Luigi'}, popitem would remove the last item entered, which is 1: 'Luigi'; (b) prior to Python 3.7, popitem removed a *random* item, because only in 3.7+ were the order of dict items preserved by their order of entry.
I should have said: prior to Python 3.7, popitem removed some unspecified item based on the implementation details of the Python runtime; that is, not to imply that popitem was a clever way to remove a random item.
Thank you. As always with your stuff, this is a great "Introduction to...": complete, but succinct and clear. And nicely indexed so people can skip over methods they're already familiar with. Since you asked ... I'm still fairly new to Python, so there were a couple I'd never heard of, and a few that I'd *only* heard of and never learned. I'll definitely be using a few more them now that you've introduced me.
I think you glossed over setdefault. setdefault is useful when initializing a dict(). it returns the newly created key/val pair, and you can modify if right there.: mydict[key]=mydict.setdefault(key,0)+=1 or mydict[key]=mydict.setdefault(key,[]).append(val) .setdefault closer to behavior you get with defaultdict then comparing to get()
Very interesting. The method 'fromkeys' did not work as expected and produced a sytax error. The code --------------- people: list[str] = ['Mario', 'Luigi', 'James'] users: dict = dict.fromkeys(people, __value:'Uknown') print(users) -------------- The error has to do with the use of ':'.
I'd lioke to add that popitem() is like item(), but removes the pair from the dict. So, you can use the key/value pair in a loop and (may) have an empty dict after that.
Bro, have you heard about the flet framework (flutter for python), can you create an playlist that goes through all basic and intermediate level contents , please, because I tried searching tutorials for flet but didn't get what I wanted, and sorry if I said anything bad, bcoz English is not my mother tongue
Pretty good list. You did miss that pop has a default parameter available. Maybe it's a cultural thing, but the character "|" is just called pipe, not pipeline.
I made a dictionary to try to make a program that helps me with learning French. It is formatted like this, Vocab = { "manger": { "translation": "to eat" "conjugations": { "je" : "mange", "tu" : "mange", ect.... I am trying to make it asks me the translation of a random word first if I get to right it says correct, wrong it says incorrect and shows me the fight translation. followed by each of the conjugations separately either saying correct or showing me the answer if incorrect. How would I go about starting that? New to python
It got me thinking. Since when Python started adding linux-like syntax in it? The match-case syntax also comes from bash scripting, so there is anything else on that avenue that was added recently?
Lists and dictionaries are mutable, meaning they can be changed after they are created, which makes them unhashable and therefore unsuitable for use as dictionary keys. Tuples and sets are immutable (well, technically sets are mutable, but "frozen sets" are not), meaning their contents cannot be changed after they are created, making them hashable and suitable for use as dictionary keys.
@@no_the_other_ariksquad It is but that is also a method and is also useful because you can get the value corresponding to the key, you can change the value of an existing key value pair and you can append a new key value to the dictionary and in many cases it feels cleaner to me personally that the other methods where you don't need the specialized functionality of the other dictionary methods (for example returning a default value if the key doesn't exist).
Sounds like you need to write a fair bit of documentation for anyone that uses your special “__getitem__ implementation. I’m not saying you should avoid it, but at least every developer knows immediately what’s going on with get() and setdefault(). I might make a video about getitem regardless, thanks for the suggestions :)
Since Python 3.7 dictionaries are ordered, which means the order in which the key-value pairs are entered are the order like in a list. Hence the .pop() method will "pop" the last item added to the dictionary.
Dude I appreciate your channel a lot, because I learned a lot, but marking the type of simple global variables is annoying and demolishes the concept of a dynamically typed language. I can understand in classes or functions to make them easier to use, but in simple obvious variables?
@@Indently Yeah, consistency is very proper and professional, but this one looks like overused Federico. This is such a subjective opinion of mine, besides, I am waiting for another valuable content.
For me it helps, because when I make special rules I tend to forget where it actually matters. And it doesn't hurt readability, especially for someone who got so used to seeing them, it hurts me more to not see them, regardless of how obvious the variables might be. But at the end of the day, they are optional, so my coding style of being extra explicit can only benefit those who choose to be less explicit.
If you wanted to run your code using CYTHON for speed then defining variables will be very useful and AI ie CoPilot can go through and covert them all to CYTHON style declarations.
God, I love dictionaries in python
What are you doing bro in this time
You can specify a default value for pop as well, to avoid the KeyError: pop(key, default)
Thanks for sharing, I completely missed that!
you should place the pop in an except code block
@@miguelvasquez9849 That depends on if you want to catch an error, or avoid the error in the first place 😉
3 years programming in Python. Almost all my implementations in for loop were just like
if key in d.keys():
d[key] = ["value"]
else:
d[key].append("value")
Where each search for key is O(n). If only I had known about fromkeys() before! That would simplify my code to complexity O(n) on the creation and just O(1) for searching and updating, like that:
keys = ("abc", "def")
d = d.fromkeys(keys, [])
d["abc"].append("value")
Thank you very much for this video! This was very helpful!
Great channel, learned about you via Shorts... Re: popitem: (a) popitem removes the *last* item, but the last item is defined by the last item inserted in the dict. The example in the video uses items that happen to be in numerical order by key. Such an example could give the impression that popitem will always remove the key with the largest value; however, if the example was users: dict = {0: 'Mario', 2: 'James', 1: 'Luigi'}, popitem would remove the last item entered, which is 1: 'Luigi'; (b) prior to Python 3.7, popitem removed a *random* item, because only in 3.7+ were the order of dict items preserved by their order of entry.
I should have said: prior to Python 3.7, popitem removed some unspecified item based on the implementation details of the Python runtime; that is, not to imply that popitem was a clever way to remove a random item.
What is the difference between .items() and .__dict__() method?
Thank you. As always with your stuff, this is a great "Introduction to...": complete, but succinct and clear. And nicely indexed so people can skip over methods they're already familiar with.
Since you asked ... I'm still fairly new to Python, so there were a couple I'd never heard of, and a few that I'd *only* heard of and never learned. I'll definitely be using a few more them now that you've introduced me.
I think you glossed over setdefault. setdefault is useful when initializing a dict(). it returns the newly created key/val pair, and you can modify if right there.:
mydict[key]=mydict.setdefault(key,0)+=1
or
mydict[key]=mydict.setdefault(key,[]).append(val)
.setdefault closer to behavior you get with defaultdict then comparing to get()
Perhaps worth adding: the del operation to remove item without returning the value. In your example dict it would be: del users[2]
Very interesting.
The method 'fromkeys' did not work as expected and produced a sytax error.
The code
---------------
people: list[str] = ['Mario', 'Luigi', 'James']
users: dict = dict.fromkeys(people, __value:'Uknown')
print(users)
--------------
The error has to do with the use of ':'.
finally learned how to use dictionaries (been a computer science major for 2 years)
I'd lioke to add that popitem() is like item(), but removes the pair from the dict. So, you can use the key/value pair in a loop and (may) have an empty dict after that.
thanks a lot for the tutorial👍 I find it very informative but it's still hard for me to work with dictionaries
Bro, have you heard about the flet framework (flutter for python), can you create an playlist that goes through all basic and intermediate level contents , please, because I tried searching tutorials for flet but didn't get what I wanted, and sorry if I said anything bad, bcoz English is not my mother tongue
flet looks awesome! I will look into it :)
@@Indently thanks bro 🥰
Great one man, I knew every of those, but very helpfull informational video
Can you come up with Data Structures and Algorithms?
... and design patterns 👍
There’s a professional who covers this in great detail with years of experience. Check out: Arjan Codes
@@Indently Great recommendation, excellent content as is your own, thank you 🙏
Fantastic vid - much appreciated
Are you using the colon instead of an equals sign?
It would be nice to know the average time complexity of these methods.
i think its look like this: 0.000000000000000000000000000000000000
Pretty good list. You did miss that pop has a default parameter available. Maybe it's a cultural thing, but the character "|" is just called pipe, not pipeline.
Thank you!
Is it possible to find an intersection of dictionaries, i. e. the keys common in both ones?
I was just curious.....why did you remove the names when you used the dict.copy() method?
What colour theme are you using? Thank you!
Use extansiion
Educational and instructive ...
I learned something new, |= thanks
I made a dictionary to try to make a program that helps me with learning French. It is formatted like this, Vocab = { "manger": {
"translation": "to eat"
"conjugations": {
"je" : "mange",
"tu" : "mange",
ect....
I am trying to make it asks me the translation of a random word first if I get to right it says correct, wrong it says incorrect and shows me the fight translation. followed by each of the conjugations separately either saying correct or showing me the answer if incorrect. How would I go about starting that? New to python
Very useful. Thanks
Great video, Thank you!
It got me thinking. Since when Python started adding linux-like syntax in it? The match-case syntax also comes from bash scripting, so there is anything else on that avenue that was added recently?
what IDE you use ? yours look minimilistic.
Looks like PyCharm.
Good tuto bro
Thank you.
Hmm... the key order. What makes them come out in sequence?? Or, is that built into print?
the keys are in insert order. This was implemented in Python 3.
great video
I have one question..
Why we can't use dictionary or list in key..
But can use tuple or set in dictionary keys
Lists and dictionaries are mutable, meaning they can be changed after they are created, which makes them unhashable and therefore unsuitable for use as dictionary keys. Tuples and sets are immutable (well, technically sets are mutable, but "frozen sets" are not), meaning their contents cannot be changed after they are created, making them hashable and suitable for use as dictionary keys.
I think it would have been useful to also include the __getitem__ method of the dictionaries.
Isn't that just the [0] for example? Or I think it is that.
@@no_the_other_ariksquad It is but that is also a method and is also useful because you can get the value corresponding to the key, you can change the value of an existing key value pair and you can append a new key value to the dictionary and in many cases it feels cleaner to me personally that the other methods where you don't need the specialized functionality of the other dictionary methods (for example returning a default value if the key doesn't exist).
Sounds like you need to write a fair bit of documentation for anyone that uses your special “__getitem__ implementation. I’m not saying you should avoid it, but at least every developer knows immediately what’s going on with get() and setdefault().
I might make a video about getitem regardless, thanks for the suggestions :)
users : dict = {0:"Mario", 1:"Luigi", 2:"James"}
popped : str = users.pop(2)
popitems : str = users.popitem()
print(users)
copied : dict = users.copy()
copied[0] = "!!!"
print(copied)
sample_dict: dict = {0: ['a', 'b'], 1:['c',"d"]}
my_copy : dict = sample_dict.copy()
my_copy[0][0] = "???"
print(my_copy)
print(users.get(0))
print(users.get(3, "Not found"))
print(users.setdefault(4, "Brownstone"))
copied.clear()
people: list[str] = ["Mario", "Luigi", "James"]
users: dict = dict.fromkeys(people)
print(users)
users.items()
users.values()
users.keys()
users.update({4:"Bob"})
print(users)
I thought the dictionary is not sorted so there should not be a last item. Is it like random?
Since Python 3.7 dictionaries are ordered, which means the order in which the key-value pairs are entered are the order like in a list. Hence the .pop() method will "pop" the last item added to the dictionary.
Hello everyone is anyone called Mulher brava here ?
Thanks god, thanks
I love dicts!
cool |= cool
Dude I appreciate your channel a lot, because I learned a lot, but marking the type of simple global variables is annoying and demolishes the concept of a dynamically typed language. I can understand in classes or functions to make them easier to use, but in simple obvious variables?
Some people call it consistency.
@@Indently Yeah, consistency is very proper and professional, but this one looks like overused Federico. This is such a subjective opinion of mine, besides, I am waiting for another valuable content.
For me it helps, because when I make special rules I tend to forget where it actually matters. And it doesn't hurt readability, especially for someone who got so used to seeing them, it hurts me more to not see them, regardless of how obvious the variables might be.
But at the end of the day, they are optional, so my coding style of being extra explicit can only benefit those who choose to be less explicit.
If you wanted to run your code using CYTHON for speed then defining variables will be very useful and AI ie CoPilot can go through and covert them all to CYTHON style declarations.
Watch out leetcode! Your end is nigh!
barri nayki bil pub