Python Crash Course: Gain Real World Developer Skills Now!

Explore Python fundamentals, including variables, typing, and types, and learn to get user input, apply naming conventions, and preview brief class concepts with Eliza and Hammurabi.

Create a Python project in PyCharm and study variables and expressions. Understand dynamic typing, declare integers and strings, and check types at runtime with type function, while following naming rules.

Learn how Python variables are dynamically typed, how None serves as a placeholder, and how to safely concatenate strings with numbers using str(), illustrated by an interactive number game.

Discover how variables in Python keep prompts consistent and simplify updates across the code. See how the random module generates values to vary gameplay, reinforcing code maintainability and clarity.

Learn how to initialize the answer variable before use by declaring first number, second number, and subtraction upfront, and apply this approach with a practical Python challenge.

Explore Python naming conventions from official guidelines and learn when to use camel case, underscores, and Pascal case. Distinguish public and internal names to write readable, consistent code.

Refactor the Eliza project's doctor.py to conform to Python naming conventions, identify eight deviations, and practice reading code carefully to fix errors and improve maintainability.

The lecture guides you through solving the naming convention challenge in Python, identifying eight deviations and refactoring variables to snake_case with PyCharm.

Explore Python variables, dynamic typing, and value reassignment, including type() and None as placeholders. Learn naming conventions: classes in pascal case, functions and variables in snake_case, and avoid case-only conflicts.

Explore the input and print functions for console IO, build a simple menu, and convert user input to numbers with int, using string interpolation, and illustrate with the Hammurabi game.

Learn how to read user input in Python using the input() function, build a simple menu with six coffee options and an exit, and capture and display the user’s choice.

Create a python project named hammer bitcoin, build bitcoin miner and main.py, and use the input function to drive a play again prompt in a bitcoin mining game.

Learn how to read text and numbers from the console in Python using input and int, and print results with string concatenation.

Explore how the Hammurabi project reads numeric input with a reusable get number function, converting input to integers using try/except to prevent crashes and reuse across the game.

Explore console output and string interpolation in Python 3.6 using f-strings, replacing messy concatenation with readable, auto-converted variables through curly brace placeholders.

Explore string interpolation and formatting in Python by aligning output with field widths using f-strings, adjusting alignment to right or left for columns of fruit data.

Learn to collect user input and display results in the console using Python's input, print, str, and int conversions, with examples from the simple menu and the Hammer bitcoin project.

Explore Python's basic data types, including integers and floating point numbers, and see how variables form numeric and Boolean expressions, with a brief intro to classes, instances, and attributes.

Explore Python's built-in primitive types, including numeric types, strings, booleans, sets, and dictionaries, and learn how string immutability affects performance and memory.

Explore the Python integer type (int) and its immutability, show how Python handles whole numbers with no size limit, and demonstrate variable identity using the id function.

Examine floating point types in Python, understand precision up to 52 digits, fractional values, max and min values, and when to use float versus the decimal module.

Explore how Python expressions evaluate to a single value, assign to variables, and use literals and booleans with examples like result1=47 and result2=25; the left side must be a variable.

Learn how to write and evaluate boolean expressions in Python, using ==, !=, >, <, >=, <=, and the is operator to test types, with practical examples.

Explore compound boolean expressions using and, or, and not to test multiple conditions, illustrated with apples and oranges, truth tables, and readable code with parentheses.

Master boolean variables in Python, store true and false values, and apply boolean expressions and conditional logic using and/or operators in real-world code.

Discover how booleans guide logic in the Hammer bitcoin program, via the play method's while loop, a true/false variable, and a compound condition that tracks years.

Learn to identify and count boolean expressions in a Python game code, tracing 27 expressions across buying, selling, maintenance, hacks, and market crash checks.

Explore the basics of classes and objects in Python, and see how to define a Doctor class, its methods, and how to import and call Intro from program.py.

Learn how to define a class in Python, create class instances, and call methods like accelerate and brake using self and instance variables.

