<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[Программирование]]></title><description><![CDATA[Программирование]]></description><link>https://forum.exlends.ru/category/123</link><generator>RSS for Node</generator><lastBuildDate>Wed, 20 May 2026 08:17:23 GMT</lastBuildDate><atom:link href="https://forum.exlends.ru/category/123.rss" rel="self" type="application/rss+xml"/><pubDate>Mon, 23 Mar 2026 14:31:46 GMT</pubDate><ttl>60</ttl><item><title><![CDATA[Как исправить ошибку ssl: CERTIFICATE_VERIFY_FAILED в Python]]></title><link>https://forum.exlends.ru/topic/1879/kak-ispravit-oshibku-ssl-certificate_verify_failed-v-python</link><guid isPermaLink="true">https://forum.exlends.ru/topic/1879/kak-ispravit-oshibku-ssl-certificate_verify_failed-v-python</guid><pubDate>Mon, 23 Mar 2026 14:31:46 GMT</pubDate></item><item><title><![CDATA[Интерполяция численных методов и интегрирования]]></title><description><![CDATA[Пример выше, работает благодаря того что укладывается в геометрию за счет users_at_12 = (100 + 120) / 2.
По хорошему интерполяция должна выглядеть по другому и использовать numpy.interp.
Давайте посмотрим пример:
import numpy as np

hours = [0, 4, 8, 16, 20, 24]
users = [10, 50, 100, 120, 60, 20]

hours_np = np.array(hours)
users_np = np.array(users)

users_at_12 = np.interp(12, hours_np, users_np)

print(f"Пользователей в 12:00: {int(users_at_12)}")

]]></description><link>https://forum.exlends.ru/topic/1247/interpolyaciya-chislennyh-metodov-i-integrirovaniya</link><guid isPermaLink="true">https://forum.exlends.ru/topic/1247/interpolyaciya-chislennyh-metodov-i-integrirovaniya</guid><dc:creator><![CDATA[kirilljsx]]></dc:creator><pubDate>Fri, 06 Mar 2026 15:09:14 GMT</pubDate></item><item><title><![CDATA[Обучение языку программирования Python]]></title><description><![CDATA[Часть 4 - Текстовые строки
Из предыдущих частей мы уже видел с вами строки, но в этой части поговорим о них более детально и начнем с основ.
Для того что бы создать строку в языке Python нам необходимо обернуть ее в одинарные или двойные кавычки:
"Строка"
'Строка'

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

'Тоже самое, но "наоборот"'

Также допускается использование трех кавычек:
"""Строка"""

'''Строка'''

Но у них есть особенность - это работа с многострочным текстом, к примеру четверостишье Бунина:
text = """В сухом лесу стреляет длинный кнут,
В кустарнике трещат коровы,
И синие подснежники цветут,
И под ногами лист шуршит дубовый.
"""

Между делом, есть разница между выводом через интерпретатор и функцию print(). Скопируйте код выше в интерпретатор - увидите:
'В сухом лесу стреляет длинный кнут,\nВ кустарнике трещат коровы,\nИ синие подснежники цветут,\nИ под ногами лист шуршит дубовый.\n'

Заметили \n? Это символ переноса строки, о нем мы поговорим позже.
А если вывести через print():
print("В сухом", 'лесу', """стреляет""", '''длинный кнут''')

Получим: В сухом лесу стреляет длинный кнут. Функция print() добавляет пробелы между аргументами.
Наконец, нам могут понадобиться пустые строки, они создаются любым из способов:
''
""
''' '''
""" """


Функция str()
У Python есть отдельная функция которая умеет создавать строку из другого типа данных - str():
str(98.6)
# '98.6'

str(1.0e4)
# '10000.0'

str(True)
# 'True'


Escape последовательность
Как и обещал ранее, подробнее об обратном слеше \ - это escape-последовательность внутри строк. Символ, стоящий перед \, получает особое значение. Наиболее распространённая последовательность \n обозначает переход на новую строку. Благодаря ей можно создать многострочные строки из однострочных. Взглянем на пример:
text = 'Один, \nДва, \nТри.'

print(text)
# Один,
# Два,
# Три.

Кроме того в Python есть последовательность табуляции \t которая помогает выравнивать текст:
print('\tабв')
    абв

print('а\tбв')
а    бв

print('аб\tв')
аб    в

print('абв\t')
абв


В последнем примере табуляция есть, но увидеть мы ее не сможем

Рассмотрим еще один пример последовательности, но уже для работы с кавычками \' и \":
text = "\" Раз! \" Два! \" Три! \""
'" Раз! " Два! " Три! "'

print(text)
" Раз! " Два! " Три! "

Может возникнуть ситуации когда нам понадобится обратный слеш в тексте, для этого используем просто два слеша подряд вот так:
text = "Вот \\ - слеш"
print(text)
# Вот \ - слеш


Объединение строк символом +
Почти как с числами, только наоборот: для строк можно использовать оператор сложения +, который объединяет две и более строки в одну:
'Первый ' + 'Второй'
# 'Первый Второй'

'Первый' + 'Второй'
# 'ПервыйВторой'

'Первый' + ' ' + 'Второй'
# 'Первый Второй'

Строки можно даже объединять без оператора, просто расположив их одну за другой:
"Первый " "Второй"
# 'Первый Второй'


Размножение строк
Точно также как и с оператором + мы можем использовать оператор умножения *, попробуй ввести в интерпретатор следующий код по строчно:
one = "Один " * 3 + '\n'
two = "Два " * 4 + '\n'
three = "Три."

print(one + one + two, three)

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

