====== Переменные, операторы, циклы ======

===== Общее =====
Консольные скрипты хранятся с расширением **.py**, графические **.pyw**.\\
Стандартная кодировка для файлов **UTF-8 без BOM**, если файл в другой кодировке, то ее следует указать в первой (или второй) строке так:
<code python>#-*- coding: cp1251 -*-</code>

В Unix системах, внутри скрипта следует указывать путь к интерпретатору (аналогично bash), **#!/usr/bin/python**\\

Несколько команд в одной строке можно разделять точкой с запятой, а в целом, ее использование не рекомендуется.\\

Комментарии однострочные, символом решетки, многострочный можно выделить тремя символами двойной кавычки (форматирование сохраняется)\\
:!: по факту это будет строковая переменная, которая так же используется для документирования\\


==== Вывод ====
<code python>print([<Объекты>] [, sep=' '] [, end='\n'] [, file=sys.stdout] [, flush=False])</code>
:!: В аргументе **end** можно указать пробел (end=" "), тогда после команды **print()** не будет **перевода строки**\\

<code python>print("""Str1
Str2
Str3""")</code>

Так же, есть функция **sys.stdout.write()**, она не вставляет символ перевода строки в конце\\


==== Ввод ====
Для ввода есть функция **input()**, она возвращает введенное **значение в виде строки**\\
<code python>MyVar= input("Input String: ")</code>

**Входные аргументы**\\
<code python>Array= sys.argv[:]
for n in Array: ...</code>


==== Обработка исключений ====
Блок **try: .. except**
<code python>
try:
    commands..
except EOFError:
    ActionsIsError
</code>


===== Переменные =====
Все данные в языке представлены объектами. У каждого есть тип и значение.\\
Для доступа к объекту и есть **переменные**. При инициализации, в переменную сохраняется ссылка на объект (его адрес в памяти).\\


==== Именование ====
Не начинать с цифр, с подчеркиваний\\
Не пересекаться со встроенными функциями т.к. :!: их можно переопределить\\
Чувствительны к регистру\\


==== Типы данных ====
  * **bool** - логический
  * **NoneType** - объект со значением None т.е. отсутствие значения
  * **int,float** - целочисленные **ограничены только объемом ОЗУ**
  * **complex** - комплексные числа
  * **str** - Unicode-строки
  * **bytes** - неизменяемая последовательность байт
  * **bytearray** - изменяемая последовательность байт
  * **list** - списки. Аналогичен массивам **type([1,2,3])**
  * **tuple** - кортежи **type( (1,2,3) )**
  * **range** - диапазон **type(range(1,10))**
  * **dict** - словари. Аналогичен ассоциативным массивам **type({"five":5, "ten": 10})**
  * **set** - множество (уникальных объектов) **type({"a", "b", "c"})**
  * **frozenset** - неизменяемое множество  **type(["a", "b", "c"])**
  * **ellipsis** - используется в расширенном синтаксисе получения среза.. хз
  * **function, module, type** - ф-ции, модули, классы

  * **изменяемые** - bytearray, т.е. можно обратится к элементу и заменить его
  * **не изменяемые** - int, str, tuplr, range, bytes, тут уже только сложени/конкатенация и т.д.
  
Так же, **последовательности** и **отображения**, к последним относится **словарь**.\\
Они поддерживают итераторы, с помощью метода **__next__()** или функции **next()**
<code python>
  arr=[1,2]
  i= iter(arr)
  i.__next__() || next(i)
</code>

Но лучше всего делать **перебор в цикле for**
<code python>
for i in arr:
  print(i+ " -", end=" ")

# или dict
d= {"one":1, "two":2, "three":3}  
for i in d:
  print(d[i])
</code>


==== Присваивание значения ====
После присваивания, в переменной сохраняется **ссылка на объект а не сам объект**\\
Несколько переменных могут ссылаться на один и тот же объект в памяти. Например при множественном присваивании изменяемых объектов (list/dict/bytearray) это происходит автоматически\\
:?: на счет изменяемых объектов под вопросом\\

<code python>
x,y,z= 1,2,3 # Разные объект (но интерпретатор для оптимизации может автоматом сделать один)
x,y,z= [1,2,3] # Тут присвоили list и объект в памяти один, три ссылки на него

