Операторы и выражения в python
Содержание:
Операторы¶
Кратко рассмотрим операторы и их применение:
Обратите внимание, вычислить значения выражений, данных в примерах, можно также
используя интерпретатор интерактивно. Например, для проверки выражения
воспользуйтесь интерактивной командной строкой интерпретатора Python:
>>> 2 + 3 5 >>> 3 * 5 15
Операторы и их применение
Оператор
Название
Объяснение
Примеры
Сложение
Суммирует два
объекта
даст ;
даст
Вычитание
Даёт разность
двух чисел;
если первый
операнд
отсутствует,
он считается
равным нулю
даст отрицательное число,
а даст .
Умножение
Даёт
произведение
двух чисел или
возвращает
строку,
повторённую
заданное число
раз.
даст .
даст .
Возведение
в степень
Возвращает
число ,
возведённое в
степень
даст
(т.е. )
Деление
Возвращает
частное от
деления
на
даст .
Целочисленное
деление
Возвращает
неполное
частное от
деления
даст .
даст .
Деление по
модулю
Возвращает
остаток от
деления
даст .
даст .
Сдвиг влево
Сдвигает биты
числа влево на
заданное
количество
позиций. (Любое
число в памяти
компьютера
представлено в
виде битов —
или двоичных
чисел, т.е.
0 и 1)
даст .
В двоичном виде представляет
собой . Сдвиг влево на 2 бита
даёт , что в десятичном
виде означает .
Сдвиг вправо
Сдвигает биты
числа вправо на
заданное число
позиций.
даст .
В двоичном виде представляется
как , что будучи смещённым на
1 бит вправо, даёт , а это, в
свою очередь, не что иное как
десятичное
Побитовое И
Побитовая
операция И над
числами
даёт .
Побитовое ИЛИ
Побитовая
операция ИЛИ
над числами
даёт
Побитовое
ИСКЛЮЧИТЕЛЬНО
ИЛИ
Побитовая
операция
ИСКЛЮЧИТЕЛЬНО
ИЛИ
даёт
Побитовое НЕ
Побитовая
операция НЕ для
числа
соответствует
даёт .
Меньше
Определяет,
верно ли, что
меньше
Все
операторы
сравнения
возвращают
или
.
Обратите
внимание на
заглавные буквы
в этих словах.
даст ,
а даст .
Можно составлять произвольные цепочки
сравнений: даёт .
Больше
Определяет,
верно ли, что
больше
даёт .
Если оба операнда — числа, то перед
сравнением они оба преобразуются к
одинаковому типу. В противном случае
всегда возвращается .
Меньше или
равно
Определяет,
верно ли, что
меньше
или равно
даёт
.
Больше или
равно
Определяет,
верно ли, что
больше
или равно
даёт
.
Равно
Проверяет,
одинаковы ли
объекты
даёт
.
даёт
.
даёт
.
Не равно
Проверяет,
верно ли, что
объекты не
равны
даёт
.
Логическое НЕ
Если
равно ,
оператор вернёт
Если
же равно
,
получим
.
даёт .
Логическое И
даёт ,
если
равно
, в противном
случае
возвращает
значение
возвращает , поскольку x равно
. В этом случае Python не
станет проверять значение , так
как уже знает, что левая часть
выражения ‘and’ равняется ,
что подразумевает, что и всё выражение
в целом будет равно ,
независимо от значений всех остальных
операндов. Это называется укороченной
оценкой булевых (логических) выражений.
Логическое
ИЛИ
Если
равно ,
в результате
получим
, в
противном
случае получим
значение
даёт
. Здесь также может
производиться укороченная оценка
выражений.
Python NumPy
NumPy IntroNumPy Getting StartedNumPy Creating ArraysNumPy Array IndexingNumPy Array SlicingNumPy Data TypesNumPy Copy vs ViewNumPy Array ShapeNumPy Array ReshapeNumPy Array IteratingNumPy Array JoinNumPy Array SplitNumPy Array SearchNumPy Array SortNumPy Array FilterNumPy Random
Random Intro
Data Distribution
Random Permutation
Seaborn Module
Normal Distribution
Binomial Distribution
Poisson Distribution
Uniform Distribution
Logistic Distribution
Multinomial Distribution
Exponential Distribution
Chi Square Distribution
Rayleigh Distribution
Pareto Distribution
Zipf Distribution
NumPy ufunc
ufunc Intro
ufunc Create Function
ufunc Simple Arithmetic
ufunc Rounding Decimals
ufunc Logs
ufunc Summations
ufunc Products
ufunc Differences
ufunc Finding LCM
ufunc Finding GCD
ufunc Trigonometric
ufunc Hyperbolic
ufunc Set Operations
Ошибки и исключения
В любой, особенно большой, программе могут возникать ошибки, приводящие к ее неработоспособности или к тому, что программа делает не то, что должна. Причин возникновения ошибок много.
Программист может сделать ошибку в употреблении самого языка программирования. Другими словами, выразиться так, как выражаться не положено. Например, начать имя переменной с цифры или забыть поставить двоеточие в заголовке сложной инструкции. Подобные ошибки называют синтаксическими, они нарушают синтаксис и пунктуацию языка. Интерпретатор Питона, встретив ошибочное выражение, не знает как его интерпретировать. Поэтому останавливает выполнение программы и выводит соответствующее сообщение, указав на место возникновения ошибки:
>>> 1a = 10 File "<stdin>", line 1 1a = 10 ^ SyntaxError: invalid syntax
В терминологии языка Python здесь возникло исключение, принадлежащее классу SyntaxError. Согласно документации Python синтаксические ошибки все-таки принято относить к ошибкам, а все остальные – к исключениям. В некоторых языках программирования не используется слово «исключение», а ошибки делят на синтаксические и семантические. Нарушение семантики обычно означает, что, хотя выражения написаны верно с точки зрения синтаксиса языка, программа не работает так, как от нее ожидалось. Для сравнения. Вы можете грамотным русским языком сказать несколько предложений, но по смыслу это будет белиберда, или вас поймут не так, как хотелось бы.
В Python не говорят о семантических ошибках, говорят об исключениях. Их множество. В этом уроке мы рассмотрим некоторые из них, в последующих встретимся с еще несколькими.
Если вы попытаетесь обратиться к переменной, которой не было присвоено значение, что в случае Python означает, что переменная вообще не была объявлена, она не существует, то возникнет исключение NameError.
>>> a = >>> print(a + b) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'b' is not defined
Последнюю строку сообщения можно перевести как «Ошибка имени: имя ‘b’ не определено».
Если исключение возникает при выполнении кода из файла, то вместо «line 1» будет указана строка, в которой оно возникло, например, «line 24». Вместо «<stdin>» будет указано имя файла, например, «test.py». В данном же случае обозначает стандартный поток ввода. По-умолчанию это поток ввода с клавиатуры. Строка 1 – потому что в интерактивном режиме каждое выражение интерпретируется отдельно, как обособленная программка. Если написать выражение, состоящее из нескольких строк, то линия возникновения ошибки может быть другой:
>>> a = >>> if a == : ... print(a) ... print(a + b) ... 0 Traceback (most recent call last): File "<stdin>", line 3, in <module> NameError: name 'b' is not defined
Следующие два исключения, о которых следует упомянуть, и с которыми вы уже могли встретиться в предыдущих уроках, это ValueError и TypeError – ошибка значения и ошибка типа.
>>> int("Hi")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'Hi'
>>> 8 + "3"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
В примере строку «Hi» нельзя преобразовать к целому числу. Возникает исключение ValueError, потому что функция int() не может преобразовать такое значение.
Число 8 и строка «3» принадлежат разным типам, операнд сложения между которыми не поддерживается. При попытке их сложить возникает исключение TypeError.
Деление на ноль вызывает исключение ZeroDivisionError:
>>> 1/ Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: division by zero
Overloading logical inversion (not)
Any circuit breaker definition will have a logical inverse that is still a
circuit breaker, but inverts the answer as to when to short circuit the
expression evaluation. For example, the operator.true and
operator.false circuit breakers proposed in this PEP are each other’s
logical inverse.
A new protocol method, __not__(self), will be introduced to permit circuit
breakers and other types to override not expressions to return their
logical inverse rather than a coerced boolean result.
To preserve the semantics of existing language optimisations (such as
eliminating double negations directly in a boolean context as redundant),
__not__ implementations will be required to respect the following
invariant:
assert not bool(obj) == bool(not obj)
Specialness of None
The None object denotes the lack of a value. For the purposes of these
operators, the lack of a value indicates that the remainder of the expression
also lacks a value and should not be evaluated.
A rejected proposal was to treat any value that evaluates as «false» in a
Boolean context as not having a value. However, the purpose of these operators
is to propagate the «lack of value» state, rather than the «false» state.
Some argue that this makes None special. We contend that None is
already special, and that using it as both the test and the result of these
operators does not change the existing semantics in any way.
Python Comparison Operators
These operators compare the values on either sides of them and decide the relation among them. They are also called Relational operators.
Assume variable a holds 10 and variable b holds 20, then −
| Operator | Description | Example |
|---|---|---|
| == | If the values of two operands are equal, then the condition becomes true. | (a == b) is not true. |
| != | If values of two operands are not equal, then condition becomes true. | (a != b) is true. |
| <> | If values of two operands are not equal, then condition becomes true. | (a <> b) is true. This is similar to != operator. |
| > | If the value of left operand is greater than the value of right operand, then condition becomes true. | (a > b) is not true. |
| < | If the value of left operand is less than the value of right operand, then condition becomes true. | (a < b) is true. |
| >= | If the value of left operand is greater than or equal to the value of right operand, then condition becomes true. | (a >= b) is not true. |
| <= | If the value of left operand is less than or equal to the value of right operand, then condition becomes true. | (a <= b) is true. |
Сложные логические выражения
Логические выражения типа являются простыми, так как в них выполняется только одна логическая операция. Однако, на практике нередко возникает необходимость в более сложных выражениях. Может понадобиться получить ответа «Да» или «Нет» в зависимости от результата выполнения двух простых выражений. Например, «на улице идет снег или дождь», «переменная news больше 12 и меньше 20».
В таких случаях используются специальные операторы, объединяющие два и более простых логических выражения. Широко используются два оператора – так называемые логические И (and) и ИЛИ (or).
Чтобы получить True при использовании оператора and, необходимо, чтобы результаты обоих простых выражений, которые связывает данный оператор, были истинными. Если хотя бы в одном случае результатом будет False, то и все сложное выражение будет ложным.
Чтобы получить True при использовании оператора or, необходимо, чтобы результат хотя бы одного простого выражения, входящего в состав сложного, был истинным. В случае оператора or сложное выражение становится ложным лишь тогда, когда ложны оба составляющие его простые выражения.
Допустим, переменной было присвоено значение 8 (), переменной присвоили 13 (). Логическое выражение будет выполняться следующим образом. Сначала выполнится выражение . Его результатом будет True. Затем выполнится выражение . Его результатом будет False. Далее выражение сведется к , что вернет False.
>>> x = 8 >>> y = 13 >>> y < 15 and x > 8 False
Если бы мы записали выражение так: , то оно также вернуло бы False. Однако сравнение не выполнялось бы интерпретатором, так как его незачем выполнять. Ведь первое простое логическое выражение () уже вернуло ложь, которая, в случае оператора and, превращает все выражение в ложь.
В случае с оператором or второе простое выражение проверяется, если первое вернуло ложь, и не проверяется, если уже первое вернуло истину
Так как для истинности всего выражения достаточно единственного True, неважно по какую сторону от or оно стоит
>>> y < 15 or x > 8 True
В языке Python есть еще унарный логический оператор not, т. е. отрицание. Он превращает правду в ложь, а ложь в правду. Унарный он потому, что применяется к одному выражению, стоящему после него, а не справа и слева от него как в случае бинарных and и or.
>>> not y < 15 False
Здесь возвращает True. Отрицая это, мы получаем False.
>>> a = 5 >>> b = >>> not a False >>> not b True
Число 5 трактуется как истина, отрицание истины дает ложь. Ноль приравнивается к False. Отрицание False дает True.
Python | Кортежи
Кортежи
Последнее обновление: 26.04.2017
Кортеж (tuple) представляет последовательность элементов, которая во многом похожа на список за тем исключением, что кортеж является неизменяемым
(immutable) типом. Поэтому мы не можем добавлять или удалять элементы в кортеже, изменять его.
Для создания кортежа используются круглые скобки, в которые помещаются его значения, разделенные запятыми:
user = ("Tom", 23)
print(user)
Также для определения кортежа мы можем просто перечислить значения через запятую без применения скобок:
user = "Tom", 23 print(user)
Если вдруг кортеж состоит из одного элемента, то после единственного элемента кортежа необходимо поставить запятую:
user = ("Tom",)
Для создания кортежа из списка можно передать список в функцию tuple(), которая возвратит кортеж:
users_list =
users_tuple = tuple(users_list)
print(users_tuple) # ("Tom", "Bob", "Kate")
Обращение к элементам в кортеже происходит также, как и в списке по индексу. Индексация начинается также с нуля при получении элементов с начала списка и с -1 при получении элементов с конца списка:
users = ("Tom", "Bob", "Sam", "Kate")
print(users) # Tom
print(users) # Sam
print(users) # Kate
# получим часть кортежа со 2 элемента по 4
print(users) # ("Bob", "Sam", "Kate")
Но так как кортеж — неизменяемый тип (immutable), то мы не сможем изменить его элементы. То есть следующая запись работать не будет:
users = "Tim"
При необходимости мы можем разложить кортеж на отдельные переменные:
user = ("Tom", 22, False)
name, age, isMarried = user
print(name) # Tom
print(age) # 22
print(isMarried) # False
Особенно удобно использовать кортежи, когда необходимо возвратить из функции сразу несколько значений. Когда функция возвращает несколько значений, фактически она возвращает в кортеж:
def get_user():
name = "Tom"
age = 22
is_married = False
return name, age, is_married
user = get_user()
print(user) # Tom
print(user) # 22
print(user) # False
С помощью встроенной функции len() можно получить длину кортежа:
user = ("Tom", 22, False)
print(len(user)) # 3
Перебор кортежей
Для перебора кортежа можно использовать стандартные циклы for и while. С помощью цикла for:
user = ("Tom", 22, False)
for item in user:
print(item)
С помощью цикла while:
user = ("Tom", 22, False)
i = 0
while i < len(user):
print(user)
i += 1
Как для списка с помощью выражения можно проверить наличие элемента в кортеже:
user = ("Tom", 22, False)
name = "Tom"
if name in user:
print("Пользователя зовут Tom")
else:
print("Пользователь имеет другое имя")
Сложные кортежи
Один кортеж может содержать другие кортежи в виде элементов. Например:
countries = (
("Germany", 80.2, (("Berlin",3.326), ("Hamburg", 1.718))),
("France", 66, (("Paris", 2.2),("Marsel", 1.6)))
)
for country in countries:
countryName, countryPopulation, cities = country
print("\nCountry: {} population: {}".format(countryName, countryPopulation))
for city in cities:
cityName, cityPopulation = city
print("City: {} population: {}".format(cityName, cityPopulation))
Здесь кортеж countries, который представляет страны, состоит из кортежей, каждый из которых — отдельная страна.
Вложенные кортежи имеют три элемента: название страны, численность ее населения и города. Города представляют отдельный кортеж, где каждый отдельный город — это вложенный кортеж,
содержащий название города и численность его населения.
Grab
The next example is from a Python scraping library called Grab:
class BaseUploadObject(object):
def find_content_type(self, filename):
ctype, encoding = mimetypes.guess_type(filename)
if ctype is None:
return 'application/octet-stream'
else:
return ctype
class UploadContent(BaseUploadObject):
def __init__(self, content, filename=None, content_type=None):
self.content = content
if filename is None:
self.filename = self.get_random_filename()
else:
self.filename = filename
if content_type is None:
self.content_type = self.find_content_type(self.filename)
else:
self.content_type = content_type
class UploadFile(BaseUploadObject):
def __init__(self, path, filename=None, content_type=None):
self.path = path
if filename is None:
self.filename = os.path.split(path)
else:
self.filename = filename
if content_type is None:
self.content_type = self.find_content_type(self.filename)
else:
self.content_type = content_type
This example contains several good examples of needing to provide default
values. Rewriting to use conditional expressions reduces the overall lines of
code, but does not necessarily improve readability:
class BaseUploadObject(object):
def find_content_type(self, filename):
ctype, encoding = mimetypes.guess_type(filename)
return 'application/octet-stream' if ctype is None else ctype
class UploadContent(BaseUploadObject):
def __init__(self, content, filename=None, content_type=None):
self.content = content
self.filename = (self.get_random_filename() if filename
is None else filename)
self.content_type = (self.find_content_type(self.filename)
if content_type is None else content_type)
class UploadFile(BaseUploadObject):
def __init__(self, path, filename=None, content_type=None):
self.path = path
self.filename = (os.path.split(path) if filename is
None else filename)
self.content_type = (self.find_content_type(self.filename)
if content_type is None else content_type)
The first ternary expression is tidy, but it reverses the intuitive order of
the operands: it should return ctype if it has a value and use the string
literal as fallback. The other ternary expressions are unintuitive and so
long that they must be wrapped. The overall readability is worsened, not
improved.
Rewriting using the None coalescing operator:
class BaseUploadObject(object):
def find_content_type(self, filename):
ctype, encoding = mimetypes.guess_type(filename)
return ctype ?? 'application/octet-stream'
class UploadContent(BaseUploadObject):
def __init__(self, content, filename=None, content_type=None):
self.content = content
self.filename = filename ?? self.get_random_filename()
self.content_type = content_type ?? self.find_content_type(self.filename)
class UploadFile(BaseUploadObject):
def __init__(self, path, filename=None, content_type=None):
self.path = path
self.filename = filename ?? os.path.split(path)
self.content_type = content_type ?? self.find_content_type(self.filename)
Circuit breaking identity comparisons (is and is not)
In the absence of any standard circuit breakers, the proposed if and
else operators would largely just be unusual spellings of the existing
and and or logical operators.
However, this PEP further proposes to provide a new general purpose
types.CircuitBreaker type that implements the appropriate short
circuiting logic, as well as factory functions in the operator module
that correspond to the is and is not operators.
These would be defined in such a way that the following expressions produce
VALUE rather than False when the conditional check fails:
EXPR if is_sentinel(VALUE, SENTINEL) EXPR if is_not_sentinel(VALUE, SENTINEL)
And similarly, these would produce VALUE rather than True when the
conditional check succeeds:
is_sentinel(VALUE, SENTINEL) else EXPR is_not_sentinel(VALUE, SENTINEL) else EXPR
In effect, these comparisons would be defined such that the leading
VALUE if and trailing else VALUE clauses can be omitted as implied in
expressions of the following forms:
# To handle "if" expressions, " else VALUE" is implied when omitted EXPR if is_sentinel(VALUE, SENTINEL) else VALUE EXPR if is_not_sentinel(VALUE, SENTINEL) else VALUE # To handle "else" expressions, "VALUE if " is implied when omitted VALUE if is_sentinel(VALUE, SENTINEL) else EXPR VALUE if is_not_sentinel(VALUE, SENTINEL) else EXPR
The proposed types.CircuitBreaker type would represent this behaviour
programmatically as follows:
class CircuitBreaker:
"""Simple circuit breaker type"""
def __init__(self, value, bool_value):
self.value = value
self.bool_value = bool(bool_value)
def __bool__(self):
return self.bool_value
def __not__(self):
return CircuitBreaker(self.value, not self.bool_value)
def __then__(self, result):
if result is self:
return self.value
return result
def __else__(self, result):
if result is self:
return self.value
return result
The key characteristic of these circuit breakers is that they are ephemeral:
when they are told that short circuiting has taken place (by receiving a
reference to themselves as the candidate expression result), they return the
original value, rather than the circuit breaking wrapper.
The short-circuiting detection is defined such that the wrapper will always
be removed if you explicitly pass the same circuit breaker instance to both
sides of a circuit breaking operator or use one as all three operands in a
conditional expression:
breaker = types.CircuitBreaker(foo, foo is None) assert operator.short_circuit(breaker) is foo assert (breaker if breaker) is foo assert (breaker else breaker) is foo assert (breaker if breaker else breaker) is foo breaker = types.CircuitBreaker(foo, foo is not None) assert operator.short_circuit(breaker) is foo assert (breaker if breaker) is foo assert (breaker else breaker) is foo assert (breaker if breaker else breaker) is foo
The factory functions in the operator module would then make it
straightforward to create circuit breakers that correspond to identity
checks using the is and is not operators:
Python Побитовые Операторы
Битовые операторы рассматриваются двоичные числа, чтобы произвести расчет. Python является правилом Побитовая следующим образом:
В качестве переменной в следующей таблице 60, б 13.
| операторы | описание | примеров |
|---|---|---|
| & | Побитовое и оператор: два значения, участвующие в операции, если оба соответствующие биты равны 1, то результат бит равен 1, 0 в противном случае | (A & B) выход 12, бинарная информация: 0000 1100 |
| | | Побитовая или оператор: до тех пор, как два соответствующий двоичный бит равен 1, результирующий бит равен 1. | (A | B) выход 61, бинарная информация: 00111101 |
| ^ | Побитовое исключающее ИЛИ оператор: Когда два соответствующих двоичным немного отличается, и результат 1 | (А ^ б) выход 49, бинарная информация: 00110001 |
| ~ | Битовые операторы: каждый двоичный бит данных инверсии, то есть от 1 до 0, от 0 до 1 | (~ A) -61 выход, бинарная информация: 1100 0011 в символическом виде дополнительного кода двоичного числа. |
| << | Левые операторы мобильной связи: каждый двоичный операнды все осталось некоторое количество битов, указанных цифрой «<<» справа от десятичной ходов, отбрасывая высокие и более низкие 0s. | а << 2 выхода 240 Binary интерпретация: 11110000 |
| >> | Правильные операторы мобильной связи: на каждый двоичный «>>» левый операнд Несколько все в порядке, «>>» справа от числа битов указанного | A >> 2 выход 15, бинарная информация: 0000 1111 |
Следующий пример демонстрирует Python все битовые операции:
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = 0 c = a & b; # 12 = 0000 1100 print "1 - c 的值为：", c c = a | b; # 61 = 0011 1101 print "2 - c 的值为：", c c = a ^ b; # 49 = 0011 0001 print "3 - c 的值为：", c c = ~a; # -61 = 1100 0011 print "4 - c 的值为：", c c = a << 2; # 240 = 1111 0000 print "5 - c 的值为：", c c = a >> 2; # 15 = 0000 1111 print "6 - c 的值为：", c
Примеры вышеуказанного вывода:
1 - c 的值为： 12 2 - c 的值为： 61 3 - c 的值为： 49 4 - c 的值为： -61 5 - c 的值为： 240 6 - c 的值为： 15
Python NumPy
NumPy IntroNumPy Getting StartedNumPy Creating ArraysNumPy Array IndexingNumPy Array SlicingNumPy Data TypesNumPy Copy vs ViewNumPy Array ShapeNumPy Array ReshapeNumPy Array IteratingNumPy Array JoinNumPy Array SplitNumPy Array SearchNumPy Array SortNumPy Array FilterNumPy Random
Random Intro
Data Distribution
Random Permutation
Seaborn Module
Normal Distribution
Binomial Distribution
Poisson Distribution
Uniform Distribution
Logistic Distribution
Multinomial Distribution
Exponential Distribution
Chi Square Distribution
Rayleigh Distribution
Pareto Distribution
Zipf Distribution
NumPy ufunc
ufunc Intro
ufunc Create Function
ufunc Simple Arithmetic
ufunc Rounding Decimals
ufunc Logs
ufunc Summations
ufunc Products
ufunc Differences
ufunc Finding LCM
ufunc Finding GCD
ufunc Trigonometric
ufunc Hyperbolic
ufunc Set Operations
Модуль: Вывод текста на экран
Hello, World! Вывод текста на экран
В модуле давайте познакомимся, в задаче №3, у нас была программа, которая выглядела следующим образом
print(«Hello, World!»)
Данная программа выводит на экран текст Hello, World!
Текст будет выведен без кавычек.
Таким образом, чтобы вывести что-то на экран, используется встроенная команда (функция, оператор) —
В кавычках записывается текст для вывода — то есть некоторая символьная строка
По требованию языка Python, в начале строки не должно быть пробелов
Текст можно записывать не в кавычках, а в апострофах (одиночных кавычках), например
print(‘Hello, World!’)
Использовать кавычки удобно, если нужно вывести сами кавычки на экран.
Пример:
print(‘Прочитайте книгу «Программирование для всех»!’)
ЗАПОМИНАЕМ
1 Чтобы вывести на экран что-либо, используем оператор 2 В скобках записываем что выводим, символьные строки записываем в кавычках или апострофах3 Перед командой print пробелов в начале строки не ставим!
Давайте потренируемся выводить, что-нибудь на экран!
Вывод текста 2
Внутри скобок можно через запятую записывать несколько символьных строк, все они будут автоматически выводиться на экран через пробел.
Если же пробел между строками не нужен, то при вызове функции необходимо добавить еще один аргумент с именем (значение аргумента равно пустой строке) Например, вывод фразы
Hello,World!
(без пробелов),
можно организовать таким образом
print(«Hello,»,»World!»,sep=»»)
Каждая новая команда выводит текст с новой строки.
Например. при написании такой программы
print(«Hello,»)
print(«World!»)
На экране появится
Hello,
World!
Отменить переход на новую строку можно использовав аргумент end=»» (значение аргумента равно пустой строке)ЗАПОМИНАЕМ1 Каждая команда выводит текст с новой строки2 При указании нескольких символьных строк, внутри одной команды все строки будут выводиться через пробел3 Если пробел необходимо убрать, в конце записываем 4 При записи нескольких команд вывода, можно отменить переход на новую строку
Для этого добавляем в конце аргумент
Потренируйтесь, решая задачу
Особые символы
Во многих языках программирования есть специальные символы, которые просто так не вывести.
Например, часто используемые специальные символы, — это бек-слеш (\), кавычки («) и апострофы (‘)
Обратите внимание, что обычный слеш () не является специальным символом!
Для вывода таких символов перед каждым из них мы ставим знак. То есть, если мы хотим вывести на экран знак , то в операторе вывода необходимо написать ЗАПОМИНАЕМ
Чтобы вывести символы , , , необходимо перед ними поставить знак
Потренируемся выводить такие символы на экран.
