Lists, files and numerical work

Engineering data comes in quantity: a load test with hundreds of readings, a year of hourly flows, the coordinates of every node in a truss. This final chapter gives you the tools to hold, read, process and plot that data. It covers Python's lists and dictionaries, reading and writing files, and then the NumPy library, which turns Python into a serious numerical tool. The examples bring together the course and much of first year: fitting a line to test data to find Young's modulus, integrating flow measurements, solving the three-cable system from Statics with one line of code, and simulating cooling with Euler's method.

Lists

A list is an ordered collection of values in square brackets. Lists can hold any type, can grow and shrink, and are the everyday container for a series of readings.

strain = [612, 655, 701, 748, 790, 823, 845, 812, 776, 731]
print(len(strain), strain[0], strain[-1])
print(strain[2:5], strain[:3])
strain.append(702)
print(len(strain), sum(strain) / len(strain))
print(min(strain), max(strain), sorted(strain)[:3])

10 612 731
[701, 748, 790] [612, 655, 701]
11 745.0
612 845 [612, 655, 701]

Indexing starts at 0, so strain[0] is the first item and strain[9] the tenth; negative indexes count from the end, so strain[-1] is the last. A slice a[start:stop] takes items from start up to but not including stop, the same convention as range(). Methods change a list in place: append() adds an item, insert() puts one at a position, remove() deletes the first matching value, and sort() sorts the list itself (sorted() returns a sorted copy and leaves the original alone).

List comprehensions

A list comprehension builds a new list by applying an expression to each item of another, optionally with a condition. It replaces a common three-line loop with one readable line.

pressures_psi = [100, 150, 250]
pressures_kPa = [round(p * 6.894757, 1) for p in pressures_psi]
print(pressures_kPa)

strain = [612, 655, 701, 748, 790, 823, 845, 812, 776, 731]
high = [s for s in strain if s > 800]
print(high)

Output: [689.5, 1034.2, 1723.7] and [823, 845, 812].

Dictionaries

A dictionary maps keys to values, like a lookup table. It is ideal for material properties, section tables, or any data where you look things up by name rather than by position.

E_MPa = {"steel": 200000, "aluminium": 69000, "timber": 11000}

material = "aluminium"
print(f"E for {material}: {E_MPa[material]} MPa")

E_MPa["concrete"] = 25000            # add an entry
for name, E in E_MPa.items():
    print(f"{name:<10}{E:>8}")

Looking up a key that is not there raises a KeyError; E_MPa.get("glass") returns None instead, and "glass" in E_MPa tests whether the key exists. (The moduli here are typical textbook values; real design uses the values specified in the governing standard for the particular grade.)

Reading and writing files

Data usually arrives in files, most often CSV (comma-separated values), which every spreadsheet, data logger and database can produce. Python's with open(...) statement opens a file and guarantees it is closed afterwards, and the csv module handles splitting lines into fields correctly.

Files are where real-world data is messiest: missing values, extra spaces, units in the header, a summary line at the bottom. Always look at a few lines of a new data file before writing code to read it, and check the number of rows read against what you expect.

NumPy: arrays and vectorized calculation

NumPy is the foundation of scientific Python. Its array type holds numbers of one type in a compact block of memory, and arithmetic on an array applies to every element at once, without writing a loop. This vectorized style is shorter, closer to the mathematics, and typically tens to hundreds of times faster than a Python loop for large data.

import numpy as np

strain = np.array([612, 655, 701, 748, 790, 823, 845, 812, 776, 731])
stress_MPa = 200000 * strain * 1e-6      # E times strain, every element at once
print(stress_MPa)
print(strain.mean(), strain.max(), np.std(strain, ddof=1))
print(strain[strain > 800])              # boolean selection

x = np.linspace(0, 6, 4)                 # 4 evenly spaced points from 0 to 6
print(x)

[122.4 131.  140.2 149.6 158.  164.6 169.  162.4 155.2 146.2]
749.3 845 75.50136128279777
[823 845 812]
[0. 2. 4. 6.]

Three habits make NumPy work well. Import it as np (the universal convention). Prefer whole-array operations to loops. And notice the difference between the two kinds of standard deviation: np.std divides by n by default, while ddof=1 divides by n − 1, the sample standard deviation used for test data.

Fitting a line: Young's modulus from a test

np.polyfit(x, y, 1) finds the straight line that best fits data in the least-squares sense (the method you met in MATH-125). For a tensile test, the slope of extension against load gives the stiffness, and from it Young's modulus.

Integrating measured data

Many engineering quantities are integrals of measured rates: volume from flow rate, energy from power, impulse from force. With data at discrete times, the trapezoidal rule (MATH-100, Lesson 5) approximates the integral by summing trapezoids between readings.

Solving linear systems

Systems of linear equations appear everywhere in engineering: truss and frame analysis, circuit analysis, heat flow, least squares. np.linalg.solve solves \(A\mathbf{x} = \mathbf{b}\) directly and reliably.

The same few lines solve systems of hundreds or thousands of equations, which is exactly what structural analysis software does when it analyzes a building frame. You now understand, in principle, what happens inside those programs.

Plotting

Matplotlib is the standard plotting library. A basic plot takes a handful of lines; always label axes with units and add a title or legend so the plot can stand on its own in a report (Lesson 4 of ENGG-160).

import numpy as np
import matplotlib.pyplot as plt

load_kN = np.array([0, 5, 10, 15, 20, 25, 30])
ext_mm = np.array([0.000, 0.045, 0.087, 0.134, 0.176, 0.222, 0.264])
slope, intercept = np.polyfit(load_kN, ext_mm, 1)

plt.plot(load_kN, ext_mm, "o", label="test data")
plt.plot(load_kN, slope * load_kN + intercept, "-", label="least-squares fit")
plt.xlabel("Load (kN)")
plt.ylabel("Extension (mm)")
plt.legend()
plt.savefig("tensile.png", dpi=150)      # or plt.show() to open a window

Simulation: Euler's method

Many engineering systems are described by differential equations: a tank draining, a beam vibrating, a circuit charging, a part cooling. When there is no neat formula for the solution, or even when there is, a program can step forward in time. Euler's method is the simplest scheme: if \(dy/dt = f(t, y)\), then over a small step \(\Delta t\), \(y_{new} = y + f(t, y)\,\Delta t\).

Where to go next

You now have the core of programming: values and types, decisions, loops, functions, collections, files and numerical libraries. From here, engineers typically add SciPy (optimization, integration, differential equations, signal processing), pandas (tables of data, like a programmable spreadsheet), and domain tools for their discipline. The habits matter more than the libraries: plan before coding, work in small steps, name things clearly with units, write functions with docstrings, test against hand calculations, and treat every result with an engineer's scepticism until it has been checked.