Program Arcade GamesWith Python And Pygame

A library is a collection of code for functions and classes. Often, these
libraries are written by someone else and brought into the project so that
the programmer does not have to “reinvent the wheel.” In Python the term
used to describe a library of code is module.

By using import pygame and import random, the programs
created so far have already used modules. A library can be made up of multiple
modules that can be imported. Often a library only has one module, so these words
can sometimes be used interchangeably.

Modules are often organized into groups of similar functionality. In this class
programs have already used functions from the math module,
the random module, and the pygame library. Modules can be
organized so that individual
modules contain other modules. For example, the pygame module contains
submodules for pygame.draw, pygame.image, and pygame.mouse.

Modules are not loaded unless the program asks them to. This saves time and computer
memory. This chapter shows how to create a module, and how to import and use that module.

There are three major reasons for a programmer to create his or her own
libraries:

It breaks the code into smaller, easier to use parts.

It allows multiple people to work on a program at the same time.

The code written can be easily shared with other programmers.

Some of the programs already created in this book have started to get rather long.
By separating a large program into several smaller programs, it is easier to
manage the code. For example, in the prior chapter's sprite example, a programmer
could move the sprite class into a separate file. In a complex program, each sprite
might be contained in its own file.

If multiple programmers work on the same project, it is nearly impossible to do
so if all the code is in one file. However, by breaking the program into multiple
pieces, it becomes easier. One programmer could work on developing an “Orc” sprite
class. Another programmer could work on the “Goblin” sprite class. Since the sprites
are in separate files, the programmers do not run into conflict.

Modern programmers rarely build programs from scratch. Often programs are built
from parts of other programs that share the same functionality. If one programmer
creates code that can handle a mortgage application form, that code will ideally
go into a library. Then any other program that needs to manage a mortgage application
form at that bank can call on that library.

In this example we will break apart a short program into multiple files. Here
we have a function in a file named test.py, and a call to that function:

# Foo function
def foo():
print("foo!")
# Foo call
foo()

Yes, this program is not too long to be in one file. But if both the function
and the main program code were long, it would be different.
If we had several functions, each 100 lines long, it would be time consuming to
manage that large of a file.
But for this example we will keep the code short for clarity.

We can move the foo function out of this file. Then this file would be
left with only the main program code.
(In this example there is no reason
to separate them, aside
from learning how to do so.)

To do this, create a new file and copy the foo function into it.
Save the new file with the name my_functions.py. The file must be
saved to the same directory as test.py.

# Foo function
def foo():
print("foo!")

# Foo call that doesn't work
foo()

Unfortunately it isn't as simple as this. The file
test.py does not know to go and look at
the my_functions.py file and import it. We have to
add the command to import it:

A program might have two library files that need to be used. What if the libraries
had functions that were named the same? What if there were two functions named
print_report, one that printed grades, and one that printed an account
statement?
For instance:

def print_report():
print("Student Grade Report:" )

def print_report():
print("Financial Report:" )

How do you get a program to specify which function to call? Well, that is pretty
easy. You specify the namespace. The namespace is the work that appears before
the function name in the code below:

So now we can see why this might be needed. But what if you don't have name
collisions? Typing in a namespace each and every time can be tiresome. You can get
around this by importing the library into the local namespace. The local
namespace is a list of functions, variables, and classes that you don't have to
prepend with a namespace. Going back to the foo example, let's remove the original
import and replace it with a new type of import:

# import foo
from my_functions import *
foo()

This works even without my_functions. prepended to the function call.
The asterisk is a wildcard that will import all functions from my_functions. A programmer
could import individual ones if desired by specifying the function name.

Going through lists of libraries that are available can help you
brainstorm what types of programs you can create. Most programming
involves assembling large parts, rather than writing everything from
scratch.

You can install Beautiful Soup from the Windows command prompt by
typing pip install bs4. If you are on
the Mac or a Linux machine, you can type pip3 install bs4.

"""
Example showing how to read in from a web page
"""
from bs4 import BeautifulSoup
import urllib.request
# Read in the file
url= "http://www.espnfc.com/spi/rankings/_/view/fifa/teamId/203/mexico?cc=5901"
page = urllib.request.urlopen(url)
soup = BeautifulSoup(page.read(), "html.parser")
# Find the table with the data
rank = soup.find("table").tbody
# Get a list of rows in the table
rows = rank.findAll("tr")
# Loop through each row
for row in rows:
# Get a list of cells in the row
cells = row.findAll("td")
# Loop through each cell
for cell in cells:
print(cell.text, end=", ")
# Ok, done with that row. Print a blank line so we go to the next.
print()

Note that you can zoom in, pan, and save the graph. You can even save the graph
in vector formats like ps and svg
that import into documents without loss of quality
like raster graphics would have.

The x value for Example 1, Figure 14.1 defaults to
start at zero. You can change this default and specify your own x values to go with the y
values. See Example 2 below.
Figure 14.2: Specifying the x values