Mastering the Basics

Data skills | concepts¶

• Python

Learning objectives¶

1. Contruct variables, manipulate strings, and loop through lists
2. Build and navigate dictionaries
3. Define and use functions
4. Export data to .csv files

This tutorial is designed to support multi-session workshops hosted by The Ohio State University Libraries Research Commons. It is intended to help the ABSOLUTE beginner, or anyone who is relatively new to Python and working toward confidently applying their Python skills to research projects.

Getting started¶

Setup Python¶

A easy way to install Python and essential libraries is by dowloading Anaconda on your personal device. Anaconda is a Python distribution that simplifies package management and deployment. It comes preloaded with over 250 popular for data analysis and visualization—including Pandas, NumPy, and Matplotlib—and allows you to install, update, and manage packages without using the command line, making it especially user-friendly for beginners.

Setup IDE¶

Integrated Development Environments (IDEs) combine essential coding tools—like editors, terminals, and plugins—into as single application to streamline your workflow. Spyder, included with the Anaconda distribution, is tailored for scientists, engineers, and data analysts. Another excellent option is Visual Studio Code, a versatile IDE that offers real-time feedback as you build and refine your code. Both tools support interactive coding, data exploration and more, making them great choices for beginners and professionals alike.

Absolute vs relative paths¶

When you run a Python script the folder it runs from is set as the current working directory (cwd). This is where Python looks for files to read and write by default.

• In VS Code, you can set the working directory by clicking the Explorer icon on the top left of the Activity Bar. Open or create a file in your project folder, and Python will treat that location as the base for storing and accessing files.
• In Spyder, set the working directory by clicking the folder icon in the upper right corner of the Toolbar.

Relative paths¶

If your files are stored in the same folder as your Python script, you can use a relative path.

relative_filepath_of_text = "path.txt"

Python interprets this path relative to the current working directory.

Absolute paths¶

If your files are stored elsewhere, use an absolute path to specify the full location:

absolute_filepath_of_text = "C:/path/to/your/directory/file.txt"

Reading and writing files¶

Opening a file¶

To work with a file in Python, you first need to open it. This returns a file object that allows you to read from or write to the file.

Basic Syntax:

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• file: The path to the file (absolute or relative).
• mode: Optional. Specifies how the file is opened. Default is r (read mode).

Common file modes¶

Encoding¶

Use the encoding parameter when working in text mode to specify how characters are interpreted. Common encodings include:

• utf-8 — Most commonly used and recommended.
• utf-16 — Uses 2 bytes per character; useful for some international text.
• utf-32 — Uses 4 bytes per character; supports all Unicode characters directly.

Reading a file¶

To read a file, open it in read mode (r) and use the .read() method

Writing to a file¶

To write a file, open it in write mode (w). This will overwrite the file if it already exists.

If you don’t specify a mode, Python defaults to r (read mode), so it’s important to explicity set mode='w' when writing.

Again, this creates an object. To add text to a file, use the .write() method.

Now our file reads:

Variables¶

Python supports a variety of built-in data types, each suited for different kinds of information.

• Mutuable types: Lists, dictionaries, and strings can be modified after creation.
• Immutable types: Tuples cannot be changed once defined.

Working with variables¶

Variables are created using the = operator.

Naming rules¶

• Can include letters, digits, and underscores.
• Must not start with a digit.
• Cannot contain spaces or special characthers (except _).
• Must not use reserved Python keywords.

Reserved keywords¶

False, True, None, and, as, assert, async, await, def, del, elif, else, break, class, continue, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield

To check a variable’s type, use the type() function.

Basic math operators in Python¶

Python supports standard arithmetic operations such as addition, subtraction, multiplication, and division. A list of basic math operators is below. For more details, refer to Python’s documentation on math operators.

Example:

Working with strings¶

In Python, strings represent textual data and are enclosed in either single (') or double (") quotation marks:

'this is a string'
"this is also a string"

The opening and closing quotes much match.

Consider:
"The Readers' Advisory Guide to Horror Fiction"
'"Did you take the trash out?" she asked.'

To include special characthers like quotes within a string, use a backslash ( \ ) to escape them. This tells Python to ignore the character.

'The Readers\' Advisory Guide to Horror Fiction'

Assigning strings to variables¶

You can assign a string to a variable using the = operator:

String indexing and slicing¶

Python uses zero-based indexing, meaning the first character of a string is at position 0.

Access a single character¶

Slice a substring¶

To extract a portion of a string, use the following syntax:

string[start index:end index]

The start index is where the slice begins and the end index tells Python where to stop—but it does not include the character at that position.

Example:
Slice the word Brave from the string banned_book:

If the start index is not included, Python will automatically start the range at the 0 index position.

Negative Indexing¶

You can also access characters from the end of a string using negative indices:

Common string methods¶

🔗 For more, see Python String Methods documentation.

Examples:¶

1. Replace text in a string¶

Let’s try replacing the word praise in the first sentence of carmen_ohio with wonders using the replace method.

Basic Syntax

string.replace('old string', 'new string')

2. Normalize case¶

String methods like .lower() and .upper() are useful for standardizing text, especially when comparing values that may differ in capitalization.

Example:

3. Splitting strings¶

By default, .split() separates strings by spaces. You can also specify a delimiter, such as newline ‘\n’. This returns a list of lines, one for each row in the string.

If the delimiter is blank, a list of words is returned:

Conditionals and comparisons¶

Conditionals allow you to control the flow of your program by executing code only when certain conditions are met. Python uses if, elif, and else statements to evaluate whether something is True or False.

Example: Wilbur the Pig¶

Let’s say we want to:

• Print Wilbur’s name if he’s a pig.
• Compliment him if he’s handsome.
• Confirm if Charlotte is his best friend.

Step 1: Assign variables¶

Step 2: Create conditional statements¶

Using if, elif, and else¶

• if checks the first condition.
• elif (short for “else if”) checks additional conditions if the first is false.
• else runs if none of the previous conditions are met.

Comparison operators¶

wilbur_age=1
charlotte_age=4
farmer_age=42

print('IS WILBUR OLDER THAN CHARLOTTE?')

if wilbur_age > charlotte_age:
    print("Wilbur is older than Charlotte.")
else:
    print("Wilbur is younger than Charlotte.")

Logical operators¶

Use these to combine multiple conditions

Examples:¶

Is this Wilbur?

Using the in keyword¶

The in keyword checks if a substring exists within a string.

Lists and loops¶

A list is an ordered, mutable collection of items in Python. List are enclosed in square brackets [], and lists are separated by commas.

Lists can contain any data type—even other lists or dictionaries:

Accessing list items¶

Lists use zero-based indexing, just like strings. You can use slicing to extract elements:

list_name[start_index:stop_index:step]

Examples:¶

1. Extract the first item from the list characters:

2. Extract the last 3 items from the list characters:

3. Extract characters from the string han_solo:

Common list methods¶

Examples:¶

Using loops with lists¶

When working with lists, it’s a good practice to use plural names for your list variables. This makes your code easier to read and understand—especially when you’re iterating through each element.

Python’s for loop allows you to iterate over items in a sequence—such as a list, tuple, dictionary, or string—and execute a block of code for each item.

Basic Syntax

for item in sequence
     #Code to execute for each item

Examples:¶

1. Loop through the characters list.

2. Use slicing to print names of the last 3 characters:

3. Use conditional statements to add a comment for each character:

Note the line f"{character} is a robot" in the first conditional statement of the loop. This is known as an f-string, short for formatted string literal.

An f-string is created by placing the letter f directly before the opening quotation mark of a string. This allows you to embed variables or expressions inside the string using curly braces {}. Python will automatically evaluate the expression and insert its value into the string.

presidents=["Edward Francis Baxter Orton Sr","Walter Quincy Scott","William Henry Scott","James Hulme Canfield","William Oxley Thompson",
            "George Washington Rightmire","William McPherson","Howard Landis Bevis","Novice Gail Fawcett","Harold Leroy Enarson",
            "Edward Harrington Jennings","E. Gordon Gee","John Richard Sisson","William English Kirwan","Edward Harrington Jennings",
            "Karen Ann Holbrook","Joseph A. Alutto","E. Gordon Gee","Joseph A. Alutto","Michael V. Drake","Kristina M. Johnson",
            "Peter J. Mohler",'Walter "Ted" Carter, Jr.']


for president in presidents:
    print(president)

Index or enumerate list items¶

There are several ways to determine the index position of items in a list.

.index()¶

One way is to use a for loop with the built-in .index() method. This method returns the first occurence of a specified value in the list.

Here’s an example using list of Ohio State University presidents.

.enumerate()¶

A more common and efficient approach is to use the built-in enumerate() function within a for loop.

The enumerate() function returns both the index and the item as you iterate through the list, making your code more readable and avoiding potential issues with methods like .index(), which only returns the first occurrence of a value.

Why use enumerate()?¶

• It’s more efficient than calling .index() inside a loop.
• It handles duplicate values correctly by giving the actual position in the list.
• It improves readability and reduces the chance of logical errors.

This example asks Python to return two variables from the presidents list, the index position and the president.

This example uses an f-string to make the returned print statement more clear.

Keep in mind that Python uses zero-based indexing, meaning the first item in a list has an index of 0. To make the output more user-friendly—especially when displaying positions—you can add 1 to each index so that counting starts at 1.

To enhance the script further, you can use a conditional statement to append a superscript to each number (like 1ˢᵗ, 2ⁿᵈ, 3ʳᵈ, etc.), making the output more polished and readable.

Building lists with loops¶

You can create new lists from existing ones by using a for loop along with the .append() method. This is a common and effective way to filter or transform data in Python.

Example: Finding U.S. States That Border the Pacific Ocean¶

Suppose you have a list of U.S. states and want to create a new list containing only those that border the Pacific Ocean. You can do this by checking each state and appending the matching ones to a new list:

Counting items in a list¶

Knowing how many items are in a list is especially helpful when working with data—such as extracting information from a website or querying a database.

In Python, you can determine the number of elements in a list using the built-in len() function.

Using Counter Variables¶

While Python provides built-in tools like enumerate() and the .index() method to find the position of items in a list, there are times when using a counter variable can be a simple and effective alternative.

A counter variable allows you to manually track the position of items as you loop through a list. This can be especially useful when you need more control over how positions are counted or displayed.

List Comprehensions¶

List comprehensions offer a compact way to create new lists by combining a for loop and an optional if condition—all in a single line of code.

Basic Syntax

[expression for item in iterable if condition]

Instead of writing this longer version:

Dictionaries¶

A dictionary is a collection of unordered, changeable (mutable) key-value pairs. Each key is unique and maps to a specific value. Dictionaries are enclosed in curly braces {}, with each key and value separated by a colon : and each pair separated by a comma.

Accessing dictionary data¶

Keys¶

Use .keys() to get a list of all keys.

Values¶

Use .values() to get a list of all values.

Access a value¶

Use the key inside square brackets

Modifying and adding data¶

• Add a new key-value pair

Start with an empty dictionary:¶

You can begin with an empty dictionary and add key-value pairs as needed.

Modify an existing value¶

To update a value in a dictionary, use the dictionary name followed by the key in square brackets, then assign a new value using the equals sign (=).

Nesting dictionaries¶

Dictionaries can contain other dictionaries, allowing for more complex data structures.

Access a nested dictionary¶

To access the first state in the dictionary states, use the key for "state1.

Access a nested value¶

To access the nicknames*for the first state in the dictionary states, use the keys for state1 and nicknames.

Looping through a dictionary¶

Python provides several ways to iterate through the contents of a dictionary, depending on what you need to access:

1. Loop through key-value pairs¶

Use the .items() method to access both keys and their corresponding values:

2. Loop through keys only¶

Use the .keys() method to iterate over just the keys.

3. Loop through the values only¶

Use the .values() method to iterate over just the values.

Each method gives you flexibility depending on whether you need the keys, the values, or both.

Looping through a nested dictionary¶

When working with nested dictionaries—dictionaries that contain other dictionaries as values—you can use a nested for loop to access the inner keys and values.

Explanation:¶

• The first loop (for outer_key, inner_dict in states.items()) iterates through the outer dictionary.
• The second loop (for inner_key, inner_value in inner_dict.items()) goes through each inner dictionary.

This approach allows you to access and work with all levels of data in a nested structure.

Examples:¶

Functions in Python¶

Python includes many built-in functions that help you perform common tasks, such as:

• print() – displays output
• type() – returns the data type of a value
• enumerate() – adds a counter to an iterable

In addition to these, you can also define your own functions to perform specific tasks. This is especially useful when you need to reuse the same block of code multiple times in a program.

What is a function?¶

A function is a reusable block of code designed to perform a particular task. Functions help make your code more organized, readable, and efficient.

Defining a function¶

To define a function, use the def keyword, followed by the function name, parentheses (), and a colon :. The code inside the function is indented.

Calling a function¶

To call or execute a function, simply write its name followed by parentheses.

Arguments and parameters¶

When defining a function, you can include parameters inside the parentheses. These parameters act as placeholders for values that will be passed into the function when it’s called. This allows your function to work dynamically with different inputs.

In this example:

• name is a parameter—a variable defined in the function header.
• When the function is called, you provide an argument—a specific value that replaces the parameter.

Calling the function with an argument¶

This makes your function flexible and reusable with different inputs.

Parameters vs. arguments¶

• A parameter is a variable listed inside the parentheses when defining a function. It acts as a placeholder for the value the function will receive.

• An argument is the actual value you pass into the function when calling it.

Positional vs. keyword arguments¶

When calling a function in Python, you can pass arguments in two main ways: positional and keyword.

1. Positional arguments¶

By default, Python matches arguments to parameters based on their position in the function call. The first argument is assigned to the first parameter, the second to the second, and so on.

2. Keyword arguments¶

With keyword arguments, you explicitly specify which value goes to which parameter using the parameter=value syntax. This removes the dependency on the order of arguments.

Return Values from Functions¶

So far, we’ve used print() to display output from functions. However, functions can also return values using the return statement. This allows you to store the result and use it later.

Returning values is useful when you want to process data and use the result elsewhere in your program.

Common Python Errors¶

Making mistakes is a natural part of learning Python. Don’t worry—error messages are your friends! They help you understand what went wrong and how to fix it.

🔴 SyntaxError¶

Example messages:

• SyntaxError: EOL while scanning string literal
• SyntaxError: invalid syntax

This error usually means:

• You forgot a colon : at the end of a control structure like a for loop or if statement.
• You left a string unclosed (missing a quotation mark).

Export data to a .csv file¶

You can export data to a .csv file in Python using either the built-in csv module or the powerful Pandas library. Here’s how to do both:

Method 1: Using the csv module¶

import csv

#####     STEP 1 - CREATE EMPTY DATASET AND DEFINE CSV HEADINGS     ##### 
dataSet=[]
columns=['institution_name','year_founded','school_colors','mascot','students','endowment'] # for CSV headings

#####     STEP 2 - DEFINE FUNCTION TO WRITE RESULTS TO CSV FILE     #####


def writeto_csv(data,filename,columns):
    with open(filename,'w+',newline='',encoding="UTF-8") as file:
        writer = csv.DictWriter(file,fieldnames=columns)
        writer.writeheader()
        writer = csv.writer(file)
        for element in data:
            writer.writerows([element])

#####     STEP 3 - ADD A ROW OF DATA     #####
institution_name= "The Ohio State University" 
year_founded = 1870
school_colors = "scarlet & grey"
mascot = "Brutus Buckeye"
students = 60046
endowment = 7.9

dataSet.append([institution_name,year_founded,school_colors,mascot,students,endowment])

#####     STEP 4 - EXPORT TO CSV     #####
writeto_csv(dataSet,'data/university_facts.csv',columns)

Method 2: Using Pandas¶

import pandas as pd

#####     STEP 1 - CREATE DATAFRAME TO STORE ROWS     #####
results=pd.DataFrame(columns=['institution_name','year_founded','school_colors','mascot','students','endowment'])

#####     STEP 2 - DEFINE EACH ROW AS A DICTIONARY    #####
university_facts = {"institution_name": "The Ohio State University", 
                    "year_founded" : 1870, 
                    "school_colors" : "scarlet & grey", 
                    "mascot" : "Brutus Buckeye", 
                    "students" : 60046, 
                    "endowment": 7.9 }

#####     STEP 3 - CONVERT EACH DICTIONARY ROW TO A DATAFRAME    #####
add_row_to_results=pd.DataFrame(university_facts, index=[0])

#####     STEP 4 - CONCATENATE RESULTS EACH ROW TO RESULTS DATAFRAME    #####
results=pd.concat([add_row_to_results, results], axis=0, ignore_index=True)

#####     STEP 5 - EXPORT THE RESULTS DATAFRAME TO A CSV FILE    #####
results.to_csv('data/university_facts.csv', encoding='utf-8')