Извлечение символов при помощи []
Переходим к более интересной работе со строками, для того что бы получить один символ из нашей строки необходимо указать его индекс в квадратных скобках [], напомню что в языке Python есть смещение и мы начинаем с [0]:
string = "абвгд"
string[0]
# а

string[-1]
# д

string[2]
# в

Стоит учесть следующее - если мы укажем индекс больше длины строки, то получим исключение:
[image: 1771167693695-0677e478-1037-4e6e-a20a-bd48c458253d-image.webp]
Строки являются неизменными по этому если мы попробуем по индексу задать новое значение то получим исключение:
name = 'Kirill'
name[0] = 'R'

[image: 1771167852157-d43d70bd-ae42-4f9d-b1c5-835b6b81bcbe-image.webp]
И тут на помощь приходят новые функции  replace() и slice(), про них поговорим позже. А пока взглянем на код:
name = 'Kirill'
name.replace('K', 'R')
# 'Ririll'

'R' + name[1:]
# Ririll

Помните про неизменность? Интерпретатор не меняет значение у переменной, а лишь выводит результат замены.

Подстроки и разделение
Из строк можно извлекать подстроки, другими словами - часть строки. Такой проем очень похож на регулярные выражения, они кстати очень часто используются в JavaScript, хотя в Python они тоже есть, но работа с подстроками и разделением совершенно иная.
Нам необходимо задать разделение при помощи квадратных скобок, смещения подстроки в начале и смещение в конце подстроки, а также опционально можно задать шаг между ними. В подстроках будут включены символы расположенные от точки на которую мы указываем смещение начало и до точки указываемой в конце.
От теории к практике - подробнее:

[:] возвращает всю последовательность целиком (фактически срез от начала до конца)
[начало:] берет элементы, начиная с позиции начало, и до самого конца
[:конец] берет элементы от начала и до позиции конец - 1 (правая граница не включается)
[начало:конец] извлекает фрагмент от позиции начало до позиции конец - 1 (правая граница также не включается)
[начало:конец:шаг] извлекает элементы от начало до конец - 1, выбирая каждый шаг элемент (то есть берутся позиции начало, начало + шаг, начало + 2*шаг и т. д., пока не достигнем конец)

Как в предыдущих материалах я описывал смещение происходит слева на право и начинается с 0 и далее, а справа на лево -1, -2 и т.д. Если мы не укажем оператору [:] начало, по умолчанию будет использовать 0, а если не указать конец то будет использовать конец строки.
Хватит теории, сейчас поймем все на практике, напишем простую строку:
text = "привет"

print(text[:])
# привет

Если мы используем оператор [:] без аргументов, то это аналогично что начало у нас 0 и конец до конца строки.
А вот таким образом мы можем получить всем символы, начиная с 2:
text = "привет"
print(text[2:])
ивет

А теперь попробуем указать конец:
text = "привет"
print(text[2:5])
# иве

Помните про массивы списки? Представьте что наше слово привет это список - ["п","р","и","в","е","т"]
У каждого символа/буквы есть свой индекс - п=0, р=1 Так Вам будем проще ориентироваться.
Теперь попробуем задать начало с отрицанием:
text = "привет"
print(text[-2:])
# ет

Поняли что произошло? Произошел реверс, то есть наше начало пошло с конца, попробуй поэтапно начиная с -1 увеличить до -6, и в конечно итоге мы выведем наше привет.
А теперь попробуем начало задать положительным числом, а конец отрицательным:
text = "привет"
print(text[1:-1])
# риве

Мы начали с индекса 1 и закончили индексом -1 тем самым отсекли первый и последний символ.
А теперь попробуем сделать числа все отрицательными:
text = "привет"
print(text-2:-1])
# е

Напоминаю про списки и индексы, -2=е а -1=т Мы начали наше разделение с символа е и закончили на символе т - он не включается в вывод, так как является концом.
Теперь попробуем увеличить шаг:
text = "привет"
print(text::2])
# пие

А теперь мы начали с индекса 0 он же символ п и продолжаем до конца строки, но в этот раз мы перепрыгиваем через один символ так как указали последним аргументом 2.
Мы также можем объединить все:
text = "привет"
print(text[1:6:2])
# рвт

Тут мы начали с 1=р, закончили 6=т и сделал шаг между ними в 2.
Взглянем еще на такой пример:
text = "привет"
print(text[1::2])
# рвт

Получим тоже самое что и в предыдущем, но в чем же разница? А разница в том что мы выводим каждый 2 символ начиная с 1=р.
Мы также можем начинать с каждого второго символа, начиная с 0 до 6(конца):
text = "привет"
print(text[:6:2])
# пие

И на этом еще не все, мы также можем поставить начало и шаг отрицательным, взглянем:
text = "привет"
print(text[-1::-1])
# тевирп

Таким образом Python позволяет передвигаться в обратную сторону, но этот же результат мы можем получить без назначения начало -1, сделав просто шаг -1:
text = "привет"
print(text[::-1])
# тевирп

Сам по себе оператор разделения [:] лоялен к различным смещениями в отличии от поиска по индексу (списки) [].
Если мы укажем смещение меньше чем начало строки то оно обработается как 0, а если укажем смещение больше чем конец строки то обработается как -1. Взглянем на пример:
text = "привет"
print(text[-7:])
# привет

print(text[:50])
# привет

Измерение длины строк - функция len()
Материал будет добавлен по мере написания
]]></description><link>https://forum.exlends.ru/topic/508/obuchenie-yazyku-programmirovaniya-python</link><guid isPermaLink="true">https://forum.exlends.ru/topic/508/obuchenie-yazyku-programmirovaniya-python</guid><dc:creator><![CDATA[kirilljsx]]></dc:creator><pubDate>Sat, 14 Feb 2026 09:41:23 GMT</pubDate></item></channel></rss>