Lecture 4. Introduction to Python! Lecture 4

Transcription

1 Lecture 4 Introduction to Python Lecture 4

2 Summary Modules (general things) Using modules Importing modules Standard Library modules Modules search path Import modules phases Packages Organizing Python applications

3 Modules Python modules Module File level program data Program and data packed together

4 Roles Code persistence Place to define names (attributes) Supports modular design architecture Code Reuse Module

5 Roles Code persistence Place to define names (attributes) Supports modular design architecture Code Reuse Module System namespace partitioning Avoids name clashing across the programs The names defined in modules are self-contained, they can be seen in other files only by using import

6 Roles Code persistence Place to define names (attributes) Supports modular design architecture Code Reuse Implementing shared services and data Module System namespace partitioning Helpful in implementing components shared across a program, requiring a single copy Avoids name clashing across the programs The names defined in modules are self-contained, they can be seen in other files only by using import

7 Python program structure module 2 Contains the main flow of the program This file runs when application launches module 1 Python top level file module 3 Modules usually are collections of functions and attributes module N One main top level file Zero or more additional files, named modules

8 Using modules Let s suppose we want to create a table header that looks like: id....name....title contains functions used to draw tables table.py main.py top level file strings.py contains functions used to decorate strings

9 Using modules def line(n): """ creates a dashed line of n dots """ return '-' * n table.py import table import strings print(table.line(30)) print(strings.dots('id') + ' ' + strings.dots('name') + ' ' + strings.dots('title')) print(table.line(30)) def dots(s): """ add dots in front and after a string sent as parameter """ return '..' + s + '..' strings.py main.py

10 Using modules Note that when importing table.py module, we are writing import table without using.py extension Importing table module gives access to the all the attributes defined at the top level of the table.py file. The modules import operation is performed at runtime. If the module defines objects, they are created at runtime, as the import executes. import table print(table.line(30)) Here, the method line(n) of the module table is used in the main.py file Python uses the object.attribute notation. This means Python fetches the attributes defined in different objects by the. operator.

11 Importing modules b.py a.py main.py If main.py depends on a.py and c.py, but a.py depends on b.py and copy depends on d.py, Pyhton will load all dependencies, no matter how deeper it should go through dependencies chain. c.py d.py If many files have a common dependency, that one will be loaded only once.

12 Standard Library Modules Standard Library Modules Collection of more than 200 modules, providing support for: object persistence operating system interfaces network scripting internet scripting GUI text pattern matching math many more These modules are not part of the core Python language, but they can be used by importing them. Also, coming in the Python distribution, you can be sure they work on most platforms Python runs.

13 Some modules from Python Standars Library Module Description datetime tempfile csv hashlib logging threading html os Performs calculation using date and time Functions for working with temporary files and directories CSV files processing Cryptographically secure hashes Write log messages and manages log files Supports multi-threading programming Collection of modules used to parse and generate HTML documents Supports calls to the OS specific commands

14 Examples of using standard library import calendar print(calendar.isleap(1900)) print(calendar.isleap(1993)) print(calendar.isleap(2000)) Output: False False True import random cars = ['Mercedes', 'Audi', 'BMW', 'Opel'] print(random.choice(cars)) Output: Opel import math print(math.radians(90)) print(math.sin(math.radians(90))) Output: import os print(os.getcwd()) Output: /PycharmProjects/uvt/lect-4

15 Backstage of the import operation example code here example.h #include example.h caller code here caller.cpp preprocessor a.py Find a.py Compile a.py Run a.py example code here caller code here C++ language main.py Python language

16 Modules search path In order to localise a module, Python looks for it on some predefined locations: 1. The home directory of the program 2. PYTHONPATH directory 3. Standard Library directories 4. The contant of any.pth file, if this is present 5. The site-packages home for third party extensions The result of concatenation of all these paths is a variable called sys.path (we ll talk about it later in this chapter)

17 Import phases Find modules Python does not require the path of the module in import Python does not require the extension of the file module in import (.py) It uses a module search path and known file types to locate the required modules Compile modules After the module was found, using the search method described above, it compiles in in byte code, if some conditions occur: Checks the timestamp of the Python source code (.py) and the timestamp of the compiled code (.pyc). If the source timestamp is newer than compiled timestamp, the code is compiled again. Python 3.2 or newer: the compiled files are aggregated under a pycache directory Suppose you have a file called base.py, Python creates a pycache subdirectory and inside there will be a file called base.cpython-25.pyc (if the current Python version is 3.5)

18 Import phases Compilation occurs only when the module is imported somewhere. Only the files that were imported have the.pyc correspondent. The top-level file also does not have a.pyc file, unless it was imported elsewhere. As a general rule, top-level files are designed to be executed directly and not imported. However, the top-level modules are also compiled but their byte code is discarded immediately after execution Run modules All the statements written in the file are executed from top to bottom and any assignment made to different names become attributes of the resulting module object. def fact(x): if x == 1: return 1 else: return x * fact(x -1) def runs at import time, creating the fact function, then it assigns an attribute with the same name in the module

19 Conclusions for modules import Some important conclusions related to modules import Importing a module is a complex process It requires finding it, compiling if necessary, then running it Due to its complexity, importing of a module is performed only once per process (by default) Any other attempt to import the same module after it was already imported will skip all the import phases and will use de module loaded in memory

20 Where Python looks for modules? In order to see where Python is looking for modules, run the following commands, from the interpreter (but they could be run from program too) >>> import sys >>> sys.path sys.path is a system variable A concrete example for which the output is: ['/Applications/PyCharm CE 2.app/Contents/helpers/pydev', '/Applications/ PyCharm CE 2.app/Contents/helpers/pydev', '/Projects/UVT/python_env/lib/ python35.zip', '/Projects/UVT/python_env/lib/python3.5', '/Projects/UVT/ python_env/lib/python3.5/plat-darwin', '/Projects/UVT/python_env/lib/ python3.5/lib-dynload', '/usr/local/cellar/python3/3.5.2/frameworks/ Python.framework/Versions/3.5/lib/python3.5', '/usr/local/cellar/ python3/3.5.2/frameworks/python.framework/versions/3.5/lib/python3.5/ plat-darwin', '/Projects/UVT/python_env/lib/python3.5/site-packages', '/ PycharmProjects/uvt/lab 4']

21 Extending sys.path If we need to extend the path in which Python searches for modules, we can append the new path to the sys.path variable. Suppose we want to add a new directory called ProgEnvExamples located in /Projects/UVT >>> sys.path.append('/projects/uvt/progenvexamples') >>> sys.path And now the output is: ['/Applications/PyCharm CE 2.app/Contents/helpers/pydev', '/Applications/ PyCharm CE 2.app/Contents/helpers/pydev', '/Projects/UVT/python_env/lib/ python35.zip', '/Projects/UVT/python_env/lib/python3.5', '/Projects/UVT/ python_env/lib/python3.5/plat-darwin', '/Projects/UVT/python_env/lib/ python3.5/lib-dynload', '/usr/local/cellar/python3/3.5.2/frameworks/ Python.framework/Versions/3.5/lib/python3.5', '/usr/local/cellar/ python3/3.5.2/frameworks/python.framework/versions/3.5/lib/python3.5/ plat-darwin', '/Projects/UVT/python_env/lib/python3.5/site-packages', '/ PycharmProjects/uvt/lab 4, '/Projects/UVT/ProgEnvExamples'] This is a temporary change. When exiting Python, the change will disappear

22 Importing names from a module Now, that we ve found how imports work, let s take a closer look on how we can avoid memory overloading with unnecessary imports. Suppose we need some functions from one or many big modules. Say that our module is called database which contains a lot of methods related to processing records from a database, but our program does need only a method that selects specific records, called select. We can access the select method in two ways: 1 import database database.select(args) In this case, Python loads the entire module, create the function objects in memory, prepares the module for being used by the caller If it is large, it will occupy memory for attributes that will never being used. 2 from database import select select(args) In this case, Python loads only the select method in memory and prepares the module for being used by the caller Only a small amount of memory will be used.

23 Running modules from the command line Python supports a similar functionality with other programming languages in what concerns the main() function, which executes when the application is launched. Usually, top-level files are designed with this feature in mind. def main(): print('hi from command line') if name == ' main ': main() global variable which is set by the Python interpreter to main when the user starts the program

24 Packages Python allows module to group classes and function together for a better organisation. One level up, it allows to group modules having common characteristics in something called a package. Considering we have an application processing geometrical shapes, we can have a file structure like: /shapes init.py square.py rectangle.py circle.py triangle.py polygon.py package name special file called package initialisation file import shapes.circle a = shapes.circle.area(radius) print(a) Note the. (dot) notation

25 Initialising a package When initialising a package, it is possible to write some code inside init.py file of the my_package package. def greetings(msg): print(msg) The greetings function will be available at the package level When called, the code looks like this: import my_package my_package.greetings( Hi, package ) Even it looks tempting to put some code there, it isn t always a good idea, from the organisation point of view. The code should be kept tied to the modules, to split the functionality and keep the consistence

26 Initialising a package If it is still the need for accessing a function at the package level, a better approach is to define a function at a module level, then import it in init.py file. In this way it will become available at the package level. my_module.py file: def greetings(msg): print(msg) init.py file: from my_package.my_module import greetings When called, the code looks like this: import my_package my_package.greetings( Hi, package )

27 Catalogue application User User interface Users Authentication Grades Viewer Grades Editor Reports Viewer API Backend Database Reports Generator Errors processor s processor

28 Organizing the application /user_interface init.py users_auth.py viewer.py editor.py reports.py api.py } packages /backend init.py database.py report_generator.py error_processor.py er.py } modules

29 Advantages of using modules Module 1 Module 2 New Module Main program Module 3 When a new functionality is needed, a new module can be added without interfering with the other modules. Module 1 Module 2 Change Module Module 3 When some changes are required inside a module, they are isolated, they don t affect the already existing modules Main program

30 Conclusions Modules and packages are a way to structure Python programs to support large applications The process through modules can be used in Python applications is called import The modules import has three phases: module finding, compiling (if necessary) and run