python global assignment one line

Python Global Variables – How to Define a Global Variable Example

In this article, you will learn the basics of global variables.

To begin with, you will learn how to declare variables in Python and what the term 'variable scope' actually means.

Then, you will learn the differences between local and global variables and understand how to define global variables and how to use the global keyword.

Here is what we will cover:

• Variable scope explained
• How to create variables with local scope
• The global keyword

What Are Variables in Python and How Do You Create Them? An Introduction for Beginners

You can think of variables as storage containers .

They are storage containers for holding data, information, and values that you would like to save in the computer's memory. You can then reference or even manipulate them at some point throughout the life of the program.

A variable has a symbolic name , and you can think of that name as the label on the storage container that acts as its identifier.

The variable name will be a reference and pointer to the data stored inside it. So, there is no need to remember the details of your data and information – you only need to reference the variable name that holds that data and information.

When giving a variable a name, make sure that it is descriptive of the data it holds. Variable names need to be clear and easily understandable both for your future self and the other developers you may be working with.

Now, let's see how to actually create a variable in Python.

When declaring variables in Python, you don't need to specify their data type.

For example, in the C programming language, you have to mention explicitly the type of data the variable will hold.

So, if you wanted to store your age which is an integer, or int type, this is what you would have to do in C:

However, this is how you would write the above in Python:

The variable name is always on the left-hand side, and the value you want to assign goes on the right-hand side after the assignment operator.

Keep in mind that you can change the values of variables throughout the life of a program:

You keep the same variable name, my_age , but only change the value from 28 to 29 .

What Does Variable Scope in Python Mean?

Variable scope refers to the parts and boundaries of a Python program where a variable is available, accessible, and visible.

There are four types of scope for Python variables, which are also known as the LEGB rule :

• E nclosing,

For the rest of this article, you will focus on learning about creating variables with global scope, and you will understand the difference between the local and global variable scopes.

How to Create Variables With Local Scope in Python

Variables defined inside a function's body have local scope, which means they are accessible only within that particular function. In other words, they are 'local' to that function.

You can only access a local variable by calling the function.

Look at what happens when I try to access that variable with a local scope from outside the function's body:

It raises a NameError because it is not 'visible' in the rest of the program. It is only 'visible' within the function where it was defined.

How to Create Variables With Global Scope in Python

When you define a variable outside a function, like at the top of the file, it has a global scope and it is known as a global variable.

A global variable is accessed from anywhere in the program.

You can use it inside a function's body, as well as access it from outside a function:

What happens when there is a global and local variable, and they both have the same name?

In the example above, maybe you were not expecting that specific output.

Maybe you thought that the value of city would change when I assigned it a different value inside the function.

Maybe you expected that when I referenced the global variable with the line print(f" I want to visit {city} next year!") , the output would be #I want to visit London next year! instead of #I want to visit Athens next year! .

However, when the function was called, it printed the value of the local variable.

Then, when I referenced the global variable outside the function, the value assigned to the global variable was printed.

They didn't interfere with one another.

That said, using the same variable name for global and local variables is not considered a best practice. Make sure that your variables don't have the same name, as you may get some confusing results when you run your program.

How to Use the global Keyword in Python

What if you have a global variable but want to change its value inside a function?

Look at what happens when I try to do that:

By default Python thinks you want to use a local variable inside a function.

So, when I first try to print the value of the variable and then re-assign a value to the variable I am trying to access, Python gets confused.

The way to change the value of a global variable inside a function is by using the global keyword:

Use the global keyword before referencing it in the function, as you will get the following error: SyntaxError: name 'city' is used prior to global declaration .

Earlier, you saw that you couldn't access variables created inside functions since they have local scope.

The global keyword changes the visibility of variables declared inside functions.

And there you have it! You now know the basics of global variables in Python and can tell the differences between local and global variables.

I hope you found this article useful.

To learn more about the Python programming language, check out freeCodeCamp's Scientific Computing with Python Certification .

