Core & Advance Python Programmer

Core & Advanced Python Programming is an excellent way to provide a comprehensive and quick reference guide for key concepts, functions, tools, and best practices in Python programming. This will include both core and advanced Python topics, structured for easy understanding and practical use. It will cover essential concepts, code examples, and useful libraries or modules that Python programmers commonly use. The following sections will help programmers from beginners to advanced levels.

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

add = lambda x, y: x + y

• 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.

Conclusion
Core & Advanced Python Programming provides a comprehensive reference for mastering Python. It covers fundamental concepts like data types, control flow, and functions, as well as advanced topics such as object-oriented programming, decorators, and file handling.
Download Elysium Spark Note