Встроенные функции

Почему Вам нужно обратиться именно к нам?

Старый способ — строковый оператор форматирования

Оператор % по отношению к строкам выполняет операцию форматирования и вставки таким образом, что объект, стоящий справа от него, встраивается согласно определенным правилам в строку слева от него:

Такой способ форматирования считается старым видимо потому, что заимствован из функции printf() языка C, а в Python кроме него появились более продвинутые средства форматирования вывода. Однако в ряде случаев использование оператора % бывает удобнее, чем использование строкового метода format().

Следует отметить, что форматируются строки, а не вывод. На вывод передается уже сформированная строка.

Как вывести вещественное число с необходимой точностью

Оператор деления возвращает вещественное число. Если количество знаков бесконечно, то Python выведет его в таком виде: 

>>> 4 / 3
1.3333333333333333

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

>>> "%.4f" % (4/3)
'1.3333'

Ставить скобки обязательно, иначе операция % выполняется раньше /:

>>> "%.4f" % 4/3
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    "%.4f" % 4/3
TypeError: unsupported operand type(s) for /: 'str' and 'int'

Оператор форматирования строк выполняет округление, а не урезание:

>>> "%.4f" % (1.33335)
'1.3334'
>>> "%.4f" % (1.33334)
'1.3333'

С функцией print():

>>> print("Number %.4f" % (1.33334))
Number 1.3333
>>> print("%.4f, %.2f" % (1.33334, 153*0.43))
1.3333, 65.79
>>> print("%f, %f" % (1.33334, 153*0.43))
1.333340, 65.790000
>>> 153*0.43
65.78999999999999

Вывод символа по номеру

>>> "%c" % 121
'y'
>>> "%c" % 189
'½'
>>> "%c" % 255
'ÿ'
>>> "%c" % 999
'ϧ'
>>> "%c" % 32400
'纐'

Если вместо символа ‘c’ использовать ‘d’, будет вставлено само целое число.

Вывод данных в поля заданной ширины

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

Рассмотрим пример. Допустим надо вывести числа второй строки под числами первой. Если выполнить функцию print() так:

print(10, 235)
print(1000, 50)

результат будет таким:

10 235
1000 50

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

print("%5d%7d" % (10, 235))
print("%5d%7d" % (1000, 50))

Результат:

   10     235
 1000      50

Здесь в кавычках указаны форматы данных и ширина полей. После знака % за кавычками указаны данные, которые будут подставлены вместо каждого указанного формата. Если количество форматов не совпадает с количеством данных, возникнет ошибка.

Форматы данных могут быть: d — целое число, s — строка, f — вещественное число, c — символ.

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

print("%-5d%7d" % (10, 235))
print("%-5d%7d" % (1000, 50))

Вывод:

10       235
1000      50

Python SciPy

Вызов функции

Рассмотрим полную версию программы с функцией:

def countFood():
    a = int(input())
    b = int(input())
    print("Всего", a+b, "шт.")

print("Сколько бананов и ананасов для обезьян?")
countFood()

print("Сколько жуков и червей для ежей?")
countFood()

print("Сколько рыб и моллюсков для выдр?")
countFood()

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

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

В языке Python определение функции должно предшествовать ее вызовам. Это связано с тем, что интерпретатор читает код строка за строкой и о том, что находится ниже по течению, ему еще неизвестно. Поэтому если вызов функции предшествует ее определению, то возникает ошибка (выбрасывается исключение NameError):

print("Сколько бананов и ананасов для обезьян?")
countFood()

print("Сколько жуков и червей для ежей?")
countFood()

print("Сколько рыб и моллюсков для выдр?")
countFood()

def countFood():
    a = int(input())
    b = int(input())
    print("Всего", a+b, "шт.")

Результат:

Сколько бананов и ананасов для обезьян?
Traceback (most recent call last):
  File "test.py", line 2, in <module>
    countFood()
NameError: name 'countFood' is not defined

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

Ввод из файла

Ввод также может быть прочитан из файлов. Файлы могут быть открыты с помощью встроенной функции . Использование , синтаксис ( так называемый «Контекст — менеджер») делает работу с и получить дескриптор файла супер легко:

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

