Slides | Scicho

My Research and Passion

Wed, 15 Jan 2025 00:00:00 +0000

My Research and Passion

Seyed Sadjad Abedi-Shahri

Faculty of Engineering, University of Isfahan

About Me

🎓 Background:
- BSc in Mechanical Eng.
- MSc and PhD in Biomedical Eng.
💼 Current Position:
- Assistant Professor of Biomedical Engineering

Research Interests

Numerical Methods ( , )

(go down to see details)

Numerical Methods (FEM)

Linear and Nonlinear Problems
Viscoelastic and Hyperelastic Materials
Impact Simulation
Buckling and Post-Buckling Analysis
Homogenization Techniques
Tools: ABAQUS, LS-DYNA, and Open-Source Solutions

Numerical Methods (SBFEM)

Developing formulation for specific problems
Linear and Nonlinear Problems
Viscoelastic and Hyperelastic Materials
Tools: In-house program for 2D Viscoelastic and Nonlinear Problems

Scientific Computing

Developing Research Software
Best Practices in Research Software Engineering (RSE)
Contribution to Open-Source Programs
Implementation in Fields of PDEs, Matrix Computations, etc.
Scientific Visualization
Tools: Python, Fortran, Octave/MATLAB

Computational (Bio)Mechanics

Nonlinear Solid Mechanics
Soft & Hard Tissue Biomechanics
Trauma Biomechanics
Image-Based Simulations
Impact Mechanics (Low & High velocity)
Fracture Mechanics
Topology Optimization
Inverse Problems

Computational Geometry

Mesh Generation and Optimization
Computational Topology in Meshing
Image-Based Mesh Generation
Delaunay and Voronoi-Based Methods

Machine Learning for Biomedical Applications

Data-driven Surrogate Models
Artificial Neural Networks for PDEs
Selected applications in Biomedical Image Processing

Some Examples of Projects

(go down to see details)

Scaled Boundary Finite Element Method (SBFEM)

Head Trauma

pyPolyMesher

is a python package for generating unstructured polygonal meshes in arbitrarily defined 2D domains. It allows users to mathematically specify domains using signed distance functions (SDFs).

QTREEMESH

is a python package that can create a Quadtree structure from an image. The Quadtree algorithm in this package is based on pixels’ intensity.

Bone Microcracks

Generation of bone RVE with random osteons and microcracks (using ABAQUS & python script) for homogenization problem

Composite Design Assistant(ComDA)

Composite Design Assistant(ComDA) is a scientific toolbox that provides a straightforward framework for industrial and academic analysis and design of composite structures.

Machine Learning for Biomedical Applications

Ongoing Projects

Finite Strain Viscoelasticty in SBFEM
Neural Network-Based Inverse Model for Cornea
DL in Pulmonary Vascular Histological Images

Collaboration & Contact

🤝 Open to research collaborations

📧

🌐

🔗

👨‍💻

Thank You! 🎤

Session 1: Introduction to Python

Fri, 15 Mar 2024 00:00:00 +0000

Session 1: Introduction to Python

Instructor :

Introduction to Programming

Programming is the process of creating a set of instructions or logic that can be understood and executed by a computer to perform a specific task or solve a problem. It involves breaking down complex problems into smaller, more manageable steps that the computer can follow.

Programming languages are the tools used to communicate instructions to computers. They provide a structured way to express algorithms, which are sets of rules or procedures for solving problems. Different programming languages have their own syntax (rules for writing code) and semantics (meaning of the code).

Why Learn Programming?

Problem-solving: Programming teaches logical thinking and problem-solving skills.
Career opportunities: Programming skills are in high demand across various industries.
Automation: Programming allows you to automate repetitive tasks, saving time and increasing productivity.
Creation: Programming empowers you to create software applications, websites, games, and other digital products.
Understanding technology: Having a basic understanding of programming helps you better comprehend the technologies you use daily.

What is Python?

Python is a popular, high-level, general-purpose programming language known for its simplicity, readability, and versatility. It was created by Guido van Rossum in the late 1980s and first released in 1991.

Key Features of Python

Easy to learn: Python has a clean and straightforward syntax that emphasizes readability, making it easy for beginners to learn and understand.
Interpreted: Python is an interpreted language, which means that its code is executed line by line without the need for a separate compilation step, allowing for faster development and testing cycles.
Cross-platform: Python code can run on various operating systems, including Windows, macOS, and Linux, without requiring significant modifications.

Dynamically-typed: Python is a dynamically-typed language, which means that variable types are determined during runtime, providing flexibility and reducing development time.
Extensive libraries: Python has a vast collection of standard and third-party libraries and frameworks that cover a wide range of applications, from web development to data analysis, machine learning, and more.
Open-source: Python is an open-source language, which means its source code is freely available for use, modification, and distribution, fostering a strong community of developers.

Python Applications

Web Development: Python is widely used for building web applications and frameworks like Django, Flask, and Pyramid.
Data Analysis and Scientific Computing: Libraries like NumPy, Pandas, Matplotlib, and SciPy make Python a powerful tool for data analysis, manipulation, and visualization.
Artificial Intelligence and Machine Learning: Popular libraries like TensorFlow, Keras, and scikit-learn enable Python for AI and machine learning applications.

Automation and Scripting: Python’s simplicity and cross-platform compatibility make it an excellent choice for automating tasks and writing scripts.
Game Development: With libraries like Pygame and Panda3D, Python can be used to create games.
Education and Prototyping: Python’s readability and ease of use make it a popular choice for teaching programming and building prototypes.

Setting up the Python Environment

To start programming in Python, you need to set up the Python environment on your computer. This involves installing the Python interpreter and an Integrated Development Environment (IDE) or a code editor. In this bootcamp, we will be using the Anaconda distribution and the Spyder IDE.

Anaconda Distribution

Anaconda is a popular open-source distribution of Python and other data science packages. It comes bundled with Python, the Conda package manager, and various pre-installed libraries and tools for data science, machine learning, and scientific computing.

To install Anaconda, follow these steps:

Go to the official Anaconda website ( ) and download the latest version of Anaconda for your operating system (Windows, macOS, or Linux).
Run the downloaded installer and follow the prompts to complete the installation process.

After the installation is complete, you will have access to the Anaconda Navigator, which is a graphical user interface (GUI) that allows you to launch applications and manage conda packages, environments, and channels.

Spyder IDE

Spyder (Scientific Python Development Environment) is a powerful IDE that comes bundled with Anaconda. It provides a user-friendly interface for writing, debugging, and executing Python code, as well as advanced features such as code completion, code exploration, and integration with popular scientific libraries like NumPy, SciPy, and Matplotlib.

To launch Spyder, you can either:

Open the Anaconda Navigator and click on the “Launch” button next to the Spyder application.
Open the Anaconda Prompt (on Windows) or the terminal (on macOS/Linux) and type spyder.

The Spyder IDE consists of three main panels:

Editor: This is where you write and edit your Python code.
IPython Console: This is an interactive Python shell where you can run code and see the output immediately.
Variable Explorer: This panel displays the variables and their values in your current workspace.

Python Syntax

Python’s syntax is designed to be simple, readable, and easy to learn. Here’s a quick overview of some essential syntax elements:

Comments

1# This is a single-line comment
2
3"""
4This is a
5multi-line comment
6"""

Indentation

Python uses indentation to define code blocks instead of curly braces or keywords like begin and end. Proper indentation is crucial for Python code to run correctly.

1if condition:
2 # Indented block
3 statement1
4 statement2
5else:
6 # Indented block
7 statement3

Variables

Variables in Python don’t need to be explicitly declared. You can assign values to variables directly.

1x = 5 # Integer
2y = 3.14 # Float
3name = "Sadjad Abedi" # String
4is_true = True # Boolean

Data Types

Python supports several built-in data types, including:

Numbers

Python supports two main types of numbers: integers and floating-point numbers.

1x = 31 # Integer
2y = 3.14 # Float
3z = 1 + 3j # Complex number

Strings

Strings in Python are sequences of characters enclosed in single quotes (’), double quotes ("), or triple quotes (’’’ or """).

1name = "Sadjad Abedi"
2message = 'Hello, World!'
3multiline = """This is
4a multiline
5string."""

Lists

Lists are ordered collections of items, which can be of different data types.

1fruits = ["apple", "banana", "cherry"] # List of strings
2numbers = [1, 2, 3, 4, 5] # List of integers
3mixed = [1, "apple", 3.14, True] # Mixed data types

List Operations

1len(fruits) # Get the length of the list
2fruits[0] # Access the first element
3fruits[-1] # Access the last element
4fruits[1:3] # Get a slice (from index 1 to 3)
5fruits.append("orange") # Add an element to the end
6fruits.insert(1, "kiwi") # Insert an element at a specific index
7fruits.remove("banana") # Remove the first occurrence of an element
8fruits.pop(2) # Remove the element at a specific index

Basic Input/Output Operations

Python provides several built-in functions for handling input and output operations, allowing you to interact with users and work with files.

Input

The input() function is used to get user input from the console or terminal. It takes an optional prompt string as an argument and returns the user’s input as a string.

1name = input("Enter your name: ")
2print("Hello, " + name)

By default, input() returns a string.

If you need to work with other data types, such as integers or floats, you can use type conversion functions like int() or float().

