A complete guide to the python split function

Python split String Syntax

The syntax of the Python String split function is

• String_Value: A valid String variable, or you can use the String directly.
• Separator (Optional arg): If you forget this argument, the python split string function uses Empty Space as the separator.
• Max_Split: This argument is optional. If you specify this value then, split function restricts the list of words.

Python split function returns a List of words. For example, If we have X*Y*Z and If we use * as a separator, split function search for * from left to right. Once the split function finds *, Python returns the string before the * symbol as List Item 1 (X) so on and so forth.

If you add Max_Split argument to the above example, X*Y*Z.split(‘*’, 1), python split function search for *. Once it finds *, the split function returns the string before the * symbol as List Item 1 (X) and returns the remaining string as list item 2.

Специфичные для потока данные

Некоторые ресурсы должны быть заблокированы, чтобы их могли использовать сразу несколько потоков. А другие должны быть защищены от просмотра в потоках, которые не «владеют» ими. Функция local() создает объект, способный скрывать значения для отдельных потоков.

import random
import threading
import logging

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

def show_value(data):
    try:
        val = data.value
    except AttributeError:
        logging.debug('No value yet')
    else:
        logging.debug('value=%s', val)


def worker(data):
    show_value(data)
    data.value = random.randint(1, 100)
    show_value(data)

local_data = threading.local()
show_value(local_data)
local_data.value = 1000
show_value(local_data)

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

Обратите внимание, что значение local_data.value не доступно ни для одного потока, пока не будет установлено

$ python threading_local.py

(MainThread) No value yet
(MainThread) value=1000
(Thread-1  ) No value yet
(Thread-1  ) value=34
(Thread-2  ) No value yet
(Thread-2  ) value=7

Чтобы все потоки начинались с одного и того же значения, используйте подкласс и установите атрибуты с помощью метода __init __() .

import random
import threading
import logging

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


def show_value(data):
    try:
        val = data.value
    except AttributeError:
        logging.debug('No value yet')
    else:
        logging.debug('value=%s', val)

def worker(data):
    show_value(data)
    data.value = random.randint(1, 100)
    show_value(data)

class MyLocal(threading.local):
    def __init__(self, value):
        logging.debug('Initializing %r', self)
        self.value = value

local_data = MyLocal(1000)
show_value(local_data)

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

__init __() вызывается для каждого объекта (обратите внимание на значение id()) один раз в каждом потоке

$ python threading_local_defaults.py

(MainThread) Initializing <__main__.MyLocal object at 0x100514390>
(MainThread) value=1000
(Thread-1  ) Initializing <__main__.MyLocal object at 0x100514390>
(Thread-1  ) value=1000
(Thread-2  ) Initializing <__main__.MyLocal object at 0x100514390>
(Thread-1  ) value=81
(Thread-2  ) value=1000
(Thread-2  ) value=54

Строки нарезки в Python – примеры

Струны нарезки Python могут быть сделаны по-разному.

Обычно мы получаем доступ к строковым элементам (символам) с помощью простой индексации, которая начинается с до N-1 (n – длина строки). Следовательно, для доступа к 1-й Элемент строки Мы можем просто использовать код ниже.

s1 = String1

Опять же, есть еще один способ получить доступ к этим персонажам, то есть используя Отрицательная индексация Отказ Отрицательная индексация начинается с -1 к -n (n – длина для данной строки). Примечание, отрицательная индексация выполняется с другого конца строки. Следовательно, для доступа к первому символу на этот раз нам нужно следовать указанному ниже коду.

s1 = String1

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

1. Строки нарезки в Python с началом и концом

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

#string slicing with two parameters
s = "Hello World!"

res1 = s
res2 = s #using negative indexing

print("Result1 = ",res1)
print("Result2 = ",res2)

Выход :

Result1 =  llo Wo
Result2 =  rld

Здесь,

• Мы инициализируем строку, как “Привет мир!” ,
• Сначала мы нарезаем данную строку с начальным индексом 2 и окончание индекса как 8 Отказ Это означает, что результирующая подконта будет содержать символы из S к S ,
• Аналогично, для следующего, результирующая подкора должна содержать символы из S к S Отказ

Следовательно, наш выход оправдан.

2. Струки срез, используя только начало или конец

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

#string slicing with one parameter
s1= "Charlie"
s2="Jordan"

res1 = s1 #default value of ending position is set to the length of string
res2 = s2 #default value of starting position is set to 0

print("Result1 = ",res1)
print("Result2 = ",res2)

Выход :

Result1 =  arlie
Result2 =  Jord

Здесь,

Сначала инициализируем две строки, S1 и S2 , Для нарезки их обоих мы просто упомяну о start_pos Для S1 и End_Pos только для S2, Следовательно, для RES1 , он содержит подконтную строку S1 из индекса 2 (как упоминалось) до последнего (по умолчанию он устанавливается на N-1)

Принимая во внимание, что для RES2 диапазон индексов лежит от 0 до 4 (упомянутых).

3. Строки нарезки в Python со ступенчатым параметром

Значение решает прыжок операции нарезки займет из одного индекса к другому. Посмотрите на пример ниже.

#string slicing with step parameter
s= "Python"
s1="Kotlin"

res = s
res1 = s1 #using negative parameters

print("Resultant sliced string = ",res)
print("Resultant sliced string(negative parameters) = ",res1)

Выход :

Resultant sliced string =  Pto
Resultant sliced string(negative parameters) =  nl

В коде выше,

• Мы инициализируем две строки S и S1 и попытайтесь нарезать их за данные начальные и окончательные индексы, как мы сделали для нашего первого примера,
• Но на этот раз мы упомянули шаг значение, которое было установлено на 1 по умолчанию для предыдущих примеров,
• Для RES, имеющих размер шага 2 означает, что, в то время как прохождение для получения подстроки от индекса от 0 до 4, каждый раз, когда индекс будет увеличен по значению 2. То есть первый символ S («P») следующие символы в подпологе будут S и S до тех пор, пока индекс не будет меньше 5.
• Для следующего я. RES1 Упомянутый шаг (-2). Следовательно, похоже на предыдущий случай, персонажи в подстроке будут S1 Тогда S1 или S1 до тех пор, пока индекс не будет меньше (-4).

4. Реверсируя строку с помощью нарезки в Python

С использованием отрицательной индексной строки нарезки в Python мы также можем поменять строку и хранить ее в другой переменной. Для этого нам просто нужно упомянуть Размер (-1) Отказ

Давайте посмотрим, как это работает в приведенном ниже примере.

#reversing string using string slicing
s= "AskPython"
rev_s = s #reverse string stored into rev_s

print(rev_s)

Выход :

nohtyPksA

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

Ограничение одновременного доступа к ресурсам

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

import logging
import random
import threading
import time

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

class ActivePool(object):
    def __init__(self):
        super(ActivePool, self).__init__()
        self.active = []
        self.lock = threading.Lock()
    def makeActive(self, name):
        with self.lock:
            self.active.append(name)
            logging.debug('Running: %s', self.active)
    def makeInactive(self, name):
        with self.lock:
            self.active.remove(name)
            logging.debug('Running: %s', self.active)

def worker(s, pool):
    logging.debug('Waiting to join the pool')
    with s:
        name = threading.currentThread().getName()
        pool.makeActive(name)
        time.sleep(0.1)
        pool.makeInactive(name)

pool = ActivePool()
s = threading.Semaphore(2)
for i in range(4):
    t = threading.Thread(target=worker, name=str(i), args=(s, pool))
    t.start()

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

$ python threading_semaphore.py

2013-02-21 06:37:53,629 (0 ) Waiting to join the pool
2013-02-21 06:37:53,629 (1 ) Waiting to join the pool
2013-02-21 06:37:53,629 (0 ) Running: 
2013-02-21 06:37:53,629 (2 ) Waiting to join the pool
2013-02-21 06:37:53,630 (3 ) Waiting to join the pool
2013-02-21 06:37:53,630 (1 ) Running: 
2013-02-21 06:37:53,730 (0 ) Running: 
2013-02-21 06:37:53,731 (2 ) Running: 
2013-02-21 06:37:53,731 (1 ) Running: 
2013-02-21 06:37:53,732 (3 ) Running: 
2013-02-21 06:37:53,831 (2 ) Running: 
2013-02-21 06:37:53,833 (3 ) Running: []

