Запись дробных чисел (с плавающей запятой)

Примеры дробных чисел:

3.14 10..001 1e100 3.14e-10 0e0

ЗАПИСЬ МНИМЫХ ЧИСЕЛ

Мнимое число — это комплексное число с действительной частью "0", при этом комплексные числа представлены в виде пары чисел с плавающей точкой.

Примеры мнимых чисел:

3.14j 10.j 10j.001j 1e100j 3.14e-10j

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

Целочисленный тип (int) в Python

Для хранения целых чисел в Python используется тип int (от англ. integer — целое число). Этот тип позволяет хранить как положительные, так и отрицательные числа, при этом сколь угодно большие (в отличие от большинства языков программирования, где целочисленная переменная обычно занимает лишь несколько байт). Более точно, размер числа ограничен лишь имеющейся памятью.

Для преобразования к целому типу используется функция одноименная с именем типа — int:

s = int(input())

t = int(2.5)

Для целых чисел определены арифметические операции:

+ сложение;

— вычитание;

* умножение (пропускать его в выражениях вида 2 * x нельзя);

/ деление;

// целочисленное деление (дробная часть отбрасывается);

% остаток от деления;

** возведение в степень.

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

(x - a) * 2 - (a - (1 - c))

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

Присваивания вида x = x + a, x = x // a и т. п. можно писать сокращенно: x += a, x //= a.

ПРИМЕР СЧИТЫВАНИЯ ОДНОГО ЧИСЛА

s = int(input())

ПРИМЕР СЧИТЫВАНИЯ ДВУХ ЧИСЕЛ, ВВОДИМЫХ В РАЗНЫХ СТРОЧКАХ

s = int(input())
t = int(input())

ПРИМЕР СЧИТЫВАНИЯ ДВУХ ЧИСЕЛ, ВВОДИМЫХ В ОДНОЙ СТРОКЕ ЧЕРЕЗ ПРОБЕЛ:

s, t = map(int, input().split()) # читаем строку, режем по пробелу
# с помощью split, и к каждой части
# применяем функцию int

Строки в Python

Строка состоит из последовательности символов.
Тип строки str.

>>> type('2')

<class 'str'>

В языке Питон нет отдельного символьного типа. Символ — это просто строка длины 1.

Строка считывается со стандартного ввода функцией input().

Для двух строк определена операция сложения (конкатенации), также определена операция умножения строки на число.

>>> 'Hello' + 'World'

'HelloWorld'

>>> 'ABC' * 10

'ABCABCABCABCABCABCABCABCABCABC'

Узнать количество символов (длину строки) можно при помощи функции len (от англ. length — длина):

>>> s = 'Hello'

>>> print(len(s))

Длина строк в Питоне не ограничена или, строго говоря, ограничена объемом выделенной оперативной памяти.

Функция определения длины строки в Python

Узнать количество символов (длину строки) можно при помощи функции len:

>>> S = 'Hello' >>> print(len(S)) 5

Длина строк в Питоне не ограничена или, строго говоря, ограничена объемом выделенной оперативной памяти..

Литералы строк в Python

Литералы строк могут быть записаны в апострофах:

'spa"m'

В кавычках:

"spa'm"

В тройных апострофах или тройных кавычках:

'''spam''', """spam"""

Экранированные последовательности:

"s\tp\na\0m"

Неформатированные строки (\символ не воспринимается как управляющая последовательность):

r"C:\new\test\0012"

Как строки байтов (отдельный тип bytes — каждый символ занимает 1 байт):

b'1wd'

Если в строке нужно вывести обратную косую черту, то ее нужно повторить дважды:

'Symbol \\ can be also used.'

В неформатированных строках не рассматриваются экранированные символы, а все воспринимается как есть:

s=r"C:\new\test\0012"

print(s)

выведет C:\new\test\0012

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

s="C:\\new\\test\\0012"

Строка из нескольких подряд идущих литералов будет неявно конкатенирована даже при отсутствии знака +:

s = 'Infinite' "blue" 'sky'

Строки в тройных кавычках могут содержать несколько строк текста. Пробелы от начала строки входят в текст:

s = """Happy birthday to you,

My darling Findus!

Your hostess."""

Можно добиться того же эффекта и в одинарных кавычках, оставляя в конце каждой строки обратный слэш (но рекомендуется так не делать; после \ не должно быть пробела в конце строки):

s = "Happy birthday to you,\

My darling Findus!\

Your hostess."

Срезы строк в Python

Срез (slice) — извлечение из данной строки одного символа или некоторого фрагмента (подстроки).

Есть три формы срезов. Самая простая форма среза: взятие одного символа строки, а именно, S[i] — это срез, состоящий из одного символа, который имеет номер i, при этом считая, что нумерация начинается с числа 0. То есть если S = ‘Hello’, то S[0]=='H', S[1]=='e', S[2]=='l', S[3]=='l', S[4]=='o'.

Номера символов в строке (а также в других структурах данных: списках, кортежах) называются индексом.
Если указать отрицательное значение индекса, то номер будет отсчитываться с конца, начиная с номера -1. То есть

S[-1]=='o', S[-2]=='l', S[-3]=='l', S[-4]=='e', S[-5]=='H'.

Или в виде таблицы:

Строка S	H	e	l	l	o
Индекс	S[0]	S[1]	S[2]	S[3]	S[4]
Индекс	S[-5]	S[-4]	S[-3]	S[-2]	S[-1]

Если же номер символа в срезе строки S больше либо равен len(S), или меньше, чем -len(S), то при обращении к этому символу строки произойдет ошибка IndexError: string index out of range.

Срез с двумя параметрами: S[a:b] возвращает подстроку из b-a символов, начиная с символа c индексом a, то есть до символа с индексом b, не включая его. Например, S[1:4]==‘ell’, то же самое получится если написать S[-4:-1]. Можно использовать как положительные, так и отрицательные индексы в одном срезе, например, S[1:-1] — это строка без первого и последнего символа (срез начинается с символа с индексом 1 и заканчиватеся индексом -1, не включая его).
При использовании такой формы среза ошибки IndexError никогда не возникает. Например, срез S[1:5] вернет строку ‘ello’, таким же будет результат, если сделать второй индекс очень большим, например, S[1:100] (если в строке не более 100 символов).

Если опустить второй параметр (но поставить двоеточие), то срез берется до конца строки. Например, чтобы удалить из строки первый символ (его индекс равен 0, то есть взять срез, начиная с символа с индексом 1), то можно взять срез S[1:], аналогично если опустить первый параметр, то срез берется от начала строки. То есть удалить из строки последний символ можно при помощи среза S[:-1]. Срез S[:] совпадает с самой строкой S.

Если задать срез с тремя параметрами S[a:b:d], то третий параметр задает шаг, как в случае с функцией range, то есть будут взяты символы с индексами a, a+d, a+2*d и т.д. При задании значения третьего параметра, равному 2, в срез попадет кажый второй символ, а если взять значение среза, равное -1, то символы будут идти в обратном порядке.

ПРИМЕРЫ СРЕЗОВ

На вводе дана строка.

s = input()

Выведем третий символ этой строки.

print(s[2])

Выведем предпоследний символ этой строки.

print(s[-2])

Выведем первые пять символов этой строки.

print(s[0:5])

Выведем всю строку, кроме последних двух символов.

print(s[:-2])

Выведем все символы с четными индексами (считая, что индексация начинается с 0, поэтому символы выводятся начиная с первого).

print(s[::2])

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

print(s[1::2])

Выведем все символы в обратном порядке.

print(s[::-1])

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

print(s[::-2])

Методы строк в Python

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

Имя_объекта.Имя_метода(параметры)

Например, S.find("e") — это применение к строке S метода find с одним параметром "e".

МЕТОДЫ FIND И RFIND

Метод find находит в данной строке (к которой применяется метод) данную подстроку (которая передается в качестве параметра). Функция возвращает индекс первого вхождения искомой подстроки. Если же подстрока не найдена, то метод возвращает значение -1. Например:

>>> S = 'Hello'

>>> print(S.find('e'))

>>> print(S.find('ll'))

>>> print(S.find('L'))

-1

Аналогично, метод rfind возвращает индекс последнего вхождения данной строки (“поиск справа”).

>>> S = 'Hello'

>>> print(S.find('l'))

>>> print(S.rfind('l'))

Если вызвать метод find с тремя параметрами S.find(T, a, b), то поиск будет осуществляться начиная с символа с номером a до символа с номером b (не включительно). Если указать только два параметра S.find(T, a), то поиск будет осуществляться, начиная с a-го элемента до конца строки. Метод S.find(T, a, b) возвращает индекс в строке S, а не индекс относительно начала среза.

МЕТОД REPLACE

Метод replace заменяет все вхождения одной строки на другую. Формат: S.replace(old, new) — заменить в строке S все вхождения подстроки old на подстроку new. Пример:

>>> 'Hello'.replace('l', 'L')

'HeLLo'

Если методу replace задать еще один параметр: S.replace(old, new, count), то заменены будут не все вхождения, а только не больше, чем первые count из них.

>>> 'Abrakadabra'.replace('a', 'A', 2)

'AbrAkAdabra'

МЕТОД COUNT

Подсчитывает количество вхождений одной строки в другую строку. Простейшая форма вызова S.count(T) возвращает число вхождений строки T внутри строки S. При этом подсчитываются только непересекающиеся вхождения, например:

>>> 'Abracadabra'.count('a')

>>> ('a' * 100000).count('aa')

При указании трех параметров S.count(T, a, b), будет выполнен подсчет числа вхождений строки T в срез S[a:b].