Файлы могут быть открыты в разных режимах. В приведенном выше примере файл открывается только для чтения. Чтобы открыть существующий файл для чтения только использовать . Если вы хотите , чтобы прочитать этот файл как байты использовать . Для добавления данных в существующий файл с помощью . Используйте , чтобы создать файл или перезаписать существующие файлы с тем же именем. Вы можете использовать , чтобы открыть файл для чтения и записи. Первый аргумент это имя файла, второй режим. Если режим остается пустым, то по умолчанию будет .

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

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

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

После прочтения всего содержимого позиция обработчика файла будет указана в конце файла:

Позиция обработчика файла может быть установлена ​​на то, что нужно:

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

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

Синтаксис

Окно определяется с помощью обязательной инструкции OVER(). Давайте рассмотрим синтаксис этой инструкции:

SELECT
Название функции (столбец для вычислений) 
OVER (
      PARTITION BY столбец для группировки
      ORDER BY столбец для сортировки
      ROWS или RANGE выражение для ограничения строк в пределах группы
      )

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

OVER()

Откроем окно при помощи OVER() и просуммируем столбец «Conversions»:

SELECT 
  Date
, Medium
, Conversions
, SUM(Conversions) OVER() AS 'Sum' 
FROM Orders

Мы использовали инструкцию OVER() без предложений. В таком варианте окном будет весь набор данных и никакая сортировка не применяется. Появился новый столбец «Sum» и для каждой строки выводится одно и то же значение 14. Это сквозная сумма всех значений колонки «Conversions».

PARTITION BY

Теперь применим инструкцию PARTITION BY, которая определяет столбец, по которому будет производиться группировка и является ключевой в разделении набора строк на окна:

SELECT 
  Date
, Medium
, Conversions
, SUM(Conversions) OVER(PARTITION BY Date) AS 'Sum' 
FROM Orders

Инструкция PARTITION BY сгруппировала строки по полю «Date». Теперь для каждой группы рассчитывается своя сумма значений столбца «Conversions».

ORDER BY

Попробуем отсортировать значения внутри окна при помощи ORDER BY:

SELECT 
  Date
, Medium
, Conversions
, SUM(Conversions) OVER(PARTITION BY Date ORDER BY Medium) AS 'Sum' 
FROM Orders

К предложению PARTITION BY добавилось ORDER BY по полю «Medium». Таким образом мы указали, что хотим видеть сумму не всех значений в окне, а для каждого значения «Conversions» сумму со всеми предыдущими. То есть мы посчитали нарастающий итог.

ROWS или RANGE

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

Инструкция RANGE, в отличие от ROWS, работает не со строками, а с диапазоном строк в инструкции ORDER BY. То есть под одной строкой для RANGE могут пониматься несколько физических строк одинаковых по рангу.

Обе инструкции ROWS и RANGE всегда используются вместе с ORDER BY.

В выражении для ограничения строк ROWS или RANGE также можно использовать следующие ключевые слова:

• UNBOUNDED PRECEDING — указывает, что окно начинается с первой строки группы;
• UNBOUNDED FOLLOWING – с помощью данной инструкции можно указать, что окно заканчивается на последней строке группы;
• CURRENT ROW – инструкция указывает, что окно начинается или заканчивается на текущей строке;
• BETWEEN «граница окна» AND «граница окна» — указывает нижнюю и верхнюю границу окна;
• «Значение» PRECEDING – определяет число строк перед текущей строкой (не допускается в предложении RANGE).;
• «Значение» FOLLOWING — определяет число строк после текущей строки (не допускается в предложении RANGE).

Разберем на примере:

SELECT 
  Date
, Medium
, Conversions
, SUM(Conversions) OVER(PARTITION BY Date ORDER BY Conversions ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING) AS 'Sum' 
FROM Orders

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

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

Нововведения Python 3.9.0

Начиная с недавно вышедшей версии Python 3.9, у разработчиков больше нет необходимости импортировать абстрактные коллекции для описания типов. Теперь вместо можно использовать , то же самое происходит с , , и т.д. Полное описание этого нововведения можно прочитать тут: PEP-585.

