Sign In
Sign In

Conditional Statements in Python

Conditional Statements in Python
Hostman Team
Technical writer
Python
21.10.2024
Reading time: 12 min

In this article, we will discuss perhaps the most essential part of any program, as conditional constructs shape its structure and determine which parts of the code are executed. These constructs are often referred to as the "heart" of a program in any programming language, and even artificial intelligence is largely built on conditional branching. Therefore, let's take a closer look at them in the following order:

  • The if statement

  • The if-else construct

  • The if-elif-else construct

  • Examples of programs

What Does the Conditional Statement Do in Python?

The simplest way to understand this is through an example. Enter the following in the Python interpreter and press Enter to see the output:

>>> if 5 > 4:
print('True, 5 is greater than 4.')

Output:

True, 5 is greater than 4.

Here we have a basic example of how the program works with a condition. 

Thus, if is used to execute a block of code based on a condition: if the condition is true, the block of code will be executed; if it is false, it will not. Let’s provide an example of False; enter and press Enter:

if 5 < 4:
print('True, 4 is greater than 5')

The interpreter remains silent—which is correct because the condition is false, and thus the statement "True, 4 is greater than 5" (which is itself also incorrect) will never be output.

However, in most cases, more than one condition will be required, and we will need to use more complex constructs: if-else and if-elif-else.

The if-else Conditional Statement

The if-else construct is used when you need to give the program a choice: in the first case, do one thing, and in the second case, do something else. Here’s an example:

money = int(input('How much would you like to spend on shopping? Enter a number: '))
if money >= 10:
    print('Welcome! We have sent the catalog to your email.')
else:
    print('Unfortunately, we do not have any products cheaper than 10 dollars. Please visit us again.')
input('Press Enter to exit.')

The first line is needed for input, handled by the input statement. In brief, the input function accepts user input and, if necessary, assigns the entered value to a variable (in this case, money).

Next comes the condition: if the entered amount equals or exceeds $10, the program gives a positive response. If the entered amount is $9 or less, a different response is given.

In the last line, we also added the input operator, which, in this case, does not pass any value to a variable but serves to move to the next line of code. Since we have no additional lines, pressing Enter will exit the program; this is another feature of input.

The if-elif-else Conditional Statement

Let’s complicate the previous example and make the program choose from three options. We can do this by adding an additional condition that will be set by the elif operator:

money = int(input('How much would you like to spend on shopping? Enter a number: '))
if money >= 10000:
    print('Welcome, wholesale buyer! We have special discounts for you.')
elif money >= 10:
    print('Welcome! We have sent the catalog to your email.')
else:
    print('Unfortunately, we do not have any products cheaper than 10 dollars. Please visit us again.')
input('Press Enter to exit.')

Now, if the user enters an amount equal to or greater than the specified value (10000), the program will output the text from the first if block. If the amount is less than this value but equal to or greater than 10, the condition of the elif operator will be executed, and the user will see the second message.

It’s worth noting that there can be as many elif statements as needed, but the main rule is that the first condition must always specify the if operator. Here’s an example of code with several elif statements. Let’s imagine we want to generate a starting star system for our civilization in a space strategy game:

import random
star = random.randint(1, 5)
planets = random.randint(1, 10)

if star == 1:
    print('Your civilization lives in a blue giant system with', planets, 'planets orbiting.')
elif star == 2:
    print('Your civilization lives in a white dwarf system with', planets, 'planets orbiting.')
elif star == 3:
    print('Your civilization lives in a sun-like yellow dwarf system with', planets, 'planets orbiting.')
elif star == 4:
    print('Your civilization lives in an orange giant system with', planets, 'planets orbiting.')
else:
    print('Your civilization lives in a red supergiant system with', planets, 'planets orbiting.')

input('Press Enter to exit')

Here’s the system that random has gifted us:

Your civilization lives in a sun-like yellow dwarf system with 6 planets orbiting.
Press Enter to exit.

It’s almost solar, just with fewer planets. Note that we created two variables (star and planets), and we entrusted the generation of values to the random module, which needs to be called first:

import random

Next, using the random.randint instruction, we set the range of generated values, from which the random number generator (RNG) selects one: for stars from 5 and for planets from 10:

star = random.randint(1, 5)
planets = random.randint(1, 10)

Since we have five types of stars, there should be just as many blocks of code with conditions, which is why we used several elif operators. The number of planets will be arbitrary for any piece of code because the planets variable is included in everything.

One more thing: you may have already noticed that some operations in the code are indicated with a single = sign, while others use a double equality ==. In Python, a single equal sign = is used only for assigning values to variables, while double equality == is used for comparison. Therefore, in the example above, the code:

