Introduction to Python for Digital Humanities

The Digital Humanities (DH) is an interdisciplinary field that brings together computational tools and methods with traditional disciplines in the humanities, such as history, literature, art history, linguistics, philosophy, and cultural studies. As the volume of digital cultural content grows—such as digitized manuscripts, historical records, social media posts, and multimedia archives—the need to process, analyze, and interpret these materials using digital tools becomes increasingly important.

Why Use Python in the Digital Humanities?

Python has emerged as a key language in DH because it is:

• Easy to Read and Write: Python’s clean syntax makes it approachable, especially for scholars without a computer science background.
• Widely Supported: Python has a vibrant global community and extensive online documentation, tutorials, and forums.
• Rich in Libraries: There are many ready-to-use libraries for working with text, data, images, sound, and even geographic information.
• Flexible and Powerful: Python can be used for small tasks like file renaming, or large-scale tasks like building full text analysis pipelines or interactive web applications.
• Interoperable: Python can work with many different file formats (e.g., CSV, XML, JSON, PDF, images) and integrate with other tools commonly used in humanities research.

Practical Applications of Python in DH

Using Python, digital humanists can:

• Analyze Large Text Corpora: Quickly process thousands of pages to extract keywords, count word frequencies, detect sentiment, or classify genres.
• Explore Historical Patterns: Visualize trends over time using data from newspapers, census records, or personal letters.
• Build Digital Exhibits: Combine historical images, audio clips, and data visualizations in an interactive website.
• Transcribe and Clean Data: Automate OCR cleanup, remove metadata noise, or reformat archival information.
• Perform Network Analysis: Study connections between people, places, or concepts across time using network graphs.
• Map Cultural Content: Use Python’s geospatial libraries to create maps that show the spread of artistic movements, migration patterns, or historical events.

Real-World Examples:

• Text Mining: Identify recurring phrases and topics in a century’s worth of digitized books.
• Social Media Analysis: Study public sentiment and discourse during key cultural or political events.
• Metadata Curation: Automatically extract, clean, and organize metadata from thousands of image or document files.
• Historical Visualization: Animate the rise and fall of empires using historical timelines and geographic data.
• Interactive Archives: Create searchable digital editions of rare manuscripts using Python web frameworks.

By learning Python, researchers in the humanities gain a set of tools to extend their traditional methods, handle complex datasets, and share their work in innovative and engaging ways.

Introduction to JupyterLab

JupyterLab is an interactive computing environment that allows you to create and share documents containing live code, equations, visualizations, and narrative text. It is commonly used in data science, research, and education, especially for projects in the Digital Humanities, because of its flexibility and ease of use. JupyterLab is essentially an upgrade of Jupyter Notebooks, providing a more modular and feature-rich interface.

Key Features of JupyterLab:

• Code cells: These are cells where you write and execute code.
• Markdown cells: These cells are used for explanatory text, formatted using Markdown.
• Rich outputs: Visualizations, graphs, images, and other media can be displayed inline within the notebook.
• File management: JupyterLab has a built-in file browser that allows you to organize and manage notebooks, text files, images, and other resources.

How to Add Cells in JupyterLab

In JupyterLab, cells are the building blocks of your notebook. You can add, delete, and modify cells to create a flow between code execution and explanatory text.

Adding Cells:

1. Via Menu: Navigate to the top menu: Insert → Insert Cell Below or Insert → Insert Cell Above.

2. Keyboard Shortcuts: Press B to insert a cell below the current one or A to insert a cell above.

3. Clicking Buttons: Use the “+” button in the toolbar to insert new cells.

Switching Between Cell Types (Code and Markdown):

You can switch between code cells and markdown cells to organize your content effectively.

1. To Change a Cell Type to Code:

• Select the cell and press Y.
• Alternatively, click on the Cell Type dropdown menu in the toolbar (where “Markdown” is by default) and select Code.

2. To Change a Cell Type to Markdown:

• Select the cell and press M.
• Alternatively, use the Cell Type dropdown and select Markdown.

This allows you to seamlessly switch between running code and writing descriptive text.

Running and Stopping Cells

Cells in JupyterLab can either be run (executed) or stopped, depending on whether you want to see the result of the code.

1. Running Cells: To execute a cell, you can:

• Windows/Linux: Press Shift + Enter to run the current cell and move to the next.

• Mac: Press Shift + Enter to run the current cell and move to the next. You can also use command + Enter to run the cell and stay in that cell.

• Alternatively, click the Run button in the toolbar.

2. Stopping a Cell: If you want to stop the execution of a cell:

• Navigate to Kernel → Interrupt in the top menu or use the Stop button in the toolbar.

• Alternatively, use the keyboard shortcut I twice (press I quickly two times) to interrupt the current execution.

The Kernel in JupyterLab

The kernel is the engine behind your notebook, it runs your Python code and remembers what you’ve done.

When you press Shift + Enter to run a cell, the kernel executes that code and gives you a result (a number, a list, a graph, etc.).

Understanding [ ], [*], and [1] in Jupyter Cells

Every time you run a code cell, you’ll see a number appear inside square brackets next to the cell, like this:

print("Hello")

Hello

Here’s what those brackets mean:

[ ] — The cell has not been run yet.

[*] — The code is currently running (kernel is busy).

[1], [2], … — The number shows the order in which you ran the cells.

For example:

If you see [5] next to a cell, it means this was the fifth cell you ran.

If a cell is stuck on [*], it might be taking a long time or be stuck — you can stop it using Kernel → Interrupt.

Common Kernel Actions:

1. Run code: Shift + Enter
2. Interrupt kernel: Stop a running cell (especially useful if stuck on [*])
3. Restart kernel: Clears everything the kernel remembers (variables, imports, etc.)

Use Kernel → Restart if things get messy or confusing — then rerun your cells from the top to start fresh.

Built-in Functions and Documentation

Python provides a wide range of built-in functions—these are standard, preloaded tools that help with common tasks. They require no additional libraries or installations and are available immediately when you run Python.

What Are Built-in Functions?

A built-in function is a function that is always available in Python. These are designed to simplify common programming tasks. For instance, rather than writing your own code to calculate the length of a string, you can use len().

Built-in functions improve productivity and reduce the need for writing code from scratch for basic operations.

Common Built-in Functions and What They Do:

• print(): Displays text or variable output.
• len(): Returns the number of items in an object (string, list, etc.).
• type(): Returns the data type of a variable (e.g., int, str).
• int(), float(), str(): Convert between data types.
• range(): Produces a sequence of numbers, often used in loops.
• sum(): Adds numbers in a list or iterable.
• sorted(): Returns a new list containing all items from the iterable in ascending order.
• max() / min(): Finds the largest or smallest value in a dataset.

# Example 1: Basic text output
print("Welcome to Digital Humanities")

# Example 2: Working with a string
sentence = "Humanities meet computation"
print("Length of sentence:", len(sentence))

# Example 3: Check data type
number = 42
print("Data type:", type(number))

# Example 4: Sorting a list
years = [1850, 2023, 1945, 1789]
print("Sorted years:", sorted(years))

# Example 5: Using range and sum
print("Sum from 1 to 5:", sum(range(1, 6)))  # 1+2+3+4+5 = 15

Welcome to Digital Humanities
Length of sentence: 27
Data type: <class 'int'>
Sorted years: [1789, 1850, 1945, 2023]
Sum from 1 to 5: 15

Exploring Python Documentation

Learning how to explore the documentation is key to becoming self-sufficient in Python.

Python provides tools for this: - help() function - The ? syntax in Jupyter Notebooks

help(str)

Help on class str in module builtins:

class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to 'utf-8'.
 |  errors defaults to 'strict'.
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __format__(self, format_spec, /)
 |      Return a formatted version of the string as described by format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __sizeof__(self, /)
 |      Return the size of the string in memory, in bytes.
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  capitalize(self, /)
 |      Return a capitalized version of the string.
 |
 |      More specifically, make the first character have upper case and the rest lower
 |      case.
 |
 |  casefold(self, /)
 |      Return a version of the string suitable for caseless comparisons.
 |
 |  center(self, width, fillchar=' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  count(self, sub[, start[, end]], /)
 |      Return the number of non-overlapping occurrences of substring sub in string S[start:end].
 |
 |      Optional arguments start and end are interpreted as in slice notation.
 |
 |  encode(self, /, encoding='utf-8', errors='strict')
 |      Encode the string using the codec registered for encoding.
 |
 |      encoding
 |        The encoding in which to encode the string.
 |      errors
 |        The error handling scheme to use for encoding errors.
 |        The default is 'strict' meaning that encoding errors raise a
 |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and
 |        'xmlcharrefreplace' as well as any other name registered with
 |        codecs.register_error that can handle UnicodeEncodeErrors.
 |
 |  endswith(self, suffix[, start[, end]], /)
 |      Return True if the string ends with the specified suffix, False otherwise.
 |
 |      suffix
 |        A string or a tuple of strings to try.
 |      start
 |        Optional start position. Default: start of the string.
 |      end
 |        Optional stop position. Default: end of the string.
 |
 |  expandtabs(self, /, tabsize=8)
 |      Return a copy where all tab characters are expanded using spaces.
 |
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |
 |  find(self, sub[, start[, end]], /)
 |      Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].
 |
 |      Optional arguments start and end are interpreted as in slice notation.
 |      Return -1 on failure.
 |
 |  format(self, /, *args, **kwargs)
 |      Return a formatted version of the string, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  format_map(self, mapping, /)
 |      Return a formatted version of the string, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  index(self, sub[, start[, end]], /)
 |      Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].
 |
 |      Optional arguments start and end are interpreted as in slice notation.
 |      Raises ValueError when the substring is not found.
 |
 |  isalnum(self, /)
 |      Return True if the string is an alpha-numeric string, False otherwise.
 |
 |      A string is alpha-numeric if all characters in the string are alpha-numeric and
 |      there is at least one character in the string.
 |
 |  isalpha(self, /)
 |      Return True if the string is an alphabetic string, False otherwise.
 |
 |      A string is alphabetic if all characters in the string are alphabetic and there
 |      is at least one character in the string.
 |
 |  isascii(self, /)
 |      Return True if all characters in the string are ASCII, False otherwise.
 |
 |      ASCII characters have code points in the range U+0000-U+007F.
 |      Empty string is ASCII too.
 |
 |  isdecimal(self, /)
 |      Return True if the string is a decimal string, False otherwise.
 |
 |      A string is a decimal string if all characters in the string are decimal and
 |      there is at least one character in the string.
 |
 |  isdigit(self, /)
 |      Return True if the string is a digit string, False otherwise.
 |
 |      A string is a digit string if all characters in the string are digits and there
 |      is at least one character in the string.
 |
 |  isidentifier(self, /)
 |      Return True if the string is a valid Python identifier, False otherwise.
 |
 |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
 |      such as "def" or "class".
 |
 |  islower(self, /)
 |      Return True if the string is a lowercase string, False otherwise.
 |
 |      A string is lowercase if all cased characters in the string are lowercase and
 |      there is at least one cased character in the string.
 |
 |  isnumeric(self, /)
 |      Return True if the string is a numeric string, False otherwise.
 |
 |      A string is numeric if all characters in the string are numeric and there is at
 |      least one character in the string.
 |
 |  isprintable(self, /)
 |      Return True if all characters in the string are printable, False otherwise.
 |
 |      A character is printable if repr() may use it in its output.
 |
 |  isspace(self, /)
 |      Return True if the string is a whitespace string, False otherwise.
 |
 |      A string is whitespace if all characters in the string are whitespace and there
 |      is at least one character in the string.
 |
 |  istitle(self, /)
 |      Return True if the string is a title-cased string, False otherwise.
 |
 |      In a title-cased string, upper- and title-case characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |
 |  isupper(self, /)
 |      Return True if the string is an uppercase string, False otherwise.
 |
 |      A string is uppercase if all cased characters in the string are uppercase and
 |      there is at least one cased character in the string.
 |
 |  join(self, iterable, /)
 |      Concatenate any number of strings.
 |
 |      The string whose method is called is inserted in between each given string.
 |      The result is returned as a new string.
 |
 |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
 |
 |  ljust(self, width, fillchar=' ', /)
 |      Return a left-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  lower(self, /)
 |      Return a copy of the string converted to lowercase.
 |
 |  lstrip(self, chars=None, /)
 |      Return a copy of the string with leading whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  partition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string.  If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing the original string
 |      and two empty strings.
 |
 |  removeprefix(self, prefix, /)
 |      Return a str with the given prefix string removed if present.
 |
 |      If the string starts with the prefix string, return string[len(prefix):].
 |      Otherwise, return a copy of the original string.
 |
 |  removesuffix(self, suffix, /)
 |      Return a str with the given suffix string removed if present.
 |
 |      If the string ends with the suffix string and that suffix is not empty,
 |      return string[:-len(suffix)]. Otherwise, return a copy of the original
 |      string.
 |
 |  replace(self, old, new, /, count=-1)
 |      Return a copy with all occurrences of substring old replaced by new.
 |
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |
 |  rfind(self, sub[, start[, end]], /)
 |      Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].
 |
 |      Optional arguments start and end are interpreted as in slice notation.
 |      Return -1 on failure.
 |
 |  rindex(self, sub[, start[, end]], /)
 |      Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].
 |
 |      Optional arguments start and end are interpreted as in slice notation.
 |      Raises ValueError when the substring is not found.
 |
 |  rjust(self, width, fillchar=' ', /)
 |      Return a right-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  rpartition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing two empty strings
 |      and the original string.
 |
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the substrings in the string, using sep as the separator string.
 |
 |        sep
 |          The separator used to split the string.
 |
 |          When set to None (the default value), will split on any whitespace
 |          character (including \n \r \t \f and spaces) and will discard
 |          empty strings from the result.
 |        maxsplit
 |          Maximum number of splits.
 |          -1 (the default value) means no limit.
 |
 |      Splitting starts at the end of the string and works to the front.
 |
 |  rstrip(self, chars=None, /)
 |      Return a copy of the string with trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the substrings in the string, using sep as the separator string.
 |
 |        sep
 |          The separator used to split the string.
 |
 |          When set to None (the default value), will split on any whitespace
 |          character (including \n \r \t \f and spaces) and will discard
 |          empty strings from the result.
 |        maxsplit
 |          Maximum number of splits.
 |          -1 (the default value) means no limit.
 |
 |      Splitting starts at the front of the string and works to the end.
 |
 |      Note, str.split() is mainly useful for data that has been intentionally
 |      delimited.  With natural text that includes punctuation, consider using
 |      the regular expression module.
 |
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the string, breaking at line boundaries.
 |
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |
 |  startswith(self, prefix[, start[, end]], /)
 |      Return True if the string starts with the specified prefix, False otherwise.
 |
 |      prefix
 |        A string or a tuple of strings to try.
 |      start
 |        Optional start position. Default: start of the string.
 |      end
 |        Optional stop position. Default: end of the string.
 |
 |  strip(self, chars=None, /)
 |      Return a copy of the string with leading and trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  swapcase(self, /)
 |      Convert uppercase characters to lowercase and lowercase characters to uppercase.
 |
 |  title(self, /)
 |      Return a version of the string where each word is titlecased.
 |
 |      More specifically, words start with uppercased characters and all remaining
 |      cased characters have lower case.
 |
 |  translate(self, table, /)
 |      Replace each character in the string using the given translation table.
 |
 |        table
 |          Translation table, which must be a mapping of Unicode ordinals to
 |          Unicode ordinals, strings, or None.
 |
 |      The table must implement lookup/indexing via __getitem__, for instance a
 |      dictionary or list.  If this operation raises LookupError, the character is
 |      left untouched.  Characters mapped to None are deleted.
 |
 |  upper(self, /)
 |      Return a copy of the string converted to uppercase.
 |
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |
 |      The string is never truncated.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  maketrans(x, y=<unrepresentable>, z=<unrepresentable>, /)
 |      Return a translation table usable for str.translate().
 |
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.