Learn how classes use attributes, including data attributes and methods, by building a car example with a speed field using self.speed, init, and accelerate and brake methods, illustrating instance-specific values.

Learn how class constructors work in Python, using the __init__ method to initialize attributes like speed and car name, with a hands-on example showing self and instance creation.

Explore how to create and import Python modules to reuse code across scripts. Understand distinct namespaces per module and how dir reveals available names and attributes.

Explain how the __name__ global variable controls module execution in Python and why wrapping code in if __name__ == 'main' prevents code outside a class from running.

Explore how Python handles public and nonpublic class members, using underscore conventions and the absence of true private access to centralize logic with a _show_speed method.

Explore name mangling in Python, including how two underscores trigger internal name changes and how to access mangled attributes. Understand how single versus double underscores suggest private members.

Explore Python's built-in primitive types, including integers and floats, and master numeric and Boolean expressions, variables, and and/or usage in expressions. Build a car class with public and private members.

Learn how to alter program flow with loops and conditionals, explore methods and functions, and use the PyCharm debugger to inspect code as you practice reading and understanding it.

Using the Python language documentation, learn the for loop and how it iterates over sequences like lists and strings, guided by examples and navigation features.

Learn how Python for loops iterate over a string, printing each character. See how loops handle sequences and build a small project to run the example.

Learn to use the PyCharm debugger to set breakpoints, step over, inspect variables, and run code with resume to understand how a for loop executes.

Learn how to use Python for loops with the range function to iterate over sequences, customize start, stop, and step values, and even count backwards with debugging.

Master nested for loops in Python to print a ten-by-ten grid, control line breaks with end, and debug with PyCharm.

Learn to use the PyCharm debugger with the hammer bitcoin project, set breakpoints, step into and over code, inspect bitcoin miner instances, and observe runtime output and final scores.

Learn to implement a while loop in Python with a menu that uses user input and print, and quit on q or Q by converting input with lower().

Move the menu outside the while loop so it prints once and test the program after the change. Use PyCharm to reformat indentation if needed, then run and quit.

compare input handling methods, weighing lowercasing against preserving case, and evaluate readability versus performance. analyze the modulo-based loop for numbers divisible by 7 and related conditions.

Explore while loops in the Eliza project with the Python debugger in PyCharm to set breakpoints and step through pattern matching and reflections.

Explore how the Eliza program matches user input against phrase lists, uses breakpoints to trace execution, and generates random responses through nested while and for loops.

Learn how while loops work with an else clause that runs when the condition becomes false. Discover the pass statement as a placeholder to define empty blocks in Python.

Explore Python documentation to identify keywords and statements, master for loops and nested loops, and use PyCharm with breakpoints to debug hammer bitcoin code and the Eliz project.

Explore how to make decisions in Python by using if-else statements to execute code blocks based on conditions. Learn to use the ternary operator as a concise alternative to if-else.

Create robust Python programs using if and else statements, mapping user input to rock, paper, or scissors through constants, and validating choices in a rock, paper, scissors game.

Explore how to replace multiple if statements with elif and else in a rock, paper, scissors game, improving efficiency by avoiding unnecessary tests and handling invalid input.

Develop the rock paper scissors game by implementing draw and win logic with if, elif, and else, using value comparisons and logical operators.

Convert the computer’s numeric choice to its string with if-else (rock, paper, scissor), print player and computer choices for transparency, and prepare the challenge to validate the game logic.

Learn a rock, paper, scissors game using if-elif-else to map values to choices, then add a while loop to play again with a get yes or no method.

Demonstrate solving the play again challenge by using a while loop and a play again boolean, driven by get yes or no prompts, with indented blocks and no curly braces.

This lecture demonstrates how the Python break statement exits a loop when a match is found, using a simplified Eliza example with matches and an index to illustrate early termination.

Explore the Python continue statement, how it skips to the next loop iteration, and how it differs from break, illustrated with a vending machine coffee menu example.

Explore the scope of break and continue in Python, showing break exits the innermost block and continue advances the enclosing loop inside if, for, and while contexts.

Explore the ternary conditional operator as a concise alternative to if-else in Python, with practical examples that assign time to relax or work based on the day.

Master the ternary conditional operator by refactoring the HammerBitcoin project's count new hires method to replace an if-else block that handles starving employees, showcasing real-world Python practice.

Develop and refactor code by converting an if-else to a ternary conditional operator in the count new hire method, then test to ensure correct behavior.

Explore conditional execution and control flow by mastering if statements, boolean expressions, and if-else branches, using break and continue, constants, and the ternary operator to write concise, efficient code.

Learn how to declare functions and methods, understand parameters, arguments, and return values, and explore global variables, scope, side effects, and refactoring to reduce reliance on globals.

Learn how to call methods in a class by turning accelerate public, and observe how the flow of execution changes with the PyCharm debugger's step into and step over.

Understand how methods call other methods by stepping through the call stack and return addresses, so execution jumps into a called method and returns to the caller after it ends.

Explore method parameters by converting the accelerate method to accept an amount parameter and using arguments to update speed, while distinguishing parameters from arguments.

Explore the parameter challenge by adding a speed reduction parameter to the brake method, ensure correct argument types, and prevent the car speed from going below zero.

Explore multiple approaches to implementing a brake function in Python, ensuring speed never drops below zero. Compare normal subtraction, conditional checks, and the ternary operator, with practical code demonstrations.

Create a simple text-based car game in Python, exploring a car class, constants, and keyboard controls to steer, accelerate, and draw the road with strings.

Explore public vs non-public methods in Python with a car game, learn about double underscores and name mangling, and refactor to expose a public show_speed accessed by the info key.

Clarify the difference between functions and methods in Python by showing how functions live outside classes and methods live inside classes, using dot notation and self to call object behaviors.

Learn how to return a value from a function in Python, using a still on track boolean function with position and road parameters, and apply top down programming.

Realize why duplicating code is bad by examining a car game crash handling for left, right, and straight paths, refactor duplicated draw logic into a function, and test all directions.

Refactor to remove duplicate code by creating a drive function that takes speed and position, moving repeated logic into a single method while preserving game logic.

Explore pass by value, where the function receives a copied position (15) and cannot change the original car position, unlike pass by reference.

Explore how to modify a shared car position using global variables in python, apply the global keyword, and compare pass by value with python’s lack of pass by reference.

Refactor the drive function to support left, straight, and right movements by adding -1, 0, and 1 to the position and eliminating duplicate evaluation logic.

Explore a challenge solution by extending a drive function with a direction parameter to support left, straight, and right movements, using constants or an enum to improve readability.

Explore variable scope by examining class attributes, static fields, and instance variables, and learn how non-public underscores limit access and minimize side effects in the hammer bitcoin project.

Refactor buy computers to return the number of computers to buy, limiting side effects to cash and moving updates to the call site.

Refactor the Bitcoin Miners class to remove method side effects, understand call sites and callers, and distinguish class attributes (static), instance, global, and local variables.

Refactor the given challenge code by introducing parameters, return values, and updated calls to manage computers and cash, while testing step by step to spot bugs.

Continue solving the challenge by refactoring the maintain computers flow, updating computers and employees as arguments, and optimizing cash calculations while refining the check for crash.

Explore flow control with for, while, do-while loops and if-else, and trace method execution with the debugger. Clarify parameters and arguments, return behavior, top down programming, and global scope.

Begin this section by exploring arithmetic operators and operator precedence, and prepare to study string methods in the next section.

Learn how operators and operator precedence govern Python expressions, using addition, multiplication, and parentheses to control evaluation order. See how parentheses change results from 19 to 40.

Explore Python's primary operators and precedence, including dot notation, math module imports, and method calls, then practice with arithmetic, remainder, floor division, and exponent operations.

This lecture explains operator precedence in Python, detailing unary operators like negation and not, left to right evaluation of same priority operators, and how parentheses and flow division affect results.