1age = int(input("Enter your age: "))
2weight = float(input("Enter your weight (kg): "))

Output

The print() function is used to display output to the console or terminal.

1print("Hello, World!")

You can print multiple values by separating them with commas, and you can customize the separator and end characters using the sep and end parameters, respectively.

1print("Apple", "Banana", "Cherry", sep=", ") # Output: Apple, Banana, Cherry
2print("Hello", end="")
3print("World") # Output: HelloWorld

File Operations

Python provides several functions and methods for working with files, including reading from and writing to files.

Writing to a File

To write to a file, you first need to open it in write mode (“w”) or append mode (“a”). Then, you can use the write() method to write data to the file.

1file = open("data.txt", "w") # Open a file for writing
2file.write("Hello, World!")
3file.close() # Don't forget to close the file

Reading from a File

To read from a file, you need to open it in read mode (“r”). Then, you can use methods like read() or readline() to read the contents of the file.

1file = open("data.txt", "r")
2content = file.read() # Read the entire file
3print(content)
4file.close()

Alternatively, you can use a for loop to read the file line by line.

1file = open("data.txt", "r")
2for line in file:
3 print(line.strip()) # Strip leading/trailing whitespace
4file.close()

Python also provides a convenient with statement to automatically handle opening and closing files.

1with open("data.txt", "r") as file:
2 content = file.read()
3 print(content)

Questions?

Session 2: Control Flow and Functions

Fri, 15 Mar 2024 00:00:00 +0000

Session 2: Control Flow and Functions

Instructor :

Control flow statements in Python allow you to control the order of execution of your code based on certain conditions or loops. These statements are essential for creating dynamic and flexible programs.

Conditional Statements

Conditional statements allow you to execute different blocks of code based on certain conditions. Python uses the if, elif (else if), and else statements for this purpose.

`if` Statement

The if statement executes a block of code if the specified condition is True.

1x = 5
2
3if x > 0:
4 print("x is positive")

`elif` Statement

The elif statement allows you to check for additional conditions if the previous conditions were False.

1x = 0
2
3if x > 0:
4 print("x is positive")
5elif x < 0:
6 print("x is negative")
7else:
8 print("x is zero")

`else` Statement

The else statement is executed if all the previous conditions in the if and elif statements were False.

1age = 18
2
3if age < 13:
4 print("You are a child")
5elif age < 20:
6 print("You are a teenager")
7else:
8 print("You are an adult")

Loops

Loops are used to repeat a block of code multiple times. Python provides two types of loops: for loops and while loops.

`for` Loop

The for loop is used to iterate over a sequence (such as a list, tuple, string, or range) or other iterable objects.

1fruits = ["apple", "banana", "cherry"]
2
3for fruit in fruits:
4 print(fruit)

You can also use the range() function to generate a sequence of numbers for the for loop.

1for i in range(5):
2 print(i) # Output: 0 1 2 3 4

`while` Loop

The while loop executes a block of code as long as the specified condition is True.

1count = 0
2while count < 5:
3 print(count)
4 count += 1 # Increment the counter

Loops can be nested (one loop inside another loop) to create more complex patterns or iterate over multi-dimensional data structures.

1for i in range(3):
2 for j in range(2):
3 print(f"({i}, {j})")

Functions

Functions are reusable blocks of code that perform a specific task. They help organize code into logical units, improve code readability, and promote code reuse. In Python, functions are defined using the def keyword, followed by the function name, parentheses for arguments, and a colon.

Defining Functions

Here’s the basic syntax for defining a function:

1def function_name(parameters):
2 """
3 Docstring: A brief description of what the function does.
4 """
5 # Function body
6 # Code to be executed
7 return value

def is the keyword used to define a function.
function_name is the name you give to the function (follow naming conventions).
parameters are optional inputs that the function can accept (separated by commas).
The """Docstring""" is a multi-line string that provides a brief description of the function (optional but recommended).
The function body is the block of code that will be executed when the function is called.
The return statement is used to return a value from the function (optional).

Example:

1def greet(name):
2 """
3 Prints a greeting message with the provided name.
4 """
5 print(f"Hello, {name}!")
6
7greet("Alice") # Output: Hello, Alice!

Calling Functions

To use a function, you need to call it by its name, followed by parentheses and any required arguments.

1result = my_function(argument1, argument2)

Functions can return values using the return statement, which can be assigned to variables or used in expressions.

1def add_numbers(a, b):
2 """
3 Returns the sum of two numbers.
4 """
5 return a + b
6
7sum = add_numbers(3, 5)
8print(sum) # Output: 8

Scope and Namespaces

In Python, variables and functions have a scope, which determines their visibility and accessibility within the program. Understanding scope and namespaces is crucial for managing variable names and avoiding naming conflicts.

