Mastering Python: A University Study Guide

Python is a high-level, interpreted language famous for its readability and

simplicity. The goal is to write clean, logical code. Unlike C, Python manages
memory for you, so your focus shifts from memory management to data structures and
program logic.
1. The Basics: Syntax & Control Flow
This is the foundation. Python is whitespace-sensitive; indentation matters!
* Variables: Dynamic typing. You don't declare a type.
* x = 10 (x is an int)
* x = "Hello" (Now x is a str)
* Operators:
* +, -, *, / (float division)
* // (integer division)
* % (modulus)
* ** (exponent, e.g., 2**3 is 8)
* Control Flow:
* if, elif, else: For decision making.
* for loop: Iterates over a sequence (like a list, string, or range).
* for item in my_list:
* for i in range(5): (Loops 0 through 4)
* while loop: Loops as long as a condition is true.
* Strings:
* Immutable (cannot be changed in place).
* Useful methods: .lower(), .upper(), .strip(), .split(), .join().
* f-Strings (Formatted Strings): The modern, easy way to format.
* name = "World"
* print(f"Hello, {name}!")
2. Core Data Structures (The "Pythonic" Way)
This is the most important part of Python. Mastering these is the key to success.
* Lists:
* What: An ordered, changeable (mutable) collection of items.
* Syntax: my_list = [1, "hello", 3.14]
* Key Methods: .append(item), .pop(), .sort(), .remove(item).
* Slicing: my_list[1:3] (gets items at index 1 and 2).
* Dictionaries (dicts):
* What: An unordered collection of key-value pairs. Very fast for lookups.
* Syntax: my_dict = {"name": "Alice", "id": 123}
* Access: my_dict["name"] (returns "Alice")
* Key Methods: .keys(), .values(), .items(), .get(key).
* Tuples:
* What: An ordered, unchangeable (immutable) collection. Used for data that
shouldn't be modified.
* Syntax: my_tuple = (1, 2, 3)
* Use: Faster than lists. Often used as keys in dictionaries.
* Sets:
* What: An unordered collection of unique items.
* Syntax: my_set = {1, 2, 3, 3, 3} (Result: {1, 2, 3})
* Use: Great for removing duplicates or checking for membership (if item in
my_set:).
3. Functions
The building blocks of reusable code.
* Definition: Uses the def keyword.
* def add_numbers(a, b):
* return a + b
* Arguments:
* Positional: add_numbers(5, 10)
* Keyword: add_numbers(a=5, b=10) (Order doesn't matter)
* Default: def greet(name="World"):
* Scope (LEGB Rule): How Python finds variables:
 * Local: Inside the current function.
* Enclosing: In the def of an outer function (for nested functions).
* Global: At the top level of the script.
* Built-in: Python's reserved names (like print, len).
* Lambda Functions: Small, anonymous, single-line functions.
* add = lambda x, y: x + y
4. Object-Oriented Programming (OOP)
How to bundle data (attributes) and functions (methods) into reusable blueprints.
* Class: The blueprint.
class Dog:
def __init__(self, name, age):
[Link] = name
[Link] = age
def bark(self):
print(f"{[Link]} says woof!")
* Object (Instance): An instance of the class.
* my_dog = Dog("Buddy", 4)
* __init__(self): The "constructor" method. It runs automatically when you create
a new object.
* self: Represents the instance of the class itself. You must include it as the
first parameter in every method.
* Inheritance: How one class can "inherit" methods and attributes from a parent
class.
5. Modules, Packages, & File I/O
How to use code from other files and the standard library.
* import: The keyword to bring in code.
* import math (Use: [Link](16))
* from math import sqrt (Use: sqrt(16))
* from math import * (Bad practice - imports everything)
* Useful Standard Library Modules:
* math: For mathematical constants and functions.
* os: For interacting with the operating system (e.g., [Link]()).
* json: For reading and writing JSON data.
* datetime: For working with dates and times.
* File I/O (The with statement):
* This is the correct way to handle files. It closes the file for you
automatically, even if errors occur.
* with open("[Link]", "r") as f:
* data = [Link]()
* with open("[Link]", "w") as f:
* [Link]("Hello")
* Modes: "r" (read), "w" (write, overwrites), "a" (append).
6. Error Handling
How to gracefully handle crashes and errors.
* try...except:
try:
result = 10 / 0
except ZeroDivisionError:
print("You can't divide by zero!")
except TypeError:
print("Wrong data type.")
finally:
print("This runs no matter what.")
🧠 How to Succeed in Python
* Practice in the Interpreter. Open a Python shell (just type python in your
terminal) and play. Test snippets. See what works. This is the fastest way to
learn.
* Learn List Comprehensions. This is a "Pythonic" way to create lists.
* Old way: squares = []
 for i in range(10): [Link](i**2)
* Pythonic way: squares = [i**2 for i in range(10)]
* Read the Errors. Python's error messages (Tracebacks) are very descriptive. Read
them from the bottom up. The last line tells you what went wrong, and the lines
above it tell you where.
* Use Virtual Environments. Learn to use venv to keep project dependencies
separate. It's a critical skill for any real-world project.
* Read Other People's Code. Look at well-written Python projects on GitHub. You'll
learn best practices and clever tricks.