python type of variable assignment

Leon Lovett

Python Variables – A Guide to Variable Assignment and Naming

In Python, variables are essential elements that allow developers to store and manipulate data. When writing Python code, understanding variable assignment and naming conventions is crucial for effective programming.

Python variables provide a way to assign a name to a value and use that name to reference the value later in the code. Variables can be used to store various types of data, including numbers, strings, and lists.

In this article, we will explore the basics of Python variables, including variable assignment and naming conventions. We will also dive into the different variable types available in Python and how to use them effectively.

Key Takeaways

• Python variables are used to store and manipulate data in code.
• Variable assignment allows developers to assign a name to a value and reference it later.
• Proper variable naming conventions are essential for effective programming.
• Python supports different variable types, including integers, floats, strings, and lists.

Variable Assignment in Python

Python variables are created when a value is assigned to them using the equals sign (=) operator. For example, the following code snippet assigns the integer value 5 to the variable x :

From this point forward, whenever x is referenced in the code, it will have the value 5.

Variables can also be assigned using other variables or expressions. For example, the following code snippet assigns the value of x plus 2 to the variable y :

It is important to note that variables in Python are dynamically typed, meaning that their type can change as the program runs. For example, the following code snippet assigns a string value to the variable x , then later reassigns it to an integer value:

x = "hello" x = 7

Common Mistakes in Variable Assignment

One common mistake is trying to reference a variable before it has been assigned a value. This will result in a NameError being raised. For example:

print(variable_name) NameError: name ‘variable_name’ is not defined

Another common mistake is assigning a value to the wrong variable name. For example, the following code snippet assigns the value 5 to the variable y instead of x :

y = 5 print(x) NameError: name ‘x’ is not defined

To avoid these mistakes, it is important to carefully review code and double-check variable names and values.

Using Variables in Python

Variables are used extensively in Python code for a variety of purposes, from storing user input to performing complex calculations. The following code snippet demonstrates the basic usage of variables in a simple addition program:

number1 = input("Enter the first number: ") number2 = input("Enter the second number: ") sum = float(number1) + float(number2) print("The sum of", number1, "and", number2, "is", sum)

This program prompts the user to enter two numbers, converts them to floats using the float() function, adds them together, and prints the result using the print() function.

Variables can also be used in more complex operations, such as string concatenation and list manipulation. The following code snippet demonstrates how variables can be used to combine two strings:

greeting = "Hello" name = "Alice" message = greeting + ", " + name + "!" print(message)

This program defines two variables containing a greeting and a name, concatenates them using the plus (+) operator, and prints the result.

Variable Naming Conventions in Python

In Python, proper variable naming conventions are crucial for writing clear and maintainable code. Consistently following naming conventions makes code more readable and easier to understand, especially when working on large projects with many collaborators. Here are some commonly accepted conventions:

It’s recommended to use lowercase or snake case for variable names as they are easier to read and more commonly used in Python. Camel case is common in other programming languages, but can make Python code harder to read.

Variable names should be descriptive and meaningful. Avoid using abbreviations or single letters, unless they are commonly understood, like “i” for an iterative variable in a loop. Using descriptive names will make your code easier to understand and maintain by you and others.

Lastly, it’s a good practice to avoid naming variables with reserved words in Python such as “and”, “or”, and “not”. Using reserved words can cause errors in your code, making it hard to debug.

Scope of Variables in Python

Variables in Python have a scope, which dictates where they can be accessed and used within a code block. Understanding variable scope is important for writing efficient and effective code.

Local Variables in Python

A local variable is created within a particular code block, such as a function. It can only be accessed within that block and is destroyed when the block is exited. Local variables can be defined using the same Python variable assignment syntax as any other variable.

Example: def my_function():     x = 10     print(“Value inside function:”, x) my_function() print(“Value outside function:”, x) Output: Value inside function: 10 NameError: name ‘x’ is not defined

In the above example, the variable ‘x’ is a local variable that is defined within the function ‘my_function()’. It cannot be accessed outside of that function, which is why the second print statement results in an error.

Global Variables in Python

A global variable is a variable that can be accessed from anywhere within a program. These variables are typically defined outside of any code block, at the top level of the program. They can be accessed and modified from any code block within the program.

Example: x = 10 def my_function():     print(“Value inside function:”, x) my_function() print(“Value outside function:”, x) Output: Value inside function: 10 Value outside function: 10

In the above example, the variable ‘x’ is a global variable that is defined outside of any function. It can be accessed from within the ‘my_function()’ as well as from outside it.