Также добавили аннотации типов, которые в дальнейшем могут быть использованы инструментами статического анализа. где — тип переменной , а — некоторые метаданные для переменной. По оценкам некоторых авторов, эти метаданные могут быть использованы также и во время выполнения (подробности смотрите в PEP-593).

А как сделать резервное копирование всех моих настроек?

Проверяет, что все элементы в последовательности True.

Описание:

Функция возвращает значение , если все элементы в итерируемом объекте — истинны, в противном случае она возвращает значение .

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

Функция применяется для проверки на ВСЕХ значений в последовательности и эквивалентна следующему коду:

def all(iterable):
    for element in iterable
        if not element
            return False
    return True

Так же смотрите встроенную функцию

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

>>> True and True and True
# True
>>> True and False and True
# False

>>> all()
# True
>>> all()
# False

Но между и в Python есть два основных различия:

• Синтаксис.
• Возвращаемое значение.

Функция всегда возвращает или (значение )

>>> all()
# True
>>> all(])
# False

Если в выражении все значения , то оператор возвращает ПЕРВОЕ истинное значение, а если все значения , то последнее ложное значение. А если в выражении присутствует значение , то ПЕРВОЕ ложное значение. Что бы добиться поведения как у функции , необходимо выражение с оператором обернуть в функцию .

>>> 3 and 1 and 2 and 6
# 6
>>> 3 and  and 3 and []
# 0

>>> bool(3 and 1 and 2 and 6)
# True
>>> bool(3 and  and 3 and [])
# False

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

num = 1, 2.0, 3.1, 4, 5, 6, 7.9
# использование встроенных функций или
# методов на примере 'isdigit()'
>>> str(x).isdigit() for x in num
# 

# использование операции сравнения
>>> x > 4 for x in num
# 

# использование оператора вхождения `in`
>>> '.' in str(x) for x in num
# 

# использование оператора идентичности `is`
>>> type(x) is int for x in num
# 

# использование функции map()
>>> list(map(lambda x x > 1, num))
False, True, True, True, True, True, True

Примеры проводимых проверок функцией .

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

>>> num1 = range(1, 9)
>>> num2 = range(-1, 7)
>>> all()
# True
>>> all()
# False

Или проверить, что последовательность чисел содержит только ЦЕЛЫЕ числа.

>>> num1 = 1, 2, 3, 4, 5, 6, 7
>>> num2 = 1, 2.0, 3.1, 4, 5, 6, 7.9
>>> all()
# True
>>> all()
# False

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

>>> line1 = "1, 2, 3, 9.9, 15.1, 7"
>>> line2 = "1, 2, 3, 9.9, 15.1, 7, девять"
>>> all()
# True
>>> all()
# False

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

Package managers

Pull in Bootstrap’s source files into nearly any project with some of the most popular package managers. No matter the package manager, Bootstrap will require a Sass compiler, Autoprefixer, and postcss-flexbugs-fixes for a setup that matches our official compiled versions.

npm

Install Bootstrap in your Node powered apps with the npm package:

will load all of Bootstrap’s jQuery plugins onto the jQuery object. The module itself does not export anything. You can manually load Bootstrap’s jQuery plugins individually by loading the files under the package’s top-level directory.

Bootstrap’s contains some additional metadata under the following keys:

• — path to Bootstrap’s main Sass source file
• — path to Bootstrap’s non-minified CSS that’s been precompiled using the default settings (no customization)

RubyGems

Install Bootstrap in your Ruby apps using Bundler (recommended) and RubyGems by adding the following line to your :

Alternatively, if you’re not using Bundler, you can install the gem by running this command:

See the gem’s README for further details.

NuGet

If you develop in .NET, you can also install and manage Bootstrap’s CSS or Sass and JavaScript using NuGet:

The is required until Bootstrap v4 has a stable release.

Примеры создания и изменения классов «на лету» при помощи type():

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

>>> class Foo(object):
...       bar = True
>>> Foo = type('Foo', (), {'bar'True})

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

>>> Foo
# <class '__main__.Foo'>
>>> f = Foo()
>>> f.bar
# True

# можно наследоваться от него
>>>   class FooChild(Foo): pass
...
>>> FooChild
# <class '__main__.FooChild'>
>>> FooChild.bar # bar унаследован от Foo
# True

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

