Как отделяются строки в программировании

Строки и работа с символами — Введение в программирование

Сейчас вы уже знаете, что здесь происходит вызов функции, а функция console.log принимает аргумент. В данном случае аргумент — не число, а "строка". Так мы называем фрагменты текста в программировании, потому что они как последовательность букв на веревке.

Строки есть везде. Сейчас я читаю сценарий, и текстовый файл — это длинная строка. Веб-сайт, на котором вы смотрите эти видео, содержит множество слов — всё это строки. Работа Google запоминать строки — в этом суть поиска. Файлы и папки в вашем компьютере идентифицируются через их названия, которые так же являются всего лишь строками.

Так же, как мы это делали с числами, мы можем создать константу из строки:

const str = "Hello"; 

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

Если вам необходимо использовать реальные кавычки внутри строки, тогда используйте другой знак для её создания. Например:

const str = 'They call him "Harry", and he likes it'; ///They call him "Harry", and he likes it 

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

const str = "They call him 'Harry', and he likes it"; /// They call him 'Harry', and he likes it 

Двойные снаружи — одиночные внутри.

Но что делать, если такое невозможно, и вам нужно использовать одинаковый тип кавычек и для формулировки строки и внутри неё. Если вы попробуете сделать так

const str = "They call him "Harry", and he likes it"; 

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

Нам нужно объяснить интерпретатору JavaScript, что некоторые кавычки он должен воспринимать иначе. Они не должны означать "начало строки" или "конец строки", они должны означать "символ кавычек".

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

const str = "They call him \"Harry\", and he likes it"; const str2 = 'They call her \'Ann\', and she likes it'; // They call him "Harry", and he likes it // They call her 'Ann', and she likes it 

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

Тут есть три момента.

Первый: если нам нужен обратный слеш в строке, то он должен быть экранирован другим обратным слешем.

Второе: обратный слеш-t это не "экранируемый t-символ": вам не нужно экранировать "t", "t" — это не специальный символ; вся конструкция обратный слеш-t — это специальная управляющая последовательность — она представляет собой единичную табуляцию, по сути — длинный пробел.

Третье: обратный слеш-n — это другая управляющая последовательность, которая представляет собой новую строчку. Считай, что вы нажмёте клавишу Enter, когда набираете текст. Поэтому, всё, что следует дальше, перейдет на новую строчку .

Теперь давайте попробуем написать функцию. Она будет принимать строку — имя и возвращать другую строку — приветствие. Вот как это должно работать:

const result = greet("Sherlock"); // "Well hello, Sherlock" 

Эта функция должна уметь каким-то образом принимать входящую строку и склеивать её с другой строкой. Такой процесс называется "конкатенацией" и в JavaScript он реализуется знаком плюс, как при сложении чисел:

const greet = (str) =>  return "Well hello, " + str; > 

Теперь другой пример. Эта функция принимает строку и возвращает ту же строку, но без каждой второй буквы. Например, "California" становится "Clfri".

const skip = (str) =>  let i = 0; let result = ''; while (i  str.length)  result = result + str[i]; i = i + 2; > return result; > 

Такие квадратные скобки позволяют нам получать индивидуальные символы из строки. Как и во многих процессах в программировании, вы начинаете отсчёт с 0, а не от 1. Поэтому первый символ str это str[0] , второй — str[1] , и так далее. Это число называется "индексом".

Функция skip принимает аргумент, создаёт две переменных — i для счётчика и result для итоговой строки. Счётчик — это 0, потому что нам нужно начать с первого символа, а result это пустая строка — мы будем добавлять символы к ней один за другим.

Затем следует цикл while, с условием , что "i меньше, чем длина строки". Длина означает "сколько символов". Длина строки "cats" — 4 — в ней 4 символа, 4 буквы.

Пока счётчик меньше, чем длина, мы склеиваем или конкатенируем результирующую строку с символом по индексу i. Затем добавляем 2 к счётчику. Два, а не один, потому что нам нужно пропустить один символ.

