Interactive Session 1C

A cartoon depicting the idea of a variable. MidJourney 5

Understanding the types of variables and the methods available for different objects is crucial for effective programming in Python. This guide will walk you through how to determine the type of a variable and explore the methods you can use with various objects.

Getting Started

Before we begin our interactive session, please follow these steps to set up your Jupyter Notebook:

Open JupyterLab and create a new notebook:
- Click on the + button in the top left corner
- Select Python 3.10.0 from the Notebook options (it should be the third option)
Rename your notebook:
- Right-click on the Untitled.ipynb tab (see the note below if you have trouble!)
- Select “Rename”
- Name your notebook with the format: Session_1C_Variables_and_Strings.ipynb

Right-clicking in JupyterLab

Some browsers and operating system combinations will not conceded right-clicking to the JupyterLab interface and will show a system menu when you try to right click. In those cases, usually CTRL-Right Click or OPTION-Right Click will bring up the Jupyter menu.

Add a title cell:
- In the first cell of your notebook, change the cell type to “Markdown”
- Add the following content (replace the placeholders with the actual information):

# Day 1: Session C - Variables & Strings

[Session Webpage](https://eds-217-essential-python.github.io/course-materials/interactive-sessions/1c_variables_strings.html)

Date: 09/03/2024

Add a code cell:
- Below the title cell, add a new cell
- Ensure it’s set as a “Code” cell
- This will be where you start writing your Python code for the session
Throughout the session:
- Take notes in Markdown cells
- Copy or write code in Code cells
- Run cells to test your code
- Ask questions if you need clarification

Caution

Remember to save your work frequently by clicking the save icon or using the keyboard shortcut (Ctrl+S or Cmd+S).

Let’s begin our interactive session!

Variable Types

In Python, everything is an object. Each object has a specific type, and knowing the type of a variable helps you understand what operations and methods you can perform on it.

Determining Variable Type

To find out the type of a variable, you can use the type() function. This function returns the type of the object passed to it.

Code

# Define some variables
number = 42
text = "Hello, World!"
pi = 3.14159
data = [1, 2, 3, 4, 5]

# Determine the type of each variable
print(type(number))
print(type(text))
print(type(pi))
print(type(data))

<class 'int'>
<class 'str'>
<class 'float'>
<class 'list'>

Built-in Types

Here are some common built-in types in Python:

int: Represents integers.
float: Represents floating-point numbers.
str: Represents strings.
list: Represents lists, which are ordered collections of items.

Exploring Methods

Once you know the type of an object, you can discover the methods available for that object. Methods are functions that belong to an object and can be used to perform operations on the data contained within the object.

Discovering Methods

You can use the dir() function to list all the attributes and methods available for an object. This function returns a list of the object’s attributes and methods, including special methods (also known as “dunder” methods) that begin and end with double underscores.

Code

# List all methods and attributes of a string object
string_methods = dir(text)
print(string_methods)

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

Filtering User-Facing Methods

While dir() lists all methods, you often only need user-facing methods. You can filter out special methods by ignoring those with double underscores.

Code

# Filter out special methods
user_methods = [method for method in dir(text) if not method.startswith('__')]
print(user_methods)

['capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

Using Methods

Now that you’ve discovered the methods available for an object, let’s see how to use them. Here are some examples with strings and lists.

String Methods

Strings in Python have various methods for text manipulation. Let’s look at a few commonly used methods.

Example: `upper()`, `lower()`, and `replace()`, `strip()`

Code

text = " Hello, World!  "

# Convert to uppercase
print(text.upper())

# Convert to lowercase
print(text.lower())

# Replace a substring
print(text.replace("World", "Python"))

# Remove leading and trailing whitespace, including tabs and newlines
print(text.strip())

 HELLO, WORLD!  
 hello, world!  
 Hello, Python!  
Hello, World!

Advanced Example: String Normalization

In this section, we’ll explore how to normalize strings using built-in Python string methods. String normalization is a common task in data processing and can involve operations like converting text to lowercase, removing extra whitespace, and replacing spaces with other characters. For example, in R, the janitor package is often used to normalize dataframe columns names.

Basic String Normalization

Let’s start with a simple example of string normalization:

Code

# A string with mixed case and extra spaces
original = "  Hello, World!  "

# Normalize the string using the .strip() method to remove whitespace 
# and the .lower() method to convert to lowercase
normalized = original.strip().lower()

print(f"Original: '{original}'")
print(f"Normalized: '{normalized}'")

Original: '  Hello, World!  '
Normalized: 'hello, world!'

In this example, we used two string methods: - strip(): Removes leading and trailing whitespace - lower(): Converts the string to lowercase

Advanced String Normalization

Now, let’s look at a more comprehensive approach to string normalization:

Code

# Examples of strings to normalize
examples = [
    "Hello World",
    "  Python Programming  ",
    "STRING NORMALIZATION\n",
    "  Trim  Spaces  ",
    "\tTabs and Newlines\n"
]

print("String Normalization Examples:")
print("==============================")

for original in examples:
    # Normalize the string:
    # 1. Remove leading/trailing whitespace and newlines
    # 2. Convert to lowercase
    # 3. Replace internal whitespace with underscores
    normalized = original.strip().lower().replace(" ", "_")
    
    print(f"Original: '{original}'")
    print(f"Normalized: '{normalized}'")
    print()

String Normalization Examples:
==============================
Original: 'Hello World'
Normalized: 'hello_world'

Original: '  Python Programming  '
Normalized: 'python_programming'

Original: 'STRING NORMALIZATION
'
Normalized: 'string_normalization'

Original: '  Trim  Spaces  '
Normalized: 'trim__spaces'

Original: ' Tabs and Newlines
'
Normalized: 'tabs_and_newlines'

In this advanced example, we:

Start with strip() to remove all leading and trailing whitespace, including spaces, tabs, and newlines.
Use lower() to convert the string to lowercase.
Finally, apply replace(" ", "_") to substitute internal spaces with underscores.

Exercise

Now it’s your turn to practice! Modify the code below to normalize the given strings according to these rules:

Remove leading and trailing whitespace
Convert to uppercase (instead of lowercase)
Replace spaces with hyphens

Code

strings_to_normalize = [
    "data science",
    "  MACHINE learning ",
    "Artificial Intelligence\t",
    " Natural\nLanguage Processing "
]

print("Your Normalized Strings:")
print("========================")

for string in strings_to_normalize:
    # Your normalization code here
    normalized = string  # Replace this line with your normalization steps!
    
    print(f"Original: '{string}'")
    print(f"Normalized: '{normalized}'")
    print()

Your Normalized Strings:
========================
Original: 'data science'
Normalized: 'data science'

Original: '  MACHINE learning '
Normalized: '  MACHINE learning '

Original: 'Artificial Intelligence  '
Normalized: 'Artificial Intelligence    '

Original: ' Natural
Language Processing '
Normalized: ' Natural
Language Processing '

Try experimenting with different normalization techniques or adding your own strings to the list!

List Methods

Lists also have several useful methods for data manipulation. Here are some examples.

Example: `append()`, `remove()`, and `sort()`

Code

numbers = [3, 1, 4, 1, 5, 9]

# Append an item
numbers.append(2)
print(numbers)

# Remove an item
numbers.remove(1)  # Removes the first occurrence of 1
print(numbers)

# Sort the list
numbers.sort()
print(numbers)

[3, 1, 4, 1, 5, 9, 2]
[3, 4, 1, 5, 9, 2]
[1, 2, 3, 4, 5, 9]

Special Methods

Special methods, also known as “dunder” (double underscore) methods, allow you to define the behavior of your objects for built-in operations. For example, __init__ is used for initializing objects, and __str__ defines the string representation.

While important, these are generally more advanced and used in object-oriented programming, so we will not focus on them in this introductory course.

Conclusion

This guide has introduced you to determining variable types and exploring the methods available for different objects in Python. By understanding how to discover and use methods, you’ll be better equipped to manipulate data and build powerful programs.

Feel free to experiment with the code examples interactively in your Jupyter notebook to deepen your understanding.

End interactive session 1C

Getting Started

Variable Types

Determining Variable Type

Built-in Types

Exploring Methods

Discovering Methods

Filtering User-Facing Methods

Using Methods

String Methods

Example: upper(), lower(), and replace(), strip()

Advanced Example: String Normalization

Basic String Normalization

Advanced String Normalization

Exercise

List Methods

Example: append(), remove(), and sort()

Special Methods

Conclusion

Example: `upper()`, `lower()`, and `replace()`, `strip()`

Example: `append()`, `remove()`, and `sort()`