Showing posts with label Python. Show all posts
Showing posts with label Python. Show all posts

Friday 14 June 2024

Machine Learning with Python: From Beginner to Advanced course syllabus

 


Module 1: Introduction to Machine Learning

  • Week 1: Overview of Machine Learning

    • What is Machine Learning?
    • Types of Machine Learning: Supervised, Unsupervised, Reinforcement
    • Real-world applications of Machine Learning
    • Setting up Python environment: Anaconda, Jupyter Notebooks, essential libraries (NumPy, pandas, matplotlib, scikit-learn)
  • Week 2: Python for Data Science

    • Python basics: Data types, control flow, functions
    • NumPy for numerical computing
    • pandas for data manipulation
    • Data visualization with matplotlib and seaborn

Module 2: Supervised Learning

  • Week 3: Regression

    • Introduction to regression analysis
    • Simple Linear Regression
    • Multiple Linear Regression
    • Evaluation metrics: Mean Squared Error, R-squared
  • Week 4: Classification

    • Introduction to classification
    • Logistic Regression
    • K-Nearest Neighbors (KNN)
    • Evaluation metrics: Accuracy, Precision, Recall, F1 Score, ROC-AUC
  • Week 5: Advanced Supervised Learning Algorithms

    • Decision Trees
    • Random Forests
    • Gradient Boosting Machines (XGBoost)
    • Support Vector Machines (SVM)

Module 3: Unsupervised Learning

  • Week 6: Clustering

    • Introduction to clustering
    • K-Means Clustering
    • Hierarchical Clustering
    • DBSCAN
  • Week 7: Dimensionality Reduction

    • Introduction to dimensionality reduction
    • Principal Component Analysis (PCA)
    • t-Distributed Stochastic Neighbor Embedding (t-SNE)
    • Singular Value Decomposition (SVD)

Module 4: Reinforcement Learning

  • Week 8: Fundamentals of Reinforcement Learning

    • Introduction to Reinforcement Learning
    • Key concepts: Agents, Environments, Rewards
    • Markov Decision Processes (MDP)
    • Q-Learning
  • Week 9: Deep Reinforcement Learning

    • Deep Q-Networks (DQN)
    • Policy Gradient Methods
    • Applications of Reinforcement Learning

Module 5: Deep Learning

  • Week 10: Introduction to Neural Networks

    • Basics of Neural Networks
    • Activation Functions
    • Training Neural Networks: Forward and Backward Propagation
  • Week 11: Convolutional Neural Networks (CNNs)

    • Introduction to CNNs
    • CNN architectures: LeNet, AlexNet, VGG, ResNet
    • Applications in Image Recognition
  • Week 12: Recurrent Neural Networks (RNNs)

    • Introduction to RNNs
    • Long Short-Term Memory (LSTM) networks
    • Applications in Sequence Prediction

Module 6: Advanced Topics

  • Week 13: Natural Language Processing (NLP)

    • Introduction to NLP
    • Text Preprocessing
    • Sentiment Analysis
    • Topic Modeling
  • Week 14: Model Deployment and Production

    • Saving and loading models
    • Introduction to Flask for API creation
    • Deployment on cloud platforms (AWS, Google Cloud, Heroku)
  • Week 15: Capstone Project

    • Work on a real-world project
    • End-to-end model development: Data collection, preprocessing, model training, evaluation, and deployment
    • Presentation and review

Saturday 8 June 2024

File Chooser using Python

 

from plyer import filechooser


# Open a file chooser dialog

file_path = filechooser.open_file()

print("Selected file:", file_path)


# Open multiple files chooser dialog

files_path = filechooser.open_file(multiple=True)

print("Selected files:", files_path)


# Save file chooser dialog

save_path = filechooser.save_file()

print("Save file path:", save_path)


#clcoding.com

Friday 7 June 2024

Python Programming Basics: For Freshers Learn Python Programming Infrastructure and Attend Interviews free pdf

 

Python Programming Basics

For Freshers Learn Python Programming Infrastructure and Attend Interviews

What You Will Learn

Chapter 1 : Basics

1 Python Introduction

2 Python Variables


Chapter 2 : Data Types

1 Python boolean

2 Python String

3 Python Number

4 Python List

5 Python Tuple

6 Python Dictionary


Chapter 3 : Operators

1 Python Arithmetic Operators

2 Python Bitwise Operators

3 Python Comparison Operators

4 Python Logical Operators

5 Python Ternary Operators


Chapter 4 : Statements

1 Python if

2 Python while

3 Python for loop

4 Python pass

5 Python break

6 Python continue


Chapter 5 : Functions

1 Python function

2 Python Function Recursion


Chapter 6 : Object Oriented

1 Python Modules

2 Python class

3 Python class Inheritance

4 Python Abstract Base Classes

5 Python Operator Overloading