When defining a function, it is possible to access and modify a global variable from within the function using the ‘global’ keyword.

Example: x = 10 def my_function():     global x     x = 20 my_function() print(x) Output: 20

In the above example, the ‘global’ keyword is used to indicate that the variable ‘x’ inside the function is the same as the global variable ‘x’. The function modifies the global variable, causing the final print statement to output ’20’ instead of ’10’.

One of the most fundamental concepts in programming is the use of variables. In Python, variables allow us to store and manipulate data efficiently. Here are some practical examples of how to use variables in Python:

Mathematical Calculations

Variables are often used to perform mathematical calculations in Python. For instance, we can assign numbers to variables and then perform operations on those variables. Here’s an example:

x = 5 y = 10 z = x + y print(z) # Output: 15

In this code, we have assigned the value 5 to the variable x and the value 10 to the variable y. We then create a new variable z by adding x and y together. Finally, we print the value of z, which is 15.

String Manipulation

Variables can also be used to manipulate strings in Python. Here is an example:

first_name = “John” last_name = “Doe” full_name = first_name + ” ” + last_name print(full_name) # Output: John Doe

In this code, we have assigned the strings “John” and “Doe” to the variables first_name and last_name respectively. We then create a new variable full_name by combining the values of first_name and last_name with a space in between. Finally, we print the value of full_name, which is “John Doe”.

Working with Data Structures

Variables are also essential when working with data structures such as lists and dictionaries in Python. Here’s an example:

numbers = [1, 2, 3, 4, 5] sum = 0 for num in numbers:     sum += num print(sum) # Output: 15

In this code, we have assigned a list of numbers to the variable numbers. We then create a new variable sum and initialize it to 0. We use a for loop to iterate over each number in the list, adding it to the sum variable. Finally, we print the value of sum, which is 15.

As you can see, variables are an essential tool in Python programming. By using them effectively, you can manipulate data and perform complex operations with ease.

Variable Types in Python

Python is a dynamically typed language, which means that variables can be assigned values of different types without explicit type declaration. Python supports a wide range of variable types, each with its own unique characteristics and uses.

Numeric Types:

Python supports several numeric types, including integers, floats, and complex numbers. Integers are whole numbers without decimal points, while floats are numbers with decimal points. Complex numbers consist of a real and imaginary part, expressed as a+bi.

Sequence Types:

Python supports several sequence types, including strings, lists, tuples, and range objects. Strings are sequences of characters, while lists and tuples are sequences of values of any type. Range objects are used to represent sequences of numbers.

Mapping Types:

Python supports mapping types, which are used to store key-value pairs. The most commonly used mapping type is the dictionary, which supports efficient lookup of values based on their associated keys.

Boolean Type:

Python supports a Boolean type, which is used to represent truth values. The Boolean type has two possible values: True and False.

Python has a special value called None, which represents the absence of a value. This type is often used to indicate the result of functions that do not return a value.

Understanding the different variable types available in Python is essential for effective coding. Each type has its own unique properties and uses, and choosing the right type for a given task can help improve code clarity, efficiency, and maintainability.

Python variables are a fundamental concept that every aspiring Python programmer must understand. In this article, we have covered the basics of variable assignment and naming conventions in Python. We have also explored the scope of variables and their different types.

It is important to remember that variables play a crucial role in programming, and their effective use can make your code more efficient and easier to read. Proper naming conventions and good coding practices can also help prevent errors and improve maintainability.

As you continue to explore the vast possibilities of Python programming, we encourage you to practice using variables in your code. With a solid understanding of Python variables, you will be well on your way to becoming a proficient Python programmer.

Similar Posts

Yield and Generators in Python

Python generators are an essential part of modern Python programming. They allow for efficient memory usage and enable developers to iterate over large data sets in a streamlined manner. Python generator functions use the “yield” keyword to generate a sequence of values that can be iterated over. In this article, we will explore the benefits…

Demystifying the Python __init__ Method

Python is one of the most widely used programming languages in the world, known for its simplicity and ease of use. One of the key features of Python is the __init__ method, which plays a critical role in object-oriented programming. In this article, we will explore the __init__ method in depth, starting with its syntax…

An Introduction to Python’s Core Data Types

Python is a widely used programming language that is renowned for its simplicity and accessibility. At the core of Python lies its data types, which are fundamental units that enable programmers to store and manipulate information. Understanding Python data types is essential for effective programming in the language. This article provides an introduction to Python’s…

Object Oriented Programming in Python – A Beginner’s Guide

