About Libraries

Pip
The pip package manager makes it easy to install open-source libraries that expand what
you’re able to do with Python.
Later, we will use it to install everything needed to create a working web application.
If you don’t have it already, you can get pip by following these instructions. In Windows, it’s
necessary to make sure
that the Python Scripts directory is available on your system’s PATH so it can be called from
anywhere on the command line. This screencast can help.
Verify pip is installed with the following.
$ pip -V

Tkinter

The primary GUI toolkit we will be using is Tk, Python’s default GUI. We’ll access Tk from
its Python interface called Tkinter (short for “Tk interface”).
Tk is not the latest and greatest, nor does it have the most robust set of GUI building blocks,
but it is fairly simple to use, and with it, you can build GUIs that run on most platforms.
Once you have completed tkinter, you will have the skills to build more complex
applications and/or move to a more advanced toolkit. Python has bindings or adapters to
most of the current major toolkits, including commercial systems.

What Are Tcl, Tk, and Tkinter?

Tkinter is Python’s default GUI library. It is based on the Tk toolkit, originally designed for
the Tool Command Language (Tcl). Due to Tk’s popularity, it has been ported to a variety of
other scripting languages, including Perl (Perl/Tk), Ruby (Ruby/Tk), and Python (Tkinter).
The combination of Tk’s GUI development portability and flexibility along with the
simplicity of a scripting language integrated with the power of systems language gives you
the tools to rapidly design and implement a wide variety of commercial-quality GUI
applications.
Python, along with Tkinter, provides a fast and exciting way to build useful applications that
would have taken much longer if you had to program directly in C/C++ with the native
windowing system’s libraries.

Windows and Widgets

In GUI programming, a top-level root windowing object contains all of the little windowing
objects that will be part of your complete GUI application. These can be text labels, buttons,
list boxes, etc. These individual little GUI components are known as widgets.
So when we say create a top-level window, we just mean that you need a place where you put
all your widgets. In Python, this would typically look like this line: top = Tkinter.Tk() or just
Tk() with "from Tkinter import *"
The object returned by Tkinter.Tk() is usually referred to as the root window; hence, the
reason why some applications use root rather than top to indicate as such. Top-level windows
are those that show up stand-alone as part of your application.

You can choose to completely design all your widgets first, and then add the real
functionality, or do a little of this and a little of that along the way.
Widgets can be stand-alone or be containers. If a widget contains other widgets, it is
considered the parent of those widgets. Accordingly, if a widget is contained in another
widget, it’s considered a child of the parent, the parent being the next immediate enclosing
container widget.
Usually, widgets have some associated behaviours, such as when a button is pressed, or text
is filled into a text field. These types of user behaviours are called events, and the GUI’s
response to such events are known as callbacks.

Event-Driven Processing
Events can include the actual button press (and release), mouse movement, hitting the Return
or Enter key, etc. The entire system of events that occurs from the beginning until the end of
a GUI application is what drives it. This is known as event-driven processing.
One example of an event with a callback is a simple mouse move.
so everything just remains idle on the screen again.

• The event-driven processing nature of GUIs fits right in with client/server architecture.
• When you start a GUI application, it must perform some setup procedures to prepare for the
core execution, just as how a network server must allocate a socket and bind it to a local
address.
• This loop runs forever waiting for GUI events, processing them, and then going to wait for
more events to process.

Geometry Managers
Geometry managers allow us to organize widgets inside of a container
Tk has three geometry managers that help with positioning your widgetset:
• Placer: You provide the size of the widgets and locations to place them; the manager then
places them for you. The problem is that you have to do this with all the widgets, burdening
the developer with coding that should otherwise take place automatically.
• Packer: it packs widgets into the correct places (namely the containing parent widgets,
based on your instruction), and for every succeeding widget, it looks for any remaining “real
estate” into which to pack the next one. The process is similar to how you would pack
elements into a suitcase when traveling.
• Grid: It is used to specify GUI widget placement, based on grid coordinates. The Grid will
render each object in the GUI in their grid position.

Tkinter Events and Binding

<Button‐1> ‐ left mouse button
<Button‐2> ‐ middle mouse button (on 3 button mouse)
<Button‐3> ‐ rightmost mouse button
<B1‐Motion>‐ mouse moved with left button depressed
<ButtonRelease‐1>- left button released
<Double‐Button‐1>‐ double click on button 1
<Enter> ‐ mouse pointer entered widget
<Leave> ‐ mouse pointer left the widget
<FocusIn> ‐ Keyboard focus moved to a widget
<FocusOut> ‐ Keyboard focus moved to another widget
<Return> ‐ Enter key depressed
<Key> ‐ A key was depressed
<Shift‐Up> ‐ Up arrow while holding Shift key

Tk Widgetsget Description
Button Similar to a Label but provides additional functionality for mouse-overs, presses, and
releases, as well as keyboard activity/events.
Canvas Provides ability to draw shapes (lines, ovals, polygons, rectangles); can contain
images or bitmaps.
Checkbutton Set of boxes, of which any number can be “checked”.
Entry Single-line text field with which to collect keyboard input.
Frame Pure container for other widgets.
Label Used to contain text or images.
LabelFrame Combo of a label and a frame but with extra label attributes.
Listbox Presents the user with a list of choices from which to choose.
Menu Actual list of choices “hanging” from a Menu button from which the user can choose.
Menubutton Provides infrastructure to contain menus (pulldown, cascading, etc.)
Message Similar to a Label, but displays multiline text.
PanedWindow A container widget with which you can control other widgets placed within
it.
Radiobutton Set of buttons, of which only one can be “pressed”.
Scale Linear “slider” widget providing an exact value at current setting; with defined starting
and ending values.
Scrollbar Provides scrolling functionality to supporting widgets, for example, Text, Canvas,
Listbox, and Entry.
Spinbox Combination of an entry with a button letting you adjust its value
Text Multiline text field with which to collect (or display) text from user
Toplevel Similar to a Frame, but provides a separate window container
pymysql

In order to connect Python to a database you need a driver, which is a library used to Interact
with the database. For MySQLdatabase, you have such 3 Driver choices:
1. MySQL/connector for Python
2. MySQLdb
3. PyMySQL

MySQL/Connector for Python This is a library provided by the MySQL community.

MySQLdb MySQLdb is a library that connects to MySQL from Python, it is written
in C language and it is free and open source software.
PyMySQL This is a library that connects to MySQL from Python and it is a pure Python
library. PyMySQL's goal is to replace MySQLdb and work
on CPython, PyPy and IronPython.
PyMySQL is an open source project.

Install PyMySQL
In order to install PyMySQL on Windows (or Ubuntu/Linux) you need to open
the CMD window, and run the following statement: pip install PyMySQL.

Connection Object
classpymysql.connections.Connection(host=None, user=None, password='', 
database=None)
Representation of a socket with a mysql server.
The proper way to get an instance of this class is to call connect().
Establish a connection to the MySQL database. Accepts several arguments:

Basic Parameters:  host – Host where the database server is located

 user – Username to log in as
 password – Password to use.
  database – Database to use, None to not use a
particular one.

Cursor Objects
classpymysql.cursors.Cursor(connection)
This is the object you use to interact with the database.
Do not create an instance of a Cursor yourself. Call connections.Connection.cursor().
Methods of cursor object
close() Closing a cursor just exhausts all remaining data.
execute(query, args=None) Execute a query

 query (str) – Query to execute.

Parameters:  args (tuple, list or dict) – parameters used with
query.

Returns: Number of affected rows

Return
int
type:
If args is a list or tuple, %s can be used as a placeholder in the query. If args is a dict, %
(name)s can be used as a placeholder in the query.
fetchall() Fetch all the rows
fetchmany(size=None) Fetch several rows
fetchone() Fetch the next row

sys

The sys module in Python lets us access system-specific parameters

and functions. It gives us information about constants, functions, and
methods of the interpreter.
We can store the command-line arguments we pass to a script in a list we
call sys.argv. The first item of this is the name of the script; the
arguments are next.
We’ve so often used the Python shell interactively and even as a
calculator. We simply rebind sys.displayhook to a callable object.
We can also use the readline() method to get input from the user.

Notice that it gives us the number of characters, which is why it gives us

13 instead of 12 when we give it a \n newline character too at the end.
sys.modules in Python gives us a dictionary of the names of the modules
existing in the current shell.
sys.path in Python will give you a list of paths it will search in whenever
you make an import.
Now, when you make a call to sys.path in Python, you can see this
location in the list.
sys.copyright in Python displays the copyright information on the
currently-installed version of Python.
sys.exit in Python lets the interpreter abruptly exit the current flow of
execution.
You can use a try-except block to catch the call.
The getrefcount function gives us the count of references to an object
where used. When in a program, this value drops to 0, Python cleans up
the memory for this variable.

To get the name of the platform we’re running Python on, we make a call
to sys.platform in Python.
Instead of delivering the output to the console, you can log into a text file.
Using sys.stderr and a text file in Python, we can log error information to
the text file.
Note that this traceback doesn’t show up in the log file until we close its file object in
Python (which, in this case, is fsock).

Unlike stdout, stderr does not add carriage returns.

A similar function flush() lets us flush write buffers.
The purpose of this tutorial is to get you started with the sys module;
there is so much more to it.
To get a list of all the built-in functions and methods we have for sys, try
the calling the dir() function on it.