How to write scripts in python

Writing your first Script

Before we write anything, let’s create a folder to hold your Python scripts.

Usually you would choose a hierarchy that’s sensible for you (for example I use Documents/programming/python in my home directory as the root for all of my Python projects!).

For the purposes of this workshop, let’s use your Desktop folder in your U drive and create a folder called

*nix users

Similar to above, but place the python_workshop folder in your home folder (e.g. /home/ubuntu for openstack users).

NB

It’s a slightly confusing convention, but a user’s home folder is the path /home/username , not simply /home .

What is a Python Script?

A Python script is just a plain text file, and the convention is to use the extension .py (instead of e.g. .txt ) to let programs know that it holds Python code.

Python code is very close to something called pseudo-code, which is what people use when detailing the main components of an algorithm.

For example, the pseudo-code for the factorial function (e.g. 3! = 3 x 2 x 1) is

SET fact to n WHILE n is more than 1 SET fact to fact times (n - 1) SET n to n - 1 

fact = n while n > 1: fact = fact * (n-1) n = n - 1 

What this simple example illustrates, is that Python is extremely readable; it just takes becoming familiar with a few base syntax rules (~grammar).

We’ll be speaking Python in no time!

Worked Exercise : Hello, world!

We’ll start by creating a blank Python script file.

Creating a file

We’re going to name our first script file exercise_hello_world.py and keep it inside the newly created python_workshop folder.

To do this, open Notepad++ . You should see a blank file (that may be named “new 1”, or “new 2” etc, depending on if you closed any tabs!).

If you don’t see a blank file, select File->New from the menu bar.

Then select File->Save As , navigate to the python_workshop folder we created a few minutes ago, and set the file name to exercise_hello_world.py and click Save.

Now that we have a blank Python script file, lets start adding some code!

Initial content

 # Author: Your Name # This is a script to test that Python is working 

replacing the text in the line starting # Author with your details.

Running the script with Python: The Terminal

Now let’s see what running this through Python does!

Start a customized command prompt (reminder: in the Windows File Explorer, find the WinPython3 folder on the C: drive, and click on WinPython Command Prompt.exe).

A terminal window should pop up, that looks a little bit like

Reminder: Basic terminal usage

You were advised to have basic knowledge of using a terminal (Windows Command Prompt/Linux Terminal/MacOS Terminal), you are about to see out why!

Here’s a recap of the things you’re most likely to need.

Windows	MacOS / Linux	What it does
`cd FOLDER_NAME`	`cd FOLDER_NAME`	Change directory to FOLDER_NAME
`dir FOLDER_NAME`	`ls FOLDER_NAME`	List folder contents; if FOLDER_NAME is omitted, list current folder contents
`..`	`..`	Reference to parent folder. E.g. `cd ..` is how you would navigate from `/a/b/c/` to `/a/b/` if you are currently in `/a/b/c/`.
`mkdir FOLDER_NAME`	`mkdir FOLDER_NAME`	Create a folder called FOLDER_NAME

Quick note on terminology

Folder and directory refer to the same thing, while full path or absolute path means the full directory location. E.g. if you’re currently in your Desktop folder, the folder is Desktop, but the full path is something like /users/joe/Desktop . If you’re on Windows the path starts with a drive letter too, like “C:” or “U:”, and the forward-slashes will be backslashes instead.

Console and terminal (and sometimes shell) are usually used interchangeably to mean the same thing; the text-based interface where commands can be entered. In windows, the built-in console is also called the “command prompt” and is started using cmd.exe .

For our purposes, we’re going to be mainly interested in the terminal console which is where we type commands like cd , or dir .

For interactive Python snippet testing we can also use the Interactive Python console, which is where we can directly type python commands. You might encounter this later; for now just be aware that there are these two types of console.

Now using the terminal command to change directory, cd , navigate to your Desktop directory.

You can verify that it contains your new python_workshop folder by using the windows terminal command dir :

Источник

Writing a Script in Python

So far, we have covered the main programming structures used in Python. We will now put that together in a script which can be run on demand.

Using Spyder which is part of the Anaconda suite

Spyder is an application where you can edit and run your Python scripts. As part of Anaconda, there are a large number of scientific packages which come pre-installed, to make it easier for scientists getting started in programming.

We will run through a brief overview of the panels:

1. Left panel: Editor
   • this is a special type of editor which understands python
   • as you type, possible options may appear to assist you
   • key words are highlighted to help readability and understanding
2. Top Right panel: Help
   • Variable explorer: as a program runs, variables are loaded here with their values
   • File explorer: list of files in the current working directory
   • Help: documentation and tutorials
3. Bottom Right panel: Console
   • Python console: standard python command-line (like typing python in a terminal window)
   • IPython console: interactive python (like Jupyter cells)

Organizing your code to run as a script

In Spyder, a new file is created when you first open the application. This is called temp.py.

1. Create a new project under Projects ->New Project in your required directory
2. Save the temp file to hello.py
3. Type the following (the HelloWorld mantra):

1. Click on the green arrow in the top toolbar. A popup window may appear which allows you to change a few things. Accept the defaults and click OK
2. Have a look in the IPython console window and you should see the output similar to:

runfile('D:/Projects/Python-tutorial/examples/hello.py', wdir='D:/Projects/Python-tutorial/examples') Hello World 

Methods

Recall that it is useful to group code into methods so replace the code with:

def hello(): """Print "Hello World" and return None""" print("Hello World") # main program starts here hello() 

1. Run again as before and the same output will appear in the console window.
2. As we have run the output in the IPython console window and we have defined a method called hello() , what will happen if we just type hello() in the console?

Libraries

We will now use a library as we did in previous lessons. Take note of the order.

1. The import statement goes at the top
2. The methods should come next but should be before the instructions (main body)
3. The instructions for running the methods go at the end

import math def hello(): """Print "Hello World" and return None""" print("Hello World") def get_pi(): """Get value of pi""" return math.pi # main program starts here hello() print('pi is', get_pi()) 

After running this script, you can type help(math) in the IPython console — just as we did in Jupyter but it has to be loaded with import math first

External

Before we move on, there is an extra line recommended when running the script from outside this environment:

Insert this line above hello() then indent the following code:

# main program starts here if __name__ == '__main__': hello() print('pi is', get_pi()) 

This allows us to run from a terminal window: python hello.py

Flexible code — running with arguments

So how would we make this script more dynamic?

We will change the hello() method to take a variable name .

def hello(name): """Print "Hello " and a name and return None""" print("Hello", name) . hello("Josephine") 

After running the script, in the IPython console, type hello(«Napoleon») or any other name

Challenge

Change the call function to loop over a few names (your first spamming script!).

External Arguments

But these are still variables defined in the script, how do we pass variables in from the command line? There is a library called sys which allows your script to read from the system in which it is running. Variables passed in are called arguments and are strings which are stored in a list called sys.argv

In a new script called sysargs.py, type:

import sys # main program starts here if __name__ == '__main__': program = sys.argv[0] print("Program running is:", program) 

Only one argument is present and that is the name of the program which is running — this will always be the case. We will now include two extra arguments so add some extra lines to the code:

import sys # main program starts here if __name__ == '__main__': program = sys.argv[0] print("Program running is:", program) #Now check for extra arguments if (len(sys.argv) == 3): argument1 = sys.argv[1] argument2 = sys.argv[2] print("Arguments:", argument1, argument2) 

1. In Spyder, we can add the extra arguments by:
   1. Run ->Configure
   2. Check Command line options then enter “hello world” in the text field
   3. Click on OK

   Challenge

   Return to your hello.py script and allow the name to be entered as an argument

   import sys import re def hello(name): """Print "Hello " and a name and return None""" print("Hello", name) def valid(name): '''Only words with characters, underscores or hyphens are valid''' # Provide a validity check to ensure bad stuff is not passed in # Introducing a new library called `re` match = re.match(r'^[A-Za-z0-9_\-]+$', name) if (match): isvalid = True else: isvalid = False return isvalid # main program starts here if __name__ == '__main__': randomname = None #ensure that this variable is clean to start if (len(sys.argv) > 1): #test whether any arguments have been passed in randomname = sys.argv[1] # Check that name is a valid string if (randomname is not None and valid(randomname)): hello(randomname) else: print("No name passed in") 

   WARNING!! Allowing information to be passed into your script this way can be DANGEROUS. The argv array should never be read directly without checking the validity of the contents first.

   ArgParse: Safe use of external arguments

   To help you with checking that nothing malicious is passed into your script, use a library called argparse . The argparse module makes it easy to write user-friendly command-line interfaces. The program defines what arguments it requires, and argparse will figure out how to parse those out of sys.argv . The argparse module also automatically generates help and usage messages and issues errors when users give the program invalid arguments.

   We will update the previous script:

   import argparse import re def hello(name): """Print "Hello " and a name and return None""" print("Hello", name) def valid(name): '''Only words with characters, underscores or hyphens are valid''' # Provide a validity check to ensure bad stuff is not passed in # Introducing a new library called `re` match = re.match(r'^[A-Za-z0-9_\-]+$', name) if (match): isvalid = True else: isvalid = False return isvalid # main program starts here if __name__ == '__main__': #Setup the argument parser class parser = argparse.ArgumentParser(prog='Hello program', description='''\ Reads a name and says hello ''') #We use the optional switch -- otherwise it is mandatory parser.add_argument('--randomname', action='store', help='A name', default="Josephine") #Run the argument parser args = parser.parse_args() #Extract our value or default randomname = args.randomname # Check that name is a valid string if (randomname is not None and valid(randomname)): hello(randomname) else: print("No name passed in") 

   1. As before, use the Run ->Configure to add Command-line options —randomname Napoleon , ‘OK’
   2. Now Run

   We will now move onto the next lesson Handling errors

   Источник

   Читайте также:  Fork join framework java