Python Records and Highlights in 2024

 

1. Python Adoption Records:

   • Surpassed 50 million active developers globally using Python in various domains.
   • Ranked as the #1 language on TIOBE and Stack Overflow Developer Survey for the 5th consecutive year.

2. Most Downloaded Libraries:

   • NumPy, Pandas, and Matplotlib retained their spots as the most downloaded libraries for data analysis.
   • Libraries like Transformers (by Hugging Face) broke records in downloads due to generative AI applications.

3. Longest Python Code Base:

   • Open-source project pandas reached a milestone with over 200k lines of code, reflecting its complexity and growth.

4. Most Forked GitHub Python Repository:

   • Python itself remained the most forked Python repository on GitHub, followed closely by projects like Django and Flask.

5. Highest Salary for Python Developers:

   • Python developers working in AI research reported an average annual salary of $180,000 in leading tech hubs like Silicon Valley.

6. Top Trending Python Tools in 2024:

   • Streamlit: For building data-driven apps.
   • FastAPI: For creating fast and secure RESTful APIs.
   • Poetry: For Python dependency management and packaging.

7. Learning Python in 2024:

• Python remained the most taught language in schools and universities globally.
• Platforms like freeCodeCamp, Kaggle, and HackerRank saw a significant surge in Python-based coding challenges and courses.

Python Programming in 2024: Summary

1. Popularity and Adoption:

   • Python maintained its position as one of the most popular programming languages worldwide, particularly for data science, machine learning, and web development.
   • Python’s simplicity continued to attract new developers, making it a top choice for beginners in programming.

2. New Features in Python 3.13:

   • Performance Improvements: Python 3.13 introduced significant enhancements in performance, especially in I/O operations and memory management.
   • Syntax Updates: Added support for pattern matching enhancements and cleaner error messages.
   • Typing Updates: Continued focus on static type hints with improved support for generics and type narrowing.

3. AI and Machine Learning:

   • Python remained the dominant language for AI and machine learning with tools like TensorFlow, PyTorch, and Hugging Face.
   • New Libraries: Advanced AI libraries like PyCaret 3.0 and LangChain gained traction for low-code AI and generative AI applications.

4. Web Development:

   • Frameworks like FastAPI and Django introduced major updates, focusing on developer experience and scalability.
   • Integration of AI with web applications became a popular trend, with Python enabling rapid prototyping.

5. Community and Events:

   • Python conferences like PyCon 2024 (held in Toronto) set attendance records, highlighting global interest in Python.
   • The Python Software Foundation (PSF) expanded its initiatives to promote diversity and inclusivity in the Python community.

Read More

Python Coding challenge - Day 315| What is the output of the following Python Code?

 

Code Explanation:

Lambda Function:

lambda a, b: abs(a - b) defines an anonymous function (lambda function) that takes two arguments, a and b.

The function calculates the absolute difference between a and b using the abs() function.

abs(x) returns the absolute value of x (i.e., it removes any negative sign from the result).

Assigning the Function:

absolute_diff = lambda a, b: abs(a - b) assigns the lambda function to the variable absolute_diff.

Now, absolute_diff can be used as a regular function to compute the absolute difference between two numbers.

Calling the Function:

result = absolute_diff(7, 12) calls the absolute_diff function with the arguments 7 and 12.

Inside the function:

a−b=7−12=−5.

abs(-5) evaluates to 5, as the abs() function removes the negative sign.

Printing the Result:

print(result) outputs the value of result to the console, which is 5.

Output:

The program prints:

5

Read More

Python Coding challenge - Day 314| What is the output of the following Python Code?

 

Code Explanation:

Lambda Function:

lambda x: x ** 0.5 defines an anonymous function (lambda function) that takes a single argument x.

The body of the function is x ** 0.5, which calculates the square root of x.

In Python, raising a number to the power of 0.5 is equivalent to taking its square root.

Assigning the Function:

sqrt = lambda x: x ** 0.5 assigns the lambda function to the variable sqrt.

Now, sqrt can be used as a regular function to compute square roots.

Calling the Function:

result = sqrt(16) calls the sqrt function with the argument 16.

Inside the function:

16 ** 0.5 is calculated.

The function returns 4.0.

Printing the Result:

print(result) outputs the value of result to the console, which is 4.0.

Output:

The program prints:

4.0

Note:

The result is 4.0 (a float), even though the square root of 16 is 4, because the ** operator with 0.5 produces a floating-point number.

If you want the output as an integer, you can cast the result to an int:

sqrt = lambda x: int(x ** 0.5)

result = sqrt(16)

print(result)

This would print:

4

Read More

Python Coding challenge - Day 312| What is the output of the following Python Code?

 

Code Explanation:

Lambda Function:

lambda c: (c * 9/5) + 32 defines an anonymous function (lambda function) that takes a single argument c.

The body of the function is (c * 9/5) + 32. This formula converts a temperature from Celsius to Fahrenheit.

Assigning the Function:

