discuss about variables and assignments in python

Python Numerical Methods

This notebook contains an excerpt from the Python Programming and Numerical Methods - A Guide for Engineers and Scientists , the content is also available at Berkeley Python Numerical Methods .

The copyright of the book belongs to Elsevier. We also have this interactive book online for a better learning experience. The code is released under the MIT license . If you find this content useful, please consider supporting the work on Elsevier or Amazon !

< 2.0 Variables and Basic Data Structures | Contents | 2.2 Data Structure - Strings >

Variables and Assignment ¶

When programming, it is useful to be able to store information in variables. A variable is a string of characters and numbers associated with a piece of information. The assignment operator , denoted by the “=” symbol, is the operator that is used to assign values to variables in Python. The line x=1 takes the known value, 1, and assigns that value to the variable with name “x”. After executing this line, this number will be stored into this variable. Until the value is changed or the variable deleted, the character x behaves like the value 1.

TRY IT! Assign the value 2 to the variable y. Multiply y by 3 to show that it behaves like the value 2.

A variable is more like a container to store the data in the computer’s memory, the name of the variable tells the computer where to find this value in the memory. For now, it is sufficient to know that the notebook has its own memory space to store all the variables in the notebook. As a result of the previous example, you will see the variable “x” and “y” in the memory. You can view a list of all the variables in the notebook using the magic command %whos .

TRY IT! List all the variables in this notebook

Note that the equal sign in programming is not the same as a truth statement in mathematics. In math, the statement x = 2 declares the universal truth within the given framework, x is 2 . In programming, the statement x=2 means a known value is being associated with a variable name, store 2 in x. Although it is perfectly valid to say 1 = x in mathematics, assignments in Python always go left : meaning the value to the right of the equal sign is assigned to the variable on the left of the equal sign. Therefore, 1=x will generate an error in Python. The assignment operator is always last in the order of operations relative to mathematical, logical, and comparison operators.

TRY IT! The mathematical statement x=x+1 has no solution for any value of x . In programming, if we initialize the value of x to be 1, then the statement makes perfect sense. It means, “Add x and 1, which is 2, then assign that value to the variable x”. Note that this operation overwrites the previous value stored in x .

There are some restrictions on the names variables can take. Variables can only contain alphanumeric characters (letters and numbers) as well as underscores. However, the first character of a variable name must be a letter or underscores. Spaces within a variable name are not permitted, and the variable names are case-sensitive (e.g., x and X will be considered different variables).

TIP! Unlike in pure mathematics, variables in programming almost always represent something tangible. It may be the distance between two points in space or the number of rabbits in a population. Therefore, as your code becomes increasingly complicated, it is very important that your variables carry a name that can easily be associated with what they represent. For example, the distance between two points in space is better represented by the variable dist than x , and the number of rabbits in a population is better represented by nRabbits than y .

Note that when a variable is assigned, it has no memory of how it was assigned. That is, if the value of a variable, y , is constructed from other variables, like x , reassigning the value of x will not change the value of y .

EXAMPLE: What value will y have after the following lines of code are executed?

WARNING! You can overwrite variables or functions that have been stored in Python. For example, the command help = 2 will store the value 2 in the variable with name help . After this assignment help will behave like the value 2 instead of the function help . Therefore, you should always be careful not to give your variables the same name as built-in functions or values.

TIP! Now that you know how to assign variables, it is important that you learn to never leave unassigned commands. An unassigned command is an operation that has a result, but that result is not assigned to a variable. For example, you should never use 2+2 . You should instead assign it to some variable x=2+2 . This allows you to “hold on” to the results of previous commands and will make your interaction with Python must less confusing.

You can clear a variable from the notebook using the del function. Typing del x will clear the variable x from the workspace. If you want to remove all the variables in the notebook, you can use the magic command %reset .

In mathematics, variables are usually associated with unknown numbers; in programming, variables are associated with a value of a certain type. There are many data types that can be assigned to variables. A data type is a classification of the type of information that is being stored in a variable. The basic data types that you will utilize throughout this book are boolean, int, float, string, list, tuple, dictionary, set. A formal description of these data types is given in the following sections.

Python Variables

In Python, a variable is a container that stores a value. In other words, variable is the name given to a value, so that it becomes easy to refer a value later on.

Unlike C# or Java, it's not necessary to explicitly define a variable in Python before using it. Just assign a value to a variable using the = operator e.g. variable_name = value . That's it.

The following creates a variable with the integer value.

In the above example, we declared a variable named num and assigned an integer value 10 to it. Use the built-in print() function to display the value of a variable on the console or IDLE or REPL .

In the same way, the following declares variables with different types of values.

Multiple Variables Assignment

You can declare multiple variables and assign values to each variable in a single statement, as shown below.

In the above example, the first int value 10 will be assigned to the first variable x, the second value to the second variable y, and the third value to the third variable z. Assignment of values to variables must be in the same order in they declared.

You can also declare different types of values to variables in a single statement separated by a comma, as shown below.

Above, the variable x stores 10 , y stores a string 'Hello' , and z stores a boolean value True . The type of variables are based on the types of assigned value.

Assign a value to each individual variable separated by a comma will throw a syntax error, as shown below.

Variables in Python are objects. A variable is an object of a class based on the value it stores. Use the type() function to get the class name (type) of a variable.

In the above example, num is an object of the int class that contains integre value 10 . In the same way, amount is an object of the float class, greet is an object of the str class, isActive is an object of the bool class.

Unlike other programming languages like C# or Java, Python is a dynamically-typed language, which means you don't need to declare a type of a variable. The type will be assigned dynamically based on the assigned value.

The + operator sums up two int variables, whereas it concatenates two string type variables.

Object's Identity

Each object in Python has an id. It is the object's address in memory represented by an integer value. The id() function returns the id of the specified object where it is stored, as shown below.

Variables with the same value will have the same id.

Thus, Python optimize memory usage by not creating separate objects if they point to same value.

Naming Conventions

Any suitable identifier can be used as a name of a variable, based on the following rules:

• The name of the variable should start with either an alphabet letter (lower or upper case) or an underscore (_), but it cannot start with a digit.
• More than one alpha-numeric characters or underscores may follow.
• The variable name can consist of alphabet letter(s), number(s) and underscore(s) only. For example, myVar , MyVar , _myVar , MyVar123 are valid variable names, but m*var , my-var , 1myVar are invalid variable names.
• Variable names in Python are case sensitive. So, NAME , name , nAME , and nAmE are treated as different variable names.
• Variable names cannot be a reserved keywords in Python.
• Compare strings in Python
• Convert file data to list
• Convert User Input to a Number
• Convert String to Datetime in Python
• How to call external commands in Python?
• How to count the occurrences of a list item?
• How to flatten list in Python?
• How to merge dictionaries in Python?
• How to pass value by reference in Python?
• Remove duplicate items from list in Python
• More Python articles

We are a team of passionate developers, educators, and technology enthusiasts who, with their combined expertise and experience, create in -depth, comprehensive, and easy to understand tutorials.We focus on a blend of theoretical explanations and practical examples to encourages hands - on learning. Visit About Us page for more information.

• Python Questions & Answers
• Python Skill Test
• Python Latest Articles

Python Variables – The Complete Beginner's Guide

Variables are an essential part of Python. They allow us to easily store, manipulate, and reference data throughout our projects.

This article will give you all the understanding of Python variables you need to use them effectively in your projects.

If you want the most convenient way to review all the topics covered here, I've put together a helpful cheatsheet for you right here:

Download the Python variables cheatsheet (it takes 5 seconds).

What is a Variable in Python?

So what are variables and why do we need them?

Variables are essential for holding onto and referencing values throughout our application. By storing a value into a variable, you can reuse it as many times and in whatever way you like throughout your project.

You can think of variables as boxes with labels, where the label represents the variable name and the content of the box is the value that the variable holds.

In Python, variables are created the moment you give or assign a value to them.

How Do I Assign a Value to a Variable?

Assigning a value to a variable in Python is an easy process.

You simply use the equal sign = as an assignment operator, followed by the value you want to assign to the variable. Here's an example:

In this example, we've created two variables: country and year_founded. We've assigned the string value "United States" to the country variable and integer value 1776 to the year_founded variable.

There are two things to note in this example:

• Variables in Python are case-sensitive . In other words, watch your casing when creating variables, because Year_Founded will be a different variable than year_founded even though they include the same letters
• Variable names that use multiple words in Python should be separated with an underscore _ . For example, a variable named "site name" should be written as "site_name" . This convention is called snake case (very fitting for the "Python" language).

How Should I Name My Python Variables?

There are some rules to follow when naming Python variables.

Some of these are hard rules that must be followed, otherwise your program will not work, while others are known as conventions . This means, they are more like suggestions.

Variable naming rules

• Variable names must start with a letter or an underscore _ character.
• Variable names can only contain letters, numbers, and underscores.
• Variable names cannot contain spaces or special characters.

Variable naming conventions

• Variable names should be descriptive and not too short or too long.
• Use lowercase letters and underscores to separate words in variable names (known as "snake_case").

What Data Types Can Python Variables Hold?

One of the best features of Python is its flexibility when it comes to handling various data types.

Python variables can hold various data types, including integers, floats, strings, booleans, tuples and lists:

Integers are whole numbers, both positive and negative.

Floats are real numbers or numbers with a decimal point.

Strings are sequences of characters, namely words or sentences.

Booleans are True or False values.

Lists are ordered, mutable collections of values.

Tuples are ordered, immutable collections of values.

There are more data types in Python, but these are the most common ones you will encounter while working with Python variables.

Python is Dynamically Typed

Python is what is known as a dynamically-typed language. This means that the type of a variable can change during the execution of a program.

Another feature of dynamic typing is that it is not necessary to manually declare the type of each variable, unlike other programming languages such as Java.

You can use the type() function to determine the type of a variable. For instance:

What Operations Can Be Performed?

Variables can be used in various operations, which allows us to transform them mathematically (if they are numbers), change their string values through operations like concatenation, and compare values using equality operators.

Mathematic Operations

It's possible to perform basic mathematic operations with variables, such as addition, subtraction, multiplication, and division:

It's also possible to find the remainder of a division operation by using the modulus % operator as well as create exponents using the ** syntax:

String operators

Strings can be added to one another or concatenated using the + operator.

Equality comparisons

Values can also be compared in Python using the < , > , == , and != operators.

These operators, respectively, compare whether values are less than, greater than, equal to, or not equal to each other.

Finally, note that when performing operations with variables, you need to ensure that the types of the variables are compatible with each other.

For example, you cannot directly add a string and an integer. You would need to convert one of the variables to a compatible type using a function like str() or int() .

Variable Scope

The scope of a variable refers to the parts of a program where the variable can be accessed and modified. In Python, there are two main types of variable scope:

Global scope : Variables defined outside of any function or class have a global scope. They can be accessed and modified throughout the program, including within functions and classes.

Local scope : Variables defined within a function or class have a local scope. They can only be accessed and modified within that function or class.

In this example, attempting to access local_var outside of the function_with_local_var function results in a NameError , as the variable is not defined in the global scope.

Don't be afraid to experiment with different types of variables, operations, and scopes to truly grasp their importance and functionality. The more you work with Python variables, the more confident you'll become in applying these concepts.

Finally, if you want to fully learn all of these concepts, I've put together for you a super helpful cheatsheet that summarizes everything we've covered here.

Just click the link below to grab it for free. Enjoy!

Download the Python variables cheatsheet

Become a Professional React Developer

React is hard. You shouldn't have to figure it out yourself.

I've put everything I know about React into a single course, to help you reach your goals in record time:

Introducing: The React Bootcamp

It’s the one course I wish I had when I started learning React.

Click below to try the React Bootcamp for yourself:

Full stack developer sharing everything I know.

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 Variables and Assignment

Python variables, variable assignment rules, every value has a type, memory and the garbage collector, variable swap, variable names are superficial labels, assignment = is shallow, decomp by var.

previous episode

Python for absolute beginners, next episode, variables and assignment.

Overview Teaching: 15 min Exercises: 15 min Questions How can I store data in programs? Objectives Write scripts that assign values to variables and perform calculations with those values. Correctly trace value changes in scripts that use assignment.

Use variables to store values

Variables are one of the fundamental building blocks of Python. A variable is like a tiny container where you store values and data, such as filenames, words, numbers, collections of words and numbers, and more.

The variable name will point to a value that you “assign” it. You might think about variable assignment like putting a value “into” the variable, as if the variable is a little box 🎁

(In fact, a variable is not a container as such but more like an adress label that points to a container with a given value. This difference will become relevant once we start talking about lists and mutable data types.)

You assign variables with an equals sign ( = ). In Python, a single equals sign = is the “assignment operator.” (A double equals sign == is the “real” equals sign.)

• Variables are names for values.
• In Python the = symbol assigns the value on the right to the name on the left.
• The variable is created when a value is assigned to it.
• Here, Python assigns an age to a variable age and a name in quotation marks to a variable first_name :

Variable names

Variable names can be as long or as short as you want, but there are certain rules you must follow.

• Cannot start with a digit.
• Cannot contain spaces, quotation marks, or other punctuation.
• May contain an underscore (typically used to separate words in long variable names).
• Having an underscore at the beginning of a variable name like _alistairs_real_age has a special meaning. So we won’t do that until we understand the convention.
• The standard naming convention for variable names in Python is the so-called “snake case”, where each word is separated by an underscore. For example my_first_variable . You can read more about naming conventions in Python here .

Use meaningful variable names

Python doesn’t care what you call variables as long as they obey the rules (alphanumeric characters and the underscore). As you start to code, you will almost certainly be tempted to use extremely short variables names like f . Your fingers will get tired. Your coffee will wear off. You will see other people using variables like f . You’ll promise yourself that you’ll definitely remember what f means. But you probably won’t.

So, resist the temptation of bad variable names! Clear and precisely-named variables will:

• Make your code more readable (both to yourself and others).
• Reinforce your understanding of Python and what’s happening in the code.
• Clarify and strengthen your thinking.

Use meaningful variable names to help other people understand what the program does. The most important “other person” is your future self!

Python is case-sensitive

Python thinks that upper- and lower-case letters are different, so Name and name are different variables. There are conventions for using upper-case letters at the start of variable names so we will use lower-case letters for now.

Off-Limits Names

The only variable names that are off-limits are names that are reserved by, or built into, the Python programming language itself — such as print , True , and list . Some of these you can overwrite into variable names (not ideal!), but Jupyter Lab (and many other environments and editors) will catch this by colour coding your variable. If your would-be variable is colour-coded green, rethink your name choice. This is not something to worry too much about. You can get the object back by resetting your kernel.

Use print() to display values

We can check to see what’s “inside” variables by running a cell with the variable’s name. This is one of the handiest features of a Jupyter notebook. Outside the Jupyter environment, you would need to use the print() function to display the variable.

You can run the print() function inside the Jupyter environment, too. This is sometimes useful because Jupyter will only display the last variable in a cell, while print() can display multiple variables. Additionally, Jupyter will display text with \n characters (which means “new line”), while print() will display the text appropriately formatted with new lines.

• Python has a built-in function called print() that prints things as text.
• Provide values to the function (i.e., the things to print) in parentheses.
• To add a string to the printout, wrap the string in single or double quotations.
• The values passed to the function are called ‘arguments’ and are separated by commas.
• When using the print() function, we can also separate with a ‘+’ sign. However, when using ‘+’ we have to add spaces in between manually.
• print() automatically puts a single space between items to separate them.
• And wraps around to a new line at the end.

Variables must be created before they are used

If a variable doesn’t exist yet, or if the name has been misspelled, Python reports an error (unlike some languages, which “guess” a default value).

The last line of an error message is usually the most informative. This message lets us know that there is no variable called eye_color in the script.

Variables Persist Between Cells Variables defined in one cell exist in all other cells once executed, so the relative location of cells in the notebook do not matter (i.e., cells lower down can still affect those above). Notice the number in the square brackets [ ] to the left of the cell. These numbers indicate the order, in which the cells have been executed. Cells with lower numbers will affect cells with higher numbers as Python runs the cells chronologically. As a best practice, we recommend you keep your notebook in chronological order so that it is easier for the human eye to read and make sense of, as well as to avoid any errors if you close and reopen your project, and then rerun what you have done. Remember: Notebook cells are just a way to organize a program! As far as Python is concerned, all of the source code is one long set of instructions.

Variables can be used in calculations

• We can use variables in calculations just as if they were values. Remember, we assigned 42 to age a few lines ago.

This code works in the following way. We are reassigning the value of the variable age by taking its previous value (42) and adding 3, thus getting our new value of 45.

Use an index to get a single character from a string

• The characters (individual letters, numbers, and so on) in a string are ordered. For example, the string ‘AB’ is not the same as ‘BA’. Because of this ordering, we can treat the string as a list of characters.
• Each position in the string (first, second, etc.) is given a number. This number is called an index or sometimes a subscript.
• Indices are numbered from 0 rather than 1.
• Use the position’s index in square brackets to get the character at that position.

Use a slice to get a substring

A part of a string is called a substring. A substring can be as short as a single character. A slice is a part of a string (or, more generally, any list-like thing). We take a slice by using [start:stop] , where start is replaced with the index of the first element we want and stop is replaced with the index of the element just after the last element we want. Mathematically, you might say that a slice selects [start:stop] . The difference between stop and start is the slice’s length. Taking a slice does not change the contents of the original string. Instead, the slice is a copy of part of the original string.

Use the built-in function len() to find the length of a string

The built-in function len() is used to find the length of a string (and later, of other data types, too).

Note that the result is 6 and not 7. This is because it is the length of the value of the variable (i.e. 'helium' ) that is being counted and not the name of the variable (i.e. element )

Also note that nested functions are evaluated from the inside out, just like in mathematics. Thus, Python first reads the len() function, then the print() function.

Choosing a Name Which is a better variable name, m , min , or minutes ? Why? Hint: think about which code you would rather inherit from someone who is leaving the library: ts = m * 60 + s tot_sec = min * 60 + sec total_seconds = minutes * 60 + seconds Solution minutes is better because min might mean something like “minimum” (and actually does in Python, but we haven’t seen that yet).

Swapping Values Draw a table showing the values of the variables in this program after each statement is executed. In simple terms, what do the last three lines of this program do? x = 1.0 y = 3.0 swap = x x = y y = swap Solution swap = x # x->1.0 y->3.0 swap->1.0 x = y # x->3.0 y->3.0 swap->1.0 y = swap # x->3.0 y->1.0 swap->1.0 These three lines exchange the values in x and y using the swap variable for temporary storage. This is a fairly common programming idiom.

Predicting Values What is the final value of position in the program below? (Try to predict the value without running the program, then check your prediction.) initial = "left" position = initial initial = "right" Solution initial = "left" # Initial is assigned the string "left" position = initial # Position is assigned the variable initial, currently "left" initial = "right" # Initial is assigned the string "right" print(position) left The last assignment to position was “left”

Can you slice integers? If you assign a = 123 , what happens if you try to get the second digit of a ? Solution Numbers are not stored in the written representation, so they can’t be treated like strings. a = 123 print(a[1]) TypeError: 'int' object is not subscriptable

Slicing What does the following program print? library_name = 'social sciences' print('library_name[1:3] is:', library_name[1:3]) What does thing[low:high] do? What does thing[low:] (without a value after the colon) do? What does thing[:high] (without a value before the colon) do? What does thing[:] (just a colon) do? What does thing[number:negative-number] do? Solution library_name[1:3] is: oc It will slice the string, starting at the low index and ending an element before the high index It will slice the string, starting at the low index and stopping at the end of the string It will slice the string, starting at the beginning on the string, and ending an element before the high index It will print the entire string It will slice the string, starting the number index, and ending a distance of the absolute value of negative-number elements from the end of the string

Key Points Use variables to store values. Use meaningful variable names. Python is case-sensitive. Use print() to display values. Variables must be created before they are used. Variables persist between cells. Variables can be used in calculations. Use an index to get a single character from a string. Use a slice to get a substring. Use the built-in function len to find the length of a string.

• Hands-on Python Tutorial »
• 1. Beginning With Python »

1.6. Variables and Assignment ¶

Each set-off line in this section should be tried in the Shell.

Nothing is displayed by the interpreter after this entry, so it is not clear anything happened. Something has happened. This is an assignment statement , with a variable , width , on the left. A variable is a name for a value. An assignment statement associates a variable name on the left of the equal sign with the value of an expression calculated from the right of the equal sign. Enter

Once a variable is assigned a value, the variable can be used in place of that value. The response to the expression width is the same as if its value had been entered.

The interpreter does not print a value after an assignment statement because the value of the expression on the right is not lost. It can be recovered if you like, by entering the variable name and we did above.

Try each of the following lines:

The equal sign is an unfortunate choice of symbol for assignment, since Python’s usage is not the mathematical usage of the equal sign. If the symbol ↤ had appeared on keyboards in the early 1990’s, it would probably have been used for assignment instead of =, emphasizing the asymmetry of assignment. In mathematics an equation is an assertion that both sides of the equal sign are already, in fact, equal . A Python assignment statement forces the variable on the left hand side to become associated with the value of the expression on the right side. The difference from the mathematical usage can be illustrated. Try:

so this is not equivalent in Python to width = 10 . The left hand side must be a variable, to which the assignment is made. Reversed, we get a syntax error . Try

This is, of course, nonsensical as mathematics, but it makes perfectly good sense as an assignment, with the right-hand side calculated first. Can you figure out the value that is now associated with width? Check by entering

In the assignment statement, the expression on the right is evaluated first . At that point width was associated with its original value 10, so width + 5 had the value of 10 + 5 which is 15. That value was then assigned to the variable on the left ( width again) to give it a new value. We will modify the value of variables in a similar way routinely.

Assignment and variables work equally well with strings. Try:

Try entering:

Note the different form of the error message. The earlier errors in these tutorials were syntax errors: errors in translation of the instruction. In this last case the syntax was legal, so the interpreter went on to execute the instruction. Only then did it find the error described. There are no quotes around fred , so the interpreter assumed fred was an identifier, but the name fred was not defined at the time the line was executed.

It is both easy to forget quotes where you need them for a literal string and to mistakenly put them around a variable name that should not have them!

Try in the Shell :

There fred , without the quotes, makes sense.

There are more subtleties to assignment and the idea of a variable being a “name for” a value, but we will worry about them later, in Issues with Mutable Objects . They do not come up if our variables are just numbers and strings.

Autocompletion: A handy short cut. Idle remembers all the variables you have defined at any moment. This is handy when editing. Without pressing Enter, type into the Shell just

Assuming you are following on the earlier variable entries to the Shell, you should see f autocompleted to be

This is particularly useful if you have long identifiers! You can press Alt-/ several times if more than one identifier starts with the initial sequence of characters you typed. If you press Alt-/ again you should see fred . Backspace and edit so you have fi , and then and press Alt-/ again. You should not see fred this time, since it does not start with fi .

1.6.1. Literals and Identifiers ¶

Expressions like 27 or 'hello' are called literals , coming from the fact that they literally mean exactly what they say. They are distinguished from variables, whose value is not directly determined by their name.

The sequence of characters used to form a variable name (and names for other Python entities later) is called an identifier . It identifies a Python variable or other entity.

There are some restrictions on the character sequence that make up an identifier:

The characters must all be letters, digits, or underscores _ , and must start with a letter. In particular, punctuation and blanks are not allowed.

There are some words that are reserved for special use in Python. You may not use these words as your own identifiers. They are easy to recognize in Idle, because they are automatically colored orange. For the curious, you may read the full list:

There are also identifiers that are automatically defined in Python, and that you could redefine, but you probably should not unless you really know what you are doing! When you start the editor, we will see how Idle uses color to help you know what identifies are predefined.

Python is case sensitive: The identifiers last , LAST , and LaSt are all different. Be sure to be consistent. Using the Alt-/ auto-completion shortcut in Idle helps ensure you are consistent.

What is legal is distinct from what is conventional or good practice or recommended. Meaningful names for variables are important for the humans who are looking at programs, understanding them, and revising them. That sometimes means you would like to use a name that is more than one word long, like price at opening , but blanks are illegal! One poor option is just leaving out the blanks, like priceatopening . Then it may be hard to figure out where words split. Two practical options are

• underscore separated: putting underscores (which are legal) in place of the blanks, like price_at_opening .
• using camel-case : omitting spaces and using all lowercase, except capitalizing all words after the first, like priceAtOpening

Use the choice that fits your taste (or the taste or convention of the people you are working with).

Table Of Contents

• 1.6.1. Literals and Identifiers

Previous topic

1.5. Strings, Part I

1.7. Print Function, Part I

• Show Source

Quick search

Enter search terms or a module, class or function name.

Learning Python by doing

• suggest edit

Variables, Expressions, and Assignments

Variables, expressions, and assignments 1 #, introduction #.

In this chapter, we introduce some of the main building blocks needed to create programs–that is, variables, expressions, and assignments. Programming related variables can be intepret in the same way that we interpret mathematical variables, as elements that store values that can later be changed. Usually, variables and values are used within the so-called expressions. Once again, just as in mathematics, an expression is a construct of values and variables connected with operators that result in a new value. Lastly, an assignment is a language construct know as an statement that assign a value (either as a constant or expression) to a variable. The rest of this notebook will dive into the main concepts that we need to fully understand these three language constructs.

Values and Types #

A value is the basic unit used in a program. It may be, for instance, a number respresenting temperature. It may be a string representing a word. Some values are 42, 42.0, and ‘Hello, Data Scientists!’.

Each value has its own type : 42 is an integer ( int in Python), 42.0 is a floating-point number ( float in Python), and ‘Hello, Data Scientists!’ is a string ( str in Python).

The Python interpreter can tell you the type of a value: the function type takes a value as argument and returns its corresponding type.

Observe the difference between type(42) and type('42') !

Expressions and Statements #

On the one hand, an expression is a combination of values, variables, and operators.

A value all by itself is considered an expression, and so is a variable.

When you type an expression at the prompt, the interpreter evaluates it, which means that it calculates the value of the expression and displays it.

In boxes above, m has the value 27 and m + 25 has the value 52 . m + 25 is said to be an expression.

On the other hand, a statement is an instruction that has an effect, like creating a variable or displaying a value.

The first statement initializes the variable n with the value 17 , this is a so-called assignment statement .

The second statement is a print statement that prints the value of the variable n .

The effect is not always visible. Assigning a value to a variable is not visible, but printing the value of a variable is.

Assignment Statements #

We have already seen that Python allows you to evaluate expressions, for instance 40 + 2 . It is very convenient if we are able to store the calculated value in some variable for future use. The latter can be done via an assignment statement. An assignment statement creates a new variable with a given name and assigns it a value.

The example in the previous code contains three assignments. The first one assigns the value of the expression 40 + 2 to a new variable called magicnumber ; the second one assigns the value of π to the variable pi , and; the last assignment assigns the string value 'Data is eatig the world' to the variable message .

Programmers generally choose names for their variables that are meaningful. In this way, they document what the variable is used for.

Do It Yourself!

Let’s compute the volume of a cube with side \(s = 5\) . Remember that the volume of a cube is defined as \(v = s^3\) . Assign the value to a variable called volume .

Well done! Now, why don’t you print the result in a message? It can say something like “The volume of the cube with side 5 is \(volume\) ”.

Beware that there is no checking of types ( type checking ) in Python, so a variable to which you have assigned an integer may be re-used as a float, even if we provide type-hints .

Names and Keywords #

Names of variable and other language constructs such as functions (we will cover this topic later), should be meaningful and reflect the purpose of the construct.

In general, Python names should adhere to the following rules:

It should start with a letter or underscore.

It cannot start with a number.

It must only contain alpha-numeric (i.e., letters a-z A-Z and digits 0-9) characters and underscores.

They cannot share the name of a Python keyword.

If you use illegal variable names you will get a syntax error.

By choosing the right variables names you make the code self-documenting, what is better the variable v or velocity ?

The following are examples of invalid variable names.

These basic development principles are sometimes called architectural rules . By defining and agreeing upon architectural rules you make it easier for you and your fellow developers to understand and modify your code.

If you want to read more on this, please have a look at Code complete a book by Steven McConnell [ McC04 ] .

Every programming language has a collection of reserved keywords . They are used in predefined language constructs, such as loops and conditionals . These language concepts and their usage will be explained later.

The interpreter uses keywords to recognize these language constructs in a program. Python 3 has the following keywords:

False class finally is return

None continue for lambda try

True def from nonlocal while

and del global not with

as elif if or yield

assert else import pass break

except in raise

Reassignments #

It is allowed to assign a new value to an existing variable. This process is called reassignment . As soon as you assign a value to a variable, the old value is lost.

The assignment of a variable to another variable, for instance b = a does not imply that if a is reassigned then b changes as well.

You have a variable salary that shows the weekly salary of an employee. However, you want to compute the monthly salary. Can you reassign the value to the salary variable according to the instruction?

Updating Variables #

A frequently used reassignment is for updating puposes: the value of a variable depends on the previous value of the variable.

This statement expresses “get the current value of x , add one, and then update x with the new value.”

Beware, that the variable should be initialized first, usually with a simple assignment.

Do you remember the salary excercise of the previous section (cf. 13. Reassignments)? Well, if you have not done it yet, update the salary variable by using its previous value.

Updating a variable by adding 1 is called an increment ; subtracting 1 is called a decrement . A shorthand way of doing is using += and -= , which stands for x = x + ... and x = x - ... respectively.

Order of Operations #

Expressions may contain multiple operators. The order of evaluation depends on the priorities of the operators also known as rules of precedence .

For mathematical operators, Python follows mathematical convention. The acronym PEMDAS is a useful way to remember the rules:

Parentheses have the highest precedence and can be used to force an expression to evaluate in the order you want. Since expressions in parentheses are evaluated first, 2 * (3 - 1) is 4 , and (1 + 1)**(5 - 2) is 8 . You can also use parentheses to make an expression easier to read, even if it does not change the result.

Exponentiation has the next highest precedence, so 1 + 2**3 is 9 , not 27 , and 2 * 3**2 is 18 , not 36 .

Multiplication and division have higher precedence than addition and subtraction . So 2 * 3 - 1 is 5 , not 4 , and 6 + 4 / 2 is 8 , not 5 .

Operators with the same precedence are evaluated from left to right (except exponentiation). So in the expression degrees / 2 * pi , the division happens first and the result is multiplied by pi . To divide by 2π, you can use parentheses or write: degrees / 2 / pi .

In case of doubt, use parentheses!

Let’s see what happens when we evaluate the following expressions. Just run the cell to check the resulting value.

Floor Division and Modulus Operators #

The floor division operator // divides two numbers and rounds down to an integer.

For example, suppose that driving to the south of France takes 555 minutes. You might want to know how long that is in hours.

Conventional division returns a floating-point number.

Hours are normally not represented with decimal points. Floor division returns the integer number of hours, dropping the fraction part.

You spend around 225 minutes every week on programming activities. You want to know around how many hours you invest to this activity during a month. Use the \(//\) operator to give the answer.

The modulus operator % works on integer values. It computes the remainder when dividing the first integer by the second one.

The modulus operator is more useful than it seems.

For example, you can check whether one number is divisible by another—if x % y is zero, then x is divisible by y .

String Operations #

In general, you cannot perform mathematical operations on strings, even if the strings look like numbers, so the following operations are illegal: '2'-'1' 'eggs'/'easy' 'third'*'a charm'

But there are two exceptions, + and * .

The + operator performs string concatenation, which means it joins the strings by linking them end-to-end.

The * operator also works on strings; it performs repetition.

Speedy Gonzales is a cartoon known to be the fastest mouse in all Mexico . He is also famous for saying “Arriba Arriba Andale Arriba Arriba Yepa”. Can you use the following variables, namely arriba , andale and yepa to print the mentioned expression? Don’t forget to use the string operators.

Asking the User for Input #

The programs we have written so far accept no input from the user.

To get data from the user through the Python prompt, we can use the built-in function input .

When input is called your whole program stops and waits for the user to enter the required data. Once the user types the value and presses Return or Enter , the function returns the input value as a string and the program continues with its execution.

Try it out!

You can also print a message to clarify the purpose of the required input as follows.

The resulting string can later be translated to a different type, like an integer or a float. To do so, you use the functions int and float , respectively. But be careful, the user might introduce a value that cannot be converted to the type you required.

We want to know the name of a user so we can display a welcome message in our program. The message should say something like “Hello \(name\) , welcome to our hello world program!”.

Script Mode #

So far we have run Python in interactive mode in these Jupyter notebooks, which means that you interact directly with the interpreter in the code cells . The interactive mode is a good way to get started, but if you are working with more than a few lines of code, it can be clumsy. The alternative is to save code in a file called a script and then run the interpreter in script mode to execute the script. By convention, Python scripts have names that end with .py .

Use the PyCharm icon in Anaconda Navigator to create and execute stand-alone Python scripts. Later in the course, you will have to work with Python projects for the assignments, in order to get acquainted with another way of interacing with Python code.

This Jupyter Notebook is based on Chapter 2 of the books Python for Everybody [ Sev16 ] and Think Python (Sections 5.1, 7.1, 7.2, and 5.12) [ Dow15 ] .

Python tutorials

Variables and assignments, 6. variables and assignments #.

Author: Tue Nguyen

6.1. Outline #

Assignments, variables, objects, and values

Equality comparison

Object identities

Python interning

Formatted printing

6.2. Variables, assignments, objects, and values #

From last tutorial, we know a variable is created through an assignment

Ex: x = 1000

x : variable name

1000 : value

Warning: many people think that x contains value 1000 . It’s NOT true

Under the hood

First, Python evaluates the right hand side (RHS) of the assignment and comes up with value 1000

Python then creates an object in the memory to hold that value

Finally, Python links the object to a variable named x on the left hand side (LHS)

You should think as follows

Object = a box

Value = what’s inside the box

Variable = a label pasted on the box

We use the label the retrieve the thing inside the box

Why use variables?

It is extremely complicated for us, as human beings, to deal with objects directly

Variables help

Abstract away all unnecessary technical complications

Allow us to focus on solving our main problem at a higher level

6.3. Equality comparision #

In Python, = is used for assignment, not comparision

To check if two things are equal (in terms of value), we use ==

If they are indeed equal, True will be returned

Otherwise, False will be returned

6.4. Object identity #

In Python, everything is an object

Each object has an unique ID (like a person has an ID)

We use id(x) to get the ID of the object that variable x is pointing to

We might say “ID of x ” but the correct sentence should be “ID of the object associated with x ”

Some notes on saying

Suppose id(x) gives us 2350614735152 , then we say

“ x is pointing to the object with ID 2350614735152 ”

“ x is referring to the object with ID 2350614735152 ”

In the statement x = 1000 , we say

“ x is assigned value 1000 ”

“ 1000 is assigned to x ”

NOT: “ x is assigned to 1000 ”

On the first assignment on x we use the word initialize (or init for short)

On the next assignment on x we use the word assign

a) Ex 1: get ID