В какой-то момент счетчик станет достаточно большим для того, чтобы условие цикла стало ложным, и функция вернёт result .

Давайте попробуем вызвать функцию с аргументом 'cats':

const skipped = skip('cats'); 

Длина 'cats' — 4. Несмотря на то, что индексы начинаются с 0, длина — это действительное количество. 'c' — не 0 букв, это одна буква. Поэтому длина 'cats' — 4, но индекс его последней буквы — 3.

1. 0 меньше четырёх, поэтому войти в цикл while
2. конкатенировать строку с символом по индексу 0 — это 'c'
3. увеличить счётчик на 2
4. 2 меньше 4, поэтому повторить
5. конкатенировать строку с символом по индексу 2 — это 't'. строка теперь стала 'ct'
6. увеличить счётчик на 2
7. 4 не меньше 4, поэтому больше не повторять
8. вернуть результат — 'ct'

Вас ждут тест и практическое упражнение.

Дополнение к уроку

Неизменяемость

В JavaScript строки являются неизменяемыми, так же говорят "immutable". Это означает, что какие бы вы к ним не применяли функции, они не производят in-place замены (то есть не производят изменения самой строки). Любые строковые функции, примененные к строкам, возвращают новую строку. Это верно и в том случае, когда мы обращаемся к конкретному символу в строке.

const str = 'hello'; // toUpperCase возвращает ту же строку в верхнем регистре str.toUpperCase(); // HELLO console.log(str); // => hello str[0].toUpperCase(); // H console.log(str); // => hello str[0] = 'W'; console.log(str); // => hello 

Лексикографический порядок

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

В JavaScript вы можете сравнивать строки с помощью > и < , и сравнение будет происходить именно лексикографически.

'a'  'b' // true 'a' > 'b' // false 'abc' > 'abc' // false 'abb' > 'abc' // false 'abd' > 'abc' // true 

Помните, '8' это не число, а строка.

Интерполяция

Кроме одиночных '' и двойных кавычек "" , современный JavaScript содержит обратные тики (backticks):

С обратными тиками вы можете использовать интерполяцию, вместо конкатенации. Вот, смотрите:

const name = "Alex"; const a = 10; const b = 12; console.log(`His name was $name> and his age was $a + b>`); 

Такой код выведет на экран His name was Alex and his age was 22 . Внутрь $<> вы можете поместить любое выражение.

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

Интерполяция предпочтительнее конкатенации. Мы советуем не использовать конкатенацию вообще. Вот некоторые из причин:

• Такой код заставляет больше думать, потому что синтаксически + больше смахивает на сложение.
• Из-за слабой типизации можно легко получить не тот результат. Конкатенация может породить ошибки.
• Сложные строки при использовании конкатенации невозможно нормально разобрать в голове и понять, как они устроены.

Выводы

• Строка — это последовательность символов
• Пустая строка — это тоже строка (последовательность нуля символов)
• Обозначается единичными или двойными кавычками

Создание строки с константой:

const str1 = "Hello"; const str2 = 'Hello'; 

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

const str1 = 'They call him "Harry", and he likes it'; const str2 = "They call him 'Harry', and he likes it"; 

Если в строке используются кавычки того же типа, они должны быть экранированы с помощью обратного слеша \ :

const str1 = 'They call her \'Ann\', and she likes it'; const str2 = "They call her \"Ann\", and she likes it"; 

Если строка включает обратный слеш (именно как символ, который хочется иметь в строке), он должен быть экранирован другим обратным слешем:

const str = "This is a backslash \\ here" // This is a backslash \ here 

Также существуют управляющие символы — специальные комбинации, которые генерируют невидимые детали:

const str = "There is a tab \t and here \ncomes the new line!" // Here is a tab and here // comes the new line! 

\t — это табуляция, \n это перенос на новую строку.

Конкатенация строк