c_ to _f = lambda c: (c * 9/5) + 32 assigns the lambda function to the variable c_to_f.

Now, c_to_f can be used as a regular function to convert temperatures.

Calling the Function:

result = c_to_f(25) calls the c_to_f function with the argument 25 (25 degrees Celsius).

Inside the function, the formula (25 * 9/5) + 32 is evaluated:

25×9/5=45

45+32=77

So, the function returns 77.

Printing the Result:

print(result) outputs the value of result to the console, which is 77.

Output:

The program prints:

77

This shows that 25 degrees Celsius is equivalent to 77 degrees Fahrenheit.

Read More

Python Coding challenge - Day 311| What is the output of the following Python Code?

 Code Explanation:

Lambda Function:

lambda x, y: x * y creates an anonymous function (lambda function) that takes two arguments, x and y.

The function's body is x * y, meaning it returns the product of x and y.

Assigning to a Variable:

multiply = lambda x, y: x * y assigns the lambda function to the variable multiply.

Now, multiply can be used as a regular function.

Calling the Function:

result = multiply(4, 7) calls the multiply function with the arguments 4 and 7.

Inside the function, x becomes 4 and y becomes 7, so the return value is 4 * 7, which is 28.

Printing the Result:

print(result) outputs the value of result to the console, which is 28.

Output:

The program prints:

28

Read More

Python Quiz on Identity Operator

 

Read More

Day 64 : Python Program to Remove Odd Indexed Characters in a string

 def remove_odd_indexed_chars(input_string):

    """

    Remove characters at odd indices from the input string.

      Args:

        input_string (str): The string to process.

        Returns:

        str: A new string with characters at odd indices removed.

    """

    return input_string[::2]

if __name__ == "__main__":

    input_string = input("Enter a string: ")

    result = remove_odd_indexed_chars(input_string)

    print("String after removing odd indexed characters:", result)

#source code --> clcoding.com 

Code Explanation:

1. Function Definition

def remove_odd_indexed_chars(input_string):

def: Used to define a function.

remove_odd_indexed_chars: The name of the function, which describes its purpose (removing odd-indexed characters).

input_string: A parameter that represents the input string the user provides.

2. Docstring

    """

    Remove characters at odd indices from the input string.

    Args:

        input_string (str): The string to process.

    Returns:

        str: A new string with characters at odd indices removed.

    """

A docstring provides an explanation of the function:

Purpose: The function removes characters at odd indices.

Args: It expects one argument:

input_string: The string to be processed.

Returns: It outputs a new string with the odd-indexed characters removed.

3. Function Logic

    return input_string[::2]

input_string[::2]: This is a slicing operation. Here's how it works:

Start (start): By default, starts at index 0 (the first character).

Stop (stop): By default, goes to the end of the string.

Step (step): Specifies the interval; 2 means take every second character.

Effect:

Only characters at even indices (0, 2, 4, ...) are retained.

Characters at odd indices (1, 3, 5, ...) are skipped.

The resulting string is returned to the caller.

4. Main Execution Block

if __name__ == "__main__":

if __name__ == "__main__"::

Ensures the code inside this block runs only when the script is executed directly (not imported as a module in another script).

5. Input Prompt

    input_string = input("Enter a string: ")

input("Enter a string: "):

Prompts the user to enter a string.

The entered string is stored in the variable input_string.

6. Function Call

    result = remove_odd_indexed_chars(input_string)

remove_odd_indexed_chars(input_string):

Calls the function remove_odd_indexed_chars with the user-provided string (input_string) as an argument.

The function processes the string and returns a new string with odd-indexed characters removed.

result:

Stores the returned value (the modified string).

7. Output

    print("String after removing odd indexed characters:", result)

print:

Outputs the result to the user.

Displays the modified string with odd-indexed characters removed.

Read More

Day 63 : Python Program to Check If a String is Pangram or Not

 

import string

def is_pangram(sentence):

    """

    Check if a sentence is a pangram.

    A pangram contains every letter of the English alphabet at least once.

    Args:

        sentence (str): The input string to check.

    Returns:

        bool: True if the sentence is a pangram, False otherwise.

    """

    alphabet = set(string.ascii_lowercase)

    letters_in_sentence = set(char.lower() for char in sentence if char.isalpha())

    return alphabet <= letters_in_sentence

if __name__ == "__main__":

    input_sentence = input("Enter a sentence: ")

    if is_pangram(input_sentence):

        print("The sentence is a pangram.")

    else:

        print("The sentence is not a pangram.")

#source code --> clcoding.com 

Code Explanation:

1. Importing the string module

import string

The string module provides constants such as string.ascii_lowercase, which is a string containing all lowercase letters ('abcdefghijklmnopqrstuvwxyz').

2. Function: is_pangram

def is_pangram(sentence):

    """

    Check if a sentence is a pangram.

    A pangram contains every letter of the English alphabet at least once.

    Args:

        sentence (str): The input string to check.

    Returns:

        bool: True if the sentence is a pangram, False otherwise.

    """

    alphabet = set(string.ascii_lowercase)  # Create a set of all 26 lowercase letters

alphabet: A set containing all 26 letters of the English alphabet. Using set ensures easy comparison with the letters in the sentence.

    letters_in_sentence = set(char.lower() for char in sentence if char.isalpha())

letters_in_sentence: A set comprehension that:

Iterates over each character in the sentence.

Converts the character to lowercase using char.lower() to make the comparison case-insensitive.

Checks if the character is alphabetic (char.isalpha()) to filter out non-letter characters.

Adds valid characters to the set, automatically eliminating duplicates.

    return alphabet <= letters_in_sentence

alphabet <= letters_in_sentence: This checks if all elements of the alphabet set are present in letters_in_sentence.

<=: Subset operator. If alphabet is a subset of letters_in_sentence, the function returns True.

3. Main Execution Block

if __name__ == "__main__":

    input_sentence = input("Enter a sentence: ")

This ensures that the code runs only when executed directly (not when imported as a module).

    if is_pangram(input_sentence):

        print("The sentence is a pangram.")

    else:

        print("The sentence is not a pangram.")

Takes user input and checks if it is a pangram using the is_pangram function. Prints the result accordingly.

Read More

Python Coding Challange - Question With Answer(01281224)

 

What will the following code output?

print([x**2 for x in range(10) if x % 2 == 0])

• [0, 1, 4, 9, 16]

• [0, 4, 16, 36, 64]

• [4, 16, 36, 64]

• [1, 4, 9, 16, 25]

1. List Comprehension Syntax

This code uses list comprehension, a concise way to create lists in Python. The general structure is:

[expression for item in iterable if condition]

• expression: What you want to compute for each item.
• item: The current element from the iterable.
• iterable: A sequence, such as a list or range.
• if condition: A filter to include only items that satisfy the condition.

---

2. Components of the Code

a. range(10)

• range(10) generates numbers from 0 to 9.

b. if x % 2 == 0

• This is the filter condition.
• x % 2 calculates the remainder when x is divided by 2.
  • If the remainder is 0, the number is even.
• This condition selects only the even numbers from 0 to 9.

c. x**2

• For each even number, x**2 computes the square of x.

---

3. Step-by-Step Execution

Step 1: Generate Numbers from range(10)

The numbers are:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Step 2: Apply the Condition if x % 2 == 0

Keep only even numbers:

0, 2, 4, 6, 8

Step 3: Compute the Expression x**2

Calculate the square of each even number:

• $0^2 = 0$
• $2^2 = 4$
• $4^2 = 16$
• $6^2 = 36$
• $8^2 = 64$

Step 4: Create the Final List

The resulting list is:

[0, 4, 16, 36, 64]

---

4. Output

The code prints:

[0, 4, 16, 36, 64]

Read More

Fetch Trending Searches using Python

 

from pytrends.request import TrendReq

# Connect to Google Trends

pytrends = TrendReq()

region = input("Enter the region: ")

trending = pytrends.trending_searches(pn=region )

print(trending)

#source code --> clcoding.com

Read More

Python Quiz on Membership Operator

 

Read More

Python Coding challenge - Day 23| What is the output of the following Python Code?

Step-by-Step Explanation:

List Creation:

a is assigned a list containing one element: [10].

b is assigned a separate list containing the same element: [10].

Identity Comparison (is):

The is operator checks whether two variables refer to the same object in memory (i.e., have the same identity).

Although a and b have the same content ([10]), they are stored in different locations in memory. They are two distinct objects.

Result:

Since a and b are distinct objects, a is b evaluates to False.

Important Note:

If you want to check if the contents of a and b are the same, you should use the equality operator (==):

print(a == b)  # This will return True because the content of both lists is identical.

Output:

False

Read More

Python Coding challenge - Day 22| What is the output of the following Python Code?

Step-by-Step Explanation:

Initialization:

my_list is initialized as a list containing three elements: [1, 2, 3].

Using append:

The append method adds a single element to the end of a list.

Here, [4, 5] is a list, and it's treated as a single element.

After the append operation, my_list becomes [1, 2, 3, [4, 5]].

Notice that [4, 5] is now a sublist (nested list) within my_list.

Using len:

The len function returns the number of top-level elements in the list.

In my_list = [1, 2, 3, [4, 5]], there are four top-level elements:

1

2

3

[4, 5] (the entire sublist is considered one element).

Output:

The length of my_list is 4.

Final Output:

4

 

Read More

Python Coding challenge - Day 21| What is the output of the following Python Code?

 

Step-by-step Explanation:

Initialize the List:

cl is initialized as an empty list [].

Multiply the List:

When you multiply a list by an integer, Python creates a new list where the elements of the original list are repeated.

Syntax: list * n → repeats the elements of list, n times.

Empty List Multiplied:

Since cl is an empty list, repeating its elements (even 2 times) results in another empty list because there are no elements to repeat.

Output:

The result of cl * 2 is [].

[]

Read More

Day 62: Create Audiobook Using Python