Время выполнения программы

Существует множество разных задач, для решения которых нужно найти время, потраченное на работу программы либо отдельных ее блоков. Чтобы найти данную величину, достаточно посчитать разницу в секундах между точкой старта определенной функции и местом, где она завершает свою работу. В следующем примере демонстрируется применение методов time() для получения текущего времени, чтобы в конечном итоге выявить, как долго работал блок кода. Метод sleep() здесь увеличивает время выполнения программы на 5 секунд.

import time
start = time.time()
time.sleep(5)
finish = time.time()
result = finish - start
print("Program time: " + str(result) + " seconds.")

Program time: 5.005090236663818 seconds.

Несмотря на простоту вышеописанного подхода, использовать его в серьезных целях, где требуется точный и независимый от ОС результат, не рекомендуется. Все дело в том, что числовое значение времени, получаемое таким образом, может иметь погрешности за счет внутренних особенностей работы компьютера, в среде которого выполняется программа. Например, системные часы могут быть подкорректированы вручную пользователем во время выполнения программы. Корректировка может произойти и автоматически, если настроена синхронизация системных часов по NTP.

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

monotonic

По этой причине лучше всего использовать метод monotonic(), впервые появившийся в версии Python 3.3 на некоторых платформах, а начиная с выпуска 3.5 ставший доступным абсолютно везде. Его главной особенностью является точное представление измеряемого количества времени, вне зависимости от работы ОС и текущей платформы. Используемый таймер никогда не вернет при повторном вызове метода значение, которое будет меньше предыдущего. Это позволяет избежать многих ошибок, а также неожиданного поведения.

import time
start = time.monotonic()
time.sleep(15)
result = time.monotonic() - start
print("Program time: {:>.3f}".format(result) + " seconds.")

Program time: 15.012 seconds.

В примере программы, описанном выше, продемонстрирована работа функции monotonic(). Принцип ее применения такой же, как и в предыдущем примере, однако здесь результат обладает гарантированной точностью и независим от внешних условий. Для отображения времени в более комфортной форме используется небольшое форматирование результата.

Строки байтов — bytes и bytearray

Определение которое мы дале в самом начале можно считать верным только для строк типа str. Но в Python имеется еще два дугих типа строк: bytes – неизменяемое строковое представление двоичных данных и bytearray – тоже что и bytes, только допускает непосредственное изменение.

Основное отличие типа str от bytes и bytearray заключается в том, что str всегда пытается превратить последовательность байтов в текст указанной кодировки. По умолчанию этой кодировкой является utf-8, но это очень большая кодировка и другие кодировки, например ASCII, Latin-1 и другие являются ее подмножествами

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

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

Например, что бы создать строку типа bytes или bytearray достаточно передать соответствующим функциям последовательности целых чисел:

Учитывая то, что для кодирования некоторых символов (например ASCII) достаточно всего одного байта, данные типы пытаются представить последовательности в виде символов если это возможно. Например, строка будет выведена как :

А это значит, что байтовые данные могут вполне обоснованно интерпретированться как ASCII символы и наоборот. Т.е. строки байтов могут быть созданы и так:

Но, следует помнить что это все-таки байты, в чем легко убедиться, если мы обратимся к какому-нибудь символу по его индексу в строке:

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

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

Описание:

Метод возвращает строку, которая является конкатенацией (объединением) всех элементов строк итерируемого объекта .

В итоговой строке элементы объединяются между собой при помощи строки-разделителя .

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

Примеры создания строки из списка строк.

>>> x = 'возвращает',  'строку',  'которая', 
         'является', 'конкатенацией'

# объединение списка строк с разделителем "пробел"
>>> line =  ' '.join(x)
>>> line
# 'возвращает строку которая является конкатенацией'

# в качестве разделителя символ новой строки '\n'
>>> line = '\n'.join(x)
>>> line
# 'возвращает\nстроку\nкоторая\nявляется\nконкатенацией'
>>> print(line)
# возвращает
# строку
# которая
# является
# конкатенацией

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

В примере будем использовать словарь из двух списков — (для ошибок) и (для итогового сообщения):

# здесь поступают какие то данные, пускай 
# num - должно быть целым числом
# name - имя, которое должно быть не менее 3-х букв

content = {'message' [], 'error' []}
# далее идет код проверок например:
if num
    if type(num) is int
        content'message'.append(f'  - Введено число {num}')
    else
        content'error'.append(f'  - {num} - это не целое число')
else
    content'error'.append('  - Вы не ввели число')

if name
    if len(name) > 3
        content'message'.append(f'  - Введено имя: {name}')
    else
        content'error'.append('  - Имя не должно быть короче 3-х букв')
else
    content'error'.append('  - Вы не ввели имя')

# в конце кода итоговые проверки и вывод сообщения
if content'error']:
    # если есть какие-то ошибки
    content'error'.insert(, 'При вводе данных возникли ошибки:\n')
    result_message = '\n'.join(content'error'])
else
    # если все хорошо.
    content'message'.insert(, 'Результаты ввода данных:\n')
    result_message = '\n'.join(content'message'])

print(result_message)

Как добавить/соединить существующую строку со списком строк.

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

# начальная строка
>>> line = 'Состав корзины покупателя:'
# список строк, которые нужно добавить
>>> lst_line = '- картошка', '- морковь', '- лук', '- чеснок', '- свекла'
# вставляем начальную строку по индексу 0 в список
>>> lst_line.insert(, line)
# объединяем список строк по разделителю '\n'
>>> rez = '\n'.join(lst_line)
>>> print(rez)
# Состав корзины покупателя:
# - картошка
# - морковь
# - лук
# - чеснок
# - свекла

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

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

Помимо синхронизации операций с потоками, также важно иметь возможность контролировать доступ к общим ресурсам, чтобы предотвратить повреждение данных. Встроенные в 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

Разделение строки с использованием разделителя

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

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

print("Python2, Python3, Python, Numpy".split(','))
print("Python2; Python3; Python; Numpy".split(';'))

Результат:

Как видите, в результирующих списках
отсутствуют сами разделители.

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

import re

sep = re.split(',', 'Python2, Python3, Python, Numpy')
print(sep)
sep = re.split('(,)', 'Python2, Python3, Python, Numpy')
print(sep)

Результат:

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

text = 'Python2, Python3, Python, Numpy'
sep = ','

result = 
print(result)

Результат:

Что насчёт поиска в строке?

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

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

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

Форматирование строк в Python

Экранирование символов

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

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

Один из способов обойти эту проблему — использовать тройные кавычки. В качестве альтернативы мы можем использовать escape-последовательности или так называемое «экранирование символов».

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

# Тройные кавычки
print('''He said, "What's there?"''')

# Экранирование одинарных кавычек
print('He said, "What\'s there?"')

# Экранирование двойных кавычек
print("He said, \"What's there?\"")

Использование метода format() для форматирования строк

Метод format(), доступный для строкового объекта, очень универсален и мощен в форматировании строк. Формат строки содержит фигурные скобки {} в качестве заполнителей или заменяющих полей, которые заменяются соответствующими значениями.

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

# порядок по умолчанию
default_order = "{}, {} and {}".format('John','Bill','Sean')
print(default_order)

# порядок задается вручную
positional_order = "{1}, {0} and {2}".format('John','Bill','Sean')
print(positional_order)

# порядок задается аргументами
keyword_order = "{s}, {b} and {j}".format(j='John',b='Bill',s='Sean')
print(keyword_order)

Метод format() может иметь необязательные спецификации формата. Они отделены от имени поля двоеточием. Например, мы можем выравнивать по левому краю <, выравнивать по правому краю > или центрировать ^ строку в заданном пространстве. Мы также можем отформатировать целые числа как двоичные, шестнадцатеричные и т.д., а числа с плавающей точкой могут быть округлены или отображены в формате экспоненты. Существует множество форматов, которые вы можете использовать. Более подробно про метод format() можно почитать в официальной документации к языку.

>>> # форматирование целых чисел
>>> "Binary representation of {0} is {0:b}".format(12)
'Binary representation of 12 is 1100'

>>> # форматирование чисел с плавающей запятой
>>> "Exponent representation: {0:e}".format(1566.345)
'Exponent representation: 1.566345e+03'

>>> # округление
>>> "One third is: {0:.3f}".format(1/3)
'One third is: 0.333'

>>> # выравнивание строки
>>> "|{:<10}|{:^10}|{:>10}|".format('butter','bread','ham')
'|butter | bread | ham|’

Подклассы потоков

При запуске Thread выполняет базовую инициализацию и затем вызывает свой метод run(). Он в свою очередь вызывает целевую функцию, переданную конструктору. Чтобы создать подкласс Thread, переопределите run().

import threading
import logging

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

class MyThread(threading.Thread):

    def run(self):
        logging.debug('running')
        return

for i in range(5):
    t = MyThread()
    t.start()

Возвращаемое значение метода run() игнорируется.

$ python threading_subclass.py

(Thread-1  ) running
(Thread-2  ) running
(Thread-3  ) running
(Thread-4  ) running
(Thread-5  ) running

Значения args и kwargs, передаваемые в конструктор Thread, сохраняются в private переменных. Поэтому к ним трудно получить доступ из подкласса.

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

import threading
import logging

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

class MyThreadWithArgs(threading.Thread):

    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, verbose=None):
        threading.Thread.__init__(self, group=group, target=target, name=name,
                                  verbose=verbose)
        self.args = args
        self.kwargs = kwargs
        return

    def run(self):
        logging.debug('running with %s and %s', self.args, self.kwargs)
        return

for i in range(5):
    t = MyThreadWithArgs(args=(i,), kwargs={'a':'A', 'b':'B'})
    t.start()

MyThreadWithArgs использует тот же API, что и Thread. Но другой класс может легко изменить метод конструктора, чтобы принимать другие аргументы, связанные с назначением потока.

$ python threading_subclass_args.py

(Thread-1  ) running with (0,) and {'a': 'A', 'b': 'B'}
(Thread-2  ) running with (1,) and {'a': 'A', 'b': 'B'}
(Thread-3  ) running with (2,) and {'a': 'A', 'b': 'B'}
(Thread-4  ) running with (3,) and {'a': 'A', 'b': 'B'}
(Thread-5  ) running with (4,) and {'a': 'A', 'b': 'B'}

Метод strip¶

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

Для того, чтобы избавиться от них, очень удобно использовать метод
:

In 47]: string1 = '\n\tinterface FastEthernet0/1\n'

In 48]: print(string1)

    interface FastEthernet01


In 49]: string1
Out49]: '\n\tinterface FastEthernet0/1\n'

In 50]: string1.strip()
Out50]: 'interface FastEthernet0/1'

По умолчанию метод strip() убирает пробельные символы. В этот набор
символов входят:

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

In 51]: ad_metric = '[110/1045]'

In 52]: ad_metric.strip('[]')
Out52]: '110/1045'

Определение текущего потока

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

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

import threading
import time

def worker():
    print threading.currentThread().getName(), 'Starting'
    time.sleep(2)
    print threading.currentThread().getName(), 'Exiting'

def my_service():
    print threading.currentThread().getName(), 'Starting'
    time.sleep(3)
    print threading.currentThread().getName(), 'Exiting'

t = threading.Thread(name='my_service', target=my_service)
w = threading.Thread(name='worker', target=worker)
w2 = threading.Thread(target=worker) # используем имя по умолчанию

w.start()
w2.start()
t.start()

Программа выводит имя текущего потока в каждой строке. «Thread-1» — это безымянный поток w2.

$ python -u threading_names.py

worker Thread-1 Starting
my_service Starting
Starting
Thread-1worker Exiting
 Exiting
my_service Exiting

Большинство программ не используют print для отладки. Модуль logging поддерживает добавление имени потока в каждое сообщение журнала с помощью % (threadName)s. Включение имен потоков в журнал облегчает отслеживание этих сообщений.

import logging
import threading
import time

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

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

def my_service():
    logging.debug('Starting')
    time.sleep(3)
    logging.debug('Exiting')

t = threading.Thread(name='my_service', target=my_service)
w = threading.Thread(name='worker', target=worker)
w2 = threading.Thread(target=worker) # use default name

w.start()
w2.start()
t.start()

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

$ python threading_names_log.py

 (worker    ) Starting
 (Thread-1  ) Starting
 (my_service) Starting
 (worker    ) Exiting
 (Thread-1  ) Exiting
 (my_service) Exiting