Gain insights into using Python for scientific and engineering applications. Delve into real-world scenarios, learning NumPy, Matplotlib, audio processing, and more through practical, hands-on projects.

Python for Scientists and Engineers_468 x 60 copy 2.png

jupter.tar.gz

notebook

obesity_plot_gender

print_gender_pandas

create_sine_wave

notebook_exercise

range

print_gender_pandas_remove_NaN

print_gender_year

print_data_age

print_data_age_with_year

print_data_age_remove_NaN

obesity_plot_age_simple

obesity_plot_age_clear

print_data_age_under_16

print_data_age_25_34

obesity_plot_children_vs_adults

print_movie_top_rated

print_movies_oldie_teen

print_movies_by_gender

print_movies_for_women

print_movies_by_gender_loc

print_movies_diff_gender

movies_diff_gender_plot

print_u_data

print_movies_oldie_index

print_movies_oldies

print_movies_teens

display_image_nouse

grey_image

blur_image

edge_detection_low

edge_detection_high

plot_sin_wave

create_wave_file

display_again

print_frequencies

count_objects

detect_faces

detect_faces_little_mix

count_exact_lines

webcam_detection

single_thread

find_correlation

webcam_face_detection

motion_detection

motion_detection_live

In this course, you will learn to use Python for real-world scientific/engineering applications. For each topic, there will be a real case scenario where you will build a quick solution in Python to solve the problem.

More specifically, you will cover topics such as creating a word counter, NumPy and Matplotlib, audio processing, and a lot more. Throughout each chapter, you will get hands-on experience in building solutions for complex problems that engineers and scientists face every day.

The Practical Guide to Python for Scientists and Engineers


There are two ways to call Python files:

1. We can call the file directly (Python [filename]), which is what we’ve been doing.
 
2. We can call the file using an external library.

We haven’t covered calling the file using an external library yet. If we wanted to use the function `count_words` in another file, we would do this:

```
from word_count import count_words
```

This will take the function `count_words` and make it available in the new file. We can also do the following:

```
from word_count import *
```

This will import all functions and variables, but generally, this approach isn’t recommended. It would be best if we only imported what we needed. Furthermore, we’ll sometimes have a code we only want to run if the file is being called directly (without an `import`). In that case, we can put it under this line:

```
if __name__ == "__main__":
```

This means “only run this code if we are running this file from the command line." If we import this file in another, all of this code will be ignored.

Using this syntax ensures that our function only runs when someone calls our program directly and does not import it as a module.


>**Note**: `__name__` is an internal variable set to `__main__` by the Python interpreter when running the program standalone.

In our examples, we’ve been calling the files directly. However, we thought we’d show the following syntax as well. It is optional, but good practice for whenever we want to turn our code into a library. Even though you might not need to now, it’s good practice to include the command as it’s only one line. 

```
 if len(sys.argv) < 2:
        print("Usage: python word_count.py <file>")
        exit(1)

```
> The **`sys`** library contains several system calls, one of which is the `sys.argv` command, which returns the command line arguments.

We’re already familiar with `len()`. Let’s check if the number of command-line arguments is less than two.

> The first argument is always the name of the file.

````
WordCount> python ./word_count.py
````
If so, print a message and exit. This is what happens when we pass one argument to the function.

Output:
`Usage: python word_count.py <file>`

The next line:
```
filename = sys.argv[1]
```
As we said, the first element of `sys.argv` (or `argv[0]`) will be the name of the file itself (`word_count.py` in our case).

The second will be the file the user entered. We’ll read that:

    f = open(filename, "r")
    data = f.read()
    f.close()

We’ll read the following data from the file:

    num_words = count_words(data)
    num_lines = count_lines(data)
    print("The number of words: ", num_words)
    print("The number of lines: ", num_lines)

And now we’ll call our functions to count the number of words and lines. Then we’ll print the results. Voila! We’ve created a simple word counter.

Learn about the different ways of calling Python files.

How to Call Python Files?

Introduction

Create a Word Counter in Python

An Introduction to NumPy and Matplotlib

Python pandas

Audio Processing

Image and Video Processing

MultiThreading vs. Multiprocessing in Python

Machine Learning with an Amazon-like Recommendation Engine

Conclusion

How to Call Python Files?