from gtts import gTTS

import os

def create_audiobook(text_file, output_file):

    with open(text_file, 'r', encoding='utf-8') as file:

        text = file.read()

     tts = gTTS(text=text, lang='en')

    tts.save(output_file)

    print(f"Audiobook saved as {output_file}")

text_file = "clcoding_hindi.txt"  

output_file = "clcoding_hindi.mp3"

create_audiobook(text_file, output_file)

os.system(f"start {output_file}")  

#source code --> clcoding.com

Code Explanation:

1. Importing Required Libraries:

from gtts import gTTS

import os

from gtts import gTTS:

Imports the gTTS class from the gtts library, which is used to convert text to speech.

gTTS allows you to specify the text, language, and other options for generating the speech.

import os:

Imports the os module, which provides functions to interact with the operating system, such as running commands (os.system) to play the generated MP3 file.

2. Defining the create_audiobook Function:

def create_audiobook(text_file, output_file):

What It Does:

Defines a function named create_audiobook that takes two arguments:

text_file: Path to the input text file containing the content to be converted into speech.

output_file: Name of the MP3 file to save the audiobook.

3. Reading the Text File:

    with open(text_file, 'r', encoding='utf-8') as file:

        text = file.read()

open(text_file, 'r', encoding='utf-8'):

Opens the specified text_file in read mode ('r') with UTF-8 encoding to handle special characters if present.

with Statement:

Ensures the file is properly closed after it is read.

text = file.read():

Reads the entire content of the file and stores it in the variable text.

4. Converting Text to Speech:

    tts = gTTS(text=text, lang='en')

gTTS(text=text, lang='en'):

Converts the text to speech using the gTTS library.

Arguments:

text: The text content to convert.

lang='en': Specifies the language for the speech (English in this case).

tts:

A gTTS object that contains the generated speech.

5. Saving the Audiobook:

    tts.save(output_file)

tts.save(output_file):

Saves the generated speech to an MP3 file specified by output_file.

6. Confirmation Message:

    print(f"Audiobook saved as {output_file}")

print(...):

Prints a confirmation message to inform the user that the audiobook has been saved successfully.

7. Specifying the Input and Output Files:

text_file = "clcoding_hindi.txt"  

output_file = "clcoding_hindi.mp3"

text_file:

Specifies the name of the input text file that contains the content to be converted to speech.

output_file:

Specifies the name of the output MP3 file to save the audiobook.

8. Calling the Function:

create_audiobook(text_file, output_file)

create_audiobook(...):

Calls the create_audiobook function with the text_file and output_file arguments to generate the audiobook.

9. Playing the Audiobook:

os.system(f"start {output_file}")  

os.system(f"start {output_file}"):

Executes an operating system command to play the generated MP3 file.

Platform-Specific:

On Windows: start opens the file in the default media player.

On Linux or macOS, you might use commands like xdg-open or open instead.

 

Read More

Day 61: Python Program to Find GCD of Two Numbers Using Recursion

 

def gcd(a, b):

    """

   Function to calculate GCD of two numbers using recursion

    """

    if b == 0:

        return a

    else:

        return gcd(b, a % b)

num1 = int(input("Enter the first number: "))

num2 = int(input("Enter the second number: "))

result = gcd(num1, num2)

print(f"The GCD of {num1} and {num2} is {result}")

#source code --> clcoding.com 

Code Explanation:

1. Function Definition:

def gcd(a, b):

    """

    Function to calculate GCD of two numbers using recursion

    """

def gcd(a, b):

This defines a function named gcd that takes two arguments, a and b.

a and b represent the two numbers for which we want to calculate the Greatest Common Divisor (GCD).

""" ... """

This is a docstring that describes what the function does. It mentions that the function calculates the GCD of two numbers using recursion.

2. Base Case:

    if b == 0:

        return a

if b == 0:

Checks whether b (the second number) is 0.

This is the base case of recursion. When b is 0, the recursion stops.

return a

If b is 0, the function returns the value of a, as the GCD of any number and 0 is the number itself.

Example: GCD(8, 0) → 8.

3. Recursive Case:

    else:

        return gcd(b, a % b)

else:

Executes if b is not 0.

return gcd(b, a % b)

This is the recursive call. The function calls itself with:

b as the new first argument.

a % b (the remainder when a is divided by b) as the new second argument.

This step reduces the size of the problem with each recursive call, eventually reaching the base case where b is 0.

4. Taking User Input:

num1 = int(input("Enter the first number: "))

num1 = int(input("Enter the first number: "))

Prompts the user to input the first number with the message "Enter the first number: ".

input() captures the user’s input as a string.

int() converts the string input to an integer so it can be used in calculations.

The integer value is stored in the variable num1.

num2 = int(input("Enter the second number: "))

num2 = int(input("Enter the second number: "))

Similar to the above, prompts the user to input the second number.

Converts the input string to an integer and stores it in the variable num2.

5. Calling the Function and Storing the Result:

result = gcd(num1, num2)