>>> def echo_bar(self):
...       print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar' echo_bar})
>>> hasattr(Foo, 'echo_bar')
# False
>>> hasattr(FooChild, 'echo_bar')
# True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
# True

# после динамического создания класса добавим еще один метод 
>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
# True

Другие встроенные функции

abs(x) — Возвращает абсолютную величину (модуль числа).

all(последовательность) — Возвращает True, если все элементы истинные (или, если последовательность пуста).

any(последовательность) — Возвращает True, если хотя бы один элемент — истина. Для пустой последовательности возвращает False.

ascii(object) — Как repr(), возвращает строку, содержащую представление объекта, но заменяет не-ASCII символы на экранированные последовательности.

bin(x) — Преобразование целого числа в двоичную строку.

callable(x) — Возвращает True для объекта, поддерживающего вызов (как функции).

chr(x) — Возвращает односимвольную строку, код символа которой равен x.

classmethod(x) — Представляет указанную функцию методом класса.

compile(source, filename, mode, flags=0, dont_inherit=False) — Компиляция в программный код, который впоследствии может выполниться функцией eval или exec. Строка не должна содержать символов возврата каретки или нулевые байты.

delattr(object, name) — Удаляет атрибут с именем ‘name’.

dir() — Список имен объекта, а если объект не указан, список имен в текущей локальной области видимости.

divmod(a, b) — Возвращает частное и остаток от деления a на b.

enumerate(iterable, start=0) — Возвращает итератор, при каждом проходе предоставляющем кортеж из номера и соответствующего члена последовательности.

eval(expression, globals=None, locals=None) — Выполняет строку программного кода.

exec(object]) — Выполняет программный код на Python.

filter(function, iterable) — Возвращает итератор из тех элементов, для которых function возвращает истину.

format(value) — Форматирование (обычно форматирование строки).

getattr(object, name ,) — извлекает атрибут объекта или default.

globals() — Словарь глобальных имен.

hasattr(object, name) — Имеет ли объект атрибут с именем ‘name’.

hash(x) — Возвращает хеш указанного объекта.

help() — Вызов встроенной справочной системы.

hex(х) — Преобразование целого числа в шестнадцатеричную строку.

id(object) — Возвращает «адрес» объекта. Это целое число, которое гарантированно будет уникальным и постоянным для данного объекта в течение срока его существования.

input() — Возвращает введенную пользователем строку. Prompt — подсказка пользователю.

isinstance(object, ClassInfo) — Истина, если объект является экземпляром ClassInfo или его подклассом. Если объект не является объектом данного типа, функция всегда возвращает ложь.

issubclass(класс, ClassInfo) — Истина, если класс является подклассом ClassInfo. Класс считается подклассом себя.

iter(x) — Возвращает объект итератора.

len(x) — Возвращает число элементов в указанном объекте.

locals() — Словарь локальных имен.

map(function, iterator) — Итератор, получившийся после применения к каждому элементу последовательности функции function.

max(iter, * ) — Максимальный элемент последовательности.

min(iter, * ) — Минимальный элемент последовательности.

next(x) — Возвращает следующий элемент итератора.

oct(х) — Преобразование целого числа в восьмеричную строку.

open(file, mode=’r’, buffering=None, encoding=None, errors=None, newline=None, closefd=True) — Открывает файл и возвращает соответствующий поток.

ord(с) — Код символа.

pow(x, y) — ( x ** y ) % r.

reversed(object) — Итератор из развернутого объекта.

repr(obj) — Представление объекта.

print(, *, sep=» «, end=’\n’, file=sys.stdout) — Печать.

property(fget=None, fset=None, fdel=None, doc=None)

round(X ) — Округление до N знаков после запятой.

setattr(объект, имя, значение) — Устанавливает атрибут объекта.

sorted(iterable) — Отсортированный список.

staticmethod(function) — Статический метод для функции.

sum(iter, start=0) — Сумма членов последовательности.

super(]) — Доступ к родительскому классу.

type(object) — Возвращает тип объекта.

type(name, bases, dict) — Возвращает новый экземпляр класса name.

vars() — Словарь из атрибутов объекта. По умолчанию — словарь локальных имен.

zip(*iters) — Итератор, возвращающий кортежи, состоящие из соответствующих элементов аргументов-последовательностей.

Known Issues

Чтение, запись и обработка файлов в Python.

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

# Unix
/path/to/file/text.txt

# Windows
c:\path\to\file\text.txt

Он разбит на три основные части:

1. Путь к файлу : расположение директории в файловой системе, где папки разделены прямой косой чертой в Unix подобных системах или обратной косой чертой в Windows.
2. Имя файла : фактическое имя файла.
3. Расширение : используется для указания типа файла.

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

>>> full_path = '/path/to/file/text.txt'
>>> print(full_path)
# /path/to/file/text.txt

В системе Windows путь включает в себя обратную косую черту . Этот символ в строках на Python используется для экранирования escape-последовательностей, таких как новая строка .

>>> full_path = 'c:\path\to\file\text.txt'
>>> print(full_path)
# c:\path o
#          ile    ext.txt

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

# экранируем обратную косую черту
>>> full_path = 'c:\\path\\to\\file\\text.txt'
>>> print(full_path)
# c:\path\to\file\text.txt

# строковой литерал raw строки
>>> full_path = r'c:\path\to\file\text.txt'
>>> print(full_path)
# c:\path\to\file\text.txt

Открытие/закрытие файла для чтения/записи в Python.
Прежде чем начать работать с файлом, первое, что нужно сделать, это открыть его. Это делается путем вызова встроенной функции open(). Она имеет единственный обязательный аргумент, который представляет путь к файлу filename

Типы обрабатываемых данных и файлов в Python.
Существуют три типа файлов которые чаще всего обрабатываются на практике. Текстовые файлы. Буферизованные двоичные типы файлов. Необработанный тип файлов Raw.

Способы чтения открытого файла в Python.
Существует несколько методов, которые могут быть вызваны для чтения открытого файла. read(size=-1), readline(size=-1), readlines()

Способы записи в открытый файл в Python.
Как и при чтении файлов, файловые объекты имеют несколько методов, которые полезны для записи в файл. fp.write(string), fp.writelines(sequence)

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

Добавление данных в открытый файл в Python..
Иногда может понадобиться добавить данные в файл или начать запись в конце уже заполненного файла. Это легко сделать, используя символ ‘a’ для аргумента mode функции open():

Управление указателем чтения/записи в файле в Python.
Краткий обзор методов управления указателем чтения/записи в файле.

Создание менеджера для обработки файла в Python.
У менеджера контекста есть два «магических метода». __enter__() — вызывается при вызове оператора with. __exit__() вызывается при выходе из блока оператора with.

Сохранение словарей в формат JSON в Python.
Для сохранения сложных типов данных в файлы, Python позволяет использовать популярный формат обмена данными, называемый JSON. pickle — это протокол, который позволяет сериализовать произвольно сложные объекты Python.

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

Ввод и вывод данных

• Вывод данных осуществляется при помощи оператора print:

1
2
3
4
5

a = 1
b = 2
print(a)
print(a + b)
print('сумма = ', a + b)

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

1
2
3

a = 1; b = 2; print(a)
print(a + b)
print('сумма = ', a + b)

Для функции print может задаваться так называемый сепаратор — разделитель между элементами вывода:

1
2
3

x=2
y=5
print ( x, "+", y, "=", x+y, sep = " " )

Результат отобразится с пробелами между элементами: 2 + 5 = 7

Для форматированного вывода используется format:

1
2

x = 11
print ( "{:4d}".format(x) )

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

Или с несколькими аргументами:

1
2

x = 2
print ( "{:4d}{:4d}{:4d}".format (x, x+x, x*x) )

В итоге каждое из значений выводится из расчета 4 знакоместа.

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

1
2

a = input()
print(a)

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

a = input ("Введите количество: ")

Функция input воспринимает входные данные, как поток символов. Поэтому, чтобы принять целочисленное значение, следует воспользоваться функцией int():

a = int (input())

Задание Python 1_1:
Используя операторы input и print, выведите значения целых переменных x=5 и y=3 в следующих форматах:
3+5=?
3 | 5 | 8
Z(5)=F(3)
x=5; y=3;
Ответ: (5;3)