Chapter 7 : Advanced

1 Python File

2 Python Text File

3 Python Exceptions

4 Python Testing

Free PDF: Python Programming Basics: For Freshers Learn Python Programming Infrastructure and Attend Interviews


Hard Copy: Python Programming Basics: For Freshers Learn Python Programming Infrastructure and Attend Interviews





Monday 3 June 2024

Country Details using Python

 

from countryinfo import CountryInfo

country = CountryInfo(input("Enter Country Name:"))


# Various information about the country

print("Country Name:", country.name())

print("Capital:", country.capital())

print("Population:", country.population())

print("Area (in square kilometers):", country.area())

print("Region:", country.region())

print("Subregion:", country.subregion())

print("Demonym:", country.demonym())

print("Currency:", country.currencies())

print("Languages:", country.languages())

print("Borders: ", country.borders())

#clcoding.com

Sunday 2 June 2024

Print Calendar using Python

 

Let's break down the code and understand what it does step by step.

Code Explanation

Importing the Calendar Module:

from calendar import *

  • This line imports all the functions and classes from the calendar module in Python. The calendar module provides various functions related to calendar operations.

Getting User Input:

year = int(input('Enter Year:'))
  • This line prompts the user to enter a year. The input function takes the user's input as a string, and the int function converts this string to an integer, which is then stored in the variable year.

Printing the Calendar:

print(calendar(year, 2, 1, 8, 4))
  • This line is intended to print the calendar for the given year with specific formatting. 
formatyear(year, w=2, l=1, c=6, m=3):
  • year: The year for which the calendar is to be printed.
  • w: The width of each date column (default is 2).
  • l: The number of lines for each week (default is 1).
  • c: The number of spaces between month columns (default is 6).
  • m: The number of months per row (default is 3).

Friday 31 May 2024

Programmation pour tous (mise en route de Python)

 

Introduction

Si vous êtes débutant en programmation et que vous souhaitez apprendre Python, le cours "Programming for Everybody (Getting Started with Python)" de l'Université du Michigan sur Coursera est parfait pour vous. Ce cours, dispensé en français, couvre les bases essentielles de la programmation en Python et est conçu pour ceux qui n'ont aucune expérience préalable en codage.

Contenu du Cours

Le cours comprend :

  • Installation de Python : Guide étape par étape pour installer Python sur votre ordinateur.
  • Écriture de votre premier programme : Introduction aux bases de la syntaxe Python.
  • Utilisation des variables et des fonctions : Apprenez à manipuler les données et à structurer votre code.
  • Boucles et instructions conditionnelles : Découvrez comment contrôler le flux de votre programme.

Structure du Cours

Le cours est structuré de manière à faciliter l'apprentissage avec des vidéos explicatives, des lectures, des quiz interactifs et des devoirs pratiques. Il est conçu pour être suivi à votre propre rythme, ce qui vous permet de l'adapter à votre emploi du temps.

Pourquoi Apprendre Python?

Python est un langage de programmation polyvalent et très populaire. Il est utilisé dans divers domaines tels que le développement web, l'analyse de données, l'intelligence artificielle, et bien plus encore. En apprenant Python, vous ouvrez la porte à de nombreuses opportunités professionnelles.

Certification

À la fin du cours, vous aurez la possibilité d'obtenir un certificat partageable qui peut enrichir votre CV et démontrer vos compétences en programmation Python.

Conclusion

Le cours "Programming for Everybody (Getting Started with Python)" est une excellente opportunité pour débuter en programmation. Il offre une introduction complète et accessible à Python, avec le soutien d'une institution prestigieuse comme l'Université du Michigan.

Pour plus d'informations et pour vous inscrire, visitez la page du cours sur Coursera. Bon apprentissage !

rejoindre gratuitement: Programmation pour tous (mise en route de Python)

Saturday 25 May 2024

Download YouTube Videos using Python - pytube

 


Code:

from pytube import YouTube

# YouTube video URL

video_url = "https://www.youtube.com/watch?v=6VYtgkl3HPQ"

# Initialize a YouTube object

yt = YouTube(video_url)

# Select the highest resolution stream

stream = yt.streams.get_highest_resolution()

# Download the video

stream.download()


Explanantion:

This Python script uses the pytube library to download a YouTube video.

Let's break down the code:

Importing the necessary module:

from pytube import YouTube
This line imports the YouTube class from the pytube module, which provides functionality to interact with YouTube videos.

Defining the YouTube video URL:

video_url = "https://www.youtube.com/watch?v=6VYtgkl3HPQ"
Here, you specify the URL of the YouTube video you want to download. Replace "https://www.youtube.com/watch?v=6VYtgkl3HPQ" with the URL of the video you want to download.

Initializing a YouTube object:

yt = YouTube(video_url)
This line creates a YouTube object using the specified video URL. This object represents the YouTube video and allows you to access various properties and methods associated with the video.

Selecting the highest resolution stream:

stream = yt.streams.get_highest_resolution()
Here, you retrieve the stream with the highest resolution available for the video. The get_highest_resolution() method returns a Stream object representing the highest resolution stream.

Downloading the video:

stream.download()
Finally, you call the download() method on the Stream object to download the video. This method saves the video file to the current working directory with the default filename.

In summary, this script downloads the YouTube video specified by the video_url variable using the pytube library, selecting the highest resolution available.







Friday 24 May 2024

Python 201: Intermediate Python


Python 201 is the sequel to my first book, Python 101. If you already know the basics of Python and now you want to go to the next level, then this is the book for you! This book is for intermediate level Python programmers only. There won't be any beginner chapters here. This book is based on Python 3.

The book will be broken up into five parts. Here's how:


Part I - Intermediate Modules

Chapter 1 - The argparse module

Chapter 2 - The collections module

Chapter 3 - The contextlib module (Context Managers)

Chapter 4 - The functools module (Function overloading, caching, etc)

Chapter 5 - All about imports

Chapter 6 - The importlib module

Chapter 7 - Iterators and Generators

Chapter 8 - The itertools module

Chapter 9 - The re module (An Intro to Regex in Python)

Chapter 10 - The typing module (Type Hinting)


Part II - Odds and Ends

Chapter 11 - map, filter and more

Chapter 12 - unicode

Chapter 13 - benchmarking

Chapter 14 - encryption

Chapter 15 - Connecting to databases

Chapter 16 - super

Chapter 17 - descriptors

Chapter 18 - Scope (local, global and the new non_local)


Part III - Web

Chapter 19 - Web scraping

Chapter 20 - Working with web APIs

Chapter 21 - ftplib

Chapter 22 - urllib


Part IV - Testing

Chapter 23 - Doctest

Chapter 24 - unittest

Chapter 25 - mock

Chapter 26 - coverage.py


Part V - Concurrency

Chapter 27 - The asyncio module

Chapter 28 - The threading module

Chapter 29 - The multiprocessing module

Chapter 30 - The concurrent.futures module


Join the course: Python 201: Intermediate Python





Thursday 23 May 2024

Convert to mathematical symbols using Python 🧵

 

import math
import latexify
@latexify.function
def quadratic_roots(a, b, c):
    discriminant = b ** 2 - 4 * a * c
    root1 = (-b + math.sqrt(discriminant)) / (2 * a)
    root2 = (-b - math.sqrt(discriminant)) / (2 * a)
    return root1, root2
quadratic_roots

#clcoding.com
import math
import latexify
@latexify.function
def pythagorean_theorem(a, b):
    return math.sqrt(a ** 2 + b ** 2)
pythagorean_theorem

#clcoding.com
import math
import latexify
@latexify.function
def compound_interest(P, r, n, t):
    return P * (1 + r/n) ** (n*t)
compound_interest

#clcoding.com

import math
import latexify
@latexify.function
def distance(x1, y1, x2, y2):
  return math.sqrt((x2-x1)**2 + (y2-y1)**2)
distance
import math
import latexify
@latexify.function
def factorial(n):
  if n == 0:
    return 1
  elif n == 1:
    return 1
  else:
    return n * factorial(n-1)
factorial

Tuesday 21 May 2024

Pdf To Audio using Python

 


# Importing necessary libraries

import PyPDF2

import pyttsx3

# Prompt user for the PDF file name

pdf_filename = input("Enter the PDF file name (including extension): ").strip()

# Open the PDF file

try:

    with open(pdf_filename, 'rb') as pdf_file:

        # Create a PdfFileReader object

        pdf_reader = PyPDF2.PdfReader(pdf_file)

        

        # Get an engine instance for the speech synthesis

        speak = pyttsx3.init()        

        # Iterate through each page and read the text

        for page_num in range(len(pdf_reader.pages)):

            page = pdf_reader.pages[page_num]

            text = page.extract_text()

            if text:

                speak.say(text)

                speak.runAndWait()       

        # Stop the speech engine

        speak.stop()      

        print("Audiobook creation completed.")

except FileNotFoundError:

    print("The specified file was not found.")

except Exception as e:

    print(f"An error occurred: {e}")

#clcoding.com


Explanation:

This script segment accomplishes several tasks:

Importing Necessary Libraries:

PyPDF2: This library is used to work with PDF files, allowing us to read the content of PDF documents.
pyttsx3: This library is used for text-to-speech conversion, enabling us to convert the text extracted from the PDF into spoken words.
Prompting User for PDF File Name:

The input() function is used to prompt the user to enter the name of the PDF file, including its extension (e.g., example.pdf).
The entered file name is stored in the variable pdf_filename.
Opening the PDF File:

The open() function is used to open the PDF file specified by the user. The file is opened in binary read mode ('rb').
This operation is wrapped in a try block to handle possible exceptions, such as the file not being found (FileNotFoundError) or other unexpected errors (Exception).
Reading PDF Content and Converting to Speech:

If the PDF file is successfully opened, a PdfReader object named pdf_reader is created using PyPDF2. This object is used to read the content of the PDF document.
An instance of the text-to-speech engine (speak) is initialized using pyttsx3.init().
The script iterates through each page of the PDF using a for loop and the range(len(pdf_reader.pages)) construct. For each page:
The text content is extracted from the page using page.extract_text().
If the extracted text is not empty, it is passed to the text-to-speech engine to be spoken aloud using speak.say(text) and speak.runAndWait().
After processing all pages, the text-to-speech engine is stopped using speak.stop().
Error Handling:

If the specified PDF file is not found (FileNotFoundError), the script prints a message indicating that the file was not found.
If any other unexpected error occurs during the execution of the script (Exception), the error message is printed.
Completion Message:

If the script executes successfully without encountering any errors, a message indicating the completion of audiobook creation is printed.
Overall, this script segment enables the user to specify a PDF file, reads its content, converts the text to speech, and creates an audiobook from the PDF content.

Monday 20 May 2024

Box and Whisker plot using Python Libraries

Step 1: Install Necessary Libraries

First, make sure you have matplotlib and seaborn installed. You can install them using pip:

pip install matplotlib seaborn

#clcoding.com

Step 2: Import Libraries

Next, import the necessary libraries in your Python script or notebook.

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

Step 3: Create Sample Data

Create some sample data to plot. This can be any dataset you have, but for demonstration purposes, we will create a simple dataset using NumPy.

# Generate sample data
np.random.seed(10)
data = [np.random.normal(0, std, 100) for std in range(1, 5)]

Step 4: Create the Box and Whisker Plot

Using matplotlib and seaborn, you can create a basic Box and Whisker plot.

# Create a boxplot
plt.figure(figsize=(10, 6))
plt.boxplot(data, patch_artist=True)

# Add title and labels
plt.title('Box and Whisker Plot')
plt.xlabel('Category')
plt.ylabel('Values')

# Show plot
plt.show()

Step 5: Enhance the Plot with Seaborn

For more advanced styling, you can use seaborn, which provides more aesthetic options.

# Set the style of the visualization

sns.set(style="whitegrid")

# Create a boxplot with seaborn

plt.figure(figsize=(10, 6))

sns.boxplot(data=data)

# Add title and labels

plt.title('Box and Whisker Plot')

plt.xlabel('Category')

plt.ylabel('Values')

# Show plot

plt.show()

Thursday 16 May 2024

Interesting facts about Dictionaries

 Dictionary Methods

Dictionaries come with several handy methods such as setdefault, update, pop, popitem, and clear.

my_dict = {'name': 'Alice', 'age': 25}

# setdefault
my_dict.setdefault('city', 'Unknown')
print(my_dict)  

# update
my_dict.update({'age': 26, 'city': 'New York'})
print(my_dict)  

# pop
age = my_dict.pop('age')
print(age)  # Output: 26
print(my_dict)  

# popitem
item = my_dict.popitem()
print(item) 
print(my_dict)  

# clear
my_dict.clear()
print(my_dict)  

#clcoding.com
{'name': 'Alice', 'age': 25, 'city': 'Unknown'}
{'name': 'Alice', 'age': 26, 'city': 'New York'}
26
{'name': 'Alice', 'city': 'New York'}
('city', 'New York')
{'name': 'Alice'}
{}

Ordered Dictionaries

As of Python 3.7, dictionaries maintain insertion order by default. The OrderedDict from the collections module was used for this purpose in earlier versions.

my_dict = {'first': 1, 'second': 2, 'third': 3}
print(my_dict)  

#clcoding.com
{'first': 1, 'second': 2, 'third': 3}

Merging Dictionaries

Starting with Python 3.9, you can use the | operator to merge dictionaries.

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = dict1 | dict2
print(merged_dict)  

#clcoding.com
{'a': 1, 'b': 3, 'c': 4}
Dictionary Views
The keys, values, and items methods return dictionary view objects, which are dynamic and reflect changes in the dictionary.

my_dict = {'name': 'Alice', 'age': 25}
keys_view = my_dict.keys()
print(keys_view)  
my_dict['city'] = 'New York'
print(keys_view) 

#clcoding.com
dict_keys(['name', 'age'])
dict_keys(['name', 'age', 'city'])

Default Values with get and defaultdict

Using the get method, you can provide a default value if the key is not found.

my_dict = {'name': 'Alice'}
print(my_dict.get('age', 'Not Found'))  
Not Found
With defaultdict from the collections module, you can provide default values for missing keys.

