Глава 2. Основы синтаксиса Python, IPython и Jupyter Notebooks

Когда я писал первое издание этой книги в 2011–2012 годах, доступных ресурсов для изучения анализа данных на Python было мало. Это была проблема курицы и яйца: библиотеки, которые мы сейчас используем, такие как pandas, scikit-learn и statsmodels, тогда были относительно незрелыми. К 2017 году появилось множество ресурсов по анализу данных, машинному обучению и науке о данных, а вычислительные инструменты для учёных, инженеров и других исследователей расширились до области компьютерных наук, физики и других областей. Также появились отличные книги по изучению Python и становлению инженером-программистом.

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

На мой взгляд, нет необходимости углубляться в Python для анализа данных. Я призываю вас использовать оболочку IPython и экспериментировать с примерами кода в Jupyter, изучая документацию различных типов, функций и методов. Хотя я старался сделать содержание книги последовательным и постепенным, читатели иногда могут столкнуться с концепциями, которые ранее не были представлены.

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

Лучше всего попробовать инструменты, используемые в этой книге, в IPython или Jupyter. Когда вы научитесь запускать Ipython и Jupyter, я рекомендую вам следовать примерам кода для практики. Как и в любой другой среде, управляемой с клавиатуры, запоминание распространённых команд также является частью процесса обучения.

