One place for hosting & domains

      Индексация

      Индексация и разделение строк в Python 3


      Введение

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

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

      Индексация строк

      Как и тип данных списка, который содержит элементы, соответствующие индексу, строки также содержат символы, которым соответствуют индексы, начиная с 0.

      Для строки Sammy Shark! индекс выглядит следующим образом:

      S a m m y S h a r k !
      0 1 2 3 4 5 6 7 8 9 10 11

      Как видите, первая S начинается с индекса 0, а заканчивается строка символом ! с индексом 11.

      Также отметим, что символу пробела между Sammy и Shark также соответствует собственный индекс. В данном случае пробелу соответствует индекс 5.

      Восклицательному знаку (!) также соответствует индекс. Все другие специальные символы и знаки препинания, в том числе *#$&. ;?, также являются символами и будут иметь свои индексы.

      Поскольку каждый символ в строке Python имеет свой индекс, мы можем получать доступ к строкам и совершать с ними манипуляции так же, как и с другими типами последовательных данных.

      Доступ к символам через положительный числовой индекс

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

      ss = "Sammy Shark!"
      print(ss[4])
      

      Output

      y

      Когда мы ссылаемся на определенный числовой индекс строки, Python возвращает символ, находящийся на соответствующей позиции. Поскольку букве y соответствует индекс 4 строки ss = "Sammy Shark!", когда мы выводим ss[4], мы получаем y в качестве вывода.

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

      Доступ к символам через отрицательный индекс

      Если у нас имеется длинная строка, и мы хотим использовать символ ближе к концу строки, мы также можем использовать обратный отсчет от конца строки, начиная с индекса -1.

      Для той же строки Sammy Shark! отрицательная разбивка индекса выглядит следующим образом:

      S a m m y S h a r k !
      -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

      Используя отрицательные индексы, мы можем вывести символ r, используя ссылку на его положение в индексе -3, как показано в следующей последовательности:

      print(ss[-3])
      

      Output

      r

      Использование отрицательных индексов может быть полезно для изоляции отдельных символов ближе к концу длинной строки.

      Разделение строк

      Также мы можем вызвать ряд символов из строки. Допустим, мы хотим вывести слово Shark. Для этого мы можем создать срез, представляющий собой последовательность символов в исходной строке. С помощью срезов мы можем вызывать несколько значений символов, создавая диапазоны символов, разделенные двоеточием [x:y]:

      print(ss[6:11])
      

      Output

      Shark

      При построении среза, такого как [6:11], первый индекс соответствует началу среза (включительно), а второй — окончанию среза (не включительно). Поэтому в нашем примере конец диапазона обозначается индексом позиции сразу после конца строки.

      При разделении строк на срезы мы создаем подстроки, то есть, строки внутри других строк. Вызывая ss[6:11], мы вызываем подстроку Shark, существующую в строке Sammy Shark!.

      Если мы хотим включить любой конец строки, мы можем пропустить одно из чисел в синтаксисе string[n:n]. Например, если нам нужно вывести первое слово строки ss — “Sammy”, мы можем сделать это так:

      print(ss[:5])
      

      Output

      Sammy

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

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

      print(ss[7:])
      

      Output

      hark!

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

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

      Давайте используем два отрицательных индекса для создания среза строки ss:

      print(ss[-4:-1])
      

      Output

      ark

      Подстрока “ark” выводится из строки “Sammy Shark!”, потому что символ “a” соответствует индексу -4, а символ “k” находится перед позицией индекса -1.

      Определение шага при создании срезов строк

      В дополнение к двум индексам при создании срезов можно использовать третий параметр. Третий параметр указывает шаг, означающий, на сколько символов нужно сдвинуться после извлечения первого символа из строки. В предыдущих примерах мы не использовали параметр шага, а по умолчанию Python использует значение шага 1, выводя все символы между двумя индексами.

      Давайте снова посмотрим на пример выше, который выводит подстроку “Shark”:

      print(ss[6:11])
      

      Output

      Shark

      Мы можем получить те же результаты, добавив третий параметр шага со значением 1:

      print(ss[6:11:1])
      

      Output

      Shark

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

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

      print(ss[0:12:2])
      

      Output

      SmySak

      Если мы зададим шаг 2 как последний параметр в синтаксисе Python ss[0:12:2], будет пропущен каждый второй символ. Выводимые символы обозначены красным цветом:

      Sammy Shark!

      Обратите внимание, что символ пробела с индексом 5 также пропускается, если задан шаг 2.

      Если мы используем более крупное значение шага, подстрока будет значительно короче:

      print(ss[0:12:4])
      

      Output

      Sya

      Если мы укажем шаг 4 как последний параметр синтаксиса Python ss[0:12:4], будет выведен только каждый четвертый символ. Выводимые символы также обозначены красным цветом:

      Sammy Shark!

      В этом примере символ пробела тоже пропускается.

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

      print(ss[::4])
      

      Output

      Sya

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

      Также мы можем указать отрицательное значение шага и использовать его для вывода исходной строки в обратном порядке, если зададим шаг -1:

      print(ss[::-1])
      

      Output

      !krahS ymmaS

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

      Давайте повторим эту команду, но используем шаг -2:

      print(ss[::-2])
      

      Output

      !rh ma

      В этом примере, ss[::-2], мы включаем в диапазон всю первоначальную строку, поскольку индексы не указаны, и задаем обратный порядок вывода отрицательным значением шага. Кроме того, с шагом -2 мы пропускаем каждую вторую букву строки, выводимой в обратном порядке:

      ! krahS[пробел]ymmaS

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

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

      Методы подсчета

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

      Вначале мы рассмотрим метод len(), который поможет определить длину любого типа данных упорядоченной или неупорядоченной последовательности, включая строки, списки, кортежи и словари.

      Давайте выведем длину строки ss:

      print(len(ss))
      

      Output

      12

      Длина строки “Sammy Shark!” составляет 12 символов, включая символ пробела и символ восклицательного знака.

      Вместо использования переменной мы также можем передать строку прямо в метод len():

      print(len("Let's print the length of this string."))
      

      Output

      38

      Метод len() подсчитывает общее количество символов в строке.

      Если нам нужно подсчитать, сколько раз в строке встречается определенный символ или последовательность символов, мы можем использовать метод str.count(). Давайте возьмем нашу строку ss = "Sammy Shark!" и подсчитаем, сколько раз в ней встречается символ “a”:

      print(ss.count("a"))
      

      Output

      2

      Мы можем поискать и другой символ:

      print(ss.count("s"))
      

      Output

      0

      Хотя в строке есть буква “S”, важно понимать, что при подсчете учитывается регистр. Если мы хотим найти все буквы в строке независимо от регистра, мы можем использовать метод str.lower(), чтобы предварительно конвертировать все символы строки в нижний регистр. Вы можете узнать больше об этом методе в учебном модуле Введение в методы строк в Python 3.

      Давайте попробуем использовать str.count() с последовательностью символов:

      likes = "Sammy likes to swim in the ocean, likes to spin up servers, and likes to smile."
      print(likes.count("likes"))
      

      Output

      3

      В строке likes последовательность символов, эквивалентная “likes”, встречается в исходной строке 3 раза.

      Также мы можем определить позицию символа или последовательности символов в строке. Для этого мы можем использовать метод str.find(), который выводит позицию символа на базе номера индекса.

      Мы можем посмотреть, где появляется первый символ “m” в строке ss:

      print(ss.find("m"))
      

      Ouput

      2

      Первый символ “m” появляется в строке “Sammy Shark!” на позиции с индексом 2. Мы можем проверить позиции индекса в строке ss выше.

      Давайте посмотрим, где встречается первая последовательность символов “likes” в строке likes:

      print(likes.find("likes"))
      

      Ouput

      6

      Первый экземпляр последовательности символов “likes” начинается с индекса 6, соответствующего позиции символа l в последовательности likes.

      Что делать, если, если мы хотим увидеть, где начинается вторая последовательность “likes”? Для этого мы можем передать второй параметр в метод str.find(), который будет начинаться с конкретного индекса. Вместо того, чтобы начинать с начала строки, начнем с индекса 9:

      print(likes.find("likes", 9))
      

      Output

      34

      Во втором примере, который начинается с индекса 9, первая последовательность символов “likes” начинается с индекса 34.

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

      print(likes.find("likes", 40, -6))
      

      Output

      64

      В последнем примере мы ищем позицию последовательности “likes” между индексами 40 и -6. Поскольку последний параметр отрицательный, отсчет выполняется с конца первоначальной строки.

      Методы строки len(), str.count() и str.find() можно использовать для определения длины, количества символов или последовательностей символов и индексов символов или последовательностей символов в строках.

      Заключение

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

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



      Source link

      Индексация, разделение и управление строками в JavaScript


      Введение

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

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

      Примитивы и объекты String

      Для начала мы расскажем о двух типах строк. JavaScript различает примитив string, или неизменный тип данных, и объект String.

      Чтобы показать различия, мы инициализируем примитив строки и объект строки.

      // Initializing a new string primitive
      const stringPrimitive = "A new string.";
      
      // Initializing a new String object
      const stringObject = new String("A new string.");  
      

      Для определения типа значения можно использовать оператор typeof. В первом примере мы просто назначили строку переменной.

      typeof stringPrimitive;
      

      Output

      string

      Во втором примере мы использовали new String() для создания объекта строки и назначения его переменной.

      typeof stringObject;
      

      Output

      object

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

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

      Процедура индексации строк

      Каждому из символов в строке соответствует числовой индекс, начиная с 0.

      Для наглядности мы создадим строку со значением How are you?.

      H o w a r e y o u ?
      0 1 2 3 4 5 6 7 8 9 10 11

      Первый символ этой строки — H, ему соответствует индекс 0. Последний символ — ?, соответствующий символу 11. У символов пробела также имеются индексы на позициях 3 и 7.

      Возможность доступа к каждому символу строки даст нам множество способов для работы со строками и совершения манипуляций с ними.

      Доступ к символам

      Мы продемонстрируем, как получить доступ к символам и индексам в строке How are you?.

      "How are you?";
      

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

      "How are you?"[5];
      

      Output

      r

      Также мы можем использовать метод charAt() для возврата символа, используя числовой индекс в качестве параметра.

      "How are you?".charAt(5);
      

      Output

      r

      Другой способ: мы можем использовать indexOf() для возврата числового индекса для первого экземпляра символа.

      "How are you?".indexOf("o");
      

      Output

      1

      Хотя “o” появляется в строке How are you? дважды, метод indexOf() выдаст результат для первого экземпляра.

      lastIndexOf() используется для поиска последнего экземпляра.

      "How are you?".lastIndexOf("o");
      

      Output

      9

      С помощью обоих этих методов также можно найти несколько символов в строке. Он возвращает индекс первого символа в экземпляре.

      "How are you?".indexOf("are");
      

      Output

      4

      С другой стороны, метод slice() возвращает символы между двумя числовыми индексами. Первым параметром будет начальный числовой индекс, а вторым — конечный числовой индекс.

      "How are you?".slice(8, 11);
      

      Output

      you

      Обратите внимание, что 11 соответствует ?, но ? не является частью вывода, поскольку метод slice() возвращает символы между индексами, не включая последний параметр.

      Если второй параметр не указывается, slice() возвращает все символы от первого параметра до конца строки.

      "How are you?".slice(8);
      

      Output

      you?

      Таким образом, charAt() и slice() возвращают значения строк по числовым индексам, а indexOf() и lastIndexOf() имеют противоположное действие, возвращая числовые индексы по заданным символам строки.

      Определение длины строки

      Свойство length позволяет вывести количество символов в строке.

      "How are you?".length;
      

      Output

      12

      Помните, что свойство length возвращает фактическое количество символов, начиная с 1, то есть, 12, а не последний числовой индекс диапазона, который начинается с 0 и заканчивается 11.

      Преобразование в верхний или нижний регистр

      Встроенные методы toUpperCase() и toLowerCase() можно использовать для форматирования и сравнения текста в JavaScript.

      toUpperCase() конвертирует все символы в верхний регистр.

      "How are you?".toUpperCase();
      

      Output

      HOW ARE YOU?

      toLowerCase() конвертирует все символы в нижний регистр.

      "How are you?".toLowerCase();
      

      Output

      how are you?

      Эти два метода форматирования не принимают дополнительных параметров.

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

      Разделение строк

      В JavaScript имеется полезный метод разделения строк по символу и создания нового массива из полученных частей. Мы используем метод split() для разделения массива по символу пробела, представленного " ".

      const originalString = "How are you?";
      
      // Split string by whitespace character
      const splitString = originalString.split(" ");
      
      console.log(splitString);
      

      Output

      [ 'How', 'are', 'you?' ]

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

      splitString[1];
      

      Output

      are

      Если указан пустой параметр, split() создаст разделенный запятыми массив, содержащий все символы в строке.

      Разделяя строки, вы можете определить, сколько слов содержится в предложении, или использовать метод для определения имен и фамилий людей.

      Обрезка пробелов

      Метод JavaScript trim() удаляет пробелы с обоих концов строки, но не из промежутка между ними. Пробелами могут являться обычные пробелы или символы табуляции.

      const tooMuchWhitespace = "     How are you?     ";
      
      const trimmed = tooMuchWhitespace.trim();
      
      console.log(trimmed);
      

      Output

      How are you?

      Метод trim() — это простой способ выполнения распространенной задачи по удалению лишних пробелов.

      Поиск и замена значений строк

      Мы можем использовать метод replace(), чтобы найти в строке значение и заменить его новым значением. Первым параметром будет искомое значение, а вторым параметром — значение, которое его заменит.

      const originalString = "How are you?"
      
      // Replace the first instance of "How" with "Where"
      const newString = originalString.replace("How", "Where");
      
      console.log(newString);
      

      Output

      Where are you?

      Помимо замены значений в строках, мы также можем использовать регулярные выражения для расширения возможностей метода replace(). Например, replace() влияет только на первое значение, но мы можем использовать флаг g (глобальный), чтобы найти все экземпляры значения, и флаг i (без учета регистра), чтобы игнорировать регистр.

      const originalString = "Javascript is a programming language. I'm learning javascript."
      
      // Search string for "javascript" and replace with "JavaScript"
      const newString = originalString.replace(/javascript/gi, "JavaScript");
      
      console.log(newString);
      

      Output

      JavaScript is a programming language. I'm learning JavaScript.

      Это очень распространенная задача с использованием регулярных выражений. Посетите Regexr, чтобы потренироваться с другими примерами регулярных выражений.

      Заключение

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

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

      Более общий обзор строк можно найти в учебном модуле Работа со строками в JavaScript.



      Source link