Python for Scientists

Welcome to the deep dive. So, if you're a scientist, and we meet that pretty broadly, right, anyone using numbers, models to figure things out.

Yeah, analyzing data, simulating theories, asking those big what if questions.

Exactly, and you're maybe curious about using Python, Well, you're definitely in the right place today. Yeah.

Today we're digging into Michael Mommert's Python for Scientists, the third edition. We're basically pulling out the essentials for you.

Think of this as the fast track, getting you the core stuff you need to know about Python in science without you know, getting totally lost in the weeds.

We're aiming to highlight what's actually useful for your scientific work.

Okay, so let's dive in Python for scientists. What are we really talking about here? First off, just to be clear, it's the programming language, not the snake.

Yeah, yeah, important distinction. And scientists, it's not just lab codes, right.

If you're using quantitative models, processing data, asking what if with numbers.

And this is for you. It's amazing how much modern science relies on computation.

Now totally experiments are getting huge, data sets are massive. You just can't do it by hand anymore.

And our theories are getting more complex too, needing computers to really explore them. You basically need computational tools to do science today.

But here's a curious thing the book points out. You'd think with all this powerful hardware, there'd be tons of amazing specialized software for scientists just readily available.

But that's not always the case, is it.

No, And a big reason is just market size. Scientists, well, we're a relatively small market compared to say, gamers or businesses, so the.

Big money isn't always there to constantly push the boundaries of specialized scientific software, even though these tools are like essential for us, right.

Which brings us to a key choice using proprietary versus open source software.

Okay, yeah, proprietary stuff. That's the commercial software companies make it. They've costs, payroll shareholders, so you've got to pay for it exactly, and often the actual code, the source code is secret. It's their intellectual property.

Which means you can't easily customize it for your specific maybe weird research needs.

Right, and the book mentions this daneingel de effect ah yes, where because they need ongoing revenue, you often find yourself paying for frequent updates or new versions just to keep using it effectively.

Then you've got the flip side. Open source.

Yeah, open source software is usually free. It's often built by communities, maybe researchers at universities.

People sharing tools with colleagues basically.

And the licensing is different too. It's usually designed so no one company can just take it over and lock it down anti copyright.

Often then you might think, okay, free software made by volunteers, it can't be as good as the paid stuff.

Right, That's a common thought, but the book really pushes back on that. It argues that actually, in many scientific fields, open source tools are incredibly powerful. Sometimes they even lead the way.

Interesting. So, okay, we have this proprietary versus open source split. But the book also talks about different kinds of scientific software.

Right, so you have what you might call scientific software tools. These are kind of prepackaged applications.

Like matt Lab or even Excel on the commercial.

Side exactly, and open source ones like are again Octave, Libre Office. Some have nice graphical user interfaces guys, you know, click buttons, get results.

Makes common stuff easy, definitely.

But that ease of use can mean less flexibility if you want to do something really specific the designers didn't think of.

It can be tough, Okay.

Other tools try to bridge that gap. They might have a user interface but also include their own built in programming language.

Like interpreters. They run your code bit by bit precisely.

It gives you more power than just a GUI.

But underneath all these tools, there are the actual programming languages, right, the fundamental building blocks.

Absolutely. Languages like C and Fotran have been huge in science historically. They're often called compiled languages.

Compiled language, Yeah, the book uses that racing car analogy.

Right, Yeah, like a formula one car. They can be incredibly fast because your code gets translated directly into efficient machine instructions by a compiler. Super powerful, But like driving enough one car, using them well takes a lot of skill and sometimes getting things working across different compilers can be tricky. Plus, you often need lots of external libraries for basic stuff.

So why don't scientists just use these super fast languages for everything?

Well, back to the analogy. You wouldn't take enough one car to pop to the shops, would you?

Eh? Probably not? Speed isn't everything there exactly?

Compiled languages aren't always the best for quickly trying out an idea or writing a simple script for a daily task.

Okay, so what's the alternative for those everyday tasks?

That's where interpreted languages shine. We mentioned them already. They often power those more flexible software tools.

It might not be quite as fast as the compiled.

