Using Debug Mode in Uvicorn Python Files in PyCharm


Debugging is an essential part of the development process. It allows developers to identify and fix issues in their code, leading to more efficient and robust applications. When working with Uvicorn, a lightning-fast ASGI server for Python web applications, it’s crucial to know how to leverage the debug mode to streamline the debugging process. In this blog post, we’ll explore how to use debug mode in Uvicorn Python files in PyCharm, a popular integrated development environment (IDE).


Before we dive into the details, ensure that you have the following prerequisites in place:

  1. Python and PyCharm: Make sure you have Python installed on your machine, along with the PyCharm IDE. You can download the latest versions from the official Python and JetBrains websites.
  2. Uvicorn: Install the Uvicorn server if it’s not already installed. You can do this using the pip package manager by running the command pip install uvicorn.

Step-by-Step Guide

Now, let’s go through the step-by-step process of using debug mode in Uvicorn Python files in PyCharm:

Step 1: Set Up the Project

Open your project in PyCharm, or create a new one if needed. Ensure that you have a Python file containing the Uvicorn server code you want to debug. If you don’t have such a file, create a new Python file and import the necessary dependencies.

Step 2: Install Dependencies

If you haven’t already installed Uvicorn, open the terminal within PyCharm and run the command pip install uvicorn to install it.

Step 3: Modify the Uvicorn Server Code

Locate the section of the code where the Uvicorn server is instantiated. This is typically the section that looks similar to the following:

if __name__ == "__main__":, host="", port=8000)

To enable debug mode, modify the code as follows:

import uvicorn

if __name__ == "__main__":, host="", port=8000, debug=True)

By adding debug=True as an argument to the function, we enable debug mode in Uvicorn.

Step 4: Set Breakpoints

Next, set breakpoints in your code where you want the debugger to stop. Breakpoints allow you to pause the execution of the program at specific locations and inspect the values of variables and the program’s state. To set a breakpoint, click on the left gutter of the code editor next to the line numbers. You can set multiple breakpoints if necessary.

Step 5: Start the Debugger

Once you’ve set the breakpoints, you can start the debugger. Click on the “Debug” button in the toolbar or go to the “Run” menu and choose the “Debug” option. This action will initiate the Uvicorn server in debug mode.

Step 6: Debugging Process

With the debugger running, the Uvicorn server will start in debug mode. Execution will pause at the breakpoints you set, allowing you to analyze the program’s behavior and inspect variables. You can use various debugging features provided by PyCharm, such as stepping through the code, evaluating expressions, and watching variables.

Step 7: Analyze and Fix Issues As the program execution pauses at breakpoints, you can examine the values of variables, step through the code line by line, and analyze the program’s behavior to identify any issues or bugs. Use the debugging features provided by PyCharm, such as the Variables pane, Console, and Watches, to gain insights into the state of your application and track any anomalies.

While in debug mode, you can take advantage of PyCharm’s powerful debugging tools, such as:

  1. Stepping: Step through the code line by line using the Step Over (F8), Step Into (F7), and Step Out (Shift+F8) buttons. This allows you to follow the flow of execution and understand how the program progresses.
  2. Variable Inspection: Inspect the values of variables at different points in the code. The Variables pane in PyCharm displays all the variables in the current scope, allowing you to examine their values and make informed decisions about the program’s behavior.
  3. Conditional Breakpoints: Set breakpoints with conditions to pause execution only when specific conditions are met. This can be helpful when you want to focus on a particular scenario or when you want to investigate a specific branch of code.
  4. Expression Evaluation: Use the Console in PyCharm to evaluate expressions and test hypotheses about the program’s behavior. You can execute Python statements and inspect variables interactively to gain a deeper understanding of your code.
  5. Watch Variables: Add variables to the Watches pane to monitor their values continuously during the debugging process. This helps you keep track of important variables and detect any unexpected changes.

Step 8: Fixing Issues As you analyze the behavior of your Uvicorn server in debug mode, you may encounter bugs or unexpected behavior. The insights gained from the debugger can help you identify the root cause of the problem more efficiently.

When you encounter an issue, use the debugger to examine the state of variables, step through the code to understand the flow, and evaluate expressions to pinpoint problematic areas. With this information, you can make the necessary changes to your code to fix the issue.


Debugging is a crucial aspect of software development, and knowing how to use debug mode in Uvicorn Python files in PyCharm can greatly enhance your debugging experience. By leveraging breakpoints, variable inspection, stepping, and other debugging features, you can gain valuable insights into your code’s behavior and quickly identify and resolve issues.

In this blog post, we walked through the step-by-step process of enabling debug mode in Uvicorn Python files, setting breakpoints, starting the debugger, and utilizing PyCharm’s debugging tools. By following these steps, you can effectively debug your Uvicorn server code, leading to more robust and reliable web applications.

Debugging is a skill that improves with practice, so don’t hesitate to experiment with different scenarios and explore PyCharm’s debugging capabilities. Happy debugging!


How to Achieve LINQ-like Functionality in Python

Are you familiar with LINQ (Language-Integrated Query), a powerful feature of C# that enables you to query data from various sources in a declarative and composable way? If you’re a Python developer, you might be wondering if there’s an equivalent way to achieve LINQ-like functionality in Python. Fortunately, Python has a rich set of features that can help you achieve similar results. In this blog post, we’ll explore some examples of how you can use Python to filter, project, and manipulate sequences of data, just like you can with LINQ.


First, let’s define what we mean by “LINQ-like functionality”. LINQ provides a set of methods that you can use to perform queries on data sources, such as lists, arrays, and databases. These methods are chainable and composable, which means that you can combine them in various ways to create powerful queries. Here are some common LINQ methods and their Python equivalents:

  • Where -> List comprehension or filter()
  • Select -> List comprehension or map()
  • OrderBy -> Sorted()
  • GroupBy -> itertools.groupby()
  • Join -> Nested loops or dict lookup

Note that LINQ also supports many other methods, such as Distinct, Count, Sum, Max, Min, and more, but we’ll focus on the above methods for this blog post.

Sequences in Python

Before we dive into the examples, let’s briefly review the concept of sequences in Python. In Python, a sequence is an ordered collection of elements, such as a list, tuple, or string. You can perform various operations on sequences, such as indexing, slicing, concatenation, and iteration. Here’s an example of a list of numbers:

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

We can perform various operations on this list, such as indexing:

codeprint(numbers[0])  # prints 1
print(numbers[-1])  # prints 5


codeprint(numbers[1:3])  # prints [2, 3]


codemore_numbers = [6, 7, 8]
all_numbers = numbers + more_numbers
print(all_numbers)  # prints [1, 2, 3, 4, 5, 6, 7, 8]


codefor n in numbers:



Now that we’re familiar with sequences in Python, let’s see how we can use them to achieve LINQ-like functionality.



LINQ provides the Where method to filter elements in a sequence based on a predicate. In Python, you can use a list comprehension or the filter() function to achieve similar functionality. Here’s an example:

codenumbers = [1, 2, 3, 4, 5, 6]
even_numbers = [n for n in numbers if n % 2 == 0]
print(even_numbers)  # prints [2, 4, 6]

In this example, we filter the numbers list to include only the even numbers. We use a list comprehension that iterates over each element n in numbers and only includes it in the even_numbers list if its remainder when divided by 2 is 0.

You can achieve the same result using the filter() function and a lambda function as the predicate:

codenumbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda n: n % 2 == 0, numbers))
print(even_numbers)  # prints [2, 4, 6]

In this example, we pass a lambda function that checks if the remainder of the argument n when divided by 2 is 0, and use filter() to only include elements that satisfy this condition.


LINQ provides the Select method to project each element of a sequence into a new form. In Python, you can use a list comprehension or the map() function to achieve similar functionality. Here’s an example:

codenames = ['Alice', 'Bob', 'Charlie']
name_lengths = [len(name) for name in names]
print(name_lengths)  # prints [5, 3, 7]

In this example, we project each element name in the names list into its length using a list comprehension.

You can achieve the same result using the map() function and the len built-in function:

codenames = ['Alice', 'Bob', 'Charlie']
name_lengths = list(map(len, names))
print(name_lengths)  # prints [5, 3, 7]

In this example, we pass the len function as the first argument to map(), and names as the second argument. This applies the len function to each element of names and returns a map object, which we convert to a list using list().


LINQ provides the OrderBy method to sort elements in a sequence based on a key. In Python, you can use the sorted() function to achieve similar functionality. Here’s an example:

codenumbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # prints [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

In this example, we sort the numbers list in ascending order using the sorted() function.

You can also sort in descending order by passing the reverse=True argument:

codenumbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers, reverse=True)
print(sorted_numbers)  # prints [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]


LINQ provides the GroupBy method to group elements in a sequence based on a key. In Python, you can use the itertools.groupby() function to achieve similar functionality. Here’s an example:

codeanimals = ['ant', 'bat', 'cat', 'dog', 'elephant']
key_func = lambda animal: animal[0]  # group by first letter
animal_groups = {key: list(group) for key, group in itertools.groupby(animals, key_func)}
print(animal_groups)  # prints {'a': ['ant'], 'b': ['bat'], 'c': ['cat'], 'd': ['dog']

In this example, we group the animals list by the first letter of each animal name using a lambda function key_func, and pass animals and key_func to itertools.groupby(). The resulting object is an iterator that returns consecutive keys and groups, which we convert to a dictionary where the keys are the group keys and the values are lists of group elements.


LINQ provides several methods for aggregating elements in a sequence, such as Sum, Average, and Count. In Python, you can use built-in functions like sum(), len(), and max() to achieve similar functionality. Here’s an example:

codenumbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sum_of_numbers = sum(numbers)
average_of_numbers = sum(numbers) / len(numbers)
max_number = max(numbers)
min_number = min(numbers)
count_of_numbers = len(numbers)
print(sum_of_numbers)  # prints 44
print(average_of_numbers)  # prints 4.0
print(max_number)  # prints 9
print(min_number)  # prints 1
print(count_of_numbers)  # prints 11

In this example, we use the sum() function to calculate the sum of the numbers list, and divide it by the length of the list to calculate the average. We also use the max() and min() functions to find the maximum and minimum values, respectively. Finally, we use the len() function to calculate the count of elements in the list.


Python offers a wide range of built-in functions and libraries that can be used to achieve LINQ-like functionality. Although the syntax may be slightly different, the core concepts remain the same, and with a bit of practice, you can become proficient in using Python to manipulate and query data.

In conclusion, we have explored how to achieve LINQ-like functionality in Python using built-in functions and libraries. We have covered a range of concepts including filtering, mapping, grouping, and aggregation, and provided examples to demonstrate how each of these operations can be performed in Python.

While LINQ and Python have different syntax, the core concepts are similar, and by leveraging the built-in functions and libraries provided by Python, you can achieve the same functionality as LINQ. This flexibility and power make Python an excellent choice for data manipulation and analysis tasks.

As you become more comfortable with Python, you may also want to explore other third-party libraries such as Pandas, which provides a high-level interface for data manipulation and analysis, and can help streamline your workflow even further.

We hope that this article has been helpful in showing how to achieve LINQ-like functionality in Python, and has inspired you to explore the vast capabilities of Python for data manipulation and analysis.