Explore the remainder (modulo) operator to test divisibility, determine odd or even numbers, and wrap a month counter from December back to January using a for loop.

Discover how the remainder operator powers winner logic in rock, paper, scissors by mapping choices to numbers and using modulo to simplify win and draw conditions.

Master comparison and relational operators in Python, learn boolean and logical operators, assignment operators, and understand operator precedence and the use of parentheses to clarify expressions.

Explore short circuit evaluation in Python, using boolean and and or to skip the second expression and avoid errors, and understand macarthy evaluation.

Explore assignment operators in Python, using plus-equal and other shorthand on variables, printing results like 46 and 408, and consider readability and potential side effects.

Explore Python's membership operators to test if a value exists in a sequence, using strings and lists, with in and not in returning boolean results and examples of membership tests.

Explore essential Python operators, including the modulus for cyclic values, grasp operator precedence, and use parentheses to document intent, ensuring clear expressions and safe short‑circuit evaluation.

Explore Python strings by searching for substrings, replacing them, and slicing with indices. Learn string indexing and immutability, and see how these concepts apply to arrays and lists.

Explore what a string is in Python, including unicode and immutability, and learn to create, concatenate, format with f-strings, format, and old style methods, then index and iterate characters.

Learn how Python indexing works across strings and lists, starting at zero, with positive and negative indexes, and master string slicing to extract portions.

Master string slicing in Python by using start, end, and step with optional parameters, and compare it to indexing (positive and negative). Explore defaults and practical examples.

Explore string slicing and iterating through strings in Python, using start, end, and step parameters, and practice forward and reverse traversal with positive and negative indexing.

Learn how to compute string length in Python with the built-in len function, and use it with a while loop. See how indexing applies to strings and lists.

Explore how the find() method detects substrings in Python and how lowering input aids matching. See indices, matches, and response mapping in a loop.

Learn to perform a case-insensitive search in Python using the find method by converting strings to lowercase. Implement a find_ignore_case function to locate matches.

Explore method chaining in Python by applying lowercase conversions and the find ignore case function, reducing three lines of code to a single line for readability and efficiency.

Learn how to use rfind to locate the last match. Discover how to find all occurrences of a string within a text using from index and a while loop.

Explore Python string methods and the official documentation to learn capabilities like endswith, find, format, lower, upper, and isnumeric.

Explore the immutable behavior of strings in Python by inspecting identities, mutating through concatenation, and watching how new strings are created when changes occur.

Master string concatenation in Python using the plus operator, including adding spaces, printing results, and using the del keyword to delete and recreate strings to prevent errors.

Explore the different forms of the find method in Python strings, including one, two, and three parameter variants with start and end defining the search range.

Explore Python strings as sequences of Unicode characters, learn to compare, find, slice, format, and index strings, including positive and negative indexing and the impact of immutability.

Explore object oriented programming with classes, encapsulation, inheritance, polymorphism, and abstraction, using airport modeling to illustrate design choices and how Python structures data and behavior.

Design an airport model using Python, creating airport, runways, runway, airport terminal, and room classes while planning on paper before coding.

Learn how to generate class diagrams in PyCharm, show diagrams for modules and classes, and understand the differences between PyCharm professional and community editions.

Explore class attributes and data attributes, and how getters and properties validate and expose values across instances. Grasp constructors and nested classes in Python.

Explore Python constructors and data attributes by building a car class, initializing name and speed in __init__, creating multiple instances, and understanding how Python differs from Java in object creation.

Learn how to replace direct attribute access with pythonic getters, setters, and a speed property to safely expose and manage car speed, including nonpublic naming conventions and refactoring expectations.

Learn why use properties in Python. Use getters and setters to enforce encapsulation, create read-only and write-only attributes, and validate values such as speed to keep data valid.

Explore the single responsibility principle and how to keep a class focused, separating display from data to preserve the API contract and prevent code breakage when units change.

Expose a read-only name attribute using properties, getters, and setters to prevent external modification, illustrating how to implement non-public fields with underscores and a property wrapper.