Python Basics

    

Python is a high-level, versatile programming language known for its simplicity and readability, making it an excellent choice for both beginners and experienced developers. Created by Guido van Rossum and first released in 1991, Python has gained immense popularity due to its clear syntax, which resembles natural language. This allows developers to express complex ideas in fewer lines of code compared to other programming languages.

Python supports multiple programming paradigms, including procedural, object-oriented, and functional programming. Its extensive standard library and thriving ecosystem of third-party packages empower developers to tackle a wide range of tasks, from web development and data analysis to artificial intelligence and scientific computing.

One of Python's strengths is its ability to integrate with other languages and tools, making it highly adaptable for various projects and environments. Its portability ensures that Python code can run on different operating systems, such as Windows, macOS, and Linux, without modification.

Python's open-source nature and strong community support have led to continuous development and enhancement, ensuring that it remains at the forefront of technological advancements. Its combination of ease of use, flexibility, and power has solidified Python's position as a leading language in the tech industry.

Python Topics Outline

Basics

• Introduction to Python
• Variables and Data Types
• Basic Operators
• Control Flow
  • Conditional Statements
  • Loops
• Functions
• Input and Output
• Exception Handling
• Data Structures
  • Lists
  • Tuples
  • Dictionaries
  • Sets

Intermediate

• List Comprehensions
• Lambda Functions
• Modules and Packages
• File Handling
• Object-Oriented Programming (OOP)
  • Classes and Objects
  • Inheritance
  • Polymorphism
  • Encapsulation
• Iterators and Generators
• Decorators
• Regular Expressions

Advanced

• Advanced OOP Concepts
• Context Managers
• Metaclasses
• Threading and Multiprocessing
• Asynchronous Programming
• Networking
• Database Interaction
• Testing and Debugging
• Best Practices and Code Optimization

Python Basics

Introduction to Python

Python is a high-level, interpreted programming language known for its simplicity and readability. It supports multiple programming paradigms, including procedural, object-oriented, and functional programming.

Example:

python

print("Hello, Python!")

Variables and Data Types

Variables are used to store data in memory. Python has several built-in data types, such as integers, floats, strings, and booleans.

Example:

python
x = 5           # Integer
y = 3.14        # Float
name = "Alice"  # String
is_valid = True # Boolean

Basic Operators

Operators are used to perform operations on variables and values. Python supports arithmetic, comparison, logical, and assignment operators.

Example:

python
# Arithmetic
sum = 5 + 3
product = 5 * 3

# Comparison
is_equal = (5 == 3)

# Logical
is_true = (5 > 3) and (3 < 5)

# Assignment
x = 10
x += 5  # x becomes 15

Control Flow

Conditional Statements

Conditional statements allow the execution of code based on certain conditions.

Example:

python
age = 18
if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

Loops

Loops are used to execute a block of code repeatedly.

Example:

python
# For loop
for i in range(5):
    print(i)

# While loop
count = 0
while count < 5:
    print(count)
    count += 1

Functions

Functions are reusable blocks of code that perform a specific task.

Example:

python
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))

Input and Output

Python provides functions to handle input from the user and output to the console.

Example:

python
name = input("Enter your name: ")
print(f"Hello, {name}!")

Exception Handling

Exception handling is used to manage errors in a program gracefully.

Example:

python
try:
    number = int(input("Enter a number: "))
    result = 100 / number
except ValueError:
    print("Please enter a valid number.")
except ZeroDivisionError:
    print("Cannot divide by zero.")
else:
    print(f"Result: {result}")
finally:
    print("Execution complete.")

Data Structures

Lists

Lists are ordered, mutable collections of items.

Example:

python
fruits = ["apple", "banana", "cherry"]
fruits.append("orange")
print(fruits)

Tuples

Tuples are ordered, immutable collections of items.

Example:

python
point = (10, 20)
x, y = point
print(x, y)

Dictionaries

Dictionaries are unordered collections of key-value pairs.

Example:

python
person = {"name": "Alice", "age": 25}
print(person["name"])

Sets

Sets are unordered collections of unique items.

Example:

python
unique_numbers = {1, 2, 3, 4, 4, 5}
print(unique_numbers)  # Output: {1, 2, 3, 4, 5}

Intermediate Python

List Comprehensions

List comprehensions provide a concise way to create lists.

Example:

python
squares = [x**2 for x in range(10)]
print(squares)

Lambda Functions

Lambda functions are anonymous, inline functions defined using the lambda keyword.

Example:

python
add = lambda a, b: a + b
print(add(3, 5))

Modules and Packages

Modules are files containing Python code, and packages are collections of modules.

Example:

python
# math module
import math

print(math.sqrt(16))

File Handling

Python provides built-in functions to read from and write to files.

Example:

python
# Write to a file
with open('example.txt', 'w') as f:
    f.write("Hello, file!")

# Read from a file
with open('example.txt', 'r') as f:
    content = f.read()
    print(content)

Object-Oriented Programming (OOP)

Classes and Objects

Classes are blueprints for creating objects. Objects are instances of classes.

Example:

python
class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(f"{self.name} barks!")

dog = Dog("Rex")
dog.bark()

Inheritance

Inheritance allows a class to inherit attributes and methods from another class.

Example:

python
class Animal:
    def speak(self):
        print("Animal speaks")

class Cat(Animal):
    def meow(self):
        print("Cat meows")

cat = Cat()
cat.speak()
cat.meow()

Polymorphism

Polymorphism allows methods to do different things based on the object it is acting upon.

Example:

python
class Bird:
    def speak(self):
        print("Chirp")

class Parrot(Bird):
    def speak(self):
        print("Squawk")

def make_sound(animal):
    animal.speak()

bird = Bird()
parrot = Parrot()
make_sound(bird)
make_sound(parrot)

Encapsulation

Encapsulation restricts access to certain components of an object and can be achieved using private and protected members.

Example:

python
class Car:
    def __init__(self, model):
        self._model = model  # Protected attribute

    def _start_engine(self):  # Protected method
        print(f"{self._model} engine started")

car = Car("Toyota")
car._start_engine()

Iterators and Generators

Iterators

Iterators are objects that allow traversal of a collection.

Example:

python
numbers = [1, 2, 3]
it = iter(numbers)

print(next(it))
print(next(it))

Generators

Generators are functions that yield items one at a time using the yield keyword.

Example:

python
def countdown(n):
    while n > 0:
        yield n
        n -= 1

for number in countdown(5):
    print(number)

Decorators

Decorators are functions that modify the behavior of another function.

Example:

python
def greet(func):
    def wrapper():
        print("Hello!")
        func()
        print("Goodbye!")
    return wrapper

@greet
def say_name():
    print("Alice")

say_name()

Regular Expressions

Regular expressions are patterns used for matching and manipulating strings.

Example:

python
import re

pattern = r"\d+"  # Matches one or more digits
text = "There are 123 apples"
match = re.findall(pattern, text)
print(match)  # Output: ['123']

Advanced Python

Advanced OOP Concepts

Advanced concepts include multiple inheritance and method resolution order (MRO).

Example:

python
class A:
    def method(self):
        print("A method")

class B(A):
    def method(self):
        print("B method")

class C(A):
    def method(self):
        print("C method")

class D(B, C):
    pass

d = D()
d.method()  # Output: "B method" due to MRO

Context Managers

Context managers allow resource management using with statements.

Example:

python
with open('example.txt', 'w') as f:
    f.write("Using context manager")

Metaclasses

Metaclasses are classes of classes and define how classes behave.

Example:

python
class Meta(type):
    def __new__(cls, name, bases, dct):
        print(f"Creating class {name}")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    pass

# Output: "Creating class MyClass"

Threading and Multiprocessing

Threading

Threading allows concurrent execution of code.

Example:

python
import threading

def print_numbers():
    for i in range(5):
        print(i)

thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()

Multiprocessing

Multiprocessing allows parallel execution using multiple processes.

Example:

python
import multiprocessing

def worker(num):
    print(f"Worker {num}")

if __name__ == "__main__":
    process = multiprocessing.Process(target=worker, args=(1,))
    process.start()
    process.join()

Asynchronous Programming

Asynchronous programming allows tasks to be executed without blocking the main thread.

Example:

python
import asyncio

async def greet():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

asyncio.run(greet())

Networking

Networking involves communication between devices over a network.

Example:

python
import socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("example.com", 80))
s.sendall(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
response = s.recv(1024)
print(response.decode())
s.close()

Database Interaction

Python can interact with databases using libraries like SQLite, MySQL, and PostgreSQL.

Example using SQLite:

python
import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

cursor.execute('''CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)''')
cursor.execute('''INSERT INTO users (name) VALUES ('Alice')''')

conn.commit()
cursor.execute('''SELECT * FROM users''')
print(cursor.fetchall())

conn.close()

Testing and Debugging

Testing ensures code correctness, while debugging helps find and fix errors.

Example using unittest:

python
import unittest

def add(a, b):
    return a + b

class TestMath(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(3, 4), 7)

if __name__ == "__main__":
    unittest.main()

Best Practices and Code Optimization

• Follow PEP 8 style guide.
• Use meaningful variable and function names.
• Optimize code for readability and performance.
• Avoid premature optimization; profile before optimizing.