Python for Data Science

A Crash Course

Introduction to Python Programming

Khalil El Mahrsi
2024
Creative Commons License

Basics

Interacting With the Python Interpreter

The Python interpreter can be launched in interactive mode by typing the python command in the Unix shell (terminal)
The interpreter prompts for the next instruction with the primary prompt (>>>)
Instructions are read from the standard input (e.g., keyboard)
The results are directed to the standard output (e.g., screen)
Use quit() to exit the interpreter

% python
Python 3.8.5 (default, Aug  5 2020, 03:39:04) 
[Clang 10.0.0 ] :: Anaconda, Inc. on darwin
Type "help", "copyright", "credits" or "license" for more information.>>> welcome_message = "Hello world!"
>>> print(welcome_message)Hello world!>>> 1 + 23>>> quit() # exit() or [ctrl + d] ([ctrl + z] for Windows) also works%

Using Python Source Files

The Python interpreter can also be invoked while passing the name of a Python script (.py source file) as an argument
The statements in the file are read and executed by the interpreter

Content of hello_world.py file

 # -*- coding: utf-8 -*-
welcome_message = "Hello world!"
print(welcome_message)
1 + 2

Execution

% python hello_world.pyHello world!%

Behavior when executing scripts might differ from interactive mode!

Statements and Expressions

Instructions that can be executed by the Python interpreter are called statements

A simple statement is contained within a single logical line

Expressions are combinations of values, variables, operators, and function calls that the interpreter can evaluate

The evaluation of an expression produces a value
The expression's content is evaluated in a specific order defined by the operator precedence

>>> welcome_message = "Hello world!" # this is an assignment statement
>>> print(welcome_message) # another statementHello world!>>> 1 + 2 # expression statement with one expression combining the + operator with the values 1 and 23

Variables

Variables are names used to reference objects
The (re)binding between names and objects is done through assignment statements

The expression on the right is evaluated and the name on the left is assigned to the resulting object

Syntax

variable_name = expression

Examples

>>> welcome_message = "Hello world!"
>>> print(welcome_message)Hello world!>>> a, b = 1, 2 # multiple assignments can be done in the same statement
>>> print(a)1>>> print(b)2>>> a += b # augmented assignment statement, equivalent to a = a + b
>>> print(a)3

Operation	Meaning
`<`	Strictly less than
`<=`	Less than or equal to
`>`	Strictly greater than
`>=`	Greater than or equal to
`==`	Equal to
`!=`	Not equal to
`is`	Object identity
`is not`	Negated object identity
`in`*	Member of
`not in`*	Not member of

Operation	Result
`x or y`	if `x` is false, then `y`, else `x`
`x and y`	if `x` is false, then `x`, else `y`
`not x`	if `x` is false, then `True`, else `False`

String Formatting

Strings can be constructed from other values and variables by using the format() method

The format string contains replacement fields, specified using curly braces {}
Replacement fields

Are substituted by the provided values
Can contain names (e.g., {name}, {age}, ...) of keyword arguments or numeric indexes (e.g., {0}, {1}, ...) of positional arguments
Can contain format specifications (e.g., :%, :.2f, ...) that customize their presentation

Syntax

format_string.format(value_1, value_2, ...)

String Formatting Examples

>>> author = "Arthur Conan Doyle"
>>> book = "The Hound of the Baskervilles"
>>> birthplace = "Edinburgh"
>>> print("{} was originally published in {}.".format(book, 1902))The Hound of the Baskervilles was originally published in 1902.>>> print("{1} is the author of {0}.".format(book, author)) # using indexes of positional argumentsArthur Conan Doyle is the author of The Hound of the Baskervilles.>>> print("{name} was born in {birthplace}.".format(name=author, birthplace=birthplace)) # using names of keyword argumentsArthur Conan Doyle was born in Edinburgh.>>> print("You scored {:.2%} on the exam!".format(0.95)) # format as percentage w/2 significant digitsYou scored 95.00% on the exam!>>> print("The world's population in {year} was {population:,.0f}.".format(year=2018, population=7.59e9))The world's population in 2018 was 7,590,000,000.

Mutable vs. Immutable Objects

>>> text = "Meat"
>>> id(text)  # check object's identity140385175741424>>> text[2] = "e"  # trying to modify the string will raise an exception (result in an error)Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment>>> text = text + " is delicious!"
>>> print(text)Meat is delicious!>>> id(text) # text is now bound to a new object140385175731376>>> animals = ["cat", "dog", "chicken"]
>>> id(animals)140385175649664>>> animals[2] = "duck" # try to replace the third member of the list
>>> animals['cat', 'dog', 'duck']>>> id(animals) # re-check the object's identity (it remains the same)140385175649664

Operation	Description
`len(t)`	Length (number of items) of the tuple `t`
`x in t`	`True` if a member of `t` equals `x`, `False` otherwise
`x not in t`	`False` if a member of `t` equals `x`, `True` otherwise
`t.count(x)`	Number of occurrences of `x` in the tuple `t`
`t.index(x)`	Index of the first occurrence of `x` in the tuple `t`
`max(t)`	Largest item in the tuple `t`
`min(t)`	Smallest item in the tuple `t`

Operation	Description
`x in s`	Returns `True` if `x` is an element of `s`
`x not in s`	Returns `True` if `x` is not an element of `s`
`s1 == s2`	Returns `True` if `s1` and `s2` contain the same elements
`s1.isdisjoint(s2)`	Returns `True` if `s1` and `s2` have no elements in common
`s1.issubset(s2)` `s1 <= s2`	Tests if `s1` is a subset of `s2` (use `s1.issuperset(s2)` or `s1 >= s2` for the other way around)
`s1 < s2`	Tests if `s1` is a proper subset of `s2` (use `s1 > s2` for the other way around)
`s1.intersection(s2)` `s1 & s2`	Returns a new sets containing elements common to both `s1` and `s2`
`s1.union(s2)` `s1 \| s2`	Returns a new sets containing elements of both `s1` and `s2`
`s1.difference(s2)` `s1 - s2`	Returns a new sets containing elements that are in `s1` but not in `s2`
`s1.symmetric_difference(s2)` `s1 ^ s2`	Returns a new sets containing elements that are in either `s1` or `s2` but not both

Operation	Description
`s.add(x)`	Adds `x` to the set `s` (`x` must be hashable)
`s.remove(x)`	Removes `x` from `s` (raises an exception if `x not in s`)
`s.discard(x)`	Removes `x` from `s` (does not raises an exception if `x not in s`)
`s.clear()`	Empties the set `s` from all its elements
`s.pop()`	Removes an arbitrary element from the set `s` and returns it
`s1 &= s2` `s1 \|= s2` `s1 -= s2` `s1 ^= s2`	Update the set `s1` by adding the result of the corresponding set operation (intersection, union, difference, and symmetric difference respectively) to `s1` and `s2`

Operation	Description
`d[key] = value`	Insert the `(key, value)` pair in `d` (updates `d[key]` if it already exists)
`del d[key]`	Removes `key` from `d` (raises a `KeyError` exception if the key is not in the dict)
`len(d)`	Length (number of items) of the dictionary `d`
`x in d`	`True` if a key of `d` equals `x`, `False` otherwise
`x not in d`	`False` if a key of `d` equals `x`, `True` otherwise
`d.pop(key, default)`	If `key in d`, removes the key and returns the associated value, else returns `default`
`d.popitem()`	Removes and returns a `(key, value)` pair from `d` in LIFO (last in first out) order
`d.clear()`	Empty `d` from all its items

1 / 100

Python for Data Science A Crash Course Introduction to Python Programming Khalil El Mahrsi 2024

	number = int(input("Please enter an integer: ")) # ask user to provide input
	if (number % 2):
	print("{} is an odd number".format(number))
	elif not ((number % 3) or (number % 4)):
	print("{} is even and can be divided by both 3 and 4".format(number))
	elif number > 10:
	print("{} is even and greater than 10".format(number))
	print("Finished") # rest of the program

	l = [1, 2, 3]

	def outer_func():
	l = [4, 5, 6]

	def inner_func_a():
	l = [7, 8, 9]
	print("Inside inner_func_a:", l)

	def inner_func_b():
	global l # will be looked up in top-most scope -> global
	print("Inside inner_func_b:", l)

	def inner_func_c():
	nonlocal l # looked up in nearest enclosing scope -> outer_func()
	print("Inside inner_func_c:", l)

	def inner_func_d():
	nonlocal l
	l = [10, 11, 12] # modify binding
	print("Inside inner_func_d:", l)

	def inner_func_e():
	nonlocal l
	l.append(42) # modify list
	print("Inside inner_func_e:", l)

	print("Before inner_func_* calls:", l)
	inner_func_a()
	print("After inner_func_a call:", l)
	inner_func_b()
	print("After inner_func_b call:", l)
	inner_func_c()
	print("After inner_func_c call:", l)
	inner_func_d()
	print("After inner_func_d call:", l)
	inner_func_e()
	print("After inner_func_e call:", l)

	print("Before outer_func call:", l)
	outer_func()
	print("After outer_func call:", l)

	def append_to(element, to=[]):
	to.append(element)
	return to

	my_list = append_to(12)
	print(my_list)

	my_other_list = append_to(42)
	print(my_other_list)

	# -- coding: utf-8 --
	welcome_message = "Hello world!"
	print(welcome_message)
	1 + 2