Python: Installation and Basic Syntax

Installation

First of all you need to install the interpreter of the Python. Interpreter is the programm which will execute you code. Download Python and package manager pip from the official website and install in as an ordical programm. Don't forget to check the option Add Python 3.X to PATH to call Python's interpreter from the command line with simple python command. Mac users can install the python using the Homebrew package manager: brew install python3.

Then, install code editor you like. I would advise to use Sublime Text 3 but it is a matter of taste.

Runnung the code

There are two ways to write and run Python's code: using interactive prompt or modules. The simplest one is to type commands at the Python’s interactive prompt and run it immediately.

To launch interactive prompt type python and pressing the Enter in the command line. Then you can write commands. Each command is run immediately after it’s entered. Moreover, because the interactive session automatically prints the results of expressions you type, you don’t usually need to say print explicitly at this prompt.

The interactive prompt runs code and echoes results as you go, but it doesn’t save your code in a file. Although this means you won’t do the bulk of your coding in interactive sessions, the interactive prompt turns out to be a great place to both experiment with the language and test program files on the fly.

To save programs permanently, you need to write your code in files, which are usually known as modules. Modules are simply text files containing Python statements. Once they are coded, you can ask the Python interpreter to execute the statements in such a file any number of times, and in a variety of ways — by system command lines, by file icon clicks and so on.

python <path-to-modile-here>

Documentation

Ok, you have done a great job, but, I suppose, you have a lot of questions. The best way to answer them is to read the documentation. Spend at least 15 minutes browsing the Python library and language manuals before moving on to get a feel for the available tools in the standard library and the structure of the documentation set. It takes at least this long to become familiar with the locations of major topics in the manual set; once you’ve done this, it’s easy to find what you need.

Structute of Python programms

Python programs can be decomposed into modules, statements, expressions, and objects, as follows

1. Programs are composed of modules.
2. Modules contain statements.
3. Statements contain expressions. Statements
4. Expressions create and process objects. Expression is an instruction that combines objects and operators and always evaluates down to a single value.

There is quite subtle difference between Statements and Expressions:

• Statements executed solely for their side effects, while expressions always return a result and often do not have side effects at all.
• ...hence statements are executed, while expressions are evaluated.

It would be logically to start with expressions, but first of all I would like to mention assignment statement first since it is the most frequently used consructions in any language.

Assignment statement and Variables

Variables are simply names created by you or Python that are used to keep track of information in your program.

Each time you generate a new value in your script by running an expression, Python creates a new object (i.e., a chunk of memory) to represent that value. Assignment statement is used to refer to that value in future.

More fact about variables:

• Variables are created when they are first assigned values.
• Variables are replaced with their values when used in expressions.
• Variables must be assigned before they can be used in expressions.
• Variables refer to objects and are never declared ahead of time.

Variables can be assigned in the following ways:

Commentaries

The text after a # is simply ignored as a human-readable comment and is not considered part of the statement’s syntax. Comments can show up on lines by themselves, or to the right of code on a line.

Expressions: core data types its operators

Now we can approach to the comprehension of the expressions. As you probably remember, expressions are instructions that combines objects and operators and always evaluates down to a single value. Lets consider core types of objects. It is extremely important since everything we process in Python programs is a kind of object — numbers, functions, classes, modules, everything! But fow now we will only consider objects which can store the data — core data types.

To get the type of any object pass it to the function type:

Every type of object can be used with a definite set of operators in a definite way. For example, operator plus + sum numbers but concatinate the strings, operator - substract one number from anoth and can not be used with strings:

Moreover, in addition to expression operators, data types provide a set of methods that implement more sophisticated tasks. In Python, expressions and built-in functions may work across a range of types, but methods are generally specific to object types — string methods, for example, work only on string objects. Methods are simply functions that are associated with and act upon particular objects. Technically, they are attributes attached to objects that happen to reference callable functions which always have an implied subject.

Method calls combine two operations at once — an attribute fetch using dot operator . and a call with brackets (). General syntax of calling method to process object with arguments looks like this:

For example, to return a copy of the string with all the cased characters converted to uppercase call method upper on a string object.

Now lets look at the every core data type and investigate its methods and how it works with different operators.

Numeric Types

In Python, numbers are not really a single object type, but a category of similar types:

• Integers that have no fractional part. Integers are written as strings of decimal digits: 123.
• Floating-point numbers have a decimal point and/or an optional signed exponent introduced by an e or E and followed by an optional sign: 1.23.

The other data types are used much less often:

• Complex. Numbers with real and imaginary parts.
• Fraction and Decimal for the best precision.

Python also allows us to write integers using decimal (base 10), hexadecimal (base 16), octal (base 8) or binary (base 2) literal:

Expression Operators for Numeric Types

When you mix expressions in another expression, like 2 + 3 * 4^2, operators lower in the table have higher precedence. You can forget about precedence completely if you’re careful to group parts of expres- sions with parentheses: ((2 + 3) * 4)^2.

Besides mixing operators in expressions, you can also mix numeric types. For instance, you can add an integer to a floating-point number:

To execute this expression Python converts more simple types to more complex: integers are simpler than floating-point numbers, which are simpler than complex numbers.

Result of comparisons between number is a boolean value.

Boolean

Python Boolean type, bool, is numeric in nature because its two values, True and False, are just customized versions of the integers 1 and 0 that print themselves differently. Because True is just the integer 1 with a custom display format, True + 4 yields integer 5 in Python!

You can make sure that numeric data type is really an ancestor of the boolean by calling isinstance function, which returns True if the specified object is of the specified type, otherwise False.

Logical operators

Most these operators are quite easy to understand. Быстро объяснить

Looking at this table you might ask some question.

String

Strings are defined as immutable ordered sequence of characters. Strings are used to record both textual information (your name, for instance) as well as arbitrary collections of bytes (such as an image file’s contents). They are our first example of what in Python we call a sequence—a positionally ordered collection of other objects. Sequences maintain a left-to-right order among the items they contain: their items are stored and fetched by their relative positions. Strictly speaking, strings are sequences of one-character strings; other, more general sequence types include lists and tuples, covered later.

The start and end of the string are defined with a pair of quotation marks. Around Python strings, single- and double-quote characters are interchangeable.

Python also has a triple-quoted string literal format, sometimes called a block string, that is a syntactic convenience for coding multiline text data. This form begins with three quotes (of either the single or double variety), is followed by any number of lines of text, and is closed with the same triple-quote sequence that opened it. Single and double quotes embedded in the string’s text may be, but do not have to be, escaped.

String as a Sequence: Indexing and Slicing

Because strings are sequences, we can access their components by position. In Python, characters in a string are fetched by indexing— providing the numeric offset of the desired component in square brackets after the string.

Indexes are coded as offsets from the front, and so start from 0: the first item is at index 0, the second is at index 1, and so on. Index ends at one less than the length of the string.

Python also lets you fetch items from sequences such as strings using negative offsets. Technically, a negative offset is added to the length of a string to derive a positive offset.

In addition to simple positional indexing, sequences also support a more general form of indexing known as slicing, which is a way to extract an entire section (slice) in a single step. The left offset is taken to be the lower bound (inclusive), and the right is the upper bound (noninclusive).

In a slice, the left bound defaults to zero, and the right bound defaults to the length of the sequence being sliced:

Slice expressions support for an optional third index, used as a step (sometimes called a stride). The step is added to the index of each item extracted:

Because strings are the sequences you can also use the other keywords with them: in, for and so on.

String is an immutable type

Every string operation is defined to produce a new string as its result, because strings are immutable in Python—they cannot be changed in place after they are created. In other words, you can never overwrite the values of immutable objects. For example, you can’t change a string by assigning to one of its positions, but you can always build a new one and assign it to the same name.

To prove thi I will use id function, which returns unique and constant integer for the object:

Basic operators

String Methods

Escape characters

As many other languages Python supports eascape characters this the strings. Escape character is a character which invokes an alternative interpretation on subsequent characters in a character sequence. An escape character may not have its own meaning, so all escape sequences are of two or more characters.