b) Ex 2: two assignments are handled separately

Why different IDs?

First assignment

Python evaluates RHS, comes up with value 1000 , and creates an object to hold that value

Then Python links that object to variable x

Second assignment

Python evaluates RHS, also comes up with value 1000 , but it creates another different object to hold that value

Then Python links that object to variable y

Thus, different objects have different IDs

Think of it this way: there are two boxes (objects) containing the same thing (values) and having two different labels (variables)

c) Ex 3: compare identities

d) Ex 4: garbage collector

What just happened?

When we run x = 2000 , Python evaluates RHS, comes up with value 2000 , and creates an object with ID shown above to hold the value

Python detect y is already linked to a different object, so it delete the current link, and re-link y to the new object

That’s why when we print x or id(x) we get new values

What happened to the old object?

When Python detect an object with no variables referring to it, Python will summon the garbage collector to destroy that object and release memory to the system for future assignments

How can we verify it? We can’t because we only have access to an object through its associated with it

e) Ex 5: assignment to avariable An assignment to a variable will not create a new object

What happened?

When the RHS of an assignment is just a variable name, no new object is created

You can think of it as we have two labels pasted on the same box

Either we use x or z , we get the same thing back

f) Ex 6: assignment to an expression involving a variable

If the RHS is an expression involving a variable, then a new object is created as usual

g) Ex 7: garbage collector only destroys objects with no reference

6.5. Python interning #

We already saw that the theory works for some large numbers such as 1000 and 2000

But for the theory is NOT true for every case

Consider the following example

This weird behavior (called Python interning) is due to some optimization decision of the Python core team (which I will not discuss here)

Basically, maintaining only one single copy helps save memory and make comparisons a lot faster

And the core team accepted this language inconsistency in exchange for performance

You can see Python interning behavior for small integers (normally from -5 to 128 , but it depends on specific implementations) and for short strings

Key take away: never compare identities for small integers and short strings

a) Ex 1: test with integers

b) Ex 2: test with strings

The theory is true in general , but be aware of Python interning behavior in some special cases

Never compare identities of small integers and short strings

In practice, you rarely compare identities, so it won’t matter much

6.6. Formatted printing #

Now, you already gained some more understanding of how Python works. It’s time to introduce some more useful tips for printing.

6.6.1. Normal printing #

6.6.2. formatted printing #.

A formatted string is a string having some placeholders that will be filled by the values of some variables

a) Ex 1: use .format()

Here, the string s has two placeholders in it (denoted by {} )

Each placeholder will be filled with the values of name and place respectively

b) Ex 2: use string interpolation

Avaiable for Python >= 3.6 only

You place an f (meaning “formatted”) before the beginning quote and put the variable names inside the corresponding placeholders

This behavior is called string interpolation

6.7. Summary #

Syntax: variable_name = value

How an assignment works

Python always evaluates the RHS first

Comes up with a value

Creates an object to hold the value

And finally links the object to a variable name on the LHS

Variables are just symbolic names; they don’t contain values

Only objects contain values

We, as human beings, don’t manipulate object directly but through variables

The box model

Variable = label pasted on the box

At a given point in time

A box can have multiple label pasted on it

But a label can be pasted on one box only (because if not, when we use the variable, Python cannot decide know which box to open)

Object identity

Everything that contains value or data is an object

In Python, almost everything is an object

An object have a unique ID

Use id(x) to get ID of the object associated with x

Equality comparision

Use = for assignments

Use == to compare values

Use is to comapre identities

Various types of assignment

x = 1000 and y = 1000 will creates two different objects although x and y have the same value

z = x will not create a new object: x and z now are referring to the same object

When re-use a variable x in a new assignment, Python will delete the binding between x and the old object and establish a new binding between x and the new object

Garbage collector

When Python notices a box without any label, it will immediately summon the garbage collector to destroy that box and return the memory to the system

Only objects without references will be destroyed

When assigning the same small integer or short string to two different variables x and y , then it might be that only one object is created and both x and y are pointing to that object

This is called Python interning behavior

Python interning happens in assignment with

Small integers (normally from -5 to 128 )

Short strings

When a print statement involve a formatted string, it is called formatted printing

A formatted string has some placeholders in it that will be filled with values of some variables

Two syntaxes

Use .format() : s = "I am {} from {}".format(name, place)

Use string interpolation: s = f"This is {name}. He is {age} years old"

Other notes

The theory on assignment is true in general

Just be aware of Python interning behavior

Never compare identity of small integers and short strings

6.8. Practice #

To be updated

• Module 2: The Essentials of Python »
• Variables & Assignment
• View page source

Variables & Assignment 

There are reading-comprehension exercises included throughout the text. These are meant to help you put your reading to practice. Solutions for the exercises are included at the bottom of this page.

Variables permit us to write code that is flexible and amendable to repurpose. Suppose we want to write code that logs a student’s grade on an exam. The logic behind this process should not depend on whether we are logging Brian’s score of 92% versus Ashley’s score of 94%. As such, we can utilize variables, say name and grade , to serve as placeholders for this information. In this subsection, we will demonstrate how to define variables in Python.

In Python, the = symbol represents the “assignment” operator. The variable goes to the left of = , and the object that is being assigned to the variable goes to the right:

Attempting to reverse the assignment order (e.g. 92 = name ) will result in a syntax error. When a variable is assigned an object (like a number or a string), it is common to say that the variable is a reference to that object. For example, the variable name references the string "Brian" . This means that, once a variable is assigned an object, it can be used elsewhere in your code as a reference to (or placeholder for) that object:

Valid Names for Variables 

A variable name may consist of alphanumeric characters ( a-z , A-Z , 0-9 ) and the underscore symbol ( _ ); a valid name cannot begin with a numerical value.

var : valid

_var2 : valid

ApplePie_Yum_Yum : valid

2cool : invalid (begins with a numerical character)

I.am.the.best : invalid (contains . )

They also cannot conflict with character sequences that are reserved by the Python language. As such, the following cannot be used as variable names:

for , while , break , pass , continue

in , is , not

if , else , elif

def , class , return , yield , raises

import , from , as , with

try , except , finally

There are other unicode characters that are permitted as valid characters in a Python variable name, but it is not worthwhile to delve into those details here.

Mutable and Immutable Objects 

The mutability of an object refers to its ability to have its state changed. A mutable object can have its state changed, whereas an immutable object cannot. For instance, a list is an example of a mutable object. Once formed, we are able to update the contents of a list - replacing, adding to, and removing its elements.

To spell out what is transpiring here, we:

Create (initialize) a list with the state [1, 2, 3] .

Assign this list to the variable x ; x is now a reference to that list.

Using our referencing variable, x , update element-0 of the list to store the integer -4 .

This does not create a new list object, rather it mutates our original list. This is why printing x in the console displays [-4, 2, 3] and not [1, 2, 3] .

A tuple is an example of an immutable object. Once formed, there is no mechanism by which one can change of the state of a tuple; and any code that appears to be updating a tuple is in fact creating an entirely new tuple.

Mutable & Immutable Types of Objects 

The following are some common immutable and mutable objects in Python. These will be important to have in mind as we start to work with dictionaries and sets.

Some immutable objects

numbers (integers, floating-point numbers, complex numbers)

“frozen”-sets

Some mutable objects

dictionaries

NumPy arrays

Referencing a Mutable Object with Multiple Variables 

It is possible to assign variables to other, existing variables. Doing so will cause the variables to reference the same object:

What this entails is that these common variables will reference the same instance of the list. Meaning that if the list changes, all of the variables referencing that list will reflect this change:

We can see that list2 is still assigned to reference the same, updated list as list1 :

In general, assigning a variable b to a variable a will cause the variables to reference the same object in the system’s memory, and assigning c to a or b will simply have a third variable reference this same object. Then any change (a.k.a mutation ) of the object will be reflected in all of the variables that reference it ( a , b , and c ).

