🗊Презентация Python

Python Vasiliy Kovalev MERA - 2019

About Python

What is Python? A programming language Open Source Free; source code available Download on your own system Written by Guido van Rossum Monty Python’s Flying Circus…

Features of Python A script language Interpreted No compile/link stage Write and run Slow compared to C, C++ Elegant design; “tight” Designed for Quick-and-dirty scripts Reusable modules Very large systems Object-oriented Very well-designed But you don’t have to use it

The Zen of Python Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren’t special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one — and preferably only one — obvious way to do it. Although that way may not be obvious at first unless you’re Dutch. Now is better than never. Although never is often better than 'right now'. If the implementation is hard to explain, it’s a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea — let’s do more of those!

Part 1: Variables and built-in types

Basic data types

Useful functions type(object) – returns type of an object dir(object) – returns a list of attributes for an object

Useful functions help(object) – returns description of an object

Numeric types and literals

Numeric tools

Boolean expressions ‘True’ and ‘ False’ are predefined values; actually integers 1 and 0 Value 0 is considered False, all other values True The usual Boolean expression operators: not, and, or

String Single quotes or double quotes can be used for string literals Produces exactly the same value Special characters in string literals: \n newline, \t tab, others Triple quotes useful for large chunks of text in program code

String conversions Convert data types using functions ‘str’, ‘int’, ‘float’ ‘repr’ is a variant of ‘str’ intended for strict, code-like representation of values ‘str’ usually gives nicer-looking representation Function ‘eval’ interprets a string as a Python expression

String operations Common string operations on page 75 in ‘Learning Python’

Changing strings. Not! A string cannot be changed in Python! Immutable Good reasons for this; more later Create new strings from bits and pieces of old

String methods Strings have a set of built-in methods No method ever changes the original string! Several methods produce new strings A list on page 91 in ‘Learning Python’

List Ordered collection of objects; array Heterogenous; may contain mix of objects of any type

List operations Lists are mutable; can be changed in-place Lists are dynamic; size may be changed

List methods, part 1 Lists have a set of built-in methods Some methods change the list in-place

List methods, part 2 Use the built-in 'sort' method: efficient The list is sorted in-place; a new list is not produced!

Objects, names and references All values are objects A variable is a name referencing an object An object may have several names referencing it Important when modifying objects in-place! You may have to make proper copies to get the effect you want For immutable objects (numbers, strings), this is never a problem

Dictionary An unordered collection of key/value pairs Each key maps to a value Also called "mapping", "hash table" or "lookup table"

Forgetting things: garbage collection What happens to the object when its name is ’del’ed, or reassigned to another object? Don’t worry, be happy! The Python systems detects when an object is ’lost in space’ It keeps track of the number of references to it The object’s memory gets reclaimed; garbage collection A few problematic special cases; cyclical references

Dictionary methods, part 1

Dictionary methods, part 2

Tuple Same as list, except immutable Once created, can't be changed Some functions return tuples

String formatting Tuples are used as operands in string formatting when >1 items The length of the tuple must match the number of format codes in the string Lists won't do!

Part 2: Statements

'if' statement; block structure The Python feature that one either loves or hates Block structure is determined by indentation Edit a new script file 't2.py' In window 't1.py' do 'File', 'New Window', then 'Save As… Use the 'if' statement:

Dictionary often better than if… elif… Particularly with many hardcoded choices (elif's)… More compact, and more efficient This pattern is very useful

Built-in types and their Boolean interpretations

'for' statement Repetition of a block of statements Iterate through a sequence (list, tuple, string, iterator)

Built-in functions 'range' and 'xrange' Built-in functions 'range' and 'xrange' useful with 'for' 'range' creates a list Warning: may use lots of memory; inefficient!

'while' statement Repetition of a block of statements Loop until test becomes false, or 'break'

Optional 'else' block in loops 'else' block executed if no 'break' encountered May often replace success/failure flags Valid in 'for' and 'while' loops

Error handling: ’try’ and ’except’ Run-time error normally causes execution to bomb The error message gives type of error Use a ’try’, ’except’ blocks to catch and handle errors

How to split up long lines Sometimes a source code line needs splitting up Indentation rule means we do not have free-format!

Statements not covered in this course 'finally': used with 'try', 'except' 'raise': causes an exception 'yield': in functions 'global': within functions 'exec': execute strings as code There is no 'goto' statement!

Part 3: Functions

How to define your own function Use the 'def' statement Function body follows; indented! This is a statement like others Can be placed basically anywhere Required: Define the function before calling it

Function features The value of an argument is not checked for type Often very useful; overloading without effort Of course, the function may still bomb if invalid value is given The documentation string is not required (more later) But strongly encouraged! Make a habit of writing one (before writing the function code) A user-defined function has exactly the same status as a built-in function, or a function from another module

Function arguments: fixed Fixed number of arguments Associated by order

Function arguments: variable List of any number of arguments Useful when unknown number of arguments needed The argument values collected into a tuple Called 'args', by convention The ’*’ is the magical part

Function arguments: default values Arguments may have default values When argument not given in a call, default value is used If no default value, and not given when called: bombs Use explicit names to override argument order

Function arguments: keywords Keyword/value arguments The argument values collected into a dictionary Called 'kwargs', by convention The ’**’ is the magical part First attempts to match existing argument names

Function arguments: local variables Arguments become local variables Immutable values are copied, in effect Mutable values may still be changed: be careful Variables created within 'def' block are local Forgotten on return

Function without 'return': value None A function does not have to use the 'return' statement If not, then same as a 'procedure' in other languages Actually returns a value anyway: 'None' A 'return' without value is OK: returns 'None' 'None' is a special value meaning 'nothing' Useful in many contexts Particularly in object-oriented programming (more later)

The 'math' module: functions and constants A peek at modules Math functions available in a separate module

Functions are objects; names are references A function is just another kind of object Nothing magical about their names; can be changed

Built-in function 'map' Built-in function that works on a list 'map' takes a function and a list The function must take only one argument, and return one value The function is applied to each value of the list The resulting values are returned in a list

Built-in function 'reduce'

Built-in function 'filter'

Files: reading A file object is created by the built-in function 'open' The file object has a set of methods The 'read' methods get data sequentially from the file 'read': Get the entire file (or N bytes) and return as a single string 'readline': Read a line (up to and including newline) 'readlines': Read all lines and return as a list of strings

Files: writing The 'write' method simply outputs the given string The string does not have to be ASCII; binary contents allowed

Part 4: Modules

Example: Reverse complement NT sequence Given a nucleotide sequence, produce reverse complement Use available features

Make a module of the code How to make the code even more reusable? Step 2: Make a module out of it Is actually already a module! Let’s simply rename it to ’ntseq.py’

How to use the module: ’import’ statement The ’import’ statement makes a module available The module name (not the file name) is imported: skip the ’.py’ Access module features through the ’dot’ notation

Module self-test code: the ’__name__’ trick The ’import’ statement executes all code in the module file How to ’hide’ self-test code? Use the predefined variable ’__name__’: If executed as the main program: value ’__main__’ If executed as a module: some other value

Now, the ’import’ statement behaves

Modules are easy, fun, and powerful The module feature is the basis for Python's ability to scale to really large software systems Easy to create: every Python source code file is a module! Features to make a module elegant: Doc strings '__name__' trick Namespace concept Be sure to browse the standard library modules! You will find extremely useful stuff there You will learn good coding habits Packages are directories of several associated modules Not covered in this course. A few minor interesting points

Namespaces A namespace is a bag of names A module is a namespace Use the built-in function ’dir’ to list the names in a namespace ’import’ statement modifies the namespace

Avoiding clutter in your namespace Using ’from module import *’ can create clutter Fine-tuning of import; bring in only selected things Rename things from a module Avoid name collisions Make it clearer

Doc strings: ’__doc__’ We have mentioned documentation strings before The first string in a module The first string after a ’def’ statement Accessed through variable ’__doc__’ Feature to facilitate creation of documentation Used by tools to produce documentation, such as ’pydoc’ See ’Module Docs’ in ’Start’ > ’Programs’ > ’Python 2.3’

Part 5: Object-oriented programming, classes

Classes vs. objects (instances) A class is like a Prototype Blue-print ("ritning") An object creator A class defines potential objects What their structure will be What they will be able to do Objects are instances of a class An object is a container of data: attributes An object has associated functions: methods

A class example: Geometrical shapes Let's define classes for geometrical shapes With data; position, etc With functions: compute area, etc

Instances of classes Let's create some instances of the Circle class Look at attribute 'radius' Use the method 'area'

Changing an instance: references Variables may reference the same object Changing an attribute changes the object, not the reference

Changing an instance: attribute add/delete An attribute can be added! And deleted!

Equality between objects Two kinds of equality: Are the two objects similar in value? Are the two references actually pointing to the same object?

Special methods in classes Special methods '__xxx__' in classes Define custom-made behaviour See page 327 in 'Learning Python'

Using the special methods, part 1 Special method definitions are detected by Python Built-in functions use them; see documentation

Using the special methods, part 2 Defining special methods may clarify code tremendously But: Stay reasonable 'natural'!

Inheritance: Class hierarchies Let's define a general 'Shape' class 'Circle' is a special case of 'Shape' 'Blob' is also a special case of 'Shape' Notice: redefinition of 'is_round' in 'Blob'

Instances of classes using inheritance Which method is called by which instance? Polymorphism Selection of method depends on actual class of the instance Extremely powerful, if properly designed class hierarchy

Part 6: Standard library modules

Module 're', part 1 Define a pattern The pattern syntax is very much like Perl or grep Apply it to a string Process the results

Module 'sys', part 1 sys.argv List of command-line arguments; sys.argv[0] is script name sys.path List of directory names, where modules are searched for sys.platform String to identify type of computer system

Module 'sys', part 2 sys.stdout, sys.stdin, sys.stderr Predefined file objects for input/output 'print' stuff goes to 'sys.stdout' May be set to other files sys.exit(n) Force exit from Python execution 'n' is an integer error code, normally 0

Module 'os', part 1 os.getcwd() Returns the current directory

Module 'os', part 2 os.chdir(path) Changes the current working directory to 'path' os.listdir(path) Return a list of the contents of the directory 'path' os.mkdir(path) Create the directory 'path' os.rmdir(path) Remove the directory 'path' os.remove(path) Remove the file named 'path'

Module 'os', part 3 os.system(command) Execute the shell command (string) in a subprocess Return the error code as integer os.popen(command, mode='r') Run the shell command (string) Open a pipe to the command, return as a file object Mode is either read, or write; not both os.popen2, os.popen3, os.popen4 Variants of os.popen, with different file objects os.getpid() Return the process ID as integer

Module 'os.path', part 1 os.path.abspath(path) Returns the absolute path for the given relative 'path'

Module 'os.path', part 2 os.path.join(path, path, …) Joint together the path parts intelligently into a valid path name

Module 'os.path', part 3 os.path.isfile(path) Is 'path' the name of a file? os.path.isdir(path) Is 'path' the name of a directory?

Some other useful modules