Scope

The scope of a variable or function refers to the region of the code where it is accessible. Python has several types of scope:

Local Scope: Variables defined within a function are local to that function and cannot be accessed outside of it. Their scope is limited to the function in which they are defined.

Global Scope: Variables defined outside of any function or class are global and can be accessed from anywhere in the program, including within functions.
Built-in Scope: Names that are part of the Python language itself, such as print, len, and range, have a built-in scope and are always available.

Example:

1x = 10 # Global variable
2
3def my_function():
4 y = 5 # Local variable
5 print(x) # Accessing global variable
6 print(y)
7
8my_function() # Output: 10, 5
9print(y) # Error: y is not defined (outside the function scope)

Namespaces

While scope determines the visibility and accessibility of variables and functions, namespaces are mapping structures that associate names (identifiers) with objects (variables, functions, etc.). Python maintains several namespaces:

Built-in Namespace: Contains names of built-in functions, exceptions, and other objects. This namespace is always available.

Global Namespace: Contains names defined at the top level of a module or script. Variables and functions defined outside any function or class reside in this namespace.
Local Namespace: Contains names defined inside a function or class. Variables and functions defined within a function or class reside in this namespace.

When Python tries to resolve a name (e.g., a variable or function), it searches the namespaces in the following order:

Local Namespace
Enclosing Namespaces (if nested functions or classes)
Global Namespace
Built-in Namespace

The scope of a variable or function determines which namespace it belongs to and where it can be accessed. The namespaces themselves are the structures that store and map these names to their corresponding objects.

Introducing CodeWars

CodeWars is an educational online platform that helps developers improve their coding skills through practice and gamification. It provides a vast collection of coding challenges, also known as “katas”, which cover a wide range of programming languages and concepts.

What are Katas?

Katas are coding challenges that range in difficulty from beginner to expert level. Each kata presents a problem statement and a set of requirements that you must fulfill by writing code that passes a series of test cases. Katas are designed to help you practice your problem-solving skills, learn new language features, and improve your coding proficiency.

Getting Started with CodeWars

To get started with CodeWars, follow these steps:

Sign Up: Visit the CodeWars website ( ) and create an account.
Choose a Language: Select the programming language you want to practice. CodeWars supports many popular languages, including Python, Java, JavaScript, C#, and more.

Browse Katas: Explore the available katas by difficulty level or topic. You can filter katas based on your preferences or search for specific keywords.
Attempt a Kata: Click on a kata to view its problem statement and requirements. CodeWars provides an online code editor where you can write and test your solution.

Submit Your Solution: Once you’ve written your code, submit it to the CodeWars platform. Your solution will be tested against a set of test cases, and you’ll receive feedback on whether it passed or failed.
Learn from Others: CodeWars allows you to view other users’ solutions to the same kata. You can learn from these solutions and gain insights into different problem-solving approaches.

Optionally, You can join the Clan “Scicho” by setting this name as clan name in your profile. You can also follow the instructor using this Link:

There is also a collection of katas that most fit your current proficiency:

Tutorial Videos

Questions?

Session 3: Data Structures

Fri, 15 Mar 2024 00:00:00 +0000

Session 3: Data Structures

Instructor :

Python provides several built-in data structures that allow you to organize and store data efficiently. In this session, we’ll explore data structures in Python.

Lists

Lists are ordered collections of items, which can be of different data types. They are mutable, meaning you can modify, add, or remove elements after creating the list.

Creating Lists

Lists are defined using square brackets [] and elements are separated by commas.

1fruits = ["apple", "banana", "cherry"]
2numbers = [1, 2, 3, 4, 5]
3mixed = [1, "apple", 3.14, True]

List Operations

Lists support various operations, such as indexing, slicing, concatenation, and more.

 1fruits = ["apple", "banana", "cherry"]
 2
 3print(len(fruits)) # Get the length of the list (Output: 3)
 4print(fruits[0]) # Access the first element (Output: "apple")
 5print(fruits[-1]) # Access the last element (Output: "cherry")
 6print(fruits[1:3]) # Get a slice (from index 1 to 3) (Output: ["banana", "cherry"])
 7fruits.append("orange") # Add an element to the end
 8fruits.insert(1, "kiwi") # Insert an element at a specific index
 9fruits.remove("banana") # Remove the first occurrence of an element
10fruits.pop(2) # Remove the element at a specific index

Lists are versatile and commonly used for storing and manipulating collections of data in Python.

Tuples

Tuples are ordered collections of items, similar to lists, but they are immutable, meaning you cannot modify, add, or remove elements after creating the tuple.

Creating Tuples

Tuples are defined using parentheses () and elements are separated by commas.

