Вычислите значения следующих выражений запишите результат в двоичной: § 12. № 5. ГДЗ Информатика 10 класс Поляков. Помогите вычислить значения выражений И записать в других системах счисления.

Логические выражения

Мы можем определять логические выражения, используя рекурсивное определение:

1. Пропозициональные переменные (значение которых ИСТИНА или ЛОЖЬ) а пропозициональные константы ИСТИНА и ЛОЖЬ являются логическими выражениями.
2. Если LE1 и LE2 - логические выражения, то LE1 AND LE2 - логическое выражение, значение которого ИСТИНА, если оба LE1 и LE2 имеют значение ИСТИНА, и ЛОЖЬ в противном случае.
3. Если LE1 и LE2 - логические выражения, то LE1 OR LE2 - логическое выражение, значение которого ИСТИНА, если либо LE1, либо LE2 имеют значение TRUE, и ЛОЖЬ в противном случае.
4. Если LE1 является логическим выражением, тогда НЕ LE1 является логическим выражением, значение которого ИСТИНА, если LE1 имеет значение ЛОЖЬ, и ЛОЖЬ в противном случае.

Уровни приоритета логических операторов:

1. НЕ
2. И
3. ИЛИ

Присваивая значения переменным в логическом выражении, мы также присваиваем значение самому выражению.

Пример: задано выражение «(p AND q) OR r», если p = TRUE, q = TRUE и r = FALSE, то значение выражения - TRUE.

Логические функции и таблицы истинности

Смысл (или значение) логического выражения является логическим. функция из множества возможных присвоений истинностных значений для переменных в выражении к значениям {ИСТИНА, ЛОЖЬ}.

Пример: используя выражение «(p AND q) OR r», мы можем описать логическая функция, определяющая значение выражения путем рассмотрения всех комбинаций присвоений значений для p, q и r.

      p q r (p AND q) ИЛИ r
      ------------------------------
      Т Т Т Т
      Т Т Ф Т
      Т Ф Т Т
      T F F F
      F T T T
      F T F F
      F F T T
      F F F F
   

Приведенная выше таблица с описанием логической функции "(p AND q) OR r" называется таблицей истинности .В таблице истинности есть столбец для каждой переменной в выражение, и каждая строка в таблице соответствует присвоение значений переменным. В последнем столбце указано значение выражения для конкретный набор присвоений переменных, указанный в строке.

Мы можем определить основные операторы в терминах таблицы истинности следующим образом (где мы используем 1 и 0 вместо ИСТИНА и ЛОЖЬ):

     p q p И q p ИЛИ q НЕ p
     ------------------------------------
     0 0 0 0 1
     0 1 0 1 1
     1 0 0 1 0
     1 1 1 1 0
   

Обратите внимание, что таблица истинности для функции N переменных имеет 2 ^ N строк.N различных булевых функций от N переменных.

Вот некоторые дополнительные функции двух переменных, которые часто используются:

     p q p-> q p == q p NAND q p NOR q
     -------------------------------------------
     0 0 1 1 1 1
     0 1 1 0 1 0
     1 0 0 0 1 0
     1 1 1 1 0 0
   

Комментарии к этим функциям:

• Следствие: «p -> q» или «p подразумевает q» означает, что всякий раз, когда p истинно, q тоже.Единственный способ "p -> q" может быть ЛОЖЬ, если p ИСТИНА, а q ЛОЖЬ.
• Эквивалентность: «p == q» означает что p и q имеют одинаковое значение.
• NAND: «p NAND q» означает «НЕ (p AND q)».
• NOR: «p NOR q» - это то же самое, что «NOT (p OR q)».
• Приоритет (от высшего к низшему): НЕ, И-НЕ, ИЛИ, И, ИЛИ, ->, ==.

Вычисление выражений с таблицами истинности

Мы можем вычислить значение выражения, используя таблицы истинности.Создаем таблицу для всех возможных значений переменных, и все подвыражения в выражении.

Вычислите значение следующего выражения E для всех возможные присвоения истинности: (p -> q) -> (q -> r)

      p q r p-> q q-> r E
      ---------------------------
      0 0 0 1 1 1
      0 0 1 1 1 1
      0 1 0 1 0 0
      0 1 1 1 1 1
      1 0 0 0 1 1
      1 0 1 0 1 1
      1 1 0 1 0 0
      1 1 1 1 1 1
   

Обратите внимание, что столбец для значения q-> r такой же как столбец для значения всего выражения E.Мы установили эквивалентность этих двух столбцов, что значит:

       (p -> q) -> (q -> r) == q-> r.
   

Генерация выражений из функций

Нам часто дают булеву функцию в виде таблицы истинности. и должен получить соответствующее логическое выражение.

Например, цифровые схемы построены из цифровых элементы, которые вычисляют основные логические операции (например, НЕ и И-НЕ).

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

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

Результирующее выражение использует в качестве операторов только AND, OR и NOT.

Исключительное Или: выражение из таблицы истинности

Исключающее ИЛИ (XOR) - еще одна хорошо известная функция двух переменных. Таблица истинности для XOR:

      p q XOR
      ---------------
      0 0 0
      0 1 1
      1 0 1
      1 1 0
   

Мы можем построить выражение для XOR в терминах AND, OR и НЕ, используя следующие рассуждения:

• Вторая строка говорит нам, что p XOR q истинно. когда p - ЛОЖЬ, а q - ИСТИНА.Другими словами, p XOR q ИСТИНА, если НЕ p И q ИСТИНА.
• Третья строка сообщает нам, что p XOR q истинно. когда p - ИСТИНА, а q - ЛОЖЬ. Другими словами, p XOR q истинно, если p AND NOT q истинно.
• Остальные строки говорят нам, что p XOR q имеет значение FALSE в все остальные случаи.
• Итак, p XOR q ИСТИНА, если НЕ p И q ИСТИНА, или если истинно p AND NOT q.

Из вышеизложенного мы определяем, что следующее логическое выражение для функции p XOR q:

      (НЕ p И q) ИЛИ (p И НЕ q)
   

Конъюнктивные и дизъюнктивные нормальные формы

Логическое выражение находится в дизъюнктивной нормальной форме если оно выражено как сумма (ИЛИ) произведений (И).То есть логическое выражение B находится в дизъюнктивной нормальной форме если это написано как:

      A1 ИЛИ A2 ИЛИ A3 ИЛИ ... An
   

      Т1 И Т2 И ... И Тм
   

Логическое выражение находится в конъюнктивной нормальной форме если оно выражено как произведение (И) сумм (ИЛИ).То есть логическое выражение B находится в конъюнктивной нормальной форме если это написано как:

      O1, O2, O3, и ...
   

      Т1 ИЛИ Т2 ИЛИ ... ИЛИ Tm
   

Нормальные формы в таблицах истинности

Конъюнктивные и дизъюнктивные нормальные формы двойственны друг другу; любой из них может использоваться для генерации логического выражения из таблицы истинности.

С помощью этих нормальных форм мы можем быть более точными о том, как сгенерировать логическое выражение из таблицы истинности.

Чтобы построить логическое выражение в дизъюнктивной нормальной форме из таблица истинности:

• Создайте minterm для каждой строки таблицы, в которой функция истинна.
• Для каждой переменной, значение которой равно 1 в этой строке, мы включаем переменная в minterm; если переменная в этой строке равна 0, мы включаем отрицание переменной в minterm.
• Выражение состоит из ИЛИ всех минтермов.

Конечно, мы могли бы построить выражение в дизъюнктивном нормальном форма с использованием maxterms и И.

Логическое выражение для сумматора

Двоичный сумматор целых чисел может быть построен из ряда однобитовых сумматоров. Однобитовый сумматор принимает два однобитовых операнда (x и y) и бит переноса из предыдущего однобитового сумматора (ci), и производит сумму этих битов, и выносной бит (со).

Мы можем определить логическую функцию, соответствующую сумматору в виде таблицы истинности. Затем мы можем построить логические выражения для s и co, из которого мы могли построить схему.

  x y ci co s
  ---------------------
  0 0 0 0 0
  0 0 1 0 1 с: НЕ x И НЕ y И ci
  0 1 0 0 1 с: НЕ x И y И НЕ ci
  0 1 1 1 0 co: НЕ x, y и ci
  1 0 0 0 1 с: x И НЕ y И НЕ ci
  1 0 1 1 0 co: x И НЕ y И ci
  1 1 0 1 0 co: x И y И НЕ ci
  1 1 1 1 1 co, s: x, y и ci
   

Логическое выражение для s:

  (НЕ x И y И ci) ИЛИ (x И НЕ y И ci) ИЛИ
  (x AND y И НЕ ci) ИЛИ (x AND y AND ci)
   

Логическое выражение для co:

  (НЕ x И НЕ y И ci) ИЛИ (НЕ x И Y И НЕ ci)
  ИЛИ (x И НЕ y И НЕ ci) ИЛИ (x И y И ci)
   

Полнота логических операторов

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

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

Мы можем показать, что одного оператора И-НЕ достаточно для генерации каждой логической функции, показывая, как реализовать И, ИЛИ, и НЕ с точки зрения NAND.

      p q p NAND 1 q NAND 1 p NAND q E1 E2
      --------------------------------------------
      0 0 1 1 1 0 0
      0 1 1 0 1 0 1
      1 0 0 1 1 0 1
      1 1 0 0 0 1 1
  
    E1: p AND q == ((p NAND q) НЕ ИСТИНА)
    E2: p ИЛИ q == ((p НЕ И ИСТИНА) ИЛИ (q НЕ И ИСТИНА))
    E3: (НЕ p) == (p НЕ ИСТИНА)
   

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

Таким образом, мы можем генерировать цифровые схемы для любой булевой функции используя только операторы NAND или NOR (или компоненты).

Тавтологии

Тавтология - это логическое выражение, которое всегда ИСТИНА, независимо от присвоения значений истинности переменным в выражениях.

Примеры тавтологий:

• ИСТИНА
• ИСТИНА ИЛИ p
• p ИЛИ НЕ p
• НЕ (p И НЕ p)
• p == p
• (p OR q) == p OR (НЕ p AND q)
• (p == q) -> (p -> q)

Если мы сможем установить, что «LE1 == LE2» является тавтологией, тогда независимо от того, какие значения мы присваиваем переменным в LE1 и LE2, мы знаем, что «LE1 == LE2» имеет значение ИСТИНА.

Если «LE1 == LE2» является тавтологией, то мы можем заменить LE2 на LE1. (или наоборот) в любом выражении, без изменения значения выражения.

Задача тавтологии

Интересный вопрос - задать ли данное логическое выражение - тавтология. Этот вопрос известен как «проблема тавтологии».

Для решения проблемы тавтологии нам достаточно построить таблица истинности логического выражения.кн) время, т.е. экспоненциальное время.

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

Еще одна такая неразрешимая проблема - это «проблема выполнимости». который спрашивает, есть ли присвоение истинностных значений переменные в логическом выражении, которое делает выражение ИСТИННЫМ.Нет известного алгоритма решения этой проблемы, более того эффективнее, чем перебор всех возможных комбинаций присвоения истинности для переменных.

Выражений - CodeQL

Выражение оценивается как набор значений и имеет тип.

Например, выражение 1 + 2 оценивается как целое число 3 , а выражение «QL» оценивается как строка «QL» . 1 + 2 имеет тип int и "QL" имеет тип string .

В следующих разделах описаны выражения, доступные в QL.

Ссылки на переменные

Ссылка на переменную - это имя объявленной переменной. Этот вид выражение имеет тот же тип, что и переменная, к которой оно относится.

Например, если вы объявили переменные int i и LocalScopeVariable lsv , тогда выражения i и lsv имеют типы int и LocalScopeVariable соответственно.

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

Литералы

Вы можете выражать определенные значения непосредственно в QL, например числа, логические значения и строки.

• Логические литералы: это значения true и false .

• Целочисленные литералы: это последовательности десятичных цифр (от 0 до 9 ), возможно, начиная со знака минус ( - ).Например:

• Литералы с плавающей запятой: это последовательности десятичных цифр, разделенных точкой. (. ), возможно, начиная со знака минус ( - ). Например:

• Строковые литералы: это конечные строки из 16-битных символов. Вы можете определить строковый литерал, заключив символы в кавычки ( "..." ). Самый персонажи представляют себя, но есть несколько символов, от которых нужно «убежать» с обратной косой чертой.Ниже приведены примеры строковых литералов:

   "привет"
  «Они сказали: \" Избегайте кавычек! \ "»
   

  См. Строковые литералы в спецификации языка QL для более подробной информации.

  Примечание: в QL нет «литерала даты». Вместо этого, чтобы указать дату, вы должны преобразовать строку в дату, которую она представляет, используя предикат toDate () . Например, «2016-04-03» .toDate () - это дата 3 апреля 2016 г., а - «2000-01-01 00:00:01» .toDate () - это дата момент времени через одну секунду после Нового 2000 года.

  В качестве дат распознаются следующие строковые форматы:

  • Даты ISO , например "2016-04-03 17:00:24" . Часть секунд не является обязательной (предполагается, что быть "00" , если он отсутствует), а также может отсутствовать вся временная часть (в которой случае предполагается, что это "00:00:00" ).
  • Краткие даты ISO , например "20160403" .
  • Финики в британском стиле , например, "03.04.2016" .
  • Подробные даты , например «03 апреля 2016» .

Выражения в скобках

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

Диапазоны

Выражение диапазона обозначает диапазон значений, упорядоченных между двумя выражениями.Это состоит из два выражения, разделенные .. и заключенные в квадратные скобки ( [ и ] ). Например, [3 .. 7] - допустимое выражение диапазона. Его значения - любые целые числа от 3 и 7 (включая сами 3 и 7 ).

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

Установить литеральные выражения

Литеральное выражение набора позволяет явный список выбора между несколькими значениями. Он состоит из набора выражений, разделенных запятыми, заключенных в квадратные скобки ( [ и ] ). Например, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] - допустимое буквальное выражение набора. Его значения - первые десять простых чисел.

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

поддерживаются начиная с версии 2.1.0 интерфейса командной строки CodeQL и версии 1.24 LGTM Enterprise.

Супервыражения

Супервыражения в QL похожи на супервыражения в других языках программирования, например как Java. Вы можете использовать их в вызовах предикатов, если хотите использовать определение предиката. от супертипа.На практике это полезно, когда предикат наследует два определения от его супертипы. В этом случае предикат должен переопределить эти определения, чтобы избежать двусмысленности. Однако, если вы хотите использовать определение из определенного супертипа вместо написания новое определение, вы можете использовать супервыражение.

В следующем примере класс C наследует два определения предиката getANumber () - один из A и один из B .Вместо переопределения обоих определений используется определение из B .

 class A extends int {
  A () {это = 1}
  int getANumber () {результат = 2}
}

class B extends int {
  B () {это = 1}
  int getANumber () {результат = 3}
}

class C расширяет A, B {
  // Необходимо определить `int getANumber ()`; иначе было бы двусмысленно
  int getANumber () {
    результат = B.super.getANumber ()
  }
}

из C c
выберите c, c.getANumber ()
 

Результат этого запроса: 1, 3 .

Вызов предикатов (с результатом)

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

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

Например, a.getAChild () - это вызов предиката getAChild () для переменной a .Этот вызов оценивает набор дочерних элементов от до .

Агрегаты

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

Общий синтаксис:

 <агрегат> (<объявления переменных> | <формула> | <выражение>)
 

Переменные, объявленные в <объявления переменных> , вызываются агрегационные переменные .

Упорядоченные агрегаты (а именно: min , max , rank , concat и strictconcat ): по умолчанию упорядочены по их значениям <выражение> .Порядок может быть числовым (для целые числа и числа с плавающей запятой) или лексикографический (для строк). Лексикографический порядок на основе значения Unicode каждого персонажа.

Чтобы указать другой порядок, после <выражение> введите ключевые слова в порядке , затем выражение, определяющее порядок, и, необязательно, ключевое слово asc или desc (чтобы определить, следует ли упорядочить выражение в порядке возрастания или убывания). Если вы этого не сделаете укажите порядок, по умолчанию это asc .

В QL доступны следующие агрегаты:

• count : Этот агрегат определяет количество различных значений для каждое возможное присвоение переменных агрегации.

  Например, следующая агрегация возвращает количество файлов, содержащих более 500 линий:

   счетчик (Файл f | f.getTotalNumberOfLines ()> 500 | f)
   

  Если нет возможных присвоений переменным агрегации, удовлетворяющих формуле, как в count (int i | i = 1 and i = 2 | i) , затем count по умолчанию равняется значению 0 .

• мин. и макс. : эти агрегаты определяют наименьшее ( мин. ) или наибольшее ( макс. ) значение <выражение> среди возможных присвоений агрегационным переменным. В этом случае <выражение> должно иметь числовой тип или тип строка .

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

   max (Файл f | f.getExtension () = "js" | Порядок f.getBaseName () по f.getTotalNumberOfLines ())
   

  Следующая агрегация возвращает минимальную строку s из трех упомянутых строк ниже, то есть строка, которая идет первой в лексикографическом порядке всех возможных значения с . (В этом случае возвращается «Де Морган» .)

   мин. (Строка s | s = "Tarski" или s = "Dedekind" или s = "De Morgan" | s)
   

• avg : этот агрегат определяет среднее значение для всех возможных присвоения переменных агрегации.Тип <выражение> должен быть числовым. Если нет возможных назначений для переменных агрегации, удовлетворяющих формуле, агрегация завершается ошибкой и не возвращает значений. Другими словами, он оценивается как пустой набор.

  Например, следующая агрегация возвращает среднее значение целых чисел 0 , 1 , 2 и 3 :

   в среднем (int i | i = [0 .. 3] | i)
   

• сумма : Этот агрегат определяет сумму значений <выражение> по всем возможным присвоения переменных агрегации.Тип <выражение> должен быть числовым. Если нет возможных назначений для переменных агрегации, удовлетворяющих формуле, тогда сумма составляет 0 .

  Например, следующая агрегация возвращает сумму i * j для всех возможных значений. из i и j :

   сумма (int i, int j | i = [0 .. 2] и j = [3 .. 5] | i * j)
   

• concat : Этот агрегат объединяет значения по всем возможным присвоения переменных агрегации.Обратите внимание, что <выражение> должно быть типа строка . Если нет возможных назначений для переменных агрегации, удовлетворяющих формула, то concat по умолчанию пустая строка.

  Например, следующая агрегация возвращает строку "3210" , то есть объединение строк "0" , "1" , "2" и "3" в порядке убывания:

   concat (int i | i = [0.. 3] | Порядок i.toString () по i desc)
   

  Агрегат concat также может принимать второе выражение, отделенное от первого выражением запятая. Это второе выражение вставляется как разделитель между каждым сцепленным значением.

  Например, следующая агрегация возвращает "0 | 1 | 2 | 3" :

   concat (int i | i = [0 .. 3] | i.toString (), "|")
   

• rank : этот агрегат принимает возможные значения <выражение> и ранжирует их.В этом случае <выражение> должно иметь числовой тип или тип строка . Агрегация возвращает значение, ранжированное в позицию, указанную выражением ранга . Вы должны включить это выражение ранга в скобки после ключевого слова rank .

  Например, следующая агрегация возвращает значение, занимающее 4-е место среди всех возможные значения. В данном случае 8 является четвертым целым числом в диапазоне от 5 до 15 :

   ранг [4] (int i | i = [5.. 15] | я)
   

  Примечание

  • Индексы ранга начинаются с 1 , поэтому rank [0] (...) не имеет результата.
  • ранг [1] (...) совпадает с мин. (...) .

• strictconcat , strictcount и strictsum : эти агрегаты работают как concat , - это , а - соответственно, за исключением того, что это строгий .То есть, если нет возможные присвоения переменных агрегации, которые удовлетворяют формуле, тогда вся агрегация завершится неудачно и оценивается как пустой набор (вместо значения по умолчанию 0 или пустой строки). Это полезно, если вас интересуют только результаты, в которых тело агрегирования нетривиально.

• unique : Этот агрегат зависит от значений по всем возможным присвоениям переменные агрегирования.Если есть уникальное значение <выражение> для переменных агрегации, затем агрегат оценивает это значение. В противном случае агрегат не имеет значения.

  Например, следующий запрос возвращает положительные целые числа 1 , 2 , 3 , 4 , 5 . Для отрицательных целых чисел x выражения x и x.abs () имеют разные значения, поэтому значение для y в агрегированном выражении не определяется однозначно.

   из int x
  где x in [-5 .. 5] и x! = 0
  выберите уникальный (int y | y = x или y = x.abs () | y)
   

  Уникальный агрегат поддерживается начиная с версии 2.1.0 интерфейса командной строки CodeQL и версии 1.24 LGTM Enterprise.

Оценка агрегатов

Как правило, совокупная оценка включает следующие шаги:

1. Определите входные переменные: это переменные агрегирования, объявленные в <объявления переменных> и также переменные, объявленные вне агрегата, которые используются в каком-либо компоненте агрегата.
2. Сгенерировать все возможные отдельные кортежи (комбинации) значений входных переменных так, чтобы <формула> верна. Обратите внимание, что одно и то же значение агрегированной переменной может отображаться в несколько отдельных кортежей. Все такие вхождения одного и того же значения рассматриваются как разные вхождения. при обработке кортежей.
3. Примените <выражение> к каждому кортежу и соберите сгенерированные (отдельные) значения. Приложение of в кортеже может привести к созданию более одного значения.
4. Примените функцию агрегирования к значениям, сгенерированным на шаге 3, чтобы вычислить окончательный результат.

Давайте применим эти шаги к сумме агрегата в следующем запросе:

 выберите сумму (int i, int j |
    существует (строка s | s = "hello" .charAt (i)) и существует (строка s | s = "world!". charAt (j)) | я)
 

1. Входные переменные: i , j .

2. Все возможные кортежи (<значение i>, <значение j>) , удовлетворяющие заданному условию: (0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1),..., (4, 5) .

   На этом шаге генерируется 30 кортежей.

3. Примените <выражение> i ко всем кортежам. Это означает выбор всех значений i из все кортежи: 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4.

4. Примените функцию агрегирования sum к вышеуказанным значениям, чтобы получить окончательный результат 60 .

Если мы изменим <выражение> на i + j в приведенном выше запросе, результат запроса будет 135 , поскольку применение i + j ко всем кортежам приводит к следующим значениям: 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 8, 4 , 5, 6, 7, 8, 9 .

Затем рассмотрим следующий запрос:

 выберите количество (строка s | s = "hello" | s.charAt (_))
 

1. s - входная переменная агрегата.
2. На этом шаге генерируется одиночный кортеж "hello" .
3. К этому кортежу применяется <выражение> charAt (_) . Подчеркивание _ в диаграмме (_) выражение безразличия, которое представляет любое значение. s.charAt (_) генерирует четыре различных значения h, e, l, o .
4. Наконец, к этим значениям применяется счетчик , и запрос возвращает 4 .

Пропуск части агрегации

Три части агрегации не всегда требуются, поэтому часто можно написать агрегирование в более простой форме:

1. Если вы хотите написать агрегацию в форме ( v | = v | v) , тогда вы можете опустить части <объявления переменных> и <формула> и записать их следующим образом:

    <агрегат> (<выражение>)
    

   Например, следующие агрегаты определяют, сколько раз буква l встречается в строка "привет" .Эти формы эквивалентны:

    count (int i | i = "hello" .indexOf ("l") | i)
   count ("привет" .indexOf ("l"))
    

2. Если есть только одна агрегационная переменная, вы можете опустить вместо нее часть <выражение> . В этом случае выражение считается самой переменной агрегирования. Например, следующие агрегации эквивалентны:

    в среднем (int i | i = [0 .. 3] | i)
   avg (int i | i = [0 .. 3])
    

3. В качестве особого случая вы можете опустить часть <выражение> из count , даже если их больше чем одна агрегационная переменная.В таком случае он подсчитывает количество различных кортежей агрегационные переменные, удовлетворяющие формуле. Другими словами, часть выражения считается константой 1 . Например, следующие агрегации эквивалентны:

    count (int i, int j | i в [1 .. 3] и j в [1 .. 3] | 1)
   count (int i, int j | i в [1 .. 3] и j в [1 .. 3])
    

4. Вы можете опустить часть <формула> , но в этом случае вы должны включить две вертикальные полосы:

    <агрегат> (<объявления переменных> | | <выражение>)
    

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

    макс. (Файл f | | f.getTotalNumberOfLines ())
    

5. Наконец, вы также можете опустить части <формула> и <выражение> . Например, следующие агрегаты являются эквивалентными способами подсчета количества файлов в базе данных:

    счетчик (Файл f | любой () | 1)
   count (Файл f | | 1)
   count (файл f)
    

Монотонные агрегаты

Помимо стандартных агрегатов, QL также поддерживает монотонные агрегаты.Монотонные агрегаты отличаются от стандартных агрегатов тем, как они справляются с значения, генерируемые частью формулы <выражение> :

• Стандартные агрегаты принимают значения <выражение> для каждого значения <формула> и сведите их в список. Ко всем значениям применяется одна функция агрегирования.
• Монотонные агрегаты принимают <выражение> для каждого значения, заданного <формулой> , и создайте комбинации всех возможных значений.Агрегация функция применяется к каждой из результирующих комбинаций.

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

• Если отсутствуют <выражение> значений (то есть нет <выражение> значение для значения, сгенерированного с помощью <формула> ), монотонные агрегаты не будет вычислять результат, так как вы не можете создавать комбинации значений включая ровно одно значение <выражение> для каждого значения, сгенерированного <формула> .
• Если на результат <формула> приходится более одного <выражение> , вы можете создать несколько комбинации значений, включая ровно одно значение <выражение> для каждого значение, сгенерированное функцией <формула> . Здесь функция агрегирования применяется к каждому из результирующие комбинации.

Пример монотонных агрегатов

Рассмотрим этот запрос:

 строка getPerson () {result = "Alice" или
                     result = "Боб" или
                     result = "Charles" или
                     результат = "Диана"
                   }
строка getFruit (строка p) {p = "Алиса" и результат = "Апельсин" или
                            p = "Алиса" и результат = "Apple" или
                            p = "Боб" и результат = "Apple" или
                            p = "Charles" и result = "Apple" или
                            p = "Чарльз" и результат = "Банан"
                          }
int getPrice (string f) {f = "Apple" и результат = 100 или
                         f = "Апельсин" и результат = 100 или
                         f = "Апельсин" и результат = 1
                       }

предикат nonmono (строка p, int стоимость) {
  p = getPerson () и cost = sum (строка f | f = getFruit (p) | getPrice (f))
}

язык [monotonicAggregates]
предикат моно (строка p, int стоимость) {
  p = getPerson () и cost = sum (строка f | f = getFruit (p) | getPrice (f))
}

из строкового варианта, строковое лицо, int стоимость
где вариант = "по умолчанию" и немоно (человек, стоимость) или
      вариант = "монотонный" и моно (человек, стоимость)
выберите вариант, человека, стоимость
заказать по варианту, человек
 

Запрос дает следующие результаты:

Два варианта совокупной семантики отличаются тем, что происходит когда getPrice (f) имеет несколько результатов или нет результатов для данного f .

В этом запросе апельсины доступны по двум разным ценам, а по умолчанию сумма Агрегат возвращает единственную строку, в которой Алиса покупает апельсин по цене 100, еще один апельсин по цене 1 и яблоко по цене 100, итого 201. С другой стороны, в монотонная семантика на сумму , Алиса всегда покупает один апельсин и одно яблоко, и на каждые способов, она может заполните ее список покупок.

Если бы на яблоки были две разные цены, монотонная Сумма произвела бы четыре строки вывода для Алисы.

Чарльз хочет купить банан, который совсем не продается. в в случае по умолчанию сумма, произведенная для Чарльза, включает стоимость яблоко он может купить , но в мононтонном , сумма , потому что не может быть для Чарльза, чтобы купить одно яблоко плюс один банан.

(Дайана вообще не покупает фруктов, и в обоих вариантах ее общая стоимость равно 0. Совокупность strictsum исключила бы ее из результаты в обоих случаях).

В реальной практике QL довольно редко используются монотонные агрегаты. с целью иметь несколько выходных строк, как в «Алисе» случай этого примера. Более значимым моментом является «Чарльз». Случай: Пока на бананы нет цены, продукция не производится. для него. Это означает, что если мы позже узнаем о цене на бананы, мы не нужно удалять уже созданный выходной кортеж. В Важность этого заключается в том, что монотонное агрегатное поведение хорошо работает с семантикой на основе фиксированных точек для рекурсии, поэтому это будет значимым чтобы позволить предикату getPrice быть взаимно рекурсивным с подсчетом агрегировать себя.(С другой стороны, getFruit все еще не может быть разрешено быть рекурсивным, потому что добавление еще одного фрукта к чьему-то список покупок сделает недействительными общие затраты, которые мы уже знали их).

Эта возможность использовать рекурсию является основной практической причиной запрос монотонной семантики агрегатов.

Рекурсивные монотонные агрегаты

Монотонные агрегаты могут использоваться рекурсивно, но рекурсивный вызов может появляться только в выражение, а не в диапазоне.Рекурсивная семантика для агрегатов такая же, как у рекурсивная семантика для остальной части QL. Например, мы могли бы определить предикат для вычисления расстояние узла в графе от листьев следующее:

 int depth (Node n) {
  если не существует (n.getAChild ())
  тогда результат = 0
  иначе результат = 1 + max (дочерний узел | дочерний элемент = n.getAChild () | глубина (дочерний элемент))
}
 

Здесь рекурсивный вызов находится в выражении, что является допустимым. Рекурсивная семантика для агрегатов такие же, как рекурсивная семантика для остальной части QL.Если вы понимаете, как агрегаты работают в в нерекурсивном случае вам не составит труда использовать их рекурсивно. Однако это стоит посмотреть, как происходит оценка рекурсивной агрегации.

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

Затем оценка предиката depth выполняется следующим образом:

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

Любая

Общий синтаксис выражения any аналогичен синтаксису выражения агрегация, а именно:

 любой (<объявления переменных> | <формула> | <выражение>)
 

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

любое выражение обозначает любые значения, которые имеют определенную форму и удовлетворяют особое состояние. Точнее, любое выражение :

1. Добавляет временные переменные.
2. Ограничивает их значения теми, которые удовлетворяют части <формула> (если она присутствует).
3. Возвращает <выражение> для каждой из этих переменных. Если нет части <выражение> , затем он возвращает сами переменные.

В следующей таблице перечислены некоторые примеры различных форм любых выражений:

Унарные операции

Унарная операция - это знак минус ( - ) или знак плюс ( + ), за которым следует выражение типа int или float .Например:

 -6,28
+ (10-4)
+ avg (с плавающей запятой f | f = 3,4 или f = -9,8)
-сумма (int i | i in [0 .. 9] | i * i)
 

Знак плюс оставляет значения выражения неизменными, а знак минус принимает арифметические отрицания значений.

Бинарные операции

Бинарная операция состоит из выражения, за которым следует бинарный оператор, за которым следует другое выражение. Например:

 5% 2
(9 + 1) / (-2)
«Q» + «L»
2 * мин (с плавающей запятой f | f в [-3 .. 3])
 

В QL можно использовать следующие бинарные операторы:

Если оба выражения являются числами, эти операторы действуют как стандартные арифметические операторы.Для Например, 10,6 - 3,2 имеет значение 7,4 , 123,456 * 0 имеет значение 0 и 9% 4 имеет значение 1 (остаток после деления 9 на 4 ). Если оба операнда являются целыми числами, результатом будет целое число. В противном случае результат будет число с плавающей запятой.

Вы также можете использовать + в качестве оператора конкатенации строк. В этом случае хотя бы один из выражения должны быть строкой - другое выражение неявно преобразуется в строку с использованием toString () предикат.Два выражения объединяются, и в результате получается строка. Для Например, выражение 221 + «B» имеет значение «221B» .

Отливки

Приведение позволяет ограничить тип выражения. Это похоже на литье в других языки, например на Java.

Приведение можно написать двумя способами:

• В виде «постфиксного» приведения: точка, за которой следует имя типа в круглых скобках. Например, x. (Foo) ограничивает тип x до Foo .
• Как «префиксное» приведение: тип в круглых скобках, за которым следует другое выражение. Например, (Foo) x также ограничивает тип x до Foo .

Обратите внимание, что преобразование постфикса эквивалентно преобразованию префикса в круглые скобки - x. (Foo) в точности эквивалентен ((Foo) x) .

Приведения полезны, если вы хотите вызвать предикат члена, который определен только для более конкретный тип. Например, следующий запрос выбирает Java классы которые имеют прямой супертип под названием «Список»:

 импорт Java

от типа t
где т.(Класс) .getASupertype (). HasName ("Список")
выберите т
 

Поскольку предикат getASupertype () определен для Class , но не для Type , вы невозможно вызвать t.getASupertype () напрямую. Литой т. (Класс) гарантирует, что т. составляет типа Class , поэтому он имеет доступ к желаемому предикату.

Если вы предпочитаете использовать префиксное преобразование, вы можете переписать , где часть , как:

 где ((Класс) t).getASupertype (). hasName ("Список")
 

Выражения безразличия

Это выражение, записанное как одинарное подчеркивание _ . Он представляет собой любую ценность. (Ты «Неважно», каково значение.)

В отличие от других выражений, выражение безразличия не имеет типа. На практике это означает, что _ не имеет предикатов членов, поэтому вы не можете позвоните _.somePredicate () .

Например, следующий запрос выбирает все символы в строке "hello" :

 из строки s
где s = "привет".charAt (_)
выберите s
 

Предикат charAt (int i) определен для строк и обычно принимает аргумент int . Здесь выражение безразличия _ используется, чтобы указать запросу на выбор символов в всевозможный индекс. Запрос возвращает значения h , e , l и o .

7. Простые операторы - документация Python 3.9.7

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

  simple_stmt  :: =  выражение_stmt 
                 |  assert_stmt 
                 |  assignment_stmt 
                 |  augmented_assignment_stmt 
                 |  annotated_assignment_stmt 
                 |  pass_stmt 
                 |  del_stmt 
                 |  return_stmt 
                 |  yield_stmt 
                 |  raise_stmt 
                 |  break_stmt 
                 |  continue_stmt 
                 |  import_stmt 
                 |  future_stmt 
                 |  global_stmt 
                 |  nonlocal_stmt 
 

7.1. Выражения

Операторы выражений используются (в основном интерактивно) для вычисления и записи значение или (обычно) для вызова процедуры (функции, которая не возвращает значимого результат; в Python процедуры возвращают значение Нет ). Другое использование операторы выражения разрешены и иногда полезны. Синтаксис для выражение:

  выражение_стмт  :: =  звездное_выражение 
 

Оператор выражения оценивает список выражений (который может быть выражение).

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

7.2. Заявления о переуступке

Операторы присваивания используются для (пере) привязки имен к значениям и для изменения атрибуты или элементы изменяемых объектов:

  assignment_stmt  :: = ( target_list  "=") + ( starred_expression  |  yield_expression )
  target_list  :: =  target  (","  target ) * [","]
  цель  :: =  идентификатор 
                     | "(" [ целевой_лист ] ")"
                     | "[" [ target_list ] "]"
                     |  attributeref 
                     |  подписка 
                     |  нарезка 
                     | "*"  цель 
 

(См. Определение синтаксиса для attributeref , подписка и нарезка .)

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

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

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

• Если целевой список представляет собой единственную цель без конечной запятой, необязательно в круглых скобках объект назначается этой цели.

• Иначе: объект должен быть итерируемым с тем же количеством элементы, поскольку в целевом списке есть цели, и элементы назначены, слева направо к соответствующим целям.

  • Если целевой список содержит одну цель со звездочкой, называется «Помеченная» цель: объект должен быть итерируемым, по крайней мере, с таким же количеством элементов. поскольку в целевом списке есть цели, минус один. Первые позиции iterable назначаются слева направо целям перед отмеченными звездочкой цель. Последние элементы итерации назначаются целям после отмеченная звездой цель. Список оставшихся в итерируемом элементе затем назначен цели, отмеченной звездочкой (список может быть пустым).

  • Иначе: объект должен быть итерируемым с тем же количеством элементов, что и в нем. являются целями в целевом списке, и элементы назначаются слева направо право, к соответствующим целям.

Присвоение объекта одной цели рекурсивно определяется следующим образом.

• Если целью является идентификатор (имя):

  • Если имя не встречается в глобальном или нелокальном в текущем блоке кода: имя привязано к объекту в текущее локальное пространство имен.

  • В противном случае: имя привязано к объекту в глобальном пространстве имен или внешнее пространство имен определяется нелокальным соответственно.

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

• Если целью является ссылка на атрибут: основное выражение в ссылка оценивается.В результате должен получиться объект с назначаемыми атрибутами; если это не так, возникает ошибка TypeError . Этот объект тогда попросили присвоить присвоенный объект данному атрибуту; если это не может выполнить задание, возникает исключение (обычно, но не обязательно AttributeError ).

  Примечание. Если объект является экземпляром класса и ссылка на атрибут встречается на обе стороны оператора присваивания, выражение в правой части, a.x может получить доступ либо атрибут экземпляра, либо (если атрибут экземпляра не существует) класс атрибут.Левая цель a.x всегда устанавливается как атрибут экземпляра, создавая его при необходимости. Таким образом, два появления a.x не обязательно относятся к одному и тому же атрибуту: если выражение в правой части относится к class, левая сторона создает новый атрибут экземпляра как цель присвоение:

   класс Cls:
      x = 3 # переменная класса
  inst = Cls ()
  inst.x = inst.x + 1 # записывает inst.x как 4, оставляя Cls.x как 3
   

  Это описание не обязательно применимо к атрибутам дескриптора, таким как свойства, созданные с помощью property () .

• Если целью является подписка: основное выражение в ссылке: оценен. Он должен давать либо изменяемый объект последовательности (например, список) или объект отображения (например, словарь). Затем нижний индекс выражается так: оценен.

  Если первичным является изменяемый объект последовательности (например, список), нижний индекс должен давать целое число. Если он отрицательный, длина последовательности добавляется к Это. Результирующее значение должно быть неотрицательным целым числом меньше, чем длины последовательности, и последовательность просят назначить назначенный объект свой товар с этим индексом.Если индекс вне допустимого диапазона, IndexError поднят (присвоение последовательности с индексами не может добавлять новые элементы в список).

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

  Для пользовательских объектов метод __setitem __ () вызывается с соответствующие аргументы.

• Если целью является срез: основным выражением в ссылке является оценен. Он должен дать изменяемый объект последовательности (например, список). В назначенный объект должен быть объектом последовательности того же типа. Далее нижний и выражения верхней границы оцениваются, если они присутствуют; значения по умолчанию равны нулю, а длина последовательности. Границы должны быть целыми числами.Если какая-либо граница отрицательная, к ней добавляется длина последовательности. В результирующие границы обрезаются, чтобы они находились между нулем и длиной последовательности, включительно. Наконец, объекту последовательности предлагается заменить срез на элементы заданной последовательности. Длина среза может быть разной. от длины назначенной последовательности, тем самым изменяя длину целевая последовательность, если это позволяет целевая последовательность.

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

Хотя определение присвоения подразумевает, что левая и правая части являются «одновременными» (например, a, b = b, a меняет местами две переменные), перекрывает в пределах набора назначенных переменные идут слева направо, что иногда приводит к путанице. Например, следующая программа печатает [0, 2] :

 x = [0, 1]
я = 0
i, x [i] = 1, 2 # i обновляется, затем x [i] обновляется
печать (х)
 

См. Также

PEP 3132 - Extended Iterable Unpacking

Спецификация для функции * target .

7.2.1. Операторы с расширенными присваиваниями

Расширенное присваивание - это комбинация в одном операторе двоичного операция и заявление о присвоении:

  augmented_assignment_stmt  :: =  augtarget   augop  ( список_выражений  |  yield_expression )
  augtarget  :: =  идентификатор  |  attributeref  |  подписка  |  нарезка 
  augop  :: = "+ =" | "- =" | "* =" | "@ =" | "/ =" | "// =" | "% =" | знак равно
                               | ">> =" | "<< =" | "& =" | "^ =" | "| ="
 

(См. Раздел "Основные" для определения синтаксиса последних трех символы.)

Расширенное задание оценивает цель (которая, в отличие от обычного операторов, не может быть распаковкой) и список выражений, выполняет двоичный операция, специфичная для типа присваивания двух операндов, и присваивает результат к исходной цели. Цель оценивается только один раз.

Расширенное выражение присваивания, такое как x + = 1 , можно переписать как x = x + 1 для достижения аналогичного, но не совсем равного эффекта. В расширенном версия, x оценивается только один раз.Также, по возможности, фактическая операция выполняется на месте , что означает, что вместо создания нового объекта и присваивая это цели, вместо этого модифицируется старый объект.

В отличие от обычных заданий, расширенные задания оценивают левую часть до , оценивая правую часть. Например, сначала a [i] + = f (x) ищет a [i] , затем вычисляет f (x) и выполняет сложение, и наконец, он записывает результат обратно в a [i] .

За исключением назначения кортежам и нескольким целевым объектам в одном оператор, присваивание, выполняемое операторами расширенного присваивания, обрабатывается так же, как и обычные задания. Аналогично, за исключением возможных на месте , двоичная операция, выполняемая с помощью расширенного присваивания, то же, что и обычные бинарные операции.

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

7.2.2. Аннотированные отчеты о присвоении

Назначение аннотации - это комбинация в одном оператор, аннотации переменной или атрибута и необязательный оператор присваивания:

  annotated_assignment_stmt  :: =  augtarget  ":"  выражение 
                               ["=" ( звездное_выражение  |  yield_expression )]
 

Отличие от обычных операторов присваивания в том, что разрешена только одна цель.

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

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

Если имя аннотировано в области действия функции, то это имя является локальным для этот объем. Аннотации никогда не оцениваются и не сохраняются в областях видимости функций.

Если правая сторона присутствует, аннотированный присваивание выполняет фактическое присваивание перед оценкой аннотаций (где применимо). Если правая часть отсутствует в выражении target, то интерпретатор оценивает цель, кроме последнего __setitem __ () или __setattr __ () вызов .

См. Также

PEP 526 - Синтаксис для аннотаций переменных

Предложение, добавляющее синтаксис для аннотирования типов переменных (включая переменные класса и переменные экземпляра) вместо выражения их через комментарии.

PEP 484 - Подсказки по типу

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

Изменено в версии 3.8: Теперь аннотированные присваивания позволяют использовать те же выражения в правой части, что и регулярные задания. Ранее некоторые выражения (например, без скобок выражения кортежа) вызвали синтаксическую ошибку.

7.3.

Assert - удобный способ вставки утверждений отладки в программа:

  assert_stmt  :: = "assert"  выражение  [","  выражение ]
 

Простая форма, , выражение утверждения , эквивалентно

, если __debug__:
    если не выражение: поднять AssertionError
 

Расширенная форма, assert выражение1, выражение2 , эквивалентно

, если __debug__:
    если не выражение1: поднять ошибку AssertionError (выражение2)
 

Эти эквиваленты предполагают, что __debug__ и AssertionError относятся к встроенные переменные с этими именами.В текущей реализации встроенная переменная __debug__ is True при нормальных обстоятельствах, Ложь при запросе оптимизации (параметр командной строки -O ). Электрический ток генератор кода не генерирует код для утверждения утверждения, когда оптимизация запрашивается во время компиляции. Обратите внимание, что указывать источник необязательно. код для выражения, которое не удалось в сообщении об ошибке; это будет отображаться как часть трассировки стека.

Назначение __debug__ незаконно.Значение встроенной переменной определяется при запуске интерпретатора.

7.4. Пропуск

  pass_stmt  :: = "пройти"
 

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

 def f (arg): передать # функцию, которая (пока) ничего не делает

class C: передать # класс без методов (пока)
 

7.5. Заявление

  del_stmt  :: = "del"  target_list 
 

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

При удалении целевого списка рекурсивно удаляются все целевые объекты слева направо.

Удаление имени удаляет привязку этого имени к локальному или глобальному пространство имен, в зависимости от того, встречается ли имя в глобальном операторе в том же блоке кода.Если имя не привязано, возникает исключение NameError будет поднят.

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

Изменено в версии 3.2: Ранее было запрещено удалять имя из локального пространства имен, если оно встречается как свободная переменная во вложенном блоке.

7.6.

  return_stmt  :: = "return" [ список_выражений ]
 

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

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

return оставляет текущий вызов функции со списком выражений (или Нет ) в качестве возвращаемого значения.

При возврате передает управление из инструкции try с , наконец, предложение , что предложение , наконец, выполняется до действительно оставив функцию.

В функции генератора оператор return указывает, что генератор готов и вызовет подъем StopIteration . Вернувшийся значение (если есть) используется в качестве аргумента для построения StopIteration и становится StopIteration.значение атрибута .

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

7.7.

  yield_stmt  :: =  yield_expression 
 

Оператор yield семантически эквивалентен yield выражение.В операторе yield можно опустить круглые скобки. что в противном случае потребовалось бы в эквивалентном выражении yield утверждение. Например, операторы доходности

 yield 
доход от 
 

эквивалентны операторам выражения yield

 (yield )
(доход от )
 

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

Для получения полной информации о семантике выхода yield см. Раздел выражений доходности.

7,8. Оператор подъема

  raise_stmt  :: = "raise" [ выражение  ["from"  выражение ]]
 

Если никаких выражений нет, вызывает повторно вызывает последнее исключение который был активен в текущей области.Если в текущем области, возникает исключение RuntimeError , указывающее, что это ошибка.

В противном случае, raise оценивает первое выражение как исключение. объект. Это должен быть подкласс или экземпляр BaseException . Если это класс, экземпляр исключения будет получен при необходимости создание экземпляра класса без аргументов.

Тип исключения - это класс экземпляра исключения, значение - это сам экземпляр.

Объект трассировки обычно создается автоматически при возникновении исключения. и прикреплен к нему как атрибут __traceback__ , который доступен для записи. Вы можете создать исключение и установить собственную трассировку за один шаг, используя with_traceback () метод исключения (который возвращает то же исключение экземпляр, с его трассировкой, установленной для его аргумента), например:

 возбудить исключение ("произошло foo"). With_traceback (tracebackobj)
 

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

 >>> попробуйте:
... печать (1/0)
... кроме Exception as exc:
... поднять RuntimeError ("Произошло что-то плохое") из exc
...
Отслеживание (последний вызов последний):
  Файл "", строка 2, в 
ZeroDivisionError: деление на ноль

Вышеупомянутое исключение явилось прямой причиной следующего исключения:

Отслеживание (последний вызов последний):
  Файл "", строка 4, в 
RuntimeError: Произошло что-то плохое
 

Аналогичный механизм работает неявно, если исключение возникает внутри обработчик исключений или предложение finally : предыдущее исключение прикреплен как атрибут __context__ нового исключения:

 >>> попробуйте:
... печать (1/0)
... Кроме:
... поднять RuntimeError ("Произошло что-то плохое")
...
Отслеживание (последний вызов последний):
  Файл "", строка 2, в 
ZeroDivisionError: деление на ноль

Во время обработки вышеуказанного исключения произошло другое исключение:

Отслеживание (последний вызов последний):
  Файл "", строка 4, в 
RuntimeError: Произошло что-то плохое
 

Цепочку исключений можно явно подавить, указав None в из статьи :

 >>> попробуйте:
... печать (1/0)
... Кроме:
... поднять RuntimeError ("Что-то плохое случилось") из None
...
Отслеживание (последний вызов последний):
  Файл "", строка 4, в 
RuntimeError: Произошло что-то плохое
 

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

Изменено в версии 3.3: Нет. теперь разрешен, так как Y в поднять X с Y .

Новое в версии 3.3: Атрибут __suppress_context__ для подавления автоматического отображения контекст исключения.

7.9. Разрыв

  break_stmt  :: = "перерыв"
 

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

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

Если цикл для завершается разрывом , управление циклом target сохраняет свое текущее значение.

Когда break передает управление из оператора try с , наконец, предложение , что предложение , наконец, выполняется до действительно выходит из петли.

7.10.

  continue_stmt  :: = "продолжить"
 

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

Когда continue передает управление из оператора try с , наконец, предложение , что предложение , наконец, выполняется до действительно начало следующего цикла цикла.

7.11.

  import_stmt  :: = "import"  module  ["as"  идентификатор ] (","  module  ["as"  идентификатор ]) *
                     | "from"  relative_module  "import"  идентификатор  ["as"  идентификатор ]
                     ("," Идентификатор   ["как" идентификатор  ]) *
                     | "from"  relative_module  "import" "("  идентификатор  ["как"  идентификатор ]
                     ("," Идентификатор   ["как" идентификатор  ]) * [","] ")"
                     | "from"  relative_module  "import" "*"
  модуль  :: = ( идентификатор  ".") *  идентификатор 
  relative_module  :: = "." *  module  | "." +
 

Основной оператор импорта (№ из пункта ) выполняется в двух шаги:

1. найти модуль, при необходимости загрузить и инициализировать

2. определяет имя или имена в локальном пространстве имен для области, в которой появляется оператор import .

Если оператор содержит несколько предложений (разделенных запятые) два шага выполняются отдельно для каждого предложения, просто как если бы статьи были разделены на отдельные статьи заявления.

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

Если запрошенный модуль получен успешно, он будет выполнен доступен в локальном пространстве имен одним из трех способов:

• Если после имени модуля идет как , то имя следующий за , поскольку привязан непосредственно к импортированному модулю.

• Если другое имя не указано, а импортируемый модуль является верхним уровня модуля, имя модуля связано в локальном пространстве имен как ссылка на импортный модуль

• Если импортируемый модуль , а не модуль верхнего уровня, то имя пакета верхнего уровня, содержащего модуль, привязан к локальному пространство имен как ссылка на пакет верхнего уровня.Импортированный модуль доступ должен осуществляться с использованием его полного квалифицированного имени, а не напрямую

Форма из использует немного более сложный процесс:

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

2. для каждого из идентификаторов, указанных в пунктах import :

   1. проверьте, есть ли у импортированного модуля атрибут с таким именем

   2. если нет, попробуйте импортировать подмодуль с этим именем, а затем еще раз проверьте импортированный модуль на наличие этого атрибута

   3. , если атрибут не найден, возникает ошибка ImportError .

   4. в противном случае ссылка на это значение сохраняется в локальном пространстве имен, используя имя в как предложение , если оно присутствует, в противном случае используется имя атрибута

Примеры:

 import foo # foo импортировано и привязано локально
import foo.bar.baz # foo.bar.baz импортировано, foo привязано локально
импортировать foo.bar.baz как fbb # foo.bar.baz импортировать и привязать как fbb
from foo.bar import baz # foo.bar.baz импортирован и привязан как baz
from foo import attr # foo import и foo.attr привязан как attr
 

Если список идентификаторов заменить звездочкой ( '*' ), все общедоступные имена, определенные в модуле, привязаны к локальному пространству имен для области где встречается оператор import .

общедоступных имен , определенных модулем, определяются путем проверки пространство имен для переменной с именем __all__ ; если определено, это должна быть последовательность строк, которые являются именами, определенными или импортированными этим модулем. Имена данные в __all__ считаются общедоступными и обязаны существовать.Если __all__ не определено, набор публичных имен включает все найденные имена в пространстве имен модуля, которые не начинаются с символа подчеркивания ( '_' ). __all__ должен содержать весь общедоступный API. Это предназначено чтобы избежать случайного экспорта элементов, не являющихся частью API (например, модули библиотеки, которые были импортированы и использовались в модуле).

Форма импорта с подстановочными знаками - из импорта модуля * - разрешена только в уровень модуля.Попытка использовать его в определениях классов или функций приведет к вызвать SyntaxError .

При указании импортируемого модуля необязательно указывать абсолютный имя модуля. Когда модуль или пакет содержится в другом package можно сделать относительный импорт в том же самом верхнем пакете без упоминания имени пакета. Используя ведущие точки в указанный модуль или пакет после из вы можете указать, как высоко пройти вверх по текущей иерархии пакетов без указания точных имен.Один ведущая точка означает текущий пакет, в котором модуль, выполняющий импорт существуют. Две точки означают повышение на один уровень пакета. Три точки - это два уровня вверх и т. Д. Итак, если вы запустите из. импортировать мод из модуля в пакете pkg тогда вы в конечном итоге импортируете pkg.mod . Если вы запустите из ..subpkg2 import mod из pkg.subpkg1 вы импортируете pkg.subpkg2.mod . Спецификация относительного импорта содержится в раздел «Относительный импорт пакетов».

importlib.import_module () предоставляется для поддержки приложений, которые динамически определять загружаемые модули.

Вызывает событие аудита import с аргументами module , filename , sys.path , sys.meta_path , sys.path_hooks .

7.11.1. Отчетность о будущем

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

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

  future_stmt  :: = "from" "__future__" "import"  feature  ["as"  идентификатор ]
                 ("," Функция   ["как" идентификатор  ]) *
                 | "from" "__future__" "import" "(" функция   ["как" идентификатор  ]
                 ("," Функция   ["как" идентификатор  ]) * [","] ")"
  признак  :: =  идентификатор 
 

Заявление о будущем должно появиться в верхней части модуля.Единственные строки, которые могут появиться перед будущим выпиской:

Единственная функция, которая требует использования оператора future, - это аннотаций (см. PEP 563 ).

Все исторические особенности, включенные в будущий отчет, по-прежнему распознаются на Python 3. Список включает absolute_import , деление , генераторы , generator_stop , unicode_literals , print_function , nested_scopes и with_statement .Они есть все избыточны, потому что они всегда включены и сохраняются только в обратная совместимость.

Отчет о будущем распознается и обрабатывается специально во время компиляции: Изменения к семантике основных конструкций часто реализуются путем генерации другой код. Может даже случиться так, что новая функция вводит новые несовместимый синтаксис (например, новое зарезервированное слово), и в этом случае компилятор может потребоваться разобрать модуль по-другому. Такие решения нельзя оттолкнуть до времени выполнения.

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

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

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

Обратите внимание, что в выписке нет ничего особенного:

 импорт __future__ [как имя]
 

Это не заявление о будущем; это обычный оператор импорта без особая семантика или синтаксические ограничения.

Код, скомпилированный вызовами встроенных функций exec () и compile () которые происходят в модуле M , содержащем оператор future, по умолчанию, используйте новый синтаксис или семантику, связанную с оператором future.Это может управляться необязательными аргументами compile () - см. документацию этой функции для получения подробной информации.

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

См. Также

PEP 236 - Назад в __future__

Первоначальное предложение механизма __future__.

7.12. Глобальный отчет

  global_stmt  :: = "global"  идентификатор  (","  идентификатор ) *
 

Заявление global - это декларация, действующая для всего текущий блок кода. Это означает, что перечисленные идентификаторы подлежат интерпретации. как глобальные. Было бы невозможно присвоить глобальную переменную без глобальные , хотя свободные переменные могут ссылаться на глобальные переменные, не будучи объявлен глобальным.

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

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

Детали реализации CPython: Текущая реализация не применяет некоторые из этих ограничений, но программы не должны злоупотреблять этой свободой, поскольку будущие реализации могут потребовать их или молча изменить смысл программы.

Примечание программиста: global - это директива для синтаксического анализатора. Это применяется только к коду, который анализируется одновременно с глобальным оператором . В частности, глобальный оператор , содержащийся в строке или коде объект, передаваемый во встроенную функцию exec () , не влияет на код блок , содержащий вызов функции, а код, содержащийся в такой строке, не зависит от глобальных операторов в коде, содержащем функцию вызов.То же самое относится к функциям eval () и compile () .

7.13. Нелокальный отчет

  nonlocal_stmt  :: = "нелокальный"  идентификатор  (","  идентификатор ) *
 

Нелокальный оператор заставляет перечисленные идентификаторы ссылаться на ранее связанные переменные в ближайшей охватывающей области, за исключением глобальных переменных. Это важно, потому что поведение привязки по умолчанию - поиск сначала локальное пространство имен.Оператор позволяет инкапсулированному коду повторно связывать переменные вне локальной области видимости помимо глобальной (модульной) области.

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

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

См. Также

PEP 3104 - Доступ к именам во внешних областях

Спецификация нелокального оператора .

Двоичный калькулятор

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

Двоичное вычисление - сложение, вычитание, умножение или деление

Преобразовать двоичное значение в десятичное

Преобразовать десятичное значение в двоичное

Двоичная система счисления - это система счисления, которая функционирует практически идентично десятичной системе счисления, с которой люди, вероятно, более знакомы.В то время как в десятичной системе счисления используется число 10 в качестве основы, в двоичной системе используется 2. Кроме того, хотя в десятичной системе используются цифры от 0 до 9, в двоичной системе используются только 0 и 1, и каждая цифра называется битом. . Помимо этих различий, такие операции, как сложение, вычитание, умножение и деление, все вычисляются по тем же правилам, что и десятичная система.

Практически все современные технологии и компьютеры используют двоичную систему из-за простоты ее реализации в цифровых схемах с использованием логических вентилей.Намного проще разработать оборудование, которое должно определять только два состояния: включено и выключено (или истина / ложь, присутствует / отсутствует и т. Д.). Использование десятичной системы требует оборудования, которое может обнаруживать 10 состояний для цифр от 0 до 9, что является более сложным.

Ниже приведены некоторые типичные преобразования между двоичными и десятичными значениями:

Двоичное / десятичное преобразование

Десятичное	Двоичное
0	0
1	1
2	10
	10 4	7	111