You'll start from the basics and learn in an interactive and beginner-friendly way. You'll also build five projects at the end to put into practice and help reinforce what you've learned.

Thanks for reading and happy coding!

Read more posts .

If this article was helpful, share it .

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

• Python Basics
• Interview Questions
• Python Quiz
• Popular Packages
• Python Projects
• Practice Python
• AI With Python
• Learn Python3
• Python Automation
• Python Web Dev
• DSA with Python
• Python OOPs
• Dictionaries

Assigning multiple variables in one line in Python

• How to input multiple values from user in one line in Python?
• Python | Assign multiple variables with list values
• Print Single and Multiple variable in Python
• How to check multiple variables against a value in Python?
• Assigning Values to Variables
• How to Take Multiple Inputs Using Loop in Python
• How to Print Multiple Arguments in Python?
• Python - Horizontal Concatenation of Multiline Strings
• Multi-Line printing in Python
• Multiline String in Python
• Different Forms of Assignment Statements in Python
• Python | Insert the string at the beginning of all items in a list
• Python | Unpack whole list into variables
• Variables under the hood in Python
• How to use Variables in Python3?
• List As Input in Python in Single Line
• Assigning values to variables in R programming - assign() Function
• Python | Variables Quiz | Question 23
• Python | Variables Quiz | Question 5
• Adding new column to existing DataFrame in Pandas
• Python map() function
• Read JSON file using Python
• How to get column names in Pandas dataframe
• Taking input in Python
• Read a file line by line in Python
• Dictionaries in Python
• Enumerate() in Python
• Iterate over a list in Python
• Different ways to create Pandas Dataframe

A variable is a segment of memory with a unique name used to hold data that will later be processed. Although each programming language has a different mechanism for declaring variables, the name and the data that will be assigned to each variable are always the same. They are capable of storing values of data types.

The assignment operator(=) assigns the value provided to its right to the variable name given to its left. Given is the basic syntax of variable declaration:

 Assign Values to Multiple Variables in One Line

Given above is the mechanism for assigning just variables in Python but it is possible to assign multiple variables at the same time. Python assigns values from right to left. When assigning multiple variables in a single line, different variable names are provided to the left of the assignment operator separated by a comma. The same goes for their respective values except they should be to the right of the assignment operator.

While declaring variables in this fashion one must be careful with the order of the names and their corresponding value first variable name to the left of the assignment operator is assigned with the first value to its right and so on. 

Variable assignment in a single line can also be done for different data types.

Not just simple variable assignment, assignment after performing some operation can also be done in the same way.

Assigning different operation results to multiple variable.

Here, we are storing different characters in a different variables.

Please Login to comment...

Similar reads.

• python-basics
• Technical Scripter 2020
• Technical Scripter

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Luca Chiodini

What the global statement really means in python.

Consider this Python program:

What does global mean? What does it do? Maybe you could be under the impression that the global statement (i.e., the line of code that starts with the keyword global ) is necessary to make the variable foo “visible” inside the function f and therefore for this program to work properly. If that is what you think or you are not sure whether this claim is correct or not, then I encourage you to continue reading to learn some of Python’s Execution Model.

The goal of this explanation is to make you understand when and why the global statement is needed. To accomplish this, we will introduce two key concepts: code blocks and bindings . Before diving in, take a moment to read the rest of this section.

Prerequisites and limitations

We refer to the latest Python version at the time of this writing (Python 3.10). This explanation tries to minimize as much as possible the number of Python’s language features used. It assumes that you are familiar with the following constructs:

• Function definition and function call
• Numbers (and the == operator to compare them)
• Lists (of numbers)
• Assignment, if and for statements
• The built-in print function

Everything else is out of scope, and particularly the following features are explicitly excluded:

• Definition of classes
• Import from modules
• with and try statements

Code blocks

A Python program is made of code blocks . In the subset of Python we are considering, only two pieces of a source code constitute a block: the body of a function and a module . For the purpose of this explanation, you only need to be aware that each Python source file contains a top-level module that includes all its source code.

Here is the content of a hypothetical file containing a Python program. Try to answer yourself: how many blocks are there?

The correct answer is three: one block for the top-level module, one for the body of the function f (which just consists of the definition of a function g ) and one for the body of the function g .

Let’s play with a different example: a file contains this source code. How many blocks are there?

If you answered two, give yourself a pat on the back. Surprisingly, the body of the for statement does not constitute a block (remember: only function bodies and modules). For the same reason, the body of the if statement also does not constitute another block. Note that this is different from what happens in many other languages, such as C/C++ and Java, where blocks are created with curly braces { ... } (also used in loops and if statements). This is not the case in Python, and more importantly, indentation does not determine blocks.

For the limited purposes of this explanation, the scope of a name is the region of code in which that name is visible. Observe that in a program, the same name can refer to more than one entity. For example, a program can contain two different variables both named x . In this case, each variable has its own scope.

In Python, a scope is made of blocks. The scope of a name includes the block where the name is introduced and any blocks contained within that block that do not introduce a different binding for that name.

When a name is used in a block, it is resolved (to figure out its value) using the nearest enclosing scope.

Let’s re-examine the program presented in the teaser but without any global statement:

The name foo is used inside the block determined by the body of the function f . Since this block does not introduce foo , it is resolved using the nearest enclosing scope rule. We “climb up” one level and reach the top-level block, in which foo is found. It gets successfully evaluated to 42, which is the value that will be printed. Look mum, no global !

To understand then why global exists, continue reading.

What binding means

Consider this fragment of code (valid both in C/C++ and Java):

In the first line, we are declaring a variable of type int named foo . Later on, we can use an assignment to set the value of foo to 42. You might be wondering why we are spending time to walk through such a simple program: the highlight, here, is that you are able to first declare a variable with a name and only later assign a value to that variable.

Python does not support declarations . This means that we have to immediately associate a value to a name whenever we introduce a name. This operation is called binding : to associate a value to a name . Binding operations introduce names.

In Python, the example presented above would simply be:

This assignment statement binds the value on its right to the name on its left in the only block present, the top-level module.

Not only the assignment binds

The assignment statement is not the only construct that binds. Among others (the full list is described in the language specification ), the following constructs also bind names:

• a function definition binds the name of the function to the function;
• when a function is called, the parameter names are bound to the arguments used to call the function;
• a for loop binds the name in its header to the values provided by the iterator.

In the previous section, we stated that an assignment binds a value to a name. What happens when there are two assignments to the same name in the same block? A re-binding operation occurs: the name on the left side of the assignment, previously already introduced, is re-bound to a new (potentially different) value. In our example, foo is initially associated with the value 42; later on, a new assignment causes re-binding and foo is then associated with the value 10.

In general, a binding operation causes re-binding of a name when that name was already introduced in the same block.

Things are no different if we move away from the boring, top-level block. In this program:

foo is bound and re-bound inside the block constituted by the body of the function f . Even after calling f from the top-level block, when we try to access foo in that block we get back an error, as expected.

Binding the same name in two blocks

We are approaching the core of this explanation. Carefully consider this Python program and try to convince yourself, using the knowledge acquired so far, that indeed the call to print inside the function f will print 10 and the one in the last line of the program will print 42.

Here is the explanation. The assignment in the first line is contained in the top-level block: when executed, it binds the value 42 to the name foo . The assignment inside the function f is instead contained in the block determined by the body of the function f . Therefore, when executed, it binds the value 10 to the name foo in that block , regardless of the presence or not of foo in some enclosing block. No re-binding occurs in this scenario because the two binding operations happen in different blocks.

A more elaborate example:

Here a variable named foo is introduced in the body of h and its scope includes the bodies of the functions h and i (two blocks). Another variable named foo is introduced in the body of the function f and its scope includes the bodies of the functions f and g but not the bodies of h and i . To find out what gets printed at a given point, we need to look at the nearest enclosing scope.

If you read until here, you might be wondering why one would ever need a global statement. Take a look again at the Python program we analyzed a little earlier:

It introduces a different foo inside f . How would you, instead, assign a different value to the foo variable whose name is bound to 42 and that was introduced in the top-level block?

There is no way to achieve that behavior with the features we have covered so far! To effectively change the value of foo introduced by the binding operation at the top-level, we need to perform an assignment. But, since Python lacks declarations, assigning some value to foo inside the body of the function f will introduce a “new” foo bound to the new value in that block .

This explains why we need the global statement, in which the keyword global is followed by a comma-separated list of names (identifiers). The global statement behaves like a binding operation : the subsequent binding operations of those names in the same block will cause re-binding of the names bound at the top-level. This means that a subsequent assignment would effectively change the value of the global variable.

Moreover, in the enclosed blocks, the uses of those names refer the names bound at the top-level. In fact, this behavior is analogous to the one of a binding operation: it does not extend to enclosed blocks that themselves introduce those names.

Let’s add just the global statement as the first line inside the body of the function f .

With this addition, the subsequent assignment that involves the name foo inside the body of the function f will cause a re-binding of the name foo that was previously bound to 42 in the top-level block. From that point onwards, the name foo will be associated with the value 10.

The next statement inside the function is going to look up the value associated with the name foo . The call to print is therefore going to print 10. After returning from f , we continue executing the next statements that belong to the top-level block. At this point, foo is clearly bound to 10, which will be printed.

We have finally solved the mystery, hurray!

There is more

The rest of this explanation is not needed to understand the example presented in the teaser, but you might still find it very helpful to improve your understanding of Python’s Execution Model.

Where a name can be used without errors

In Python, a name can be bound at any place in a block, and its scope extends to the entire block, even before the place where the binding occurs. However, that does not mean that at runtime we can freely access the name everywhere in the block without errors!

We already saw an instance of NameError in an earlier example. When a name cannot be found and we are inside a function, we get an UnboundLocalError , a subclass of NameError . Take a look at this example:

By scanning the entire source code for name binding operations, we can statically determine the set of names that are in scope in any given block. Python statically knows that the name foo is in scope for the block determined by the body of the function f , given that it is the target of an assignment statement, which is a binding operation. The problem is that at runtime, when the first line of function f is executed, the name of the local variable foo has not yet been bound to a value; hence the error.

Here is a tricky example for you to analyze: what will happen when we execute this program, and why?

You probably tried to run this example and got an UnboundLocalError . Why does that happen? Shouldn’t there be “two count variables”, one global and one local to the function inc ? The reality is more subtle, but you are already well equipped to answer these questions.

We said that the source code is scanned to find operations that bind names. Inside the function inc we have one such operation, the assignment statement, which has as a target the identifier count . There is no global statement, which means that the assignment is going to bind a “new” count that will be in scope for the current block, regardless of what might be already bound in enclosing blocks.

This local variable count is in scope for the whole block, but only gets bound to a value when the assignment statement is executed. To accomplish that, at runtime, Python has firstly to evaluate the right-hand side to figure out which value needs to be associated with count .

The right-hand side contains a use of the name count , which needs to be resolved according to the usual rules. Since there is a local count in scope for the current block, the name will refer to that binding and not to the one at the top-level. But the name has not yet been bound at the moment of the execution in which we are evaluating the right-hand side, and therefore an UnboundLocalError is raised.

nonlocal statement

We have seen that Python provides a global statement to allow, in enclosed blocks, re-binding names previously bound at the top-level (i.e., the global module). What if we want to re-bind a name that was bound in a block that is not the local one, but also not the global one? The nonlocal statement comes to the rescue with exactly this semantics.

