#!/usr/bin/env python
# coding: utf-8

# # Структура программы
# ## Условный оператор if
# 
# В полной форме:
# 
# ```
# if [условие - логическое выражение, True или False]:
#     [блок кода с отступом 4]
# elif [условие]:
#     # иначе, если. Условие проверяется, если не выполнено предыдущее
#     [блок кода с отступом 4]
# elif [условие]:
#     # еще условие, проверяется, если оба предыдущих не выполнились
#     [блок кода с отступом 4]
# else:
#     # блок выполняется, если все предыдущие условия не выполнены (False)
#     [блок кода с отступом 4]
# ```
# 
# Обязательно иметь только блок c `if`, блоков `elif` может быть сколько угодно или вообще не быть, блок `else` либо один, либо его нет.
# 
# блоки if могут быть вложены, т.е. во внутренних блоках кода тоже можно проверять условия:
# 
# ```
# if x > 0:
#     if y > 0:
#         print("здесь x и y положительны")
#     else:
#         print("здесь только x положительный")
# ```
# 
# Второй `else` относится к `if y > 0`. Это понятно из форматирования, потому что он поставлен с отступом от `if x > 0`.
# 
# ## Циклы
# ### Цикл for
# 
# Одна форма:
# 
# ```
# for [переменная] in [какое-то перечисление]:
#     [блок кода с отступом 4, можно использовать "переменную"]
# ```
# 
# переменной последовательно присваиваются значения из перечисления. Например, так:

# In[1]:


for i in range(10):
    print(i)


# Переменной `i` последовательно присваиваются значения от 0 до 9, подробней про `range` будет дальше.
# 
# Получается, что в python нет привычных циклов из Pascal или C, когда можно сказать, что переменная сначала равна 1, а потом постепенно увеличиваеся до 10:
# 
# ```
# for i := 1 to 10 do
# ```
# 
# В C и Pascal последовательное изменение значения числовой перменной встроено в язык.
# 
# ### Цикл while
# 
# ```
# while [условие]:
#     [блок кода с отступом 4]
# ```
# 
# В цикле проверяется условие. Если оно верно, выполняется блок кода, иначе цикл заканчивается.
# После выполнения блока кода снова проверяется условие, если оно верно, выполняется блок кода, иначе цикл заканчивается.
# И так далее.
# 
# Другими словами, пока условие верно, блок кода выполняется. Как только оно стало неверным, цикл завершается.
# 
# В Python нет цикла do while, в котором условие проверяется в конце.

# In[4]:


x = 1
while x < 100:
    print(x)
    x = x * 2


# In[5]:


x = 1
while x < 100:
    x = x * 2
    print(x)


# Например, давайте пользователь будет вводить числа до тех пор пока не введет слово `stop`. Дальше программа должна распечатать сумму введенных чисел. Ввод данных - это функция input.
# 
# Цикл `for` не подходит, потому что он делает действия для фиксированного набора элементов из перечисления. Пользуемся `while`:|

# In[10]:


sum = 0  # сначала сумма равна 0, потом будем изменяться
text = input("введите число или слово stop")  # возвращает строку, введенную пользователем
while text != 'stop':
    sum = sum + int(text)  # int это и имя типа, и функция превращаения в int, т.е. целое
    text = input("введите число или слово stop")
    
print(f"сумма введенных чисел равна {sum}")    


# Как сделать лучше? Часто условие нужно проверять не в начале цикла, а в середине. В данном случае в цикле надо сначла спросить пользователя число, проверить не слово ли это stop и потом уже добавить число в сумму:

# In[11]:


sum = 0  # сначала сумма равна 0, потом будем изменяться
while True:  # условие, которое всегда верно. 2 == 2 эквивалентно True
    text = input("введите число или слово stop")
    if text == 'stop':  # проверка условия на выход в середине цикла
        break  # break завершает цикл
    sum = sum + int(text)  # int это и имя типа, и функция превращаения в int, т.е. целое
    
print(f"сумма введенных чисел равна {sum}")   


# # Типы последовательности
# Хранят последовательность значений, эти значения можно перечислять в цикле `for`. Таких типов очень много, можно создавать свои. Встроенные:
# 
# 1. Строки - перечисление своих символов. "abc", например, это перечисление символов "a", "b", "c". В Python нет разделения типов между строками и символами. Символы тоже строки.

# In[12]:


for c in "hello":
    print(c)


# `c` последовательно присваиваются символы слова "hello".

# 2. range - диапазоны. Это специальный тип, он называется range, диапазон можно создать функцией, которая тоже называется `range`. Варианты использования:

# In[20]:


range(10) # от 0 до 9, указанное значение не включается. Не до 10, а до 9
range(2, 10) # от 2 до 9, правое значение опять не включается
range(0, 100, 10)  # от 0 до 100 (не включительно) с шагом 10

# Пока что мы можем использовать это только в циклах

for x in range(0, 100, 10):
    print(x)
    
print("---")    
    
for x in range(10, 0, -1):  # конечное значение 0 не включается
    print(x)


# 3. Списки (list) и кортежи (tuple, тьюплы). Это упорядоченные последовательности произвольных элементов. Например, список `[10, 20, 30]` хранит три числа 10, 20 и 30.
# 
#     Кортежи аналогично, только можно без скобок:
#     ```10, 20, 30```, это тоже три числа 10, 20, 30.
#     
#     Различие кортежей и списков в том, что списки можно изменять, например, добавлять в них новые элементы. Про изменяемые и неизменяемые типы будем говорить отдельно в следующий раз.

# In[25]:


a = [10, 20, 30]  # список
b = 10, 20, 30  # кортеж

print(a)
print(b)  # кортеж печатается с круглыми скобочками

a = []  # пустой список
b = ()  # пустой кортеж (обычно в нем нет смысла)
a = [10]  # список из одного элемента
b = (10,)  # кортеж из одного элемента. Здесь хитрый синтаксис - скобки и запятая
           # потому что 10 или (10) это просто число 10, а не кортеж.


# Списки, кортежи можно перечислять:

# In[26]:


for x in [10, 20, 30]:
    print(x)


# Очень часто можно увидеть код, в котором перечисляются элементы списка по индексу, это просто калька с Pascal или С, которая не имеет смысла:

# In[27]:


a = [10, 20, 30]
for i in range(3):  # i от 0 до 2
    print(a[i])  # тоже см. дальше, это получение элемента по его номеру.


# Лучше писать предыдущим способом без индекса.

# In[28]:


for x in 10, 20, 30:  # перечисляем кортеж
    print(x)


# При создании кортежа довольно часто ставят вокруг круглые скобки, потому что иначе Python не поймет, что имелось в виду. Примеры будут появляться дальше сами собой.
# 
# ## Действия с типами-последователностями:
# 
# [Таблица действий](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)

# In[2]:


print(10 in [10, 20, 30])
print(10 in (10, 20, 30))  # нужны скобки для кортежа, иначе другой смысл
print('a' in 'qwr;oiasdsdg')
print('as' in 'qwr;oiasdsdg')  # можно проверять подстроки

print([20, 30, 40] + [40, 50, 60])
print((20, 30, 40) + (40, 50, 60))

print(len([10, 20, 30]))  # длина 3


# **Слайсы**
# Очень мощная возможность python

# In[42]:


a = [10, 20, 30, 40, 50, 60]
print(a[3])  # элемент с индексом 3, начиная с 0
print(a[2:4])  # от 2 до 4 индекса, не включая последний
print(a[2:])  # от 2 до конца
print(a[:4])  # с начала до 4-го не включительно
print(a[0:6:2]) # шаг 2
print(a[::2]) # от начала до конца с шагом 2


# И еще много других комбинаций с указанием или без указания начала или конца. Можно использовать отрицательный шаг, чтобы перечислять справа налево. **И можно использовать отрицательные индексы. Отрицательный индекс означает подсчет с конца, например, -1 означает последний элемент.**
# 
# Слайсы работают со всеми типами последовательностями, со строками тоже. У нас будут задачи про строки и слайсы. Поэтому экспериментируйте.