The common escape characters are:

• \' — single quote
• \" — double quote
• \\\\ — backslash
• \n — new line
• \r — carriage return
• \t — tab
• \b — backspace
• \xFF — character represented by the hexadecimal byte "FF"

String Conversion

One of Python’s design mottos is that it refuses the temptation to guess. As a prime example, you cannot add a number and a string together in Python, even if the string looks like a number, because + can mean both addition and concatenation, the choice of conversion would be ambiguous. Instead, Python treats this as an error.

You need to employ conversion tools before you can treat a string like a number, or vice versa

Empty string is converted to the boolean False when necessary:

It is very convenient. Otherwise we have to write less readable if name != "" at the lower statement.

String formatting

The easiest way to format a string is to concatenate existing strings using the + operator. But if the strings are long and there are many of them, this approach will not work, and you will need to refer to the string formatting expressions. There are many ways to format strings in Python. Let consider two most common: string object’s format method and f-strings.

The string object’s format method uses the subject string as a template, and takes any number of arguments that represent values to be substituted according to the template. Within the subject string, curly braces designate substitution targets and arguments to be inserted either by position (e.g., {1}), or keyword (e.g., {food}), or relative position ({})

f-strings are string literals that have an f at the beginning and curly braces containing expressions that will be replaced with their values.

See more about string formatting in Python at the pyformat.info and read the docs on Format Specification Mini-Language.

String Methods

In Python, expressions and built-in functions may work across a range of types, but methods are generally specific to object types — string methods, for example, work only on string objects.

Byte strings

The computer does not work with characters, but with their byte representations. Bytes, not strings, are transmitted over the network and saved to disk. Often all this happens automatically, however, sometimes it is necessary to create byte strings manually. A byte string is an immutable sequence of numbers from 0 to 255.

We can encode stings to bytes and decode from it with encode and decode methods.

See unicode-table.com to check if this string is a real unicode string represented in a byte form.

None

Python also provides a special object called None. It is the only value of a special data type in Python and typically serves as an empty placeholder.

None is always considered to be false but it is not the false. A variable with a value of None can come in handy when you need to distinguish it from zero.

Lists

The Python list object is the most general sequence provided by the language. Lists are positionally ordered collections of arbitrarily typed objects, and they have no fixed size. They are also mutable—unlike strings, lists can be modified in place by assignment to offsets as well as a variety of list method calls.

In Python lists are written with square brackets or you can create a list from the other object with list conctructor.

Lists support all the sequence operations we discussed for strings:

Lists support arbitrary nesting — we can nest them as deeply as we like.

To perform in-plase sorting use sort method.

We can update list using index assignment ot special methods:

The insert function takes two parameters: index - position where an element needs to be inserted, and item to be inserted.

append method adds a single item to the end of the list.

extend method adds items from another list (or any sequence) to the end.

remove method removes item by literal.

pop method removes an individual item (last by default if no argument) and returns it:

del keyword removes an individual item by index, or to remove all items identified by a slice.

It is also possible to use + and * with lists as the are sequences:

Practical assignment

1. Create a shopping list with apple, strawberry, carrot, banana.
2. What is the length of this list? Print it.
3. Add rice to the end of this list.
4. Sort shopping list alphabetically for a to z.
5. Print last two items of this list.
6. You just have remembered that you have allergy on strawberry. Replce it with orange.
7. Bon appétit!

Dictionaries

Python dictionaries (also called associative arrays or hashes) are quite special kind of collections: they are not sequences, but mappings. Mappings are collections of other objects, like lists, but they store objects by key instead of by relative position. In fact, mappings don’t maintain any reliable left-to-right order; they simply map keys to associated values. Because dictionaries are unordered collections, operations that depend on a fixed positional order (e.g., concatenation, slicing) don’t make sense.

Dictionaries, the only mapping type in Python’s core objects set, are also mutable: like lists, they may be changed in place and can grow and shrink on demand.

