Python 101: Variables, Operators and Simple I/O

• Python 101
• Chapter 1
• Chapter 2
• Chapter 3
• Chapter 4
• Chapter 5
• Chapter 6
• Chapter 7
• Index

Variables in Python

Variables in Python

Hi, and welcome back to Python 101. In the second chapter of this course, we will have a look at variables, operators and simple I/O.

• Programs you'll be able to compose by the end of this chapter: Fill the form, Odd or even, Leap year or not.
• Variables: String, number, floating point, Boolean, assignment statements, identifiers, guidelines for naming variables.
• All about strings: Using quotes inside strings, verbatim strings, escape sequences, concatenating and repeating strings, line continuation, immutability, nesting quotes, string methods, calculating the length of a string.
• More about print: Printing multiple values, ending print statement with a desired character.
• Numeric data types: int, float, complex, arithmetic operators.
• Boolean data type: boolean operators.
• A Few General Things: getting user input with input(), casting: type conversions(string to int, int to string, string to float), comparison operators.
• Controlling the flow of the program: Introduction to how to control the flow of the program, branching: if construct.
• On the agenda in next chapter
• Exercises

What you'll be able to make by the end of this chapter

§

Let's have a look at the programs you will be able to materialize by the end of this chapter...

#1 Fill the form

#2 Odd or even number?

#3 Leap Year or not?

Variables

§

• A variable is a container (say, a glass), that holds a value(say, water) that may change (say, coffee).
• Once a variable is assigned a value, the variable can be used in place of that value.
• Variables are stored in the memory of your computer. This memory space is vacated as soon as the program runs it full course (google 'Python Garbage Collection' for further study). To vacate this space while the program is still running, you may use the del keyword e.g. >>> del variable_name
• Python supports 4 primitive types of variables: string, integer, floating point, Boolean (complex numbers are also supported, but are not considered primitive). Apart from these, variables can also hold more complex data types like lists, sets, tuples and dictionaries, these are known as data structures. We will get to them in due time. For now, let's grapple with the fundamental ones: string, integer, floating point and Boolean.
• Declaring a variable is easy. Simply give your variable a name, followed by an equality sign(also called assignment operator), followed by the value you want your variable to hold.

  >>> my_variable_1 = 'Hello'      # a string variable

  >>> my_variable_2 = "Hellooooo"  # another string variable

  >>> my_variable_3 = 23           # an integer variable

  >>> my_variable_4 = 23.0         # a floating point variable

  >>> my_variable_5 = True         # a Boolean variable

  All of the above are assignment statements, with variables on the left and values on the right

• As you can see, we do not specify any additional keyword to specify what kind of data is the variable going to hold. Python is smart, it deduces the data type based on the value we are assigning to the variable. You can check it yourself by using the builtin type function.

  >>> type(my_variable_1)

  <class 'str'>

  >>> type(my_variable_2)

  <class 'str'>

  >>> type(my_variable_3)

  <class 'int'>

  >>> type(my_variable_4)

  <class 'float'>

  >>> type(my_variable_5)

  <class 'bool'>

• Each variable type i.e. str, int, float, bool, dict, tuple, list, set has a finite set of associated functions and attributes (properties) that can be called only on a particular type of variable e.g. a string variable is open to methods like upper(), lower(), title() etc. which are not applicable to an integer variable. Likewise, an integer variable has attributes like numerator and denominator that are not applicable to strings, so on and so forth.

• You can replace the existing value in a variable.

  >>> variable_1 = "hi"

  >>> variable_1 = "hello"

  >>> print(variable_1)

  hello

• Variables need to be declared before they are referenced in the code, or else the interpreter raises a NameError exception. We will cover exceptions later.

Guidelines for naming a variable

There are two synonyms for variables: attributes & identifiers. From lexical point of view of the Python programming language(for that matter, any programming language), identifier is the name given to entities like class, functions, variables etc. It helps differentiating one entity from another and to refer them.

Following are the rules to make a valid identifier:

• it can be a combination of lowercase alphabet (a-z), uppercase alphabet (A-Z), digits (0-9) and underscore(_) e.g. my_variable, myVariable, myVar.
• it cannot begin with a digit i.e. myVar1 is fine but 1myVar is not.
• special symbols like $, #, !, % etc. are not allowed since they have special meanings in the language.
• there is no limit on the length of identifiers, but try to make them as readable as you can, keeping readability in mind.
• identifiers are case sensitive. so myVar and myvar are two different variables.
• identifiers should not be keywords i.e. you should not make a variable named print or True etc., as it will create problems when you want to the keyword True.

All about strings

§

