
Set up your Python environment with Anaconda, install Python 3.6, and learn to launch and use Jupyter Notebook to work with notebooks and basic Python concepts.
Learn to replace print statements with a configurable logging system to debug in real time, control verbosity with levels like debug, info, and error, and write logs to a file.
Developers work in a sandbox by duplicating the production database and code, while the QA team uses tests and TDD to verify changes before production deployment.
Write and run Python tests to verify division and sorting functions with assertions and exceptions. Learn how test discovery, imports, and edge cases ensure code reliability.
Explore list mutability and deep copying in Python, including aliasing, shallow copies via slicing, deep copies with the copy module, and working with nested lists and tuples.
Explore how Python generators enable memory-efficient streaming of data, maintaining state with yield to decouple loading and processing, and support infinite sequences without loading everything at once.
Explore how generators in Python enable lazy evaluation and memory efficiency by producing values on demand, illustrated with squared numbers and log bytes processing.
Explore higher-order functions by treating functions as first-class values, naming or anonymous, and passing them as parameters to a generic summation.
Explore higher-order functions by building a square-root calculator that uses a default or custom good-enough test; pass functions as parameters to enable callbacks and flexible code, as in JavaScript.
Explores decorators in Python by wrapping a Fibonacci function with a logger, demonstrates slow recursion, and introduces memoization to speed up via a higher-order function that stores results.
Learn how memoize wraps a function with a memory dictionary to memorize results, creating a memorized wrapper via a decorator that speeds up fib calculations.
Master context managers to automate setup and cleanup, preventing resource leaks with open as f and automatic file handling. Build reusable timing context managers to keep core logic clean.
Discover how to use context managers to create and automatically clean up temporary directories and files, employing try/finally, with blocks, and generator-based patterns to separate setup from business logic.
Learn how to download multiple pages in parallel using Python threading to speed up network requests, compare sequential versus multithreaded execution, and observe overhead from interleaved prints with join.
Explore how parallel threads cause race conditions when updating a shared variable and learn to use locks and context managers to protect the critical section and ensure correct results.
Explore asynchronous programming with asyncio and async/await, learning to mark slow operations as awaitables and run tasks concurrently, avoiding threading and locks. Understand the event loop and futures.
Explore functional programming as a paradigm with pure functions and no side effects, emphasizing predictability and easier debugging. Learn map, higher-order functions, and lambdas to apply operations across collections.
Explore how map, filter, and reduce demonstrate functional programming principles for intermediate Python programmers, enabling word-count tasks and scalable big-data processing with Hadoop and Spark.
Learn plotting basics in Python with NumPy and Matplotlib, generating inline line plots in Jupyter notebooks, and customize legends and axis labels for clear data visualization.
Compare two algorithms for calculating the NADJI number by timing Fips low and Freepost across a range, then plot the results to visualize exponential versus near-constant growth.
Explore the fundamentals of regular expressions in Python, learn to search patterns, capture matches with the re package, and understand greedy versus non-greedy matching using practical examples.
Learn to modularize regular expressions by splitting the pattern into date and time parts, handle am/pm variants and case sensitivity, and extract emails with a structured pattern.
Extract an email address from a string using RegExp capturing groups, isolating the username and domain.
So you have taken an initial programming course or have learned the basics on your own. However, when you look at other people's code, or listen to their discussions, you see many concepts that seem alien -- stuff that you don't understand. So, the question is: how do you go from a beginning level programmer to the expert level? How do you become a guru?
This course answers this question. In it, we will be building on top of your existing basic understanding of the Python language (and programming in general). We will cover concepts that will take you to the next level of programming expertise. These will include language constructs that are typically not covered in a beginner level course. Concepts like generators, decorators, callbacks, higher order functions, context managers and others.
We will also discuss some tools that are not difficult but are essential to the life of a professional programmer. An example of this is logging for tracking down bugs -- a simple technique that is used in all production level software but is never touched upon in typical programming courses.
We will discuss parallel programming -- multi-threading and synchronization issues -- another important concept you must understand to code in a production environment. We discuss these through a case study to explain WHY you need them as well as HOW to use them.
Closely related to this, a highly important concept in today's programming practice is the idea of asynchronous programming -- more commonly known as asyncio. Python and Javascript -- two of the most influential languages in today's development -- are heavily focused on this new paradigm and we will cover this in a very intuitive, easy to understand manner. For all concepts, we take a case study-based approach and motivate why we need the concepts we're seeing and how everything fits together.
Remember: the most important reason you're paying for a course is support. So, please ask questions in the Q&A forum if you ever get stuck. I have a maximum response time of around 15 hours -- not average, maximum. Please use this to your advantage -- ask questions and you should be able to breeze through this course and go beyond a basic level of programming to the next level where your code will take less time to write ... will be clean and much easier to maintain.
What will I learn?
About the instructor:
Target Audience:
Anyone who:
What you need to know:
You should have knowledge of basic usage of Python (variables, conditionals, loops, basic list and dictionary usage, basic file handling)