Of course, assigning two variables to identical but distinct lists means that a change to one list will not affect the other:

Reading Comprehension: Does slicing a list produce a reference to that list?

Suppose x is assigned a list, and that y is assigned a “slice” of x . Do x and y reference the same list? That is, if you update part of the subsequence common to x and y , does that change show up in both of them? Write some simple code to investigate this.

Reading Comprehension: Understanding References

Based on our discussion of mutable and immutable objects, predict what the value of y will be in the following circumstance:

Reading Comprehension Exercise Solutions: 

Does slicing a list produce a reference to that list?: Solution

Based on the following behavior, we can conclude that slicing a list does not produce a reference to the original list. Rather, slicing a list produces a copy of the appropriate subsequence of the list:

Understanding References: Solutions

Integers are immutable, thus x must reference an entirely new object ( 9 ), and y still references 3 .

1.3 Variables

Learning objectives.

By the end of this section you should be able to

• Assign variables and print variables.
• Explain rules for naming variables.

Assignment statement

Variables allow programs to refer to values using names rather than memory locations. Ex: age refers to a person's age, and birth refers to a person's date of birth.

A statement can set a variable to a value using the assignment operator ( = ). Note that this is different from the equal sign of mathematics. Ex: age = 6 or birth = "May 15" . The left side of the assignment statement is a variable, and the right side is the value the variable is assigned.

Assigning and using variables

Concepts in practice.

• print( "In which city do you live?" )
• city = "London"
• print( "The city where you live is" , city)
• print( "Total =" , total) total = 6
• total = 6 print( "Total =" , total)
• print( "Total =" , total) total = input ()
• temperature = 98.5
• 98.5 = temperature
• temperature - 23.2

Variable naming rules

A variable name can consist of letters, digits, and underscores and be of any length. The name cannot start with a digit. Ex: 101class is invalid. Also, letter case matters. Ex: Total is different from total . Python's style guide recommends writing variable names in snake case , which is all lowercase with underscores in between each word, such as first_name or total_price .

A name should be short and descriptive, so words are preferred over single characters in programs for readability. Ex: A variable named count indicates the variable's purpose better than a variable named c .

Python has reserved words, known as keywords , which have special functions and cannot be used as names for variables (or other objects).

Valid variable names

• contains an underscore
• starts with a digit
• is a keyword

Final score

Write a Python computer program that:

• Creates a variable, team1 , assigned with the value "Liverpool" .
• Creates a variable, team2 , assigned with the value "Chelsea" .
• Creates a variable score1 , assigned with the value 4 .
• Creates a variable, score2 , assigned with the value 3 .
• Prints team1 , "versus" , and team2 as a single line of output.
• Prints "Final score: " , score1 , "to" , score2 as a single line of output.

This book may not be used in the training of large language models or otherwise be ingested into large language models or generative AI offerings without OpenStax's permission.

Want to cite, share, or modify this book? This book uses the Creative Commons Attribution License and you must attribute OpenStax.

Access for free at https://openstax.org/books/introduction-python-programming/pages/1-introduction

• Authors: Udayan Das, Aubrey Lawson, Chris Mayfield, Narges Norouzi
• Publisher/website: OpenStax
• Book title: Introduction to Python Programming
• Publication date: Mar 13, 2024
• Location: Houston, Texas
• Book URL: https://openstax.org/books/introduction-python-programming/pages/1-introduction
• Section URL: https://openstax.org/books/introduction-python-programming/pages/1-3-variables

© Mar 15, 2024 OpenStax. Textbook content produced by OpenStax is licensed under a Creative Commons Attribution License . The OpenStax name, OpenStax logo, OpenStax book covers, OpenStax CNX name, and OpenStax CNX logo are not subject to the Creative Commons license and may not be reproduced without the prior and express written consent of Rice University.

Learn Python practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn python interactively, python introduction.

• Get Started With Python
• Your First Python Program

Python Comments

Python Fundamentals

Python variables and literals.

• Python Type Conversion
• Python Basic Input and Output
• Python Operators

Python Flow Control

• Python if...else Statement
• Python for Loop
• Python while Loop
• Python break and continue
• Python pass Statement

Python Data types

Python Numbers, Type Conversion and Mathematics

• Python List
• Python Tuple
• Python Sets
• Python Dictionary
• Python Functions
• Python Function Arguments
• Python Variable Scope
• Python Global Keyword
• Python Recursion
• Python Modules
• Python Package
• Python Main function

Python Files

• Python Directory and Files Management
• Python CSV: Read and Write CSV files
• Reading CSV files in Python
• Writing CSV files in Python
• Python Exception Handling
• Python Exceptions
• Python Custom Exceptions

Python Object & Class

• Python Objects and Classes
• Python Inheritance
• Python Multiple Inheritance
• Polymorphism in Python
• Python Operator Overloading

Python Advanced Topics

• List comprehension
• Python Lambda/Anonymous Function
• Python Iterators
• Python Generators
• Python Namespace and Scope
• Python Closures
• Python Decorators
• Python @property decorator
• Python RegEx

Python Date and Time

• Python datetime
• Python strftime()
• Python strptime()
• How to get current date and time in Python?
• Python Get Current Time
• Python timestamp to datetime and vice-versa
• Python time Module
• Python sleep()

Additional Topic

• Precedence and Associativity of Operators in Python

Python Keywords and Identifiers

• Python Asserts
• Python Json
• Python *args and **kwargs

Python Tutorials

Python Data Types

In the previous tutorial you learned about Python comments . Now, let's learn about variables and literals in Python.

• Python Variables

In programming, a variable is a container (storage area) to hold data. For example,

Here, number is a variable storing the value 10 .

• Assigning values to Variables in Python

As we can see from the above example, we use the assignment operator = to assign a value to a variable.

In the above example, we assigned the value programiz.pro to the site_name variable. Then, we printed out the value assigned to site_name

Note : Python is a type-inferred language, so you don't have to explicitly define the variable type. It automatically knows that programiz.pro is a string and declares the site_name variable as a string.

• Changing the Value of a Variable in Python

Here, the value of site_name is changed from 'programiz.pro' to 'apple.com' .

Example: Assigning multiple values to multiple variables

If we want to assign the same value to multiple variables at once, we can do this as:

Here, we have assigned the same string value 'programiz.com' to both the variables site1 and site2 .

1. Constant and variable names should have a combination of letters in lowercase (a to z) or uppercase ( A to Z ) or digits ( 0 to 9 ) or an underscore ( _ ) . For example:

2. Create a name that makes sense. For example, vowel makes more sense than v .

3. If you want to create a variable name having two words, use underscore to separate them. For example:

5. Python is case-sensitive. So num and Num are different variables. For example,

6. Avoid using keywords like if, True, class, etc. as variable names.

• Python Literals

Literals are representations of fixed values in a program. They can be numbers, characters, or strings, etc. For example, 'Hello, World!' , 12 , 23.0 , 'C' , etc.

Literals are often used to assign values to variables or constants. For example,

In the above expression, site_name is a variable, and 'programiz.com' is a literal.

There are different types of literals in Python. Let's discuss some of the commonly used types in detail.

• Python Numeric Literals

Numeric Literals are immutable (unchangeable). Numeric literals can belong to 3 different numerical types: Integer , Float , and Complex .

1. Integer Literals

Integer literals are numbers without decimal parts. It also consists of negative numbers. For example, 5 , -11 , 0 , 12 , etc.

2. Floating-Point Literals

Floating-point literals are numbers that contain decimal parts.

Just like integers, floating-point numbers can also be both positive and negative. For example, 2.5 , 6.76 , 0.0 , -9.45 , etc.

3. Complex Literals

Complex literals are numbers that represent complex numbers.

Here, numerals are in the form a + bj , where a is real and b is imaginary. For example, 6+9j , 2+3j .

• Python String Literals

In Python, texts wrapped inside quotation marks are called string literals. .

We can also use single quotes to create strings.

More on Python Literals

There are two boolean literals: True and False .

For example,

Here, true is a boolean literal assigned to pass .

Character literals are unicode characters enclosed in a quote. For example,

Here, S is a character literal assigned to some_character .

Python contains one special literal None . We use it to specify a null variable. For example,

Here, we get None as an output as the value variable has no value assigned to it.

Let's see examples of four different collection literals. List, Tuple, Dict, and Set literals.

In the above example, we created a list of fruits , a tuple of numbers , a dictionary of alphabets having values with keys designated to each value and a set of vowels .

To learn more about literal collections, refer to Python Data Types .

Table of Contents

Video: python variables and print().

Sorry about that.

Related Tutorials

Python Tutorial

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 variables, varia b l e s.

Variables are containers for storing data values.

Creating Variables