8	1000
10	1010
16	10000
может сбивать с толку с первого взгляда понимание того, что каждое двоичное разрядное значение представляет 2 n , так же, как каждое десятичное место представляет 10 n , должно помочь уточнить.Возьмем, к примеру, число 8. В десятичной системе счисления 8 находится в первом десятичном разряде слева от десятичной точки, что означает 10 0 место. По сути это означает: 8 × 10 0 = 8 × 1 = 8 Используя число 18 для сравнения: (1 × 10 1 ) + (8 × 10 0 ) = 10 + 8 = 18 В двоичном формате 8 представлено как 1000. При чтении справа налево первый 0 представляет 2 0 , второй 2 1 , третий 2 2 и четвертый 2 3 ; точно так же, как десятичная система, за исключением того, что основание 2, а не 10.Поскольку 2 3 = 8, в его позиции вводится 1, что дает 1000. Используя 18 или 10010 в качестве примера: 18 = 16 + 2 = 2 4 + 2 1 10010 = (1 × 2 4 ) + (0 × 2 3 ) + (0 × 2 2 ) + (1 × 2 1 ) + (0 × 2 0 ) = 18 Пошаговый процесс преобразования десятичной системы в двоичную: Найдите наибольшую степень двойки, лежащую в пределах данного числа Вычтите это значение из данного числа Найдите наибольшую степень двойки в остатке, найденном на шаге 2 Повторяйте до тех пор, пока не останется остаток Введите 1 для каждого найденного двоичного разряда и 0 для остальных Снова используя целевое значение 18 в качестве примера, ниже представлен другой способ визуализировать это: 0 2 n 2 4 2 3 2 2 2 1 2 0 Инстансы в пределах 18 0 1 0 Цель: 18 18-16 = 2 → 2 - 2 = 0 Преобразование из двоичной в десятичную систему просто .Определите все значения разряда, в которых встречается 1, и найдите сумму значений. Пример: 10111 = (1 × 2 4 ) + (0 × 2 3 ) + (1 × 2 2 ) + (1 × 2 1 ) + (1 × 2 0 ) = 23 Отсюда: 16 + 4 + 2 + 1 = 23. Сложение двоичных файлов Двоичное сложение следует тем же правилам, что и сложение в десятичной системе, за исключением того, что вместо переноса 1, когда добавленные значения равны 10, перенос происходит, когда результат сложения равен 2.Обратитесь к примеру ниже для пояснения. Обратите внимание, что в двоичной системе: 0 + 0 = 0 0 + 1 = 1 1 + 0 = 1 1 + 1 = 0, переносится 1, т. Е. 10 EX: 1 1 0 1 1 1 1 1 0 1 + 1 1 = 1 0 0 1 0 0 Единственная реальная разница между двоичным и десятичным сложением. двоичная система эквивалентна 10 в десятичной системе.Обратите внимание, что единицы с надстрочным индексом представляют собой перенесенные цифры. Распространенная ошибка, на которую следует обратить внимание при выполнении двоичного сложения, - это случай, когда 1 + 1 = 0 также имеет 1, перенесенную из предыдущего столбца вправо. Тогда значение внизу должно быть 1 из перенесенного на 1, а не 0. Это можно увидеть в третьем столбце справа в приведенном выше примере. Двоичное вычитание Подобно двоичному сложению, есть небольшая разница между двоичным и десятичным вычитанием, за исключением тех, которые возникают из-за использования только цифр 0 и 1.Заимствование происходит в любом случае, когда вычитаемое число больше, чем число, из которого оно вычитается. При бинарном вычитании заимствование необходимо только тогда, когда 1 вычитается из 0. Когда это происходит, 0 в столбце заимствования по существу становится «2» (изменение 0-1 на 2-1 = 1), в то время как уменьшение 1 в столбце, из которого заимствуется, на 1. Если следующий столбец также равен 0, заимствование должно происходить из каждого последующего столбца, пока столбец со значением 1 не может быть уменьшен до 0.Обратитесь к примеру ниже для пояснения. Обратите внимание, что в двоичной системе: 0 - 0 = 0 0 - 1 = 1, заимствовать 1, в результате чего -1 переносится на 1 - 0 = 1 1-1 = 0 EX1: -1 1 2 0 1 1 1 - 0 1 1 1 1 = 0 1 0 1 0 EX2: 01 -1 1 2-1 0 0 - 0 1 1 901 0 0 1 Обратите внимание, что отображаемые верхние индексы - это изменения, которые происходят с каждым битом при заимствовании.Столбец заимствования по существу получает 2 от заимствования, а столбец, из которого заимствовано, уменьшается на 1. Двоичное умножение Двоичное умножение, возможно, проще, чем его десятичный аналог. Поскольку используются только значения 0 и 1, результаты, которые необходимо добавить, либо те же, что и для первого члена, либо 0. Обратите внимание, что в каждой последующей строке необходимо добавить заполнитель 0, а значение сдвинуть влево, как в десятичном умножении. Сложность двоичного умножения возникает из-за утомительного двоичного сложения, зависящего от количества битов в каждом члене.Обратитесь к примеру ниже для пояснения. Обратите внимание, что в двоичной системе: 0 × 0 = 0 0 × 1 = 0 1 × 0 = 0 1 × 1 = 1 EX: 1 0 1 1 1 × 1 0 1 1 1 + 1 0 1 1 1 0 9014 905 0 0 0 1 0 1 Как видно из приведенного выше примера, процесс двоичного умножения такой же, как и при десятичном умножении.Обратите внимание, что заполнитель 0 написан во второй строке. Обычно заполнитель 0 визуально не присутствует при десятичном умножении. Хотя то же самое можно сделать и в этом примере (с предполагаемым заполнителем 0, а не явным), он включен в этот пример, потому что 0 актуален для любого двоичного калькулятора сложения / вычитания, подобного тому, который представлен на этой странице. Без отображения 0 можно было бы ошибиться, исключив 0 при добавлении двоичных значений, показанных выше.Еще раз обратите внимание, что в двоичной системе любой 0 справа от 1 имеет значение, а любой 0 слева от последней единицы в значении - нет. EX: 1 0 1 0 1 1 0 0 = 0 0 1 0 1 0 1 1 0 0 ≠ 1 0 1 0 1 1 0 0 0 0 Бинарный отдел Процесс двоичного деления аналогичен длинному делению в десятичной системе счисления. Дивиденд по-прежнему делится на делитель таким же образом, с единственной существенной разницей, заключающейся в использовании двоичного, а не десятичного вычитания.Обратите внимание, что хорошее понимание двоичного вычитания важно для проведения двоичного деления. Обратитесь к примеру ниже, а также к разделу двоичного вычитания для пояснения. 16 в двоичном формате - как преобразовать 16 из десятичного числа в двоичное? 16 в двоичной системе составляет 10000. В отличие от десятичной системы счисления, где мы используем цифры от 0 до 9 для представления числа, в двоичной системе мы используем только 2 цифры, которые являются 0 и 1 (биты). Мы использовали 5 бит для представления 16 в двоичном формате.В этой статье мы покажем, как преобразовать десятичное число 16 в двоичное. 16 в двоичном формате: 16₁₀ = 10000₂ 16 восьмеричных: 16₁₀ = 20₈ 16 в шестнадцатеричной системе: 16₁₀ = 10₁₆ 10000₂ в десятичной системе: 16₁₀ Как преобразовать 16 в двоичное? Шаг 1: Разделите 16 на 2. Используйте целое частное, полученное на этом шаге, как делимое для следующего шага.Повторяйте процесс, пока частное не станет равным 0. Дивиденды остаток 16/2 = 8 0 8/2 = 4 0 4/2 = 2 0 2/2 = 1 0 1/2 = 0 1 Шаг 2: Запишите остаток снизу вверх i.е. в обратном хронологическом порядке. Это даст двоичный эквивалент 16. Следовательно, двоичный эквивалент десятичного числа 16 равен 10000. ☛ Десятичный в двоичный калькулятор Описание проблем: FAQ по 16 в двоичном формате Что такое 16 в двоичном формате? 16 в двоичном формате равно 10000. Чтобы найти десятичный или двоичный эквивалент, разделите 16 последовательно на 2, пока частное не станет равным 0. Двоичный эквивалент можно получить, записав остаток на каждом шаге деления снизу вверх. ☛ Двоичное в десятичное Сколько бит у 16 ​​в двоичном файле? Мы можем подсчитать количество нулей и единиц, чтобы увидеть, сколько битов используется для представления 16 в двоичном формате, т.е. 10000. Поэтому мы использовали 5 битов для представления 16 в двоичном формате. Как преобразовать 16 в двоичный эквивалент? Мы можем разделить 16 на 2 и продолжить деление, пока не получим 0. Запишите остаток на каждом шаге. 16 mod 2 = 0 - младший бит (младший значащий бит) 8 мод 2 = 0 4 мод 2 = 0 2 мод 2 = 0 1 mod 2 = 1 - MSB (старший разряд) Записать остатки от MSB к LSB.Следовательно, десятичное число 16 в двоичном формате может быть представлено как 10000. Найдите значение 6 × 16 в двоичной форме. Мы знаем, что 16 в двоичном формате равно 10000, а 6 равно 110. Используя правила двоичного умножения (0 × 0 = 0; 0 × 1 = 0; 1 × 0 = 0 и 1 × 1 = 1), мы можем умножить 10000 × 110 = 1100000, что равно 96 в десятичной системе счисления. [16 × 6 = 96] Что такое двоичный эквивалент 16 + 41? 16 в двоичной системе счисления равно 10000, а 41 равно 101001. Мы можем сложить двоичный эквивалент 16 и 41, используя правила двоичного сложения [0 + 0 = 0, 0 + 1 = 1, 1 + 1 = 10, обратите внимание, что 1 - это перейти к следующему биту].Следовательно, (10000) ₂ + (101001) ₂ = (111001) ₂, что есть не что иное, как 57. ☛ Двоично-десятичный калькулятор ☛ Также проверьте: . Author: alexxlab Добавить комментарий Отменить ответ Ваш адрес email не будет опубликован. Обязательные поля помечены * Комментарий * Имя * Email * Сайт 2019 © Все права защищены. Карта сайта