Ones generally, no, but they're often much easier to learn and use. For a lot of scientists, especially for scripting or getting started, they're way more approachable.

And this is where Python comes in, right, It's huge now.

It really is especially popular with younger researchers, it seems.

So why what makes Python so attractive for science?

A big reason the book highlights is this idea of explicitness.

Explicitness what does that mean in code?

Okay, imagine you need to read data from say, three different file types. You could try writing one super complicated function to handle all three, right, or the Pythonic way, the sort of encouraged style is to write three separate, clear functions. One function explicitly handles format A, another handles format B, and so on.

Ah. Okay, one function, one.

Job exactly And why is that good?

I guess it's easier to understand what's going on less confusing.

Precisely, it's easier for collaborators to read, easier for you to read six months later when you've forgotten the details, and in science that kind of clarity and reproducibility is vital.

Makes sense. Okay, So let's say you're sold on Python. How do you actually get started? Like? Install it?

Right installation? The book mentions you might already have Python on your.

System, but you shouldn't mess with that one.

Probably best not to, Yeah, it might break other things. The recommendation is to install something called Anaconda. It's a distribution of Python that comes bundled with a tool called Conda, and Conda is fantastic for managing different programming environments environments.

Why do I need different environments?

Well, imagine you're working on project X and it needs version one point zero of a specific library, but project Y needs version two point zero of the same library.

Ah conflicts exactly.

Conda lets you create isolated sandboxes or environments. Project X gets its own environment with its specific libraries. Project Y gets its own. Nothing clashes.

Okay, that sounds super useful for keeping research projects separate and reproducible.

It's essential, really, and installing packages into an environment is easy with Conda. Just Conda install and the package name like cond install NumPy.

In these pack like NumPy. Where do they come from? Where they like add ons?

Sort of?

Yeah?

Think of them as libraries of pre written code for specific tasks. Numb Pi is fundamental for numerical stuff and most packages scientists need are available through Conda.

Where does condfind them?

A major source is Conda Forge. It's a huge community effort maintaining recipes to build thousands of packages. It's a great place to look for scientific tools.

Okay, installed via Anaconda using Conda environments, how do I actually write and run Python code?

Then the book really focuses on Jupiter notebooks, and honestly they're a fantastic tool for scientists. The book itself is written as notebooks jupitern notebooks.

What's special about them.

They let you mix live, runnable code with text, equations, plots all in one document. You can run them in your web browser, either locally or in the cloud.

So it's not just code. It's like an interactive lab notebook.

That's a great way to put it. It integrates your code, your explanations, and your results together. Really powerful for documents and sharing your work.

What are the main parts of a notebook?

They're made up of cells. You have code cells for your Python code, which you can run individually.

And see the output right away.

Yep, right underneath the cell. Then you have markedown cells. Markdown is a simple way to format text headings lists bold italics.

So you can write explanations right alongside the chemical exactly.

You can even put in mathematical equations using latex notation. It encourages you to explain what you're doing and why as you go.

That sounds incredibly useful for keeping track of things.

It really is. And inside the code cells, you can even run special commands called magic commands that interact with the operating system or control the notebook itself. They start with eight percent.

Or percent magic commands like what you can.

List files, change directories, time your code. Things like that. Typing percent magic gives you the full rundown and percents magic gives a quick list.

Cool. Okay, so we're in a notebook. What about the basic Python language elements a scientist needs to grasp right fundamentals.

Let's start with com comments, essential for explaining your code.

How do you write comments two main ways.

Single line comments start with a hash symbol hashtag. Anything after the hashtag on that line is ignored by Python. And then there are dock strings. These are multiline strings, usually enclosed in triple quotes like this is a dock string?

What are they used for?

They're typically put right at the start of a function or a class to explain what it does. It's inputs, its outputs really important for documentation.

Got it? What about the actual data we work with? Numbers text?

In Python? Basically everything is an object. A number is an object, A piece of text is an object, a list is an object. Each object has a type like integer, float, string, and an identity, which is basically its address and memory.

We don't usually worry about the memory address though right not directly.