Here is an example in which the nonlocal statement causes the assignment inside the function g to re-bind the name foo introduced in the nearest enclosing block (excluding the global one), which in this case is the block determined by the body of the function f . There, foo was bound to 42 and is now going to be re-bound to 10.

Wow, this was a blast! We have covered a significant part of Python’s Execution Model, and with this knowledge you should now be able to properly reason on the need of global (and more!).

This explanation is grounded in the official language specification , which covers in-depth some more aspects not explained here (e.g., free variables and closures).

If you find issues or have ideas on how to improve this explanation, feel free to drop me a line !

I am Luca Chiodini . This work would have not been possible without Igor Moreno Santos : the good bits of this explanation are because of him, and any remaining error is my fault. We both are PhD students working under the excellent supervision of prof. Matthias Hauswirth at the LuCE Research Lab .

Python Tutorial

File handling, python modules, python numpy, python pandas, python matplotlib, python scipy, machine learning, python mysql, python mongodb, python reference, module reference, python how to, python examples, python global variables, global variables.

Variables that are created outside of a function (as in all of the examples above) are known as global variables.

Global variables can be used by everyone, both inside of functions and outside.

Create a variable outside of a function, and use it inside the function

If you create a variable with the same name inside a function, this variable will be local, and can only be used inside the function. The global variable with the same name will remain as it was, global and with the original value.

Create a variable inside a function, with the same name as the global variable

The global Keyword

Normally, when you create a variable inside a function, that variable is local, and can only be used inside that function.

To create a global variable inside a function, you can use the global keyword.

If you use the global keyword, the variable belongs to the global scope:

Also, use the global keyword if you want to change a global variable inside a function.

To change the value of a global variable inside a function, refer to the variable by using the global keyword:

Related Pages

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

Assigning to global variables PREMIUM

Let's talk about assigning to global variables in Python.

Variable assignments are local

Let's take a global variable (a variable defined outside of any function ) called message :

Premium Screencast

This is a premium screencast available only to active Python Morsels subscribers.

Feel free to watch some of the free screencasts in the Variable Scope series .

Need to fill-in gaps in your Python skills ? I send weekly emails designed to do just that.

Remember the "two types of change" in Python? Scope is all about one of those two types of change: assignment . Python's scope rules are unrelated to mutation.

How to Write the Python if Statement in one Line

• online practice

Have you ever heard of writing a Python if statement in a single line? Here, we explore multiple ways to do exactly that, including using conditional expressions in Python.

The if statement is one of the most fundamental statements in Python. In this article, we learn how to write the Python if in one line.

The if is a key piece in writing Python code. It allows developers to control the flow and logic of their code based on information received at runtime. However, many Python developers do not know they may reduce the length and complexity of their if statements by writing them in a single line.

For this article, we assume you’re somewhat familiar with Python conditions and comparisons. If not, don’t worry! Our Python Basics Course will get you up to speed in no time. This course is included in the Python Basics Track , a full-fledged Python learning track designed for complete beginners.

We start with a recap on how Python if statements work. Then, we explore some examples of how to write if statements in a single line. Let’s get started!

How the if Statement Works in Python

Let’s start with the basics. An if statement in Python is used to determine whether a condition is True or False . This information can then be used to perform specific actions in the code, essentially controlling its logic during execution.

The structure of the basic if statement is as follows:

The <expression> is the code that evaluates to either True or False . If this code evaluates to True, then the code below (represented by <perform_action> ) executes.

Python uses whitespaces to indicate which lines are controlled by the if statement. The if statement controls all indented lines below it. Typically, the indentation is set to four spaces (read this post if you’re having trouble with the indentation ).

As a simple example, the code below prints a message if and only if the current weather is sunny:

The if statement in Python has two optional components: the elif statement, which executes only if the preceding if/elif statements are False ; and the else statement, which executes only if all of the preceding if/elif statements are False. While we may have as many elif statements as we want, we may only have a single else statement at the very end of the code block.