result = gcd(num1, num2)

Calls the gcd function with num1 and num2 as arguments.

The function computes the GCD of num1 and num2 and returns the result.

The returned GCD is stored in the variable result.

6. Printing the Result:

print(f"The GCD of {num1} and {num2} is {result}")

print(f"...")

Prints the GCD of the two numbers in a formatted message.

F-String (f"..."): Dynamically inserts the values of num1, num2, and result into the string.

Example Output: The GCD of 48 and 18 is 6.

Read More

Python Coding Challange - Question With Answer(01271224)

 

1. Understanding any() Function

• The any() function in Python returns True if at least one element in an iterable evaluates to True. Otherwise, it returns False.
• An empty iterable (e.g., []) always evaluates to False.

---

2. Evaluating Each Expression

a. 5 * any([])

• any([]) → The list is empty, so it evaluates to False.
• 5 * False → False is treated as 0 when used in arithmetic.
• Result: 0

b. 6 * any([[]])

• any([[]]) → The list contains one element: [[]].
  • [[]] is a non-empty list, so it evaluates to True.
• 6 * True → True is treated as 1 in arithmetic.
• Result: 6

c. 7 * any([0, []])

• any([0, []]) →
  • 0 and [] are both falsy, so the result is False.
• 7 * False → False is treated as 0 in arithmetic.
• Result: 0

d. 8

• This is a constant integer.
• Result: 8

---

3. Summing Up the Results

The sum() function adds all the elements of the list:

sum([0, 6, 0, 8]) = 14

---

Final Output

The code outputs : 14

Read More

Happy New Year 2025 using Python

 

import random

from pyfiglet import Figlet

from termcolor import colored

TEXT = "Happy New Year 2025"

COLOR_LIST = ['red', 'green', 'blue', 'yellow']

with open('texts.txt') as f:

    font_list = [line.strip() for line in f]

figlet = Figlet()

for _ in range(1):  

    random_font = random.choice(font_list)

    random_color = random.choice(COLOR_LIST)

    figlet.setFont(font=random_font)

    text_art = colored(figlet.renderText(TEXT), random_color)

    print("\n", text_art)

#source code --> clcoding.com

Read More

Python Quiz on Bitwise Operator

 

Read More

Audio to Text using Python

 

pip install SpeechRecognition pydub

import speech_recognition as sr

recognizer = sr.Recognizer()

audio_file = "audiobook.wav"

from pydub import AudioSegment

AudioSegment.from_mp3(audio_file).export(audio_file , format="wav")

with sr.AudioFile(audio_file) as source:

    audio_data = recognizer.record(source)

try:

    text = recognizer.recognize_google(audio_data)

    print("Extracted Text:", text)

except sr.UnknownValueError:

    print("Could not understand the audio.")

except sr.RequestError as e:

    print("API Error:", e)

Read More

Day 60: Python Program to Find Lcm of Two Number Using Recursion

 

def find_lcm(a, b):

    def find_gcd(a, b):

        if b == 0:

            return a

        else:

            return find_gcd(b, a % b)

    return abs(a * b) // find_gcd(a, b)

num1 = int(input("Enter the first number: "))

num2 = int(input("Enter the second number: "))

lcm = find_lcm(num1, num2)

print(f"The LCM of {num1} and {num2} is {lcm}.")

#source code --> clcoding.com 

Code Explanation:

1. def find_lcm(a, b):

This defines a function find_lcm that takes two parameters, a and b, representing the two numbers for which we want to calculate the LCM.

2. def find_gcd(a, b):

Inside the find_lcm function, there is a nested helper function find_gcd to calculate the GCD of two numbers.

The function uses recursion:

Base Case: If b == 0, return a as the GCD.

Recursive Case: Call find_gcd(b, a % b) until b becomes 0.

This is an implementation of the Euclidean Algorithm to compute the GCD.

3. return abs(a * b) // find_gcd(a, b)

Once the GCD is determined, the formula for calculating LCM is used:

LCM

(𝑎,𝑏)=∣𝑎×𝑏∣/GCD(𝑎,𝑏)

​abs(a * b) ensures the product is non-negative (handles potential negative input).

// is used for integer division to compute the LCM.

4. num1 = int(input("Enter the first number: "))

Takes input from the user for the first number, converts it to an integer, and stores it in num1.

5. num2 = int(input("Enter the second number: "))

Takes input from the user for the second number, converts it to an integer, and stores it in num2.

6. lcm = find_lcm(num1, num2)

Calls the find_lcm function with num1 and num2 as arguments.

The LCM of the two numbers is stored in the variable lcm.

7. print(f"The LCM of {num1} and {num2} is {lcm}.")

Outputs the calculated LCM using an f-string for formatted output.

Read More

Day 59: Python Program to Find GCD of Two Number

def find_gcd(a, b):

    while b:

        a, b = b, a % b

    return a

num1 = int(input("Enter the first number: "))

num2 = int(input("Enter the second number: "))

gcd = find_gcd(num1, num2)

print(f"The GCD of {num1} and {num2} is {gcd}.")

 #source code --> clcoding.com 

Code Explanation:

1. def find_gcd(a, b):

This defines a function named find_gcd that takes two parameters, a and b, representing the two numbers whose GCD you want to find.

2. while b:

This while loop runs as long as b is not zero. The loop keeps iterating until b becomes zero.

The condition while b is equivalent to while b != 0.

3. a, b = b, a % b

Inside the loop, this line uses Python's tuple unpacking to simultaneously update the values of a and b.

a becomes the current value of b, and b becomes the remainder of the division a % b.

This step implements the Euclidean Algorithm, which states that the GCD of two numbers does not change if the larger number is replaced by its remainder when divided by the smaller number.

The process continues until b becomes zero, at which point a holds the GCD.

4. return a

When the loop ends, the function returns the value of a, which is the GCD of the two numbers.

5. num1 = int(input("Enter the first number: "))

This line takes input from the user, converts it to an integer, and stores it in the variable num1.

6. num2 = int(input("Enter the second number: "))

Similarly, this line takes the second input from the user, converts it to an integer, and stores it in the variable num2.

7. gcd = find_gcd(num1, num2)

The find_gcd function is called with num1 and num2 as arguments, and the result is stored in the variable gcd.

8. print(f"The GCD of {num1} and {num2} is {gcd}.")

This line prints the GCD using an f-string to format the output.

Read More

Python Quiz on While Loop

 

Read More

Python Coding Challange - Question With Answer(01261224)

 

Step 1: Create a list

data = [1, 2, 3]

This creates a list named data with three elements: $1, 2, 3$.

---

Step 2: Unpack the list into a set

output = {*data, *data}

Here:

• The unpacking operator * is used with the list data. It extracts the elements $1, 2, 3$ from the list.
• {*data, *data} means the unpacked elements of the list are inserted into a set twice. However:
  • Sets in Python are unordered collections of unique elements.
  • Even though the elements $1, 2, 3$ are unpacked twice, the set will only store one copy of each unique value.

Result:

output = {1, 2, 3}

---

Step 3: Print the set

print(output)

The print statement outputs the set output:

{1, 2, 3}

---

Key Points to Remember:

1. The unpacking operator * extracts elements from an iterable (like a list, tuple, or set).
2. A set is a collection of unique elements, so duplicates are automatically removed.
3. Even though *data is unpacked twice, the final set contains only one instance of each value.

---

Output:

{1, 2, 3}

Read More

Python Coding challenge - Day 20| What is the output of the following Python Code?

 

Code Explanation:

Tuple Definition:

my_tuple = (1, 2, 3)

This creates a tuple called my_tuple with three elements: 1, 2, and 3.

Tuples in Python are immutable, meaning their elements cannot be changed once they are created.

Attempt to Modify an Element of the Tuple:

my_tuple[1] = 4

This line tries to change the value of the element at index 1 (which is 2) to 4.

However, since tuples are immutable, you cannot assign a new value to an element of the tuple.

Trying to modify an element of a tuple will raise a TypeError.

Error:

You will get an error like this:

TypeError: 'tuple' object does not support item assignment

Print Statement:

print(my_tuple)

This line would print the tuple, but it will not be reached because the code will raise an error in the previous line.

Final Output:

Type error

Read More

Python Coding challenge - Day 310| What is the output of the following Python Code?

 

Code Explanation:

Lambda Function Definition:

cube = lambda x: x ** 3

lambda is used to define an anonymous function (a function without a name) in Python.

lambda x: defines a function that takes one argument x.

x ** 3 is the expression that is computed and returned. This expression calculates the cube of x (i.e., x raised to the power of 3).

The function defined is equivalent to:

def cube(x):

    return x ** 3

But the lambda allows us to define the function in a single line.

Function Call:

result = cube(3)

The lambda function cube is called with the argument 3.

Inside the function, x is replaced by 3, and the expression 3 ** 3 is computed.

3 ** 3 means 3 raised to the power of 3, which equals 27.

Printing the Result:

print(result)

The value of result, which is 27, is printed to the console.

Output:

27

Read More

Python Coding challenge - Day 309| What is the output of the following Python Code?

Code Explanation:

remainder = lambda x, y: x % y

result = remainder(10, 3)

print(result)

Breakdown:

Lambda Function Definition:

remainder = lambda x, y: x % y

lambda is used to create an anonymous (inline) function in Python.

lambda x, y: specifies that the function takes two arguments, x and y.

x % y is the expression that is evaluated and returned. It calculates the remainder when x is divided by y.

This creates a function named remainder that takes two numbers and returns their remainder.

Function Call:

result = remainder(10, 3)

The remainder function is called with arguments 10 (for x) and 3 (for y).

Inside the lambda function, 10 % 3 is computed.

% is the modulus operator that gives the remainder when dividing 10 by 3.

10 % 3 equals 1 because when 10 is divided by 3, the quotient is 3 and the remainder is 1.

Printing the Result:

print(result)

The value of result, which is 1, is printed to the console.

Output:

1

Read More

Python Quiz on Assignment Operator

 

Read More

Day 58: Python Program to Find LCM of Two Numbers

 

import math

def find_lcm(num1, num2):

    """

    Function to find the LCM of two numbers.

    :param num1: First number

    :param num2: Second number

    :return: LCM of num1 and num2

    """

    gcd = math.gcd(num1, num2)

    lcm = (num1 * num2) 

    return lcm

num1 = int(input("Enter the first number: "))

num2 = int(input("Enter the second number: "))

result = find_lcm(num1, num2)

print(f"The LCM of {num1} and {num2} is: {result}")

#source code --> clcoding.com 

Code Explanation:

Importing the math Module

import math

The math module is imported to use its built-in math.gcd() function for calculating the Greatest Common Divisor (GCD) of two numbers.

Defining the Function: find_lcm

def find_lcm(num1, num2):

    """

    Function to find the LCM of two numbers.

    

    :param num1: First number

    :param num2: Second number

    :return: LCM of num1 and num2

    """

Purpose: Calculates the LCM of two numbers.

Parameters:

num1: First input number.

num2: Second input number.

Return Value: The LCM of num1 and num2.

Calculating the GCD

    gcd = math.gcd(num1, num2)

math.gcd(num1, num2):

Finds the Greatest Common Divisor (GCD) of num1 and num2.

The GCD is the largest integer that evenly divides both numbers.

Calculating the LCM

    lcm = (num1 * num2) 

​ 

The product of the two numbers is divided by their GCD to compute the LCM efficiently.

Why it works: This relationship between GCD and LCM ensures that the LCM is the smallest positive integer that is divisible by both numbers.

Returning the LCM

    return lcm

Returns the computed LCM to the caller.

User Input

num1 = int(input("Enter the first number: "))

num2 = int(input("Enter the second number: "))

Prompts the user to input two integers:

num1: The first number.

num2: The second number.

Converts the input strings to integers using int().

Calling the Function

result = find_lcm(num1, num2)

Calls the find_lcm() function with num1 and num2 as arguments.

Stores the result (the LCM) in the variable result.

Displaying the Result

print(f"The LCM of {num1} and {num2} is: {result}")

Uses an f-string to display the computed LCM in a user-friendly format.

Read More

Day 57: Python Program to Find Sum of Cosine Series

 import math

def cosine_series_sum(x, n):

    """

    Calculate the sum of the cosine series up to n terms for a given x.

    :param x: The angle in radians

    :param n: The number of terms in the series

    :return: The sum of the cosine series

    """

    cosine_sum = 0

    sign = 1  

    for i in range(n):

        term = sign * (x**(2 * i)) / math.factorial(2 * i)

        cosine_sum += term

        sign *= -1  

     return cosine_sum

x = float(input("Enter the value of x (in radians): "))

n = int(input("Enter the number of terms in the series: "))

result = cosine_series_sum(x, n)

print(f"The sum of the cosine series up to {n} terms for x = {x} is: {result}")

#source code --> clcoding.com 

Code Explanation:

Import Statement

import math

Imports the math module, which provides mathematical functions like math.factorial().

Function Definition: cosine_series_sum()

def cosine_series_sum(x, n):

    """

    Calculate the sum of the cosine series up to n terms for a given x.

    

    :param x: The angle in radians

    :param n: The number of terms in the series

    :return: The sum of the cosine series

    """

Purpose: Defines a function to compute the cosine of an angle using its Taylor series expansion.

Parameters:

x: The angle in radians.

n: The number of terms in the series.

Returns: The computed cosine value as the sum of the series.

Initialize Variables

    cosine_sum = 0

    sign = 1

cosine_sum: Initializes the sum to 0.

sign: Tracks the alternating signs (+1,−1,+1,−1,…) in the series.

For Loop to Compute Series

    for i in range(n):

Iterates through 𝑛

n terms of the cosine series.

Calculate Each Term

        term = sign * (x**(2 * i)) / math.factorial(2 * i)

Computes each term in the Taylor series:𝑥2 𝑖x 2i Raises x to the power 

2i (only even powers for cosine).

(2i)!: Computes the factorial of 

2i using math.factorial().

sign: Alternates between +1 and −1 for successive terms.

 

Add Term to Sum

        cosine_sum += term

Adds the computed term to the cumulative sum.

Alternate the Sign

        sign *= -1

Multiplies sign by −1to alternate between 

+1 and −1 for the next term.

Return the Result

    return cosine_sum

Returns the final sum of the cosine series.

Input the Angle and Number of Terms

x = float(input("Enter the value of x (in radians): "))

n = int(input("Enter the number of terms in the series: "))

Prompts the user to:

Enter the angle (𝑥 )in radians.

Enter the number of terms (𝑛)for the series.

Call the Function

result = cosine_series_sum(x, n)

Calls the cosine_series_sum() function with the provided inputs.

Stores the result in the variable result.

Output the Result

