DEV Community: ahmed elboshi

What is Asynchronous Code? How to Use It in Python to Speed Up Your Code Learn by Building a Weather App! ☀️🌦️

ahmed elboshi — Fri, 04 Oct 2024 02:17:06 +0000

Hey there, future Python pro! 👋 So, you’ve probably heard the term “asynchronous” thrown around by developers like it’s some kind of magic spell. Today, we’re going to uncover the secrets of asynchronous code in Python, why it’s so awesome, and how to use it to speed up your code. And guess what? By the end, you’ll have built a nifty little weather app that requests data for multiple cities all at once. Let’s get to it!

Synchronous vs. Asynchronous Code

Before we dive in, let’s talk about synchronous and asynchronous code. These two types of code are like tortoises and hares 🐢🐇 of the programming world.

Synchronous Code

Synchronous code runs line-by-line. So, if you’re getting weather data for Paris and London, your code will first get Paris’ data, then wait until that’s done before moving on to London’s data. This makes your code simple to read, but it’s slow because it waits around doing nothing while each request finishes. Not ideal!

def get_weather_sync(city):
    # Imagine this function fetches weather data for a city
    print(f"Getting weather data for {city}...")
    # Pretend we wait here for the data
    time.sleep(2)
    print(f"Got data for {city}!")

get_weather_sync("Paris")
get_weather_sync("London")

Here, each city takes 2 seconds, so getting both takes a painful total of 4 seconds. 🥱

Asynchronous Code

Asynchronous code doesn’t wait around! If it’s fetching weather for Paris, it can also start fetching weather for London at the same time. It’s like having two arms: you can grab two things at once instead of one. This is where Python’s asyncio library comes in, letting you handle tasks concurrently.

Here’s a simple example of asynchronous code:

import asyncio

async def get_weather_async(city):
    print(f"Getting weather data for {city}...")
    await asyncio.sleep(2)
    print(f"Got data for {city}!")

async def main():
    await asyncio.gather(
        get_weather_async("Paris"),
        get_weather_async("London")
    )

asyncio.run(main())

Now, both tasks are done in 2 seconds instead of 4. Speedy!

Why Use Asynchronous Code?

Asynchronous code shines when you’re dealing with I/O-bound tasks. These tasks spend a lot of time waiting, like fetching data over the internet. With asynchronous code, your program can perform other actions while waiting, making it faster and more efficient.

Meet `asyncio`: Your Asynchronous Sidekick

Python’s asyncio library lets you write asynchronous code with a few powerful tools:

async def: Defines an asynchronous function.
await: Pauses the function until the awaited task is done.
asyncio.gather(): Runs multiple async functions at the same time.

Let’s Build a Weather App! 🌎⛅

Enough theory—let’s get our hands dirty! We’re going to make a simple weather app that gets data for multiple cities simultaneously.

Step 1: Set Up

First, you’ll need to install the aiohttp library, which helps with making async HTTP requests. Open your terminal and run:

pip install aiohttp

Step 2: Write the Asynchronous Weather Fetcher

We’re going to use a free weather API, wttr.in, which gives us weather info just by calling a URL.

import asyncio
import aiohttp

async def fetch_weather(session, city):
    url = f"http://wttr.in/{city}?format=3"
    async with session.get(url) as response:
        data = await response.text()
        print(f"Weather in {city}: {data}")

Here’s what’s happening:

We’re using aiohttp.ClientSession() to create a session for our requests.
The await response.text() line pauses our function until the data comes back.

Step 3: Run the Async Functions Together

Now, let’s add the main function that will fetch weather data for multiple cities simultaneously.

async def main():
    cities = ["Paris", "London", "New York", "Tokyo", "Sydney"]

    async with aiohttp.ClientSession() as session:
        tasks = [fetch_weather(session, city) for city in cities]
        await asyncio.gather(*tasks)

# Start the async event loop
asyncio.run(main())

In the main function:

We create a list of tasks for each city.
asyncio.gather(*tasks) runs them all at once, so our weather app gets data super fast!

Step 4: Run Your App

Save your code, and then run it! You should see the weather for all cities printed out in about 2 seconds. Here’s the full code for your convenience:

import asyncio
import aiohttp

async def fetch_weather(session, city):
    url = f"http://wttr.in/{city}?format=3"
    async with session.get(url) as response:
        data = await response.text()
        print(f"Weather in {city}: {data}")

async def main():
    cities = ["Paris", "London", "New York", "Tokyo", "Sydney"]
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_weather(session, city) for city in cities]
        await asyncio.gather(*tasks)

asyncio.run(main())

Wrapping Up 🎉

And there you have it! You just made a supercharged weather app using asynchronous code in Python. Now, you can fetch data from multiple sources without slowing down your program, like a pro!

By learning how to use asyncio, you’ve unlocked the power of faster, more efficient code. So, go ahead—explore more APIs, handle more data, and build cool stuff. The async world is yours! 🚀

Learn How to Use JSON as a Small Database for Your Python Projects by Building a Hotel Accounting System

ahmed elboshi — Thu, 03 Oct 2024 23:48:32 +0000

Are you tired of setting up and managing bulky databases for your small projects? If you’ve got a small-scale application and need something lightweight, JSON (JavaScript Object Notation) can be your best buddy! In this tutorial, we’ll build a simple Hotel Accounting System using Python, and we’ll use JSON to store and manage our data.

But first, let’s dive into the basics of JSON files, the standard format, and how to use Python's json module to manipulate these files.

What is JSON?

JSON, or JavaScript Object Notation, is a lightweight data-interchange format that’s easy to read and write for humans, and easy to parse and generate for machines. It’s commonly used to transmit data between servers and web applications, and it's great for small databases!

Standard JSON Format

A JSON file stores data in key-value pairs, much like a Python dictionary. Here’s a basic structure:

{
    "key": "value",
    "key2": {
        "nested_key": "nested_value"
    },
    "list_key": [1, 2, 3]
}

In our Hotel Accounting System, we’ll use JSON to store information like bookings, customer details, and room charges.

Python's `json` Module

Python’s built-in json module makes it easy to read and write JSON data. Let's look at some key methods in this module:

`json.load()`

The json.load() method reads JSON data from a file and converts it into a Python object (usually a dictionary).

import json

with open('data.json', 'r') as file:
    data = json.load(file)

`json.loads()`

The json.loads() method reads JSON data from a string and converts it into a Python object.

json_string = '{"name": "John", "age": 30}'
data = json.loads(json_string)

`json.dump()`

The json.dump() method writes a Python object to a JSON file.

data = {"name": "John", "age": 30}
with open('data.json', 'w') as file:
    json.dump(data, file)

`json.dumps()`

The json.dumps() method converts a Python object into a JSON string.

data = {"name": "John", "age": 30}
json_string = json.dumps(data)

Now that we’re JSON ninjas, let’s put these methods to use by building a Hotel Accounting System!

Step 1: Setting Up the Project

First, let’s create a basic structure for our Hotel Accounting System. We’ll need:

A JSON file to store hotel data (bookings, customer info, etc.).
Python functions to manage this data.

Create a file called hotel_data.json, and initialize it with an empty dictionary:

{}

Step 2: Defining the Hotel Accounting System Functions

Let’s define some basic functions to handle bookings, checkouts, and displaying customer info.

1. Adding a Booking

Let’s create a function called add_booking() that takes customer details and booking info, and then saves it to the JSON file.

import json

def add_booking(customer_name, room_number, nights, rate_per_night):
    try:
        with open('hotel_data.json', 'r') as file:
            data = json.load(file)
    except FileNotFoundError:
        data = {}

    # Calculate total charges
    total_charge = nights * rate_per_night

    # Create a booking dictionary
    booking = {
        "customer_name": customer_name,
        "room_number": room_number,
        "nights": nights,
        "rate_per_night": rate_per_night,
        "total_charge": total_charge
    }

    # Store booking data
    data[customer_name] = booking

    # Save data back to JSON file
    with open('hotel_data.json', 'w') as file:
        json.dump(data, file, indent=4)

    print(f"Booking added for {customer_name} in room {room_number}.")

# Example usage
add_booking(customer_name="John Doe",room_number= 101,nights= 3,rate_per_night= 100)

2. Displaying Bookings

Next, let’s create a function called view_bookings() to display all bookings.

def view_bookings():
    try:
        with open('hotel_data.json', 'r') as file:
            data = json.load(file)
    except FileNotFoundError:
        data = {}

    if not data:
        print("No bookings found.")
        return

    for customer, details in data.items():
        print(f"Customer: {customer}")
        for key, value in details.items():
            print(f"  {key}: {value}")
        print()  # Newline for readability

# Example usage
view_bookings()

3. Checking Out a Customer

Now, let’s create a checkout() function that removes a customer’s booking from the JSON file.

def checkout(customer_name):
    try:
        with open('hotel_data.json', 'r') as file:
            data = json.load(file)
    except FileNotFoundError:
        print("No bookings found.")
        return

    if customer_name in data:
        del data[customer_name]
        with open('hotel_data.json', 'w') as file:
            json.dump(data, file, indent=4)
        print(f"Checked out {customer_name}.")
    else:
        print(f"No booking found for {customer_name}.")

# Example usage
checkout("John Doe")

4. Calculating Total Revenue

Finally, let’s create a calculate_revenue() function to sum up the charges from all bookings.

def calculate_revenue():
    try:
        with open('hotel_data.json', 'r') as file:
            data = json.load(file)
    except FileNotFoundError:
        data = {}

    total_revenue = sum(booking["total_charge"] for booking in data.values())
    print(f"Total Revenue: ${total_revenue}")

# Example usage
calculate_revenue()

Wrapping Up

Absolutely! Wrapping all functions in a while loop will make our Hotel Accounting System interactive, allowing users to choose options in a menu-like format and perform various operations repeatedly until they choose to exit. Let’s go ahead and implement this.

Step 3: Adding a Main Menu Loop

Here, we’ll create a function called main_menu() that will:

Display a menu with available options.
Take user input to determine which action to perform.
Continue looping until the user chooses to exit.

def main_menu():
    while True:
        print("\n--- Hotel Accounting System ---")
        print("1. Add Booking")
        print("2. View Bookings")
        print("3. Checkout Customer")
        print("4. Calculate Revenue")
        print("5. Exit")

        # Get user choice
        choice = input("Choose an option (1-5): ")

        if choice == '1':
            customer_name = input("Enter customer name: ")
            room_number = int(input("Enter room number: "))
            nights = int(input("Enter number of nights: "))
            rate_per_night = float(input("Enter rate per night: "))
            add_booking(customer_name, room_number, nights, rate_per_night)

        elif choice == '2':
            view_bookings()

        elif choice == '3':
            customer_name = input("Enter customer name for checkout: ")
            checkout(customer_name)

        elif choice == '4':
            calculate_revenue()

        elif choice == '5':
            print("Exiting the system. Have a great day!")
            break

        else:
            print("Invalid choice. Please enter a number from 1 to 5.")

Explanation of the `main_menu()` Function

Display Menu Options: The function starts by printing a menu with options for the user. Each option corresponds to a specific function in the system: adding bookings, viewing bookings, checking out a customer, calculating revenue, and exiting the program.
Get User Input: The input() function is used to capture the user's choice. We then use an if-elif block to determine which action to perform based on the user's input.
Execute Functions Based on User Choice:
- If 1 is chosen, it prompts for booking details and calls the add_booking() function.
- If 2 is chosen, it calls view_bookings() to display all current bookings.
- If 3 is chosen, it asks for the customer’s name and calls checkout() to remove their booking.
- If 4 is chosen, it calls calculate_revenue() to display the total revenue from all bookings.
- If 5 is chosen, the loop is broken with the break statement, and a farewell message is displayed.
Invalid Input Handling: If the user enters anything other than 1-5, it displays an error message and the loop continues, allowing the user to choose a valid option.

Running the Program

Now, you can simply call the main_menu() function to start the interactive Hotel Accounting System:

main_menu()

When you run the program, you’ll see a menu. You can then enter the corresponding number for the action you want to take, and the system will respond accordingly. You can keep performing actions until you select option 5 to exit.

And there you have it! 🎉 You now have a fully interactive Hotel Accounting System using JSON as a small database. This loop provides a simple but effective way to simulate a real system, making it easy to extend with additional features in the future. Happy coding!

Rust tutorials for Python DEV: Variables and Mutability in Rust

ahmed elboshi — Sun, 14 Jul 2024 04:28:27 +0000

Beginner's Guide to Variables and Mutability in Rust

In Rust, the let keyword is used to declare variables. When you declare a variable with let, you are introducing a new binding (or name) that associates with a value of a particular type.
Here's a detailed explanation of how to assign variables using let in Rust:

Basic Variable Assignment

To assign a variable in Rust, you use the let keyword followed by the variable name and optionally a type annotation (: type) if you want to explicitly specify the type.

Example:

fn main() {
    // Declare a variable named `x` and assign it the value `5`
    let x = 5;

    // Print the value of `x`
    println!("The value of x is: {}", x);
}

In this example:

let x = 5; declares a variable named x and assigns it the value 5.
Rust infers the type of x as i32 (a 32-bit signed integer) based on the assigned value.

Explicit Type Annotation

If you want to explicitly specify the type of a variable, you can do so by appending : type after the variable name.

Example:

fn main() {
    // Declare a variable named `y` with type annotation `i64` (a 64-bit signed integer)
    let y: i64 = 100;

    // Print the value of `y`
    println!("The value of y is: {}", y);
}

In this example:

let y: i64 = 100; declares a variable named y with the type annotation i64 and assigns it the value 100.

Rebinding Variables with `let`

In Rust, variables are immutable by default. Once you assign a value to a variable, you cannot reassign it. However, you can rebind a variable by using the let keyword again, which shadows the previous binding.

Example:

fn main() {
    let z = 10;
    println!("The value of z is: {}", z);  // Output: The value of z is: 10

    let z = "hello";
    println!("The new value of z is: {}", z);  // Output: The new value of z is: hello
}

In this example:

let z = 10; declares a variable z and assigns it the value 10.
Later, let z = "hello"; shadows the previous z variable with a new binding of type &str (a string slice).

mut

In Rust, variables are by default immutable, meaning once you assign a value to a variable, you cannot change it. However, you can explicitly make variables mutable using the mut keyword.
Immutable variables are declared using the let keyword without mut. Once assigned, their value cannot be changed.

Python:

x = 5
x = 10  # This is allowed

Rust:

fn main() {
    let x = 5;
    // x = 10; // Uncommenting this line will cause a compile-time error

    println!("The value of x is: {}", x);
}

Breaking Down the Code

Declare an Immutable Variable:

   let x = 5;

This declares a variable x with the value 5. Rust infers the type of x as i32 (32-bit signed integer) in this case.

Trying to Reassign the Variable:

   // x = 10; // Uncommenting this line will cause a compile-time error

Rust does not allow reassigning x because it's immutable.

Mutable Variables

If you want to change the value of a variable, you need to declare it as mutable using the mut keyword.

Python:

x = 5
x = 10  # This is allowed

Rust:

fn main() {
    let mut y = 5;
    y = 10;  // This is allowed because y is mutable
    println!("The value of y is: {}", y);
}

Breaking Down the Code

Declare a Mutable Variable:

   let mut y = 5;

This declares a mutable variable y with the initial value 5.

Assign a New Value:

   y = 10;

Since y is mutable, you can reassign its value to 10.

Why Use Mutability?

In Rust, immutability by default helps prevent unintended changes to data, which can help catch bugs at compile time. Mutable variables are useful when you need to change the value of a variable after it's initially set.

Conclusion

Understanding variables and mutability in Rust is fundamental to writing safe and efficient code. By default, variables are immutable, and you can make them mutable by using the mut keyword. This ensures that your code is more predictable and less prone to bugs related to unintended changes. Happy coding in Rust!

This tutorial introduces the concept of variables and mutability in Rust, highlighting how Rust's default immutability helps ensure safer and more predictable code.

Rust tutorials for Python DEV: if statements

ahmed elboshi — Sun, 14 Jul 2024 04:16:18 +0000

Beginner's Guide to Using `if` Statements in Rust

The if statement in Rust allows you to execute code conditionally, depending on whether an expression evaluates to true or false. This is similar to how if statements work in Python, but with some syntax differences.

Basic `if` Statement

In Python, you might write an if statement like this:

Python:

x = 5
if x > 3:
    print("x is greater than 3")

In Rust, the syntax is slightly different but serves the same purpose:

Rust:

fn main() {
    let x = 5;
    if x > 3 {
        println!("x is greater than 3");
    }
}

Breaking Down the Code

Define the Variable:

   let x = 5;

This creates a variable x with the value 5.

If Statement:

   if x > 3 {
       println!("x is greater than 3");
   }

This checks if x is greater than 3. If the condition is true, it executes the code inside the curly braces.

`if-else` Statement

You can add an else block to execute code when the condition is false.

Python:

x = 2
if x > 3:
    print("x is greater than 3")
else:
    print("x is not greater than 3")

Rust:

fn main() {
    let x = 2;
    if x > 3 {
        println!("x is greater than 3");
    } else {
        println!("x is not greater than 3");
    }
}

Breaking Down the Code

If-Else Statement:

   if x > 3 {
       println!("x is greater than 3");
   } else {
       println!("x is not greater than 3");
   }

If the condition x > 3 is true, it executes the first block. Otherwise, it executes the code in the else block.

`else if` Statement

For multiple conditions, you can use else if.

Python:

x = 5
if x > 10:
    print("x is greater than 10")
elif x > 5:
    print("x is greater than 5 but less than or equal to 10")
else:
    print("x is 5 or less")

Rust:

fn main() {
    let x = 5;
    if x > 10 {
        println!("x is greater than 10");
    } else if x > 5 {
        println!("x is greater than 5 but less than or equal to 10");
    } else {
        println!("x is 5 or less");
    }
}

Breaking Down the Code

Else If Statement:

   if x > 10 {
       println!("x is greater than 10");
   } else if x > 5 {
       println!("x is greater than 5 but less than or equal to 10");
   } else {
       println!("x is 5 or less");
   }

This checks multiple conditions in sequence. It executes the first block where the condition is true.

Using `if` in a `let` Statement

In Rust, you can use if expressions to assign values.

Python:

x = 10
y = "greater than 5" if x > 5 else "5 or less"

Rust:

fn main() {
    let x = 10;
    let y = if x > 5 {
        "greater than 5"
    } else {
        "5 or less"
    };
    println!("y is {}", y);
}

Breaking Down the Code

If Expression in Let Statement:

   let y = if x > 5 {
       "greater than 5"
   } else {
       "5 or less"
   };

This uses an if expression to assign a value to y based on the condition.

Conclusion

The if statement in Rust is a powerful tool for controlling the flow of your program based on conditions. It is similar to if statements in Python but with slight syntax differences. You can use if, else if, and else to handle multiple conditions and even use if expressions to assign values. Happy coding!

Python:

x = 2
if x > 3:
    print("x is greater than 3")
else:
    print("x is not greater than 3")

Rust:

fn main() {
    let x = 2;
    if x > 3 {
        println!("x is greater than 3");
    } else {
        println!("x is not greater than 3");
    }
}

Breaking Down the Code

If-Else Statement:

   if x > 3 {
       println!("x is greater than 3");
   } else {
       println!("x is not greater than 3");
   }

If the condition x > 3 is true, it executes the first block. Otherwise, it executes the code in the else block.

`else if` Statement

For multiple conditions, you can use else if.

Python:

x = 5
if x > 10:
    print("x is greater than 10")
elif x > 5:
    print("x is greater than 5 but less than or equal to 10")
else:
    print("x is 5 or less")

Rust:

fn main() {
    let x = 5;
    if x > 10 {
        println!("x is greater than 10");
    } else if x > 5 {
        println!("x is greater than 5 but less than or equal to 10");
    } else {
        println!("x is 5 or less");
    }
}

Breaking Down the Code

Else If Statement:

   if x > 10 {
       println!("x is greater than 10");
   } else if x > 5 {
       println!("x is greater than 5 but less than or equal to 10");
   } else {
       println!("x is 5 or less");
   }

This checks multiple conditions in sequence. It executes the first block where the condition is true.

Using `if` in a `let` Statement

In Rust, you can use if expressions to assign values.

Python:

x = 10
y = "greater than 5" if x > 5 else "5 or less"

Rust:

fn main() {
    let x = 10;
    let y = if x > 5 {
        "greater than 5"
    } else {
        "5 or less"
    };
    println!("y is {}", y);
}

Breaking Down the Code

If Expression in Let Statement:

   let y = if x > 5 {
       "greater than 5"
   } else {
       "5 or less"
   };

This uses an if expression to assign a value to y based on the condition.

Conclusion

Rust for Python developers : Rust Data Types for Python Developers

ahmed elboshi — Sun, 14 Jul 2024 04:02:13 +0000

Rust Data Types for Python Developers

Scalar Types

Integers

Python:

x = 5
y = -3

Rust:

fn main() {
    let x: i32 = 5;
    let y: u32 = 10;
    println!("x = {}, y = {}", x, y);
}

Floating-Point Numbers

Python:

pi = 3.14

Rust:

fn main() {
    let pi: f64 = 3.14;  // f64 is a 64-bit floating-point number
    println!("pi = {}", pi);
}

Booleans

Python:

is_active = True
is_deleted = False

Rust:

fn main() {
    let is_active: bool = true;
    let is_deleted: bool = false;
    println!("is_active = {}, is_deleted = {}", is_active, is_deleted);
}

Characters

Python:

letter = 'a'

Rust:

fn main() {
    let letter: char = 'a';
    println!("letter = {}", letter);
}

Compound Types

Tuples

Python:

point = (3, 4.5)

Rust:

fn main() {
    let point: (i32, f64) = (3, 4.5);
    println!("point = ({}, {})", point.0, point.1);
}

Arrays

Python:

numbers = [1, 2, 3, 4, 5]

Rust:

fn main() {
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
    println!("numbers = {:?}", numbers);
}

Strings

Python:

greeting = "Hello, world!"

Rust:

fn main() {
    let greeting: &str = "Hello, world!";
    let mut dynamic_greeting: String = String::from("Hello, world!");
    dynamic_greeting.push_str(" Welcome!");
    println!("{}", dynamic_greeting);
}

Unleash Python's Hidden Power: Mastering Lambda Functions for Beginners

ahmed elboshi — Thu, 14 Mar 2024 15:18:23 +0000

Welcome, Python enthusiasts! Today, we embark on a journey to demystify one of Python's most powerful tools: lambda functions. Often dubbed as the "ninjas" of Python programming, lambdas possess the prowess to streamline your code and add a touch of elegance to your solutions. Fear not, for in this guide, we'll unravel the secrets of lambda functions together.

What Are Lambdas?

Lambda functions, also known as anonymous functions, are small, anonymous functions that can have any number of arguments but only one expression. They are defined using the lambda keyword, and typically used where a regular function would be cumbersome or unnecessary.

lambda arguments: expression

Let's dive into some examples to illustrate this better.

Example 1: Doubling Numbers

Suppose we want a function that doubles a given number. Traditionally, we would define a function like this:

def double(x):
    return x * 2

print(double(5))  # Output: 10

However, with lambdas, we can achieve the same functionality in a single line:

double = lambda x: x * 2
print(double(5))  # Output: 10

Impressive, right? Now, let's explore a more complex scenario.

Example 2: Sorting Lists

Sorting lists is a common task in programming. The sorted() function in Python accepts a key parameter, which allows us to specify a function to be called on each list element prior to making comparisons. Lambdas can be handy here:

players = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 90},
    {'name': 'Charlie', 'score': 75}
]

# Sort players by score
sorted_players = sorted(players, key=lambda player: player['score'], reverse=True)
print(sorted_players)
# Output: [{'name': 'Bob', 'score': 90}, {'name': 'Alice', 'score': 85}, {'name': 'Charlie', 'score': 75}]

In this example, the lambda function serves as the 'key' argument for sorting the players list based on the 'score' attribute.

Benefits of Using Lambdas

Conciseness: Lambdas allow you to define functions in a single line, reducing boilerplate code.
Readability: For simple operations, lambdas can make code more readable by keeping the focus on the operation itself.
Functional Programming: Lambdas are often used in conjunction with functions like map(), filter(), and reduce(), promoting a functional programming style.

Conclusion

In this guide, we've unlocked the mysteries of lambda functions in Python. Armed with this knowledge, you're now equipped to wield lambdas like a true ninja in your Python endeavors. Practice incorporating lambdas into your code, and watch as your programs become more concise and expressive.

Happy coding! 🐍✨

Python Tips & Tricks Day 5

ahmed elboshi — Mon, 11 Mar 2024 14:36:45 +0000

Python's Secret Weapon: Leveraging the 'itertools' Module

Hey Python Enthusiasts! 🐍 Ready to unlock the power of Python's secret weapon? Introducing the 'itertools' module – a treasure trove of tools for efficient iteration and combination. Let's delve into its magic and discover how it can supercharge your Python code!

The Trick:

from itertools import permutations

# Generating all permutations of a list
letters = ['a', 'b', 'c']
perms = permutations(letters)

# Printing permutations
for perm in perms:
    print(perm)

🔮 Results:

('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')

💡 Why It's Awesome:

The 'itertools' module offers a wide range of functions like permutations, combinations, and more, allowing you to tackle complex iteration tasks with ease. With just a few lines of code, you can generate all possible permutations, combinations, and even iterate over Cartesian products effortlessly!

In Conclusion:

Don't overlook the power of the 'itertools' module – it's a game-changer for anyone working with iteration and combination tasks in Python. Whether you're solving puzzles, generating test cases, or exploring data science, 'itertools' will be your ultimate ally. Embrace its magic and elevate your Python skills to new heights! 🌟✨

Python Tips & Tricks Day 4

ahmed elboshi — Sat, 09 Mar 2024 22:12:10 +0000

Python's Hidden Gem: The Powerful 'collections.Counter'

Hey Python Pros! 🚀 Get ready to uncover a hidden gem in Python – the mighty collections.Counter! This powerful tool will revolutionize the way you work with collections, offering a simple yet effective solution to counting elements. Let's dive in and unlock its magic together!

The Trick:

from collections import Counter

# Counting occurrences of elements in a list
fruits = ['apple', 'banana', 'orange', 'apple', 'banana', 'apple']
fruit_counts = Counter(fruits)
print(fruit_counts)

# Accessing counts of specific elements
print(fruit_counts['apple'])  # Output: 3
print(fruit_counts['banana'])  # Output: 2
print(fruit_counts['grape'])  # Output: 0

💡 Why It's Awesome:

collections.Counter is like having a built-in tally counter for your collections. It simplifies the task of counting occurrences of elements, making your code cleaner and more efficient. Plus, it's lightning-fast, even with large datasets!

In Conclusion:

Don't overlook the power of collections.Counter – it's a game-changer for anyone working with collections in Python. Whether you're analyzing data, processing text, or solving coding challenges, this hidden gem will be your trusty ally. Embrace its magic and elevate your Python skills to new heights!

Shear your tricks and tips with us

AI vs CODERS : The Epic Showdown!

ahmed elboshi — Fri, 08 Mar 2024 03:50:19 +0000

Hey tech wizards and code conjurers! 💻🧙‍♂️

Have you ever wondered if AI is secretly plotting to take over the realm of developers?

🤖👾 Well, let's dive into this epic battle between human creativity and artificial intelligence!

Picture this: a showdown of binary proportions, where lines of code clash in a virtual arena. On one side, we have the daring developers, armed with their trusty keyboards and caffeinated beverages, ready to conquer any coding challenge that comes their way. 💥💻

And on the other side, lurking in the digital shadows, are the AI overlords, equipped with neural networks and machine learning algorithms, silently analyzing data and learning at lightning speed. 🤖⚡️

But fear not, fellow developers! While AI may excel at crunching numbers and automating tasks, there are some things it just can't replicate. Like the quirky bugs that only a human touch can create, or the ingenious solutions born from late-night coding sessions fueled by pizza and determination. 🍕💡

Sure, AI can write code based on patterns and data, but can it capture the essence of creativity and innovation? Can it understand the thrill of unraveling a complex problem or the satisfaction of crafting elegant, efficient solutions? 🤔💡

So, let's raise our debuggers high and march into battle, knowing that while AI may be a formidable opponent, it will never replace the ingenuity, passion, and downright awesomeness of human developers! 💪🚀

In the end, it's not about who writes the most lines of code or who can optimize algorithms the fastest. It's about the journey of discovery, the camaraderie of the coding community, and the sheer joy of bringing ideas to life through the power of programming. 🌟👩‍💻👨‍💻

So, fellow developers, keep coding, keep innovating, and never forget: the true magic of technology lies not in the machines we build, but in the hearts and minds of those who wield them!

WRITTEN BY

Python Tips & Tricks Day 3

ahmed elboshi — Thu, 07 Mar 2024 18:49:52 +0000

Python's Stealthy Trick: The Elegant 'any' and 'all' Functions

Hey Python Enthusiasts! 🌟 Today, I'm unveiling a ninja-level trick that will add a touch of elegance to your code: the powerful duo of 'any' and 'all' functions. These stealthy operators will help you streamline your logic and make your code shine like never before. Let's dive in!

What are 'any' and 'all'?

Imagine you have a bunch of conditions to check, and you want to know if at least one or all of them are True. That's where 'any' and 'all' come in handy! With 'any', you can quickly check if any element in an iterable is True, while 'all' ensures that all elements are True.

Here's the Magic:

# Checking if any number in a list is even
numbers = [1, 2, 3, 4, 5]
if any(num % 2 == 0 for num in numbers):
    print("At least one number is even!")

# Checking if all numbers in a list are positive
numbers = [1, 2, -3, 4, 5]
if all(num > 0 for num in numbers):
    print("All numbers are positive!")

# Checking if any string in a list starts with 'A'
names = ['Alice', 'Bob', 'Charlie']
if any(name.startswith('A') for name in names):
    print("At least one name starts with 'A'!")

# Checking if all strings in a list have length greater than 3
names = ['Alice', 'Bob', 'Charlie']
if all(len(name) > 3 for name in names):
    print("All names have length greater than 3!")

Result

💫 Results:

At least one number is even!
At least one name starts with 'A'!

Why They're Awesome:

'any' and 'all' are like silent guardians, silently evaluating conditions and providing you with quick and concise answers. Whether you're validating user inputs, filtering data, or checking conditions, these functions are your trusty companions.

In Conclusion:

So there you have it, Python warriors – the stealthy power of 'any' and 'all' functions! With their help, you can write cleaner, more expressive code and tackle complex logic with ease. Embrace these ninja tricks, and watch your code reach new heights of elegance and efficiency! 🥷✨🌟

Python Tips & Tricks Day 2

ahmed elboshi — Thu, 07 Mar 2024 03:52:12 +0000

Python's Awesome Trick: Mastering Dictionary Comprehensions!

Hey Python Enthusiasts! 🚀 Ready to unleash an awesome trick that'll take your coding skills to the next level? Today, we're diving into the realm of dictionary comprehensions – a powerful wizardry that will have you conjuring dictionaries like a pro magician! 🪄✨

What's the Trick?

Imagine writing complex dictionaries in just one line of code – that's the magic of dictionary comprehensions! With this spell, you can create dictionaries with ease and elegance, leaving your code looking sleek and stylish.

How Does it Work?

# Traditional way
squares = {}
for i in range(1, 6):
    squares[i] = i ** 2

# The awesome dictionary comprehension
squares = {i: i ** 2 for i in range(1, 6)}

🔮 Results:

Traditional method: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
Dictionary comprehension: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Boom! With just a flick of your wand, you've summoned a dictionary of squares in a single line of code. It's like performing a spell that transforms your loops into pure magic!

So there you have it, folks – dictionary comprehensions are the secret weapon in every Python magician's toolkit! With a dash of creativity and a sprinkle of Pythonic charm, you'll be crafting dictionaries like a true sorcerer in no time. So grab your wands and let's work some magic! 🪄✨

Python Tips & Tricks Day 1

ahmed elboshi — Thu, 07 Mar 2024 03:19:19 +0000

🎩✨ Python Party Trick vs. Stone Age Code! ✨🎩

Hey Python pals! 👋 Tired of coding like a caveman? 🦕 Let's upgrade that Stone Age script with a slick Python party trick! 🧙‍♂️

The Long Way (aka Caveman Coding):

names = ['Alice', 'Bob', 'Charlie']
ages = [30, 25, 35]

for i in range(len(names)):
    name = names[i]
    age = ages[i]
    print(f'{name} is {age} years old')

The Pythonic Party Trick (aka Zip & Star Power):

names = ['Alice', 'Bob', 'Charlie']
ages = [30, 25, 35]

for name, age in zip(names, ages):
    print(f'{name} is {age} years old')

Say goodbye to dragging your knuckles through endless loops and hello to coding joy! 🚀💻 #PythonPartyTrick #UpgradeYourCode 🌟

DEV Community: ahmed elboshi

What is Asynchronous Code? How to Use It in Python to Speed Up Your Code Learn by Building a Weather App! ☀️🌦️

Synchronous vs. Asynchronous Code

Synchronous Code

Asynchronous Code

Why Use Asynchronous Code?

Meet asyncio: Your Asynchronous Sidekick

Let’s Build a Weather App! 🌎⛅

Step 1: Set Up

Step 2: Write the Asynchronous Weather Fetcher

Step 3: Run the Async Functions Together

Step 4: Run Your App

Wrapping Up 🎉

Learn How to Use JSON as a Small Database for Your Python Projects by Building a Hotel Accounting System

What is JSON?

Standard JSON Format

Python's json Module

json.load()

json.loads()

json.dump()

json.dumps()

Step 1: Setting Up the Project

Step 2: Defining the Hotel Accounting System Functions

1. Adding a Booking

2. Displaying Bookings

3. Checking Out a Customer

4. Calculating Total Revenue

Wrapping Up

Step 3: Adding a Main Menu Loop

Explanation of the main_menu() Function

Running the Program

Rust tutorials for Python DEV: Variables and Mutability in Rust

Beginner's Guide to Variables and Mutability in Rust

Basic Variable Assignment

Example:

Explicit Type Annotation

Example:

Rebinding Variables with let

Example:

mut

Breaking Down the Code

Mutable Variables

Breaking Down the Code

Why Use Mutability?

Conclusion

Rust tutorials for Python DEV: if statements

Beginner's Guide to Using if Statements in Rust

Basic if Statement

Breaking Down the Code

if-else Statement

Breaking Down the Code

else if Statement

Breaking Down the Code

Using if in a let Statement

Breaking Down the Code

Conclusion

Breaking Down the Code

else if Statement

Breaking Down the Code

Using if in a let Statement

Breaking Down the Code

Conclusion

Rust for Python developers : Rust Data Types for Python Developers

Rust Data Types for Python Developers

Scalar Types

Integers

Floating-Point Numbers

Booleans

Characters

Compound Types

Tuples

Arrays

Strings

Unleash Python's Hidden Power: Mastering Lambda Functions for Beginners

What Are Lambdas?

Example 1: Doubling Numbers

Example 2: Sorting Lists

Benefits of Using Lambdas

Conclusion

Python Tips & Tricks Day 5

Meet `asyncio`: Your Asynchronous Sidekick

Python's `json` Module

`json.load()`

`json.loads()`

`json.dump()`

`json.dumps()`

Explanation of the `main_menu()` Function

Rebinding Variables with `let`

Beginner's Guide to Using `if` Statements in Rust

Basic `if` Statement

`if-else` Statement

`else if` Statement

Using `if` in a `let` Statement

`else if` Statement

Using `if` in a `let` Statement