star = random.randint(1, 5)

means that the variable star takes on a random value generated by the random module, while the expression:

if star == 1:

means that the variable star, which has already been assigned a value, is being compared to the value 1 (and if this condition is true, the code in this block begins to execute).

Game Examples

The best way to learn is by playing, so let’s demonstrate how the if-else conditional operator works in Python through simple games while also getting acquainted with other useful functions.

Coin Tossing

Let’s write a program using the if-elif-else conditional statement and examine how this program is structured step by step. Type the following into your editor, making sure to maintain the indentation:

import random
coin = random.randint(1, 2)
attempts = 0
heads = 0
tails = 0

while attempts < 100:
    if coin == 1:
        heads += 1
        attempts += 1
        coin = random.randint(1, 2)
    elif coin == 2:
        tails += 1
        attempts += 1
        coin = random.randint(1, 2)
    else:
        print('The coin landed on its edge. Does that ever happen? Alright, let’s toss it again.')
        attempts += 1
        coin = random.randint(1, 2)

print('Heads appeared', heads, 'time(s), and tails', tails, 'time(s).')
input('Press Enter to exit')

We will simulate the coin tosses using the RNG we are already familiar with, provided by the random module. This is called in the first line of the code:

import random

Next, we define several variables:

  • coin — for the coin tosses,

  • attempts — to count the number of tosses,

  • heads — to tally the number of heads,

  • tails — to tally the number of tails.

When tossing the coin, we will use the RNG immediately, so we write:

coin = random.randint(1, 2)

This means that a value will be generated randomly in the range from 1 to 2, which means it can either be a 1 or a 2. Now we just need to assign these values to heads and tails accordingly, specify the maximum number of tosses, and ensure that the count of each increases by one with each toss. For this, we use the Python if-elif-else conditional construct inside a while loop:

while attempts < 100:

This part of the code means: as long as the number of tosses is less than 100:

if coin == 1:
    heads += 1
    attempts += 1
    coin = random.randint(1, 2)

If the RNG returns 1:

  • increase the number of heads by one,

  • increase the number of tosses by one,

  • toss the coin again.

elif coin == 2:
    tails += 1
    attempts += 1
    coin = random.randint(1, 2)

The same applies for tails.

else:
    print('The coin landed on its edge. Does that ever happen? Alright, let’s toss it again.')
    attempts += 1
    coin = random.randint(1, 2)

This code is added to handle the impossible case (a coin will never land on its edge since our RNG can only output 1 or 2). However, adding a final else block is a good habit — "impossible" conditions can sometimes still occur because programmers can’t always account for every scenario. Therefore, an else block can make the program more stable in cases of unanticipated conditions.

As soon as the coin has been tossed for the hundredth time, the last block of code will execute:

print('Heads appeared', heads, 'time(s), and tails', tails, 'time(s).')
input('Press Enter to exit')

The program will exit the while loop and display how many times heads and tails appeared; we analyze the statistics and exit. Essentially, the user will only see the result displayed like this:

Heads appeared 53 time(s), and tails 47 time(s).
Press Enter to exit.

Of course, observing the RNG is interesting, but calling either the star and planet generator or the coin toss a game is a stretch, so let’s write a more interesting program.

Playing Dice

In this game, we will take turns rolling dice against the computer, and in the end, we will declare a winner. The following code accomplishes this:

import random

score1 = 0
score2 = 0
games = 0
die1 = 0
die2 = 0
total1 = 0
die3 = 0
die4 = 0
total2 = 0

input('Roll the dice, press Enter!\n')

while score1 < 6 and score2 < 6 and games <= 11:
    die1 = random.randint(1, 6)
    die2 = random.randint(1, 6)
    total1 = die1 + die2
    print(die1, die2)
    print(total1, '\n')
    input('Now it’s my turn, press Enter!\n')

    die3 = random.randint(1, 6)
    die4 = random.randint(1, 6)
    total2 = die3 + die4
    print(die3, die4)
    print(total2, '\n')

    if total1 > total2:
        score1 += 1
        games += 1
    elif total1 < total2:
        score2 += 1
        games += 1
    else:
        games += 1
        print('It’s a tie\n')
    print('Score', score1, ':', score2, '\n')
    input('Press Enter!\n')

if score1 > score2:
    input('You won! Press Enter to exit.')
elif score1 < score2:
    input('I won! Press Enter to exit.')
else:
    input('Friendship wins! Press Enter to exit.')

This code may seem a bit long and complicated at first glance, but, firstly, we've written a real game (even if it doesn’t have graphics yet), and secondly, there’s nothing particularly difficult here — let's explain everything now.

First, we call the familiar random module, then we define the following variables, which will, of course, be initialized to 0 before the game starts:

  • score1 and score2 for counting victories for the player and the computer,

  • games for counting the number of rounds (which we will later limit to prevent a long game in case of frequent ties),

  • die1, die2, die3, die4 for rolling the individual dice,

  • total1 and total2 for calculating the total score in each roll for both players: for the human player, it will be the sum total1 of the dice die1 and die2, and for the computer, it will be total2 and die3, die4 respectively.

Next, we prompt the start of the game (the player will see this first), and then the program enters a loop:

while score1 < 6 and score2 < 6 and games < 11:

As we can see, there are multiple conditions connected by and operators. This means the program will exit the loop if any one of them is no longer true (i.e., either score1 or score2 reaches 6, or games equals 11). We play almost like a tennis set: as soon as one of the players wins six rounds, the game ends in their victory. Meanwhile, the number of rounds cannot exceed 11. Thus, if no player achieves 6 wins due to a series of ties, the game will still end after the 11th round.

Now the player rolls the dice, and the program calculates their total (total1 = die1 + die2) and prints the result. After pressing Enter, the computer does the same (its total will be total2 = die3 + die4). Of course, the entire game runs solely on the RNG, but that’s how most simple games are structured: even for the player, everything is determined by random chance.

Next, we move to the most important part of the program: the two if-elif-else blocks. The first one is part of the while loop:

if total1 > total2:
    score1 += 1
    games += 1
elif total1 < total2:
    score2 += 1
    games += 1
else:
    games += 1
    print('It’s a tie\n')
print('Score', score1, ':', score2, '\n')
input('Press Enter!\n')

This is straightforward: if our total is higher, we score a point; if the computer wins the round, it gets a point; and in the event of a tie, no one scores, but the round is counted as played in any case. The current score is then displayed, and the players are prompted to continue playing. As soon as the while loop condition is met, meaning one of the players has achieved 6 victories or the number of played rounds has reached 11, the program exits the loop and moves to the final block:

if score1 > score2:
    input('You won! Press Enter to exit.')
elif score1 < score2:
    input('I won! Press Enter to exit.')
else:
    input('Friendship wins! Press Enter to exit.')

The first if condition is satisfied when the player has won more rounds than the computer. The elif condition applies if the computer was more fortunate. But what if 11 rounds were played, and both players won an equal number? This is why we added the else block, which will display a conciliatory message.

Lastly, it’s important to note that Python checks conditions sequentially and executes the first true one: it will first check the if condition, then the elif conditions (if there are multiple, they are checked from top to bottom), and finally the else. Thus, if several conditions happen to be true in a complex program, only the first block will execute: keep this in mind when writing code.

Check out our app platform to find Python applications, such as Celery, Django, FastAPI and Flask. 

Python
21.10.2024
Reading time: 12 min

Similar

Python

Useful Tips for Web Data Scraping

In one of the previous articles, we learned what parsing is and looked at examples of obtaining data from HTML pages using Python. In this guide, we continue to move in that direction and offer web scraping best practices and tips that will help you automatically extract data from most existing websites. Obtaining data automatically may be prohibited by the terms of use of websites. We do not encourage violations of these terms, the rules specified in the robots.txt file, or any other applicable legal norms. Use the methods presented here only within permitted scenarios, and respect the policies of website owners. Tip 1. Learn to Work with DevTools By the way information is delivered, websites can be divided into two groups: static and dynamic. On static websites, all data is stored in the form of fixed HTML files that are kept on the server. Their contents do not change unless the developer modifies them. Dynamic websites, on the other hand, support real-time content generation and can load information from storage or, for example, from a database. Usually, writing a script for a static site is easier, since the information is definitely located inside the HTML document, and you don’t need to look for additional requests. Working with the Web Inspector The first thing a developer needs in order to identify the source of data quickly is to learn how to use the developer tools (DevTools). They exist in every browser and can be opened using the F12 key, or the combination Ctrl + Alt + I on Windows, or Command + Option + I on macOS. At first, you will only need two tabs: Elements and Network. The first allows you to see the structure of the page and determine in which DOM element the data is located. The Network tab is needed for working with requests, which we will later copy. The tabs are located at the top of the developer tools. Most often, information reaches the site in two ways: In the HTML markup of the page. This happens if the data is added to the page during backend processing. In JSON format. Such data can be requested by the frontend both during page loading and after certain user actions on the page. Tip 2. Use a Ready-Made Algorithm to Start Working with Any Donor Site Below is an action algorithm recommended for starting work with any donor site: Find a GET request with content type text/html, which the browser sends when the page is initialized.To do this, go to the page from which you need to extract data. Open the web inspector in the Network tab. Clear the requests by clicking on the trash bin icon to the left of the request search bar. Reload the page with Ctrl + R on Windows/Linux or Command + R on macOS. One of the first requests will be the needed GET request with content type text/html. Click on the request you found. Then go to the Response tab. A preview mode of the server’s response will open. The page layout may appear broken; this is normal. Try to find the required data visually in the preview mode. For example, the HTML markup of articles on Hostman is generated by the server. If you needed to automatically obtain the text of an article, then most of the work would already be done. If you can’t find it visually, go to the HTML markup view mode of the server response (not to be confused with the Elements tab). Activate search within the response with Ctrl + F on Windows or Command + F on macOS. Enter an example of data that you know is definitely on the page (for instance, the developer knows that the article contains the phrase “configuring Nginx,” so that exact phrase can be searched). The browser will highlight the substring if matches are found. Often, if the information is delivered by the server as HTML markup, selector names remain the same. For convenience, you can use the standard element search tool with the mouse: Ctrl + Shift + C on Windows or Cmd + Shift + C on macOS. Press the shortcut and select the element directly on the page. The browser will show the desired element, and its selectors can be conveniently transferred into your code. If the required data is not present, proceed to the next step. Find the requests that contain only JSON. This is easiest to do by filtering: click on the search bar for requests and enter the filter: mime-type: application/json Go through each request with the donor site’s domain and repeat the search for data, as in the previous step. If no necessary data is found, then most likely you will need to resort to browser emulation to parse the information. Tip 3. Use Quick Export of Requests In most cases, along with the request, the browser sends request headers and cookies to the server. Headers transmit metadata that allows the server to understand what data format is being requested and how best to deliver it. Cookies store session information and user preferences. Thanks to this, the server forms a personalized response. Without this data, the server may reject the request if it considers it insufficiently secure. Exporting a Request with cURL This method allows you to export ready-made code for making a request, not only in Python. It works for any requests. Find the desired request in the web inspector. Right-click the request, then choose Copy and Copy as cURL. Now the request information is copied to your clipboard. Go to curlconverter.com, a Swiss Army knife for developers of parsing and automation scripts. Click Python in the programming language selection bar. Paste the copied request into the input field. You now have a ready-made code template with all request parameters, suitable for importing into your IDE. The code contains dictionaries with headers, cookie data, JSON request parameters (json_data, if present), and everything necessary to fully duplicate the request made in the browser. Tip 4. Use a Virtual Environment When Working with Python Most often, scripts for parsing and automation are later uploaded to a remote server. A virtual environment creates a separate environment for the project and isolates its dependencies from system libraries. This helps to avoid version conflicts and reduces the risk of unexpected failures. We explained more about virtual environments and how to create them in another article. To quickly transfer the project to a server, provided you worked in a virtual environment on your local computer, first save the list of libraries with versions from pip into a file requirements.txt: pip freeze > requirements.txt If you just created a server on Ubuntu, you can use a universal script to install Python, a virtual environment, and all dependencies on a clean server. First, transfer the project files (using the scp utility or the FTP protocol), go to the project directory, and paste the ready-made command into the terminal. At the beginning of the command, specify the required Python version in the variable PYVER and then execute the command: export PYVER=3.9 && sudo apt update && sudo apt upgrade -y && sudo apt install -y software-properties-common && sudo add-apt-repository ppa:deadsnakes/ppa -y && sudo apt update && sudo apt install -y python${PYVER} python${PYVER}-venv python${PYVER}-dev python3-pip && python${PYVER} -m venv venv && source venv/bin/activate && pip install --upgrade pip && [ -f requirements.txt ] && pip install -r requirements.txt Tip 5. Include Error Handlers in Your Algorithm When developing a parser, it is important to provide an error handling mechanism. Network failures, changes in the HTML structure, or unexpected blocking by the site may lead to script failures. Add retries for requests, timeouts, and a logging system for all actions and errors. This approach allows you to quickly detect problems, adjust parsing algorithms, and ensure the stability of the application even when the donor site changes. In Python, you can use: try, except, finally constructs; the logging library for logging; loops for retrying failed requests; timeouts, for example: requests: requests.get("hostman.com", timeout=20) aiohttp: timeout = aiohttp.ClientTimeout(total=60, sock_connect=10, sock_read=10)  async with aiohttp.ClientSession(timeout=timeout) as session:      async with session.get(url) as response:          return await response.text() Tip 6. Implement Your Parser as a Generator A generator is a class that implements the logic of an object that iteratively yields elements as needed. Generators are especially convenient to use when developing a parsing script for the following reasons: Lazy evaluation. Generators calculate and return data “on the fly,” which makes it possible to process large volumes of information without consuming significant amounts of memory. When parsing large files or web pages, this is critical: data is processed gradually, and only the current part is stored in memory, not the entire result at once. Increased performance. Since elements are generated as needed, you can begin processing and transferring data (for example, to a database or a bot) before the entire dataset has been obtained. This reduces delays and allows you to react faster to incoming data. Code organization convenience. Generators simplify the implementation of iterative processes, allowing you to focus on the parsing logic rather than managing iteration state. This is especially useful when you need to process a data stream and pass it to other parts of the system. Example of Implementing a Parser as a Generator in Python In the loop where the generator is used, it is convenient to initiate writing data to a database or, for example, sending notifications through a Telegram bot. Using generators makes the code more readable. import requests from bs4 import BeautifulSoup class MyParser: def __init__(self, url): self.url = url def parse(self): """ Generator that sequentially returns data (for example, titles of elements on a page). """ response = requests.get(self.url) if response.status_code != 200: raise Exception(f"Failed to retrieve page, status: {response.status_code}") soup = BeautifulSoup(response.text, "html.parser") items = soup.select("div") for item in items: title = item.select_one("h1").get_text(strip=True) if item.select_one("h1") else "No title" yield { "title": title, "content": item.get_text(strip=True) } if __name__ == "__main__": parser = MyParser("https://example.com") for data_item in parser.parse(): print(data_item["title"], "--", data_item["content"]) Tip 7. Use an Asynchronous Approach to Speed Up Processing a Large Number of Requests When parsing a large number of pages, a synchronous approach often becomes a bottleneck, since each request waits for the previous one to finish. Asynchronous libraries, such as aiohttp in Python, allow you to execute many requests simultaneously, which significantly speeds up data collection. However, to avoid overloading both your application and the donor servers, it is important to properly regulate the request flow. This is where throttling, exponential backoff, and task queue techniques come into play. How It Works Asynchronous requests. Create an asynchronous session with specified timeouts (for example, total timeout, connection timeout, and read timeout). This allows you to process many requests in parallel without blocking the main execution thread. Throttling. To prevent excessive load on the donor server, it makes sense to limit the number of simultaneous requests. This can be done using semaphores or other concurrency control mechanisms (for example, asyncio.Semaphore), so as not to send requests faster than allowed. Exponential backoff. If a request fails (for example, due to a timeout or temporary blocking), use an exponential backoff strategy. On each retry, the waiting interval increases (for example, 1 second, then 2, 4, 8…), which allows the server to recover and reduces the likelihood of repeated errors. Task queues. Organizing queues (for example, with asyncio.Queue) helps manage a large flow of requests. First, a queue of URLs is formed, then requests are processed as “slots” become available for execution. This ensures an even distribution of load and stable operation of the parser. Example of Implementation in Python Using aiohttp import asyncio import aiohttp from aiohttp import ClientTimeout # Limit the number of simultaneous requests semaphore = asyncio.Semaphore(10) async def fetch(session, url): async with semaphore: try: async with session.get(url) as response: return await response.text() except Exception: # Apply exponential backoff in case of error for delay in [1, 2, 4, 8]: await asyncio.sleep(delay) try: async with session.get(url) as response: return await response.text() except Exception: continue return None async def main(urls): timeout = ClientTimeout(total=60, sock_connect=10, sock_read=10) async with aiohttp.ClientSession(timeout=timeout) as session: tasks = [asyncio.create_task(fetch(session, url)) for url in urls] results = await asyncio.gather(*tasks) # Process the obtained data for result in results: if result: print(result[:200]) # Print the first 200 characters of the response # Example list of URLs for parsing urls = ["http://hostman.com"] * 100 asyncio.run(main(urls)) Recommendations for Developers There are also recommendations that will help simplify a developer’s work: Check if the donor site has a public API. Sometimes the task of writing a parsing algorithm has already been solved, and the site offers a convenient API that fully covers the required functionality. Monitor changes in the site’s structure. Donor site developers may change the layout, which would require you to update the selectors of the elements used in your code. Test function execution at every stage. Automated tests (unit tests, integration tests) help promptly detect issues related to site structure changes or internal code modifications. Checklist for Determining the Parsing Method We have systematized the information from this article so you can understand which parsing method to use when working with any donor site. Conclusion The universal parsing methods presented here form a reliable foundation for developing algorithms capable of extracting data from a wide variety of websites, regardless of the programming language chosen. Following these scraping best practices and tips allows you to build a flexible, scalable, and change-resistant algorithm. Such an approach not only helps to optimally use system resources but also ensures the ability to quickly integrate the obtained data with databases, messengers, or other external services.
23 September 2025 · 12 min to read
Python

How to Use Python time.sleep()

Sometimes, while running a program, it’s necessary to pause: wait for data to load, give the user time to enter input, or reduce the load on the system. One of the simplest ways to achieve this in Python is with the time.sleep() function, which suspends program execution for a given interval. In this article, we’ll examine how time.sleep() works in Python, its features and alternatives, as well as possible errors. We’ll discuss when it’s appropriate to use it in multithreaded and asynchronous programs, and when it’s better to choose asyncio.sleep() or other waiting mechanisms. What is the sleep() Function in Python? Python's time.sleep() function can be used to freeze the current thread's execution for a specific period of time. The built-in time module in Python contains this function. This function in Python was added to the standard library to simplify creating pauses in code. It is located in the time module and is called time.sleep, allowing you to pause program execution for a specified number of seconds. In practice, sleep() is useful for pauses in test environments, delays between API requests, or intervals between sending messages. However, you should not confuse its use for system-level tasks, such as thread synchronization, with simply slowing down a script. If precise timing coordination or asynchronous I/O is needed, other tools are more suitable. How time.sleep() Works The time.sleep() function in Python pauses the current thread for the specified number of seconds. In a multithreaded scenario, other threads continue running, but the one where time.sleep() was called remains "frozen" for that interval. It’s important to note that time.sleep() blocks code execution at that point, delaying all subsequent operations. Ignoring this rule can lead to reduced performance or even a frozen user interface in desktop applications. When time.sleep() is Used Most often, time.sleep() is used in testing and debugging, when a short delay is needed—for example, to verify the correctness of an API response or wait for a server reply. It’s also used for step-by-step script execution, giving the user time to view information or enter data. In demonstrations, tutorials, and prototyping, time.sleep() helps simulate long-running processes, and when working with external services, it helps avoid penalties or blocks from too frequent requests. However, sleep() is not the only way to slow down code execution. Further in the article, we’ll review some alternatives. How to Use time.sleep() in Python You must import the time module before you can use time.sleep(). The required delay in seconds can then be passed as a parameter when calling time.sleep(). For a few seconds, this delay may be expressed as a floating-point number or as a whole number.  Basic Syntax of time.sleep() To call the time.sleep() function, first import the time module: import time time.sleep(5) In this example, the program will "sleep" for 5 seconds. The number passed to the function can be either an integer or a float, which allows sleeping for fractions of a second. Syntax: time.sleep(seconds) The time.sleep() function does not return any value. That means you cannot precisely determine how accurate the pause was—it simply suspends the current thread for the specified duration. Example: Delaying Code Execution Suppose you have a small script that prints messages with a 2-second interval. To add a delay in Python, just insert time.sleep(2): import time print("First message") time.sleep(2) print("Second message") time.sleep(2) print("Third message") When running this script, the user will see a 2-second pause between each message. That’s exactly how a delay in Python works using time.sleep(2). Parameters of time.sleep() The time.sleep() function accepts only one parameter, but it can be either an integer or a float. This adds flexibility when implementing delays in Python. Passing Values in Seconds Most examples of time.sleep() usage pass an integer representing seconds. For example: time.sleep(10) Here, the script pauses for 10 seconds. This is convenient when you need a long pause or want to limit request frequency. Using Fractions of a Second (Milliseconds) Sometimes you need to pause for a few milliseconds or fractions of a second. To do this, you can pass a floating-point number: time.sleep(0.5) This creates a half-second pause. However, because of OS and Python timer limitations, the delay may slightly exceed 500 milliseconds. For most tasks, this isn’t critical, but in high-precision real-time systems, specialized tools should be used instead. Alternative Ways to Pause in Python Although time.sleep() is the most popular and simplest way to create pauses, there are other methods that may be more suitable when waiting for external events or handling multiple threads. Let’s look at the most common alternatives. Using input() for Waiting The simplest way to pause in Python is by calling input(). It suspends execution until the user presses Enter or enters data. Example: print("Press Enter to continue...") input() print("Resuming program execution") While this feels like a pause, technically it’s not a timed delay. The program waits for user action, not a fixed interval. This method is rarely useful in automated scripts but can be handy in debugging or console utilities where a "pause on demand" is needed. Waiting with threading.Event() If you’re writing a multithreaded program, it can be more useful to use synchronization objects like threading.Event(). You can configure it to block a thread until a signal is received. Example: import threading event = threading.Event() def worker():     print("Starting work in thread")     event.wait()     print("Event received, resuming work") thread = threading.Thread(target=worker) thread.start() import time time.sleep(3) event.set() In this case, the thread is blocked until event.set() is called. You can still use time.sleep() to set a maximum pause, but unlike plain sleep(), this approach allows more flexible control. The thread can be "woken up" immediately without waiting for the full interval. asyncio.sleep() for Asynchronous Programs In asynchronous Python programming (asyncio module), asyncio.sleep() is used. Unlike time.sleep(), it doesn’t block the entire thread but only suspends the current coroutine, allowing the event loop to continue running other tasks. Example: import asyncio async def main(): print("Start async work") await asyncio.sleep(2) print("2 seconds passed, resuming") asyncio.run(main()) This is especially useful when you have multiple asynchronous functions that should run in parallel without interfering with each other. If you use regular time.sleep() in async code, it will block the entire event loop, causing other coroutines to wait too. Common Issues When Using time.sleep()  The time.sleep() function is simple, but misusing it can cause unexpected problems. It’s important to understand how it affects program execution so you don’t block important processes. Blocking the Main Thread The main feature of time.sleep() is that it blocks the thread where it was called. If you use it in the main thread of a GUI application (for example, Tkinter or PyQt), the interface will stop responding, creating a "frozen" effect. To avoid this, use time.sleep() only in separate threads or switch to asynchronous approaches like asyncio.sleep() for non-blocking delays. In GUI applications, it’s better to use timers (QTimer, after, etc.), which call functions at intervals without blocking the interface. Use in Multithreaded and Asynchronous Code In multithreaded code, time.sleep() can be called independently in each thread, but note that it doesn’t automatically release the Global Interpreter Lock (GIL). While other threads can still run during one thread’s sleep, in Python this depends on OS-level thread scheduling. In asynchronous code, time.sleep() should be used cautiously. If called inside an event loop (like with asyncio.run()), it blocks the entire loop, defeating the benefits of async programming. Instead, use asyncio.sleep(), which hands control back to the scheduler, letting other coroutines run in the background. Real-World Example of Using time.sleep() Imagine you’re writing a script to periodically poll an external API, which, according to its rules, must not be called more than once every 30 seconds. If requests are too frequent, the server may return errors or block your IP. Solution using time.sleep(): import time def poll_api(): print("Making API request...") def main(): while True: poll_api() time.sleep(30) if __name__ == "__main__": main() Here, after each request, we pause for 30 seconds with time.sleep(). This ensures no more than two requests per minute, respecting the limits. Async alternative: import asyncio async def poll_api(): print("Making API request...") async def main(): while True: await poll_api() await asyncio.sleep(30) if __name__ == "__main__": asyncio.run(main()) This version doesn’t block the entire program, allowing other requests or tasks to run in the same async environment. It’s more flexible and scalable. Conclusion Organizing pauses and delays is an important aspect of Python development. time.sleep() is the first and most obvious tool for this, but choosing between time.sleep(), asyncio.sleep(), and other methods should depend on your project’s architecture. In single-threaded scripts and console utilities, time.sleep() is perfectly fine, but for multithreaded and asynchronous applications, other mechanisms are better. Key recommendations: Use time.sleep() for short delays in tests, pauses between requests, or interface demonstrations. Don’t block the main thread of GUI applications to avoid a "frozen" interface. In async code, replace time.sleep() with asyncio.sleep() to keep the event loop efficient. In multithreaded programs, remember only the current thread pauses, but GIL affects scheduling. In special cases, use threading.Event() or input() to wait for events or user actions.
19 September 2025 · 8 min to read
Python