Here’s the basic structure:

Here’s how our previous example looks after adding elif and else statements. Change the value of the weather variable to see a different message printed:

How to Write a Python if in one Line

Writing an if statement in Python (along with the optional elif and else statements) uses a lot of whitespaces. Some people may find it confusing or tiresome to follow each statement and its corresponding indented lines.

To overcome this, there is a trick many Python developers often overlook: write an if statement in a single line !

Though not the standard, Python does allow us to write an if statement and its associated action in the same line. Here’s the basic structure:

As you can see, not much has changed. We simply need to “pull” the indented line <perform_action> up to the right of the colon character ( : ). It’s that simple!

Let’s check it with a real example. The code below works as it did previously despite the if statement being in a single line. Test it out and see for yourself:

Writing a Python if Statement With Multiple Actions in one Line

That’s all well and good, but what if my if statement has multiple actions under its control? When using the standard indentation, we separate different actions in multiple indented lines as the structure below shows:

Can we do this in a single line? The surprising answer is yes! We use semicolons to separate each action in the same line as if placed in different lines.

Here’s how the structure looks:

And an example of this functionality:

Have you noticed how each call to the print() function appears in its own line? This indicates we have successfully executed multiple actions from a single line. Nice!

By the way, interested in learning more about the print() function? We have an article on the ins and outs of the print() function .

Writing a Full Python if/elif/else Block Using Single Lines

You may have seen this coming, but we can even write elif and else statements each in a single line. To do so, we use the same syntax as writing an if statement in a single line.

Here’s the general structure:

Looks simple, right? Depending on the content of your expressions and actions, you may find this structure easier to read and understand compared to the indented blocks.

Here’s our previous example of a full if/elif/else block, rewritten as single lines:

Using Python Conditional Expressions to Write an if/else Block in one Line

There’s still a final trick to writing a Python if in one line. Conditional expressions in Python (also known as Python ternary operators) can run an if/else block in a single line.

A conditional expression is even more compact! Remember it took at least two lines to write a block containing both if and else statements in our last example.

In contrast, here’s how a conditional expression is structured:

The syntax is somewhat harder to follow at first, but the basic idea is that <expression> is a test. If the test evaluates to True , then <value_if_true> is the result. Otherwise, the expression results in <value_if_false> .

As you can see, conditional expressions always evaluate to a single value in the end. They are not complete replacements for an if/elif/else block. In fact, we cannot have elif statements in them at all. However, they’re most helpful when determining a single value depending on a single condition.

Take a look at the code below, which determines the value of is_baby depending on whether or not the age is below five:

This is the exact use case for a conditional expression! Here’s how we rewrite this if/else block in a single line:

Much simpler!

Go Even Further With Python!

We hope you now know many ways to write a Python if in one line. We’ve reached the end of the article, but don’t stop practicing now!

If you do not know where to go next, read this post on how to get beyond the basics in Python . If you’d rather get technical, we have a post on the best code editors and IDEs for Python . Remember to keep improving!

You may also like

How Do You Write a SELECT Statement in SQL?

What Is a Foreign Key in SQL?

Enumerate and Explain All the Basic Elements of an SQL Query

self.global

This webpage was generated by the domain owner using Sedo Domain Parking . Disclaimer: Sedo maintains no relationship with third party advertisers. Reference to any specific service or trade mark is not controlled by Sedo nor does it constitute or imply its association, endorsement or recommendation.

Python One Line Conditional Assignment

Problem : How to perform one-line if conditional assignments in Python?

Example : Say, you start with the following code.

You want to set the value of x to 42 if boo is True , and do nothing otherwise.

Let’s dive into the different ways to accomplish this in Python. We start with an overview:

Exercise : Run the code. Are all outputs the same?

Next, you’ll dive into each of those methods and boost your one-liner superpower !

Method 1: Ternary Operator