• A string is a sequence of characters, and a character is, well, you know what a character is. In literal terms, character is anything you can put on to the screen using your keyboard, like a letter, a number, a space, special symbols such as hash, percent etc. "Hello there!" is a string. It consists of 12 characters(5 + 1 + 5 + 1).
• Strings can be declared using an apostrophe/single quote('), double quotes("), 3 apostrophes(''') or 3 double quotes("""). You can use all these interchangeably, as long as you wrap your string with the same set of symbols i.e. if you cannot begin a string with a single quote and end with a double quote.

  >>> stringOne = 'Hi there!'

  >>> stringOne

  'Hi there!'

  >>> stringTwo = "Hello there!'

  >>> stringTwo

  'Hello there!'

  >>> stringThree = '''Hi there from triple apostrophe strings!'''

  >>> stringThree

  'Hi there from triple apostrophe strings!'

  >>> stringFour = """Hello from triple double quoted strings!"""

  >>> stringFour

  'Hello from triple double quoted strings'

• As I said, you could either of these 4 ways to denote a string. The last two, the triple quoted strings may span multiple lines and Python won't generate any error, while in the first two cases, it will generate an error if you try to span them over multiple lines.

  >>> stringFive = "Hello # Press enter to make it span to the next line

  SyntaxError: EOL while scanning string literal

  >>> stringSix = '''Hello from a verbatim string...

  ...'''

  >>> stringSix

  'Hello from a verbatim string...\n\n...'

  Triple quoted strings are really helpful when you want to output ascii art on to the screen, as they preserve the whitespace you specify in the variable. Ascii art is combination of special symbols(including alphabet and numbers) that depict a picture or a logo. These come in handy while trying to output a graphic when some event occurs in the program. One example is outputting different pictures in a game of hangman, depending how many tries has a player had.

  stringSeven = '''

  _______

  |/     |

  |     (-)

  |     \|/

  |      |

  |     / \

  |

  |___

  '''

  If you simply enter this variable name in the interpreter and press enter, you will see a combination of sequences such as \n, \xa0. These are escape sequences, you will learn about them in the next section. For now, suffice it to know that to output this graphic as it is depicted here, you have to wrap the variable in a print() function i.e. >>> print(stringSeven)

  Triple quoted strings are also used as docstrings in functions, we will get to that later.

• You may use normal strings to span multiple lines by using the line continuation character i.e. backslash (\).

  >>> stringEight = 'This string is most likely to violate the Python guideline which says you \

  should try to limit your statements to 79 characters and no further.'

  >>> stringEight

  'This string is most likely to violate the Python guideline which says you should try to limit your statements to 79 characters and no further.'

  However, PEP, the Python Enhancement Proposal prefers that if you want your strings to span multiple lines, you may use the brackets, like below.

  >>> stringNine = ("This string is also likely to violate the Python guideline which says you "

  "should try to limit your statements to 79 characters and no further.")

  >>> stringNine

  'This string is also likely to violate the Python guideline which says you should try to limit your statements to 79 characters and no further.'

Unpacking a string

Strings are sequences of characters, and they can be unpacked into individual variables. Unpacking procedure can be performed on lists, dictionaries, sets and tuples, but we'll look at that later. Here's how you unpack a string:

Referring individual characters in a string with indexes

You can extract a particular string out of a string using a number in square brackets, as below:

What you specified in the brackets is what is called an index. Indexes are a programming language's way of storing your data sequentially in the memory. Indexes are zero based, that is the first character will be given an index of 0. Here's how the string 'Hello there!' will be stored in the memory:

You can access the characters from the end as well, using negative indexes. In this case, the first character from the end will be represented by -1. Give that a try.

Repeating a string

You can repeat a string multiple times by using the asterisk symbol (*), like this:

Concatenating two or more strings

You can join two strings by using the addition symbol (+), or by giving each string as an argument to the print function, or by placing the strings to be joined adjacent to each other wrapped in their own quotes. See below for example.

Be wary of the fact for string concatenation, all the participants should be of the type string, or you will see a TypeError. Refer to type casting below to make the required conversion.

Escape Sequences: how to print special characters inside strings

There are many characters you might want to include in your string, but inserting them normally will generate errors or unexpected results e.g. say you wanted to quote a great author or wanted to include a dialogue from a character in direct speech, or wanted to use the sarcastic quotation marks, or further more, wanted to emphasize a particular word using single quotes, here's how you would do it:

What you cannot do is this:

because Python cannot make sense of the above, you need to escape the single quotes in the middle by prefixing them with a backslash (\).

Following are the prominent escape sequences used in Python:

For further reading, visit this link.

Slicing a string

Slicing means getting a substring of a given string i.e. getting a portion of the original string. Here's how we achieve slicing in Python.

String methods

• Python provides numerous methods for tweaking strings, each of which is handy. You can see all these by entering a string in the Python interpreter with single/double quotes, typing in a period (.), then pressing tab or Ctrl/Cmd + Space.
• To bring these into action, select one of these using arrow keys, double press Tab, type in two round brackets i.e. () and hit enter e.g. "Sample".upper()
• To get help on these methods, say title method you may do something like this: >>> help("Sample".title)

I'll list a few prominent ones here, you can explore the rest.

Calculating the length of a string

We can use the inbuilt len() function to calculate the length of a string. The len() is a generic method, meaning it can be used to calculate the length of lists, tuples, dictionaries etc.

More about print

§

So far, we have seen how the print() function is arguably the most used builtin function. Let's discuss a couple more functionalities provided by the print() function.

Ending a statement with a desired character

The default behavior of the print() is to print a new line after whatever we ask it to print. Now that you know about escape sequences, you would have probably guessed that it ends with a \n.

We can tweak this to suit our needs, using the end argument. Let's see this in action:

Printing multiple values

We have actually touched upon this in the string concatenation bit, for the sake of completeness, let's see it once again. We can print multiple values using the same print() function, like this:

Number data types

§

Python 2 supports int, float, complex and long data types. However, long was dropped in Python 3. Integers are numbers without any fractional component e.g. 2, -2, 0. Floating point numbers have a fractional component e.g. 2.3, 3.14. Complex numbers have an imaginary bit along with them, represented by the letter j.

Arithmetic Operators

Python supports mixed arithmetic: when an arithmetic operator has operands of different numeric types, the operand with less precision is widened to that of the other, where integer is narrower than floating point, which is narrower than complex.

Mathematical operators work more or less the same way on all integer types, except for a couple of exceptions.

Boolean Data Type

§

Boolean is the simplest data type you will ever see. It only has two valid values: True and False. It was added to Python in version 2.3. Since then, many builtin functions and standard library functions were changed to return either True or False e.g. the isinstance(x, y) which tells us whether x is of the type y.

Boolean data type was added with the primary goal of making code clearer. For example, if you're reading a function and encounter the statement return 1, you might wonder whether the 1 represents a Boolean truth value, an index, or just a number to be used elsewhere. If the statement is return True, however, the meaning of the return value is crystal clear.

In all actuality, True and False are string versions of integers 0 and 1, and Boolean data type is a subclass of the 'int' type. Hence, it supports arithmetic, like this:

Boolean operators

Following are the three boolean operators: or, and and not.

A Few General Things

§

Here are a few handy things you should take note of.

Getting user input: input()

The builtin input() function is used for receiving input from the user. The input function takes an argument, which is what will be flashed on the screen before the user enters a value. We can assign the value entered to a variable that we can use later in the program.

Casting: Type Conversions

There will be times when you need to convert a string to a numeric form, or vice versa. For example, try executing

You should see something like this:

To get around situations like this, we can use the builtin str(), int(), float() functions.

Comparison Operators

At some point in your program, you will the need to compare two values, and then proceed on the basis of the result of the comparison. For example, you have to compare the entered string with the stored password of the safe, and grant or revoke access to the safe on the same basis, or you have to monitor the temperature of a furnace and throw off an alarm as soon as it surpasses the maximum allowed value of temperature. Okay, a little too intricate for an example, but you get the point, don't you?

Python supports 8 comparison operations, here they are with examples:

Controlling The Flow Of The Program

§

Python is an imperative language, as opposed to being a declarative language. Imperative paradigm suggests that the language uses its statements to jump around the program and control the way a program operates. In other words, the control shifts from one block of code to the other. Declarative languages emphasizes on what the statements would accomplish, and not on how they would do it. You specify what you want done, it is left on the machine (more specifically, compiler) to figure that out. Examples of declarative languages are SQL and Prolog.

There are three methods of controlling the flow in Python:

• Loops
• Branchincg
• Function calls

We'll cover branching for now. Branching, as the word suggests, implies that if a given condition(also known as predicate) is true, execute the following indented(four spaces or a tab) code block. Else, execute another code block. There is only one statement in Python that implements branching i.e. the if statement.

if statement

The simplest form of an if statement is: if a given condition is true, execute this piece of code. If it is false, proceed by skipping the code block.

The elif and else clauses give you more ways to cover the domain of your problem. They are optional to specify.
Elif: If the predicate in the "if" is false, it will test the predicate on the first elif, and run that code block if it’s true. If the first elif is false, it tries the second one, and so on. As soon as it finds a true predicate, it will stop checking branches, and skip the rest of the if statement.
Else: The else clause is placed at the bottom of the entire if statement. If none of the other branches are executed, then Python will run this branch. It doesn't take any predicate.

On the agenda in the next chapter

§

Strings, Numbers, Operators, Controlling the flow, we have covered significant ground in this chapter, kudos to you! Try the 3 programs yourself. You will be able to make sense of them now, and in case you don't, then place a comment down below.

In the next chapter, we will cover 2 the looping constructs, namely, for and while. Till then, cheerio!

Further Reading

• Operator Precedence
• Ternary Operator/Conditional Expression

• Python 101
• Chapter 1
• Chapter 2
• Chapter 3
• Chapter 4
• Chapter 5
• Chapter 6
• Chapter 7
• Index

See also:

• Object Oriented Python
• Design Patterns in Python
• 50+ Handy Standard Library Modules
• 60+ Handy Third Library Modules
• 50+ Tips & Tricks for Python Developers
• 50+ Know-How(s) Every Pythonista Must Know