1point = (3, 4)
2person = ("John", 32, "Programmer")
3empty_tuple = ()

Alternatively, you can create tuples without parentheses if there is a comma separating the elements.

1point = 3, 4
2single_element_tuple = 1, # Note the trailing comma

Tuple Operations

Although tuples are immutable, you can perform various operations on them, such as indexing, slicing, and concatenation.

1person = ("John", 32, "Programmer")
2
3print(len(person)) # Get the length of the tuple (Output: 3)
4print(person[0]) # Access the first element (Output: "John")
5print(person[-1]) # Access the last element (Output: "Programmer")
6print(person[1:3]) # Get a slice (from index 1 to 3) (Output: (32, "Programmer"))

Tuples are commonly used for storing and handling collections of related but immutable data, such as coordinates, database records, or configuration settings.

Sets

Sets are unordered collections of unique elements. They are mutable, meaning you can add or remove elements after creating the set. Sets are useful for performing mathematical operations like union, intersection, and difference on collections of elements.

Creating Sets

Sets are defined using curly braces {} or the set() function.

1fruits = {"apple", "banana", "cherry"}
2numbers = set([1, 2, 3, 4, 4, 5]) # Duplicates are automatically removed

Set Operations

Sets support various operations, such as adding and removing elements, performing set operations, and more.

 1fruits = {"apple", "banana", "cherry"}
 2
 3fruits.add("orange") # Add an element to the set
 4fruits.remove("banana") # Remove an element from the set
 5fruits.discard("kiwi") # Remove an element if it exists (no error if not)
 6
 7numbers = {1, 2, 3, 4, 5}
 8even_numbers = {2, 4, 6, 8}
 9
10print(numbers | even_numbers) # Union (Output: {1, 2, 3, 4, 5, 6, 8})
11print(numbers & even_numbers) # Intersection (Output: {2, 4})
12print(numbers - even_numbers) # Difference (Output: {1, 3, 5})

Sets are useful for removing duplicates, performing mathematical operations on collections, and maintaining an unordered collection of unique elements.

Dictionaries

Dictionaries are unordered collections of key-value pairs. They are mutable, meaning you can add, modify, or remove key-value pairs after creating the dictionary. Dictionaries are useful for storing and retrieving data based on keys.

Creating Dictionaries

Dictionaries are defined using curly braces {} with key-value pairs separated by colons.

1person = {"name": "John", "age": 32, "occupation": "Programmer"}
2empty_dict = {}

Dictionary Operations

Dictionaries support various operations, such as accessing, adding, modifying, and removing key-value pairs.

1person = {"name": "John", "age": 32, "occupation": "Programmer"}
2
3print(person["name"]) # Access the value associated with the "name" key (Output: "John")
4person["age"] = 33 # Modify the value associated with the "age" key
5person["location"] = "USA" # Add a new key-value pair
6del person["occupation"] # Remove a key-value pair
7for key, value in person.items():
8 print(f"{key}: {value}") # Iterate over key-value pairs

Dictionaries are used for storing and retrieving data based on keys, representing structured data like objects or records, and implementing efficient lookup and retrieval operations.

List Comprehensions

List comprehensions in Python provide a concise and efficient way to create lists from existing iterables (such as lists, tuples, or strings) based on specific conditions or transformations. They offer a more readable and expressive syntax compared to traditional for loops and can often lead to more compact and optimized code.

Basic Syntax

The basic syntax for a list comprehension is as follows:

1new_list = [expression for item in iterable]

new_list: The new list created by the list comprehension.
expression: The operation or transformation applied to each item in the iterable.
item: The variable representing each element in the iterable.
iterable: The sequence (list, tuple, string, etc.) from which the elements are drawn.

Example:

1numbers = [1, 2, 3, 4, 5]
2squared_numbers = [x**2 for x in numbers]
3print(squared_numbers) # Output: [1, 4, 9, 16, 25]

In this example, the list comprehension creates a new list squared_numbers by squaring each element x in the numbers list.

Using Conditionals

List comprehensions can also include conditional statements to filter or transform elements based on specific conditions.

1numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2even_numbers = [x for x in numbers if x % 2 == 0]
3print(even_numbers) # Output: [2, 4, 6, 8, 10]

In this example, the list comprehension creates a new list even_numbers by including only the elements x from numbers that are divisible by 2 (even numbers).

Nested Comprehensions

List comprehensions can be nested to create more complex expressions or work with multiple iterables.

1matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
2flattened = [num for row in matrix for num in row]
3print(flattened) # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In this example, the nested list comprehension[num for row in matrix for num in row] flattens the nested matrix list into a single list flattened.

Conditional Expression (Ternary Operator)

List comprehensions can also incorporate conditional expressions (ternary operators) to perform different operations based on conditions.

1numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2result = ["even" if x % 2 == 0 else "odd" for x in numbers]
3print(result) # Output: ['odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even']

In this example, the list comprehension ["even" if x % 2 == 0 else "odd" for x in numbers] creates a new list result by appending the string “even” if x is even, and “odd” if x is odd.

List comprehensions are powerful and expressive tools that can significantly improve the readability and conciseness of your code when working with lists and iterables in Python. They can help you write more Pythonic and efficient code, especially when dealing with complex data transformations or filtering operations.

Questions?

Session 4: Introduction to Libraries and Modules

Fri, 15 Mar 2024 00:00:00 +0000

Session 4: Introduction to Libraries and Modules

Instructor :

Python provides a modular structure that allows you to organize your code into reusable components called modules and packages. These modules and packages can contain variables, functions, classes, and even other modules and packages.

This modular approach promotes code reuse, maintainability, and collaboration within the Python community.

Modules

A module in Python is a single file containing Python code, such as functions, classes, or variables. Modules help organize code into logical units and promote code reuse across different parts of your program or across different projects.

Packages

A package is a collection of modules organized into a directory structure. Packages allow you to hierarchically organize related modules, making it easier to manage and distribute larger code bases.

A package is essentially a directory that contains an __init__.py file, which marks the directory as a Python package. The __init__.py file can contain initialization code or be left empty.

Importing and Using Modules

To use a module or package in your Python code, you need to import it. The import statement allows you to access and use the code defined in the imported module or package.

Importing Modules

There are several ways to import modules in Python:

Import the entire module: import module_name
Import specific objects from a module: from module_name import object1, object2
Import a module with an alias: import module_name as alias
Import all objects from a module: from module_name import * (not recommended, as it can lead to naming conflicts)

Example:

1import math # Import the entire math module
2print(math.pi) # Access the pi constant from the math module
3
4from math import sqrt # Import the sqrt function from the math module
5print(sqrt(16)) # Use the imported sqrt function
6
7import random as rd # Import the random module with an alias
8print(rd.randint(1, 10)) # Use the randint function from the random module

Importing Packages

To import modules from a package, you need to use the package hierarchy in your import statement.

1import package_name.module_name
2from package_name.module_name import object1, object2

Installing External Libraries

Python has a vast ecosystem of external libraries and packages that provide additional functionality beyond the standard library. These external libraries can be installed using package managers like pip (Python Package Installer) or conda (Anaconda’s package manager).

To install an external library (e.g., NumPy or Matplotlib), you can open the Anaconda Prompt (on Windows) or the terminal (on macOS/Linux) and run the following command:

1conda install library_name

Replace library_name with the name of the library you want to install (e.g., numpy or matplotlib).

After installing a library, you can import and use it in your Python code like any other module or package.

Built-in Libraries

Python comes with a comprehensive standard library that provides a wide range of modules for various tasks. Here are a few examples of commonly used built-in modules:

math: This module provides access to mathematical functions and constants, such as pi, sin(), cos(), sqrt(), and more.
random: This module provides functions for generating random numbers and making random choices.
os: The os module allows you to interact with the operating system, including functions for file and directory operations, environment variables, and more.

re: The re module provides support for regular expressions, which are powerful patterns for text processing and manipulation.
datetime: This module supplies classes for working with dates, times, and time intervals, making it easier to perform date and time operations.
json: The json module allows you to encode and decode JSON (JavaScript Object Notation) data, which is a lightweight data interchange format.

Examples of `math` Module

1import math
2
3print(math.pi) # Output: 3.141592653589793 (pi constant)
4print(math.sqrt(16)) # Output: 4.0 (square root)
5print(math.sin(0)) # Output: 0.0 (sine function)
6print(math.cos(math.pi / 2)) # Output: 6.123233995736766e-17 (cosine function)
7print(math.floor(3.7)) # Output: 3 (floor function)
8print(math.ceil(3.2)) # Output: 4 (ceiling function)

Examples of `random` Module

 1import random
 2
 3print(random.random()) # Output: A random float between 0 and 1
 4print(random.uniform(1, 10)) # Output: A random float between 1 and 10
 5print(random.randint(1, 6)) # Output: A random integer between 1 and 6 (inclusive)
 6
 7my_list = [1, 2, 3, 4, 5]
 8print(random.choice(my_list)) # Output: A random element from the list
 9random.shuffle(my_list) # Shuffle the elements of the list in-place
10print(my_list) # Output: The shuffled list

Popular External Libraries

The Python ecosystem is enriched by a vast collection of external libraries and packages contributed by the community. These libraries offer specialized functionality for various domains. Here’s a description of some popular external libraries:

NumPy: A powerful library for numerical computing, providing support for large, multi-dimensional arrays and matrices, along with a vast collection of mathematical functions to operate on these arrays.
Matplotlib: A comprehensive data visualization library for creating static, animated, and interactive visualizations in Python, including plots, histograms, bar charts, scatter plots, and more.
Pandas: A high-performance, easy-to-use data manipulation and analysis library for working with structured (tabular, multidimensional, heterogeneous) and time-series data.

SciPy: A collection of mathematical algorithms and convenience functions for scientific and technical computing, including modules for optimization, linear algebra, integration, interpolation, and more.
Scikit-learn: A machine learning library that provides simple and efficient tools for data mining and data analysis, including classification, regression, clustering, dimensionality reduction, and more.
TensorFlow: A powerful library for machine learning and deep learning, used for building and deploying neural networks and other machine learning models.

Requests: A simple and elegant library for making HTTP requests, handling cookies, file uploads, and more.
Django: A high-level Python web framework that encourages rapid development and clean, pragmatic design for web applications.
Flask: A lightweight, flexible, and minimalist Python web framework for building web applications.

Introducing NumPy (for Numerical Computing)

NumPy (Numerical Python) is a fundamental library for scientific computing in Python. It provides support for large, multi-dimensional arrays and matrices, as well as a vast collection of mathematical functions to operate on these arrays efficiently.

NumPy is widely used in various fields, including data analysis, machine learning, scientific computing, and more. It serves as the foundation for many other scientific libraries in the Python ecosystem, such as Pandas, SciPy, and Matplotlib.

NumPy Arrays

The core data structure in NumPy is the ndarray (N-dimensional array). NumPy arrays are efficient, homogeneous (containing elements of the same data type), and provide a wide range of operations and functions to work with them.

1import numpy as np
2
3# Creating NumPy arrays
4a = np.array([1, 2, 3, 4, 5]) # 1D array
5b = np.array([[1, 2], [3, 4]]) # 2D array
6c = np.zeros((3, 4)) # 3x4 array filled with zeros
7d = np.ones((2, 3, 4)) # 2x3x4 array filled with ones
8e = np.arange(10) # 1D array with values from 0 to 9
9f = np.linspace(0, 1, 5) # 1D array with 5 evenly spaced values between 0 and 1

 1# Array operations
 2print(a + 2) # Output: [3 4 5 6 7] (Element-wise addition)
 3print(a * b) # Output: [[ 1 4]
 4 # [ 9 16]] (Element-wise multiplication)
 5print(np.sqrt(a)) # Output: [1. 1.41421356 1.73205081 2. 2.23606798] (Square root)
 6print(np.sum(b)) # Output: 10 (Sum of all elements)
 7print(np.mean(a)) # Output: 3.0 (Mean of the elements)
 8
 9# Array indexing and slicing
10print(b[0, :]) # Output: [1 2] (First row of b)
11print(b[:, 1]) # Output: [2 4] (Second column of b)
12print(b[1, 1]) # Output: 4 (Element at row 1, column 1 of b)

1# Array reshaping
2g = a.reshape(1, 5) # Reshaping 1D array a into a 2D array with shape (1, 5)
3print(g) # Output: [[1 2 3 4 5]]
4
5# Array concatenation
6h = np.concatenate((a, e), axis=0) # Concatenate a and e along the first axis
7print(h) # Output: [1 2 3 4 5 0 1 2 3 4 5 6 7 8 9]

Introducing Matplotlib (for Data Visualization)

Matplotlib is a comprehensive data visualization library in Python. It provides a wide range of tools and functions for creating static, animated, and interactive visualizations in various formats, including plots, histograms, bar charts, scatter plots, and more.

Basic Plotting

Matplotlib provides a MATLAB-like interface for creating plots. Here’s an example of creating a simple line plot:

 1import matplotlib.pyplot as plt
 2import numpy as np
 3
 4# Generate some data
 5x = np.linspace(0, 10, 100)
 6y = np.sin(x)
 7
 8# Create a figure and axes
 9fig, ax = plt.subplots()
10
11# Plot the data
12ax.plot(x, y)
13
14# Add labels and title
15ax.set_xlabel('X')
16ax.set_ylabel('Y')
17ax.set_title('Sine Wave')
18
19# Display the plot
20plt.show()

Plot Customization

Matplotlib offers extensive customization options for plots, allowing you to adjust colors, line styles, markers, legends, and more.

 1import matplotlib.pyplot as plt
 2import numpy as np
 3
 4# Generate some data
 5x = np.linspace(-10, 10, 100)
 6y1 = x**2
 7y2 = x**3
 8
 9# Create a figure and axes
