Core Python Programming Concepts

1.Data Types

• Integers (int): Whole numbers, e.g., x = 10
• Floating Point Numbers (float): Decimal numbers, e.g., y = 3.14
• Strings (str): Sequence of characters, e.g., s = “Hello”
• Booleans (bool): True or False, e.g., b = True
• Lists (list): Ordered, mutable collection, e.g., l = [1, 2, 3]
• Tuples (tuple): Ordered, immutable collection, e.g., t = (1, 2, 3)
• Dictionaries (dict): Unordered, mutable key-value pairs, e.g., d = {‘key’: ‘value’}
• Sets (set): Unordered collection of unique elements, e.g., s = {1, 2, 3}

2.Variables and Constants

• Variable Assignment: Python uses dynamic typing, e.g., x = 5, name = “Alice”.
• Constants: Python does not have constant variables. By convention, constants are written in uppercase letters, e.g., PI = 3.14159.

3.Operators

• Arithmetic Operators: +, -, *, /, // (floor division), % (modulus), ** (exponentiation).
• Comparison Operators: ==, !=, >, <, >=, <=.
• Logical Operators: and, or, not.
• Assignment Operators: =, +=, -=, *=, /=, //=, %=, **=.
• Membership Operators: in, not in.
• Identity Operators: is, is not.

4.Control Flow

• If-Else Statements:

if x > 10:

    print("Greater than 10")

elif x == 10:

    print("Equal to 10")

else:

    print("Less than 10")

• Loops:
  • For Loop: Iterates over sequences (lists, tuples, strings, etc.)

for i in range(5):

    print(i)

While Loop: Repeats as long as the condition is true

python

Copy

while x < 10:

    print(x)

    x += 1

• Break and Continue: Control the flow within loops

for i in range(10):

    if i == 5:

        break  # Exit the loop

    if i % 2 == 0:

        continue  # Skip the rest of the loop body

    print(i)

5.Functions

• Defining Functions: Functions are defined using the def keyword

def greet(name):

    return f"Hello, {name}!"

• Lambda Functions: Anonymous functions for short-term use

• Arguments: Functions can take different types of arguments:
  • Positional: def func(a, b):
  • Keyword: def func(a, b=10):
  • Variable-Length: def func(*args, **kwargs):

6.Error Handling

• Try-Except Blocks:

try:

    x = 10 / 0

except ZeroDivisionError as e:

    print(f"Error: {e}")

• Finally Block: Executes no matter what

try:

    file = open('file.txt', 'r')

except FileNotFoundError:

    print("File not found")

finally:

    file.close()

1. Object-Oriented Programming (OOP)

• Classes and Objects:

class Dog:

    def __init__(self, name, breed):

        self.name = name

        self.breed = breed

    def bark(self):

        print(f"{self.name} says Woof!")

dog1 = Dog("Buddy", "Golden Retriever")

dog1.bark()  # Output: Buddy says Woof!

• Inheritance: Creating a new class by inheriting from an existing class

class Animal:

    def speak(self):

        print("Animal speaks")

class Dog(Animal):

    def speak(self):

        print("Dog barks")

dog = Dog()

dog.speak()  # Output: Dog barks

• Polymorphism: The ability to define methods in a child class with the same name as the parent class

class Cat(Animal):

    def speak(self):

        print("Cat meows")

animals = [Dog(), Cat()]

for animal in animals:

    animal.speak()  # Output: Dog barks, Cat meows

• Encapsulation: Hiding private data using self._variable or self.__variable

class Car:

    def __init__(self, make, model):

        self.make = make

        self.model = model

        self.__speed = 0  # Private variable

    def accelerate(self):

        self.__speed += 5

car = Car("Toyota", "Corolla")

car.accelerate()

2. Decorators

• Function Decorators: A function that modifies the behavior of another function

def decorator(func):

    def wrapper():

        print("Before function call")

        func()

        print("After function call")

    return wrapper

@decorator

def say_hello():

    print("Hello!")

say_hello()

• Class Decorators: A class that modifies the behavior of another class

def add_method(cls):

    def new_method(self):

        print("New method added!")

    cls.new_method = new_method

    return cls

@add_method

class MyClass:

    pass

obj = MyClass()

obj.new_method()

3. Iterators and Generators

• Iterator: An object that implements the __iter__() and __next__() methods

class MyIterator:

    def __init__(self, start, end):

        self.current = start

        self.end = end

    def __iter__(self):

        return self

    def __next__(self):

        if self.current < self.end:

            self.current += 1

            return self.current - 1

        else:

            raise StopIteration

iter_obj = MyIterator(0, 5)

for i in iter_obj:

    print(i)

• Generator: A function that yields a value and pauses the function’s execution

def count_up_to(max):

    count = 1

    while count <= max:

        yield count

        count += 1

gen = count_up_to(5)

for num in gen:

    print(num)

4. File Handling

• Reading from a File:

with open('file.txt', 'r') as file:

    content = file.read()

    print(content)

• Writing to a File:

with open('file.txt', 'w') as file:

    file.write("Hello, World!")

5. Working with Libraries and Modules

• Importing Standard Libraries:

import math

print(math.sqrt(16))  # Output: 4.0

• Third-Party Libraries: Using libraries like requests, numpy, pandas, matplotlib:

import requests

response = requests.get('https://jsonplaceholder.typicode.com/todos/1')

print(response.json())

6. Multithreading and Multiprocessing

• Multithreading: Using multiple threads to run tasks concurrently within the same process

import threading

def print_numbers():

    for i in range(5):

        print(i)

thread = threading.Thread(target=print_numbers)

thread.start()

• Multiprocessing: Using multiple processes to take full advantage of multicore processors

from multiprocessing import Process

def print_numbers():

    for i in range(5):

        print(i)

process = Process(target=print_numbers)

process.start()

7.Regular Expressions (Regex)

• Basic Regex Operations:

import re

pattern = r"\d+"  # Matches one or more digits

text = "There are 123 apples and 456 oranges"

result = re.findall(pattern, text)

print(result)

• PEP 8 Compliance: Follow Python’s official style guide for writing clean, readable code.
  • Use 4 spaces for indentation.
  • Limit lines to 79 characters.
  • Use descriptive variable names.
  • Avoid using import *.
• Documentation: Write docstrings for functions, classes, and methods to improve code readability and maintainability.
• Unit Testing: Use the unittest or pytest framework to create automated tests for your code.
• Error Handling: Handle exceptions properly, providing informative error messages without exposing sensitive data.
• Optimization: Be mindful of performance, and avoid unnecessary complexity in algorithms.