No, Instead we use identifiers. These are just names or variables that we assign to point to these objects. X equals five means the identifier X now refers to the integer object five.

Are there rules for naming these identifiers? Yep.

They have to start with a letter or an underscore. After that, they can have letters, numbers, or underscores.

In case matters data is different from.

Data absolutely case sensitive Also, names starting or ending with underscores often have special meanings, so maybe you avoid those at first, and you can't use pythons on keywords like if for list int as names.

Okay, and using clear descriptive names is good practice. I assume like reaction rate instead of just.

Are readability accounts, especially in science.

So when we write x equals five, you said that's assignment. Can you elaborate on that? It's not quite like algebra's equals sign exactly.

It's crucial to get this in Python means assign the object on the right to the identifier on the left. It's an instruction, not a statement of fact. The object five has the type int, not the.

Name X, and I could later say X hello, yep.

You can reassign x to point to a completely different object, even one of a different type. The name just points wherever you tell it to.

How does Python and keep track of all these names and what they point to?

It uses name spaces. Think of a name space as a dictionary mapping names identifiers to objects. When you're working interactively or in a script, there's a main name space called main. When you import modules, they get their own name spaces too.

Like folders for names to avoid clashes.

That's a good analogy. Yeah, it keeps things organized.

Okay, what about different kinds of numbers? Scientists use lots of those.

Python has the basics covered. You've got integers, int, whole numbers positive negative, zero, and in modern Python they can be basically as big as you need.

Count equals one hundred, no maximum size practically speaking, not.

Really, which is nice. Then for numbers with decimal points, you have floating point numbers or floats.

Floats like measurements.

Exactly temperature ecals twenty five point five. They typically have about sixteen digits of precision. You can write them normally or using scientific notation like speedo flight it calls three.

E eight and doing math addition subtraction.

All the standard operators work plus and for multiplication. For division, one thing always gives a float result. Even if you divide integers like four to two, you get two point zero.

What if I want injured division, like just a whole number part.

Use the double slash then, so seven to three gives two, And if you want the remainder, use a modulle operator percent seven percent three gives one.

Powers like squaring something, use.

The double asters collapse, so five to two is twenty five. And there are shorthand operators like x plus x, which is the same as x plus one.

Standard order operations applies.

Parentheses work yep, just like in regular math pemdas bodnus, and for more complex math trig functions logs you import the math module.

What about complex numbers useful in physics and engineering.

Sometimes Python has built in support for complex numbers. You write them like three plus four J, where J is the imaginary unit. All the standard complex arithmetic.

Works and true false values.

Those are boullions holy think they can only be true or false. Note the capital letters.

How do we get bullion values?

Usually often from comparisons. You use operators like less than, greater than, greater than, are equal to, less than are equal to for equals right, double equals for testing equality because single is for assignment and r is for not equal to. These all return true or false.

Can you combine conditions like temperature is high, any pressure is low.

Yep, using the logical operators and or and not.

Okay, that covers basic data types, but scientists often work with collections of data points. How does Python handle that.

There are several ways, but the most fundamental container is the list.

Lists.

Okay, A list is an ordered sequence of items. You create it using square brackets with commas between items, like my data is one point two one point five to one point one.

Can lists hold different types of data like numbers and texts?

Absolutely mixed list equals one apple three point one four. That's perfectly fine. You can even have lists inside other lists, nested lists.

How do you find out how many items are in a list?

Use the built in len function lend my data would give you three in that example.

Are lists fixed once you create them? Or can you change them? Add things?

They are mutable, meaning you can change them. You can add an item to the end using the a pen method like my data dot a pen one point four That modifies the list directly.

If you join lists together.

YEP, using the plus operator list one plus list two creates a new list with all the elements from both. You can also repeat a list using one one two three gives one two, one two one two.

How do you get a specific item out of a list like the first one or the third one?

Using indexing, You put the index number in square brackets after the list name. Crucially, Python uses zero based indexing, so the.

First item is at index zero.

Correct might dad A zero would be one point two, My data one would be one point five, and so on.

What about getting items from the end?

Python has negative indexing for that. My data one gives you the last item, my data two gives a second to last, et cetera. Very handy.