Python has no command for declaring a variable.

A variable is created the moment you first assign a value to it.

Variables do not need to be declared with any particular type , and can even change type after they have been set.

If you want to specify the data type of a variable, this can be done with casting.

Advertisement

Get the Type

You can get the data type of a variable with the type() function.

Single or Double Quotes?

String variables can be declared either by using single or double quotes:

Case-Sensitive

Variable names are case-sensitive.

This will create two variables:

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.

previous episode

Introduction to python for data science, next episode, variables and assignment.

Overview Teaching: 10 min Exercises: 10 min Questions How can I store data in programs? Objectives Write programs that assign scalar values to variables and perform calculations with those values. Correctly trace value changes in programs that use scalar assignment.

Use variables to store values.

• Variables are names for values.
• In Python the = symbol assigns the value on the right to the name on the left.
• The variable is created when a value is assigned to it.
• Here, Python assigns an age to a variable age and a name in quotes to a variable first_name .
• can only contain letters, digits, and underscore _ (typically used to separate words in long variable names)
• cannot start with a digit
• are case sensitive (age, Age and AGE are three different variables)
• Variable names that start with underscores like __alistairs_real_age have a special meaning so we won’t do that until we understand the convention.

Use print to display values.

• Python has a built-in function called print that prints things as text.
• Call the function (i.e., tell Python to run it) by using its name.
• Provide values to the function (i.e., the things to print) in parentheses.
• To add a string to the printout, wrap the string in single or double quotes.
• The values passed to the function are called arguments
• print automatically puts a single space between items to separate them.
• And wraps around to a new line at the end.

Variables must be created before they are used.

• If a variable doesn’t exist yet, or if the name has been mis-spelled, Python reports an error. (Unlike some languages, which “guess” a default value.)
• The last line of an error message is usually the most informative.
• We will look at error messages in detail later .

Variables Persist Between Cells Be aware that it is the order of execution of cells that is important in a Jupyter notebook, not the order in which they appear. Python will remember all the code that was run previously, including any variables you have defined, irrespective of the order in the notebook. Therefore if you define variables lower down the notebook and then (re)run cells further up, those defined further down will still be present. As an example, create two cells with the following content, in this order: print ( myval ) myval = 1 If you execute this in order, the first cell will give an error. However, if you run the first cell after the second cell it will print out 1 . To prevent confusion, it can be helpful to use the Kernel -> Restart & Run All option which clears the interpreter and runs everything from a clean slate going top to bottom.

Variables can be used in calculations.

• Remember, we assigned the value 42 to age a few lines ago.

Use an index to get a single character from a string.

• The characters (individual letters, numbers, and so on) in a string are ordered. For example, the string 'AB' is not the same as 'BA' . Because of this ordering, we can treat the string as a list of characters.
• Each position in the string (first, second, etc.) is given a number. This number is called an index or sometimes a subscript.
• Indices are numbered from 0.
• Use the position’s index in square brackets to get the character at that position.

Use a slice to get a substring.

• A part of a string is called a substring . A substring can be as short as a single character.
• An item in a list is called an element. Whenever we treat a string as if it were a list, the string’s elements are its individual characters.
• A slice is a part of a string (or, more generally, any list-like thing).
• We take a slice by using [start:stop] , where start is replaced with the index of the first element we want and stop is replaced with the index of the element just after the last element we want.
• Mathematically, you might say that a slice selects [start:stop) .
• The difference between stop and start is the slice’s length.
• Taking a slice does not change the contents of the original string. Instead, the slice is a copy of part of the original string.

Use the built-in function len to find the length of a string.

• Nested functions are evaluated from the inside out, like in mathematics.

Python is case-sensitive.

• Python thinks that upper- and lower-case letters are different, so Name and name are different variables.
• There are conventions for using upper-case letters at the start of variable names so we will use lower-case letters for now.

Use meaningful variable names.

• Python doesn’t care what you call variables as long as they obey the rules (alphanumeric characters and the underscore).
• Use meaningful variable names to help other people understand what the program does.
• The most important “other person” is your future self.

Swapping Values Fill the table showing the values of the variables in this program after each statement is executed. # Command # Value of x # Value of y # Value of swap # x = 1.0 # # # # y = 3.0 # # # # swap = x # # # # x = y # # # # y = swap # # # # Solution # Command # Value of x # Value of y # Value of swap # x = 1.0 # 1.0 # not defined # not defined # y = 3.0 # 1.0 # 3.0 # not defined # swap = x # 1.0 # 3.0 # 1.0 # x = y # 3.0 # 3.0 # 1.0 # y = swap # 3.0 # 1.0 # 1.0 # These three lines exchange the values in x and y using the swap variable for temporary storage. This is a fairly common programming idiom.

Predicting Values What is the final value of position in the program below? (Try to predict the value without running the program, then check your prediction.) initial = 'left' position = initial initial = 'right' Solution 'left' The initial variable is assigned the value 'left' . In the second line, the position variable also receives the string value 'left' . In third line, the initial variable is given the value 'right' , but the position variable retains its string value of 'left' .

Challenge If you assign a = 123 , what happens if you try to get the second digit of a via a[1] ? Solution Numbers are not strings or sequences and Python will raise an error if you try to perform an index operation on a number. In the next lesson on types and type conversion we will learn more about types and how to convert between different types. If you want the Nth digit of a number you can convert it into a string using the str built-in function and then perform an index operation on that string. a = 123 print ( a [ 1 ]) TypeError: 'int' object is not subscriptable a = str ( 123 ) print ( a [ 1 ]) 2

Choosing a Name Which is a better variable name, m , min , or minutes ? Why? Hint: think about which code you would rather inherit from someone who is leaving the lab: ts = m * 60 + s tot_sec = min * 60 + sec total_seconds = minutes * 60 + seconds Solution minutes is better because min might mean something like “minimum” (and actually is an existing built-in function in Python that we will cover later).

Slicing practice What does the following program print? atom_name = 'carbon' print ( 'atom_name[1:3] is:' , atom_name [ 1 : 3 ]) Solution atom_name[1:3] is: ar

Slicing concepts What does thing[low:high] do? What does thing[low:] (without a value after the colon) do? What does thing[:high] (without a value before the colon) do? What does thing[:] (just a colon) do? What does thing[number:some-negative-number] do? What happens when you choose a high value which is out of range? (i.e., try atom_name[0:15] ) Solutions thing[low:high] returns a slice from low to the value before high thing[low:] returns a slice from low all the way to the end of thing thing[:high] returns a slice from the beginning of thing to the value before high thing[:] returns all of thing thing[number:some-negative-number] returns a slice from number to some-negative-number values from the end of thing If a part of the slice is out of range, the operation does not fail. atom_name[0:15] gives the same result as atom_name[0:] .

Key Points Use variables to store values. Use print to display values. Variables persist between cells. Variables must be created before they are used. Variables can be used in calculations. Use an index to get a single character from a string. Use a slice to get a substring. Use the built-in function len to find the length of a string. Python is case-sensitive. Use meaningful variable names.

Variable Types

• 2.2. I/O Operations
• 2.3. Comments
• 2.4. Mathematical Operations
• 2.5. Dealing with Errors
• 7.4. Sequence Operations
• 7.6. Copying Data Structures

2.1. Variables and Data Types

In this section, we're going to look at one of the most fundamental concept of programming, variables and data types.

Introduction to Variables

Simply put, variables are containers that store a specific value. Each variable has a name and a value. We can store any value to variable and when we want to access that value again, we can simply reference that variable with its name.

For example, if we want to store the age of user, we can simply write: age = 20 This is the syntax of creating variables. Here, left hand side of the = symbol represents the name of variable while the right hand side is the value assigned to variable.

20 = age is not a valid syntax. Left side is always the variable name with right side being the value to store.

When we need the information, we can simply access it by referencing variable name:

Variable types

If you are coming from another language, you might be used to mentioning the type of variable when declaring it. In Python, the type is inferred automatically.

Rules for variable name

There are a few rules for the name of a variable which must be followed:

• Variable name can only contain letters, numbers or underscore.
• Variable name must start with a letter or underscore.
• Variable names are case-sensitive. (e.g. age and Age are two different variables)

Updating a variable

As the name suggest, variables value can be varied too. For example, in below snippet of code we are first assigning the value 20 to age and after printing that, we're updating the age variable to hold the value 30.

When updating a variable, you can use the previous value too. For example, incrementing the previous age by one:

In programming, we tend to deal with different kinds of data e.g. numbers, text, decimal numbers, dates etc.

To categorize the data, we have data types in programming. Data types are used to represent the type or kind of data. In Python, we have four basic data types:

• str (string) for textual data
• int for integers or whole numbers
• float for floating point (decimal) numbers
• bool (boolean) for boolean values ( True or False )

