Course curriculum

  • 1

    Module 1: Operators

    • Resources
    • Segment 00 : Downloading All Course Material
    • Segment 1 : Downloading Module 1 Content
    • Segment 2 : Exploring the Course Material
    • Segment 3 : Launching the Material with Jupyter Notebooks
    • Segment 5 : Getting started with the Modules
    • Segment 6 : Arithmetic Operators
    • Segment 7 : More Arithmetic Operators
    • Segment 8 : Change Operator Precedence with Parentheses
    • Segment 9 : Comparison Operators
    • Segment 10 : Comparison and Arithmetic Operators Together
    • Segment 11 : Chained Comparison Operators
    • Segment 12 : Unary Plus and Minus Operators
    • Segment 13 : Boolean Operators
    • Segment 14 : Multiple Arithmetic Operators
    • Segment 15 : The or Operator
    • Segment 16 : The not Operator
    • Segment 17 : Combining Boolean and Other Operators
    • Segment 18 : Assigning Values to Variable Names
    • Segment 19 : Multiple Variables
    • Segment 20 : Python Comments
    • Segment 21 :Augmented Assignment Statements
    • Segment 22 : Other Operators
    • Segment 23 : Open Project Notebook
    • Segment 24 : Project Solutions
  • 2

    Module 2: What is Python?

    • Segment 25 : Preparing for Module 2
    • Segment 26 : Exploring the Contents of Module 2
    • Segment 27 : Downloading Module 2 Content
    • Segment 28 : What is Python
    • Segment 29 : What is a Computer Programming Language
    • Segment 30 : Programming Language Implementations
    • Segment 31 : A Specific Example of Different Implementations
    • Segment 32 : Language Specification
    • Segment 33 : Python Implementations
    • Segment 34 : Python Syntax
    • Segment 35 : Components of the Python Programming Language
    • Segment 36 : Whitespace and Indentation
    • Segment 37 : Long lines of code
    • Segment 38 : Python is an Interactive Language
    • Segment 39 : Running Entire Python Programs
    • Segment 40 : Why use Python
    • Segment 41 : Module 2 Project
  • 3

    Module 3 : Objects and Types

    • Segment 42 : Exploring Module 3 Contents
    • Segment 42 : Objects in the Real World
    • Segment 43 : An Introduction to Types in Python
    • Segment 44 : Writing Integers
    • Segment 45 : The Boolean Type
    • Segment 46 : The Complex Type
    • Segment 47 : The Float Type
    • Segment 48 : The None Object
    • Segment 49 : Passing Variables to the type Function
    • Segment 50 : Object Identity
    • Segment 51 : Dynamic Typing
    • Segment 52 : Built-in Types
    • Segment 53 : Object Attributes and Methods
    • Segment 54 : Accessing Attributes and Methods with Dot Notation
    • Segment 55 : What isn't an Object
    • Segment 56 : Summary
    • Segment 57 : Module 3 Project
  • 4

    Module 4: Strings

    • Segment 58 : Exploring Module 4 Contents
    • Segment 59 : Introduction to Strings
    • Segment 61 : Strings Containing Quotes
    • Segment 62 : Strings with Escape Characters
    • Segment 63 : Empty Strings
    • Segment 64 : Unicode
    • Segment 65 : Operators with Strings
    • Segment 66 : Method Chaining
    • Segment 67 : Find the Length of a String
    • Segment 68 : String Interpolation
    • Segment 69 : Selecting Substrings
    • Segment 70 : Selecting Substrings with Slice Notation
    • Segment 71 : Changing the Characters of a String
    • Segment 72 : Testing for a Substring
    • Segment 73 : Methods
    • Segment 74 : String Summary
    • Segment 75 : Module 4 Project
  • 5

    Module 5: Lists

    • Segment 76 : Introduction to Lists
    • Segment 77 : Brackets have a New Meaning
    • Segment 78 : Lists are Data Structures
    • Segment 79 : Selecting List Items
    • Segment 80 : Mutating Lists
    • Segment 81 : Unexpected Behavior with Mutable Objects
    • Segment 82 : Confirm Objects are the Same with id Function
    • Segment 83 : Creating a Unique List Copy
    • Segment 84 : Discovering List Methods
    • Segment 85 : The append Method
    • Segment 86 : The extend Method
    • Segment 87 : The insert Method
    • Segment 88 : The remove, pop, and clear Methods
    • Segment 89 : The reverse and sort Methods
    • Segment 90 : Reversing a List with Slice Notation
    • Segment 91 : The count and index Methods
    • Segment 92 : Getting the Length of a List
    • Segment 93 : Addition and Multiplicaiton Operators with Lists
    • Segment 94 : List Equality
    • Segment 95 : Check for Item Membership with the in Operator
    • Segment 96 : Lists of Lists
    • Segment 97 : Creating a String from a List
    • Segment 98 : Lists Summary
    • Segment 99 : Module 5 Project
  • 6

    Module 6: Ranges and Constructors

    • Segment 100 : Introduction to the range Object
    • Segment 101 : The range Constructor
    • Segment 102 : Viewing the Sequence Defined by range
    • Segment 103 : The bool Constructor
    • Segment 104 : The int Constructor
    • Segment 105 : The float Constructor
    • Segment 106 : The str Contructor
    • Segment 107 : More range Functionality
    • Segment 108 : Summary of Module 6
    • Segment 109 : Module 6 Project
  • 7

    Module 7: Conditional Statements

    • Segment 110 : Control Flow
    • Segment 111 : Python if Statements
    • Segment 112 : Indentation and Code Blocks
    • Segment 113 : else Statements
    • Segment 114 : elif Statements
    • Segment 115 : Dice Betting Game
    • Segment 116 : Multiple Boolean Conditions
    • Segment 117 : Ternary Conditional Operator
    • Segment 118 : Other Conditions
    • Segment 119 : Implied Truth Values
    • Segment 120 : Module 7 Summary
    • Segment 121 : Nested Conditional Statements
    • Segment 122 : Module 7 Project
  • 8

    Module 8: Writing Entire Programs

    • Segment 123 : Writing Entire Programs
    • Segment 124 : Creating a Python Program
    • Segment 125 : Running a Python Program
    • Segment 126 : Source Code Editors
    • Segment 127 : Downloading Visual Studio Code
    • Segment 128 : Opening Python Files in VS Code
    • Segment 129 : Running Python Files in VS Code (EASY)
    • Segment 130 : Running Python Files in VS Code
    • Segment 131 : Creating New Python Files in VS Code
    • Segment 132 : Triva Game Instructions
    • Segment 133 : Coding the Trivia Game
    • Segment 134 : Summary Module 8
    • Segment 135 : Project - Choose Your Own Adventure Game
    • Segment 136 : Getting Started with the Game
    • Segment 137 : Coding the Game
  • 9

    Module 9: Looping

    • Segment 138 : For-Loops
    • Segment 139 : Looping through a List
    • Segment 140 : Looping through range Objects
    • Segment 141 : Example for-loops
    • Segment 142 : While Loops
    • Segment 143 : Doubling Money While Loop
    • Segment 144 : Finding the Square Root using Newton_s Method
    • Segment 145 : Simple Guessing Game
    • Segment 146 : More Looping Control with continue and break
    • Segment 147 : While True then break
    • Segment 148 : Nested Loops
    • Segment 149 : Creating a Multiplication Table
    • Segment 150 : Generating Random Numbers
    • Segment 151 : Craps Game - Stage 1
    • Segment 152 : Craps Game - Stage 2
    • Segment 153 : Implementing Trivia Game with Loop
    • Segment 154 : Module 9 Summary
    • Segment 155 : Exercises 1-13
    • Segment 156 : Exercise 14
    • Segment 157 : Exercise 15
  • 10

    Module 10: Lists Comprehensions

    • Segment 158 : List Comprehensions
    • Segment 159 : List Comprehension Examples
    • Segment 160 : Conditional List Comprehensions
    • Segment 161 : Conditional List Comprehension Examples
    • Segment 162 : Ternary Conditional Operator in List Comprehensions
    • Segment 163 : Complex List Comprehensions
    • Segment 164 : Nested for-loops within List Comprehensions
    • Segment 165 : List Comprehension Summary
    • Segment 166 : Project Solutions
  • 11

    Module 11: Built-in Functions

    • Segment 167 : Intro to Functions
    • Segment 168 : Built-in Functions
    • Segment 169 : The any and all Functions
    • Segment 170 : The chr and ord Functions
    • Segment 171 : The dir Function
    • Segment 172 : The print Function
    • Segment 173 : The len Function
    • Segment 174 : The sorted Function
    • Segment 175 : Summary of Built-in Functions
    • Segment 176 : The id Function
    • Segment 177 : Project Solutions
  • 12

    Module 12: User-Defined Functions

    • Segment 178 : Intro to User-Defined Functions
    • Segment 179 : Functions that Explicitly Return a Value
    • Segment 180 : Calculating the Square Root of a Number
    • Segment 181 : Defining Functions with Parameters
    • Segment 182 : Defining a Function with Multiple Parameters
    • Segment 183 : Different Ways to Call the Function using Parameter Names
    • Segment 184 : Using Pre-Assigned Variables as Arguments
    • Segment 185 : Positional and Keyword Arguments
    • Segment 186 : Keyword-only Arguments
    • Segment 187 : Default Parameter Values
    • Segment 188 : Positional-only Arguments
    • Segment 189 : Built-in Functions with Positional-only and Keyword-only Arguments
    • Segment 190 : Documenting Functions with Docstrings
    • Segment 191 : Functions are Objects
    • Segment 192 : Function Attributes and Methods
    • Segment 193 : Some Built-in Functions are not Functions
    • Segment 194 : Anonymous Functions
    • Segment 195 : Use-Cases for Anonymous Functions
    • Segment 196 : The map Function
    • Segment 197 : The filter Function
    • Segment 198 : Refactoring Code
    • Segment 199 : Rules of Thumb for User-Defined Functions
    • Segment 200 : Testing Code with assert Statements
    • Segment 201 : User-Defined Functions Summary
    • Segment 202 : Project - Exercises 1-9
    • Segment 203 : Project - Exercises 10-13
  • 13

    Module 13: Tic-Tac-Toe

    • Segment 204 : Tic-Tac-Toe
    • Segment 205 : Create the Board
    • Segment 206 : Output the Board
    • Segment 207 : Get Player Input
    • Segment 208 : Change Turn
    • Segment 209 : Validate Open Position
    • Segment 211 : Place Mark on Board
    • Segment 212 : Check for a Row Winner
    • Segment 213 : Check for a Column Winner
    • Segment 214 : Check for Diagonal Winner
    • Segment 215 : Check for a Winner
    • Segment 216 : Check for Cats Game
    • Segment 217 : Check for End of Game
    • Segment 218 : Play the game
  • 14

    Module 14: Tuples, Sets, and Dictionaries

    • Segment 219 : Data Structures
    • Segment 220 : Tuples
    • Segment 221 : More on tuple Creation
    • Segment 222 : Ambiguous tuple Situations
    • Segment 223 : Converting Iterables to tuples
    • Segment 224 : Selecting Items from a tuple
    • Segment 225 : Using Operators with tuples
    • Segment 226 : Tuple Methods
    • Segment 227 : Attempting to Mutate Tuples
    • Segment 228 : Why use tuples when lists are more flexible
    • Segment 229 : Sets
    • Segment 230 : Sets can only Contain Hashable Objects
    • Segment 231 : Accessing Items in a Set
    • Segment 232 : Using the set Constructor
    • Segment 233 : Finding the Number of Elements in a set
    • Segment 234 : Set Membership Checking
    • Segment 235 : Extremely Fast Membership Checking
    • Segment 236 : Mathematical Set Operations
    • Segment 237 : Set Methods
    • Segment 238 : The Birthday Paradox
    • Segment 239 : Estimating the Probability for each Group
    • Segment 240 : Estimating Probabilities for Many Groups
    • Segment 241 : Plotting the Probabilities
    • Segment 242 : Dictionaries
    • Segment 243 : Dictionary Keys must be Hashable
    • Segment 244 : Dictionary Constructor
    • Segment 245 : Creating Empty Dictionaries
    • Segment 246 : Selecting Values in a Dictionary
    • Segment 247 : Dictionary Membership Checking
    • Segment 248 : Dictionary get Method
    • Segment 249 : Retrieving the Keys and Values Separately
    • Segment 250 : Get the Items as an Iterable
    • Segment 251 : pop and popitem Methods
    • Segment 252 : Mutating Dictionaries
    • Segment 253 : Iterating through Dictionaries
    • Segment 254 : Looping to Find the Average Score
    • Segment 255 : Tuple, Set, and Dictionary Comprehensions
    • Segment 256 : Dictionary Comprehension Examples
    • Segment 257 : Unpacking Iterables
    • Segment 258 : Single-line Unpacking
    • Segment 259 : Partial Unpacking with Star Notation
    • Segment 260 : The zip Function
    • Segment 261 : Finding the Lowest Score
    • Segment 262 : Summary
    • Segment 263 : Module 14 Exercises
  • 15

    Module 15: Python Modules

    • Segment 264 : Python Modules
    • Segment 265 : The Random Module
    • Segment 266 : Different Ways to Use the Import Statement
    • Segment 267 : Alias Names when Importing with as
    • Segment 268 : Import All Names from a Module
    • Segment 269 : Batteries Included
    • Segment 270 : The re Module - Regular Expressions
    • Segment 271 : The datetime Module
    • Segment 272 : The calendar Module
    • Segment 273 : The time Module
    • Segment 274 : The collections Module
    • Segment 275 : The copy Module
    • Segment 276 : The math Module
    • Segment 277 : The fractions Module
    • Segment 278 : The statistics Module
    • Segment 279 : The sys Module
    • Segment 280 : Way More to the Standard Library
    • Segment 281 : Third-Party Libraries
    • Segment 282 : Summary - Python Modules
    • Segment 283 : Module 15 Exercises
  • 16

    Module 16: User-Defined Python Modules

    • Segment 284 : User-Defined Python Modules
    • Segment 285 : Creating our own Python Modules
    • Segment 286 : Creating the my_array Module
    • Segment 287 : Using my_array_solutions
    • Segment 288 : Opening my_array in VS Code
    • Segment 289 : Unit Testing
    • Segment 290 : Running the Unit Tests
    • Segment 291 : Completing add_constant
    • Segment 292 : Sub, Mul, Div Constant
    • Segment 293 : The zip Function
    • Segment 294 : Add, Sub, Mul, and Div Arrays
    • Segment 295 : The Dot Product
    • Segment 296 : Importing a User-Defined Module
    • Segment 297 : Summary Module 16
  • 17

    Module 17: Errors and Exceptions

    • Segment 298 : Errors and Exceptions
    • Segment 299 : Syntax Errors
    • Segment 300 : Errors vs Exceptions
    • Segment 301 : The KeyError
    • Segment 302 : The IndexError
    • Segment 303 : The TypeError
    • Segment 304 : ValueError
    • Segment 305 : The Attribute Error
    • Segment 306 : Other Exceptions
    • Segment 307 : Purposefully Raising Exceptions
    • Segment 308 : The isinstance Bult-in Function
    • Segment 309 : Raising Errors on Bad Input
    • Segment 310 : Handling Exceptions
    • Segment 311 : Catching All Errors
    • Segment 312 : Catching Multiple Different Errors
    • Segment 313 : The else and finally Blocks
    • Segment 314 : More on Exceptions
    • Segment 315 : Summary
    • Segment 316 : Exercise Solutions
  • 18

    Module 18: Files

    • Segment 317 : Files
    • Segment 318 : Opening and Reading Text Files
    • Segment 319 : Reading Continues Forward
    • Segment 320 : Closing a File
    • Segment 321 : Automated File Closing
    • Segment 322 : Reading in one line at a time
    • Segment 323 : Reading in each Line into a List
    • Segment 324 : Iterating through the lines in a file
    • Segment 325 : Reading in Files in Different Locations
    • Segment 326 : Reading in Non-Text Files
    • Segment 327 : Writing to a File
    • Segment 328 : Appending to Files
    • Segment 329 : Playing Bingo
    • Segment 330 : Reading in the Boards
    • Segment 331 : Checking the Winner
    • Segment 332 : Get All Winning Board Combinations
    • Segment 333 : Summary
    • Segment 334 : Exercises
  • 19

    Module 19: Classes

    • Segment 335 : Classes
    • Segment 336 : Creating New Types
    • Segment 337 : Creating a Car Instance
    • Segment 338 : Instance Methods
    • Segment 339 : Object-Oriented Programming
    • Segment 340 : Initializing an Instance
    • Segment 341 : The Parameter Names Don_t Need to Match the Attribute Names
    • Segment 342 : Mutating Attributes
    • Segment 343 : Changing Attributes After Instantiation
    • Segment 344 : Return a Value from a Method
    • Segment 345 : Docstrings for Classes
    • Segment 346 : Calling Method from Attributes within your Class
    • Segment 347 : Setting an Attribute to an Instance from a User-Defined Class
    • Segment 348 : Object Composition
    • Segment 349 : The Dice Class
    • Segment 350 : Single Responsibility Principle
    • Segment 351 : Craps with Classes
    • Segment 352 : Playing Craps from the Command Line
    • Segment 353 : What does if __name__ == ___main___ mean_
    • Segment 354 : More to Classes
    • Segment 355 : Summary
  • 20

    Module 20: Texas Holdem Poker

    • Segment 356 : Texas Holdem Poker
    • Segment 357 : Four Rounds in a Hand
    • Segment 358 : The First Action
    • Segment 359 : Round Two - The Flop
    • Segment 360 : Round Three - The Turn
    • Segment 361 : Round Four - The River
    • Segment 362 : The Showdown
    • Segment 363 : Rules Summary
    • Segment 364 : Five-card Poker Hand Ranking
    • Segment 365 : Evaluating Hands within the Same Ranking Category
    • Segment 366 : Planning the Game Development
    • Segment 367 : The Card Class
    • Segment 368 : Displaying a Nice Text Output of the Card
    • Segment 369 : The __repr__ Special Method
    • Segment 370 : The __eq__ Special Method
    • Segment 371 : The Deck Class
    • Segment 372 : Making your Object Work with the Square Brackets
    • Segment 373 : The Hand Class
    • Segment 374 : The Evaluator Class
    • Segment 375 : Sorted Ranks
    • Segment 376 : The Full Evaluator Class
    • Segment 377 : The Player Class
    • Segment 378 : The Computer and Human Classes
    • Segment 379 : Subclasses
    • Segment 380 : The Poker Class
    • Segment 381 : Playing Texas Holdem Poker
    • Segment 382 : Unit Tests
    • Segment 383 :Project - Artificial Intelligence
    • Segment 384 :Exercise 1 - Calculating a Preflop Score
    • Segment 385 :Exercise 2 - Preflop Score List
    • Segment 386 :Exercise 3 - Calculating Preflop Rank
    • Segment 387 :Exercise 4 - Relative Hand Ranking After the Flop
    • Segment 388 :Exercise 5 - Implementing the Artificial Intelligence