Строки могут склеиваться друг с другом. Такой процесс называется конкатенацией и задаётся символом + :

const name = "Alex"; const age = 22; console.log("His name is " + name + " and his age is " + age); // His name is Alex and his age is 22 

Строки будут склеены в том порядке, в котором они указаны: "mos" + "cow" → "moscow" , а "cow" + "mos" → "cowmos"

Доступ к индивидуальным символам

str[i] это i-ый символ строки str , начинающейся с 0. Например, "hexlet"[0] это h , а "hexlet"[2] это x .

Вот функция, которая принимает строку и возвращает копию этой строки без каждой второй буквы. Например, "hexlet" становится "hxe".

const skip = (str) =>  let i = 0; let result = ''; while (i  str.length)  result = result + str[i]; i = i + 2; > return result; > 

str.length это длина str , то есть количество символов. Это просто количество, поэтому мы не начинаем отсчёт от 0. Например, "food".length это 4.

Дополнительные материалы

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты

Об обучении на Хекслете

• Статья «Как учиться и справляться с негативными мыслями»
• Статья «Ловушки обучения»
• Статья «Сложные простые задачи по программированию»
• Урок «Как эффективно учиться на Хекслете»
• Вебинар « Как самостоятельно учиться »

Открыть доступ

Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно

• 130 курсов, 2000+ часов теории
• 1000 практических заданий в браузере
• 360 000 студентов

Наши выпускники работают в компаниях:

Строки в Python

Строка — это последовательность символов.

Символ — это просто одиночный символ. Например, в английском языке 26 символов, букв.

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

Преобразование символа в число называется кодированием, а обратный процесс — декодированием. О самых известных стандартах кодирования вы, скорее всего, слышали. Это ASCII и Unicode.

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

Как создать строку

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

# все способы ниже эквиваленты: они делают одно и то же my_string = 'Привет' print(my_string) my_string = "Привет" print(my_string) my_string = '''Привет''' print(my_string) # тройные кавычки позволяют создавать многострочные строки my_string = """Привет, добро пожаловать в мир Python""" print(my_string)

Вывод:

Привет
Привет
Привет
Привет, добро пожаловать 
в мир Python

Как получить доступ к символам в строке

1. По индексу

Получить доступ к отдельным символам в строке можно стандартным способом — по индексу.

Примечание. Первый элемент в строке (то есть первый символ) Python имеет индекс 0.

Индекс всегда должен быть целым числом, поэтому тип float не подойдет. Использование в качестве индекса числа с плавающей точкой приведет к ошибке TypeError.

Если вы попытаетесь получить доступ к символу с индексом, который больше длины строки, Python выдаст ошибку IndexError.

Индекс не обязательно должен быть положительным числом. Python поддерживает и «отрицательную индексацию». Индекс -1 ссылается на последний символ, -2 — на предпоследний и так далее.

2. С помощью среза

Получить доступ к символам в строке можно и с помощью слайсинга (от англ. «нарезание»). Таким способом удобно получать набор символов в заданном диапазоне.

Срезы задаются с помощью квадратных скобов [] и 2-3 аргументов через двоеточие : .

my_collection[старт:стоп:шаг]

string = 'codechick' print('string = ', string) #первый символ print('string[0] = ', string[0]) #последний символ print('string[-1] = ', string[-1]) #срез от 2 до 5 символа print('string[1:5] = ', string[1:5]) #срез от 6 до предпоследнего символа print('string[5:-2] = ', string[5:-2])

Вывод:

string = codechick
string[0] = c
string[-1] = k
string[1:5] = odec
string[5:-2] = hi

Если мы попытаемся получить доступ к символу с индексом вне допустимого диапазона или использовать не целые числа, получим ошибку.

Помните строку my_string?

# длина строки my_string = 6 символов, а мы пытаемся получить 15 символ
>>> my_string[15] 
. 
IndexError: string index out of range

# индекс должен быть целым числом
>>> my_string[1.5] 
. 
TypeError: string indices must be integers