The string type, str , is used to represent arbitrary textual values. In order to represent a string, we enclose the given text in quotes.

type() function

When we call the type(X) function, it returns the type of X .

Strings are used when we want to represent any textual value. It is important that we enclose strings in quotes, either double quotes or single quotes.

In this case, both name and name2 are same. Worth noting that we cannot mix double and single quotes. If you start a string with double quote, you must end it with a double quote too and vice versa.

This code will raise an error because quotes are not consistent: name = "Harry Potter'

When we want to represent integers i.e whole numbers, we use the int data type. To represent numbers, we simply write the number as is. There is no need of enclosing them in quotes.

A common pitfall is to enclose the number in quotes which makes it of str data type instead of int data type.

Floating-point numbers

Floating-point numbers are simply decimal numbers. In Python, the data type to represent these numbers is called float .

Boolean values

Boolean value is simply either True or False . Boolean values are often used to represent ON/OFF state. For example, if you're developing a program to control the lights remotely, you might need a boolean value to represent the current state of lights.

In Python, we have bool type to represent boolean values. There are only two boolean literals, True and False .

Booleans are used in logical expressions and conditionals . These topics are covered in later sections.

Converting data types

In programming, it is important to ensure that each data is in its appropriate data type. This is done to ensure that proper operations can be performed on the data.

For example, if you have two numeric strings "20" and "30" , you cannot add these two until they are converted to integer type.

• The two strings are joined together instead of expected mathematical addition operation.

In order to convert a data into a different type, we can call that data type with the value that needs to be converted.

For example, we can convert a numeric string to integer:

Similar to this, a string can also be converted to float and bool . Note that conversion can only occur successfully if the string is convertable to the given type. That is, in case of integers, all characters in a string are numbers.

• Raises an error as x cannot be converted to integer.

For each scenario, think of an appropriate Python data type that can be used.

• To store the address of a user.
• To store the phone number of a user.
• To store the height of user.
• To store whether the user is over 18 or not.
• To store the address of a user: str

Because address is a text, we must use a string to store it.

• To store the phone number of a user: str

Phone numbers are a set of digits and could also include dashes or plus symbols, so a string.

• To store the height of user: float

Heights can vary in decimals so floating point number is appropriate to use here.

• To store whether the user is over 18 or not: bool

Since there are only two possible cases here: over 18 or not over 18, we can use simply use a boolean value which if True, represents that user is over 18 and vice versa.

If you've used another statically typed programming language, you may be aware that variables can have fixed types and once declared, they cannot change type. This isn't the case in Python. Python is a dynamically typed language which means type can change at runtime.

For example, in this case, we first assign age an int but we can update it afterwards to hold a str type value. This code would execute without any errors.

In short, the type of variable isn't fixed and can change during the execution of program.

• 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

Different Forms of Assignment Statements in Python

• Statement, Indentation and Comment in Python
• Conditional Statements in Python
• Assignment Operators in Python
• Loops and Control Statements (continue, break and pass) in Python
• Different Ways of Using Inline if in Python
• Difference between "__eq__" VS "is" VS "==" in Python
• Augmented Assignment Operators in Python
• Nested-if statement in Python
• How to write memory efficient classes in Python?
• Difference Between List and Tuple in Python
• A += B Assignment Riddle in Python
• Difference between List VS Set VS Tuple in Python
• Assign Function to a Variable in Python
• Python pass Statement
• Python If Else Statements - Conditional Statements
• Data Classes in Python | Set 5 (post-init)
• Assigning multiple variables in one line in Python
• Python Operators for Sets and Dictionaries
• Difference between == and is operator in Python
• Difference between != and is not operator in Python
• Differences and Applications of List, Tuple, Set and Dictionary in Python
• Difference Between x = x + y and x += y in Python
• How to Fix: SyntaxError: positional argument follows keyword argument in Python
• Inplace vs Standard Operators in Python
• Assignment Operators in Programming
• What is the difference between = (Assignment) and == (Equal to) operators
• When should we write our own assignment operator in C++?
• Assignment Operators in C
• Assignment Operators In C++

We use Python assignment statements to assign objects to names. The target of an assignment statement is written on the left side of the equal sign (=), and the object on the right can be an arbitrary expression that computes an object.

There are some important properties of assignment in Python :-

• Assignment creates object references instead of copying the objects.
• Python creates a variable name the first time when they are assigned a value.
• Names must be assigned before being referenced.
• There are some operations that perform assignments implicitly.

Assignment statement forms :-

1. Basic form:

This form is the most common form.

2. Tuple assignment:

When we code a tuple on the left side of the =, Python pairs objects on the right side with targets on the left by position and assigns them from left to right. Therefore, the values of x and y are 50 and 100 respectively.

3. List assignment:

This works in the same way as the tuple assignment.

4. Sequence assignment:

In recent version of Python, tuple and list assignment have been generalized into instances of what we now call sequence assignment – any sequence of names can be assigned to any sequence of values, and Python assigns the items one at a time by position.

5. Extended Sequence unpacking:

It allows us to be more flexible in how we select portions of a sequence to assign.

Here, p is matched with the first character in the string on the right and q with the rest. The starred name (*q) is assigned a list, which collects all items in the sequence not assigned to other names.

This is especially handy for a common coding pattern such as splitting a sequence and accessing its front and rest part.

6. Multiple- target assignment:

In this form, Python assigns a reference to the same object (the object which is rightmost) to all the target on the left.

7. Augmented assignment :

The augmented assignment is a shorthand assignment that combines an expression and an assignment.

There are several other augmented assignment forms:

Please Login to comment...

Similar reads.

• python-basics
• Python Programs

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Trying to compute sum of list variables over a certain number

I’m on Coursera trying to do this one practice problem and it’s blocking my progress. I’ve analyzed all my past training materials to see if I should know the solution already. no luck! I don’t really want anyone to spit out an instant answer at me, but I don’t know how to beat this. I’d like to understand how I should recognize the direction to go for the solution so I can grow as a new programmer. I’m including the situation and what code I’ve made already to see where I’m failing. rainfall_mi is a string that contains the average number of inches of rainfall in Michigan for every month (in inches) with every month separated by a comma. Write code to compute the number of months that have more than 3 inches of rainfall. Store the result in the variable num_rainy_months. In other words, count the number of items with values > 3.0.

For future posts, please read the pinned thread to understand how to post code with proper formatting. Indentation is vital in Python, and the forum software will break it if you don’t tell it that the code is code. It also changes quote characters into fancy “smart quote” characters that are not valid in Python code, and sometimes removes or alters other things because they look like HTML.

The problem here isn’t “direction” - your approach to the problem, your algorithm , is completely sound. There are two smaller problems here: a small gap in your knowledge, and careful logical thinking - i.e. attention to detail.

First, the knowledge gap:

The problem here is that after splitting the string, the pieces are still strings. You can’t compare them to an integer like 3 directly - you must do a conversion first:

Onward to logical thinking. You should think carefully about the intended purpose of each variable, and the names that you give them. The result from rainfall_mi.split(‘,’) isn’t the number of rainy months, so it shouldn’t go into num_rainy_months . You should use a different variable and give it a name that explains its purpose to you clearly. Then, of course, to loop over it, you’ll need to use that name in the for loop. I think you’ll also find that everything to do with acc is completely irrelevant, so it should just be removed.

Finally, think about what you do put in num_rainy_months . I see your strategy is to look at each month’s data, and add 1 to num_rainy_months each time you see a rainy month. This is a fine way to do it. But the question is: how should we start off this variable before the loop, in order for that logic to make sense? (Hint: if you don’t see any rainy months the whole time, what should the result be?)

Ok, so here is what I have so far and it seems to work. Can anyone confirm that I won this battle?

here is a potential solution. Note that I have converted the string values into a list of float values so that if the data needs to be analyzed at a later date (I know it is a practice problem for your course but here as a more realistic use case).

Pretty much, yep! One small thing. In Python, you don’t “convert” variables; instead, you create new values from existing ones. It’s a subtle difference but an important one. This does nothing:

It figures out what the floating-point value equivalent to that string would be, and then… does nothing with it. However, you have successfully done the same thing on the following line:

where it DOES behave as you’d expect: it calculates the relevant floating-point value, then compares it against 3.

By the way, you can shorthand common operations like “add one to this thing”:

Going back to how things were when you were struggling, here’s a tip for tackling the problem: If In Doubt, Print It Out! Dump a whole lot of stuff onto the console and see what it looks like. Get to know the reprs of different data types, and you should start seeing important patterns. Notably, had you printed out rainy_totals , you would have seen that it was a list of strings, not numbers, and comparing those against the number 3 won’t work.

Related Topics