Python is a versatile programming language that offers support for object-oriented programming (OOP). OOP is a programming paradigm that provides a modular and reusable way to design software. In this article, we will provide a beginner’s guide to object-oriented programming in Python with a focus on Python classes. Python classes are the building blocks of…

Understanding Python Iterators and Generators

Python is a high-level programming language that offers a wide range of built-in functions and data structures. One of the most powerful and versatile of these data structures are iterators and generators. In this article, we’ll take a closer look at Python iterators and generators, their types, and how to work with them to improve…

Coding Reusable Logic with Python Functions

In the world of coding, efficiency and reusability are paramount. With Python functions, you can achieve both. Functions are code blocks that perform specific tasks and can be called multiple times throughout your program. This means you can write a block of code once and reuse it whenever you need it, saving you valuable time…

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 Enhancement Proposals

• Python »
• PEP Index »

PEP 526 – Syntax for Variable Annotations

Notice for reviewers, global and local variable annotations, class and instance variable annotations, annotating expressions, where annotations aren’t allowed, variable annotations in stub files, preferred coding style for variable annotations, changes to standard library and documentation, other uses of annotations, rejected/postponed proposals, backwards compatibility, implementation.

This PEP has been provisionally accepted by the BDFL. See the acceptance message for more color: https://mail.python.org/pipermail/python-dev/2016-September/146282.html

This PEP was drafted in a separate repo: https://github.com/phouse512/peps/tree/pep-0526 .

There was preliminary discussion on python-ideas and at https://github.com/python/typing/issues/258 .

Before you bring up an objection in a public forum please at least read the summary of rejected ideas listed at the end of this PEP.

PEP 484 introduced type hints, a.k.a. type annotations. While its main focus was function annotations, it also introduced the notion of type comments to annotate variables:

This PEP aims at adding syntax to Python for annotating the types of variables (including class variables and instance variables), instead of expressing them through comments:

PEP 484 explicitly states that type comments are intended to help with type inference in complex cases, and this PEP does not change this intention. However, since in practice type comments have also been adopted for class variables and instance variables, this PEP also discusses the use of type annotations for those variables.

Although type comments work well enough, the fact that they’re expressed through comments has some downsides:

• Text editors often highlight comments differently from type annotations.
• There’s no way to annotate the type of an undefined variable; one needs to initialize it to None (e.g. a = None # type: int ).
• Variables annotated in a conditional branch are difficult to read: if some_value : my_var = function () # type: Logger else : my_var = another_function () # Why isn't there a type here?
• Since type comments aren’t actually part of the language, if a Python script wants to parse them, it requires a custom parser instead of just using ast .
• Type comments are used a lot in typeshed. Migrating typeshed to use the variable annotation syntax instead of type comments would improve readability of stubs.
• In situations where normal comments and type comments are used together, it is difficult to distinguish them: path = None # type: Optional[str] # Path to module source
• It’s impossible to retrieve the annotations at runtime outside of attempting to find the module’s source code and parse it at runtime, which is inelegant, to say the least.

The majority of these issues can be alleviated by making the syntax a core part of the language. Moreover, having a dedicated annotation syntax for class and instance variables (in addition to method annotations) will pave the way to static duck-typing as a complement to nominal typing defined by PEP 484 .

While the proposal is accompanied by an extension of the typing.get_type_hints standard library function for runtime retrieval of annotations, variable annotations are not designed for runtime type checking. Third party packages will have to be developed to implement such functionality.

It should also be emphasized that Python will remain a dynamically typed language, and the authors have no desire to ever make type hints mandatory, even by convention. Type annotations should not be confused with variable declarations in statically typed languages. The goal of annotation syntax is to provide an easy way to specify structured type metadata for third party tools.

This PEP does not require type checkers to change their type checking rules. It merely provides a more readable syntax to replace type comments.

Specification

Type annotation can be added to an assignment statement or to a single expression indicating the desired type of the annotation target to a third party type checker:

This syntax does not introduce any new semantics beyond PEP 484 , so that the following three statements are equivalent:

Below we specify the syntax of type annotations in different contexts and their runtime effects.

We also suggest how type checkers might interpret annotations, but compliance to these suggestions is not mandatory. (This is in line with the attitude towards compliance in PEP 484 .)

The types of locals and globals can be annotated as follows:

Being able to omit the initial value allows for easier typing of variables assigned in conditional branches:

Note that, although the syntax does allow tuple packing, it does not allow one to annotate the types of variables when tuple unpacking is used:

Omitting the initial value leaves the variable uninitialized:

However, annotating a local variable will cause the interpreter to always make it a local:

as if the code were:

Duplicate type annotations will be ignored. However, static type checkers may issue a warning for annotations of the same variable by a different type:

Type annotations can also be used to annotate class and instance variables in class bodies and methods. In particular, the value-less notation a: int allows one to annotate instance variables that should be initialized in __init__ or __new__ . The proposed syntax is as follows:

Here ClassVar is a special class defined by the typing module that indicates to the static type checker that this variable should not be set on instances.

Note that a ClassVar parameter cannot include any type variables, regardless of the level of nesting: ClassVar[T] and ClassVar[List[Set[T]]] are both invalid if T is a type variable.

This could be illustrated with a more detailed example. In this class:

stats is intended to be a class variable (keeping track of many different per-game statistics), while captain is an instance variable with a default value set in the class. This difference might not be seen by a type checker: both get initialized in the class, but captain serves only as a convenient default value for the instance variable, while stats is truly a class variable – it is intended to be shared by all instances.

Since both variables happen to be initialized at the class level, it is useful to distinguish them by marking class variables as annotated with types wrapped in ClassVar[...] . In this way a type checker may flag accidental assignments to attributes with the same name on instances.

For example, annotating the discussed class:

As a matter of convenience (and convention), instance variables can be annotated in __init__ or other methods, rather than in the class:

The target of the annotation can be any valid single assignment target, at least syntactically (it is up to the type checker what to do with this):

Note that even a parenthesized name is considered an expression, not a simple name:

It is illegal to attempt to annotate variables subject to global or nonlocal in the same function scope:

The reason is that global and nonlocal don’t own variables; therefore, the type annotations belong in the scope owning the variable.

Only single assignment targets and single right hand side values are allowed. In addition, one cannot annotate variables used in a for or with statement; they can be annotated ahead of time, in a similar manner to tuple unpacking:

As variable annotations are more readable than type comments, they are preferred in stub files for all versions of Python, including Python 2.7. Note that stub files are not executed by Python interpreters, and therefore using variable annotations will not lead to errors. Type checkers should support variable annotations in stubs for all versions of Python. For example:

Annotations for module level variables, class and instance variables, and local variables should have a single space after corresponding colon. There should be no space before the colon. If an assignment has right hand side, then the equality sign should have exactly one space on both sides. Examples:

• Yes: code : int class Point : coords : Tuple [ int , int ] label : str = '<unknown>'
• No: code : int # No space after colon code : int # Space before colon class Test : result : int = 0 # No spaces around equality sign
• A new covariant type ClassVar[T_co] is added to the typing module. It accepts only a single argument that should be a valid type, and is used to annotate class variables that should not be set on class instances. This restriction is ensured by static checkers, but not at runtime. See the classvar section for examples and explanations for the usage of ClassVar , and see the rejected section for more information on the reasoning behind ClassVar .
• Function get_type_hints in the typing module will be extended, so that one can retrieve type annotations at runtime from modules and classes as well as functions. Annotations are returned as a dictionary mapping from variable or arguments to their type hints with forward references evaluated. For classes it returns a mapping (perhaps collections.ChainMap ) constructed from annotations in method resolution order.
• Recommended guidelines for using annotations will be added to the documentation, containing a pedagogical recapitulation of specifications described in this PEP and in PEP 484 . In addition, a helper script for translating type comments into type annotations will be published separately from the standard library.

Runtime Effects of Type Annotations

Annotating a local variable will cause the interpreter to treat it as a local, even if it was never assigned to. Annotations for local variables will not be evaluated:

However, if it is at a module or class level, then the type will be evaluated:

In addition, at the module or class level, if the item being annotated is a simple name , then it and the annotation will be stored in the __annotations__ attribute of that module or class (mangled if private) as an ordered mapping from names to evaluated annotations. Here is an example:

__annotations__ is writable, so this is permitted:

But attempting to update __annotations__ to something other than an ordered mapping may result in a TypeError:

(Note that the assignment to __annotations__ , which is the culprit, is accepted by the Python interpreter without questioning it – but the subsequent type annotation expects it to be a MutableMapping and will fail.)

The recommended way of getting annotations at runtime is by using typing.get_type_hints function; as with all dunder attributes, any undocumented use of __annotations__ is subject to breakage without warning:

Note that if annotations are not found statically, then the __annotations__ dictionary is not created at all. Also the value of having annotations available locally does not offset the cost of having to create and populate the annotations dictionary on every function call. Therefore, annotations at function level are not evaluated and not stored.

While Python with this PEP will not object to:

since it will not care about the type annotation beyond “it evaluates without raising”, a type checker that encounters it will flag it, unless disabled with # type: ignore or @no_type_check .

However, since Python won’t care what the “type” is, if the above snippet is at the global level or in a class, __annotations__ will include {'alice': 'well done', 'bob': 'what a shame'} .

These stored annotations might be used for other purposes, but with this PEP we explicitly recommend type hinting as the preferred use of annotations.

• Should we introduce variable annotations at all? Variable annotations have already been around for almost two years in the form of type comments, sanctioned by PEP 484 . They are extensively used by third party type checkers (mypy, pytype, PyCharm, etc.) and by projects using the type checkers. However, the comment syntax has many downsides listed in Rationale. This PEP is not about the need for type annotations, it is about what should be the syntax for such annotations.
• Introduce a new keyword: The choice of a good keyword is hard, e.g. it can’t be var because that is way too common a variable name, and it can’t be local if we want to use it for class variables or globals. Second, no matter what we choose, we’d still need a __future__ import.

The problem with this is that def means “define a function” to generations of Python programmers (and tools!), and using it also to define variables does not increase clarity. (Though this is of course subjective.)

• Use function based syntax : It was proposed to annotate types of variables using var = cast(annotation[, value]) . Although this syntax alleviates some problems with type comments like absence of the annotation in AST, it does not solve other problems such as readability and it introduces possible runtime overhead.

Are x and y both of type T , or do we expect T to be a tuple type of two items that are distributed over x and y , or perhaps x has type Any and y has type T ? (The latter is what this would mean if this occurred in a function signature.) Rather than leave the (human) reader guessing, we forbid this, at least for now.

• Parenthesized form (var: type) for annotations: It was brought up on python-ideas as a remedy for the above-mentioned ambiguity, but it was rejected since such syntax would be hairy, the benefits are slight, and the readability would be poor.

it is ambiguous, what should the types of y and z be? Also the second line is difficult to parse.

• Allow annotations in with and for statement: This was rejected because in for it would make it hard to spot the actual iterable, and in with it would confuse the CPython’s LL(1) parser.
• Evaluate local annotations at function definition time: This has been rejected by Guido because the placement of the annotation strongly suggests that it’s in the same scope as the surrounding code.
• Store variable annotations also in function scope: The value of having the annotations available locally is just not enough to significantly offset the cost of creating and populating the dictionary on each function call.
• Initialize variables annotated without assignment: It was proposed on python-ideas to initialize x in x: int to None or to an additional special constant like Javascript’s undefined . However, adding yet another singleton value to the language would needed to be checked for everywhere in the code. Therefore, Guido just said plain “No” to this.
• Add also InstanceVar to the typing module: This is redundant because instance variables are way more common than class variables. The more common usage deserves to be the default.
• Allow instance variable annotations only in methods: The problem is that many __init__ methods do a lot of things besides initializing instance variables, and it would be harder (for a human) to find all the instance variable annotations. And sometimes __init__ is factored into more helper methods so it’s even harder to chase them down. Putting the instance variable annotations together in the class makes it easier to find them, and helps a first-time reader of the code.
• Use syntax x: class t = v for class variables: This would require a more complicated parser and the class keyword would confuse simple-minded syntax highlighters. Anyway we need to have ClassVar store class variables to __annotations__ , so a simpler syntax was chosen.
• Forget about ClassVar altogether: This was proposed since mypy seems to be getting along fine without a way to distinguish between class and instance variables. But a type checker can do useful things with the extra information, for example flag accidental assignments to a class variable via the instance (which would create an instance variable shadowing the class variable). It could also flag instance variables with mutable defaults, a well-known hazard.
• Use ClassAttr instead of ClassVar : The main reason why ClassVar is better is following: many things are class attributes, e.g. methods, descriptors, etc. But only specific attributes are conceptually class variables (or maybe constants).
• Do not evaluate annotations, treat them as strings: This would be inconsistent with the behavior of function annotations that are always evaluated. Although this might be reconsidered in future, it was decided in PEP 484 that this would have to be a separate PEP.
• Annotate variable types in class docstring: Many projects already use various docstring conventions, often without much consistency and generally without conforming to the PEP 484 annotation syntax yet. Also this would require a special sophisticated parser. This, in turn, would defeat the purpose of the PEP – collaborating with the third party type checking tools.
• Implement __annotations__ as a descriptor: This was proposed to prohibit setting __annotations__ to something non-dictionary or non-None. Guido has rejected this idea as unnecessary; instead a TypeError will be raised if an attempt is made to update __annotations__ when it is anything other than a mapping.

the name slef should be evaluated, just so that if it is not defined (as is likely in this example :-), the error will be caught at runtime. This is more in line with what happens when there is an initial value, and thus is expected to lead to fewer surprises. (Also note that if the target was self.name (this time correctly spelled :-), an optimizing compiler has no obligation to evaluate self as long as it can prove that it will definitely be defined.)

This PEP is fully backwards compatible.

An implementation for Python 3.6 is found on GitHub repo at https://github.com/ilevkivskyi/cpython/tree/pep-526

This document has been placed in the public domain.

Source: https://github.com/python/peps/blob/main/peps/pep-0526.rst

Last modified: 2023-09-09 17:39:29 GMT

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.

Types of variable assignments in Python

Get Started With Data Science

Learn the fundamentals of Data Science with this free course. Future-proof your career by adding Data Science skills to your toolkit — or prepare to land a job in AI, Machine Learning, or Data Analysis.

Introduction

Variables can be defined as containers for storing data values. They make it easier for us to manage or make corrections to our code. As beginners, we can write our code without variables. However, as we begin to advance in learning, we will understand their importance.

Variable assignments

There are two types of variable assignments:

• Single value assignment : Variables that store only one data value.
• Multiple value assignment : Variables that store more than one data value.

Single value assignment

This is a variable where only one data value is assigned to it. The data values can be of any data type.

Explanation

In the above example, name is the variable, while "Favour Peters" is the data value whose data type is a string.

In the above example, age is the variable while 20 is the data value whose data type is an integer.

Note: While assigning these data values to variables, their representation changes according to their data type. For numerical data types like floats and integers, no special symbol is needed. For strings, we use double quotes ( "" ). Different data types are represented differently.

Multiple data assignment

This is a variable where more than one data value is assigned to the variable. These data values can also be accessed individually.

Let's access the individual data values in team :

Using index count, we start from index 0. So "Favour" is at index 0, "Victor" at index 1, and "Clarence" at index 2. We access the data value at index 2.

Note : In multiple data variables, we use commas ( , ) to separate the data values. When accessing these data values individually, we use square brackets( [] ) for their index numbers.

We can also use different data types in one variable:

The variable diff contains the following data types:

• "Favour" : String
• 20 : Integer
• True : Boolean

RELATED TAGS

CONTRIBUTOR

Learn in-demand tech skills in half the time

Mock Interview

Skill Paths

Assessments

Learn to Code

Tech Interview Prep

Generative AI

Data Science

Machine Learning

GitHub Students Scholarship

Early Access Courses

For Individuals

Try for Free

Gift a Subscription

Become an Author

Become an Affiliate

Earn Referral Credits

Cheatsheets

Frequently Asked Questions

Privacy Policy

Cookie Policy

Terms of Service

Business Terms of Service

Data Processing Agreement

Copyright © 2024 Educative, Inc. All rights reserved.

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 ] .

