format
Ниже приведена отрывок из документации:
Учитывая спецификации
format % values
,%
вformat
заменены на ноль или более элементов изvalues
. Эффект похож на использованиеsprintf()
в языке C.Если для
format
требуется один аргумент, значения могут быть одиночными объектами без кортежей. В противном случае значения должны быть кортежем с точно количеством элементов, заданных строкойformat
, или единственным объектом сопоставления (например, словарем).Ссылки
На
str.format
вместо%
Более новой альтернативой оператору
%
является использованиеstr.format
. Вот выдержка из документации:
str.format(*args, **kwargs)
Выполнить операцию форматирования строк. Строка, на которой вызывается этот метод, может содержать литеральный текст или поля замещения, разделенные фигурными скобками
{}
. Каждое поле замены содержит либо числовой индекс позиционного аргумента, либо имя аргумента ключевого слова. Возвращает копию строки, где каждое замещающее поле заменяется строковым значением соответствующего аргумента.Этот метод является новым стандартом в Python 3.0 и должен быть предпочтительнее форматирования
%
.Ссылки
Примеры
Вот некоторые примеры использования:
>>> '%s for %s' % ("tit", "tat") tit for tat >>> '{} and {}'.format("chicken", "waffles") chicken and waffles >>> '%(last)s, %(first)s %(last)s' % {'first': "James", 'last': "Bond"} Bond, James Bond >>> '{last}, {first} {last}'.format(first="James", last="Bond") Bond, James Bond
См. также
==
и ===
различие между свободно ==
равный оператор и строгое ===
идентичный оператор точно объяснено в руководство :
<час>Операторы сравнения
┌──────────┬───────────┬───────────────────────────────────────────────────────────┐ │ Example │ Name │ Result │ ├──────────┼───────────┼───────────────────────────────────────────────────────────┤ │$a == $b │ Equal │ TRUE if $a is equal to $b after type juggling. │ │$a === $b │ Identical │ TRUE if $a is equal to $b, and they are of the same type. │ └──────────┴───────────┴───────────────────────────────────────────────────────────┘
==
равное сравнение , Если Вы используете ==
оператор или какой-либо другой оператор сравнения, который использует свободно сравнение такой как !=
, <>
или ==
, всегда необходимо смотреть контекст для наблюдения то, что, где и почему что-то преобразовывается для понимания то, что продолжается.
Сравнения типов Как ссылка и пример Вы видите таблицу сравнения в руководство :
Свободные сравнения с [1 112]
┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐ │ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ array() │ "php" │ "" │ ├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤ │ TRUE │ TRUE │ FALSE │ TRUE │ FALSE │ TRUE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ TRUE │ FALSE │ TRUE │ │ 1 │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ 0 │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ TRUE │ TRUE │ │ -1 │ TRUE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "1" │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "0" │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "-1" │ TRUE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ │ NULL │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ TRUE │ FALSE │ TRUE │ │ array() │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ TRUE │ FALSE │ FALSE │ │ "php" │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ │ "" │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘
===
идентичное сравнение , Если Вы используете ===
оператор или какой-либо другой оператор сравнения, который использует строгое сравнение такой в качестве [1 115] или ===
, тогда можно всегда быть уверены, что типы не будут волшебно изменение, потому что не будет никакого продолжения преобразования. Таким образом со строгим сравнением тип и значение должны быть тем же, не только значением.
Сравнения типов Как ссылка и пример Вы видите таблицу сравнения в руководство :
Строгие сравнения с [1 117]
┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐ │ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ array() │ "php" │ "" │ ├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤ │ TRUE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ 1 │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ 0 │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ -1 │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "1" │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "0" │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "-1" │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ │ NULL │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ │ array() │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ │ "php" │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ │ "" │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘
Переменные имеют тип и значение.
при использовании этих переменных (в PHP), иногда у Вас нет хорошего типа. Например, если Вы делаете
if ($var == 1) {... do something ...}
, PHP должны преобразовать ("для кастинга") $var к целому числу. В этом случае, "$var == 1" верен, потому что любая непустая строка является литой к 1.
При использовании ===, Вы проверяете, что значение И ТИП равны, таким образом, "$var === 1" является ложью.
Это полезно, например, когда у Вас есть функция, которая может возвратить false (на ошибке) и 0 (результат):
if(myFunction() == false) { ... error on myFunction ... }
Этот код является неправильным, как будто myFunction()
возвраты 0, это является литым ко лжи, и у Вас, кажется, есть ошибка. Корректный код:
if(myFunction() === false) { ... error on myFunction ... }
, потому что тест - то, что возвращаемое значение "является булевской переменной и является ложью" и не, "может быть литым ко лжи".
Вы использовали бы ===, чтобы протестировать, являются ли функция или переменная ложью вместо того, чтобы просто приравняться ко лжи (нуль или пустая строка).
$needle = 'a';
$haystack = 'abc';
$pos = strpos($haystack, $needle);
if ($pos === false) {
echo $needle . ' was not found in ' . $haystack;
} else {
echo $needle . ' was found in ' . $haystack . ' at location ' . $pos;
}
В этом случае ремни для правки бритв возвратились бы 0, который приравняется ко лжи в тесте
if ($pos == false)
или
if (!$pos)
, который не является тем, что Вы хотите здесь.
В отношении JavaScript:
=== оператор работает то же == оператор, но это требует, чтобы его операнды не имели только того же значения, но также и того же типа данных.
, Например, образец ниже отобразит 'X и Y, равны', но не 'X и Y идентичны'.
var x = 4;
var y = '4';
if (x == y) {
alert('x and y are equal');
}
if (x === y) {
alert('x and y are identical');
}
===
оператор, как предполагается, выдерживает сравнение точный равенство содержания, в то время как ==
оператор сравнил бы семантическое равенство. В особенности это принудит строки к числам.
Равенство является обширным предметом. См. статья Wikipedia о равенстве .
Что касается того, когда использовать один по другому, возьмите, например, эти fwrite()
функция в PHP.
Эта функция пишет содержание в поток файла. Согласно PHP, "fwrite()
возвраты число записанных байтов, или ЛОЖНЫХ на ошибке".. Если Вы хотите протестировать, если вызов функции был успешен, этот метод испорчен:
if (!fwrite(stuff))
{
log('error!');
}
Это может возвратить нуль (и считается успешным), и Ваше условие все еще инициировано. Правильный путь был бы:
if (fwrite(stuff) === FALSE)
{
log('error!');
}
Дополнение к другим ответам относительно объектного сравнения:
== сравнивает объекты с помощью названия объекта и их значений. Если два объекта имеют тот же тип и имеют те же членские значения, $a == $b
верные урожаи.
=== сравнивает внутренний идентификатор объекта объектов. Даже если участники равны, $a !== $b
, если они не точно тот же объект.
class TestClassA {
public $a;
}
class TestClassB {
public $a;
}
$a1 = new TestClassA();
$a2 = new TestClassA();
$b = new TestClassB();
$a1->a = 10;
$a2->a = 10;
$b->a = 10;
$a1 == $a1;
$a1 == $a2; // Same members
$a1 != $b; // Different classes
$a1 === $a1;
$a1 !== $a2; // Not the same object
Оператор == бросает между двумя различными типами, если они отличаются, в то время как === оператор выполняет 'безопасное с точки зрения типов сравнение'. Это означает, что только возвратит true, если оба операнда будут иметь тот же тип и то же значение.
Примеры:
1 === 1: true
1 == 1: true
1 === "1": false // 1 is an integer, "1" is a string
1 == "1": true // "1" gets casted to an integer, which is 1
"foo" === "foo": true // both operands are strings and have the same value
Предупреждение : два экземпляра того же класса с эквивалентными участниками НЕ соответствуют ===
оператор. Пример:
$a = new stdClass();
$a->foo = "bar";
$b = clone $a;
var_dump($a === $b); // bool(false)
Короче говоря, === работы таким же образом, что == делает на большинстве других языков программирования.
PHP позволяет Вам делать сравнения, которые действительно не имеют смысла. Пример:
$y = "wauv";
$x = false;
if ($x == $y)
...
, В то время как это допускает некоторые интересные "ярлыки", необходимо остерегаться, так как функция, которая возвращает что-то, которое она не была должна (как "ошибка" вместо числа) не будет поймана, и Вас оставят, задаваясь вопросом, что произошло.
В PHP, == сравнивает значения и выполняет преобразование типов при необходимости (например, строка "12343sdfjskfjds" станет "12343" в целочисленном сравнении). === сравнит значение И введет и возвратит false, если тип не будет тем же.
, Если Вы смотрите в руководстве PHP, Вы будете видеть, что много функций возвращает "false", если функция перестала работать, но они могли бы возвратиться 0 в успешном сценарии, который является, почему они рекомендуют делать "если (функция ()! == ложь)" для предотвращения ошибок.
Учитывая x = 5
1) Оператор: == "равно". x == 8
ложно
2) Оператор: === "точно равно" (значение и тип) x === 5
верно, x === "5"
ложно