This gives detailed information about how to work with strings.

str?

This brings up a quick help popup describing the str class.

You can also combine help with other functions:

help(len)

Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.

This shows how the len() function works and what types it supports.

Libraries and Modules

Python’s strength lies in its standard library and external packages—collections of modules that offer specialized functionality. A module is simply a file containing Python definitions and statements. A library is a collection of modules that can be imported and used in your programs.

Why Libraries Matter:

They save time and provide tested, optimized tools for: - Text processing - Data handling - Visualization - Machine learning - File and network operations

Importing Modules

To use a module, you import it into your Python script:

import math
print(math.sqrt(16))  # Output: 4.0

4.0

You can also import specific functions or classes:

from math import pi, sin
print(pi)         # Output: 3.141592653589793
print(sin(pi/2))  # Output: 1.0

3.141592653589793
1.0

Or give a library module an alias:

import numpy as np
array = np.array([1, 2, 3])
array

array([1, 2, 3])

Built-in Python Libraries

Python comes with a rich standard library — a collection of modules and packages that are bundled with Python itself. This means you don’t need to install anything extra to start using them. They’re always available whenever you run Python, making it super convenient to perform many common programming tasks right out of the box.

random : Generate random numbers

Useful for creating random data, games, simulations, or selecting random elements.

import random
print(random.randint(1, 10))  # Random number between 1 and 10