10fig, ax = plt.subplots()
11
12# Plot the data
13ax.plot(x, y1, color='r', label='Square')
14ax.plot(x, y2, color='g', linestyle='--', marker='o', label='Cube')
15
16# Add labels, title, and legend
17ax.set_xlabel('X')
18ax.set_ylabel('Y')
19ax.set_title('Polynomial Plots')
20ax.legend()
21
22# Display the plot
23plt.show()

Other Visualization Types

Matplotlib supports various types of visualizations beyond line plots, including:

Scatter plots
Bar charts
Histograms
Pie charts
3D plots
Contour plots
Image plots

 1import matplotlib.pyplot as plt
 2import numpy as np
 3
 4# Generate some data
 5data = np.random.normal(0, 1, 1000)
 6
 7# Create a figure and axes
 8fig, ax = plt.subplots()
 9
10# Plot a histogram
11ax.hist(data, bins=20, edgecolor='black')
12
13# Add labels and title
14ax.set_xlabel('Value')
15ax.set_ylabel('Frequency')
16ax.set_title('Histogram')
17
18# Display the plot
19plt.show()

Reading and Writing Files

Working with files is a fundamental aspect of many programming tasks. Python provides built-in functions and modules for reading and writing files, allowing you to interact with various file formats and perform file operations efficiently.

Reading Files

Python provides the open() function to open files for reading or writing. Here’s an example of reading the contents of a text file:

 1# Open a file in read mode
 2file = open('example.txt', 'r')
 3
 4# Read the entire file
 5content = file.read()
 6print(content)
 7
 8# Read a single line
 9line = file.readline()
10print(line)
11
12# Read all lines into a list
13lines = file.readlines()
14print(lines)
15
16# Close the file
17file.close()

It’s recommended to use the with statement when working with files, as it ensures the file is properly closed after the operations are completed, even in the case of exceptions or errors.

1# Open a file using the with statement
2with open('example.txt', 'r') as file:
3 # Read the file contents
4 content = file.read()
5 print(content)

Writing Files

Writing to files is similar to reading, but you need to open the file in write mode (w) or append mode (a).

1
2# Open a file in write mode (will create the file if it doesn't exist)
3with open('output.txt', 'w') as file:
4 file.write('This is a new line\n')
5 file.write('This is another line\n')
6
7# Open a file in append mode
8with open('output.txt', 'a') as file:
9 file.write('This line is appended\n')

Working with Other File Formats

Python’s standard library and third-party libraries provide support for working with various file formats, such as CSV, JSON, Excel, and more.

 1# Working with CSV files
 2import csv
 3
 4# Open a CSV file and read its contents
 5with open('data.csv', 'r') as file:
 6 reader = csv.reader(file)
 7 for row in reader:
 8 print(row)
 9
10# Open a CSV file and write data to it
11with open('output.csv', 'w', newline='') as file:
12 writer = csv.writer(file)
13 writer.writerow(['Name', 'Age', 'City'])
14 writer.writerow(['John', 25, 'New York'])
15 writer.writerow(['Jane', 30, 'London'])

Slides | Scicho

My Research and Passion

My Research and Passion

About Me

Research Interests

Numerical Methods (FEM)

Numerical Methods (SBFEM)

Scientific Computing

Computational (Bio)Mechanics

Computational Geometry

Machine Learning for Biomedical Applications

Some Examples of Projects

Scaled Boundary Finite Element Method (SBFEM)

Head Trauma

pyPolyMesher

QTREEMESH

Bone Microcracks

Composite Design Assistant(ComDA)

Machine Learning for Biomedical Applications

Ongoing Projects

Collaboration & Contact

Thank You! 🎤

Session 1: Introduction to Python

Session 1: Introduction to Python

Introduction to Programming

Why Learn Programming?

What is Python?

Key Features of Python

Python Applications

Setting up the Python Environment

Anaconda Distribution

Spyder IDE

Python Syntax

Comments

Indentation

Variables

Data Types

Numbers

Strings

Lists

List Operations

Basic Input/Output Operations

Input

Output

File Operations

Writing to a File

Reading from a File

Questions?

Session 2: Control Flow and Functions

Session 2: Control Flow and Functions

Conditional Statements

if Statement

elif Statement

else Statement

Loops

for Loop

while Loop

Functions

Defining Functions

Calling Functions

Scope and Namespaces

Scope

Namespaces

Introducing CodeWars

What are Katas?

Getting Started with CodeWars

Tutorial Videos

Questions?

Session 3: Data Structures

Session 3: Data Structures

Lists

Creating Lists

List Operations

Tuples

Creating Tuples

Tuple Operations

Sets

Creating Sets

Set Operations

Dictionaries

`if` Statement

`elif` Statement

`else` Statement

`for` Loop

`while` Loop

Examples of `math` Module

Examples of `random` Module