Basics of Programming

Python variables are very similar to how variables are used in R. The primary difference is that instead of using ← or → to assign variables, Python uses a single =.

Python has a few key differences from R in regards to variable behavior. Information on variable assignment in Python can be found in the Variable Assigment section below.

Similar to other programming languages Python has several core variable types. Overview of each variable type are included below:

This declares a variable with a value of 4.

One of the most important differences between variables in R and Python is what is happening in the background. Take the code example below:

The first chunk of code behaves as you’d expect because int values are immutable, meaning the values cannot be changed. As a result, when we assign my_var = my_var + 1, my_vars value isn’t changing. Instead my_var is just being pointed to a different value (in this case 5). In comparison new_variable still points to the value of 4.

The second chunk of code is different because it is dealing with a mutable list. We first assign the first value (0 index) of the list to a value of 4. We then assign my_var to new_variable. Unlike the first example, this does not copy the values. Instead both my_var and new_variable point to the same mutable list object. When we then change the value of the list by 1 the change is reflected in each variable since they are pointing to the same object.

An excellent article goes into more detail and can be found here.

None is a keyword used to define a null value. This would be the Python equivalent to R’s NULL. If used in an if statement, None represents False. This does not mean None == False, in fact:

Even though None can represent False in an if statement Python does not evaluate the two as equivalent.

The difference between NaN and None in Python can be somewhat confusing. The NaN value stand for not a number and is commonly used to reference missing data. Python will often convert None values to NaN dynamically, especially when working with numbers. There are lots of methods to identify and remove or fill NaN values, but it is worth noting that Python will evaluate them with no issues for many operations.

For example, if I wanted to sum the rows below and then remove any NaN values we could try the initial code snippet.

However, Python would evaluate this as the table below:

If we were to try to remove NaN values based on the example_sum column no rows would be removed. In this case we’d want to remove or fill the Nan values prior to the aggregation (sum).

A bool has two possible values: True and False. It is important to understand that technically they also correspond to integers:

The True and False values only correspond to 1 and 0 respectively. They will not evaulate in the same way for other numbers:

However, if used in an if statement numbers that do not equal 1 or 0 can evaulate to True. Think of the if statement below as asking the question Does this value equal 3? and returning True or False as a result.

str indicate string in Python. String are "immutable sequences of Unicode code points". Strings can be surrounded in single quotes, double quotes, or triple quoted (with either single or double quotes):

The benefit of triple quoting a string is that it can span multiple lines in the code. These lines will include the whitespace between the text:

However, if we tried the same thing without triple quotes:

In Python you do have the ability for other code to span multiple lines using \, but newlines won’t be maintained:

int values are whole numbers. For instance:

int values can be added, subtracted, or multiplied without changing the variable type. However, divison of int values will change the variable type to float whether or not the result of the division is a whole number:

Similarly, any calculation between an int and a float results in a float:

float values are floating point numbers. Also known as numbers with decimals.

float values can be converted back to int using the int function. This coercion causes the float value to be truncated, regardless of how close to the "next" number the float is. Note: This will not round a number in the way that you would expect. There are round functions in Python that have the more expected functionality.

complex values represent complex numbers. For example, j can be used to represent an imaginary number. In order for Python to understand this j must be preceded by a number. For example 1j.

Arithmetic with a complex value always results in a complex:

Unlike the other types mentioned above, you cannot convert a complex value to an int or float:

Let’s try another example. Let’s execute the command x = "Hello World", and have the variable x hold a string. You can use the type function in Python to check what data type your object is.

If you wanted to get the length of the string, you could use the len function.

Now let’s say we wanted to divide two integers and then check what the resulting data type is

If you wanted to return an integer, you can use the '//' operator which returns an integer.

Logical operators in Python evaluate Boolean expressions (True/False values) and return a result based on the operator used.

Let’s demonstrate how you can perform arithmetic operations.

Now, let’s use the input() function to prompt the user to enter a number. Input() returns a string, so you need to convert it to an integer using int() to perform arithmetic operations:

You can have a user input a second integer, and assign it to a variable named num2:

Now let’s add the values of num1 and num2 and print a string that says: The sum of the two numbers is: [result here]

We will use the following dataset(s) to explore data types.

/anvil/projects/tdm/data/flights/subset/airports.csv

Reading the Data

The beginning step of most projects is reading a file and storing it. We can use the Pandas library and use read_csv, which reads in .csv files and outputs a DataFrame. A DataFrame is the star of the pandas package. Many of our pandas guides are simply building blocks for understanding DataFrames.

The standard practice for DataFrames is reading a file and saving it, taking a glimpse at its contents, and using a wide variety of methods to manipulate the data to achieve whatever goal you have.

As with any package, we must import the pandas library, and the customary import statement is import pandas as pd. Let’s use read_csv to save the file "airports.csv" into the variable myDF:

Now let’s examine the first five rows of our DataFrame to understand the structure of our data using the .head() function, including the available columns and the information they contain.

Now let’s examine the last five rows of our DataFrame using the .tail() function.

Examining the Data Types of the Dataset

We can display the dataset information, using the .info() function which returns the data types and columns of the dataset.

From the output above, we can observe that our dataset contains seven columns, with their data types listed under Dtype. The columns 'iata', 'airport', 'city', 'state', and 'country' are categorized as object types, while 'lat' and 'long' are float variables. In Python, particularly when working with pandas, the object data type is used as a container for various types of Python objects, including strings. Pandas generally classifies columns containing textual data as objects. We can convert the object columns into strings.

Handling Missing Values

Before performing data conversion, let’s identify missing values in the dataset. Missing values in numeric or textual columns can lead to issues during data type conversion so it’s good to check before we start to do data type conversion.

We can see that the columns city and state have NA values. Let’s replace missing Values with a placeholder like "Missing":

Changing Data Types

Next, let’s explore how to change data types using astype(). Let’s convert the object variables to strings. The lat and long variables can remain unchanged, as the float data type is suitable for them.