10

datetime — Work with dates and times

Easily get the current date/time or perform date calculations.

import datetime
now = datetime.datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))

2025-06-03 09:30:37

os — Interact with your computer’s operating system

Get info about files, directories, environment variables, or execute system commands.

import os

print(os.getcwd())  # Current working directory
print(os.listdir()) # List files in the current directory

/home/marie/parvus/prog/dhsi/2025_dhsi/monday
['day1_afternoon_completed.quarto_ipynb', '.jupyter_cache', 'index.qmd', 'day1_afternoon.ipynb', 'day1_afternoon_completed.qmd', 'wb_hss_prog_slides.qmd', 'day1_afternoon_completed.ipynb', 'day1_afternoon.qmd']

External Libraries

While Python’s built-in libraries cover a lot, many advanced tasks require specialized tools, this is where external libraries come in. These are packages developed by the Python community (or companies) and shared through the Python Package Index (PyPI). You usually install them using the package manager pip.

What Are External Libraries?

• They extend Python’s capabilities beyond the standard library.
• Provide tools for data science, machine learning, web development, image processing, automation, and much more.
• They often come with many modules and sub-packages bundled together, making them powerful libraries.

Installing External Libraries

Normally, you install external libraries using the command line:

pip install library-name

For example:

pip install numpy pip install pandas pip install matplotlib

Most popular external libraries used for data science and scientific computing come pre-installed in JupyterLab environments such as: - Anaconda distribution (a popular Python distribution for data science) - Cloud platforms like Google Colab - Many managed JupyterHub setups

This means when you open a notebook in JupyterLab, you can often import and use libraries like numpy, pandas, and matplotlib immediately, no extra installation required.

Let’s see some examples of these libraries:

numpy — Fast numerical computing

Provides powerful arrays and mathematical functions.

import numpy as np

arr = np.array([1, 2, 3])
print(arr * 2)  # [2 4 6]

[2 4 6]

pandas — Data manipulation and analysis

Makes working with tabular data easy.

import pandas as pd

data = {'Name': ['Alice', 'Bob'], 'Age': [25, 30]}
df = pd.DataFrame(data)
print(df)

    Name  Age
0  Alice   25
1    Bob   30

matplotlib — Data visualization

Create charts and graphs.

import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y = [10, 20, 25, 30]

plt.plot(x, y)
plt.title("Simple Line Plot")
plt.show()