Python for Engineers

Python is a high-level, interpreted, object-oriented, general-purpose language created by Guido van Rossum. Its popularity in engineering comes from its simple syntax, powerful libraries, and direct applicability to scientific computing and AI.

Let's write our first program! In your VS Code, Spyder, or py3roid, type:

print("Hello, I can write program!!")

Congratulations — you are officially a programmer now! 🎉

Now, dear engineers, let's move forward together. Put a piece of paper in front of you and imagine you're solving a civil engineering problem. How would you define parameters on paper? Obviously, with variables:

# Integer variable
x = 5
y = 10

# String variable
name = "Shayan"

# Float variable
pi = 3.14

print(x)       # 5
print(name)    # Shayan

Basic data types: (click the cards)

Python has three main number types: integer (int), float, and complex. For engineering, the first two are the most relevant.

Example — a simple calculation:

a = 10
b = 3

print(a + b)   # 13
print(a - b)   # 7
print(a * b)   # 30
print(a / b)   # 3.3333...
print(a // b)  # 3  (integer division)
print(a % b)   # 1  (remainder)
print(a ** b)  # 1000 (power)

3D rotating cube of math operators — hover to speed it up

Remember how you became a programmer with a single message? We write all our messages as strings, using either " " or ' '. There is also a dedicated constructor (str()) which we'll get to later.

name = "Shayan"
full = 'Civil Engineer'

print(name + " Dolat Yari")
print("=" * 20)
print(len(name))   # 6

# f-string — modern formatting
age = 25
print(f"My name is {name} and I am {age}")

Booleans are logical values with only two states: False and True — or, as we say informally, equivalent to 0 and 1. I wrote them in that order so you'd get it. 😄

a = 10
b = 20

print(a > b)     # False
print(a < b)     # True
print(bool(0))      # False
print(bool(1))      # True

We have several operator types that you should compare with the symbols you use on paper. Fortunately, most of them match the standard engineering notation.

Arithmetic operators:

Comparison operators:

Logical operators:

"To be, or not to be — that is the question!" — and this Shakespeare quote is always True. 😄

a = 5
b = 10

print(a > 0 and b > 0)   # True
print(a > 100 or b > 0)  # True
print(not (a > 0))          # False

Before we discuss conditions, remember: a condition activates only when the evaluated value is boolean and it must be True for us to enter the conditional body.

The conditional body is indented by 4 spaces or one Tab. And what do we need before writing a condition? Operators! So if you're unsure, review the previous lesson first.

A condition begins with if and ends with a colon :. If it's not satisfied, we can use elif (short for else if). If we simply have two branches, we use else.

age = 20

if age >= 18:
    print("You are an adult")
elif age >= 13:
    print("You are a teenager")
else:
    print("You are a child")

Engineering example — checking a concrete beam's safety:

stress = 250   # stress in MPa
limit  = 300   # allowable stress

if stress < limit:
    print("✅ Safe")
elif stress == limit:
    print("⚠️ At the limit")
else:
    print("❌ Danger")

Python has two main loop types: the conditional loop and the counted (for) loop.

For loop:

# Print numbers from 1 to 5
for i in range(1, 6):
    print(i)

names = ["Ali", "Sara", "Reza"]
for name in names:
    print(name)

While loop:

i = 1
while i <= 5:
    print(i)
    i += 1   # equivalent to i = i + 1

Engineering example — average of 5 stress samples:

stresses = [240, 255, 260, 245, 250]
total = 0

for s in stresses:
    total += s

avg = total / len(stresses)
print(f"Average = {avg} MPa")

With input() we can ask the user to provide input and store it in a variable.

# Get name
name = input("Enter your name: ")
print(f"Hello, {name}!")

# Get number (must be converted)
age = int(input("Enter your age: "))
print(f"Next year you will be {age + 1}")

height = float(input("Enter your height (m): "))

Functions in Python are used when we want to build an algorithm and call it whenever needed, avoiding repetition of loops, conditions, and so on.

Functions are reusable code blocks defined with the keyword def.

# Simple function
def greet(name):
    print(f"Hello, {name}!")

greet("Shayan")

# Function with return value
def add(a, b):
    return a + b

result = add(5, 3)
print(result)   # 8

# Function with default argument
def power(base, exp=2):
    return base ** exp

print(power(5))       # 25
print(power(2, 3))    # 8

Engineering example — area of a circular section:

import math

def circle_area(r):
    return math.pi * r ** 2

print(circle_area(5))   # 78.5398...

Data comes in two flavors:

• Local — lists, tuples, dictionaries, and so on
• Global — files, CSV files, server-side data, datasets, and so on

Python has four main local data structures:

# List
fruits = ["apple", "banana", "cherry"]
fruits.append("orange")

# Dictionary
person = {"name": "Shayan", "age": 25}
print(person["name"])   # Shayan

# Set
nums = {1, 2, 2, 3, 3}
print(nums)   # {1, 2, 3}

Python has extremely powerful libraries essential for engineering and scientific work. We import them with import.

import math

print(math.sqrt(16))    # 4.0
print(math.sin(0))      # 0.0
print(math.pi)           # 3.14159...

def hypotenuse(a, b):
    return math.sqrt(a ** 2 + b ** 2)

print(hypotenuse(3, 4))   # 5.0

For visualizing data and engineering results, we use the matplotlib library.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(x, y, color="cyan", linewidth=2)
plt.title("Sine Wave")
plt.xlabel("x")
plt.ylabel("sin(x)")
plt.grid(True)
plt.show()

Engineering example — stress-strain curve:

import matplotlib.pyplot as plt

strain = [0, 0.001, 0.002, 0.003, 0.004]
stress = [0, 50, 100, 150, 200]

plt.plot(strain, stress, marker="o")
plt.title("Stress-Strain Curve")
plt.xlabel("Strain")
plt.ylabel("Stress (MPa)")
plt.grid(True)
plt.show()

OOP is a programming paradigm in which data and behavior are organized into "objects". In Python, everything is an object — numbers, strings, lists, even functions.

Suppose we want to design a car and our company is "Eng. Dolat Yari's Company". To build a general system and structure — with us as the manufacturer — and then export cars that other engineers can import into their own programs with import, we turn to OOP.

Defining a class and creating an object:

class Student:
    # Constructor
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"My name is {self.name}, I am {self.age}")

# Create an object
s1 = Student("Shayan", 25)
s1.introduce()

Inheritance:

class Engineer(Student):
    def __init__(self, name, age, field):
        super().__init__(name, age)   # call parent constructor
        self.field = field

    def introduce(self):   # method override
        print(f"I am {self.name}, a {self.field} engineer")

e1 = Engineer("Shayan", 25, "Civil")
e1.introduce()

Engineering example — concrete beam class:

class Beam:
    def __init__(self, length, width, height):
        self.length = length
        self.width = width
        self.height = height

    def volume(self):
        return self.length * self.width * self.height

    def weight(self, density=2500):   # kg/m³ for concrete
        return self.volume() * density

b = Beam(5, 0.3, 0.5)
print(f"Volume: {b.volume()} m³")
print(f"Weight: {b.weight()} kg")