Basic Python with projects and examples

Explore Python as an easy, platform-independent interpreted language, its text processing and error handling, and practical basics like indentation, 2.7 vs 3.x, and using PyCharm for development.

Install python on Ubuntu by updating packages, then install python3 by default and optionally python2.7 for legacy work; install vim as editor, and use pip to install external packages.

Explore the structure of a typical Python program, from the shebang and interpreter to defining functions with def, indentation, and empty bodies with pass, cover strings, comments, and executing scripts.

Learn how to work with strings in Python, including indexing, slicing, length, case conversion, docstrings, and common operations like split, find, count, replace, and concatenate.

Learn Python 3 string formatting and placeholders, contrasting it with C/C++ style printf, and explore common string methods like split and how to access help and function details.

Explore string slicing and list slicing by using start and end indices, end is not inclusive, optional steps, and negative indices to extract parts from strings, lists, and tuples.

Explore list data structure by creating lists, accessing items by index (negative), and checking length. Learn to append, extend, and iterate lists; observe how plus operations affect elements and nesting.

Explore Python lists by building a mixed-type list, using slicing for index ranges, and practicing insert, append, remove, and pop operations, plus index and count methods with basic error handling.

Learn Python list operations: sorted returns a new sorted list. Min, max, and sum work on numbers; sorting strings; enumerate for indices; and joining list items into a string.

Learn how the sort method modifies a list in place, contrasts with sorted which returns a new list, and how reverse=true yields descending order when printing from the back.

Discover that tuples are immutable and cannot be modified in place. Learn to modify data by converting tuples to lists, adding elements, then converting back.

Explore how sets use hash maps, differ from dictionaries by lacking values, remove duplicates, and support quick membership checks. Learn intersection, difference, and union on sets.

Explore Python dictionaries and their hash-based structure, mapping keys to values, and learn to access keys, values, and items, iterate entries, ensure key uniqueness, and update dictionaries.

Learn to work with Python dictionaries, including safe access with get and handling missing keys without errors. Update dictionaries to modify values and add new entries, and count word occurrences.

Learn to work with Python dictionaries by iterating keys and values, using dict.items(), and deleting items with del or pop; order is not guaranteed.

Explore how Python functions work, including defining with def, using global variables, and the rules for local scope; see how default arguments and lists enable flexible function calls.

Explore how to design functions with variable numbers of arguments in Python using *args and **kwargs, including summing inputs, iterating over arguments, and handling key-value pairs.

Explore how to use variable arguments in Python functions with normal args, *args, and **kwargs, including passing tuples and dictionaries, and iterating over items.

Explore string slicing and immutable strings in Python by building a function that replaces a character at a given index, creating a new string rather than mutating the original.

Explore how to define and use Python functions, pass parameters and default arguments, return values, and even treat functions as data by storing and calling them from lists.

Master python exception handling with try-except blocks and finally, catching specific errors like zero division error and file not found, and raising custom exceptions for robust code.

Learn multiple ways to measure function performance in Python, including the Linux time command, the timeit module, and the time module with time.time(), exploring real, user, and system timings.

Compare three Python timing functions—perf_counter, process_time, and time.time—to measure code performance, noting that perf_counter includes sleep while process_time excludes it, and time.time reports epoch time.

Learn how Python uses tuple packing and unpacking to swap variables in a single line, like x, y = y, x, and compare it with C's temp-variable approach.

Learn how Python classes group data and methods into objects, with self referencing each instance; see how a class acts as a blueprint and how class versus instance variables behave.

Explore a continuing Python class example with an init constructor, a display method, and instance versus class method calls; examine class variables and dog attributes like color and texture.

Override __len__ and __str__ in a simple class, implement __init__ and character counting, and choose between real length or a byte-aligned length for the object's string representation.

Learn how Python’s dir, id, and type inspect objects, identity, and types with examples in strings and lists. Explore how magic methods like __eq__ shape behavior and equality.

Learn how to work with Python modules, import both standard and user-created modules without extensions, and call functions from modules like time and os across Python 2.7 and 3.x.

Learn to create a basic Python module, define a function, and reuse it across files by importing the module or specific functions, and access module variables like fruits.

Learn to import specific items from a module vs importing everything, access fruits via module namespaces, and explore a Python class with __init__ and self that prints breed and colour.

Learn to import the dog module from another directory by appending the path before importing, and use environment or python path settings to resolve missing modules, while inspecting system paths.

Learn how to create lists concisely with list comprehension, applying loops and optional conditions to transform items; compare list results with generator expressions to improve memory efficiency.

Explore how to generate (x, y) points from coordinate lists using list comprehensions in Python, compare with explicit loops, and learn about tuples, generators, and two dimensional iteration.

Explore dictionary comprehension and how to combine it with zip to build key-value dictionaries from paired lists, including conditional filtering and mapping countries to capitals.

Explore python sets, their uniqueness and hash behavior, and master set comprehension along with operations like union, intersection, difference, and symmetric difference.

Learn how the Python zip utility enables parallel iteration by pairing elements from multiple lists, with zip and zip longest, handling missing values via fill values and default shortest behavior.

Implement a custom zip utility in Python that pairs elements from two lists using the minimum length, then extend to handle multiple lists with star arguments and tuples.

This lecture explains iterable, iterator, and generator concepts, showing how yield enables on-the-fly values with next or for loops to avoid large memory loads, with practical examples.

Learn how generators and iterators work in Python in part 2, including using next() with a generator, how a for loop auto-advances, and handling stop iteration.

Explore how generators and iterators fetch elements with next and __next__, and how iter converts lists into iterables. Learn when to use for loops versus while loops and StopIteration handling.

Learn to implement a custom iterator by defining a next method, returning the current value, and raising StopIteration to bound the range from start to end for loops.

Explore how iterators and generators save memory through lazy evaluation, comparing lists with and without them, and measure memory using memory profiler and psutil.

Explore how Python's map, filter, and reduce functions transform and condense data using lambda expressions, with examples from doubling numbers 1-20, filtering by divisibility by three, and summing with reduce.

Convert degree values to radians using map and lambda, filter obtuse angles greater than 90 degrees, and compute the sum of angles with the radius function.