Рубрики
Без рубрики

Как Python принимает решения: введение в контрольный поток в программировании

Автор оригинала: FreeCodeCapm Team.

Иваном Лео

Что такое контрольный поток?

Мне легко думать о потоке управления в 3 разных категориях

  1. Петли (в то время как, делайте, для)
  2. Принятие решений (если-else)
  3. Обработка исключений (продолжить, попробуйте, кроме, пройти, перерыв)

Эти 3 категории примерно суммируют различные варианты доступными для нас, когда мы говорим о потоке управления в большинстве языков программирования.

Так что давайте прыгнем прямо в.

Петли

Хорошая аналогия, используемая для петли, пробивает тесто для торта:

На основании этого Рецепт Если мы используем современный дневной миксер, 3 минуты – это идеальное время, чтобы смешать тесто. Если вы должны были дать инструкции для кого-то, используя этот рецепт, это, вероятно, будет выглядеть что-то подобное.

  1. Микс яйца, мука и секретный рецепт
  2. Начните секундомер и начните смешивать тесто
  3. Смешайте тесто, пока остановка не отобразится 3 минуты

Если бы мы перевели это в PSEDO-код, это, вероятно, будет выглядеть что-то подобное

#Start Timer<....code....>time = 0
While(time != 3 minutes):    time = newvalue    mix batter

В этом случае мы используем время Чтобы определить, продолжаем ли мы смешивать наше тесто. Но это на самом деле не помогает нам учитывать конкретные ситуации, когда мы используем разные ингредиенты.

В этом случае у нас есть несколько вариантов

  1. Мы могли бы следить за консистенцией теста
  2. Или мы могли бы экспериментировать с целым кучей ингредиентов, записывать лучшие времена для каждого, а затем обратиться к этой записи каждый раз, когда мы смешаем торты.

Теперь останавливайтесь на мгновение и подумайте, когда мы будем использовать первый вариант, и когда мы будем использовать второй вариант?

<Преднамеренные пустые осталось здесь. Зайдите и думайте на некоторое время:)>

Первый вариант более подходит к ситуациям, когда мы могли бы встретить много непредсказуемых комбинаций. Следовательно, имеет смысл не только проверить время, но и добавить защиту дополнительного параметра.

Второй вариант подходит к ситуациям, когда мы сталкиваемся с повторными экземплярами нескольких комбинаций. Это широко известно как динамическое программирование.

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

Теперь давайте преобразом то, что мы узнали в коде и изучить, что мы можем реализовать в Python:)

Код

В Python у нас есть два основных инструмента для петли

  1. В то время как петли
  2. Для петлей

В то время как петли

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

x = 1y = 2
while(x=2):    print("x is looping")
while(y=2):    print("Y is looping")

В коде выше, только вторая, пока цикл будет оценивать, пока первым не будет. Когда мы запускаем код, мы получим следующий вывод

>>>python runapp.pyY is loopingY is loopingY is loopingY is looping....

Вот что происходит для первой переменной.

Как видно выше, то в то время как цикла не печатают x, поскольку оно не соответствует условию, предусмотренному в первом во время цикла.

Как насчет второго условия? Ну, это следует что-то вроде этого:

Как видно, цикл Whicle постоянно проверяет, является ли условие истинным и только выполняет, если указанное условие верно.

Вот некоторые общие реализации в Python:

#Asking for User Inputwhile True:    userinput = input("Please Input Your Name: ")    if userinput.isalpha():       break;
print("Hello %s"%(userinput))
#Dealing with dynamic Variables (i.e. Parameters that can change )no = int(input("Please Enter the number of Loops: "))i = 0
while(i

Давайте просмотрим два примера.

Пример 1.

Этот пример код (см. Выше) – это образец кода, который мы могли бы использовать для захвата некоторых пользовательских входов. Когда вы кодируете более продвинутые программы, вы сможете кодировать более продвинутые программы, которые могут проверить ввод пользователя или сделать больше вещей с вводом пользователя, но на данный момент мы собираемся распечатать «Hello »:

While True:

Поскольку истина всегда правда (я знаю, что это немного противодействует, но нести со мной), эта петля будет работать вечно. Правда никогда не может быть правдой Отказ

userinput = input("Please Input Your Name: ")

Это позволяет нам получить некоторое вход от пользователя и хранить его в виде строки. Мы создаем переменную, называемую UserInput и хранить ссылку на эту сохраненную строку в памяти. (Если вы не уверены в том, что здесь происходит, я написал статью на переменных в Python, проверить это!)

if userinput.isalpha():       break;

Теперь приходит волшебный соус. Метод .isalpha () позволяет нам проверить, состоит ли строка исключительно символов.

#Sample Output"12a".isalpha() #This returns False"12".isalpha() #This returns False"abc".isalpha() #This returns True

Использование этой функции позволяет вам проверить, будет ли пользователь ввести правильное имя, которое состоит исключительно из символов в алфавите.

Если пользователь вводит правильное имя, функция перерыва позволяет выходить из цикла.

print("Hello %s"%(userinput))

Это затем позволяет выполнять конечную строку кода, печатать строку «Привет <имя пользователя»> «.

Пример 2: зацикливание для ряда петлей

no = int(input("Please Enter the number of Loops: "))

Эта первая строка кода позволяет пользователю вводить определенное значение из командной строки, прежде чем преобразовать ее в целое число. Это делается с использованием значения int ().

i = 0
while(i

Далее мы инициализируем переменную I до 0, чтобы отслеживать количество петлей, которые мы хотим запустить, печатать значение i каждый раз:

#Sample OutputPlease Enter the number of Loops: 501234

Это полезно думать о том, что бурновая петля как таковая

while(test_expression):

Для петлей

Для петель работают немного по-другому, чем пока циклами. Давайте рассмотрим синтаксис

#Normal For LoopFor i in range(1,6,1):    
#Iteration Loopfor i in [1,2,3,4,5]:

Что тут происходит?

Когда вы объявляете A для цикла, как видно в первом случае, вы вызываете то, что известно как генератор. Это генерирует список чисел, используя параметры, которые вы указали.

Это полезно думать о генераторе как функцию, которая сейчас вызывает список. Хотя это не совсем, как это работает, это тесное приближение. Больше, чтобы прийти на эту тему!

#This generates a list with values [1,2,3,4,5]For i in range(1,6,1):

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

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

for i in [1,2,3,4,5]:

Некоторые полезные случаи

#Printing out items in a list
x = [...values...]for i in x:   print(i)
#Iterating Over items in a listy = [x**2 for i in x] #This is also known as list comprehension

Давайте рассмотрим эти случаи более подробно!

Пример 1.

x = [....values...]for i in x:

В этом случае мы инициализируем список, называемое X с определенным количеством переменных. Затем мы перейдем к повторению каждого значения в X.

print(i) #This prints out each value of x in its specified order

Мы называем каждое значение в X, в этом случае называемым I, и распечатайте его.

#Sample Outputx  = [1,2,3,4]for i in x:     print(i)
>>>python app.py1234

Пример 2.

y = [x**2 for i in x]

Давайте попробуем переписать это в другой форме

for i in x:    y.append(x**2)
y = [x**2 for i in x]

Эти 2 одинаковы! Однако список списков, как правило, будет быстрее.

Принимать решение

Что касается вашего ума, когда вы думаете о принятии решений во время написания программы? Для меня это определенно решение деревьев и блок-схема.

Хотя некоторые из них (например, приведенные ниже), безусловно, смешно, я думаю, что они все еще предлагают полезную ментальную структуру для визуализации вашего поезда программы:

Я буду использовать аналогию, чтобы поговорить об этом, прежде чем продолжать, чтобы показать, как реализовать это, используя, если-царствуют синтаксис продолжения.

Аналогия – время

Представьте, что вы пытаетесь найти идеальный ресторан на дату вечером. Вы хотите найти что-то доступное и шикарное

Пока вы просматриваете советник поездки, ваш мыслительный процесс будет чем-то вроде этого.

Вы бы только рассмотрели вещи, которые были дешевыми и шикарными. Поэтому каждый раз, когда вы смотрели в ресторан, вы бы проверили, соответствует ли он вашим критериям и устраняет те, которые этого не сделали.

Аналогичным образом, принятие решений в программе работает так же. Вы установили кучу возможных сценариев, и ваша программа реагирует соответственно.

код

Давайте посмотрим на простую программу, чтобы найти цифры, которые являются краскими двумя.

import random
x = random.randint(0,1000)
if x%2==0:
    print(str(x)+" is a multiple of 2")
else:
    print(str(x)+" is not a multiple of 2")

Как работает эта программа?

  1. Сначала мы генерируем случайное число от 0 до 1000
  2. Затем мы разделяем это случайное число, X, на 2 и проверьте, есть ли остаток. (% Возвращает оставшуюся часть подразделения)
  3. Если нет остаток, мы распечатаем утверждение «X – это краткий из 2»
  4. Если есть остаток, мы распечатаем утверждение «X не является кратным 2»

Мы знаем, что все кратные 2 следуют по формуле 2i, где я целое число. Поэтому все кратные 2 должны быть делимы на 2. Следовательно, мы используем это как способ оценки, если число является кратным 2.

Это может быть визуализировано как дерево решений, как видно ниже.

Как видно, цикл решения IF-царства позволяет нам объяснить значения наших переменных, позволяя нашей программе вернуть другое вывод W.R.t их значения.

Мы также можем использовать цикл If-else для учета типа переменных, слегка изменяя приведенный выше синтаксис.

def checking(n):
    if type(n) == str:
        print("String!")
    elif type(n) == int:
        print("Integer!")
    else:
        print("we're not sure what n is....")
x = [1,2,3,'a','bac',2.12]for i in x:    checking(i)

Указатели к примечанию:

  1. Мы использовали оператор ELIF в этом контексте, чтобы добавить дополнительные возможные случаи n, который мы хотим объяснить.
  2. Мы также использовали тип в качестве условия для оценки переменной вместо исходного использования значения переменной.

Обработка исключений

Иногда в Python вы обнаружите, что вам нужно будет учитывать исключения. Это могут быть недействительными операциями (например, пытаясь разделить 0 или переполнение стека) или класс значений, которые вы просто не заинтересованы.

В этих случаях мы можем использовать

  1. Продолжать
  2. Проходить
  3. Попробуйте
  4. Перерыв

Я постараюсь дать краткий обзор использования этих операций по обработке исключений.

Продолжать

Посмотрите на код ниже и попробуйте угадать, что продолжается:

y = [1,2,3,4,5,6,6,7,8]
x = []
for i in y:
     if i in x:
         continue
     else:
         x.append(i)     print(i)
print(x)

Если вы уже догадались, что он в основном пропускает остаток куска кода, вы правы! Продолжайте делать только это.

В указанном выше коде мы пытаемся удалить дубликаты значения в Y. Мы делаем это в коде, используя этот процесс

  1. Мы проверяем, если переменная, я, что мы оцениваем, находится в новом списке X.
  2. Если он находится в новом списке X, мы «продолжаем» и переходите для оценки следующей переменной внутри списка Y.
  3. Если он не в новом списке X, мы не «продолжаем» и вместо этого переходите, чтобы добавить переменную для перечисления X.

В конце концов это помогает нам удалить все дублирующие переменные в X.

Проходить

y = [1,2,3,4,5,6,6,7,8]
x = []
for i in y:
    if i in x:
         pass
    else:
         x.append(i)    print(i)
print(x)

Если вы должны были запустить код, вы также заметите, что все дублирующие переменные были напечатаны! Это ключевое отличие между пройденным и продолжением.

Эта разница становится полезной, если вы пытаетесь запустить дополнительные операции на невзрачных переменных (например, получить сумму).

Перерыв

Перерыв делает то, что он говорит. Он разбивает вашу программу или подпрограмму, когда вы соответствуете исключением.

Вот полезный пример перерыва:

x = [1,3,5,7,2,3,5,7]
count = 0
for i in range(len(x)):
if x[i]%2==0:
    print("There is an even number at index " + str(i))
    break
else:
    continue

В этом примере мы пытаемся найти индекс первого четного числа в нашем списке X. Перерыв позволяет нам сделать это, выходя из петли преждевременно!

Попробуйте

Попробуйте за исключением синтаксиса особенно полезен, когда речь идет о борьбе с ошибками в чтении файлов или оценке синтаксиса. Некоторые из общих ошибок исключения

  1. IoError: неспособность открыть файл
  2. ImportError: Python не может найти и открыть модуль, который вы хотите импортировать
  3. ValueError: при прохождении значения в функцию с неправильным типом или значением
  4. Keyboardintrupt: Когда вы преждевременно прекращаете свою программу
  5. EOFERROR: Когда вы достигли конца файла

Вот пример того, что мы пытаемся проверить для ValueError:

try:
    x = int(input("Please input some numbers: "))
    print(x)
except ValueError as ve:
    print("Please input numbers. NUMBERS not letters")

Эта программа работает, потому что строки и буквы не могут быть привлечены в целые числа. (Если они не являются целыми числами, которые были сохранены как строки I.E. «2», «3» и т. Д.)

Для тех, кто работает с импортными файлами, вы можете быть знакомы с DizoneErrors. Их можно объяснить, используя следующий синтаксис:

try:
    f = open('nofile.txt')
except FileNotFoundError:
    print("Erm...there's no such file man")

Синтаксис попробовать, кроме как можно подумать о таком.

try:    except :    except :

Заключение

Эта сорта подразделяет основное принятие решений в Python и многих других языках программирования. Хотя точный синтаксис определенно отличается, основные принципы примерно одинаковы.

После того, как вы получите повешение контрольного потока, вы сможете строить программы, которые будут иметь большое значение и могут работать так, как вы хотите!:)

Если вам нравится читать дальше о переменных в Python, проверьте статью, которую я написал на них здесь !

Читайте ещё по теме: