Installing Ruff

Now that you know why linting your code is important and how Ruff is a powerful tool for the job, it’s time to install it. Thankfully, Ruff works out of the box, so no complicated installation instructions or configurations are needed to start using it.

Assuming your project is already set up with a virtual environment, you can install Ruff in the following ways:

$python-mpipinstallruff

In addition topip, you can also install Ruff withHomebrew if you’re on macOS or Linux:

$brewinstallruff

Conda users can install Ruff usingconda-forge:

$condainstall-cconda-forgeruff

If you use Arch, Alpine, or openSUSE Linux, you can also use the official distribution repositories. You’ll find specific instructions on theRuff installation page of the official documentation.

Additionally, if you’d like Ruff to be available for all your projects, you might want to install Ruff withpipx.

You can check that Ruff installed correctly by using theruff version command:

$ruffversionruff 0.4.7

For theruff command to appear in yourPATH, you may need to close and reopen your terminal application or start a new terminal session.

Linting Your Python Code

While linting helps keep your code consistent and error-free, it doesn’t guarantee that your code will bebug-free. Finding the bugs in your code is best handled with adebugger and adequatetesting, which won’t be covered in this tutorial. Coming up in the next sections, you’ll learn how to use Ruff to check for errors and speed up your workflow.

 1importos 2importrandom 3 4CHARACTERS=("Frodo","Sam","Merry","Pippin","Aragorn","Legolas","Gimli","Boromir","Gandalf","Saruman","Sauron") 5 6defrandom_character(): 7returnrandom.choice(CHARACTERS) 8 9defring_bearer():10returnnamein("Frodo","Sam")1112if__name__=="__main__":13character=random_character()14ifring_bearer(character):15print(f"{character} is a ring bearer")16else:17print(f"{character} is not a ring bearer")

$ruffcheckone_ring.py:1:8: F401 [*] `os` imported but unusedone_ring.py:10:12: F821 Undefined name `name`Found 2 errors.[*] 1 fixable with the `--fix` option.

$ruffcheck--fixone_ring.py:9:12: F821 Undefined name `name`Found 2 errors (1 fixed, 1 remaining).

$ruffruleF821

# undefined-name (F821)Derived from the**PyFlakes** linter.## What it doesChecks for uses of undefined names.## Why is this bad?An undefined name is likely to raise`NameError` at runtime.## Example```pythondefdouble():returnn*2# raises `NameError` if `n` is undefined when `double` is called```Use instead:```pythondefdouble(n):returnn*2```## References-[Python documentation: Naming and binding](https://docs.python.org/3/reference/executionmodel.html#naming-and-binding)

# ...defring_bearer(name):   returnnamein("Frodo","Sam")

$ruffcheckAll checks passed!

 1importrandom 2 3CHARACTERS=("Frodo","Sam","Merry","Pippin","Aragorn","Legolas","Gimli","Boromir","Gandalf","Saruman","Sauron") 4 5defrandom_character(): 6returnrandom.choice(CHARACTERS) 7 8defring_bearer(name): 9returnnamein("Frodo","Sam")1011if__name__=="__main__":12character=random_character()13ifring_bearer(character):14print(f"{character} is a ring bearer")15else:16print(f"{character} is not a ring bearer")

$ruffcheck--watch

[14:04:01 PM] Starting linter in watch mode...[14:04:01 PM] Found 0 errors. Watching for file changes.

$ruffcheck--selectEone_ring.py:4:89: E501 Line too long (122 > 88)Found 1 error.$ruffcheck--selectE501one_ring.py:4:89: E501 Line too long (122 > 88)Found 1 error.

Formatting Your Python Code

By default, Ruff has sensible formatting rules and was designed to be adrop-in replacement for Black. Theformat command has been available sinceRuff version 0.1.2.

Just like thecheck command, theformat command takes optional arguments for a path to a single file or directory. Since the code you have in this tutorial example is a single file, you can go ahead and use it without any arguments:

$ruffformat1 file reformatted

Yourone_ring.py file should now look more readable and have consistent formatting:

 1importrandom 2 3CHARACTERS=( 4"Frodo", 5"Sam", 6"Merry", 7"Pippin", 8"Aragorn", 9"Legolas",10"Gimli",11"Boromir",12"Gandalf",13"Saruman",14"Sauron",15)161718defrandom_character():19returnrandom.choice(CHARACTERS)202122defring_bearer(name):23returnnamein("Frodo","Sam")242526if__name__=="__main__":27character=random_character()28ifring_bearer(character):29print(f"{character} is a ring bearer")30else:31print(f"{character} is not a ring bearer")

As you can see, the previous line length error inline 3 has been addressed. And although the tuple takes up more lines, it’s much easier to parse and read the list of character names. This also makes it easier for code reviewers to review changes, as most tools and platforms will only show what has exactly changed in thediff and not the whole data structure.

The next change it made is that the spacing between functions is now consistent andPEP 8 compliant, with the recommended two spaces between functions.