The most basic ternary operator x if c else y returns expression x if the Boolean expression c evaluates to True . Otherwise, if the expression c evaluates to False , the ternary operator returns the alternative expression y .

Let’s go back to our example problem! You want to set the value of x to 42 if boo is True , and do nothing otherwise. Here’s how to do this in a single line:

While using the ternary operator works, you may wonder whether it’s possible to avoid the ...else x part for clarity of the code? In the next method, you’ll learn how!

If you need to improve your understanding of the ternary operator, watch the following video:

You can also read the related article:

• Python One Line Ternary

Method 2: Single-Line If Statement

Like in the previous method, you want to set the value of x to 42 if boo is True , and do nothing otherwise. But you don’t want to have a redundant else branch. How to do this in Python?

The solution to skip the else part of the ternary operator is surprisingly simple— use a standard if statement without else branch and write it into a single line of code :

To learn more about what you can pack into a single line, watch my tutorial video “If-Then-Else in One Line Python” :

Method 3: Ternary Tuple Syntax Hack

A shorthand form of the ternary operator is the following tuple syntax .

Syntax : You can use the tuple syntax (x, y)[c] consisting of a tuple (x, y) and a condition c enclosed in a square bracket. Here’s a more intuitive way to represent this tuple syntax.

In fact, the order of the <OnFalse> and <OnTrue> operands is just flipped when compared to the basic ternary operator. First, you have the branch that’s returned if the condition does NOT hold. Second, you run the branch that’s returned if the condition holds.

Clever! The condition boo holds so the return value passed into the x variable is the <OnTrue> branch 42 .

Don’t worry if this confuses you—you’re not alone. You can clarify the tuple syntax once and for all by studying my detailed blog article.

Related Article : Python Ternary — Tuple Syntax Hack

Python One-Liners Book: Master the Single Line First!

Python programmers will improve their computer science skills with these useful one-liners.

Python One-Liners will teach you how to read and write “one-liners”: concise statements of useful functionality packed into a single line of code. You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.

The book’s five chapters cover (1) tips and tricks, (2) regular expressions, (3) machine learning, (4) core data science topics, and (5) useful algorithms.

Detailed explanations of one-liners introduce key computer science concepts and boost your coding and analytical skills . You’ll learn about advanced Python features such as list comprehension , slicing , lambda functions , regular expressions , map and reduce functions, and slice assignments .

You’ll also learn how to:

• Leverage data structures to solve real-world problems , like using Boolean indexing to find cities with above-average pollution
• Use NumPy basics such as array , shape , axis , type , broadcasting , advanced indexing , slicing , sorting , searching , aggregating , and statistics
• Calculate basic statistics of multidimensional data arrays and the K-Means algorithms for unsupervised learning
• Create more advanced regular expressions using grouping and named groups , negative lookaheads , escaped characters , whitespaces, character sets (and negative characters sets ), and greedy/nongreedy operators
• Understand a wide range of computer science topics , including anagrams , palindromes , supersets , permutations , factorials , prime numbers , Fibonacci numbers, obfuscation , searching , and algorithmic sorting

By the end of the book, you’ll know how to write Python at its most refined , and create concise, beautiful pieces of “Python art” in merely a single line.

Get your Python One-Liners on Amazon!!

While working as a researcher in distributed systems, Dr. Christian Mayer found his love for teaching computer science students.

To help students reach higher levels of Python success, he founded the programming education website Finxter.com that has taught exponential skills to millions of coders worldwide. He’s the author of the best-selling programming books Python One-Liners (NoStarch 2020), The Art of Clean Code (NoStarch 2022), and The Book of Dash (NoStarch 2022). Chris also coauthored the Coffee Break Python series of self-published books. He’s a computer science enthusiast, freelancer , and owner of one of the top 10 largest Python blogs worldwide.

His passions are writing, reading, and coding. But his greatest passion is to serve aspiring coders through Finxter and help them to boost their skills. You can join his free email academy here.