What if I want a range of items like the second through fourth elements.

That's called slicing. The syntax is list namestart dot end. It gives you an new list starting at the start index up to but not including the end index.

So my data one point four would give items in index one, two, and three exactly.

If you leave at start, it assumes zero. If you leave out end, it goes to the end of the list.

Is there more to slicing?

You can add a step listenamestart dot end dot step, So my list dot two would give you every second element, and my listash one is a common trip to get a reversed copy of the list.

Okay, lists seem very flexible. Are there built in functions useful for lists in science?

Definitely? Some adds up all the numbers in a list, but they all have to be numbers.

What about working with multiple lists together, Like if I have time points in one list and measurements in another.

ZIP is perfect for that. Zip times measurements pairs up the corresponding elements from each list into two poles. You usually wrap it in list to see the result. Like list zip times measurements.

That sounds really useful. What about filtering or transforming lists?

You have filter in map. Filter takes a function and a list and keeps only the items where the function returns true. Dot map take the function and applies it to every item in the list, giving you a new list of the results.

And their functions like all any all.

Checks if every item in a list is true or evaluates to true, and any checks if at least one item is true. Useful for checking conditions across data.

You mentioned Zip creates tuples. What are tuples? How are they different from lists?

Tuples are very similar, but you create them with parentheses instead of square brackets like point twenty to twenty. Indexing and slicing work exactly the same way.

So what's the difference? Then?

The key difference? Tuples are immutable. Once you create a tuple, you cannot change its contents. You can't append to it. You can't change an element.

Why would you want something you can't change? Is it mutable? Better?

Immutability has its advantages. Sometimes you want to guarantee that a collection of values won't be accidentally changed. Also, because they're immutable, tuples can be used in places lists can't, like as keys and dictionaries another data structure. Any performance difference Sometimes ones maybe slightly less memory, but usually not the main reason you choose one. It's more about signaling intent. This group of values shouldn't change.

How do you make a tuple with just one item? Item doesn't work? Does it right?

That just looks like parentheses. For grouping, you need a trailing comma. Okay, looks a bit weird, but that's the syntax.

Okay. Lifts are mutable, Tuples are immutable. What about text data reading, file labels notes?

That's where strings stent come in. There a's sequences of characters. You cree them with either single quotes or double quotes.

Can you convert other things to strings like numbers?

Yep? The stem function does that? Startletar function? Does that one two three? Gives you the string one two be three? Very useful for printing output or saving data.

Is there a way to go the other way? String to code?

There's Evil, which tries to run a string as Python code. But you have to be really careful with Evil, especially if the string comes from an external source, because it can be a security risk. Generally best to avoid it and you know exactly what you're doing.

Strings are mostly for impute output and format of printing.

Then, yeah, primarily, And the string object itself has tons of useful built in methods for searching, replacing texts, splitting strings, changing case, and so on.

All right, so we have data types containers. How do we control what our code does? Like making decisions?

That's control flow. The most basic is the if statement if condition followed by an indented block of code that only runs if the condition is true.

What if the condition is false? Can you do something else?

Yes, you can add inn else dot block. And if you have multiple conditions to check in sequence, use l if short for else if if condition one, ale condition two only one.

Block ever runs essential for handling different cases in experiments or simulations.

Absolutely.

What about doing things repeatedly? Loops?

Two main loop types for and while before loop is great for iterating over a sequence like stepping through each item in a list or tuple.

For item in my list exactly.

The indented code block runs once for each item. You can also loop over zipped sequences, like for tea in zip time's measurements.

You mentioned range earlier. How does that fit with four loops?

Range is perfect when you just want to loop a specific number of times. Range five effectively gives you the sequence zero, one, two, three, four. So for I in range five, will run the loop body five times with I taking those values.

Very useful for fixed iterations. What about the wile loop.

A wile loop keeps running as long as its condition stays true wile condition.

So you need to make sure the condition eventually becomes false.

Yes, otherwise you get an infinite loop and your program hangs. You usually modify something inside the loop that affects the condition.

Do you ever break out of a loop early?