print(f"The sum of the cosine series up to {n} terms for x = {x} is: {result}")

Formats and displays the result using an f-string.

Read More

Day 56: Python Program to Find Sum of Sine Series

 

import math

def factorial(n):

    """Calculate the factorial of a number."""

    if n == 0 or n == 1:

        return 1

    return n * factorial(n - 1)

def sine_series(x, terms):

    """Calculate the sum of the sine series."""

    sine_sum = 0

    for i in range(terms):

        power = 2 * i + 1

        sign = (-1) ** i 

        term = sign * (x ** power) / factorial(power)

        sine_sum += term

    return sine_sum

angle_degrees = float(input("Enter the angle in degrees: "))

terms = int(input("Enter the number of terms: "))

angle_radians = math.radians(angle_degrees)

sine_sum = sine_series(angle_radians, terms)

print(f"The sum of the sine series for {angle_degrees}° is: {sine_sum}")

#source code --> clcoding.com 

Code Explanation:

Import Statement

import math

Imports the math module to use its built-in functions, like math.radians for converting degrees to radians.

Factorial Function

def factorial(n):

    """Calculate the factorial of a number."""

    if n == 0 or n == 1:

        return 1

    return n * factorial(n - 1)

Purpose: Computes the factorial of n recursively.

Logic:

If 𝑛=0 or 𝑛=1, return 1 (base case).

Otherwise, return 𝑛×factorial(𝑛−1)(recursive step).

Example:

factorial(3)=3×2×1=6.

Sine Series Function

def sine_series(x, terms):

    """Calculate the sum of the sine series."""

    sine_sum = 0

    for i in range(terms):

        power = 2 * i + 1

        sign = (-1) ** i

        term = sign * (x ** power) / factorial(power)

        sine_sum += term

    return sine_sum

​

Logic:

power: Calculates the power 

2i+1 (odd powers only).sign: Alternates between 

1 and −1 for successive terms, determined by 

(−1)𝑖 .

sine_sum: Accumulates the sum of all terms up to the specified number of terms.

Input Angle in Degrees

angle_degrees = float(input("Enter the angle in degrees: "))

Prompts the user to enter the angle in degrees.

Converts the input to a float for precise calculations.

Input Number of Terms

terms = int(input("Enter the number of terms: "))

Prompts the user to specify the number of terms in the series.

Converts the input to an integer.

Convert Degrees to Radians

angle_radians = math.radians(angle_degrees)

Converts the angle from degrees to radians using the math.radians() function.

This step is necessary because the Taylor series for sine requires the angle in radians.

Calculate the Sine Series

sine_sum = sine_series(angle_radians, terms)

Calls the sine_series() function with:

angle_radians: The angle in radians.

terms: The number of terms in the series.

Stores the computed sum in sine_sum.

Output the Result

print(f"The sum of the sine series for {angle_degrees}° is: {sine_sum}")

Uses an f-string to display the result of the sine series for the input angle in degrees.

Read More

Day 55: Python Program to Read a Number n and Print the Series “1+2+… +n= “

 n = int(input("Enter a number: "))

series = " + ".join(str(i) for i in range(1, n + 1))

total_sum = sum(range(1, n + 1))

print(f"{series} = {total_sum}")

#source code --> clcoding.com 

Code Explanation:

Input

n = int(input("Enter a number: "))

Prompts the user to enter an integer.

Converts the input to an integer using int() and stores it in the variable n.

Generate the Series

series = " + ".join(str(i) for i in range(1, n + 1))

Generates a string representation of the series 

1+2+3+…+n:

range(1, n + 1): Creates a range of integers from 1 to 𝑛

n (inclusive).

str(i) for i in range(1, n + 1): 

Converts each number in the range to a string.

" + ".join(...): Joins these strings with " + " as the separator, forming the series.

For example:

If 

n=5, the result is: "1 + 2 + 3 + 4 + 5".

Calculate the Total Sum

total_sum = sum(range(1, n + 1))

Computes the sum of all integers from 1 to n:

range(1, n + 1): Creates a range of integers from 1 to 𝑛

n (inclusive).

sum(...):

 Adds all the numbers in the range.

For example:

If 𝑛=5, the result is: 1+2+3+4+5=15

Output the Result

print(f"{series} = {total_sum}")

Uses an f-string to format the output.

Prints the series and the total sum in the format:

series=total_sum

For example:

If 𝑛=5, the output is:

1 + 2 + 3 + 4 + 5 = 15

Read More

Wish Merry Christmas using Python

 

from colorama import Fore, Style

import numpy as np

z = np.column_stack((np.arange(15, 6, -1), np.arange(1, 18, 2)))

[print(Fore.GREEN + ' '*i + Fore.GREEN + '*'*j + 

       Style.RESET_ALL) for i, j in z]

[print(Fore.RED + ' '*13 + ' || ' + 

       Style.RESET_ALL) for _ in range(3)]

print(Fore.BLUE + ' '*11 + r'\======/' + Style.RESET_ALL)  

Read More