Python 2 allows mixing tabs and spaces in indentation; this is strongly discouraged.

The tab character

completes

the previous indentation to be a multiple of 8 spaces. Since it is common that editors are configured
to show tabs

as multiple of 4 spaces, this can cause subtle bugs.

Citing PEP 8:

When invoking the Python 2 command line interpreter with the -t option, it issues warnings about
code

that illegally mixes tabs and spaces. When using -tt these warnings become errors. These options are

highly recommended!

Many editors have "tabs to spaces" configuration. When configuring the editor, one should
differentiate between

the tab character ('\t') and the Tab key.

The tab character should be configured to show 8 spaces, to match the language semantics - at least
in cases

when (accidental) mixed indentation is possible. Editors can also automatically convert the tab
character to

spaces.

However, it might be helpful to configure the editor so that pressing the Tab key will insert 4 spaces,

instead of inserting a tab character.

Python source code written with a mix of tabs and spaces, or with non-standard number of
indentation spaces can

be made pep8-conformant using autopep8. (A less powerful alternative comes with most Python
installations:

reindent.py)

Section 1.4: Datatypes

Built-in Types

Booleans

bool: A boolean value of either True or False. Logical operations like and, or, not can be performed on
booleans.

x or y # if x is False then y otherwise x

x and y # if x is False then x otherwise y

not x # if x is True then False, otherwise True

In Python 2.x and in Python 3.x, a boolean is also an int. The bool type is a subclass of the int type
and True and

False are its only instances:

issubclass(bool, int) # True

isinstance(True, bool) # True

isinstance(False, bool) # True

If boolean values are used in arithmetic operations, their integer values (1 and 0 for True and False)
will be used to

return an integer result:

True + False == 1 # 1 + 0 == 1

True * True == 1 # 1 * 1 == 1

Numbers

int: Integer number

GoalKicker.com – Python® Notes for Professionals 12

a=2

b = 100

c = 123456789

d = 38563846326424324

Integers in Python are of arbitrary sizes.

Note: in older versions of Python, a long type was available and this was distinct from int. The two
have

been unified.

float: Floating point number; precision depends on the implementation and system architecture, for

CPython the float datatype corresponds to a C double.

a = 2.0

b = 100.e0

c = 123456789.e1

complex: Complex numbers

a = 2 + 1j

b = 100 + 10j

The <, <=, > and >= operators will raise a TypeError exception when any operand is a complex
number.
Strings

Python 3.x Version ≥ 3.0

str: a unicode string. The type of 'hello'

bytes: a byte string. The type of b'hello'

Python 2.x Version ≤ 2.7

str: a byte string. The type of 'hello'

bytes: synonym for str

unicode: a unicode string. The type of u'hello'

Sequences and collections

Python differentiates between ordered sequences and unordered collections (such as set and dict).

strings (str, bytes, unicode) are sequences

reversed: A reversed order of str with reversed function

a = reversed('hello')

tuple: An ordered collection of n values of any type (n >= 0).

a = (1, 2, 3)

b = ('a', 1, 'python', (1, 2))

b[2] = 'something else' # returns a TypeError

Supports indexing; immutable; hashable if all its members are hashable

GoalKicker.com – Python® Notes for Professionals 13

list: An ordered collection of n values (n >= 0)

a = [1, 2, 3]

b = ['a', 1, 'python', (1, 2), [1, 2]]

b[2] = 'something else' # allowed

Not hashable; mutable.

set: An unordered collection of unique values. Items must be hashable.

a = {1, 2, 'a'}

dict: An unordered collection of unique key-value pairs; keys must be hashable.

a = {1: 'one',

2: 'two'}

b = {'a': [1, 2, 3],

'b': 'a string'}

An object is hashable if it has a hash value which never changes during its lifetime (it needs a
__hash__()

method), and can be compared to other objects (it needs an __eq__() method). Hashable objects
which

compare equality must have the same hash value.

Built-in constants

In conjunction with the built-in datatypes there are a small number of built-in constants in the built-
in namespace:

True: The true value of the built-in type bool

False: The false value of the built-in type bool

None: A singleton object used to signal that a value is absent.

Ellipsis or ...: used in core Python3+ anywhere and limited usage in Python2.7+ as part of array
notation.

numpy and related packages use this as a 'include everything' reference in arrays.

NotImplemented: a singleton used to indicate to Python that a special method doesn't support the
specific

arguments, and Python will try alternatives if available.

a = None # No value will be assigned. Any valid datatype can be assigned later

Python 3.x Version ≥ 3.0

None doesn't have any natural ordering. Using ordering comparison operators (<, <=, >=, >) isn't
supported anymore

and will raise a TypeError.

Python 2.x Version ≤ 2.7

None is always less than any number (None < -32 evaluates to True).

Testing the type of variables

In python, we can check the datatype of an object using the built-in function type.

a = '123'

print(type(a))

GoalKicker.com – Python® Notes for Professionals 14

# Out: <class 'str'>

b = 123

print(type(b))

# Out: <class 'int'>

In conditional statements it is possible to test the datatype with isinstance. However, it is usually not
encouraged

to rely on the type of the variable.

i=7

if isinstance(i, int):

i += 1

elif isinstance(i, str):

i = int(i)

i += 1

For information on the differences between type() and isinstance() read: Differences between
isinstance and

type in Python

To test if something is of NoneType:

x = None

if x is None:

print('Not a surprise, I just defined x as None.')

Converting between datatypes

You can perform explicit datatype conversion.

For example, '123' is of str type and it can be converted to integer using int function.

a = '123'

b = int(a)

Converting from a float string such as '123.456' can be done using float function.

a = '123.456'

b = float(a)

c = int(a) # ValueError: invalid literal for int() with base 10: '123.456'

d = int(b) # 123

You can also convert sequence or collection types

a = 'hello'

list(a) # ['h', 'e', 'l', 'l', 'o']

set(a) # {'o', 'e', 'l', 'h'}

tuple(a) # ('h', 'e', 'l', 'l', 'o')

Explicit string type at definition of literals

With one letter labels just in front of the quotes you can tell what type of string you want to define.

b'foo bar': results bytes in Python 3, str in Python 2

u'foo bar': results str in Python 3, unicode in Python 2

'foo bar': results str

r'foo bar': results so called raw string, where escaping special characters is not necessary, everything
is

taken verbatim as you typed

normal = 'foo\nbar' # foo

GoalKicker.com – Python® Notes for Professionals 15

# bar

escaped = 'foo\\nbar' # foo\nbar

raw = r'foo\nbar' # foo\nbar

Mutable and Immutable Data Types

An object is called mutable if it can be changed. For example, when you pass a list to some function,
the list can be

changed:

def f(m):

m.append(3) # adds a number to the list. This is a mutation.

x = [1, 2]

f(x)

x == [1, 2] # False now, since an item was added to the list

An object is called immutable if it cannot be changed in any way. For example, integers are
immutable, since there's

no way to change them:

def bar():

x = (1, 2)

g(x)

x == (1, 2) # Will always be True, since no function can change the object (1, 2)

Note that variables themselves are mutable, so we can reassign the variable x, but this does not
change the object

that x had previously pointed to. It only made x point to a new object.

Data types whose instances are mutable are called mutable data types, and similarly for immutable
objects and
datatypes.

Examples of immutable Data Types:

int, long, float, complex

str

bytes

tuple

frozenset

Examples of mutable Data Types:

bytearray

list

set

dict

Section 1.5: Collection Types

There are a number of collection types in Python. While types such as int and str hold a single value,
collection

types hold multiple values.

Lists

The list type is probably the most commonly used collection type in Python. Despite its name, a list is
more like an

array in other languages, mostly JavaScript. In Python, a list is merely an ordered collection of valid
Python values. A

list can be created by enclosing values, separated by commas, in square brackets: