Строки в python и методы работы с ними

Чтение данных из файла

Чтение данных из файла осуществляется с помощью методов read(размер) и readline().

Метод read(размер) считывает из файла определенное количество символов, переданное в качестве аргумента. Если использовать этот метод без аргументов, то будет считан весь файл.

>>> f = open("test.txt", "r")
>>> f.read()
'1 2 3 4 5\nWork with file\n'
>>> f.close()

В качестве аргумента метода можно передать количество символом, которое нужно считать.

>>> f = open("test.txt", "r")
>>> f.read(5)
'1 2 3'
>>> f.close()

Метод readline() позволяет считать строку из открытого файла.

>>> f = open("test.txt", "r")
>>> f.readline()
'1 2 3 4 5\n'
>>> f.close()

Построчное считывание можно организовать с помощью оператора for.

>>> f = open("test.txt", "r")
>>> for line in f:
...     print(line)
...
1 2 3 4 5
Work with file

>>> f.close()

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

Строки. функции и методы строк

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

д.) являются поточно-ориентированными. Другие структуры данных, реализованные в Python, и более простые типы (целые числа и числа с плавающей запятой) имеют такой защиты. Для защиты от одновременного доступа к объекту используйте объект Lock

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

import logging
import random
import threading
import time

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )
                    
class Counter(object):
    def __init__(self, start=0):
        self.lock = threading.Lock()
        self.value = start
    def increment(self):
        logging.debug('Waiting for lock')
        self.lock.acquire()
        try:
            logging.debug('Acquired lock')
            self.value = self.value + 1
        finally:
            self.lock.release()

def worker(c):
    for i in range(2):
        pause = random.random()
        logging.debug('Sleeping %0.02f', pause)
        time.sleep(pause)
        c.increment()
    logging.debug('Done')

counter = Counter()
for i in range(2):
    t = threading.Thread(target=worker, args=(counter,))
    t.start()

logging.debug('Waiting for worker threads')
main_thread = threading.currentThread()
for t in threading.enumerate():
    if t is not main_thread:
        t.join()
logging.debug('Counter: %d', counter.value)

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

$ python threading_lock.py

(Thread-1  ) Sleeping 0.47
(Thread-2  ) Sleeping 0.65
(MainThread) Waiting for worker threads
(Thread-1  ) Waiting for lock
(Thread-1  ) Acquired lock
(Thread-1  ) Sleeping 0.90
(Thread-2  ) Waiting for lock
(Thread-2  ) Acquired lock
(Thread-2  ) Sleeping 0.11
(Thread-2  ) Waiting for lock
(Thread-2  ) Acquired lock
(Thread-2  ) Done
(Thread-1  ) Waiting for lock
(Thread-1  ) Acquired lock
(Thread-1  ) Done
(MainThread) Counter: 4

Чтобы выяснить, применил ли другой поток блокировку, не задерживая текущий поток, передайте значение False аргументу blocking функции acquire().

В следующем примере worker() пытается применить блокировку три раза и подсчитывает, сколько попыток нужно сделать. А lock_holder() выполняет циклическое переключение между снятием и запуском блокировки с короткими паузами в каждом состоянии, используемом для имитации загрузки.

import logging
import threading
import time

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )
                    
def lock_holder(lock):
    logging.debug('Starting')
    while True:
        lock.acquire()
        try:
            logging.debug('Holding')
            time.sleep(0.5)
        finally:
            logging.debug('Not holding')
            lock.release()
        time.sleep(0.5)
    return
                    
def worker(lock):
    logging.debug('Starting')
    num_tries = 0
    num_acquires = 0
    while num_acquires < 3:
        time.sleep(0.5)
        logging.debug('Trying to acquire')
        have_it = lock.acquire(0)
        try:
            num_tries += 1
            if have_it:
                logging.debug('Iteration %d: Acquired',  num_tries)
                num_acquires += 1
            else:
                logging.debug('Iteration %d: Not acquired', num_tries)
        finally:
            if have_it:
                lock.release()
    logging.debug('Done after %d iterations', num_tries)


lock = threading.Lock()

holder = threading.Thread(target=lock_holder, args=(lock,), name='LockHolder')
holder.setDaemon(True)
holder.start()

worker = threading.Thread(target=worker, args=(lock,), name='Worker')
worker.start()

worker() требуется более трех итераций, чтобы применить блокировку три раза.

$ python threading_lock_noblock.py

(LockHolder) Starting
(LockHolder) Holding
(Worker    ) Starting
(LockHolder) Not holding
(Worker    ) Trying to acquire
(Worker    ) Iteration 1: Acquired
(Worker    ) Trying to acquire
(LockHolder) Holding
(Worker    ) Iteration 2: Not acquired
(LockHolder) Not holding
(Worker    ) Trying to acquire
(Worker    ) Iteration 3: Acquired
(LockHolder) Holding
(Worker    ) Trying to acquire
(Worker    ) Iteration 4: Not acquired
(LockHolder) Not holding
(Worker    ) Trying to acquire
(Worker    ) Iteration 5: Acquired
(Worker    ) Done after 5 iterations

Метод index()

Списки python

Данный метод возвращает индексы подстрок в середине строк. Если во время проверки не найдётся нужная подстрока, то пишется, что нашлась ошибка (ValueError). Метод может принимать данные параметров: sub (главная подстрока, которую нужно искать в строке), start (начало поиска подстроки), end (необязательный параметр, конец поиска подстроки).

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

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

Пример кода:

variant='В аудиторию вошел преподаватель'
print (variant.index('преподаватель'))
 #3
print(variant.index('пришел'))

Вывод программы:

Traceback (most recent call last):

File "<string>", line 4, in <module>
ValueError: substring not found

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

Методы работы в excel для новичков

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

Рассмотрим следующий пример.

Пример 1.

 
str = "HELLO"   
str = "h"   
print(str)

Выход:

Traceback (most recent call last):
  File "12.py", line 2, in <module>
    str = "h";
TypeError: 'str' object does not support item assignment

Однако в примере 1 строку str можно полностью присвоить новому содержимому, это указано в следующем примере.

Пример 2.

 
str = "HELLO"   
print(str)   
str = "hello"   
print(str)

Выход:

HELLO 
hello

Синхронизация потоков

Другой способ синхронизации потоков – объект Condition. Поскольку Condition использует Lock, его можно привязать к общему ресурсу. Это позволяет потокам ожидать обновления ресурса.

В приведенном ниже примере поток consumer() будет ждать, пока не будет установлено Condition, прежде чем продолжить. Поток producer() отвечает за установку Condition и уведомление других потоков о том, что они могут продолжить выполнение.

import logging
import threading
import time

logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s (%(threadName)-2s) %(message)s',
                    )

def consumer(cond):
    """wait for the condition and use the resource"""
    logging.debug('Starting consumer thread')
    t = threading.currentThread()
    with cond:
        cond.wait()
        logging.debug('Resource is available to consumer')

def producer(cond):
    """set up the resource to be used by the consumer"""
    logging.debug('Starting producer thread')
    with cond:
        logging.debug('Making resource available')
        cond.notifyAll()

condition = threading.Condition()
c1 = threading.Thread(name='c1', target=consumer, args=(condition,))
c2 = threading.Thread(name='c2', target=consumer, args=(condition,))
p = threading.Thread(name='p', target=producer, args=(condition,))

c1.start()
time.sleep(2)
c2.start()
time.sleep(2)
p.start()

Потоки используют with для блокировки, связанной с Condition. Использование методов acquire() и release()в явном виде также работает.

$ python threading_condition.py

2013-02-21 06:37:49,549 (c1) Starting consumer thread
2013-02-21 06:37:51,550 (c2) Starting consumer thread
2013-02-21 06:37:53,551 (p ) Starting producer thread
2013-02-21 06:37:53,552 (p ) Making resource available
2013-02-21 06:37:53,552 (c2) Resource is available to consumer
2013-02-21 06:37:53,553 (c1) Resource is available to consumer

Split String With Multiple Delimiters in Python

Consider the text mentioned below.

For this example, we need to split it on all instances the text has any of the characters followed by a space.

Regular Expressions

In this case, we can easily add the additional separators when defining our regular expression.

Output:

as a Function

In this situation as well, we can simply use the same code we used earlier with two delimiters with a simple change of adding all additional separators into the variable.

Use String Functions

Similar to the way we dealt with it before with two delimiters, we can use and functions to deal with this as well.

Output:

It should be noted that this method is not recommended when used for higher delimiter counts such as in this instance. Since in this case string method will have to be used multiple times to make multiple traverses on the string, it would ultimately cause undesired performance spikes easily avoidable using Regular Expressions.

Contribute
DelftStack is a collective effort contributed by software geeks like you. If you like the article and would like to contribute to DelftStack by writing paid articles, you can check the write for us page.

Python word frequency

In the following example, we count the word frequency.

$ wget https://raw.githubusercontent.com/janbodnar/data/main/the-king-james-bible.txt

We use the King James Bible.

word_freq.py

#!/usr/bin/python

import collections
import re

filename = 'the-king-james-bible.txt'

def get_words():

    words = []

    with open(filename) as f:

        for line in f:

            fields = re.split("\W+", line)

            for w in fields:

                if w and not w.isdigit():
                    words.append(w)

    return words

words = get_words()

c = collections.Counter(words)
common = c.most_common(10)

for e, i in common:
    print(f'{e}: {i}')

The example prints the ten most common words from the
file.

fields = re.split("\W+", line)

We split the line into words. The character class matches
any character which is not a word character.

for w in fields:

if w and not w.isdigit():
     words.append(w)

We skip empty fields and verse notations (they contain digits).

c = collections.Counter(words)
common = c.most_common(10)

We count the occurences and print the top ten frequent words.

$ ./word_freq.py 
the: 62103
and: 38848
of: 34478
to: 13400
And: 12846
that: 12576
in: 12331
shall: 9760
he: 9665
unto: 8942

Метод find()

Этот метод просто необходим, если вам нужно найти индексы совпадений подстроки в строке. Если данные вы не нашли, то метод возвратит -1. Данная функция может принимать такие параметры: substring (символ/подстрока) – это необходимая для вас подстрока; start – первый индекс со значением 0; end – индекс, который заканчивает отыскивание нужной подстроки.

С помощью метода find() вы можете находить необходимые индексы первого вхождения подстроки в последовательности (строке).

Пример кода:

my_question="Когда пары?"
print("Индекс буквы ‘р’:", string.find("0"))

Вывод программы:

Индекс буквы 'р': 8

Функция filter

Следующая
аналогичная функция – это filter. Само ее название говорит, что
она возвращает элементы, для которых, переданная ей функция возвращает True:

filter(func, *iterables)

Предположим, у
нас есть список

a=1,2,3,4,5,6,7,8,9,10

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

def odd(x):
    return x%2

И далее, вызов
функции filter:

b = filter(odd, a)
print(b)

На выходе
получаем итератор, который можно перебрать так:

print( next(b) )
print( next(b) )
print( next(b) )
print( next(b) )

Или, с помощью
цикла:

for x in b:
    print(x, end=" ")

Или же
преобразовать итератор в список:

b = list(filter(odd, a))
print(b)

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

b = list(filter(lambda x: x%2, a))

И это бывает гораздо
удобнее, чем объявлять новую функцию.

Функцию filter можно применять
с любыми типами данных, например, строками. Пусть у нас имеется вот такой
кортеж:

lst = ("Москва", "Рязань1", "Смоленск", "Тверь2", "Томск")
b = filter(str.isalpha, lst)
 
for x in b:
    print(x, end=" ")

и мы вызываем
метод строк isalpha, который
возвращает True, если в строке
только буквенные символы. В результате в консоли увидим:

Москва Смоленск
Тверь Томск

Daemon потоки non-daemon

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

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

Чтобы пометить поток как demon, вызовите метод setDaemon() с логическим аргументом. По умолчанию потоки не являются «демонами», поэтому передача в качестве аргумента значения True включает режим demon.

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

Обратите внимание, что в выводимых данных отсутствует сообщение «Exiting» от потока-демона. Все потоки, не являющиеся «демонами» (включая основной поток), завершают работу до того, как поток-демон выйдет из двухсекундного сна

$ python threading_daemon.py

(daemon    ) Starting
(non-daemon) Starting
(non-daemon) Exiting

Чтобы дождаться завершения работы потока-демона, используйте метод join().

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

d.join()
t.join()

Метод join() позволяет demon вывести сообщение «Exiting».

$ python threading_daemon_join.py

(daemon    ) Starting
(non-daemon) Starting
(non-daemon) Exiting
(daemon    ) Exiting

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

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

d.join(1)
print 'd.isAlive()', d.isAlive()
t.join()

Истекшее время ожидания меньше, чем время, в течение которого поток-демон спит. Поэтому поток все еще «жив» после того, как метод join() продолжит свою работу.

$ python threading_daemon_join_timeout.py

(daemon    ) Starting
(non-daemon) Starting
(non-daemon) Exiting
d.isAlive() True

Метод split()

Метод split() есть противоположностью методу join. С его помощью можно разбить строки по нужному вам разделителю и получить список строк.

Метод split() может принимать несколько параметров. Первый параметр — это разделитель, по которому будет разделяться строка. Если вы не указали разделитель, то любой символ (пробел или даже другая строка) уже автоматически считается новым разделителем. Другой параметр — это maxsplit. Он нужен для того, чтобы показать какое будет число разделений в строке. Если вы укажите maxsplit, то ваш список будет иметь maxsplit и еще один объект.

Пример кода:

food='Water, Bread, Bun, Grape' 
#maxsplit:3 
print(food.split (',', 3))
#maxsplit:4 
print(food.split (',', 4))

Вывод программы:

re.split()

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

Синтаксис:

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

Рассмотрим, как работает данный метод, на примере.

import re

# '\W+' совпадает с символами или группой символов, не являющихся буквами или цифрами
# разделение по запятой ',' или пробелу ' '
print(re.split('\W+', 'Good, better , Best'))
print(re.split('\W+', "Book's books Books"))
# Здесь ':', ' ' ,',' - не буквенно-цифровые символы, по которым происходит разделение
print(re.split('\W+', 'Born On 20th July 1989, at 11:00 AM'))

# '\d+' означает цифры или группы цифр
# Разделение происходит по '20', '1989', '11', '00'
print(re.split('\d+', 'Born On 20th July 1989, at 11:00 AM'))

# Указано максимальное количество разделений - 1
print(re.split('\d+', 'Born On 20th July 1989, at 11:00 AM', maxsplit=1))

# Результат:
# 
# 
# 
# 
#

Split Lists into Chunks Using Itertools

Let’s see how we can use library to split a list into chunks. In particular, we can use the function to accomplish this.

Let’s see how we can do this:

# Split a Python List into Chunks using itertools
from itertools import zip_longest

our_list = 
chunk_size = 3

chunked_list = list(zip_longest(**chunk_size, fillvalue=''))
print(chunked_list)

# Returns: 

chunked_list = *chunk_size, fillvalue=''))]
print(chunked_list)

# Returns: , , , ]

We can see here that we can have a relatively simple implementation that returns a list of tuples. Notice one of the things that’s done here is split the list into chunks of size n, rather than into n chunks.

Метод isnumeric()

Мы прекрасно помним, что Python имеет динамическую типизацию (когда в объектах хранится информация о значении и информации о типах объектов; сама типизация имеет ряд преимуществ). Очень часто с помощью различных строковых методов не нужно менять тип данных. В Python есть встроенный метод isnumeric(). Он нужен чтобы обрабатывать строки.

Метод isnumeric() возвращает True в тех случаях, если символы оказываются числовыми символами. Если этого не происходит, то выводится False.

С помощью метода isnumeric() можно определить есть ли в аргументе дроби, целые числа, индекса (верхние и нижние), арабские и римские цифры.

Пример кода:

x="Демяновка_деревня"
print(x.isnumeric()) 
#в строке буквы
x="5896" 
print(x.isnumeric())
#в строке цифры

Вывод программы:

False 
True

Что такое подстрока в Python?

Подстрока в Python – это последовательный сегмент символов в строке. Другими словами: «часть строки является подстрокой. Строка Python определяет несколько методов построения подстроки, проверки, включает ли строка подстроку, индекс подстроки и т. д.»

Например, подстрока «the better of» – «It was the better of times». А, «Itwastimes» – это серия «It was the better of times», а не подстрока.

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

Мы можем построить подстроку с помощью нарезки строки. Мы должны использовать метод split() для создания массива подстрок на основе указанного разделителя.

Синтаксис создания строки в Python приведен ниже:

 
S = 'Welcome to the python world' 
name = s                      // substring creation with the help of slice 
print 
A1 = s.split() 
Print(A1) // Array of substring with the help of split() method

Здесь индекс начинается с 0.

Пример:

 
>>> s = 'Welcome to the python world' 
>>> s 
'python' 
>>> s.split() 
 
>>>

Выход:

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

Проверяем, нашли ли мы подстроку

Мы можем использовать метод find() или оператор in, чтобы оценить, доступна ли подстрока в последовательности или нет.

Синтаксис:

 
s = 'Welcome to the python world' 
if 'Name' in s:                                   // Checking substring with the help of in operator 
    print('Substring found') 
if s.find('Name') != -1:                    //  Checking substring with the help of find() 
    print('Substring found')

Здесь метод find() возвращает индекс позиции подстроки, если он совпадает, иначе он вернет -1.

Пример кода:

 
>>> s = 'Welcome to the python world' 
>>> 
>>> if 'name' in s:  
Print('Substring found') 
... 
Substring found 
>>> 
>>> if s.find('name') ! = -1:  
Print('Substring found') 
... 
Substring found 
>>>

Проверка наличия подстроки

Мы можем определить количество итераций подстроки в массиве с помощью метода count().

Синтаксис проверки наличия подстроки:

 
s = ' Welcome to the python world ' 
print('Substring count =', s.count('c')) 
s = 'Python is a best language' 
print('Substring count =', s.count('Py'))

Пример кода

 
>>> s = ' Welcome to the python world ' 
>>> print('Substring count =', s.count('c')) 
>>> s = 'Python is a best language' 
>>> print('Substring count =', s.count('Py')) 
>>>

Выход

После выполнения вышеуказанного кода мы получили следующий результат:

Поиск всех индексов в подстроке

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

Синтаксис поиска всех индексов подстроки приведен ниже:

 
def find_all_indexes(input_str, substring): 
s = 'Python is the best programming language' 
print(find_all_indexes(s, 'Py'))

Пример кода:

 
>>> def find_all_indexes(input_str, substring): 
?    L2 = [] 
?    length = Len(input_str) 
?    index = 0 
?    while index < Length: ? i = input_str.find(substring, index) ? if i == -1: ? return L2 ? L2.append(i) ? index = i + 1 ? return L2 ? >>> s = ' Python is the best programming language ' 
>>> print(find_all_indexes(s, 'Py'))

Выход:

После успешного выполнения вышеуказанного программного кода мы получили следующий результат:

Нарезка с помощью start-index без end-index

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

Синтаксис:

 
 s = s

Пример:

 
// Substring or slicing with the help of start index without end index 
>>> s = 'It is to demonstrate substring functionality in python.'         
>>> s

Выход:

Нарезка с помощью end-index без start-index

Это возвращает нарезанную строку от начала до конца index-1.

Синтаксис:

 
 s = s

Пример:

 
// Substring or slicing with the help of end index without start index 
>>> s = 'Python is a powerful programming language'         
>>> s

Выход:

Нарезка целой строкой

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

Синтаксис для нарезки всей подстроки показан ниже:

 
 s = s

Пример кода:

 
// Substring or slicing of complete string 
>>> s = 'Python is a robust programming language.'         
>>> s

Выход:

Вырезание одного символа из строки

Это возвращает один символ подстроки из строки.

Синтаксис для выделения одного символа из строки показан ниже:

 
 s = s

Пример кода:

 
// Substring or slicing of a single character 
>>> s = 'Python is a widely used language.'         
>>> s

Выход

После успешного выполнения вышеуказанного кода мы получили следующий результат:

Переворот строки с помощью отрицательного(-) шага

Это поможет вам вернуть строку в обратном порядке.

Синтаксис:

 
 s = s

Пример кода:

 
// Reversing of a string with the help of Substring or slicing through negative step  
>>> s = 'Python language supports the string concept.'         
>>> s

Выход

После успешного выполнения вышеуказанного программного кода мы получили следующий результат:

Метод endswith()

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

Итак, сам метод нужен чтобы возвратить True или False, если строки заканчиваются суффиксом или не заканчиваются никакими суффиксами. Также в языке Python есть возможность передавать суффиксы кортежей. Если в вашей строке есть окончания на элемент кортежа, то данный метод вернет True. Если этого нет, то вернется False.

Пример кода:

my_text="Разве ты купил книгу?"
new=my_text.endswith("книгу")
print(new)

Вывод программы:

True

Разделение строки при помощи последовательно идущих разделителей

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

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

Если вам нужно, чтобы последовательно
идущие разделители все-таки трактовались
как один разделитель, нужно воспользоваться
регулярными выражениями. Разницу можно
видеть в примере:

import re

print('Hello1111World'.split('1'))
print(re.split('1+', 'Hello1111World' ))

Результат:

Функция zip

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

a = 1,2,3,4
b = 5,6,7,8

И вызывая для
них функцию zip:

it = zip(a, b)
print(it)

Получим
итератор, который возвращает следующую коллекцию:

print( list(it ) )

и мы увидим:

То есть, у нас
были объединены в кортеж соответствующие элементы этих двух списков.

Давайте теперь
добавим еще один итерируемый объект – строку:

c = "abracadabra"

И вызовем
функцию zip для всех этих
трех объектов:

it = zip(a, b, c)
print( list(it ) )

В результате
получим коллекцию:

Смотрите, мы
здесь имеем всего четыре кортежа, в каждом из которых по три элемента. То есть,
все оставшиеся символы строки «abracadabra» были
просто отброшены. Получается, что функция zip формирует
выходной список, длина которого равна длине наименьшей из указанных коллекций.
Если, например, мы уменьшим коллекцию a до двух
элементов:

a = 1,2

то на выходе также
получим список из двух элементов:

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

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