Yep, using the brake statement. If Python hits brake inside a loop, it immediately jumps out and continues after the loop. Useful if you've found what you needed or hit an error, and.

You mentioned list comprehensions again. A shortcut for creating lists.

Yeah, there are really neat concise way to build lists. Instead of writing a full loop to create a list, you can often do it in one line inside square.

Brackets, like by two for x in numbers to get a list of squares exactly.

You can even add an if condition x for x in numbers if backs zero to get only the positive numbers. Very pythonic and often more readable once you get used to them.

Okay, moving on the functions. They're key for reasonable code, right, how do we make them in Python?

You use the deaf keyword deaf function name, parameters, then an indented block for the function's code.

And the docks ring goes right after the deafline.

Good practice. Yes, explain what this function does, then the code. If you want the function to give back a result, you use the return statement return result.

What if there's no return statement, then the.

Function implicitly returns a special value called none.

And calling a function is just function name arguments.

YEP, providing the values arguments for the parameters defined in the deafline.

Now a critical point for science. Can functions change the data you pass into them?

It depends on the data type. If you pass immutable things numbers, strings, tupples the function works on a copy. It can't change the original outside the function, but.

If you pass mutable things like lists.

Then yes, the function can modify the original list directly. This is called a side effect. Sometimes you want that, sometimes it's a surprise.

So if you don't want the original list changed, you should make a copy inside the function first.

That's the safe way to do it. Yes, use slicing like localist input lists or the dot copy method.

Python seems flexible about function arguments. You mentioned positional and keyword arguments. Right.

Positional arguments are matched by order. Keyword arguments you define with a default value like my funk input threshold zero point five, so.

You can call it like myfunk data and threshold to b point five.

Yep, or you can override it myfunk's data threshold zero point one. You can provide keyword arguments by name in any order.

And those aregs and quorgs thing.

They let you create functions that accept any number of extra positional are arguments, collects them into a tucle or any number of extra keyword arguments quarks collects them into a dictionary. Very flexible.

Okay, we have code functions, how do we get results out? Displaying or saving.

Simplest display is the print function. We've used it implicitly just print some value.

But often you want more control over the format right like decimal places for numbers exactly.

That's string formatting. The modern recommended way is using the dot format method on a string, or even better F strings.

How does dot format work.

You put curly braces as placeholders in your string the value is and the limit is than you call format on that string with the values dot format value.

Limit, Can you control the formatting inside the braces?

Yes, you can specify alignment with number of decimal places for floats or two decimal places, scientific notation and more. It's quite powerful. F strings f the value is valued, DOT two s are often even more concise.

What about saving results to a file or reading data from a file crucial for science.

Python has built in file handling. You start by using the open function. You give the file name and.

A mode modes like R for read, W for wright.

Exactly, R for reading file must exist, W for writing creates new file or overwrites existing A for appending to the end of a file, add B for binary files like RB or WEB.

So open gives you a file object yes.

And that object has methods like dot read to read the whole file, dot redline to read one line, dot red lines to read all lines into a list, and dot write to write a string to the file.

And you absolutely must close the file afterwards.

Critically important use the dot close method if you forget data might not get fully written, or you might run out of resources.

Is there a safer way that handles closing automatically?

Yes, and it's strongly recommended use the with statement dot with open data, dot txdrs F you work with the file object f inside the indented block. When the block finishes, Python automatically closes the file even if errors happened.

Uh. The context manager much safer.

Definitely the preferred way.

Okay. Inevitably things go wrong. Code has errors. How does Python react.

When an error occurs? Python raises an exception if you don't do anything about it. The default behavior is to print an error message the trace back and stop the program.

What kind of errors might a scientist run into?

Lots? Indentation error is common for beginners. Python cares about spaces type error if you try to say, add a number in a string. Name error. If you use a variable you haven't defined value error if a function gets the right type but a bad value, like trying to convert zxyz to an integer. Zero division error is obvious. Index error if you try to access a list element that doesn't exist. File not founder if open can't find the file. Import error if it can't find a module you try to import.

Can you stop the program from just crashing when these maybe try something else?

