Write Pythonic Code Like a Seasoned Developer Transcripts
Chapter: Course Conclusion
Lecture: Lightning review
0:01 So let's just take a few minutes and review what we have studied and what we've learned.
0:03 We started out looking at PEP8
0:06 and many people when they first start looking at Pythonic code
0:09 and thinking about these idioms and these concepts,
0:11 they might feel that well PEP8 is what is Pythonic code, it defines how we write Pythonic code.
0:18 Yes it does touch on some of the things you should do in Python,
0:21 it does talk about how you should write your code
0:23 and even some of the underlying patterns that you use,
0:26 but there is so much more as you now know.
0:29 We talked about many foundational concepts
0:31 and in some senses it's just kind of a grouping
0:34 of a really important core concepts that didn't fit into their own category.
0:38 So we talked about thruthiness, booleans,
0:41 leveraging the truthiness of objects, testing for none, remember, use is not ==none,
0:46 we talked about multiple tests against the single value,
0:49 remember we saw that Pythonic way to do this is value in collection
0:54 or set of options, using random.choice to find a random item out of a sequence;
0:59 we talked about string formatting,
1:02 we saw that when you write scripts that are meant to be run as programs
1:06 and chained together unic style you should really add exe codes for the error conditions,
1:10 and we also saw flat is better than nested, in practice.
1:15 We next turned our attention to dictionaries and you saw a dictionary
1:18 is really a core part of the Python language.
1:21 You saw there were tremendous performance benefits
1:23 for using dictionaries for random lookup by values
1:27 other than the index compared to other collection types such as list.
1:30 We saw that using slots in certain limited situations can dramatically improve
1:35 Python's performance around memory.
1:38 Python 3.5 introduced a new way to merge dictionaries,
1:42 we saw that dictionaries can be a stand in for switch statements,
1:45 and we saw that dictionaries are isomorphic to json.
1:48 Then we turned our attention to generators and collections,
1:51 generators as in methods using the yied keyword
1:53 as well as generator expressions using the parenthesis
1:57 instead of the square brackets like a list comprehension.
1:59 We talked about using in to test for whether an item is in a collection or not,
2:03 we saw slicing is a core Pythonic concept
2:08 and can even be applied to outside of basic sequences like lists and so on,
2:11 to things like databases.
2:13 For methods we saw that yield and yield return let us write simple
2:16 and highly efficient generator methods;
2:19 and finally, we saw that if we have a generator
2:22 regardless of where it comes from whether it's a generator method
2:25 or a generator expression, we saw a cool trick for summing up
2:28 or counting the number of items in a generator.
2:31 One of the core building blocks for Python of course is functions.
2:34 And we saw the functions are first class citizens
2:37 we saw that lambda expressions let us write small concise functions
2:41 to be passed around as arguments,
2:44 we talked about how using return values is errors from functions
2:47 while sometimes ok is generally as a rule of thumb frowned upon,
2:51 and we should use errors and exception handling
2:54 rather than return types to indicate failure,
2:57 we talked about different ways to add polymorphism or overloading to functions,
3:01 we talked about default values, variable number of arguments,
3:05 keyword arguments, mapping dictionaries to and from keyword arguments
3:09 all those sorts of things, and finally we saw one of the Python gotchas
3:12 of which there is not many, but using a mutable instance
3:16 or a mutable type for a default value.
3:19 Next, we came to import antigravity,
3:22 talked about how amazing packages are and what the idioms
3:25 around using packages and your own modules are in Python.
3:29 So remember, try to avoid wild cart imports,
3:32 from package import star, not super Pythonic.
3:35 If you are building a module that is meant to be reused
3:38 but also sometimes run as a program,
3:40 you saw the main, the __main__ convention in action.
3:44 We also briefly touched on virtual environments,
3:47 user requirements.txt to help the consumer of your application
3:51 know what they need to install.
3:54 Moving from functional programming into object oriented programming
3:57 we saw that classes and object oriented programming in Python are very important,
4:01 and a key cornerstone of the language,
4:03 we saw the right and the wrong way to add fields to the classes,
4:05 we talked about data encapsulation and data hiding
4:08 with underscore field name being protected
4:11 and double underscore field name actually getting mangled by the Python runtime
4:14 so that it's effectively private, although you saw that it's not really super hidden,
4:18 you can still get to it.
4:20 And we saw that properties, both read only and read write
4:23 are very powerful ways to encapsulate and protect our data
4:26 and let the class manage it more itself.
4:30 Loops in Python are interesting because they are fairly different
4:33 than most other languages, we saw there is no numerical for loop,
4:37 there is only a sequence based for in loop, but there are things to add into there,
4:41 sequences we can use that will give us variants that are basically numerical for loops.
4:47 So remember we can for in over a range and that will give us numbers in sequence,
4:50 if we have a sequence and we want to for in over that and get the index,
4:54 we enumerate over that and project or unpack that
4:59 into the tuple index, value and then we work with that.
5:02 We also saw that loops have an else block but we should forget that fact.
5:05 Tuples are powerful light weight containers often used in Python.
5:09 And, we saw that we can unpack those into variables,
5:12 so let's do something like x,y= tuple of length 2,
5:16 put the first item in x and the second item in y and so on,
5:19 and we can use that for all sorts of cool tricks,
5:22 we'll use that when we do a for in loop over enumerate,
5:24 we used that if we wanted simulate returning multiple values from a method remember,
5:28 technically that's not what happens, but that's how it appears in code which is wonderful;
5:33 we finally saw that while tuples are great working with them
5:36 can be error prone and kind of unclear so upgrading them to named tuples
5:40 via collection.namedtuple is a really nice way to work with them.
5:44 Finally, we took a look around the ecosystem for Python
5:47 and said there are so many amazing packages outside of Python,
5:51 let's just round out the course by making a point
5:54 that you should first look to things like PyPi,
5:57 the Python package index and github
5:59 for the various building blocks or lego pieces of your application
6:03 rather than trying to write them all from scratch.