Python Class Notes

1. Introduction

· What is Python?
· High-level, interpreted, general-purpose programming language.
· Known for its readability, simplicity, and versatility.
· Widely used in various domains: web development, data science, machine learning,
scripting, and more.
· Key Features:
· Interpreted: No need to compile code before execution.
· Dynamically Typed: No need to explicitly declare variable types.
· Object-Oriented: Supports object-oriented programming concepts like classes, objects,
inheritance, and polymorphism.
· Large Standard Library: Rich collection of built-in modules and functions for various
tasks.
· Cross-Platform Compatibility: Runs on various operating systems (Windows, macOS,
Linux).

2. Basic Syntax and Data Types

· Variables:
· Store data values.
· No explicit declaration needed.
· Examples:
· Python
· name = "Alice" age = 30 is_student = True
· Data Types:
· Integers (int): Whole numbers (e.g., 10, -5, 0)
· Floats (float): Real numbers with decimal points (e.g., 3.14, -2.5)
· Strings (str): Sequences of characters (e.g., "Hello", 'World!')
· Booleans (bool): Represents truth values (True or False)
· Lists (list): Ordered, mutable collections of elements (e.g., [1, 2, 3], ["apple", "banana"])
· Tuples (tuple): Ordered, immutable collections of elements (e.g., (1, 2, 3), ("apple",
"banana"))
· Sets (set): Unordered collections of unique elements (e.g., {1, 2, 3}, {"apple", "banana"})
· Dictionaries (dict): Unordered collections of key-value pairs (e.g., {"name": "Alice",
"age": 30})
· Operators:
· Arithmetic Operators: +, -, *, /, // (floor division), % (modulo), ** (exponentiation)
· Comparison Operators: == (equal to), != (not equal to), >, <, >=, <=
· Logical Operators: and, or, not
· Assignment Operators: =, +=, -=, *=, /=, //=
· Control Flow:
· Conditional Statements:
· if, elif, else blocks to execute code based on conditions.
· Example:
 · Python
· if age >= 18: print("You are an adult.") else: print("You are a
minor.")
· Loops:
· for loop: Iterates over a sequence (e.g., list, string).
· Example:
· Python
· for i in range(5): print(i) # Prints 0, 1, 2, 3, 4
· while loop: Executes code as long as a condition is true.
· Example:
· Python
· count = 0while count < 5: print(count) count += 1

3. Functions

· Defining Functions:
· Use the def keyword followed by the function name and parentheses.
· Can include parameters (inputs) within the parentheses.
· Example:
· Python
· def greet(name): print("Hello, " + name + "!") greet("Alice") #
Output: Hello, Alice!
· Function Arguments:
· Positional Arguments: Passed in the order they are defined.
· Keyword Arguments: Passed using the parameter name.
· Default Arguments: Assign default values to parameters.
· Return Values:
· Use the return statement to send a value back from the function.

4. Object-Oriented Programming (OOP)

· Classes:
· Blueprints for creating objects.
· Define attributes (data) and methods (functions) that objects will have.
· Example:
· Python
· class Dog: def __init__(self, name, breed): self.name = name
self.breed = breed def bark(self): print("Woof!") my_dog =
Dog("Buddy", "Golden Retriever") print(my_dog.name) # Output: Buddy
my_dog.bark() # Output: Woof!
· Objects:
· Instances of a class.
· Represent real-world entities.
· Inheritance:
· Create new classes (subclasses) from existing ones (parent classes).
· Subclasses inherit attributes and methods from the parent class.
· Polymorphism:
· Ability of objects of different classes to be treated as objects of a common type.
5. Working with Files

· Opening Files:
· Use the open() function to open a file.
· Specify the file path and mode (e.g., 'r' for reading, 'w' for writing).
· Example:
· Python
· file = open("my_file.txt", "r")
· Reading Files:
· Read the entire file content: file.read()
· Read the file line by line: for line in file:
· Example:
· Python
· for line in file: print(line)
· Writing to Files:
· Use the write() method to write content to a file.
· Example:
· Python
· file = open("my_file.txt", "w") file.write("This is a new line.")
· Closing Files:
· Use the close() method to release resources.
· Python
· file.close()
·

6. Modules and Packages

· Modules:
· Python files (.py) containing reusable code.
· Import modules using the import statement.
· Example:
· Python
· import math print(math.pi)
· Packages:
· Collections of related modules organized in a directory.
· Use dot notation to access modules within a package.
· Example:
· Python
· import os.path print(os.path.exists("my_file.txt"))
·
·
·
·
7. Exception Handling

· Try-Except Blocks:
·
· Use try to enclose code that might raise an exception.
·
· Use except to handle the exception gracefully.
·
· Example:
· Útržok kódu
· try:
· num1 = int(input("Enter a number: "))
· num2 = int(input("Enter another number: "))
· result = num1 / num2
· print("Result:", result)
· except ZeroDivisionError:
· print("Cannot divide by zero.")
·

8. Working with External Libraries

· Installing Libraries:

· Use pip (Package Installer for Python) to install libraries from the Python Package Index
(PyPI).
·
· Example:
· Bash
· pip install numpy

· Using Libraries:

· Import the library using the import statement.

·
· Use the library's functions and classes.
·
· Example:
 · Python
· import numpy as np
· array = np.array([1, 2, 3])
· print(array)
·
·
·
·

9. Advanced Topics

· Decorators:
·
· Functions that modify other functions.
·
·

· Generators:
·
· Functions that produce a sequence of values on-the-fly.
·
·

· Iterators:
·
· Objects that can be iterated over (e.g., using a for loop).
·
·

· Multithreading/Multiprocessing:
·
· Techniques for executing code concurrently.
·
·

· Asynchronous Programming:
 ·
· Handling multiple tasks concurrently using techniques like asyncio.
·
·

10. Best Practices

· Write Clean and Readable Code:

·
· Use meaningful variable names.
·
· Add comments to explain complex logic.
·
· Follow PEP 8 style guide (https://www.python.org/dev/peps/pep-0008/).

· Test Your Code:

·
· Write unit tests to ensure code correctness.

· Use Version Control (e.g., Git):

· Track changes to your code and collaborate with others.