Как изменить или удалить строку

Строка — неизменяемый тип данных. Это значит, что мы не можем изменить элементы строки после создания. Зато можем переназначать разные строки одной и той же переменной.

>>> my_string = 'codechick'
>>> my_string[5] = 'a'
. 
TypeError: 'str' object does not support item assignment

>>> my_string = 'Python' >>> my_string 'Python'

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

>>> del my_string[1]
. 
TypeError: 'str' object does not support item deletion

>>> del my_string
>>> my_string
. 
NameError: name 'my_string' is not defined

Строковые операции

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

Конкатенация строк

Конкатенация — это объединение двух или более строк в одну.

Эту операцию в Python выполняет оператор + . А с помощью оператора * можно повторить строку заданное количество раз — «умножить» строку на число.

string1 = 'Привет, ' string2 ='мир!' # используем + print('string1 + string2 = ', string1 + string2) # используем * print('string1 * 3 =', string1 * 3)

Вывод:

string1 + string2 = Привет, мир!
string1 * 3 = Привет, Привет, Привет,

Если просто написать рядом два строковых литерала, они тоже объединятся в одну строку. Еще можно использовать круглые скобки. Давайте рассмотрим пример.

>>> # два строковых литералы записаны вместе >>> 'Привет, ''мир!' 'Привет, мир!' >>> # круглые скобки объединяют строковые литералы >>> s = ('Привет, ' . 'мир') >>> s 'Привет, мир'

Итерирование по строке

В Python можно «пройтись» по строке, то есть перебрать все символы в ней. Для этого нужно использовать цикл for.

count = 0 for letter in 'Привет, мир!': if (letter == 'и'): count += 1 print(count, 'буквы «и» в данной строке') 

Вывод:

2 буквы «и» в данной строке

Проверка на вхождение

В Python можно проверить, находится ли данная подстрока в строке или нет с помощью операторов членства in и not in .

>>> 'chick' in 'codechick' True >>> 'code' not in 'codechick' False

Функции для работы со строками

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

Самые полезные:

• enumerate() — позволяет перебирать строку, отслеживая индекс текущего элемента.
• len() — возвращает длину строки.

string = 'кодер' # enumerate() list_enumerate = list(enumerate(string)) print('list(enumerate(string) = ', list_enumerate) # считаем количество символов print('len(string) = ', len(string))

Вывод:

list(enumerate(string) = [(0, 'к'), (1, 'о'), (2, 'д'), (3, 'е'), (4, 'р')]
len (string) = 5

Методы строк

Разбивает строки по заданном разделителю (по умолчанию — пробел)

«Собирает» строку из списка с разделителем

find(подстрока, начало, конец)

Поиск подстроки в строке. Возвращает индекс первого вхождения слева. Если подстроки в строке нет, возвращает -1

index(подстрока, начало, конец)

Поиск подстроки в строке. Возвращает индекс первого вхождения. Если подстроки в строке нет, возвращает ValueError

Замена шаблона в строке

Проверяет, состоит ли строка из цифр. Возвращает True или False

Проверяет, состоит ли строка из букв. Возвращает True или False

Проверяет, состоит ли строка из символов в нижнем регистре. Возвращает True или False

Проверяет, состоит ли строка из символов в верхнем регистре. Возвращает True или False

Преобразует строку к верхнему регистру

Преобразует строку к нижнему регистру

Преобразует символ в ASCII-код

Преобразует ASCII-код в символ

>>> "CoDeCHicK".lower() 'codechick' >>> "CoDeCHicK".upper() 'CODECHICK' >>> "Эта инструкция разобьет строку и засунет элемент в список".split() ['Эта', 'инструкция', 'разобьет', 'строку', 'и', 'засунет', 'элемент', 'в', 'список'] >>> ' '.join(['Эта', 'инструкция', 'соберет', 'все', 'слова', 'в', 'одну', 'строку']) 'Эта инструкция соберет все слова в одну строку' >>> 'Счастливого Рождества!r'.find('ож') 13 >>> 'Счастливого Рождества!'.replace('Счастливого', 'Чудесного') 'Чудесного Рождества!'

Как форматировать строки

Управляющие последовательности

Допустим, нам нужно напечатать на экран такое сообщение: He said, "What's there?" (Он сказал: «Что там?»). Проблема в том, что в этом тексте есть и двойные, и одинарные кавычки (апостроф), поэтому мы не можем использовать их для создания строки — это приведет к ошибке SyntaxError.

>>> print("He said, "What's there?"")
. 
SyntaxError: invalid syntax

>>> print('He said, "What's there?"')
. 
SyntaxError: invalid syntax

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

Есть два способа обойти эту проблему: использовать тройные кавычки или escape-последовательности — их еще иногда называют управляющими последовательностями.

Вот, как это выглядит на практике.

# с помощью тройных кавычке print('''He said, "What's there?"''') # escape-последовательность и одинарные кавычки print('He said, "What\'s there?"') # escape-последовательность и двойные кавычки print("He said, \"What's there?\"") 

Вывод:

He said, "What's there?"
He said, "What's there?"
He said, "What's there?"

Список escape-последовательностей

Управляющая последовательность

Экранирование обратного слэша

Экранирование одинарной кавычки

Экранирование двойной кавычки

Звуковой сигнал или предупреждение

Возврат на одну позицию

Перенос строки на новую

>>> print("C:\\Python32\\Lib") C:\Python32\Lib >>> print("Это сообщение печатается\на двух строках") Это сообщение печатается на двух строках

Игнорирование управляющих последовательностей

Чтобы Python проигнорировал escape-последовательность в строке, можно написать перед этой строкой r или R .

>>> print("Это \nхороший пример") Это хороший пример >>> print(r"Это \nхороший пример") Это \nхороший пример

Метод format()

Метод format() — очень гибкий и мощный инструмент для форматирования строк. В качестве заполнителей используются фигурные скобки <> .

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

# порядок по умолчанию default_order = "<>, <> и <>".format('Петя','Ваня','Катя') print('\n--- Порядок по умолчанию ---') print(default_order) # порядок с позиционными аргументами positional_order = ", и ".format('Петя','Ваня','Катя') print('\n--- Позиционный порядок ---') print(positional_order) # порядок по ключевым словам keyword_order = ", и ".format(j='Петя',b='Петя',s='Катя') print('\n--- Порядок по ключевым словам ---') print(keyword_order)

Вывод:

--- Порядок по умолчанию ---
Петя, Ваня и Катя

--- Позиционный порядок ---
Ваня, Петя и Катя

--- Порядок по ключевым словам ---
Катя, Ваня и Петя

У метода format() есть дополнительные настройки. Они отделяются от имени поля двоеточием : . Например, строку можно выровнять по левому краю < , по правому краю >или центрировать ее ^ .

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

>>> # форматирование целых чисел >>> "Двоичное запись числа = ".format(12) 'Двоичная запись числа 12 = 1100' >>> # форматирование чисел с плавающей точкой >>> "Экспоненциальное представление: ".format(1566.345) 'Экспоненциальное представление: 1.566345e+03' >>> # округление >>> "Одна треть = ".format(1/3) 'Одна треть = 0.333' >>> # выравнивание строк >>> "|||10>|".format('масло', 'булка', 'колбаса') '|масло | булка | колбаса|'

Правила оформления Python-кода

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

 def no_tab_using(): no_tab = 'Using 4 spaces' 

 def use_tab(): one_tab_using = 'Ugly' 

2. Точки с запятой

Не разделяйте ваши строки с помощью точек с запятой и не используйте точки с запятой для разделения команд, находящихся на одной строке.

 a = 'String' b = 15 c = 7.2 

 a = 'String'; b = 15; c = 7.2; 

3. Скобки

Используйте скобки экономно. Не используйте их с выражением return или с условной конструкцией, если не требуется организовать перенос строки. Однако скобки хорошо использовать для создания кортежей.

 if budget < 0: return False # ------------------- while counter  

 if (budget < 0): return (False) # ------------------- if not(line): continue # ------------------- return (result) 

 pineapple(pine[1], ) 

 pineapple( pine[ 1 ], < apple: 2 >) 

 get_number_of_guests(1) 

 get_number_of_guests (1) 

 dish['ingredients'] = cook_book[:3] 

 dish ['ingredients'] = cook_book [:3] 

 if number_of_goods == 4: print(number_of_goods, total_price) 

 if number_of_goods == 4 : print(number_of_goods , total_price) 

 counter == 1 

 counter  

 price = 1000 price_with_taxes = 1200 price_with_taxes_and_discounts = 1100 

 price = 1000 price_with_taxes = 1200 price_with_taxes_and_discounts = 1100 

 def complex(real, imag=0.0): return magic(r=real, i=imag) 

 def complex(real, imag = 0.0): return magic(r = real, i = imag) 

 style_object(self, width, height, color='black', design=None, emphasis=None, highlight=0) if (width == 0 and height == 0 and color == 'red' and emphasis == 'strong'): 

 long_string = ('This will build a very long long ' 'long long long long long long string') 

 # See details at # http://www.example.com/example/example/example/example/example/example/example_example.html 

 # See details at # http://www.example.com/example/example/example/example/example/\ # example/example_example.html 

 with open('/path/to/some/file/you/want/to/read') as file_1, \ open('/path/to/some/file/being/written', 'w') as file_2: file_2.write(file_1.read()) 

 import os . . class MyClass: . def __init__(self): self.name = 'My name' . def f(self): return 'hello world' . . def MyFunc(): i = 12345 return i . myclass = MyClass() 

 long_name = 'Хорошее имя переменной' L = 'Допустимо, но лучше избегать' 

 l = 1 I = 1 O = 0 

 import my_module 

 import my-module 

 my_variable = 'Variable' 

 __myvariable__ = 'Variable' 

 my_variable = 'Variable' 

 My-Variable = 'Variable' 

 import vkapi 

 import My-First-VKontakte-API-Modul 

 class MyFirstClass: 

 MAX_OVERFLOW = 10 TOTAL = 100 

 counter = counter + 1 # Increment counter 

 """Return something useful Optional plotz says to frobnicate the bizbaz first. """ 

 colors = ['red', 'green', 'blue', 'yellow'] for color in colors: print(color) 

 colors = ['red', 'green', 'blue', 'yellow'] for i in range(len(colors)): print(colors[i]) 

 colors = ['red', 'green', 'blue', 'yellow'] for color in reversed(colors): print(color) 

 colors = ['red', 'green', 'blue', 'yellow'] for i in range(len(colors)-1, -1, -1): print(colors[i]) 

 for i in range(6): print(i**2) 

 for i in [0, 1, 2, 3, 4, 5]: print(i**2) 

 colors = ['red', 'green', 'blue', 'yellow'] for i, color in enumerate(colors): print(i, '-->', color) 

 colors = ['red', 'green', 'blue', 'yellow'] for i in range(len(colors)): print(i, '-->', colors[i]) 

 names = ['raymond', 'rachel', 'matthew'] colors = ['red', 'green', 'blue', 'yellow'] for name, color in zip(names, colors): print(name, '-->', color) 

 names = ['raymond', 'rachel', 'matthew'] colors = ['red', 'green', 'blue', 'yellow'] n = min(len(names), len(colors)) for i in range(n): print(names[i], '-->', colors[i]) 

 import os import sys 

 import sys, os 

 from subprocess import Popen, PIPE 

 import foo from foo import bar from foo.bar import baz from foo.bar import Quux from Foob import ar 

 import mypkg.sibling from mypkg import sibling from mypkg.sibling import example 

 from . import sibling from .sibling import example