• 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 .

How to assign a variable in Python

Sign in to change your settings

Sign in to your Python Morsels account to save your screencast settings.

Don't have an account yet? Sign up here .

How can you assign a variable in Python?

An equals sign assigns in Python

In Python, the equal sign ( = ) assigns a variable to a value :

This is called an assignment statement . We've pointed the variable count to the value 4 .

We don't have declarations or initializations

Some programming languages have an idea of declaring variables .

Declaring a variable says a variable exists with this name, but it doesn't have a value yet . After you've declared the variable, you then have to initialize it with a value.

Python doesn't have the concept of declaring a variable or initializing variables . Other programming languages sometimes do, but we don't.

In Python, a variable either exists or it doesn't:

If it doesn't exist, assigning to that variable will make it exist:

Valid variable names in Python

Variables in Python can be made up of letters, numbers, and underscores:

The first character in a variable cannot be a number :

And a small handful of names are reserved , so they can't be used as variable names (as noted in SyntaxError: invalid syntax ):

Reassigning a variable in Python

What if you want to change the value of a variable ?

The equal sign is used to assign a variable to a value, but it's also used to reassign a variable:

In Python, there's no distinction between assignment and reassignment .

Whenever you assign a variable in Python, if a variable with that name doesn't exist yet, Python makes a new variable with that name . But if a variable does exist with that name, Python points that variable to the value that we're assigning it to .

