Harvard CS50’s Introduction to Programming with Python – Full University Course
Summary
This course from Harvard University, taught by Dr. David Meen, introduces programming in Python for students of all experience levels. It covers fundamental concepts like functions, variables, conditionals, loops, exceptions, libraries, and file I/O. The course also delves into testing, regular expressions, object-oriented programming, and building custom classes and modules. Practical applications and problem-solving techniques are emphasized throughout, equipping students with the vocabulary and skills for future programming endeavors in various fields.
Key Insights
Functions can have return values.
Functions, like 'input', can return values. These return values can be stored in variables for later use.
F-strings allow dynamic formatting within strings.
F-strings (formatted string literals), prefixed with 'f', allow embedding expressions inside strings using curly braces '{}' for dynamic content.
Functions can be chained together for complex operations.
Multiple string methods or functions can be chained (e.g., name.strip().title()) to apply operations sequentially, simplifying code.
'else if' ('elif') allows sequential checks.
'elif' checks subsequent conditions only if prior 'if' or 'elif' conditions were false, creating mutually exclusive checks and reducing redundant questions.
Loops allow code to repeat actions.
Repeating the same line of code multiple times is inefficient; loops provide a better structure for repetition.
A 'for' loop iterates over a sequence.
'for' loops iterate over items in a sequence (like lists or ranges), automatically handling variable assignment and iteration.
'try-except' blocks handle potential errors.
The 'try-except' structure attempts to execute code in the 'try' block and executes the 'except' block if a specified error (e.g., 'ValueError') occurs.
Loops can provide robust user input validation.
Using 'while True' with 'break' and 'continue' allows a program to repeatedly prompt the user for input until valid data is provided.
Functions can encapsulate error-handling logic.
Creating functions like 'get_int' encapsulates the logic for prompting, validating, and returning valid integer input, promoting reusability and cleaner code.
The 'random' library provides functions for randomness.
'random.choice(sequence)' selects a random element from a sequence, 'random.randint(a, b)' gets a random integer within a range.
APIs (Application Programming Interfaces) allow code to interact with services.
APIs enable programs to communicate with external services (often web-based) to retrieve or send data, like accessing the iTunes music database.
Regular expressions (regex) are patterns for matching text.
Regex provide a powerful way to define patterns for validating, searching, or manipulating text data.
Parentheses '()' capture matched groups.
Parentheses in a regex pattern create capturing groups, allowing extraction of specific matched parts of the string.
OOP models real-world entities using classes and objects.
Object-Oriented Programming (OOP) uses classes (blueprints) to create objects (instances) representing entities, encapsulating data (attributes) and behavior (methods).
Unpacking assigns multiple values from sequences or iterables.
Unpacking assigns elements from sequences (lists, tuples) or dictionaries (using '**') to multiple variables simultaneously.
'with open(...) as ...:' ensures automatic file closing.
Using the 'with open(...)' construct is the preferred Pythonic way to handle files, as it automatically closes the file even if errors occur.
Iterating directly over a file object reads line by line.
A 'for line in file:' loop reads a file one line at a time, which is more memory-efficient for large files than 'readlines()'.
'csv.DictReader()' reads CSV rows into dictionaries.
'csv.DictReader()' reads CSV data where the first row defines keys, allowing access to fields by name (e.g., 'student['name']').
'(...)' captures groups within a pattern.
Parentheses '()' create capturing groups, allowing specific parts of the matched pattern to be extracted or referenced.
Regex patterns can be refined for specific validation.
By combining metacharacters, character sets, anchors, and quantifiers, regex can precisely define complex patterns for validation or extraction.
Built-in types like 'int', 'str', 'list', 'dict' are classes.
Fundamental Python data types are implemented as classes, meaning operations like 'int()', 'str()', 'list()', and dictionary manipulation use class methods.
Object-oriented principles aid in structuring complex code.
OOP helps organize code by modeling real-world entities, encapsulating related data and behavior, leading to more maintainable and scalable software.
Generators ('yield') produce values lazily, one at a time.
Generator functions use 'yield' to produce a sequence of values iteratively, allowing processing of large datasets without consuming excessive memory.
Sections
Introduction to Programming with Python
Welcome to CS50's Introduction to Programming with Python.
The course is taught by Dr. David Meen and is designed for students with or without prior programming experience who want to learn Python.
Course structure covers functions, variables, conditionals, loops, exceptions, libraries, and file I/O.
Topics include understanding functions and variables for solving smaller problems, conditionals for logical decisions, loops for repetition, exceptions for error handling, libraries for reusing code, unit tests for code validation, file I/O for persistent storage, regular expressions for pattern matching, and object-oriented programming. The course also touches on procedural and functional programming paradigms.
No prior programming experience is required.
The course assumes no prior programming background and can be taken before, during, or after CS50.
Weekly lectures introduce concepts followed by problem sets for application.
Each week features lectures on concepts, followed by programming projects (problem sets) to apply learned lessons to real-world problems across various disciplines.
Week 1: Functions and Variables - Your First Program
Code is just text, written in a text editor.
You don't need fancy software to write code; a simple text editor suffices. Tools like Visual Studio Code offer helpful features.
Python programs typically end with '.py'.
File names for Python programs generally end with '.py' to indicate the language to the computer.
The 'print' function displays output.
The 'print' function displays specified output (e.g., 'Hello, World!') to the screen. Parentheses indicate a function call, and quotes denote a string literal.
Python interpreters translate code into machine language.
Python is both a language and an interpreter. The interpreter reads the code and translates it into zeros and ones that the computer understands.
Functions are actions or verbs in a program.
Functions like 'print' perform actions. Arguments are inputs to functions that influence their behavior.
Bugs are mistakes in programs.
Mistakes in code are called bugs. Debugging is the process of finding and fixing these bugs. Syntax errors, like missing parentheses, are common.
Text editors offer helpful features like color-coding.
Text editors like VS Code provide features like syntax highlighting (color-coding code) and auto-completion, making coding easier.
The 'input' function gets user input.
The 'input' function prompts the user for input, which is always received as a string. It can simplify code by combining printing and prompting.
Functions can have return values.
Functions, like 'input', can return values. These return values can be stored in variables for later use.
Variables are containers for values.
Variables, like 'name', act as containers in computer memory to store values, similar to mathematical variables, but can store various data types like text.
The '=' sign is the assignment operator.
In Python, a single '=' sign signifies assignment, copying the value from the right to the variable on the left, not mathematical equality.
Comments explain code using the '#' symbol.
Comments, denoted by '#', are notes for humans that the computer ignores. They help explain code's intent and purpose.
Pseudocode outlines program logic using English.
Pseudocode uses human language to express program logic algorithmically, helping to structure thoughts even before writing actual code.
Strings (str) are sequences of text.
Strings, technically called 'str' in Python, are data types representing sequences of text.
Functions can take multiple arguments separated by commas.
Functions like 'print' can accept multiple arguments, separated by commas. Python automatically inserts a space between arguments passed to 'print' by default.
'sep' and 'end' control print function's behavior.
The 'print' function has parameters like 'sep' (separator between arguments, defaults to space) and 'end' (what to print at the end, defaults to newline '\n').
Named parameters are optional and specified by name.
Named parameters (like 'sep' or 'end') are optional and can be used by name at the end of a function call.
Escape characters (like '\n') have special meaning.
Escape characters, like '\n' for newline, are used within strings to represent non-printable characters or special sequences.
F-strings allow dynamic formatting within strings.
F-strings (formatted string literals), prefixed with 'f', allow embedding expressions inside strings using curly braces '{}' for dynamic content.
String methods like 'strip', 'capitalize', and 'title' clean and reformat text.
'strip' removes whitespace, 'capitalize' capitalizes the first letter, and 'title' capitalizes the first letter of each word.
Functions can be chained together for complex operations.
Multiple string methods or functions can be chained (e.g., name.strip().title()) to apply operations sequentially, simplifying code.
Comments improve code readability and organization.
Comments, using '#', document code for humans, explaining intent and logic, crucial for longer programs.
'split' method breaks strings into substrings based on a delimiter.
The 'split' method, when given a delimiter (like a space or comma), divides a string into a list of substrings.
Week 2: Conditionals - Making Decisions in Code
Comparison symbols include >, >=, <, <=, ==, and !=
These symbols are used in Boolean expressions to compare values, resulting in True or False.
The 'if' keyword introduces conditional logic.
An 'if' statement executes code only if a Boolean expression (a question with a True/False answer) is true. Indentation is crucial in Python to define code blocks.
'else if' ('elif') allows sequential checks.
'elif' checks subsequent conditions only if prior 'if' or 'elif' conditions were false, creating mutually exclusive checks and reducing redundant questions.
'else' acts as a catch-all for unhandled conditions.
An 'else' block executes if none of the preceding 'if' or 'elif' conditions were met, providing a default path.
Flowcharts visualize program logic and control flow.
Flowcharts use shapes like ovals (start/stop), rectangles (statements), and diamonds (questions) to diagram a program's logic.
Logical operators 'or' and 'and' combine conditions.
Boolean expressions can be combined using 'or' (either condition is true) and 'and' (both conditions must be true).
The 'match' statement offers an alternative to 'if-elif-else'.
'match' (similar to 'switch' in other languages) provides a structured way to handle multiple possible cases based on a variable's value, using 'case' statements.
Indentation is mandatory in Python for code blocks.
Python strictly uses indentation (typically 4 spaces or a tab) to define code blocks, unlike languages using curly braces.
The modulo operator (%) gives the remainder of a division.
The '%' operator calculates the remainder, useful for determining even/odd numbers (remainder 0 when divided by 2 means even).
Week 3: Loops - Repeating Actions
Loops allow code to repeat actions.
Repeating the same line of code multiple times is inefficient; loops provide a better structure for repetition.
The 'while' loop repeats as long as a condition is true.
'while' loops continue executing code as long as a Boolean expression remains true. An infinite loop occurs if the condition never becomes false.
Variables in loops must be updated to avoid infinite loops.
To prevent infinite loops, the variable controlling the 'while' condition (e.g., 'i') must be updated within the loop (e.g., 'i = i - 1' or 'i = i + 1').
Counting from zero is a common programming convention.
Starting counts from zero (e.g., 'i = 0') is conventional in programming and often simplifies logic, especially with zero-based indexing.
'+=' and '-=' are shorthand for incrementing/decrementing.
Shorthand operators like '+= 1' (add 1) and '-= 1' (subtract 1) provide concise ways to update variables.
A 'for' loop iterates over a sequence.
'for' loops iterate over items in a sequence (like lists or ranges), automatically handling variable assignment and iteration.
Lists are ordered collections of values.
Lists, defined with square brackets '[]', store ordered collections of items and are a fundamental data type in Python.
'range(n)' generates a sequence of numbers from 0 up to (but not including) n.
The 'range(n)' function generates a sequence of numbers starting from 0 up to, but not including, n. It's useful for controlling loop iterations.
'_ ' is a conventional variable name for unused values.
A single underscore '_' is often used as a variable name when its value is needed for a process (like in a loop) but not used elsewhere, signaling it's intentionally ignored.
String multiplication repeats strings.
Multiplying a string by an integer (e.g., 'meow' * 3) repeats the string that many times.
'continue' skips to the next loop iteration.
The 'continue' keyword skips the rest of the current loop iteration and proceeds to the next.
'break' exits the loop entirely.
The 'break' keyword terminates the loop immediately, regardless of the loop's condition.
Nested loops can create multi-dimensional structures.
Loops can be nested within each other to create multi-dimensional structures or perform operations requiring nested iteration (e.g., printing a grid).
Dictionaries associate keys with values.
Dictionaries ('dict'), using curly braces '{}', store key-value pairs, allowing efficient lookup and association of data.
'Len()' returns the length of a sequence.
The 'len()' function returns the number of items in a sequence (like lists or strings).
Week 4: Exceptions - Handling Errors Gracefully
Syntax errors are mistakes in code structure.
Syntax errors, like typos or missing punctuation, prevent code from running and must be fixed manually.
Runtime errors occur during program execution.
Runtime errors happen while the program is running, often due to unexpected input or conditions.
'try-except' blocks handle potential errors.
The 'try-except' structure attempts to execute code in the 'try' block and executes the 'except' block if a specified error (e.g., 'ValueError') occurs.
'ValueError' occurs with invalid data conversions.
A 'ValueError' is raised when a function receives an argument of the correct type but an inappropriate value (e.g., trying to convert 'cat' to an integer).
'NameError' occurs when a variable or function is not defined.
A 'NameError' indicates that a variable or function was used before it was defined or is out of scope.
'IndexError' occurs with out-of-bounds list access.
An 'IndexError' happens when trying to access a list or sequence element at an index that does not exist.
'TypeError' occurs with incompatible data types.
A 'TypeError' arises when an operation or function is applied to an object of an inappropriate type (e.g., multiplying a string by a string).
'else' in 'try-except' executes if no exception occurred.
The 'else' block in a 'try-except' structure runs only if the 'try' block completes without raising an exception.
Code should be indented within 'try', 'except', and 'else' blocks.
Indentation is crucial to define the scope of code within 'try', 'except', and 'else' blocks.
Loops can provide robust user input validation.
Using 'while True' with 'break' and 'continue' allows a program to repeatedly prompt the user for input until valid data is provided.
Functions can encapsulate error-handling logic.
Creating functions like 'get_int' encapsulates the logic for prompting, validating, and returning valid integer input, promoting reusability and cleaner code.
Raising exceptions allows explicit error signaling.
The 'raise' keyword allows programmers to explicitly trigger exceptions (e.g., 'ValueError') with custom messages when pre-defined conditions are not met.
Properties (getters/setters) control attribute access and modification.
Properties use decorators ('@property', '@<attribute>.setter') to manage access to attributes, allowing for validation and controlled modification.
Week 5: Libraries - Reusing Code
Libraries (modules) are collections of pre-written code.
Libraries, or modules, provide reusable functions and features, promoting efficiency and avoiding code duplication.
'import' keyword loads modules into a program.
The 'import' keyword makes the functions and variables within a module available for use in the current script.
'from ... import ...' imports specific items from a module.
Using 'from module import item' imports only specific functions or variables, allowing direct use without module prefixing (e.g., 'choice()' instead of 'random.choice()').
The 'random' library provides functions for randomness.
'random.choice(sequence)' selects a random element from a sequence, 'random.randint(a, b)' gets a random integer within a range.
'random.shuffle(list)' shuffles a list in-place.
The 'shuffle' function randomizes the order of elements within a list directly, without returning a new list.
The 'statistics' library offers statistical functions.
Python's 'statistics' module provides functions like 'mean' for calculating averages.
Command-line arguments provide input at execution.
Arguments can be passed to a Python script on the command line (e.g., 'python script.py arg1 arg2'), offering an alternative to interactive input.
The 'sys' module accesses system-specific parameters.
'sys.argv' is a list containing command-line arguments, where index 0 is the script name, and subsequent indices are the arguments provided.
'IndexError' occurs when accessing non-existent list elements.
Accessing a list index outside its bounds raises an 'IndexError'.
Slicing lists extracts subsets of elements.
List slicing (e.g., 'list[start:end]') creates a new list containing a portion of the original list. Omitting 'start' or 'end' defaults to the beginning or end.
'Pip' is Python's package manager for installing libraries.
Pip allows easy installation of third-party libraries (packages) like 'requests' or 'cow' directly from the command line.
APIs (Application Programming Interfaces) allow code to interact with services.
APIs enable programs to communicate with external services (often web-based) to retrieve or send data, like accessing the iTunes music database.
JSON (JavaScript Object Notation) is a standard data exchange format.
JSON is a text-based format, using key-value pairs, curly braces for objects, and square brackets for arrays, commonly used for API data.
The 'requests' library makes HTTP web requests.
'requests.get(url)' fetches data from a web URL, and '.json()' parses the JSON response into a Python dictionary.
Packages can be organized into folders (modules within packages).
A folder containing an '__init__.py' file is treated as a Python package, allowing structured organization of modules.
Week 6: Regular Expressions - Pattern Matching
Regular expressions (regex) are patterns for matching text.
Regex provide a powerful way to define patterns for validating, searching, or manipulating text data.
're.search(pattern, string)' finds a pattern anywhere in a string.
The 're.search()' function attempts to find a match for the pattern anywhere within the given string.
Regex special characters have specific meanings.
Special characters like '.', '*', '+', '?', and '{}' define pattern matching rules (any char, zero/more, one/more, zero/one, specific count repetitions).
Escape character '\' is used for literal special characters.
A backslash '\' before a special regex character (like '.' or '*') treats it as a literal character, not a metacharacter.
'r' prefix creates raw strings, treating backslashes literally.
Raw strings (e.g., r'C:\path') prevent backslashes from being interpreted as escape sequences, essential for regex patterns.
'^' and '$' anchor patterns to the start and end of strings.
'^' matches the beginning of the string, and '$' matches the end, ensuring a full pattern match.
Character sets '[...]' define allowed characters.
Square brackets define a set of characters for matching (e.g., '[a-z0-9_]' allows letters, numbers, or underscore).
'[^...]' negates a character set.
A caret '^' at the start of a character set (e.g., '[^@]+') matches any character *except* those listed.
'\w' matches word characters (alphanumeric + underscore).
'\w' is a shorthand for '[a-zA-Z0-9_]', matching letters, numbers, and underscore.
'\d' matches decimal digits.
'\d' matches any digit (0-9).
'\s' matches whitespace characters.
'\s' matches characters like spaces, tabs, and newlines.
're.sub(pattern, replacement, string)' replaces pattern occurrences.
're.sub()' finds all occurrences of a pattern in a string and replaces them with a specified replacement string.
Parentheses '()' capture matched groups.
Parentheses in a regex pattern create capturing groups, allowing extraction of specific matched parts of the string.
're.match()' attempts to match only at the beginning of a string.
're.match()' checks for a pattern match only at the very start of the string.
're.fullmatch()' requires the entire string to match the pattern.
're.fullmatch()' insists that the entire string must match the pattern from beginning to end.
're.ignorecase' flag makes matching case-insensitive.
The 're.IGNORECASE' flag allows pattern matching to disregard case differences (e.g., 'A' matches 'a').
Week 7: Object-Oriented Programming - Modeling the World
OOP models real-world entities using classes and objects.
Object-Oriented Programming (OOP) uses classes (blueprints) to create objects (instances) representing entities, encapsulating data (attributes) and behavior (methods).
Classes define blueprints for objects.
A class is a template defining the structure (attributes) and behavior (methods) of a type of object.
Objects are instances of classes.
Objects, also called instances, are specific creations based on a class blueprint.
'__init__' initializes object attributes.
The '__init__' method (a special 'dunder' method) is automatically called when creating an object, used to set initial values for its attributes (instance variables).
'self' refers to the current object instance.
'self' is a convention in Python methods to refer to the specific object instance the method is being called on.
Attributes store data within objects.
Attributes (or instance variables), like 'name' or 'house', store data specific to each object.
Methods define object behavior.
Methods are functions defined within a class that operate on the object's data (attributes).
'__str__' provides a string representation for objects.
The '__str__' method defines how an object should be represented as a string, used by functions like 'print()'.
Tuples are immutable sequences.
Tuples, created with parentheses or commas, are immutable ordered collections; their contents cannot be changed after creation.
Lists are mutable sequences.
Lists, defined with square brackets, are mutable ordered collections, allowing changes to their elements after creation.
Dictionaries store key-value pairs.
Dictionaries ('dict'), using curly braces, associate unique keys with values for efficient data retrieval.
Unpacking assigns multiple values from sequences or iterables.
Unpacking assigns elements from sequences (lists, tuples) or dictionaries (using '**') to multiple variables simultaneously.
The '*' and '**' operators unpack iterables and dictionaries.
'*args' collects a variable number of positional arguments into a tuple, and '**kwargs' collects variable keyword arguments into a dictionary.
Map applies a function to each item in an iterable.
'map(function, iterable)' applies a given function to every element of a sequence, returning an iterator of results.
List comprehensions create lists concisely.
List comprehensions offer a compact syntax (e.g., '[expression for item in iterable if condition]') to create lists based on existing iterables.
'filter()' creates an iterator from elements that satisfy a condition.
'filter(function, iterable)' returns an iterator yielding those items from the iterable for which the function returns True.
Classes can inherit functionality from parent classes (inheritance).
Inheritance allows a class ('child' or 'subclass') to inherit attributes and methods from another class ('parent' or 'superclass'), promoting code reuse and establishing hierarchies.
'super().method()' calls a parent class's method.
The 'super()' function provides a way to call methods of the parent or superclass from within a child class's method.
Class variables are shared among all instances of a class.
Class variables are defined within the class but outside methods; they are shared by all objects created from that class.
'@classmethod' defines methods bound to the class, not instances.
Class methods receive the class itself (conventionally named 'cls') as the first argument, allowing operations on the class level, not a specific instance.
'@property' creates managed attributes (getters/setters).
Decorators like '@property' and '@<attribute>.setter' allow defining methods that act like attributes, enabling controlled access and validation.
Operator overloading allows custom behavior for operators.
Special methods (dunder methods like '__add__') allow classes to define how standard operators (like '+') behave with objects of that class.
Week 8: File I/O - Persistent Data Storage
File I/O allows reading from and writing to files.
File Input/Output (I/O) enables programs to persistently store data by writing to files or load data by reading from files.
'open()' function accesses files.
The 'open()' function creates a file handle to interact with a file, specifying the filename and mode ('w' for write, 'r' for read, 'a' for append).
'w' mode overwrites existing files or creates new ones.
Opening a file in 'w' (write) mode will create the file if it doesn't exist or overwrite its contents if it does.
'a' mode appends data to existing files.
Opening a file in 'a' (append) mode adds new data to the end of the file without overwriting existing content.
'r' mode reads data from files.
Opening a file in 'r' (read) mode allows accessing its content.
'.close()' method saves and closes file changes.
Calling 'file.close()' saves any changes and releases the file handle, ensuring data is written persistently.
'with open(...) as ...:' ensures automatic file closing.
Using the 'with open(...)' construct is the preferred Pythonic way to handle files, as it automatically closes the file even if errors occur.
'file.write()' writes data to a file.
The 'write()' method appends a string to the file. Newlines ('\n') must be manually added for separate lines.
'file.readlines()' reads all lines into a list.
The 'readlines()' method reads all lines from a file and returns them as a list of strings, each potentially including a newline character.
Iterating directly over a file object reads line by line.
A 'for line in file:' loop reads a file one line at a time, which is more memory-efficient for large files than 'readlines()'.
'.rstrip()' removes trailing whitespace from strings.
The 'rstrip()' method removes trailing whitespace (including newlines) from the end of a string.
CSV (Comma Separated Values) is a common structured file format.
CSV files store data in plain text, with values separated by commas and records (rows) separated by newlines. It's widely compatible with spreadsheets.
'csv.reader()' parses CSV files.
The 'csv.reader()' function handles parsing CSV files, correctly interpreting delimiters and quoted fields.
'csv.DictReader()' reads CSV rows into dictionaries.
'csv.DictReader()' reads CSV data where the first row defines keys, allowing access to fields by name (e.g., 'student['name']').
CSV writers handle escaping special characters automatically.
When writing to CSV, libraries like 'csv.writer' or 'csv.DictWriter' automatically quote fields containing delimiters (like commas) to maintain data integrity.
Week 8: Regular Expressions - Pattern Matching
Regular expressions define text patterns.
Regex (Rex) are powerful patterns used for validating, searching, and manipulating text data, especially user input.
The 're' module provides regex functionality in Python.
The 're' module offers functions like 'search', 'match', 'sub', and 'findall' for working with regular expressions.
're.search(pattern, string)' finds a pattern anywhere.
're.search()' looks for the pattern anywhere within the string and returns a match object if found, otherwise None.
Regex metacharacters define pattern rules.
Special characters like '.', '*', '+', '?', '^', '$', '[]', '\w', '\d', '\s' have specific meanings in regex patterns.
'|' signifies 'OR' in regex patterns.
The vertical bar '|' acts as an OR operator, allowing matching of alternative patterns (e.g., 'http|https').
'(...)' captures groups within a pattern.
Parentheses '()' create capturing groups, allowing specific parts of the matched pattern to be extracted or referenced.
'?:' creates non-capturing groups.
A non-capturing group '(?:...)' groups elements without capturing them, useful for applying quantifiers or logic without storing the matched substring.
're.sub(pattern, replacement, string)' replaces matches.
're.sub()' finds all occurrences of a pattern in a string and replaces them with a specified replacement.
're.match()' checks for a pattern only at the string's start.
're.match()' attempts to match the pattern strictly from the beginning of the string.
're.fullmatch()' requires the entire string to match.
're.fullmatch()' ensures the entire string conforms exactly to the provided pattern.
're.IGNORECASE' flag enables case-insensitive matching.
The 're.IGNORECASE' flag makes regex matching disregard case differences.
Regex patterns can be anchored to string start ('^') and end ('$').
Anchors '^' and '$' ensure a pattern matches only at the beginning or end of the string, respectively.
'\w' matches word characters (alphanumeric + underscore).
'\w' is a shorthand for [a-zA-Z0-9_].
'\.' matches a literal dot.
A backslash '\' escapes special characters, allowing them to be matched literally (e.g., '\.' matches a period).
Raw strings (r'...') prevent backslash interpretation.
Prefixing a string with 'r' creates a raw string, treating backslashes literally, which is crucial for many regex patterns.
Regex patterns can be refined for specific validation.
By combining metacharacters, character sets, anchors, and quantifiers, regex can precisely define complex patterns for validation or extraction.
Week 8: Object-Oriented Programming - Modeling the World
Classes define blueprints for objects.
Classes act as templates for creating objects, defining their attributes (data) and methods (behavior).
'__init__' method initializes objects.
The '__init__' method, a constructor, initializes an object's attributes when it's created.
'self' refers to the current object instance.
'self' is a convention used within methods to refer to the specific object instance the method is called on.
Attributes store object-specific data.
Attributes (instance variables), accessed via dot notation (e.g., 'object.attribute'), hold data unique to each object.
Methods define object behavior.
Methods are functions defined within a class that perform actions related to the object.
Raising exceptions ensures program integrity.
The 'raise' keyword allows programmers to explicitly trigger exceptions (like 'ValueError') when specific error conditions are met, rather than letting the program crash.
Properties control attribute access with getters and setters.
Properties, using decorators like '@property', manage attribute access, allowing for validation (setters) and controlled retrieval (getters).
Inheritance allows classes to inherit from parent classes.
Inheritance enables a 'child' class to inherit attributes and methods from a 'parent' class, promoting code reuse and creating hierarchical relationships.
'super().method()' calls parent class methods.
The 'super()' function allows child classes to call methods defined in their parent class, often used in '__init__'.
Class variables are shared across all instances.
Class variables are defined within the class but outside methods, shared by all objects created from that class.
'@classmethod' binds methods to the class, not instances.
Class methods receive the class itself ('cls') as the first argument, operating at the class level rather than on a specific object.
Operator overloading customizes operator behavior.
Special 'dunder' methods (e.g., '__add__') allow classes to define how standard operators (like '+') work with objects of that class.
Built-in types like 'int', 'str', 'list', 'dict' are classes.
Fundamental Python data types are implemented as classes, meaning operations like 'int()', 'str()', 'list()', and dictionary manipulation use class methods.
Object-oriented principles aid in structuring complex code.
OOP helps organize code by modeling real-world entities, encapsulating related data and behavior, leading to more maintainable and scalable software.
Additional Concepts and Tools
'Set' data type stores unique unordered elements.
Sets ('set') are unordered collections that automatically eliminate duplicate elements, useful for finding unique items.
Global variables are accessible throughout a module.
Variables declared outside functions (at the module level) are global and can be accessed (read) by any function within the module. Modifying them from within functions requires the 'global' keyword.
Type hints improve code readability and allow static analysis.
Type hints (e.g., 'n: int', '-> str') annotate variables and function signatures, enabling tools like 'mypy' to detect type-related errors before runtime.
Docstrings document functions and modules.
Docstrings (triple-quoted strings) provide standardized documentation for code elements, usable by introspection tools and for generating external documentation.
Command-line arguments provide program input at runtime.
Command-line arguments allow users to pass input directly when running a script, offering flexibility and automation possibilities.
'argparse' simplifies handling command-line arguments.
The 'argparse' module automates parsing complex command-line arguments, including flags (e.g., '-n'), handling validation, and generating help messages.
Unpacking assigns sequence elements to variables directly.
Unpacking allows assigning elements from sequences (lists, tuples) or dictionaries (using '**') directly to multiple variables.
'*' and '**' are used for variable arguments and unpacking.
'*args' collects positional arguments into a tuple, and '**kwargs' collects keyword arguments into a dictionary.
Generators ('yield') produce values lazily, one at a time.
Generator functions use 'yield' to produce a sequence of values iteratively, allowing processing of large datasets without consuming excessive memory.
Nested loops and comprehensions create complex data structures.
Nested loops and comprehensions (list, dictionary) enable concise creation and manipulation of multi-dimensional or complex data structures.
Chain operations for efficiency and readability.
Linking operations sequentially (e.g., 'name.strip().title()') can simplify code and improve efficiency.
Abstraction simplifies complex code using functions and classes.
Abstraction involves hiding complex implementation details behind simpler interfaces (functions, classes), allowing focus on higher-level logic.
Ask a Question
*Uses 1 Wisdom coin from your coin balance