from collections import defaultdict

dd = defaultdict(int)
dd['a'] += 1
print(dd)  

#clcoding.com
defaultdict(<class 'int'>, {'a': 1})


Dictionary Comprehensions

Just like list comprehensions, you can create dictionaries using dictionary comprehensions.

squares = {x: x*x for x in range(6)}
print(squares)  

#clcoding.com
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Iterating Through Dictionaries

You can iterate through keys, values, or key-value pairs in a dictionary.

my_dict = {'name': 'Alice', 'age': 25}
for key in my_dict:
    print(key)  

for value in my_dict.values():
    print(value)  

for key, value in my_dict.items():
    print(key, value)  

#clcoding.com
name
age
Alice
25
name Alice
age 25

Keys Must Be Immutable and Unique

The keys in a dictionary must be immutable types (like strings, numbers, or tuples) and must be unique.

my_dict = {(1, 2): 'tuple key', 'name': 'Alice', 3.14: 'pi'}
print(my_dict)  

#clcoding.com
{(1, 2): 'tuple key', 'name': 'Alice', 3.14: 'pi'}

Efficient Lookup Time

Dictionaries have average O(1) time complexity for lookups, insertions, and deletions due to their underlying hash table implementation.

my_dict = {'a': 1, 'b': 2, 'c': 3}
print(my_dict['b'])  

#clcoding.com
2


Dynamic and Mutable

Dictionaries are mutable, which means you can change their content without changing their identity.

my_dict = {'name': 'Alice', 'age': 25}
my_dict['age'] = 26
my_dict['city'] = 'New York'
print(my_dict)  

#clcoding.com
{'name': 'Alice', 'age': 26, 'city': 'New York'}

Monday 13 May 2024

Python Libraries for Financial Analysis and Portfolio Management

 



import statsmodels.api as sm
import numpy as np

# Generate some sample data
x = np.random.rand(100)
y = 2 * x + np.random.randn(100)

# Fit a linear regression model
model = sm.OLS(y, sm.add_constant(x)).fit()

print("Regression coefficients:", model.params)
print("R-squared:", model.rsquared)

#clcoding.com 
import pandas as pd

# Create a simple DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'Salary': [50000, 60000, 70000]}
df = pd.DataFrame(data)

# Perform data analysis
print("DataFrame head:")
print(df.head())
print("\nAverage salary:", df['Salary'].mean())

#clcoding.com 
import numpy as np

# Create a simple array
arr = np.array([1, 2, 3, 4, 5])

# Perform numerical operations
print("Sum:", np.sum(arr))
print("Mean:", np.mean(arr))
print("Standard deviation:", np.std(arr))

#clcoding.com 
from ibapi.client import EClient
from ibapi.wrapper import EWrapper

class MyWrapper(EWrapper):
    def __init__(self):
        super().__init__()

class MyClient(EClient):
    def __init__(self, wrapper):
        EClient.__init__(self, wrapper)

app = MyClient(MyWrapper())
app.connect("127.0.0.1", 7497, clientId=1)

app.run()

#clcoding.com 
import numpy as np
from scipy import optimize

# Define a simple objective function
def objective(x):
    return x**2 + 10*np.sin(x)

# Optimize the objective function
result = optimize.minimize(objective, x0=0)

print("Minimum value found at:", result.x)
print("Objective function value at minimum:", result.fun)

#clcoding.com 
from riskfolio.Portfolio import Portfolio

# Create a simple portfolio
data = {'Asset1': [0.05, 0.1, 0.15],
        'Asset2': [0.08, 0.12, 0.18],
        'Asset3': [0.06, 0.11, 0.14]}
portfolio = Portfolio(returns=data)

# Perform portfolio optimization
portfolio.optimize()

print("Optimal weights:", portfolio.w)
print("Expected return:", portfolio.mu)
print("Volatility:", portfolio.sigma)

#clcoding.com 

Saturday 11 May 2024

Happy Mother's Day!

 


Code:

import pyfiglet

from termcolor import colored

import random

def get_random_font_style():

    # List of available Figlet font styles

    font_styles = pyfiglet.FigletFont.getFonts() 

    # Choose a random font style from the list

    return random.choice(font_styles)

def get_random_color():

    # List of available colors

    colors = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white']

    # Choose a random color from the list

    return random.choice(colors)

def wish_mothers_day():

    # Get a random font style and color

    random_font_style = get_random_font_style()

    random_color = get_random_color()

    # Create a Figlet font object with the random style

    font = pyfiglet.Figlet(font=random_font_style)

    # Print the decorative greeting in the chosen color

    print(colored(font.renderText("Happy Mother's Day!"), random_color))

wish_mothers_day()

#clcoding.com

Solution and Explanation:

This code generates a Mother's Day wish with a randomly selected font style and color using the pyfiglet and termcolor libraries in Python. Here's a breakdown of what each part of the code does:

import pyfiglet: Imports the pyfiglet library, which is used to create ASCII art text.

from termcolor import colored: Imports the colored function from the termcolor library, which is used to add color to text in the terminal.

import random: Imports the random module, which is used to generate random font styles and colors.

get_random_font_style(): Defines a function that returns a random font style chosen from the available Figlet font styles provided by pyfiglet.

get_random_color(): Defines a function that returns a random color chosen from a predefined list of colors.

wish_mothers_day(): Defines the main function responsible for printing the Mother's Day wish. Inside this function:

random_font_style is assigned a random font style using get_random_font_style().
random_color is assigned a random color using get_random_color().
A Figlet font object is created using the random font style.
The text "Happy Mother's Day!" is rendered using the chosen font style and colored with the chosen color using the colored function.
The rendered text is printed to the console.
wish_mothers_day(): Finally, the wish_mothers_day() function is called to generate and print the Mother's Day wish with a random font style and color.

This code allows you to produce colorful and decorative Mother's Day wishes each time it's run, adding a touch of randomness and visual appeal to the message.


Type Hints in Python

 Type hints in Python are an excellent tool for improving code quality and maintainability, especially in larger projects. 

from typing import Optional

class TreeNode:

    def __init__(self, value: int) -> None:

        self.value = value

        self.left: Optional['TreeNode'] = None

        self.right: Optional['TreeNode'] = None

#clcoding.com

class LinkedListNode:

    def __init__(self, value: int, next_node: 'LinkedListNode' = None) -> None:

        self.value = value

        self.next = next_node

#clcoding.com

from typing import Optional

class TreeNode:

    def __init__(self, value: int) -> None:

        self.value = value

        self.left: Optional['TreeNode'] = None

        self.right: Optional['TreeNode'] = None

#clcoding.com

from typing import TypeVar

class Animal:

    def speak(self) -> str:

        raise NotImplementedError

class Dog(Animal):

    def speak(self) -> str:

        return "Woof!"

T = TypeVar('T', bound=Animal)

def make_sound(animal: T) -> str:

    return animal.speak()

#clcoding.com

from typing import Callable

def apply_func(func: Callable[[int, int], int], a: int, b: int) -> int:

    return func(a, b)

#clcoding.com

from typing import Iterable, TypeVar

T = TypeVar('T')

def process_items(items: Iterable[T]) -> None:

    for item in items:

        # Process each item

        pass

#clcoding.com

from typing import TypeVar, Iterable

T = TypeVar('T')

def first_element(items: Iterable[T]) -> T:

    return next(iter(items))

#clcoding.com

from typing import List, Tuple

Point = Tuple[int, int]

Polygon = List[Point]

def area(polygon: Polygon) -> float:

    # Calculate area of polygon

    pass

#clcoding.com

from typing import Union
def square_root(num: Union[int, float]) -> Union[int, float]:
    return num ** 0.5

#clcoding.com
from typing import Optional

def greet(name: Optional[str]) -> str:
    if name:
        return f"Hello, {name}!"
    else:
        return "Hello, anonymous!"

#clcoding.com

Automating File Compression with gzip

 

Code:

import gzip

import shutil


def compress_file(input_file, output_file):

    with open(input_file, 'rb') as f_in:

        with gzip.open(output_file, 'wb') as f_out:

            shutil.copyfileobj(f_in, f_out)


# Example usage

input_filename = 'clcoding.txt'

output_filename = 'clcoding.txt.gz'

compress_file(input_filename, output_filename)

#clcoding.com 

Explanation:

Let's break down the code step by step:

import gzip: This line imports the gzip module, which provides functionalities for working with gzip-compressed files in Python. The gzip module allows you to create, read, and write gzip-compressed files.

import shutil: This line imports the shutil module, which provides a higher-level interface for file operations. In this script, shutil is used to copy the contents of one file to another efficiently.

def compress_file(input_file, output_file):: This line defines a function named compress_file that takes two parameters: input_file (the path to the file to be compressed) and output_file (the path where the compressed file will be saved).

with open(input_file, 'rb') as f_in:: This line opens the input file (input_file) in binary read mode ('rb') using the open() function. It uses a context manager (with statement) to automatically close the file when the block is exited. The file object is assigned to the variable f_in.

with gzip.open(output_file, 'wb') as f_out:: This line opens the output file (output_file) in gzip-compressed write mode ('wb') using gzip.open(). Similar to the previous with statement, it also uses a context manager to automatically close the file when the block is exited. The compressed file object is assigned to the variable f_out.

shutil.copyfileobj(f_in, f_out): This line copies the contents of the input file (f_in) to the gzip-compressed output file (f_out). It efficiently copies data between file objects without loading the entire file into memory.

input_filename = 'clcoding.txt': This line defines a variable input_filename and assigns it the name of the input file (clcoding.txt). This file will be compressed.

output_filename = 'clcoding.txt.gz': This line defines a variable output_filename and assigns it the name of the output file (clcoding.txt.gz). This file will store the compressed data.

compress_file(input_filename, output_filename): This line calls the compress_file function with the input and output filenames as arguments, which compresses the input file and saves the compressed data to the output file.

#clcoding.com: This line appears to be a comment, possibly indicating the source of the file (clcoding.com). Comments in Python are preceded by the # symbol and are ignored by the interpreter.

This script takes a file (clcoding.txt), compresses it using gzip, and saves the compressed data to a new file (clcoding.txt.gz).


Sunday 5 May 2024

Donut Charts using Python

 


Code:

import matplotlib.pyplot as plt

# Data to plot
labels = ['A', 'B', 'C', 'D']
sizes = [15, 30, 45, 10]

# Plot
plt.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=140)

# Draw a circle at the center of pie to make it look like a donut
centre_circle = plt.Circle((0,0),0.70,fc='white')
fig = plt.gcf()
fig.gca().add_artist(centre_circle)

# Equal aspect ratio ensures that pie is drawn as a circle
plt.axis('equal')

plt.title('Basic Donut Chart')
plt.show()

#clcoding.com

Explanation:


In this code snippet, we're using the matplotlib.pyplot module, which is a powerful library in Python for creating static, animated, and interactive visualizations. We're importing it using the alias plt, which is a common convention for brevity.

Here's a breakdown of the code:

Importing matplotlib.pyplot: import matplotlib.pyplot as plt
This line imports the matplotlib.pyplot module and assigns it the alias plt, allowing us to reference it with the shorter name plt throughout the code.

labels = ['A', 'B', 'C', 'D']
sizes = [15, 30, 45, 10]
These lines define the data we want to visualize. labels contains the labels for each segment of the pie chart, and sizes contains the corresponding sizes or values for each segment.
Plotting the pie chart:

plt.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=140)
Here, we use the plt.pie() function to create a pie chart. We pass sizes as the data to plot, labels to label each segment, autopct='%1.1f%%' to display the percentage for each segment, and startangle=140 to rotate the pie chart to start from the angle 140 degrees.
Drawing a circle to create a donut effect:

centre_circle = plt.Circle((0,0),0.70,fc='white')
fig = plt.gcf()
fig.gca().add_artist(centre_circle)
These lines draw a white circle at the center of the pie chart, creating a donut-like appearance. The plt.Circle() function creates a circle with the specified parameters: center (0,0) and radius 0.70.
Setting equal aspect ratio:

plt.axis('equal')
This line ensures that the plot is displayed with equal aspect ratio, so the pie chart appears as a circle rather than an ellipse.
Adding a title and displaying the plot:

plt.title('Basic Donut Chart')
plt.show()
Here, we set the title of the plot to 'Basic Donut Chart' using plt.title(), and then plt.show() displays the plot on the screen.
This code generates a basic donut chart with four segments labeled A, B, C, and D, where the size of each segment is determined by the values in the sizes list.



Code:

import matplotlib.pyplot as plt

# Data to plot
labels = ['A', 'B', 'C', 'D']
sizes = [15, 30, 45, 10]
explode = (0, 0.1, 0, 0)  # only "explode" the 2nd slice

# Plot
plt.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%', startangle=140)

# Draw a circle at the center of pie to make it look like a donut
centre_circle = plt.Circle((0,0),0.70,fc='white')
fig = plt.gcf()
fig.gca().add_artist(centre_circle)

# Equal aspect ratio ensures that pie is drawn as a circle
plt.axis('equal')

plt.title('Donut Chart with Exploded Slices')
plt.show()

#clcoding.com

Explanation: 

This code snippet is similar to the previous one, but it adds exploding effect to one of the slices in the pie chart. Let's break down the code:

Importing matplotlib.pyplot:

import matplotlib.pyplot as plt
This line imports the matplotlib.pyplot module and assigns it the alias plt, allowing us to reference it with the shorter name plt throughout the code.
Data to plot:

labels = ['A', 'B', 'C', 'D']
sizes = [15, 30, 45, 10]
explode = (0, 0.1, 0, 0)  # only "explode" the 2nd slice
Here, labels contains the labels for each segment of the pie chart, sizes contains the corresponding sizes or values for each segment, and explode contains the magnitude of the explosion for each slice. In this case, we're exploding the second slice ('B') by 0.1.
Plotting the pie chart:

plt.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%', startangle=140)
This line creates a pie chart using plt.pie(). The explode parameter is used to specify the amount by which to explode each slice. Here, we're exploding only the second slice ('B') by 0.1. Other parameters are similar to the previous example.
Drawing a circle to create a donut effect:

centre_circle = plt.Circle((0,0),0.70,fc='white')
fig = plt.gcf()
fig.gca().add_artist(centre_circle)
This part is the same as before. It draws a white circle at the center of the pie chart, creating a donut-like appearance.
Setting equal aspect ratio:

plt.axis('equal')
This line ensures that the plot is displayed with an equal aspect ratio, so the pie chart appears as a circle.
Adding a title and displaying the plot:

plt.title('Donut Chart with Exploded Slices')
plt.show()
Here, we set the title of the plot to 'Donut Chart with Exploded Slices' and then display the plot.
This code generates a donut chart with four segments labeled A, B, C, and D, where the second slice ('B') is exploded outwards. The size of each segment is determined by the values in the sizes list.




Code:

import matplotlib.pyplot as plt

# Data to plot
labels = ['A', 'B', 'C', 'D']
sizes1 = [25, 30, 35, 10]
sizes2 = [20, 40, 20, 20]

# Plot
fig, ax = plt.subplots()
ax.pie(sizes1, radius=1.2, labels=labels, autopct='%1.1f%%', startangle=140)
ax.pie(sizes2, radius=1, startangle=140, colors=['red', 'green', 'blue', 'yellow'])

# Draw a circle at the center of pie to make it look like a donut
centre_circle = plt.Circle((0,0),0.8,fc='white')
fig = plt.gcf()
fig.gca().add_artist(centre_circle)

# Equal aspect ratio ensures that pie is drawn as a circle
ax.set(aspect="equal")
plt.title('Donut Chart with Multiple Rings')
plt.show()

#clcoding.com

Explanation: 

This code snippet creates a donut chart with multiple rings, demonstrating the capability to display more than one dataset in the same chart. Let's dissect the code:

Importing matplotlib.pyplot:

import matplotlib.pyplot as plt
This line imports the matplotlib.pyplot module and assigns it the alias plt.
Data to plot:

labels = ['A', 'B', 'C', 'D']
sizes1 = [25, 30, 35, 10]
sizes2 = [20, 40, 20, 20]
Two sets of data are defined here: sizes1 and sizes2. Each set represents the values for different rings of the donut chart.
Plotting the donut chart:

fig, ax = plt.subplots()
ax.pie(sizes1, radius=1.2, labels=labels, autopct='%1.1f%%', startangle=140)
ax.pie(sizes2, radius=1, startangle=140, colors=['red', 'green', 'blue', 'yellow'])
This code creates a subplot (fig, ax = plt.subplots()) and then plots two pie charts on the same subplot using ax.pie().
The first ax.pie() call plots the outer ring (sizes1) with a larger radius (radius=1.2), while the second call plots the inner ring (sizes2) with a smaller radius (radius=1).
labels, autopct, and startangle parameters are used to configure the appearance of the pie charts.
Different colors are specified for the inner ring using the colors parameter.
Drawing a circle to create a donut effect:

centre_circle = plt.Circle((0,0),0.8,fc='white')
fig = plt.gcf()
fig.gca().add_artist(centre_circle)
This part is similar to previous examples. It draws a white circle at the center of the pie chart to create the donut-like appearance.
Setting equal aspect ratio:

ax.set(aspect="equal")
This line sets the aspect ratio of the subplot to 'equal', ensuring that the pie charts are displayed as circles.
Adding a title and displaying the plot:

plt.title('Donut Chart with Multiple Rings')
plt.show()
Finally, the title of the plot is set to 'Donut Chart with Multiple Rings', and the plot is displayed.
This code generates a donut chart with two rings, each representing different datasets (sizes1 and sizes2). Each ring has its own set of labels and colors, and they are displayed concentrically to create the donut chart effect.


Popular Posts

Categories

AI (27) Android (24) AngularJS (1) Assembly Language (2) aws (17) Azure (7) BI (10) book (4) Books (120) C (77) C# (12) C++ (82) Course (63) Coursera (181) Cybersecurity (24) data management (11) Data Science (97) Data Strucures (6) Deep Learning (10) Django (6) Downloads (3) edx (2) Engineering (14) Excel (13) Factorial (1) Finance (6) flutter (1) FPL (17) Google (19) Hadoop (3) HTML&CSS (46) IBM (25) IoT (1) IS (25) Java (92) Leet Code (4) Machine Learning (46) Meta (18) MICHIGAN (5) microsoft (4) Pandas (3) PHP (20) Projects (29) Python (765) Python Coding Challenge (255) Questions (2) R (70) React (6) Scripting (1) security (3) Selenium Webdriver (2) Software (17) SQL (40) UX Research (1) web application (8)

Followers

Person climbing a staircase. Learn Data Science from Scratch: online program with 21 courses