Variables don't have types in Python

Note that in Python, variables don't care about the type of an object .

Our amount variable currently points to an integer:

But there's nothing stopping us from pointing it to a string instead:

Variables in Python don't have types associated with them. Objects have types but variables don't . You can point a variable to any object that you'd like.

Type annotations are really type hints

You might have seen a variable that seems to have a type. This is called a type annotation (a.k.a. a "type hint"):

But when you run code like this, Python pretty much ignores these type hints. These are useful as documentation , and they can be introspected at runtime. But type annotations are not enforced by Python . Meaning, if we were to assign this variable to a different type, Python won't care:

What's the point of that?

Well, there's a number of code analysis tools that will check type annotations and show errors if our annotations don't match.

One of these tools is called MyPy .

Type annotations are something that you can opt into in Python, but Python won't do type-checking for you . If you want to enforce type annotations in your code, you'll need to specifically run a type-checker (like MyPy) before your code runs.

Use = to assign a variable in Python

Assignment in Python is pretty simple on its face, but there's a bit of complexity below the surface.

For example, Python's variables are not buckets that contain objects : Python's variables are pointers . Also you can assign into data structures in Python.

Also, it's actually possible to assign without using an equal sign in Python. But the equal sign ( = ) is the quick and easy way to assign a variable in Python.

What comes after Intro to Python?

Intro to Python courses often skip over some fundamental Python concepts .

Sign up below and I'll explain concepts that new Python programmers often overlook .

Series: Assignment and Mutation

Python's variables aren't buckets that contain things; they're pointers that reference objects.

The way Python's variables work can often confuse folks new to Python, both new programmers and folks moving from other languages like C++ or Java.

To track your progress on this Python Morsels topic trail, sign in or sign up .

Sign up below and I'll share ideas new Pythonistas often overlook .

Python's variables are not buckets that contain objects; they're pointers. Assignment statements don't copy: they point a variable to a value (and multiple variables can "point" to the same value).

Introduction to Programming

Variables in python.

• The purpose of a variable is to store information within a program while it is running.
• A variable is a named storage location in computer memory. Use the name to access the value.
• To store a value in a variable, use the = operator (called the assignment operator).
• An = sign in Python is nothing like an equal sign in mathematics. Think of it more like an arrow going from right to left. The expression on the right is evaluated and then stored in the variable named on the left.
• For example, the line of code hourly_wage = 16.75 stores the value 16.75 in the variable called hourly_wage
• You can change the value of a variable with another assignment statement, such as hourly_wage = 17.25
• Every value has a type ( int for integers, float for decimals, str for text). In python, when you store a value in a variable (with = ), that variable then automatically has a type. For example, after the above assignment, hourly_wage is of type float .

Rules and conventions for naming variables in python

• The first character must be a letter or an underscore. For now, stick to letters for the first character.
• The remaining characters must be letters, numbers or underscores.
• No spaces are allowed in variable names.
• Legal examples: _pressure , pull , x_y , r2d2
• Invalid examples, these are NOT legal variable names: 4th_dimension , %profit , x*y , four(4) , repo man
• In python, it's a conventiion to use snake case to name variables. This means that we use all lower-case letters and we separate words in the variable name with underscores. Examples include age , x_coordinate , hourly_wage , user_password
• If the value stored in a variable is a true constant (in other words, its value will never change throughout the program), then we use all capital letters: COURSE_ENROLLMENT_LIMIT , MAX_PASSWORD_ATTEMPTS .
• For high quality code, it is crucial that you give descriptive names for variables. The variable names must help the reader of your program understand your intention.

Typical way we visualize variables

We usually draw variables by putting the value in a box, and labelling the box with the name of the variable:

Types of variables

Each variable has a name, a value, and a type. Types are necessary because different kinds of data are stored differently within the computer's memory. For now, we will learn three different types, for storing signed (positive or negative) whole numbers, signed decimals, and text.

Creating a variable with an assignment operator

A variable is created or declared when we assign a value to it using the assignment operator = . In python, the code looks like this: variable_name = <value> .

Notice that the left hand side of an assignment must be a variable name. Non-example:

After creating a variable, you can change the value stored in a variable with another assignment operator at any time. This is called reassignment .

Finding out the type of a variable or value

The type() function in python will return the type of either a variable or a value. Here are examples that show how to use it:

The output of the above code will be:

Casting (changing the type) of a variable or value

You can change the type of a value (called “casting”) using the int() , float() and str() functions. For example:

• int(23.7) (truncates the float value 23.7 to the int value 23. This is different from rounding - the decimal part is discarded, regardless of whether it is larger or smaller than 0.5.
• float(23) (outputting the result will give 23.0 rather than 23)
• str(23) (converts the integer 23 to the text "23" )
• int("23") (converts the string "23" into a numerical integer value 23 )
• float("23") (converts the string "23" into a numerical decimal value 23.0 )
• int("23.5") results in an error
• float("hello") results in an error

Doing arithmetic in python

Here are the basic arithmetic operators in python. In these examples, assume

An example of a use of the modulus operator is to determine if an integer is even or odd. Note that if x is an integer, then x%2 takes the value 0 or 1 . So x % 2 == 0 is True when x is even and False when x is odd.

Another example of integer division and modulus: When we divide 3 by 4, we get a quotient of 0 and a remainder of 3. So 3//4 results in 0 and 3%4 results in 3.

Warning note: In python, ^ is not an exponent!

Order of operations

The order of operations in python is similar to the order you are familiar with in math: parentheses, then exponentiation, then multiplication/division/modulus in order from left to right, then addition/subtraction in order from left to right.

The biomedical informatics hub's Introduction to Python workshop pages

© 2019. All rights reserved.

python-intro

Variables & the assignment operator, `=`.

The last exercise in particular would have been much cleaner if we had a way of referring to that particular string instead of having to write it all out several times!

This is one of the basic use-cases of variables !

A variable is a way of keeping a handle on data. Variables can hold numerical or string data that we’ve encountered so far, as well any other type of data, as we’ll see later.

In order to create a variable in python, we use the assignment operator , = i.e. the equals sign.

For example

Naming variables

You are free to choose any name for a variable that you wish . The only exceptions are that the variable name cannot contain spaces or other special characters, and cannot correspond to a special python keyword like if , else , or for , as these are reserved for special operations.

While not being illegal ( illegal in programming means that it will give an error), you are also strongly advised to not over-write built-in function names.

For example it is technically legal to name a variable print ! However, you would then overwrite the print function and no longer be able to print things to the terminal!

Python variables are case-sensitive , so a variable called a cannot be referred to as A , and a variable called MyNumber is not the same as mynumber !

Note on variables vs the data they hold

New programmers are sometimes confused by variables vs the data they contain, especially when it comes to string variables.

For example, the following are all valid variable assignments

• one = "1" - a variable called one that holds the single-character string “1”
• one = 1 - a variable called one that holds the number 1
• OnE = "one" - a variable called OnE that holds the string “one”

Using variables

Once a variable has been assigned, we can manipulate its data in exactly the same way as if we were dealing with the data (number, string, etc) directly.

would both output Bloggs .

What happened here?

• In the first line we assigned the string "Joe Bloggs" to the variable somename .
• Then in the second line, we access the last 6 characters of the string using the slicing that we learned about above, and print it to the terminal.

Exercise : Basic variable usage

Write a script (name the file exercise_variables.py ) and create a variable (give it any name you like!) that contains the string

Then create a second variable that contains the text

Now use the replace member-function to replace “lazy dog” with the contents of the second variable and assign the result into a third variable. Remember that a member-function is called using the

Lastly print out all three variables.

Variables exercise

The new part of this exercise is using the assignment operator; e.g.

Most of the other functionality has been covered before!

Variables exercise answer

The following example achieves each of the steps:

Here I’ve used very short and simple variable names, a , b , c - but usually a balance between simplicity and readabilty is best!

If this were part of a big script and saw variable a , b , and c , we wouldn’t have a clue what they meant.

Instead, we could use, for example input_text , replacement , and result_text . Then if we read the script again in a year’s time, (or if our collaborator reads it) there’s a much better chance that we (/ he/she) will understand it.

The output of the script should be

More assignment operators

Along with the standard assignment operator, = , Python has additional extensions that provide shorthand ways to assign values into a variable.

For example (rhs = right hand side)

• += : add the rhs to the variable; a += 10 is the same as a = a + 10
• *= : multiply rhs by the variable; a *= 2 is the same as a = a * 2
• /= : divide variable by rhs; a /= 4 is the same as a = a/4

Where appropriate, this also applies to string data, e.g.

would output Some text .

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 data types, built-in data types.

In programming, data type is an important concept.

Variables can store data of different types, and different types can do different things.

Python has the following data types built-in by default, in these categories:

Getting the Data Type

You can get the data type of any object by using the type() function:

Print the data type of the variable x:

Setting the Data Type

In Python, the data type is set when you assign a value to a variable:

Advertisement

Setting the Specific Data Type

If you want to specify the data type, you can use the following constructor functions:

Test Yourself With Exercises

The following code example would print the data type of x, what data type would that be?

Start the Exercise

COLOR PICKER

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

[email protected]

Top Tutorials

Top references, top examples, get certified.