Yes, that's what tri dot except blocks are for. You put the code that might cause an error inside the try dot block, and then you have one or more accept blocks. If an exception occurs in the triblock, Python looks for an accept block that matches the type of exception raised. If it finds one, it runs the code in that accept block instead of crashing.

So you can handle the error gracefully, log it, try again, provide a default value exactly.

It lets you build more robust programs that don't fall over at the first hurdle.

Now, the book also introduces classes. This sounds a bit more advanced. What's the idea.

Classes are a way to create your own custom object types. Think of them as blueprints for creating objects that bundle together data called attributes and functions that operate on that data, called methods.

Why would a scientist use classes?

You could model things from your research. Maybe create a molecule class with attributes like atoms and bonds and methods to calculate its mass or energy. It helps organized complex data and related operations.

How do you define one?

Using the class keyword class my object? Inside you often define a special method called innit that's the constructor. It runs when you create a new instance of the class and usually sets up the initial attributes.

The book had that frack example for fractions right with AD and mole.

Methods exactly, and it used other special methods like repro to control how the fraction object gets printed.

And things like AD and moll right.

Those allow operator overloading. By defining AD, you tell Python what the plus operator should do when used with your Frack objects. It makes your custom objects behave more intuitively like built in types.

Very cool. Let's look back to modules. You said they're key for scientific work.

Absolutely central. Most of the powerful scientific tools NUMBPI for arrays, SIPI for algorithms, matt plotlib for plotting, PANDAS for data analysis are external libraries you access as modules.

So a module is just a dot pi file with.

Code essentially Yes, it contains functions, classes, variables. You use the import statement to bring that code into your program's namespace, like import math YEP. Then you access things inside it using the dot dot math dot pi math dot sinx. This dot mechanism is fundamental in Python for accessing attributes and methods of objects and modules.

Can you import just one thing or give the module a shorter name.

Yes. From math import score, lets you use squort directly and import NumPy as NP is super common. It imports numpi, but lets you refer to it as MP, saving typing NP dot ray, NP, dot mean, et cetera.

Mastering that import in dot mechanism seems crucial, then.

It really is key to using Python effectively for science.

Finally, the book mentions PEP eight the style Guide. Why worry about style isn't getting the right answer the main thing.

Getting the right answer is critical, of course, but how you write the code matters hugely, especially in science. PP eight is about making code readable, consistent, and understandable.

Why is readability so important?

Remember the zen of Python readability count. Code is read far more often than it's written. If you're collaborating, others need to understand your code. If you revisit your own code months later, you need to understand it. Clear. Consistent code aids transparency and reproducibility.

So what are some key PP eight guidelines?

Things like using four spaces for indentation, never tabs, limiting line length to make it easy to read around seventy nine or maybe a bit more characters, using meaningful variable names, using blank lines to group logical sections, consistent spacing around operators, adding comments where needed, but not over commenting obvious things.

So it's worth taking the time to learn and follow.

These Definitely it makes you a better programmer and makes your scientific code more valuable in the long run. The book links to the full guide.

Okay, wow, we've covered a lot.

Yeah, quite a tour. So just to recap, we've seen why Python is so big in science. It's accessible, flexible, explicit. We hit the basics data types like numbers, strings, lists, tuples, control flow with if and loops, building or usable code with functions, handling files and errors, even dipped into classes, and the vital role of modules like NUMPI.

And the importance of clean, readable code. With PP eight, it really feels like a solid foundation for tackling scientific programming.

Absolutely. Python gives you the tools to handle complex data, build models, test hypotheses, all that good scientific stuff.

And the book and the official Python docs online are great places to go next for more details, for.

Sure, the documentation for lists, control flow functions, file io errors, classes PEP eight. It's all there and very comprehensive, definitely worth exploring.

All right, So here's something to chew on as we wrap up. Take a look at how you currently work your analysis you're modeling. Where could Python fit in? Could it automate some tedious stuff? Could it let you analyze data in new ways or build more complex models than you could before?

Yeah, think about how it might streamline things or even open up entirely new scientific questions you could tackle.

Food for thought. Thanks for joining us for this deep dive.