Efficient Application Development with Python3 for Beginners

This video will give you an overview about the course.

We wish to learn the powerful and popular Python programming language in a fun way.

• Build a simple dice rolling simulator

• Enhance the simulator using functions

• Add dictionaries and become more complex

We like to use complex data structures to store and use our data.

• Start using a dictionary

• Nest another dictionary within the dictionary

• Nest many more dictionaries into dictionaries

We like to understand how Python generator functions work and what they can be used for.

• Build a generator function.

• Compare a generator to a regular function

• Yield the results using next and for loops

We like to understand how to iterate over Python data collections. There are several different collections, like tuples, lists, dictionaries and sets.

• Use tuples

• Use lists and sets

• Use several Python comprehensions

We want to build our own game of playing cards.

• Create cards in a simple textual form

• Use the random module to shuffle the deck

• Advance to using OOP classes

We like to advance our game of playing cards using graphical image files.

• Start simple using gif image files

• Make our code object-oriented.

• Use tkinter to display the graphical cards

We find some nice free image files of playing cards on the internet but they are either too large or too small so we want to resize them to fit our application.

• Install Pillow and use the Image module

• Convert Unicode cards into 16-bit surrogate pairs.

• Use tkinter to display png and Unicode cards

In the previous videos we explored several ways how to create textual playing cards, order, shuffle and display them. We also learned how to resize graphical image card files. Now we want to use them to play a card game.

• Reuse some of our previous code

• Build the game logic

• Create a new tkinter game GUI

We want to learn how to program object-oriented.

• Explore Python’s Duck typing

• Advance to using objects

• Inherit from abstract classes

We want to become great programmers.

• Start to understand OOP

• Understand single inheritance

• Move forward to multiple inheritance

We want to apply what we have learned. We are building our first building using software.

• Use single inheritance

• Use multiple inheritance

• Create a Cathedral

We are building a Greek classic temple.

• Use Unicode to represent the floorplan and frontview

• Use multiple inheritance

• Mix in extra functionality

We want to learn how to build a GUI.

• Use Python’s tkinter module to build a GUI

• Add widgets to the GUI

• Create a callback function

We want to add many widgets to our GUI.

• Use a loop to add the widgets

• Use lambda to pass variables to callback functions

• Add Progress Bar and Paned Window controls

We want to use several layered Notebook tab controls. Out of the box, tkinter does not provide this widget so we build our own.

• Use frames and notebooks together

• Create and remove buttons dynamically

• Mimic a notebook tab click event

We want to make our GUI look good and modern.

• See ways how to control the GUI size

• Add several colors to different widgets

• Use ttk style element functionality

We want to search the directories on our hard drive. We want to find certain files and get a count of folders and files.

• Use Python’s OS module

• Define our search start using OS functions

• Use OS walk to walk an entire directory tree

We want to search many of our Python modules and rename code within all of them.

• Create backups of our code modules

• Generate Python class modules via code

• Rename all instances of our classes

We want to administer our Windows systems. We also want to collect statistics of CPU, memory, disk io, and other resources.

• Use the psutil Python module

• Collect data similar to task manager

• Collect data over time

We want to automate some of the tedious daily tasks. We have lots of Excel documents and manually have to open, read and close them to collect summary data. We want to automate this process.

• Use the OpenPyXL Python module

• Create Excel documents with data

• Open, read, and summarize data from many Excel documents

This video gives glimpse of the entire course.

Time is of essence and timeit is your tool. In this video we explore timeit.

• Understand what is timeit

• Set up our timing experiment

• Run our timing experiment

In this video, we will look at profile module and understand where time is spent.

• Understand what is profiling

• Understand how Profiling our Fibonacci sequence generator is done

• Profile the sequence generator using the least recently used cache

In this video we will explore and understand tips and tricks which will allow us to track time more precisely using cProfile.

• Understand the difference between cProfile vs profile

• Explore and create artificially slowed functions

• Understand profiling using cProfile

In this video we will understand the memory_profiler.

• Explore how to go about profiling a simple function

• Explore and understand how profiling manual garbage collection is done

This video is all about reducing the execution time and memory consumption.

• Understand what are slots

• Create classes that use slots

• Inspect the performance of slots vs class dicts

In this video we will use tuples instead of lists when your data does not change.

• Understand what are tuples and how to declare them

• We will see by example that tuples are fasters than lists

• We will understand why are they faster than lists

Save on memory consumption with generators instead of lists.

• What are generators?

• Why are they memory efficient?

• Implementing generators

Generators are designed for a specific purpose, here is when not to use them.

• when you need features from a list

• when you need to iterate through a list multiple times

Chain together a series of processes so one output is another's output.

• Composing two generators

• Using parenthesis to define generator comprehensions

Illustrate why we need to move from Python lists to NumPy arrays

• Problem 1: Memory consumption of lists for large amounts of data

• Problem 2: Dynamic Typing

Show how we can use NumPy and the different ways we can create NumPy arrays

• The difference between NumPy arrays and lists

• Creating NumPy arrays from Python lists

• Creating NumPy arrays from NumPy helpers

Show that for large n, NumPy arrays are much faster than list comprehensions

• Setting up our problem with list comprehensions

• Setting up its cousin in NumPy

• Comparing their performance

Show how to use broadcasting - applying binary functions on arrays of varying length

• What is NumPy's broadcasting?

• Broadcasting: an example

• How broadcasting works - three examples

Show the simple interface of numexpr and where we can use it to optimize

• What is numexpr?

• How to use numexpr?

• Use cases of numexpr

If you have a list of URLs, serially requesting the HTML body of each page is super slow

• Using requests to scrape the HTML of a web URL

• Timing 10 web scraping requests

What are coroutines and how they help you request all webpages at once

• What is gevent?

• What are semaphores?

• Creating a gevent scraper

What is event driven concurrency, and how that can speed up web scraping

• What is tornado?

• What is an IO Loop?

• Creating a tornado based scraper

Futures and asyncio driven concurrent web scraping

• What is asyncio?

• await and async

• Creating an asyncio based scraper

Introduce the audience to parallel programming concepts.

• What is parallel processing?

• Embarrassingly parallel and less embarrassingly parallel

• The global interpreter lock of Python

Show how the decorate-sort-undecorate pattern can be beaten

• The decorate-sort-undecorate pattern

• Beating the DSU pattern with a sort key

Show how we can use Pool to achieve multiprocessing

• What is Pool?

• Our first process Pool

• Asynchronous process Pools

In this video we will understand how we can stop processes from interfering with each other using locks.

• We will be using multiprocessing.Value to share variables

• Why does it not add up?

• Using a lock to remove overwrites

This video covers the effects of many processes.

• Using the logging module

• Creating the right logger format for multiprocessing

• Logging multi-processes

This video is focused on understanding how to copy and clone objects the right way.

• Identify the wrong object instance

• Use the correct object clone

This video will show us how to mini-classes of Python: namedtuples

• Learn about mini-classes of Python

In this video we will understand how to create smart values with static methods and properties.

• Create smart values with static methods and properties

In this video we will be understanding how to compare two different objects.

• Understanding how to compare two different objects

In this video we will explore how to do real OOP by implementing abstract base classes in Python.

• Do real OOP by implementing abstract base classes in Python