Introduction

Due to the currently observed rapid development of personal computing technology, there is a gradual change in the requirements for programming languages. Interpreted languages ​​are beginning to play an increasingly important role as the growing power personal computers begins to provide sufficient execution speed of interpreted programs. And the only significant advantage of compiled programming languages ​​is the high-speed code they produce. When program execution speed is not a critical value, the most the right choice there will be an interpreted language as a simpler and more flexible programming tool.

In this regard, it is of some interest to consider a relatively new language Python programming(Python), which was created by its author Guido van Rossum in the early 90s.

General information about Python. Advantages and disadvantages

Python is an interpreted, natively object-oriented programming language. It is extremely simple and contains a small number of keywords, but is also very flexible and expressive. This is a higher-level language than Pascal, C++ and, of course, C, which is achieved mainly through built-in high-level data structures (lists, dictionaries, tuples).

Advantages of language.
An undoubted advantage is that the Python interpreter is implemented on almost all platforms and operating systems. The first such language was C, but its data types on different machines could take up different amounts of memory and this served as some obstacle to writing a truly portable program. Python does not have such a disadvantage.

The next important feature is the extensibility of the language; great importance is attached to this and, as the author himself writes, the language was conceived precisely as extensible. This means that it is possible for all interested programmers to improve the language. The interpreter is written in C and source available for any manipulation. If necessary, you can insert it into your program and use it as a built-in shell. Or, by writing your own additions to Python in C and compiling the program, you can get an “extended” interpreter with new capabilities.

The next advantage is the presence of a large number of modules connected to the program, providing various additional features. Such modules are written in C and Python itself and can be developed by all sufficiently qualified programmers. Examples include the following modules:

• Numerical Python - advanced mathematical capabilities such as manipulation of integer vectors and matrices;
• Tkinter - building applications using a graphical user interface (GUI) based on the Tk interface widely used on X-Windows;
• OpenGL - using an extensive library graphic modeling two- and three-dimensional objects Open Graphics Library from Silicon Graphics Inc. This standard is supported, among other things, in such common operating systems as Microsoft Windows 95 OSR 2, 98 and Windows NT 4.0.

Disadvantages of language.
The only drawback noticed by the author is the relatively low execution speed of the Python program, which is due to its interpretability. However, in our opinion, this is more than compensated by the advantages of the language when writing programs that are not very critical to execution speed.

Features Overview

1. Python, unlike many languages ​​(Pascal, C++, Java, etc.), does not require variable declarations. They are created at the place where they are initialized, i.e. the first time a variable is assigned a value. This means that the type of a variable is determined by the type of the assigned value. In this respect, Python resembles Basic.
The type of a variable is not immutable. Any assignment to it is correct and this only leads to the fact that the type of the variable becomes the type of the new assigned value.

2. In languages ​​such as Pascal, C, C++, organizing lists presented some difficulties. To implement them, it was necessary to thoroughly study the principles of working with pointers and dynamic memory. And even with good qualifications, the programmer, each time re-implementing the mechanisms for creating, working and destroying lists, could easily make subtle errors. In view of this, some tools have been created for working with lists. For example, Delphi Pascal has a class TList that implements lists; The STL (Standard Template Library) library has been developed for C++, containing structures such as vectors, lists, sets, dictionaries, stacks and queues. However, such facilities are not available in all languages ​​and their implementations.

One of distinctive features Python is the presence of structures built into the language itself such as tuples(tuple) lists(list) and dictionaries(dictionary), which are sometimes called cards(map). Let's take a closer look at them.

1. Tuple . It is somewhat reminiscent of an array: it consists of elements and has a strictly defined length. Elements can be any values ​​- simple constants or objects. Unlike an array, the elements of a tuple are not necessarily homogeneous. And what distinguishes a tuple from a list is that a tuple cannot be changed, i.e. we cannot assign something new to the i-th tuple element and cannot add new elements. Thus, a tuple can be called a constant list. Syntactically, a tuple is specified by listing all elements separated by commas, all enclosed in parentheses:

(1, 2, 5, 8)
(3.14, ‘string’, -4)
All elements are indexed from scratch. To get the i-th element, you must specify the tuple name followed by the index i in square brackets. Example:
t = (0, 1, 2, 3, 4)
print t, t[-1], t[-3]
Result: 0 4 2
Thus, a tuple could be called a constant vector if its elements were always homogeneous.
2. List . A good, specific example of a list is the Turbo Pascal language string. The elements of a line are single characters, its length is not fixed, it is possible to delete elements or, on the contrary, insert them anywhere in the line. The elements of the list can be arbitrary objects, not necessarily of the same type. To create a list, just list its elements separated by commas, enclosing them all in square brackets:


['string', (0,1,8), ]
Unlike a tuple, lists can be modified as desired. Access to elements is carried out in the same way as in tuples. Example:
l = ]
print l, l, l[-2], l[-1]
Result: 1 s (2.8) 0
3. Dictionary . It is reminiscent of the record type in Pascal or the structure type in C. However, instead of the “record field” - “value” scheme, “key” - “value” is used here. A dictionary is a collection of key-value pairs. Here the “key” is a constant of any type (but strings are mainly used), it serves to name (index) some corresponding value (which can be changed).

A dictionary is created by listing its elements (key-value pairs separated by a colon), separated by commas, and enclosing them all in curly braces. To gain access to a certain value, after the dictionary name, write the corresponding key in square brackets. Example:
d = ("a": 1, "b": 3, 5: 3.14, "name": "John")
d["b"] = d
print d["a"], d["b"], d, d["name"]
Result: 1 3.14 3.14 John
To add a new key-value pair, simply assign the corresponding value to the element with the new key:
d["new"] = "new value"
print d
Result: ("a":1, "b":3, 5:3.14, "name":"John", "new":"new value")

3. Python, unlike Pascal, C, C++, does not support working with pointers, dynamic memory and address arithmetic. In this way it is similar to Java. As you know, pointers are a source of subtle errors and working with them relates more to low-level programming. To provide greater reliability and simplicity, they were not included in Python.

4. One of the features of Python is how one variable is assigned to another, i.e. when on either side of the operator" = " there are variables.

Following Timothy Budd (), we will call pointer semantics the case when the assignment only leads to the assignment of a reference (pointer), i.e. the new variable becomes just another name, denoting the same memory location as the old variable. In this case, changing the value denoted by the new variable will lead to a change in the value of the old one, because they actually mean the same thing.

When an assignment leads to the creation of a new object (here an object - in the sense of a piece of memory for storing a value of some type) and copying the contents of the assigned variable into it, we call this case copy semantics. Thus, if copy semantics applies when copying, then the variables on either side of the "=" sign will mean two independent objects with the same content. And here, a subsequent change in one variable will not affect the other in any way.

Assignment in Python works like this: if assignable the object is an instance of such types as numbers or strings, then copy semantics applies, but if on the right side there is an instance of a class, list, dictionary or tuple, then pointer semantics applies. Example:
a = 2; b = a; b = 3
print "copy semantics: a=", a, "b=", b
a = ; b = a; b = 3
print "pointer semantics: a=", a, "b=", b
Result:
copy semantics: a= 2 b= 3
pointer semantics: a= b=

For those of you who want to know what's going on here, I'll give you a different take on assignment in Python. If in languages ​​such as Basic, Pascal, C/C++ we dealt with “capacity” variables and constants stored in them (numeric, symbolic, string - it doesn’t matter), and the assignment operation meant “entering” the constant into the assigned variable , then in Python we must already work with “name” variables and the objects they name. (You notice some analogy with Prolog language?) What is an object in Python? This is everything that can be given a name: numbers, strings, lists, dictionaries, class instances (which in Object Pascal are called objects), the classes themselves (!), functions, modules, etc. So, when assigning a variable to an object, the variable becomes its “name”, and the object can have as many such “names” as desired and they are all independent of each other.

Now, objects are divided into modifiable (mutable) and immutable. Mutable - those that can change their “internal content”, for example, lists, dictionaries, class instances. And unchangeable ones - such as numbers, tuples, strings (yes, strings too; you can assign a new string obtained from an old one to a variable, but you cannot modify the old string itself).

So, if we write a = ; b = a; b = 3, Python interprets it like this:

give the object a "list" " Name a ;

give this object another name - b ;

modify the null element of an object.

This is how we get the “pseudo” semantics of pointers.

One last thing to say about this: although it is not possible to change the structure of the tuple, the mutable components it contains are still available for modification:

T = (1, 2, , "string") t = 6 # this is not possible del t # also an error t = 0 # allowed, now the third component is a list t = "S" # error: strings are not mutable

5. The way Python groups operators is very original. In Pascal, this is done using operator brackets begin-end, in C, C++, Java - braces(), in Basic, closing endings of language constructs are used (NEXT, WEND, END IF, END SUB).
In Python, everything is much simpler: selecting a block of statements is carried out by shifting the selected group by one or more spaces or tab characters to the right relative to the head of the structure to which the given block will belong. For example:

if x > 0: print ‘ x > 0 ’ x = x - 8 else: print ‘ x<= 0 ’ x = 0 Thus, a good style of writing programs, which teachers of the languages ​​Pascal, C++, Java, etc. call for, is acquired here from the very beginning, since it simply won’t work any other way.

Description of the language. Control structures

Exception Handling

try: <оператор1> [except[<исключение> [, <переменная>] ]: <оператор2>] [else <оператор3>]	Performed<оператор1>, if an exception occurs<исключение>, then it is fulfilled<оператор2>. If<исключение>has a value, it is assigned<переменной>. Upon successful completion<оператора1>, performed<оператор3>.
try: <оператор1> finally: <оператор2>	Performed<оператор1>. If no exceptions occur, then execute<оператор2>. Otherwise executed<оператор2>and an exception is immediately raised.
raise <исключение> [<значение>]	Throws an exception<исключение>with parameter<значение>.

Exceptions are just strings. Example:

My_ex = ‘bad index’ try: if bad: raise my_ex, bad except my_ex, value: print ‘Error’, value

Function Declaration

Class Declaration

Class cMyClass: def __init__(self, val): self.value = val # def printVal(self): print ' value = ', self.value # # end cMyClass obj = cMyClass (3.14) obj.printVal() obj.value = " string now" obj.printVal () !} Result:
value = 3.14
value = string now

Operators for all types of sequences (lists, tuples, strings)

Operators for lists (list)

s[i] = x	The i-th element s is replaced by x.
s = t	part of the elements s from i to j-1 is replaced by t (t can also be a list).
del s	removes the s part (same as s = ).
s.append(x)	adds element x to the end of s.
s.count(x)	returns the number of elements s equal to x.
s.index(x)	returns the smallest i such that s[i]==x.
s.insert(i,j)	the part of s, starting from the i-th element, is shifted to the right, and s[i] is assigned to x.
s.remove(x)	same as del s[ s.index(x) ] - removes the first element of s equal to x.
s.reverse()	writes a string in reverse order
s.sort()	sorts the list in ascending order.

Operators for dictionaries

File objects

Created by a built-in function open()(see description below). For example: f = open('mydan.dat','r').
Methods:

Other language elements and built-in functions

=	assignment.
print [ < c1 > [, < c2 >]* [, ] ]	displays values< c1 >, < c2 >to standard output. Places a space between arguments. If there is no comma at the end of the list of arguments, it moves to a new line.
abs(x)	returns absolute value x.
apply( f , <аргументы>)	calls function (or method) f with< аргументами >.
chr(i)	returns a one-character string with ASCII code i.
cmp(x,y)	returns negative, zero, or positive if, respectively, x<, ==, или >than y.
divmod (a, b)	returns tuple (a/b, a%b), where a/b is a div b (the integer part of the division result), a%b is a mod b (the remainder of the division).
eval(s)	returns the object specified in s as a string. S can contain any language structure. S can also be a code object, for example: x = 1 ; incr_x = eval("x+1") .
float(x)	returns a real value equal to the number x.
hex(x)	returns a string containing the hexadecimal representation of x.
input(<строка>)	displays<строку>, reads and returns a value from standard input.
int(x)	returns the integer value of x.
len(s)	returns the length (number of elements) of an object.
long(x)	returns a long integer value x.
max(s), min(s)	return the largest and smallest element of the sequence s (that is, s is a string, list, or tuple).
oct(x)	returns a string containing a representation of the number x.
open(<имя файла>, <режим>='r' )	returns a file object opened for reading.<режим>= 'w' - opening for writing.
ord(c)	returns the ASCII code of a character (string of length 1) c.
pow(x, y)	returns the value of x to the power of y.
range(<начало>, <конец>, <шаг>)	returns a list of integers greater than or equal to<начало>and less than<конец>, generated with a given<шагом>.
raw_input( [ <текст> ] )	displays<текст>to standard output and reads a string from standard input.
round (x, n=0)	returns real x rounded to the nth decimal place.
str(<объект>)	returns a string representation<объекта>.
type(<объект>)	returns the type of the object. For example: if type(x) == type(‘’): print ‘ this is a string ’
xrange (<начало>, <конец>, <шаг>)	is similar to range, but only simulates a list without creating it. Used in a for loop.

Special functions for working with lists

filter (<функция>, <список>)	returns a list of those elements<спиcка>, for which<функция>takes the value "true".
map(<функция>, <список>)	applies<функцию>to each element<списка>and returns a list of results.
reduce ( f , <список>, [, <начальное значение> ] )	returns the value obtained by "reduction"<списка>function f. This means that there is some internal variable p that is initialized<начальным значением>, then, for each element<списка>, the function f is called with two parameters: p and the element<списка>. The result returned by f is assigned to p. After going through everything<списка>reduce returns p. Using this function, you can, for example, calculate the sum of the elements of a list: def func (red, el): return red+el sum = reduce (func, , 0) # now sum == 15
lambda [<список параметров>] : <выражение>	An "anonymous" function that does not have a name and is written where it is called. Accepts the parameters specified in<списке параметров>, and returns the value<выражения>. Used for filter, reduce, map. For example: >>>print filter (lambda x: x>3, ) >>>print map (lambda x: x*2, ) >>>p=reduce (lambda r, x: r*x, , 1) >>> print p 24

Importing Modules

Standard math module

Variables: pi, e.
Functions(similar to C language functions):

acos(x)	cosh(x)	ldexp(x,y)	sqrt(x)
asin(x)	exp(x)	log(x)	tan(x)
atan(x)	fabs(x)	sinh(x)	frexp(x)
atan2(x,y)	floor(x)	pow(x,y)	modf(x)
ceil(x)	fmod(x,y)	sin(x)
cos(x)	log10(x)	tanh(x)

string module

Functions:

Conclusion

Due to the simplicity and flexibility of the Python language, it can be recommended to users (mathematicians, physicists, economists, etc.) who are not programmers, but who use computer technology and programming in their work.
Programs in Python are developed on average one and a half to two (and sometimes two to three) times faster than in compiled languages ​​(C, C++, Pascal). Therefore, the language may be of great interest to professional programmers who develop applications that are not critical to execution speed, as well as programs that use complex data structures. In particular, Python has proven itself well in developing programs for working with graphs and generating trees.

Literature

1. Budd T. Object-oriented programming. - St. Petersburg: Peter, 1997.
2. Guido van Rossum. Python Tutorial. (www.python.org)
3. Chris Hoffman. A Python Quick Reference. (www.python.org)
4. Guido van Rossum. Python Library Reference. (www.python.org)
5. Guido van Rossum. Python Reference Manual. (www.python.org)
6. Guido van Rossum. Python programming workshop. (http://sultan.da.ru)

This material is intended for those who are already familiar with programming and want to master the Python programming language. It is designed to show you in 10 minutes the features of the Python language, syntax features and the basic principles of working with Python using examples. There is no “water” here - information that is not directly related to the programming language. Let's begin!

The Python programming language is strongly typified (Strong typing is distinguished by the fact that the language does not allow mixing different types in expressions and does not perform automatic implicit conversions, for example, you cannot subtract a set from a string), it is used dynamic typing— all types are determined during program execution.

Declaring variables is optional, names are case sensitive (var and VAR are two different variables).

Python is an object-oriented language; everything in the language is an object.

Getting help

Help (help) in Python is always available right in the interpreter. If you want to know how an object works, call help(