# Introduction to Python¶

## Goals:¶

• Learn basic Python operations

• Understand differences in data structures

• Get familiarized with conditional statements and loops

• Learn to create custom functions and import python modules

Main Reference: McKinney, Wes. Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython. O’Reilly Media. Kindle Edition

## Indentation¶

Python code is structured by indentation (tabs or spaces) instead of braces which is what other languages normally use. In addition, a colon (:) is used to define the start of an indented code block.

for x in list(range(5)):
print("One number per loop..")
print(x)
if x > 2:
print("The number is greater than 2")
print("----------------------------")


## Everything is an Object¶

• Everything in Python is considered an object.

• A string, a list, a function and even a number is an object.

• For example, you can define a variable to reference a string and then access the methods available for the string object.

• If you press the tab key after the variable name and period, you will see the methods available for it.

a = "pedro"

a.capitalize()


## Variables¶

In Python, when you define/create a variable, you are basically creating a reference to an object (i.e string,list,etc). If you want to define/create a new variable from the original variable, you will be creating another reference to the original object rather than copying the contents of the first variable to the second one.

a = [1,2,3]
b = a
b


Therefore, if you update the original variable (a), the new variable (b) will automatically reference the updated object.

a.append(4)
b


A variable can have a short name (like x and y) or a more descriptive name (age, dog, owner). Rules for Python variables:

• A variable name must start with a letter or the underscore character

• A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )

• Variable names are case-sensitive (age, Age and AGE are three different variables)

Reference:https://www.w3schools.com/python/python_variables.asp

dog_name = 'Pedro'
age = 3
is_vaccinated = True
birth_year = 2015

is_vaccinated

dog_name


## Data Types¶

As any other object, you can get information about its type via the built-in function type().

type(age)

type(dog_name)

type(is_vaccinated)


## Combining variables and operations¶

x = 4
y = 10

x-y

x*y

y/x

y**x

x>y

x==y

y>=x


## Binary Operators and Comparisons¶

2+4

5*6

5>3


## The Respective Print statement¶

print("Hello Helk!")


## Control Flows¶

References:

• https://docs.python.org/3/tutorial/controlflow.html

• https://docs.python.org/3/reference/compound_stmts.html#the-if-statement

### If,elif,else statements¶

• The if statement is used for conditional execution

• It selects exactly one of the suites by evaluating the expressions one by one until one is found to be true; then that suite is executed.

• If all expressions are false, the suite of the else clause, if present, is executed.

print("x = " + str(x))
print("y = " + str(y))

if x==y:
print('yes')
else:
print('no')

• An if statement can be optionally followed by one or more elif blocks and a catch-all else block if all of the conditions are False :

if x==y:
print('They are equal')
elif x > y:
print("It is grater than")
else:
print("None of the conditionals were true")


## Loops¶

### For¶

The for statement is used to iterate over the elements of a sequence (such as a string, tuple or list) or other iterable object.

my_dog_list=['Pedro',3,True,2015]

for i in range(0,10):
print(i*10)


### While¶

A while loop allows you to execute a block of code until a condition evaluates to false or the loop is ended with a break command.

i = 1
while i <= 5:
print(i ** 2)
i += 1

i = 1
while i > 0:
if i > 5:
break
print(i ** 2)
i += 1


## Data structures¶

References:

• https://docs.python.org/3/tutorial/datastructures.html

• https://python.swaroopch.com/data_structures.html

### Lists¶

• Lists are data structures that allow you to define an ordered collection of items.

• Lists are constructed with square brackets, separating items with commas: [a, b, c].

• Lists are mutable objects which means that you can modify the values contained in them.

• The elements of a list can be of different types (string, integer, etc)

my_dog_list=['Pedro',3,True,2015]

my_dog_list[0]

my_dog_list[2:4]

print("My dog's name is " + str(my_dog_list[0]) + " and he is " + str(my_dog_list[1]) + " years old.")

• The list data type has some more methods an you can find them here.

• One in particular is the list.append() which allows you to add an item to the end of the list. Equivalent to a[len(a):] = [x].

my_dog_list.append("tennis balls")

my_dog_list

• You can modify the list values too:

my_dog_list[1] = 4
my_dog_list


### Dictionaries¶

• Dictionaries are sometimes found in other languages as “associative memories” or “associative arrays”.

• Dictionaries are indexed by keys, which can be any immutable type; strings and numbers can always be keys.

• It is best to think of a dictionary as a set of key: value pairs, with the requirement that the keys are unique (within one dictionary).

• A pair of braces creates an empty dictionary: {}.

• Remember that key-value pairs in a dictionary are not ordered in any manner. If you want a particular order, then you will have to sort them yourself before using it.

my_dog_dict={'name':'Pedro','age':3,'is_vaccinated':True,'birth_year':2015}

my_dog_dict

my_dog_dict['age']

my_dog_dict.keys()

my_dog_dict.values()


### Tuples¶

• A tuple consists of a number of values separated by commas

• On output tuples are always enclosed in parentheses, so that nested tuples are interpreted correctly; they may be input with or without surrounding parentheses, although often parentheses are necessary anyway (if the tuple is part of a larger expression).

my_dog_tuple=('Pedro',3,True,2015)

my_dog_tuple

• Tuples are immutable, and usually contain a heterogeneous sequence of elements that are accessed via unpacking or indexing.

• Lists are mutable, and their elements are usually homogeneous and are accessed by iterating over the list.

my_dog_tuple[1]


## Slicing¶

You can select sections of most sequence types by using slice notation, which in its basic form consists of start:stop passed to the indexing operator []

seq = [ 7 , 2 , 3 , 7 , 5 , 6 , 0 , 1 ]
seq [ 1 : 5 ]


## Functions¶

Functions allow you to organize and reuse code blocks. If you repeat the same code across several conditions, you could make that code block a function and re-use it. Functions are declared with the def keyword and returned from with the return keyword:

def square(n):
return n ** 2

print("Square root of 2 is " + str(square(2)))

number_list = [1,2,3,4,5]

for number in number_list:
sn = square(number)
print("Square root of " + str(number) + " is " + str(sn))


## Modules¶

References:

• https://docs.python.org/3/tutorial/modules.html#modules

• If you quit from the Python interpreter and enter it again, the definitions you have made (functions and variables) are lost.

• Therefore, if you want to write a somewhat longer program, you are better off using a text editor to prepare the input for the interpreter and running it with that file as input instead.

• Let’s say we define two functions:

def square(n):
return n ** 2

def cube(n):
return n ** 3

• You can save the code above in a file named math.py. I created the file for you already in the current folder.

• All you have to do is import the math_ops.py file

import math_ops

for number in number_list:
sn = square(number)
cn = cube(number)
print("Square root of " + str(number) + " is " + str(sn))
print("Cube root of " + str(number) + " is " + str(cn))
print("-------------------------")

• You can get a list of the current installed modules too

help('modules')

• Let’s import the datetime module.

import datetime

• Explore the datetime available methods. You can do that by typing the module name, a period after that and pressing the tab key or by using the the built-in functionn dir() as shown below:

dir(datetime)

• You can also import a module with a custom name

import datetime as dt

dir(dt)

['MAXYEAR',
'MINYEAR',
'__builtins__',
'__cached__',
'__doc__',
'__file__',
'__name__',
'__package__',
'__spec__',
'date',
'datetime',
'datetime_CAPI',
'sys',
'time',
'timedelta',
'timezone',
'tzinfo']