F-Strings - Advanced Python

F-strings, introduced in Python 3.6, are a way to format strings that is both concise and readable. An F-string is prefixed with `f` or `F` before the opening quotation mark. Within an F-string, you can directly insert expressions inside curly braces `{}`. The expressions are evaluated at runtime and formatted using Python's string formatting options.

Here's an overview and some examples:

Basic Usage

name = "Alice"

age = 30

 

greeting = f"Hello, my name is {name} and I am {age} years old."

print(greeting)

Expressions Inside Braces

You can place any valid Python expression inside the curly braces:

x = 10

y = 5

 

result = f"The result of {x} + {y} is {x + y}."

print(result)

Formatting Numbers

F-strings allow for inline formatting, which is handy for controlling the format of numbers:

import math

 

radius = 7.5

area = f"The area of a circle with a radius of {radius} is {math.pi * radius ** 2:.2f}."

print(area)

Here, `:.2f` formats the area to two decimal places.

Date and Time Formatting

F-strings can also be used to format dates and times:

from datetime import datetime

 

current_time = datetime.now()

formatted_time = f"Current time: {current_time:%Y-%m-%d %H:%M:%S}"

print(formatted_time)

Advanced Expressions

You can perform more complex operations inside the braces:

items = ['apples', 'bananas', 'grapes']

formatted_list = f"There are {len(items)} items: {', '.join(items).capitalize()}."

print(formatted_list)

This line creates a string using an f-string (formatted string literal). Inside this f-string, there are a couple of operations being performed on the items list:

  • len(items): This function returns the length of the list items, which is 3 in this case.
  • ', '.join(items): This method joins all the elements of the items list into a single string, separated by ', '. The result is 'apples, bananas, grapes'.
  • .capitalize(): This method is applied to the string resulting from the join operation. It capitalizes the first character of the string, turning it into 'Apples, bananas, grapes'.

F-strings are a powerful and efficient way to format strings in Python, making your code more readable and reducing the need for concatenation or manual string formatting.

Comments

Post a Comment

Popular posts from this blog

cls in Functions

In Python, `cls` is a convention used to refer to the class itself in class methods , just as `self` is used to refer to an instance of the class in instance methods. The `cls` parameter in a method definition signifies that the method is a class method. It's important to note that `cls` is just a naming convention; you could technically name it anything, but `cls` is widely used and recognized in the Python community. Class methods are methods that are bound to the class and not the instance of the class. They can be called on the class itself, rather than on instances of the class. To define a class method, you use the ` @classmethod` decorator . Example Here's an example to illustrate the use of `cls`: class MyClass:     class_variable = "I am a class variable"       @classmethod     def class_method(cls):         # Here, cls refers to MyClass itself, not an inst...
Read more

The Walrus Operator - Advanced Python

The "walrus operator" in Python, denoted as `:=` , is a feature introduced in Python 3.8 that allows you to assign values to variables as part of an expression. It's particularly useful in situations where you want to assign a value to a variable and return it in a single expression , often making your code more concise and readable. Example Here's a simple example to demonstrate the use of the walrus operator: numbers = [1, 2, 3, 4, 5] squared_numbers = [] for number in numbers:     squared = number ** 2     if squared > 5:         squared_numbers.append(squared)   # With the walrus operator squared_numbers = [] for number in numbers:     if (squared := number ** 2) > 5:         squared_numbers.append(squared)   print(squared_numbers) In this example, `squared := number ** 2` is an instance of the walrus operator b...
Read more

enumerate

`enumerate` is a built-in Python function that adds a counter to an iterable . It's commonly used in loops to get both the index and the value of each item in the iterable. This is particularly useful if you need to access the item as well as its index in the loop. Basic Syntax: enumerate(iterable, start=0) - `iterable`: Any Python iterable (like a list, tuple, string, etc.). - `start`: The starting value of the counter. By default, it starts from 0. Basic Example fruits = ['apple', 'banana', 'cherry'] for index, fruit in enumerate(fruits):     print(f"Index {index}: {fruit}") This will output: Index 0: apple Index 1: banana Index 2: cherry Starting Index from 1 You can start the counter from 1 or any other number by specifying the `start` argument: for index, fruit in enumerate(fruits, start=1):     print(f"Position {index}: {fruit}") This will outpu...
Read more