# Основы

**Python** — высокоуровневый язык программирования общего назначения, ориентированный на повышение производительности разработчика и читаемости кода ([Офф. сайт](https://www.python.org/)|[Wiki](https://ru.wikipedia.org/wiki/Python)).

## Операторы

| Оператор | Описание                                  |
| -------- | ----------------------------------------- |
| +        | Сложение                                  |
| -        | Вычитание                                 |
| \*       | Умножение                                 |
| /        | Деление (в результате вещественное число) |
| //       | Целочисленное деление                     |
| \*\*     | Возведение в степень                      |
| %        | Деление по модулю                         |

## Строки

Строка создается путём ввода текста между парой одинарных или двойных кавычек.

Строки можно объединять (конкатенация) независимо независимо от вида кавычек, в которые они заключены, так же можно умножать на целые числа.

## Строковые методы

Тип данных является классом

```
>>> type(0)
<class 'int'>
```

Рассмотрим пример вызова строкового метода (полная форма)

```
>>> str.capitalize('hello')
'Hello'
```

Обычно используется сокращенная форма

```
>>> 'hello'.capitalize()
'Hello'
```

В момент, когда мы используем сокращенную форму для вызова метода, Python преобразует ее в полную форму, а затем вызывает

Для вызова справки у методов необходимо через точку указывать их класс

```
help(str.capitalize)
```

### Примеры

```
>>> ('TTA' + 'G'*3).count('T')
2
```

```
>>> '{0} и {1}'.format('труд', 'май')
'труд и май'
```

Формат вывода метода format() может варьироваться:

```
>>> n = 10
>>> '{:b}'.format(n) # вывод в двоичной системе счисления
'1010'
>>> '{:c}'.format(n) # вывод в формате Unicode
'\n'
>>> '{:d}'.format(n) # по снованию 10
'10'
>>> '{:x}'.format(n) # по основанию 16
'a'
```

В Python есть полезные строковые методы, которые возвращают (True) истину или (False) ложь:

```
>>> 'spec'.startswith('a')
False
```

При работе с текстами полезно использовать строковый метод strip():

```
>>> s = '         \n ssssss'
\n'
>>> s.strip()
'ssssss'
```

Метод swapcase() возвращает строку с противоположными регистрами символов:

```
>>> 'Hello'.swapcase()
'hELLO'
```

Python позволяет творить чудеса с вызовами методов – их можно вызывать подряд в одну строку:

```
>>> 'ПРИВЕТ'.swapcase().endswith('т')
True
```

Перечень популярных строковых методов

```
s.upper() – возвращает строку в верхнем регистре
s.lower() – возвращает строку в нижнем регистре
s.title() – возвращает строку, первый символ которой в верхнем регистре
s.find('вет', 2, 3) – возвращает позицию подстроки в интервале либо -1
s.count('e', 1, 5) – возвращает количество подстрок в интервале либо -1
s.isalpha() – проверяет, состоит ли строка только из букв
s.isdigit() – проверяет, состоит ли строка только из чисел
s.isupper() – проверяет, написаны ли все символы в верхнем регистре
s.islower() – проверяет, написаны ли все символы в нижнем регистре
s.istitle() – проверяет, начинается ли строка с большой буквы
s.isspace() – проверяет, состоит ли строка только из пробелов
```

Объеденение строчек

```
>>> 'TT' + 'rr'
'TTrr'
```

На самом деле, в этот момент Python вызывает специальный строковый метод **add**() и передает ему в качестве первого аргумента строку 'rr':

```
>>> 'TT'.__add__('rr')
'TTrr'
```

Напомню, что этот вызов затем преобразуется Python в полную форму (результат будет аналогичный):

```
>>> str.__add__("TT", 'rr')
'TTrr'
```

### Escape-последовательности

| Синтаксис | Описание                 |
| --------- | ------------------------ |
| \n        | Переход на новую строку  |
| \t        | Знак табуляции           |
| \\        | Наклонная черта влево    |
| \\'       | Символ одиночной кавычки |
| \\"       | Символ двойной кавычки   |

Для вывода одинарных кавычек нужно заключать их в двойные (и наоборот):

```
print("Let`s")
```

Для переноса строки можно использовать тройные кавычки

```
print('''New
Line)
```

### Полезные функции

_print_ имеет несколько аргументов:

```
help(print)
```

Функция input возварщает строковый объект:

```
>>> s = input()  
hello
>>> s   
'hello'
>>> type(s)   
<class 'str'>
>>>
```

Обратиться по индексу:

```
>>> s = "Tra ta ta"
>>> s[0]
T
>>> s[-1]
a
```

Положительный аналог \[-1]:

```
>>> print(len(s)-1)
8
>>> s[len(s)-1]
a
```

### Срезы

```
>>> s = "Hello World"
>>> s[1:3] # срех начинается с индекса 1, заканчаивается индексом 3 (не включительно)
'el'
>>> s[:3] # с 0 индекса по 3-ий не включительно
'Hel'
>>> s[:] с 0 индекса по 3-ий не включительно
'Hello World'
>>> s[::2] # третий аргумент задает шаг (по умолчанию один)
'HloWrd'
>>> s[::-1] # «обратный» шаг
'dlroW olleH'
>>> s[:-1] # отрицательный индекс
'Hello Worl'
>>> s[-1:] # отрицательный индекс
'd'
```

## Преобразование типов

Возможность операций зависит от типов данных.

Для преобразования в необходимый тип данных используются функции **int**, **float** и **str**.

Например, преобразование в строковый тип данных:

```
str(4)
```

## Переменные

Переменные в Python содержат адреса объектов или можно сказать, что переменные ссылаются на объекты.

Переменная сохраняет своё значение на протяжении всей программы.

При присвоении переменной нового объекта, она (переменная) перестаёт ссылаться на старый объект и он автоматически удаляется.

Переменные не имеют типа.

В качестве имён переменных можно использовать только буквы, числа и нижнее подчеркивание. Имена переменных не могут начинаться с цифр. Имена регистрозависимые.

Удаление переменной:

```
>>> x = 2
>>> x
2
>>> del x
>>> x
NameError: name 'x' is not defined
>>>
```