How to Delete Characters from a String in Python

When writing Python code, developers often need to modify string data. Common string modifications include: Removing specific characters from a sequence Replacing characters with others Changing letter case Joining substrings into a single sequence In this guide, we will focus on the first transformation—deleting characters from a string in Python. It’s important to note that strings in Python are immutable, meaning that any method or function that modifies a string will return a new string object with the changes applied. Methods for Deleting Characters from a String This section covers the main methods in Python used for deleting characters from a string. We will explore the following methods: replace() translate() re.sub() For each method, we will explain the syntax and provide practical examples. replace() The first Pyhton method we will discuss is replace(). It is used to replace specific characters in a string with others. Since strings are immutable, replace() returns a new string object with the modifications applied. Syntax: original_string.replace(old, new[, count]) Where: original_string – The string where modifications will take place old – The substring to be replaced new – The substring that will replace old count (optional) – The number of occurrences to replace (if omitted, all occurrences will be replaced) First, let’s remove all spaces from the string "H o s t m a n": example_str = "H o s t m a n" result_str = example_str.replace(" ", "") print(result_str) Output: Hostman We can also use the replace() method to remove newline characters (\n). example_str = "\nHostman\nVPS" print(f'Original string: {example_str}') result_str = example_str.replace("\n", " ") print(f'String after adjustments: {result_str}') Output: Original string: Hostman VPS String after adjustments: Hostman VPS The replace() method has an optional third argument, which specifies the number of replacements to perform. example_str = "Hostman VPS Hostman VPS Hostman VPS" print(f'Original string: {example_str}') result_str = example_str.replace("Hostman VPS", "", 2) print(f'String after adjustments: {result_str}') Output: Original string: Hostman VPS Hostman VPS Hostman VPS String after adjustments: Hostman VPS Here, only two occurrences of "Hostman VPS" were removed, while the third occurrence remained unchanged. We have now explored the replace() method and demonstrated its usage in different situations. Next, let’s see how we can delete and modify characters in a string using translate(). translate( The Python translate() method functions similarly to replace() but with additional flexibility. Instead of replacing characters one at a time, it allows mapping multiple characters using a dictionary or translation table. The method returns a new string object with the modifications applied. Syntax: original_string.translate(mapping_table) In the first example, let’s remove all occurrences of the $ symbol in a string and replace them with spaces: example_str = "Hostman$Cloud$—$Cloud$Service$Provider." print(f'Original string: {example_str}') result_str = example_str.translate({ord('$'): ' '}) print(f'String after adjustments: {result_str}') Output: Original string: Hostman$Cloud$—$Cloud$Service$Provider. String after adjustments: Hostman Cloud — Cloud Service Provider. To improve code readability, we can define the mapping table before calling translate(). This is useful when dealing with multiple replacements: example_str = "\nHostman%Cloud$—$Cloud$Service$Provider.\n" print(f'Original string: {example_str}') # Define translation table example_table = {ord('\n'): None, ord('$'): ' ', ord('%'): ' '} result_str = example_str.translate(example_table) print(f'String after adjustments: {result_str}') Output: Original string: Hostman%Cloud$—$Cloud$Service$Provider. String after adjustments: Hostman Cloud — Cloud Service Provider. re.sub() In addition to replace() and translate(), we can use regular expressions for more advanced character removal and replacement. Python's built-in re module provides the sub() method, which searches for a pattern in a string and replaces it. Syntax: re.sub(pattern, replacement, original_string [, count=0, flags=0]) pattern – The regular expression pattern to match replacement – The string or character that will replace the matched pattern original_string – The string where modifications will take place count (optional) – Limits the number of replacements (default is 0, meaning replace all occurrences) flags (optional) – Used to modify the behavior of the regex search Let's remove all whitespace characters (\s) using the sub() method from the re module: import re example_str = "H o s t m a n" print(f'Original string: {example_str}') result_str = re.sub('\s', '', example_str) print(f'String after adjustments: {result_str}') Output: Original string: H o s t m a nString after adjustments: Hostman Using Slices to Remove Characters In addition to using various methods to delete characters, Python also allows the use of slices. As we know, slices extract a sequence of characters from a string. To delete characters from a string by index in Python, we can use the following slice: example_str = "\nHostman \nVPS" print(f'Original string: {example_str}') result_str = example_str[1:9] + example_str[10:] print(f'String after adjustments: {result_str}') In this example, we used slices to remove newline characters. The output of the code: Original string:HostmanVPSString after adjustments: Hostman VPS Apart from using two slice parameters, you can also use a third one, which specifies the step size for index increments. For example, if we set the step to 2, it will remove every odd-indexed character in the string. Keep in mind that indexing starts at 0. Example: example_str = "Hostman Cloud" print(f'Original string: {example_str}') result_str = example_str[::2] print(f'String after adjustments: {result_str}') Output: Original string: Hostman CloudString after adjustments: HsmnCod Conclusion In this guide, we learned how to delete characters from a string in Python using different methods, including regular expressions and slices. The choice of method depends on the specific task. For example, the replace() method is suitable for simpler cases, while re.sub() is better for more complex situations.
23 August 2025 · 5 min to read

Do you have questions,
comments, or concerns?

Our professionals are available to assist you at any moment,
whether you need help or are just unsure of where to start.
Email us
Hostman's Support