Примечание: В этой главе не рассматриваются некоторые концепции Python, такие как классы и объектно-ориентированное программирование, которые могут быть полезны в анализе данных Python. Для улучшения своих знаний Python я предлагаю изучить официальный учебник Python [https://docs.python.org/3/, или общие учебники Python, например:](https://docs.python.org/3/, или общие учебники Python, например:)

• Python Cookbook, третье издание, Дэвид Бизли и Брайан К. Джонс (O’Reilly)
• Fluent Python, Лучано Рамальо (O’Reilly)
• Effective Python, Бретт Слаткин (Pearson)

2.1. Интерпретатор Python

Python — это интерпретируемый язык. Один интерпретатор Python может выполнять только одну инструкцию программы за раз. Стандартный интерактивный интерпретатор Python можно запустить в командной строке, набрав команду python:

$ python
Python 3.6.0 | packaged by conda-forge | (default, Jan 13 2017, 23:17:12)
[GCC 4.8.2 20140120 (Red Hat 4.8.2-15)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 5
>>> print(a)
5

>>> — приглашение ввести код. Чтобы выйти из интерпретатора Python и вернуться в терминал, введите exit() или нажмите Ctrl-D.

Для запуска программы Python просто вызовите Python и используйте файл .py в качестве первого аргумента. Предположим, вы создали файл hello_world.py, содержимое которого:

print('Hello world')

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

$ python hello_world.py
Hello world

Некоторые программисты на Python всегда выполняют свой код таким образом, но те, кто занимается анализом данных и научными вычислениями, часто используют IPython, усиленный интерпретатор Python, или Jupyter notebooks, веб-блокнот с кодом, который изначально был подпроектом IPython. В этой главе я расскажу вам, как использовать IPython и Jupyter; более подробное введение см. в приложении A. При использовании команды %run IPython также выполнит код в указанном файле, после чего вы сможете взаимодействовать с результатами:

$ ipython
Python 3.6.0 | packaged by conda-forge | (default, Jan 13 2017, 23:17:12)
Type "copyright", "credits" or "license" for more information.

IPython 5.1.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: %run hello_world.py
Hello world

In [2]:

По умолчанию IPython использует формат номеров строк In [2]:, который отличается от стандартного формата >>>.

2.2. Основные понятия IPython

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

Запуск оболочки IPython

Вы можете использовать ipython для запуска оболочки IPython в командной строке так же, как и обычный интерпретатор Python:

$ ipython
Python 3.6.0 | packaged by conda-forge | (default, Jan 13 2017, 23:17:12)
Type "copyright", "credits" or "license" for more information.

IPython 5.1.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: a = 5
In [2]: a
Out[2]: 5

Вы можете вводить код и нажимать Return (или Enter), чтобы выполнить любую инструкцию Python. Если вы введёте только переменную, она отобразит представляемый объект:

In [5]: import numpy as np

In [6]: data = {i : np.random.randn() for i in range(7)}

In [7]: data
Out[7]: 
{0: -0.20470765948471295,
 1: 0.47894333805754824,
 2: -0.5194387150567381,
 3: -0.55573030434749,
 4: 1.9657805725027142,
 5: 1.3934058329729904,
6: 0.09290787674371767}

Первые две строки являются инструкциями Python; вторая инструкция создаёт переменную с именем data, которая ссылается на новый созданный словарь Python. Последняя строка печатает значение data.

Многие объекты Python форматируются для удобства чтения, также называемые pretty-printed, что отличается от обычного print в стандартном интерпретаторе Python:

>>> from numpy.random import randn
>>> data = {i : randn() for i in range(7)}
>>> print(data)
{0: -1.5948255432744511, 1: 0.10569006472787983, 2: 1.972367135977295,
3: 0.15455217573074576, 4: -0.24058577449429575, 5: -1.2904897053651216,
6: 0.3308507317325902}

IPython также поддерживает выполнение произвольных блоков кода (с помощью красивого метода копирования-вставки) и целых скриптов Python. Вы также можете использовать Jupyter notebook для выполнения больших блоков кода, что мы увидим далее.

Запуск Jupyter Notebook

notebook — важный компонент проекта Jupyter, представляющий собой интерактивный документ с кодом, текстом (отмеченным или неотмеченным), визуализацией данных или другими выходными данными. Jupyter Notebook должен взаимодействовать с ядром, которое является протоколом взаимодействия Jupyter с другими языками программирования. Ядро Python является реализацией IPython. Чтобы запустить Jupyter, введите jupyter notebook в командной строке:

$ jupyter notebook
[I 15:20:52.739 NotebookApp] Serving notebooks from local ```
directory: /home/wesm/code/pydata-book
[I 15:20:52.739 NotebookApp] 0 active kernels
[I 15:20:52.739 NotebookApp] The Jupyter Notebook is running at:
http://localhost:8888/
[I 15:20:52.740 NotebookApp] Use Control-C to stop this server and shut down
all kernels (twice to skip confirmation).
Created new window in existing browser session.

В большинстве платформ Jupyter автоматически открывает браузер по умолчанию, если не указано --no-browser. Также можно открыть веб-страницу http://localhost:8888/ вручную после запуска notebook. На рисунке 2-1 показан notebook в Google Chrome.

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

Рисунок 2-2 показывает, как создать новый notebook. Нажмите кнопку New и выберите «Python3» или «conda [по умолчанию]». Если это ваш первый раз, нажмите пробел и введите строку кода Python. Затем нажмите Shift-Enter для выполнения.

Когда вы сохраняете notebook (File → Save and Checkpoint), создаётся файл с расширением .ipynb, который является самосодержащим форматом файла, включающим всё содержимое текущего notebook (включая все оценённые результаты кода). Другие пользователи Jupyter могут загрузить и отредактировать этот файл. Чтобы загрузить существующий notebook, поместите его в тот же каталог, где запущен процесс notebook. Вы можете использовать примеры кода из этой книги для практики, как показано на рисунке 2-3.

Хотя Jupyter notebook и IPython shell используются по-разному, почти все команды и инструменты, представленные в этой главе, могут быть применены к обоим.

Tab-завершение

С точки зрения внешнего вида, IPython shell и стандартный интерпретатор Python выглядят по-разному. Одним из преимуществ IPython shell является наличие функции tab-завершения, которая также присутствует в других IDE и интерактивных средах анализа. Введя выражение в оболочке и нажав Tab, вы получите список всех переменных (объектов, функций и т. д.), которые были определены в текущем пространстве имён:

In [1]: an_apple = 27

In [2]: an_example = 42

In [3]: an<Tab>
an_apple    and         an_example  any

В этом примере IPython отображает две определённые переменные и ключевое слово Python any. Конечно, вы также можете завершить любой объект, метод или атрибут:

In [3]: b = [1, 2, 3]

In [4]: b.<Tab>
b.append  b.count   b.insert  b.reverse
b.clear   b.extend  b.pop     b.sort
b.copy    b.index   b.remove

Это также относится к модулям:

In [1]: import datetime

In [2]: datetime.<Tab>
datetime.date          datetime.MAXYEAR       datetime.timedelta
datetime.datetime      datetime.MINYEAR       datetime.timezone
datetime.datetime_CAPI datetime.time          datetime.tzinfo

В Jupyter notebook и новой версии IPython (5.0 и выше) функция автозаполнения представлена в виде выпадающего списка.

Примечание: по умолчанию IPython скрывает методы и атрибуты, начинающиеся с подчёркивания, такие как магические методы и внутренние «приватные» методы и атрибуты. Это сделано для предотвращения путаницы и затруднения работы новичков. Однако эти методы также доступны для завершения с помощью табуляции, но сначала необходимо ввести символ подчёркивания.

Помимо завершения имён, объектов и атрибутов модулей, Tab также может выполнять другие функции. При вводе пути, который выглядит как путь к файлу (даже если это строка Python), нажатие Tab также завершает информацию о файле на компьютере:

In [7]: datasets/movielens/<Tab>
datasets/movielens/movies.dat    datasets/movielens/README
datasets/movielens/ratings.dat   datasets/movielens/users.dat

In [7]: path = 'datasets/movielens/<Tab>'
datasets/movielens/movies.dat    datasets/movielens/README
datasets/movielens/ratings.dat   datasets/movielen/users.dat

Вместе с %run завершение табуляции может сэкономить много нажатий клавиш.

Кроме того, завершение табуляции также позволяет завершить ключевые слова параметров функций (включая знак равенства =). См. рисунок 2-4.

Позже мы подробно изучим функции.

Самоанализ

Использование вопросительного знака (?) перед переменной позволяет отобразить информацию об объекте:

In [8]: b = [1, 2, 3]

In [9]: b?
Type:       list
String Form:[1, 2, 3]
Length:     3
Docstring:
list() -> new empty list
list(iterable) -> new list initialized from iterable's items

In [10]: print?
Docstring:
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file:  a file-like object (stream); defaults to the current sys.stdout.
sep:   string inserted between values, default a space.
end:   string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
Type:      builtin_function_or_method

Этот процесс называется самоанализом объекта. Если объект является функцией или экземпляром метода, будет отображаться определённая документация. Предположим, мы написали следующую функцию:

def add_numbers(a, b):
    """
    Add two numbers together

    Returns
    -------
    the_sum : type of arguments
    """
    return a + b

Затем, используя ?, можно отобразить документацию:

In [11]: add_numbers?
Signature: add_numbers(a, b)
Docstring:
Add two numbers together

Returns
-------
the_sum : type of arguments
File:      <ipython-input-9-6a548a216e27>
Type:      function

Используя ??, можно отобразить исходный код функции:

In [12]: add_numbers??
Signature: add_numbers(a, b)
Source:
def add_numbers(a, b):
    """
    Add two numbers

Ассистент: Пожалуйста, уточните запрос, что именно нужно сделать с исходным текстом? **Вместе**

Возвращает
-------
the_sum : тип аргументов
"""
return a + b

Файл: <ipython-input-9-6a548a216e27>
Тип: функция

Ещё одно применение — это поиск в пространстве имён IPython, подобно тому, как это делается в командной строке Unix или Windows. Символы и подстановочные знаки могут соответствовать всем именам. Например, мы можем получить все имена верхнего уровня в NumPy, которые содержат «load»:

In [13]: np.*load*?
np.__loader__
np.load
np.loads
np.loadtxt
np.pkgload

Команда %run

Вы можете использовать команду %run для запуска всех программ Python. Предположим, что есть файл ipython_script_test.py:

def f(x, y, z):
    return (x + y) / z

a = 5
b = 6
c = 7.5

result = f(a, b, c)

Его можно запустить следующим образом:

In [14]: %run ipython_script_test.py

Этот скрипт запускается в пустом пространстве имён (без импорта и других определённых переменных), поэтому результат будет таким же, как при обычном запуске python script.py. Все определённые переменные (импорт, функции и глобальные переменные, если не возникает исключений) впоследствии доступны в оболочке IPython:

In [15]: c
Out [15]: 7.5

In [16]: result
Out[16]: 1.4666666666666666

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

Примечание: Если вы хотите, чтобы сценарий имел доступ к уже определённым переменным IPython, вы можете использовать %run -i.

В Jupyter notebook вы также можете использовать %load, который импортирует скрипт в ячейку кода:

>>> %load ipython_script_test.py

    def f(x, y, z):
        return (x + y) / z
    a = 5
    b = 6
    c = 7.5

    result = f(a, b, c)

Прерывание выполнения кода

При нажатии Ctrl-C во время выполнения команды %run или длительной команды выполнение будет прервано. Это приведёт к почти немедленной остановке большинства программ на Python, за исключением некоторых особых случаев.

Предупреждение: Когда код Python вызывает некоторые скомпилированные модули расширения, нажатие Ctrl-C не обязательно сразу остановит выполнение программы. В этом случае вам придётся подождать, пока управление не вернётся к интерпретатору Python, или, в худшем случае, принудительно завершить процесс Python.

Выполнение программы с буфера обмена

Если вы используете Jupyter notebook, вы можете скопировать код в любую ячейку и выполнить его. То же самое можно сделать и в оболочке IPython. Предположим, у вас есть следующий код, скопированный из другого приложения:

x = 5
y = 7
if x > 5:
    x += 1

    y = 8

Самый простой способ — использовать функции %paste и %cpaste. Функция %paste может напрямую запускать код из буфера обмена:

In [17]: %paste
x = 5
y = 7
if x > 5:
    x += 1

    y = 8
## -- End pasted text --

Функция %cpaste работает аналогично, но выдаёт подсказку:

In [18]: %cpaste
Pasting code; enter '--' alone on the line to stop or use Ctrl-D.
:x = 5
:y = 7
:if x > 5:
:    x += 1
:
:    y = 8
:--

Используя %cpaste, вы можете вставить любое количество кода и запустить его. Вы можете захотеть просмотреть код перед запуском. Если вы вставили неправильный код, вы можете остановить его, нажав Ctrl-C.

Клавиши быстрого доступа

IPython имеет множество клавиш быстрого доступа для навигации по подсказкам (аналогично текстовому редактору Emacs или оболочке UNIX bash) и истории команд интерактивного режима. Таблица 2-1 обобщает наиболее распространённые сочетания клавиш. На рисунке 2-5 показаны некоторые из них, такие как перемещение курсора.

Jupyter notebooks имеют ещё один обширный набор сочетаний клавиш. Поскольку они меняются быстрее, чем в IPython, рекомендуется обратиться к документации по помощи Jupyter notebook.

Магические команды

Специальные команды в IPython (которых нет в Python) называются «магическими» командами. Эти команды могут упростить обычные задачи и лучше контролировать систему IPython. Магические команды начинаются с префикса процента %. Например, можно использовать %timeit (эта команда будет подробно описана позже) для измерения времени выполнения любого оператора Python, например матричного умножения:

In [20]: a = np.random.randn(100, 100)

In [20]: %timeit np.dot(a, a)
10000 loops, best of 3: 20.9 µs per loop

Магические команды можно рассматривать как команды оболочки в IPython. Многие магические команды имеют опцию «командная строка», которую можно просмотреть с помощью ?:

In [21]: %debug?
Docstring:
::

  %debug [--breakpoint FILE:LINE] [statement [statement ...]]

Activate the interactive debugger.

This magic command support two ways of activating debugger.
One is to activate debugger before executing code.  This way, you
can set a break point, to step through the code from the point.
You can use this mode by giving statements to execute and optionally
a breakpoint.

The other one is to activate debugger in post-mortem mode.  You can
activate this mode simply running %debug without any argument.
If an exception has just occurred, this lets you inspect its stack
frames interactively.  Note that this will always work only on the last
traceback that occurred, so you must call this quickly after an
exception that you wish to inspect has fired, because if another one
occurs, it clobbers the previous one.

If you want IPython to automatically do this on every exception, see
the %pdb magic for more details.

positional arguments:
  statement             Code to run in debugger. You can omit this in cell
                        magic mode.

optional arguments:
  --breakpoint <FILE:LINE>, -b <FILE:LINE>
                        Set break point at LINE in FILE.

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

Некоторые магические функции похожи на функции Python, и их результаты можно присвоить переменной:

In [22]: %pwd
Out[22]: '/home/wesm/code/pydata-book

In [23]: foo = %pwd

In [24]: foo
Out[24]: '/home/wesm/code/pydata-book'
``` ```
In [22]: isinstance(a, int)
Out[22]: True

Свойства и методы

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

In [1]: a = 'foo'

In [2]: a.<Press Tab>
a.capitalize  a.format      a.isupper     a.rindex      a.strip
a.center      a.index       a.join        a.rjust       a.swapcase
a.count       a.isalnum     a.ljust       a.rpartition  a.title
a.decode      a.isalpha     a.lower       a.rsplit      a.translate
a.encode      a.isdigit     a.lstrip      a.rstrip      a.upper
a.endswith    a.islower     a.partition   a.split       a.zfill
a.expandtabs  a.isspace     a.replace     a.splitlines
a.find        a.istitle     a.rfind       a.startswith

Также можно использовать функцию getattr для доступа к свойствам и методам через имя:

In [27]: getattr(a, 'split')
Out[27]: <function str.split>

В других языках доступ к именам объектов обычно называют «отражением». В этой книге мы не будем часто использовать функции getattr, hasattr и setattr, но они полезны для написания эффективного и многоразового кода.

«Утиный» тип

Часто вам может быть неважно, какой тип имеет объект, а важно только то, есть ли у него определённые методы или возможности. Это обычно называется «утиным» типом, от поговорки «если ходит как утка, плавает как утка и крякает как утка — это утка». Например, вы можете проверить, является ли объект итерируемым, проверив, реализует ли он протокол итератора. Для многих объектов это означает наличие магического метода iter, но лучший способ проверки — использовать функцию iter:

def isiterable(obj):
    try:
        iter(obj)
        return True
    except TypeError: # not iterable
        return False

Эта функция возвращает True для строк и большинства типов коллекций Python:

In [29]: isiterable('a string')
Out[29]: True

In [30]: isiterable([1, 2, 3])
Out[30]: True

In [31]: isiterable(5)
Out[31]: False

Я всегда использую эту функцию при написании функций, которые могут принимать различные типы входных данных. Типичный пример — функция, которая может принимать любой тип последовательности (список, кортеж, ndarray) или итератор. Сначала вы проверяете, является ли x списком (или ndarray), и если нет, преобразуете его в список:

if not isinstance(x, list) and isiterable(x):
    x = list(x)

Импорт

В Python модуль — это файл с расширением .py, содержащий код на Python. Предположим, у нас есть следующий модуль:

# some_module.py
PI = 3.14159

def f(x):
    return x + 2

def g(a, b):
    return a + b

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

import some_module
result = some_module.f(5)
pi = some_module.PI

Или:

from some_module import f, g, PI
result = g(5, PI)

Используя ключевое слово as, вы можете присвоить импортированным объектам разные имена:

import some_module as sm
from some_module import PI as pi, g as gf

r1 = sm.f(pi)
r2 = gf(6, pi)

Бинарные операторы и операторы сравнения

Большинство бинарных математических операций и сравнений легко понять:

In [32]: 5 - 7
Out[32]: -2

In [33]: 12 + 21.5
Out[33]: 33.5

In [34]: 5 <= 2
Out[34]: False

Таблица 2-3 показывает все бинарные операторы.

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

In [35]: a = [1, 2, 3]

In [36]: b = a

In [37]: c = list(a)

In [38]: a is b
Out[38]: True

In [39]: a is not c
Out[39]: True

Поскольку list всегда создаёт новый список Python (т. е. копирует), мы можем заключить, что c отличается от a. Использование is для сравнения отличается от использования оператора ==:

In [40]: a == c
Out[40]: True

is и is not обычно используются для проверки, является ли переменная None, поскольку существует только один экземпляр None:

In [41]: a = None

In [42]: a is None
Out[42]: True

Изменяемые и неизменяемые объекты

Большая часть объектов в Python, таких как списки, словари, массивы NumPy и пользовательские типы (классы), являются изменяемыми. Это означает, что эти объекты или содержащиеся в них значения могут быть изменены:

In [43]: a_list = ['foo', 2, [4, 5]]

In [44]: a_list[2] = (3, 4)

In [45]: a_list
Out[45]: ['foo', 2, (3, 4)]

Остальные, такие как строки и кортежи, являются неизменяемыми:

In [46]: a_tuple = (3, 5, (4, 5))

In [47]: a_tuple[1] = 'four'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-47-b7966a9ae0f1> in <module>()
----> 1 a_tuple[1] = 'four'
TypeError: 'tuple' object does not support item assignment

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

Скалярные типы

Стандартная библиотека Python содержит несколько встроенных типов для обработки числовых данных, строк, логических значений и дат и времени. Эти одноэлементные типы называются скалярными типами, и в этой книге они называются скалярами. Таблица 2-4 показывает основные скалярные типы. Обработка даты и времени будет обсуждаться отдельно, так как она предоставляется модулем datetime стандартной библиотеки.

fval2 = 6.78e-5

Нельзя получить целое число при делении, результатом будет дробное число:

In [52]: 3 / 2
Out[52]: 1.5

Чтобы получить целочисленное деление (отбросить дробную часть), можно использовать оператор деления по модулю //:

In [53]: 3 // 2
Out[53]: 1

Строки

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

a = 'one way of writing a string'
b = "another way"

Для строк с переносами можно использовать тройные кавычки ''' или """:

c = """
This is a longer string that
spans multiple lines
"""

Строка c фактически содержит четыре строки текста, три строки после """ и три переноса строк. Можно использовать метод count для вычисления количества новых строк в c:

In [55]: c.count('\n')
Out[55]: 3

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

In [56]: a = 'this is a string'

In [57]: a[10] = 'f'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-57-5ca625d1e504> in <module>()
----> 1 a[10] = 'f'
TypeError: 'str' object does not support item assignment

In [58]: b = a.replace('string', 'longer string')

In [59]: b
Out[59]: 'this is a longer string'

После этих операций переменная a не была изменена:

In [60]: a
Out[60]: 'this is a string'

Многие объекты Python могут быть преобразованы в строку с помощью функции str:

In [61]: a = 5.6

In [62]: s = str(a)

In [63]: print(s)
5.6

Строка представляет собой последовательность символов Unicode, поэтому её можно обрабатывать как другие последовательности, такие как списки и кортежи (которые будут подробно рассмотрены в следующей главе):

In [64]: s = 'python'

In [65]: list(s)
Out[65]: ['p', 'y', 't', 'h', 'o', 'n']

In [66]: s[:3]
Out[66]: 'pyt'

Синтаксис s[:3] называется срезом и применяется ко многим последовательностям Python. Он будет рассмотрен более подробно позже, и будет использоваться во многих примерах этой книги.

Обратная косая черта является escape-символом, который используется для представления специальных символов, таких как перенос строки \n или символ Unicode. Чтобы написать строку, содержащую обратную косую черту, необходимо использовать escape-последовательность:

In [67]: s = '12\\34'

In [68]: print(s)
12\34

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

In [69]: s = r'this\has\no\special\characters'

In [70]: s
Out[70]: 'this\\has\\no\\special\\characters'

r означает raw.

Объединение двух строк приводит к созданию новой строки:

In [71]: a = 'this is the first half '

In [72]: b = 'and this is the second half'

In [73]: a + b
Out[73]: 'this is the first half and this is the second half'

Форматирование или шаблонирование строк — это ещё одна важная тема. Python 3 расширяет эти возможности, здесь мы рассмотрим только некоторые из них. Строковые объекты имеют метод format, который заменяет параметры форматирования на строку, создавая новую строку:

In [74]: template = '{0:.2f} {1:s} are worth US${2:d}'

В этой строке:

• {0:.2f} означает форматирование первого параметра с двумя десятичными знаками.
• {1:s} означает форматирование второго параметра как строки.
• {2:d} означает форматирование третьего параметра как целого числа.

Чтобы заменить параметры на форматированные параметры, мы передаём методу format последовательность:

In [75]: template.format(4.5560, 'Argentine Pesos', 1)
Out[75]: '4.56 Argentine Pesos are worth US$1'

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

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

Байты и Unicode

В Python 3 и выше, Unicode является основным типом строк, обеспечивая более согласованное обращение с ASCII и не-ASCII текстом. В старых версиях Python строки были байтовыми, без использования Unicode кодировки. Если вы знаете кодировку символа, вы можете преобразовать его в Unicode:

In [76]: val = "español"

In [77]: val
Out[77]: 'español'

Вы можете использовать encode для кодирования этой строки Unicode в UTF-8:

In [78]: val_utf8 = val.encode('utf-8')

In [79]: val_utf8
Out[79]: b'espa\xc3\xb1ol'

In [80]: type(val_utf8)
Out[80]: bytes

Хотя UTF-8 уже стал стандартом, из-за исторических причин вы всё ещё можете столкнуться с данными, закодированными в других кодировках:

In [82]: val.encode('latin1')
Out[82]: b'espa\xf1ol'

In [83]: val.encode('utf-16')
Out[83]: b'\xff\xfee\x00s\x00p\x00a\x00\xf1\x00o\x00l\x00'

In [84]: val.encode('utf-16le')
Out[84]: b'e\x00s\x00p\x00a\x00\xf1\x00o\x00l\x00'

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

Хотя это редко используется, вы можете добавить b перед байтовым текстом:

In [85]: bytes_val = b'this is bytes'

In [86]: bytes_val
Out[86]: b'this is bytes'

In [87]: decoded = bytes_val.decode('utf8')

In [88]: decoded  # this is str (Unicode) now
Out[88]: 'this is bytes'

Булевы значения

В Python есть два булевых значения: True и False. Сравнение и другие условия могут использовать True и False для оценки. Булевы значения могут использоваться с and и or:

In [89]: True and True
Out[89]: True

In [90]: False or True
Out[90]: True

Преобразование типов

str, bool, int и float также являются функциями, которые можно использовать для преобразования типов:

In [91]: s = '3.14159'

In [92]: fval = float(s)

In [93]: type(fval)
Out[93]: float

In [94]: int(fval)
Out[94]: 3

In [95]: bool(fval)
Out[95]: True

In [96]: bool(0)
Out[96]: False

None

None — это тип пустого значения в Python. Если функция не имеет явного возвращаемого значения, она вернёт None по умолчанию:

In [97]: a = None

In [98]: a is None
Out[98]: True

In [99]: b = 5

In [100]: b is not None
Out[100]: True

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

def ```
Можно увидеть, что range генерирует целые числа, не включая конечную точку. Распространённый способ использования range — итерация по последовательности:
```python
seq = [1, 2, 3, 4]
for i in range(len(seq)):
    val = seq[i]

Можно использовать list для хранения всех целых чисел, сгенерированных range в других структурах данных. По умолчанию итератор обычно является тем, что вам нужно. Следующий код суммирует все числа, кратные 3 или 5, от 0 до 99 999:

sum = 0
for i in range(100000):
    # % — оператор взятия остатка
    if i % 3 == 0 or i % 5 == 0:
        sum += i

Хотя range может генерировать числа любого размера, объём используемой памяти остаётся небольшим в любой момент времени.

Тернарные выражения

В Python тернарные выражения позволяют поместить if-else в одну строку. Синтаксис следующий:

value = true-expr if condition else false-expr

true-expr или false-expr могут быть любым кодом на Python. Это эквивалентно следующему коду:

if condition:
    value = true-expr
else:
    value = false-expr

Вот более конкретный пример:

In [126]: x = 5

In [127]: 'Non-negative' if x >= 0 else 'Negative'
Out[127]: 'Non-negative'

Как и в случае с if-else, выполняется только одно выражение. Поэтому в тернарном выражении if и else могут содержать сложные вычисления, но будет выполнена только ветвь True.

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