x is y # Ссылается ли x на y
sys.getrefcount([1,2,3]) # Кол-во ссылок на объект в памяти (удаляется при 0)
</code>

Так же работает позиционное присваивание. Если кол-во не совпадает будет ошибка, но если указать звездочку, то одна из переменных, автоматом станет списком
<code python>
x,y= y,x # Так можно поменять местами значение переменных
a,b,*c= 1,2,3,4,5
</code>


==== Проверка типа ====
<code python>
type(a) # Сообщение с указанием типа

if(type(x)== int):
  # Целое число
  
if isinstance(s, str):
  # Строка
</code>


==== Преобразование ====
  * bool(), float()
  * int(<объект>, <система счисления>= 10)
  * str(), str(<>,<кодировка>,<обработчик ошибок>)
  * bytes(), bytes(<>,<кодировка>,<обработчик ошибок>)
  * bytearray(), bytearray(<кодировка>,<обработчик ошибок>)
  * list(), tuple()

<code python>
int(7.5); int("0o71",8); int("A",16) # 7, 57, 10
float("Infinity"); float("-inf") # inf, -inf
</code>


==== Удаление ====
<code python>
del x
del x,y
</code>


===== Операторы =====

==== Математические операторы ====
Стоит отменить:
  / - деление, **результатом всегда будет вещественный тип**
  // - деление с округлением вниз (слеши вместе)
  % - остаток от деления
  ** - возведение в степень
Работа с десятичными числами может быть неочевидной, для операций с фиксированной точностью стоит использовать модель **Decimal**\\
Decimal("3.0") + Decimal("4.0")\\


==== Двоичные операторы ====
<code python>
# Инверсия(~), И(&), ИЛИ(|), Исключающее ИЛИ(^), сдвиг влево/вправо(<</>>)
</code>


==== Для работы с последовательностями ====
Конкатенация(+), повторение(*), проверка на вхождение(in), проверка на не вхождение(not in)\\


==== Операторы присваивания ====
Комбинируется со всеми мат операторами.\\


===== Условные операторы и циклы =====
**Любой объект** может интерпретироваться как логическое выражение, в т.ч. списки, словари и т.д.\\
False будет только **пустое или нулевое** значение\\
В сравнении все обычно, присутствуют **and**, **or**, **not**, **is**, **!=, ==** и т.д.\\


==== Ветвление ====
Условие можно помещать в круглые скобки, но не обязательно, даже не желательно видимо\\
Блок можно размещать в одно строке, даже несколько д-й разделенных ;\\

<code python>
if x % 2== 0:
  # chet
else:
  # ne chet
  
if var== "abc": #act1; act2
elif not var: #<empty value>
else: #act1; act2
</code>


==== Цикл for ====
По сути это **foreach**, работает только с последовательностями\\
В конце можно добавить блок **else**, который выполнится (если не было **break**) после цикла\\

<code python>
# Перебор словаря
arr= {"one":1, "two":2, "three":3}
for key in arr.keys(): # метод keys() возвращает перечень ключей
  print(key, arr[key])
else
  print("complete")

# Конкретно для цикла можно обойтись и без keys()
for key in arr:
  print(key, arr[key])

# Тут элементы списка кортежей
arr= [(1,2), (3,4)]
for a,b in arr:
  print(a,b)
</code>


==== range() и enumerate() ====
**range(<Начало>=0,<Конец>,<Шаг>=1)**- создается особый объект- **диапазон**, поддерживающий итераторы\\
Содержит два метода: 
  * **index(<значение>)**- возвращает индекс элемента по значению
  * **count(<значение>)**- кол-во элементов с указанным значением

<code python>
for i in range(1, 100): print(i) # 1-100
for i in range(100, 0, -1): print(i) # 100-1
</code>

**enumerate(<объект>, <start>=0)**- возвращает кортеж из **индекса и значения** текущего элемента, можно задать начало\\
Функция **не создает список, а возвращает итератор**\\

<code python>
arr= [1,2,3,4,5,6,7]
for i, elem in enumerate(arr):
  arr[i] *= 2
</code>


==== Цикл while(), continue/break ====
Все так же, в цикле тоже есть ветка **else**\\

<code python>
print("Input digit")
summ=0
while True:
    x= input("Input: ")
    if x== "stop":
        break
    summ += int(x)
print("Summ== ", summ)
</code>