The last change, although it may seem insignificant, is that Ruff added the missing newline at the end of the file.

This is a short piece of code that was straightforward to format. Longer code bases may need many changes, which could potentially break some functionality, though this is rare as formatters always err on the side of caution. To learn more aboutunsafe fixes in Ruff, refer to thefix safety section in Ruff’s documentation.

If you’d like to see what changes will be made when you runruff format, you can run it with the--diff flag to see the proposed changes before you make them. If you had run the--diff flag before runningruff format, you would’ve seen this output:

--- one_ring.py+++ one_ring.py@@ -1,16 +1,31 @@import random-CHARACTERS = ("Frodo", "Sam", "Merry", "Pippin", "Aragorn", "Legolas", "Gimli", "Boromir", "Gandalf", "Saruman", "Sauron")+CHARACTERS = (+    "Frodo",+    "Sam",+    "Merry",+    "Pippin",+    "Aragorn",+    "Legolas",+    "Gimli",+    "Boromir",+    "Gandalf",+    "Saruman",+    "Sauron",+)+def random_character():    return random.choice(CHARACTERS)+def ring_bearer(name):    return name in ("Frodo", "Sam")+if __name__ == "__main__":    character = random_character()    if ring_bearer(character):        print(f"{character} is a ring bearer")    else:-        print(f"{character} is not a ring bearer")\ No newline at end of file+        print(f"{character} is not a ring bearer")1 file would be reformatted

This may be all you ever need to format your code. However, there may be times you’d prefer a different line length or would like to include or exclude certain rules. In these situations, it can be time-consuming to list all your required rules to the command line each time you want to lint your code. There must be a better way!

There is. Although not required, Ruff can behighly configurable. In the next section, you’ll get a brief look into a few configuration basics.

Configuring Ruff

If you’re linting a larger code base, have multiple committers, or want to customize your experience, Ruff allows you to store your configuration in aTOML file. More specifically, aruff.toml,.ruff.toml, or your existingpyproject.toml file.

As mentioned earlier,ruff has sensible defaults. These configurations are documented on theRuff configuration page for you to read. The fulllist of settings available for your configuration is well documented. Here’s an example of a simpleruff.toml configuration you can add to your project:

 1line-length=88 2 3[lint] 4select=["E501","I"] 5 6[format] 7docstring-code-format=true 8docstring-code-line-length=72

And here’s the same example in apyproject.toml format. The only change is that you need to include atool.ruff prefix in each table header:

[tool.ruff]line-length=88[tool.ruff.lint]select=["E501","I"][tool.ruff.format]docstring-code-format=truedocstring-code-line-length=72

In these examples, you’ll notice a few new rules. Just as you did earlier, you’ve specifed that you want to include theE501 rule when linting withruff, which will return an error when the line length is greater than the default 88 characters.

In addition to adding theE501 rule to the linting configuration, you’ve also asked Ruff to add all theI rules.I rules are unique to isort, another package you may have used before to lint and format your Pythonimport statements. With this configuration, you no longer need isort and Black to format your code. This means fewer tools to manage and fewer developer dependencies.

Inlines 6 to 8, you’ll see that Ruff will now format yourdocstrings to a length of 72 characters. This number could be anything you want it to be, and many might choose 88 characters to match the code line length. Keep in mind that by default, Ruff doesn’t format docstrings.

There are many linting and formatting settings available, so it’s a good idea to scroll through the list of settings to see which ones you want to add to your Ruff configuration.

If you already have experience with a linter, please feel free to share your favorite rules and customizations in the comments below.

Next Steps

Now that you’ve learned why you should use a linter and how Ruff is a great tool to help youachieve clean, readable, and error-free code, you should take Ruff for a spin.

As mentioned above, there are a plethora of configurations you can use to take your linting to the next level. There are alsoa few integrations that canspeed up your workflow, such as theVS Code extension,PyCharm plugin,pre-commit hook, andGitHub Actions.

Conclusion

Ruff is an extremely fast Python linter and code formatter that can help you improve your code quality and maintainability. This tutorial explained how to get started with Ruff, showcased its key features, and demonstrated how powerful it can be.

In this tutorial, you learned how to:

• Install Ruff
• Check your Python code for errors
• Automaticallyfix your linting errors
• Use Ruff toformat your code
• Add optional configurations to supercharge your linting

With this new tool in your toolbox, you’ll be able to take your code to the next level and ensure it looks professional and, more importantly, is error-free.

Take the Quiz: Test your knowledge with our interactive “Ruff: A Modern Python Linter” quiz. You’ll receive a score upon completion to help you track your learning progress:

---

Interactive Quiz

Ruff: A Modern Python Linter

In this quiz, you'll test your understanding of Ruff, a modern linter for Python. By working through this quiz, you'll revisit why you'd want to use Ruff to check your Python code and how it automatically fixes errors, formats your code, and provides optional configurations to enhance your linting.