To define a dictionary, you must use a literal brace or simply call dict function.

Access to the value by key is carried out for a constant time, that is, does not depend on the size of the dictionary. This is achieved using a hashing algorithm. However, bacause of that dictionaries do not contain information about the order.

We can access the values of the dictionary much as we did for our list - using square brackets, but this time we need to place dictionary key inside, not list offsets.

If you try to access by a key that does not exist, Python will generate a KeyError exception. However, it is often useful to return some default value if the key does not exist. There is a built-in get method for that purpose:

Lets create online cart for the delivery service. It could look like this:

What food Sam ordered?

How Sam can order one more pizza?

He also want to order vegetarian pizza. Lets add it as a new key:

To test if the key present in a dictionary use in operator:

Practical assignment

Add the following order in the cart: Sasha Berg ordered a one pepperoni pizza and two bottles of Coca-cola.

Files

The built-in open function creates a Python file object, which serves as a link to a file residing on your machine. After calling open, you can transfer strings of data to and from the associated external file by calling the returned file object’s methods.

Compared to the types you’ve seen so far, file objects are somewhat unusual. They are considered a core type because they are created by a built-in function, but they’re not numbers, sequences, or mappings, and they don’t respond to expression operators; they export only methods for common file-processing tasks.

To open a file, a program calls the built-in open function, with the external filename first, followed by a processing mode. The call returns a file object, which in turn has methods for data transfer:

========= ===============================================================
Character Meaning
--------- ---------------------------------------------------------------
'r'       open for reading (default)
'w'       open for writing, truncating the file first
'x'       create a new file and open it for writing
'a'       open for writing, appending to the end of the file if it exists
'b'       binary mode
't'       text mode (default)

At the end of the work we should not forget to close file connection:

The better way to open the files is to use context-manager with, which allows you not to worry about closing files. You can open the file with the with operator, write the file object to the variablefile_obj and then work with the file inside this context block. After exiting the block, the Python interpreter will close the file automatically.

Statements

As we remember, programs written in the Python language are composed of statements and expressions. Expressions process objects and are embedded in statements. Statements code the larger logic of a program’s operation — they use and direct expressions to process the objects we studied in the preceding chapters. There are two types of statements: simple and compound.

All Python compound statements — statements that have other statements nested inside them — follow the same general pattern of a header line terminated in a colon, followed by a nested block of code usually indented underneath the header line, like this:

Header line:
    Nested statement block

The colon is required, and omitting it is probably the most common coding mistake among new Python programmers.

There is no universal standard on this: four spaces or one tab per level is common, but it’s generally up to you to decide how and how much you wish to indent, but you probably shouldn’t mix tabs and spaces.

Although statements normally appear one per line, it is possible to squeeze more than one statement onto a single line in Python by separating them with semicolons:

This is the only place in Python where semicolons are required: as statement separators.

if Statement

if statement selects actions to perform. It represents much of the logic a Python program.

General format:

if test1:          # if test
    statements1
elif test2:        # Optional elifs
    statements2
else:              # Optional else
    statements3

To handle a false result, code the else:

for loops

for can step through the items in any ordered sequence or other iterable object. The for statement works on strings, lists, tuples, and other iterables.

General format:

for target in object:
    statements

More complete format:

for target in object:
    statements
else:                   # Optional else part
    statements          # If we didn't hit a 'break'

Else statement executes if the loop exits without running into a break statement.

The break statement causes an immediate exit from a loop. Because the code that follows it in the loop is not executed if the break is reached, you can also sometimes avoid nesting by including a break.

The continue statement causes an immediate jump to the top of a loop. It also sometimes lets you avoid statement nesting.

The pass statement does nothing at all: it’s an empty statement placeholder.

Practical assignment 1

Create a list with odd numbers in a range from 0 to 50.

Hint: use function range() to create a range.

Practical assignment 2

Write a for loop that will print the names of all ordered items in the card (which we created before)

List Comprehensions

List comprehensions provide a concise way to create lists.

As list comprehension returns list, they consists of brackets containing the expression which needs to be executed for each element along with the for loop to iterate over each element.

Practical assignment

Rewrite "Practical assignment 1" above (about odd numbers) using list comprehensions

while loop

It repeatedly executes a block of (normally indented) statements as long as a test at the top keeps evaluating to a true value.

while test:
    statements
else:
    statements

Practical assignment

Some guys scraped tweets from 100+ pro-ISIS fanboys from all over the world since the November 2015 Paris Attacks.

Example of such tweet:

RT @maaj19: سَمِعْنَا وَ أطَعْنَا #gd #gd#fdfd @allah

I saved random sample of these tweets in a file "tweets_IS.txt", one tweet per line. Read the file and do the following tasks:

1. Calculate the distribution of hashtags. What is the most populat hashtag in these tweets?
2. Calculate the distribution of mentions. What is the most populat user mentioned in these tweets?
3. What is the longest tweet?

Function

Function groups a set of statements so they can be run more than once in a programa packaged procedure invoked by name. Functions also can compute a result value and let us specify parameters that serve as function inputs and may differ each time the code is run.

Functions are also the most basic program structure Python provides for maximizing code reuse. As we’ll see, functions let us split complex systems into manageable parts. By implementing each part as a function, we make it both reusable and easier to code.

General format:

def name(arg1, arg2,... argN):
    statements
    return value # optional part

As with all compound Python statements, def consists of a header line followed by a block of statements, usually indented (or a simple statement after the colon). The statement block becomes the function’s body — that is, the code Python executes each time the function is later called.

The Python return statement can show up anywhere in a function body; when reached, it ends the function call and sends a result back to the caller.

Python has a lot og build in functions:

Lets define a function:

Functions can accept default arguments. These arguments can either be specified by the caller or left blank to automatically receive a predefined value.

Lambda functions

Besides the def statement, Python also provides an expression form that generates function objects, it’s called lambda.

Like def, this expression creates a function to be called later, but it returns the function instead of assigning it to a name. This is why lambdas are sometimes known as anonymous (i.e., unnamed) functions. In practice, they are often used as a way to inline a function definition.

The lambda’s general form is the keyword lambda, followed by one or more arguments (exactly like the arguments list you enclose in parentheses in a def header), followed by an expression after a colon:

lambda argument1, argument2,... argumentN : expression using arguments

There are a few differences that make lambdas useful in specialized roles:

1. lambda is an expression, not a statement. Because of this, a lambda can appear in places a def is not allowed by Python’s syntax—inside a list literal or a function call’s arguments, for example. With def, functions can be referenced by name but must be created elsewhere. As an expression, lambda returns a value (a new func- tion) that can optionally be assigned a name. In contrast, the def statement always assigns the new function to the name in the header, instead of returning it as a result.

2. lambda’s body is a single expression, not a block of statements.

Why Use lambda?

Take a look at the sorted function. It returns a new list containing all items from the iterable in ascending order.

Lets create a list of random numbers with module random.

sorted function has an argument key, which accept a custom key function can be supplied to customize the sort order. It is useful when we want to sort by nested element.

Modules

1. Programs are composed of modules.
2. Modules contain statements.
3. Statements contain expressions.
4. Expressions create and process objects.

Python module is the highest-level program organization unit, which packages program code and data for reuse, and provides self-contained namespaces that minimize variable name clashes across your programs.

Practical assignment

Implement your own key-value storage. Your task is to write a program that accepts keys as an arguments and returns an associated values from a storage — json-file.

To write a value

storage.py --key key_name --val value

To get a value(s) by key

storage.py --key key_name

In this case result could look like this:

value

or

value_1, value_2

if more than one value was written.

If no values were associated with key return None.

To transfer arguments to the script with command line use argparse module. Onve again — your task will be to take the arguments passed to your program and write the corresponding key-value pair to the storage file or display the values if only the key was passed. You can store data in JSON format using the standard module json. Use json.load(open(storage_path, 'r')) to open json file and json.dump(storage, open(storage_path, 'w')) to save the data, see docs for more.

To create a file better use tempfile module.