Python методы: полезные функции и методы python

полезные функции и методы python

Функции — одно из главных преимуществ языка Python как минимум при использовании их в проектах Data Science. Это третья часть серии материалов «Python для Data Science», в которой речь пойдет о функциях и методах.

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

Это практическое руководство!

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

Что такое функции и методы Python?

Начнем с основ. Предположим, что существует переменная:

a = 'Hello!'

Вот простейший пример функции Python:

len(a)

А вот пример метода Python:

a.upper()

Подписывайтесь на телеграм каналы

Так что такое функции и методы Python? По сути, они превращают что-то в нечто другое. В случае этого примера ввод 'Hello!' дал вывод длины строки (6) и версию строки, переписанную с большой буквы: 'HELLO!'. Конечно, это не единственные функции. Их намного больше. Их комбинация пригодится в разных частях проекта — от очистки данных до машинного обучения.

Встроенные vs. пользовательские методы и функции

Круто то, что помимо огромного списка встроенных функций/методов, пользователи могут создавать собственные. Также они поставляются с различными Python-библиотеками. Для доступа к ним библиотеку нужно скачать и импортировать. Выходит, что возможности безграничны. Но к этому стоит вернуться позже, а сейчас сосредоточимся на встроенных элементах.

Самые важные встроенные функции Python для проектов Data Science

Функция в Python работают очень просто — ее нужно вызвать с заданными аргументами, а она вернет результат. Тип аргумента (например, строка, число, логическое значение и так далее) может быть ограничен (например, иногда нужно, чтобы это было именно целое число), но чаще аргументом может выступать значение любого типа. Рассмотрим самые важные встроенные функции Python:

print()
Эта функция уже использовалась в прошлых статьях. Она выводит различные значения на экран.

print("Hello, World!")

abs()
Возвращает абсолютную величину числа (то есть, целое число или число с плавающей точкой). Результат не может быть строкой, а только числовым значением.

abs(-4/3)

round()
Возвращает округленное значение числа

round(-4/3)

min()
Возвращает наименьший объект в списке или из общего числа введенных аргументов. Это может быть в том числе и строка.

min(3,2,5)
min('c','a','b')

max()
Несложно догадаться, что это противоположность min().

sorted()
Сортирует список по возрастанию. Он может содержать и строки и числа.

a = [3, 2, 1]
sorted(a)

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

a = [3, 2, 1]
sum(a)
b = [4/3 , 2/3, 1/3, 1/3, 1/3]
sum(b)

len()
Возвращает количество элементов в списке или количество символов в строке.

len('Hello!')

type()
Возвращает тип переменной

a = True
type(a)

b = 2
type(b)

Это встроенные функции Python, которые придется использовать регулярно. Со всем списком можно ознакомиться здесь: https://docs.python.org/3/library/functions.html

С многими другими вы познакомитесь в следующих руководствах.

Самые важные встроенные методы Python

Большую часть методов Python необходимо применять по отношению к конкретному типу. Например, upper() работает со строками, но не с целыми числами. А append() можно использовать на списках, но со строками, числами и логическими значениями он бесполезен. Поэтому дальше будет список методов, разбитый по типам.

Методы для строк Python

Строковые методы используются на этапе очистки данных проекта. Например, представьте, что вы собираете информацию о том, что ищут пользователи на сайте, и получили следующие строки: 'mug', 'mug ', 'Mug'. Человеку известно, что речь идет об одном и том же, но для Python это три уникальные строки. И здесь ему нужно помочь. Для этого используются самые важные строковые методы Python:

a.lower()
Возвращает версию строки с символами в нижнем регистре.

a = 'MuG'
a.lower()

a.upper()
Противоположность lower()

a.strip()
Если в строке есть пробелы в начале или в конце, метод их удалит.

a = ' Mug '
a.strip()

a.replace(‘old’, ‘new’)
Заменяет выбранную строку другой строкой. Метод чувствителен к регистру.

a = 'muh'
a.replace('h', 'g')

a.split(‘delimiter’)
Разбивает строку и делает из нее список. Аргумент выступает разделителем.

a = 'Hello World'
a.split(' ')

Примечание: в этом случае разделителем выступает пробел.

’delimeter’.join(a)
Объединяет элементы списка в строку. Разделитель можно указать заново.

a = ['Hello', 'World']
' '.join(a)

Это были самые важные методы, для работы со строками в Python.

Методы Python для работы со списками

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

Используем уже знакомую собаку Freddie:

[dog] = ['Freddie', 9 , True, 1.1, 2001, ['bone', 'little ball']]

Теперь посмотрим, как можно изменять список.

a.append(arg)
Метод append добавляет элемент к концу списка. Предположим, что нужно добавить количество лап Freddie (4).

dog.append(4)
dog

a.remove(arg)
Удалить любой из элементов можно с помощью метода .remove(). Для этого нужно указать элемент, который необходимо удалить, а Python уберет первый такой элемент в списке.

dog.remove(2001)
dog

a.count(arg)
Возвращает позицию этого элемента в списке.

dog.count('Freddie')

a.clear()
Удаляет все элементы списка. По сути, он полностью удалит Freddie. Но не стоит волноваться, потом его можно вернуть.

dog.clear()
dog

Список всех методов для работы с Python можно найти здесь: https://docs.python.org/3/tutorial/datastructures.html

Методы Python для работы со словарями

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

И снова Freddie:

dog_dict = {'name': 'Freddie',
'age': 9,
'is_vaccinated': True,
'height': 1.1,
'birth_year': 2001,
'belongings': ['bone', 'little ball']}

dog_dict.keys()
Вернет все ключи словаря.

dog_dict.values()
Вернет все значения словаря.

dog_dict.clear()
Удалит все из словаря.

Для добавления элемента в словарь не обязательно использовать метод; достаточно просто указать пару ключ-значение следующим образом:

dog_dict['key'] = 'value'
dog_dict['name'] = 'Freddie'

Это все методы на сегодня.

Проверьте себя

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

1. Есть список: test_yourself = [1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 5]
2. Посчитайте среднее значение элементов списка, используя знания, полученные из прошлых частей руководства.
3. Посчитайте медиану, следуя тем же условиям.

.

.

.

.

.

.

Решение

sum(test_yourself) / len(test_yourself)

sum() суммирует значения элементов, а len() подсчитывает их количество. Если поделить одно значение на другое, то выйдет среднее. Результат: 2.909090

test_yourself[round(len(test_yourself) / 2) - 1]

Повезло, что в списке нечетное количество элементов.

Примечание: эта формула не сработает, если элементов будет четное количество.

len(test_yourself) / 2 подскажет, где в списке искать среднее число — это и будет медиана. Результат равен 5,5, но результат len() / 2 всегда будет на 0,5 меньше, чем реальное число, если в списке нечетное количество элементов (можете проверить на списке с 3 или 5 элементами). Округлим 5,5 до 6 с помощью round(len(test_yourself) / 2). Все верно — в данном случае внутри функции используется другая функция. Затем нужно вычесть единицу, потому что индексация начинается с нуля: round(len(test_yourself) / 2) - 1.

В конце концов результат можно подставить в качестве индекса для поиска его в списке: test_yourself[round(len(test_yourself) / 2 - 1]; или взять полученное число: test_yourself[5]. Результат — 3.

В чем разница между функциями и методами в Python?

После прочтения этой статьи у вас наверняка появился вопрос: «Зачем нужны и функции и методы, если они делают одно и то же?»

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

Сперва очевидное. Отличается синтаксис. Функция выглядит вот так: function(something), а метод вот так: something.method().

Так зачем и методы и функции нужны в Python? Официальный ответ заключается в том, что между ними есть небольшие отличия. Так, метод всегда относится к объекту (например, в dog.append(4) методу append() нужно объект dog). В функции объект не нужно использовать. Если еще проще, метод — это определенная функция. Все методы — это функции, но не все функции являются методами.

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

Вот еще один дополнительный совет: функции и методы — это как артикли (der, die, das) в немецком языке. Нужно просто выучить синтаксис и использовать их по правилам.

Как и в немецком, есть эмпирические правила, которые также должны помочь. Так, функции можно применять к разным типам объектов, а методы — нет. Например, sorted() — это функция, которая работает со строками, списками, числами и так далее. Метод upper() работает исключительно со строками.

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

Итого

Теперь вы знакомы более чем с 20 методами и функциями Python. Неплохое начало, но это только основы. В следующих руководствах их количество будет расти в том числе за счет функций и методов из сторонних библиотек.

Далее нужно будет разобраться с циклами и инструкциями if.

Что такое «метод» в Python?

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

class C:
    def method(self, possibly, other, arguments):
        pass # do something here

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

1) связанные методы

# Create an instance of C and call method()
instance = C()

print instance.method # prints '<bound method C.method of <__main__.C instance at 0x00FC50F8>>'
instance.method(1, 2, 3) # normal method call

f = instance.method
f(1, 2, 3) # method call without using the variable 'instance' explicitly

привязанные методы-это методы, принадлежащие экземплярам класса. В этом примере instance.method привязан к экземпляру с именем instance. Каждый раз, когда этот связанный метод вызывается, экземпляр передается как первый параметр автоматически — который называется self по Конвенции.

2) несвязанные методы

print C.method # prints '<unbound method C.method>'
instance = C()
C.method(instance, 1, 2, 3) # this call is the same as...
f = C.method
f(instance, 1, 2, 3) # ..this one...

instance.method(1, 2, 3) # and the same as calling the bound method as you would usually do

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

зная эту разницу, вы можете использовать функции / методы в качестве объектов, таких как передача методов. В качестве примера использования представьте API, который позволяет определить функцию обратного вызова, но вы хотите предоставить метод в качестве функции обратного вызова. Нет проблем, просто пройти self.myCallbackMethod как обратный вызов, и он будет автоматически вызываться с экземпляром в качестве первого аргумента. Это было бы невозможно в статике языки, как C++ (или только с хитростью).

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

Методы строк в Python

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

Вызов метода в Python

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


переменная.метод(аргументы)


Поиск подстроки в строке Python

Для поиска подстроки в строке в Python, есть четыре метода:

• find()
• rfind()
• index()
• rindex()

Метод find() ищет индекс подстроки в строке — возвращает номер позиции символа указанного в аргументах.


>>> s='Найти подстроку'

>>> s.find('и')

4


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


>>> s.find('под')

6


При обращении к несуществующей подстроке, вернется значение -1.


>>> s.find('ю')

-1


Метод index() тоже ищет подстроку в строке по её индексу, но в случае поиска несуществующей подстроки в отличии от find(), возвращает ошибку ValueError.

Методы rfind() и rindex() ищут подстроку с конца строки — справа.


>>> s.rfind('т')

10


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

Метод replace() заменяет одни символы на другие, где первым параметром передаем, что заменить. А во втором параметре указываем , на что заменить.


>>> s.replace('ти','**')

'Най** подстроку'


Как удалить символ из строки?

Передадим во втором параметре пустые кавычки.


>>> s.replace('п','')

'Найти одстроку'


Как удалить пробелы в строке?

Первым параметром указываем пробел, а вторым параметром — пустые кавычки.


>>> s.replace(' ','')

'Найтиподстроку'


Разделить строку в Python

По умолчанию метод split() разделяет строку по пробелам и преобразует строку в список. В итоге мы получили список из трех элементов.


>>> h='разбить строку питон'

>>> h.split()

['разбить', 'строку', 'питон']


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


# Пример 1 - разделить по тире "-"

>>> p='питон-1 питон-2'

>>> p.split('-')

['питон', '1 питон', '2']

# Пример 2 - разделить по букве "t"

>>> c='method split in python'

>>> c.split('t')

['me', 'hod spli', ' in py', 'hon']

Объединить строки в Python

Несмотря на то, что метод join() является не строковым методом. Мы все равно его изучим в рамках данного урока. Поскольку join() в Python выполняет противоположную функцию метода split(). Берет элементы списка и преобразует список в строку. Имя переменной, ссылающейся на список строк — единственный передаваемый параметр метода join(). Перед точкой, мы указали разделитель — пустые кавычки.


>>> a=['1', '2', '3', '4', '5']

>>> ''.join(a)

'12345'

# разделитель пробел

>>> ' '.join(a)

'1 2 3 4 5'

# разделитель запятая

>>> ','.join(a)

'1,2,3,4,5'

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


a=[6, 7, 8]

' '.join(a)


Перед использованием метода join(), следует числа привести к строкам.


>>> e=['9', '10']

>>> ' '.join(e)

'9 10'


Верхний регистр строки в Python

Метод upper() приводит все буквы строки к верхнему регистру, не меняя остальных символов.


>>> w='верхний регистр'

>>> w.upper()

'ВЕРХНИЙ РЕГИСТР'


Нижний регистр строки в Python

Метод lower() приводит все буквы строки к нижнему регистру.


>>> r='НИЖНИЙ РЕГИСТР'

>>> r.lower()

'нижний регистр'


Подсчет количества символов

Метод count() считает, сколько раз встречается подстрока в строке, указанная в параметрах.


>>> y="посчитать количество слов"

>>> y.count('о')

3


Проверка символов в строке

Метод isalpha() проверяет, состоит ли строка только из букв и возвращает истину или ложь.


>>> i='толькобуквы'

>>> i.isalpha()

True


Метод isdigit() проверяет, состоит ли строка только из цифр и возвращает истину или ложь.


>>> f='23456hbbn'

>>> f.isdigit()

False


• 
  Создано 30.10.2019 10:53:26

• 
  
  Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

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

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

Python 3 #8: методы строк

Как мы уже
неоднократно говорили, в Python строки являются
объектами и у этих объектов есть методы, то есть, функции, выполняющие
определенные действия:

строка.имя_метода(аргументы)

Для примера,
предположим, у нас имеется такая, уже классическая строка:

и мы собираемся
для нее вызвать метод

String.upper()

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

Вот по такому
синтаксису вызываются различные методы строк. Причем, сама переменная string продолжает
ссылается на ту же самую неизмененную строку «Hello World!». Как мы с вами
говорили на предыдущем занятии, строки – это неизменяемые объекты, поэтому
метод upper возвращает
новую строку с заглавными буквами, не меняя прежней.

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

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

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

Так тоже можно
делать.

Ну и раз уж мы
затронули метод upper, который переводит буквы в верхний
регистр, то отметим противоположный ему метод:

String.lower()

который,
наоборот, преобразует все буквы в строчные. Например:

возвращает
строку «hello world!». Соответственно, сама строка здесь остается прежней,
измененным является новый строковый объект, который и возвращает метод lower. По такому
принципу работают все методы при изменении строк. Следующий метод

String.count(sub[,
start[, end]])

возвращает число
повторений подстроки sub в строке String. Два
необязательных аргумента:

• 
  start – индекс, с
  которого начинается поиск;
  
• 
  end – индекс,
  которым заканчивается поиск.

В самом простом
случае, мы можем для строки

определить число
повторений сочетаний «ra»:

получим значение
2 – именно столько данная подстрока встречается в нашей строке.

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

Тогда метод
следует записать со значением start=4:

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

и получаем
значение 0. Почему? Ведь на индексах 9 и 10 как раз идет подстрока «ra»? Но здесь,
также как и в срезах, последний индекс исключается из рассмотрения. То есть, мы
говорим, что нужно дойти до 10-го, не включая его. А вот если запишем 11:

то последнее
включение найдется.

Следующий метод

String.find(sub[,
start[, end]])

возвращает
индекс первого найденного вхождения подстроки sub в строке String. А аргументы start и end работают также
как и в методе count. Например:

вернет 1,
т.к. первое вхождение «br» как раз начинается с индекса 1. Поставим
теперь значение start=2:

и поиск начнется
уже со второго индекса. Получим значение 8 – индекс следующего вхождения
подстроки «br». Если мы
укажем подстроку, которой нет в нашей строке:

то метод find возвращает -1. Третий
аргумент end определяет
индекс до которого осуществляется поиск и работает также как и в методе count.

Метод find ищет первое
вхождение слева-направо. Если требуется делать поиск в обратном направлении:
справа-налево, то для этого используется метод

String.rfind(sub[,
start[, end]])

который во всем
остальном работает аналогично find. Например:

возвратит 8 –
первое вхождение справа.

Наконец, третий
метод, аналогичный find – это:

String.index(sub[,
start[, end]])

Он работает
абсолютно также как find, но с одним отличием: если указанная подстрока sub не находится в
строке String, то метод
приводит к ошибке:

тогда как find возвращает -1.
Спрашивается: зачем нужен такой ущербный метод index? В
действительности такие ошибки можно обрабатывать как исключения и это бывает
полезно для сохранения архитектуры программы: когда неожиданные ситуации
обрабатываются единым образом в блоке исключений. Но, обо всем этом речь пойдет
позже.

Следующий метод

String.replace(old,
new, count=-1)

Выполняет замену
подстрок old на строку new и возвращает
измененную строку. Например, в нашей строке, мы можем заменить все буквы a на o:

на выходе
получим строку «obrokodobro». Или, так:

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

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

Заменит только
первые две буквы a: «msg.replace(«a», ‘o’, 2)». При значении
-1 количество замен неограниченно.

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

String.isalpha()

возвращает True, если строка
целиком состоит из букв и False в противном случае. Посмотрим как он
работает:

вернет True, т.к. наша
строка содержит только буквенные символы. А вот для такой строки:

мы получим False, т.к. имеется
символ пробела.

Похожий метод

String.isdigit()

возвращает True, если строка
целиком состоит из цифр и False в противном случае. Например:

т.к. имеется
символ точки, а вот так:

получим значение
True. Такая проверка
полезна, например, перед преобразованием строки в целое число:

dig = input("Введите число: ")
if(dig.isdigit()):
   dig = int(dig)
    print(dig)
else:
   print("Число введено неверно")

Следующий метод

String.rjust(width[, fillchar = ‘ ‘])

возвращает новую
строку с заданным числом символов width и при
необходимости слева добавляет символы fillchar:

Получаем строку
«  abc» с двумя
добавленными слева пробелами. А сама исходная строка как бы прижимается к
правому краю. Или, можно сделать так:

Получим строку «—abc». Причем вторым
аргументом можно писать только один символ. Если записать несколько, то
возникнет ошибка:

Если ширина width будет меньше
длины строки:

то ничего не
изменится. Аналогично работает метод

String.ljust(width[, fillchar = ‘ ‘])

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

Следующий метод

String.split(sep=None,
maxsplit=-1)

возвращает
коллекцию строк, на которые разбивается исходная строка String. Разбивка
осуществляется по указанному сепаратору sep. Например:

"Иванов Иван Иванович".split(" ")

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

"Иванов Иван Иванович".split()

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

digs = "1, 2,3, 4,5,6"
digs.replace(" ", "").split(",")

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

Обратный метод

String.join(список)

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

d = digs.replace(" ", "").split(",")
", ".join(d)

получаем строку
«1, 2, 3, 4, 5, 6». Или так, изначально была строка:

fio = "Иванов Иван Иванович"

и мы хотим здесь
вместо пробелов поставить запятые:

fio2 = ",".join(fio.split())

Теперь fio2 ссылается на
строку с запятыми «Иванов,Иван,Иванович».

Следующий метод

String.strip()

удаляет пробелы
и переносы строк в начале и конце строки. Например:

"   hello world         \n".strip()

возвращает
строку «hello world». Аналогичные
методы:

String.rtrip()
и String.ltrip()

удаляют пробелы
и переносы строк только справа и только слева.

Вот такие методы
строк существуют в Python. Для наглядности ниже они представлены
в таблице:

Задания для самоподготовки

1. Написать
программу корректности ввода телефонного номера по шаблону:

x(xxx)xxxxxx

где x – любая цифра от
0 до 9. Данные представлены в виде строки.

2. Написать
программу изменения строки

«2+3+6.7 +
82 + 5.7 +1″

на строку, в
которой все «+» заменены на «-» и удалены все пробелы

3. Написать
программу вывода чисел 0; -100; 5.6; -3 в виде столбца:

	0
	-100
	5.6
	-3

в котором все
строки выровнены по правому краю (подсказка: воспользуйтесь методом rjust).

4. В строке «abrakadabra» найдите все
индексы подстроки «ra» и выведите их (индексы) в консоль.

Python | Основные методы строк

Основные методы строк

Последнее обновление: 02.05.2017

Рассмотрим основные методы строк, которые мы можем применить в приложениях:

• isalpha(): возвращает True, если строка состоит только из алфавитных символов

• islower(): возвращает True, если строка состоит только из символов в нижнем регистре

• isupper(): возвращает True, если все символы строки в верхнем регистре

• isdigit(): возвращает True, если все символы строки — цифры

• isnumeric(): возвращает True, если строка представляет собой число

• startswith(str): возвращает True, если строка начинается с подстроки str

• endswith(str): возвращает True, если строка заканчивается на подстроку str

• lower(): переводит строку в нижний регистр

• upper(): переводит строку в вехний регистр

• title(): начальные символы всех слов в строке переводятся в верхний регистр

• capitalize(): переводит в верхний регистр первую букву только самого первого слова строки

• lstrip(): удаляет начальные пробелы из строки

• rstrip(): удаляет конечные пробелы из строки

• strip(): удаляет начальные и конечные пробелы из строки

• ljust(width): если длина строки меньше параметра width, то справа от строки добавляются пробелы, чтобы дополнить значение width,
  а сама строка выравнивается по левому краю

• rjust(width): если длина строки меньше параметра width, то слева от строки добавляются пробелы, чтобы дополнить значение width,
  а сама строка выравнивается по правому краю

• center(width): если длина строки меньше параметра width, то слева и справа от строки равномерно добавляются пробелы,
  чтобы дополнить значение width, а сама строка выравнивается по центру

• find(str[, start [, end]): возвращает индекс подстроки в строке. Если подстрока не найдена, возвращается число -1

• replace(old, new[, num]): заменяет в строке одну подстроку на другую

• split([delimeter[, num]]): разбивает строку на подстроки в зависимости от разделителя

• join(strs): объединяет строки в одну строку, вставляя между ними определенный разделитель

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

string = input("Введите число: ")
if string.isnumeric():
    number = int(string)
    print(number)

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

file_name = "hello.py"

starts_with_hello = file_name.startswith("hello")   # True
ends_with_exe = file_name.endswith("exe")           # False

Удаление пробелов в начале и в конце строки:

string = "   hello  world!  "
string = string.strip()
print(string)           # hello  world!

Дополнение строки пробелами и выравнивание:

print("iPhone 7:", "52000".rjust(10))
print("Huawei P10:", "36000".rjust(10))

Консольный вывод:

iPhone 7:      52000
Huawei P10:      36000

Поиск в строке

Для поиска подстроки в строке в Python применяется метод find(), который возвращает индекс первого вхождения подстроки в строку и
имеет три формы:

• find(str): поиск подстроки str ведется с начала строки до ее конца

• find(str, start): параметр start задает начальный индекс, с которого будет производиться поиск

• find(str, start, end): параметр end задает конечный индекс, до которого будет идти поиск

Если подстрока не найдена, метод возвращает -1:

welcome = "Hello world! Goodbye world!"
index = welcome.find("wor")
print(index)       # 6

# поиск с 10-го индекса
index = welcome.find("wor",10)
print(index)       # 21

# поиск с 10 по 15 индекс
index = welcome.find("wor",10,15)
print(index)       # -1

Замена в строке

Для замены в строке одной подстроки на другую применяется метод replace():

• replace(old, new): заменяет подстроку old на new

• replace(old, new, num): параметр num указывает, сколько вхождений подстроки old надо заменить на new

phone = "+1-234-567-89-10"

# замена дефисов на пробел
edited_phone = phone.replace("-", " ")
print(edited_phone)     # +1 234 567 89 10

# удаление дефисов
edited_phone = phone.replace("-", "")
print(edited_phone)     # +12345678910

# замена только первого дефиса
edited_phone = phone.replace("-", "", 1)
print(edited_phone)     # +1234-567-89-10

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

Метод split() разбивает строку на список подстрок в зависимости от разделителя. В качестве разделителя может выступать любой символ или последовательность символов.
Данный метод имеет следующие формы:

• split(): в качестве разделителя используется пробел

• split(delimeter): в качестве разделителя используется delimeter

• split(delimeter, num): параметр num указывает, сколько вхождений delimeter используется для разделения. Оставшаяся часть строки добавляется
  в список без разделения на подстроки

text = "Это был огромный, в два обхвата дуб, с обломанными ветвями и с обломанной корой"
# разделение по пробелам
splitted_text = text.split()
print(splitted_text)
print(splitted_text[6])     # дуб,

# разбиение по запятым
splitted_text = text.split(",")
print(splitted_text)
print(splitted_text[1])     # в два обхвата дуб

# разбиение по первым пяти пробелам
splitted_text = text.split(" ", 5)
print(splitted_text)        
print(splitted_text[5])     # обхвата дуб, с обломанными ветвями и с обломанной корой

Соединение строк

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

words = ["Let", "me", "speak", "from", "my", "heart", "in", "English"]

# разделитель - пробел
sentence = " ".join(words)
print(sentence)  # Let me speak from my heart in English

# разделитель - вертикальная черта
sentence = " | ".join(words)
print(sentence)  # Let | me | speak | from | my | heart | in | English

Вместо списка в метод join можно передать простую строку, тогда разделитель будет вставляться между символами этой строки:

word = "hello"
joined_word = "|".join(word)
print(joined_word)      # h|e|l|l|o

что, зачем и почему? CODE BLOG

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

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

Подпишись на группу Вконтакте и Телеграм-канал. Там еще больше полезного контента для программистов.
А на YouTube-канале ты найдешь обучающие видео по программированию. Подписывайся!

Инициализация

Инициализация экземпляра класса осуществляется с помощью передачи аргументов в скобки, а обрабатывает эти параметры магический метод __init__(). Объявим класс Vector и определим там этот метод:

class Vector(object):
    def init(self, *args):   
        if isinstance(args[0], int) or isinstance(args[0], float):
            self.__values = tuple(args)
        else:
            if len(args) != 1:
                 raise ValueError('...')

        self.__values = tuple(args[0])

    self.shape = len(self.__values)

В описании ValueError указано троеточие лишь из-за того, что полное описание ошибки не влезет в блок кода. В конце статьи будет оставлена ссылка на исходник, где будет присутствовать полное описание ошибок.

Такое объявление конструктора класса даёт нам возможность создать экземпляр класса двумя способами:

v = Vector(1, 2, 3)
v = Vector([1, 2, 3])

Поле shape создано для имитации интерфейса NumPy, где это поле присутствует у каждого экземпляра класса numpy.ndarray.

Использование встроенных функций

Теперь реализуем несколько магических методов, которые используют встроенные функции.
Первый из них __len__(), который использует функция len— вызов len(obj) эквивалентно конструкции obj.__len__().

def __len__(self):
    return self.shape

Протестируем эту возможность:

>>> v.shape, len(v)
(3, 3)

Далее мы будем вычислять модуль вектора, то есть его длину. Формулу длины вектора приводить не буду, её и так все знают. Функция abs() (название от англ. absolute) использует магический метод __abs__(). Объявим этот метод в нашем классе:

def __abs__(self):
    return sum(self**2)**0.5

>>> abs(v)
3.7416573867739413

Функция sum() в качестве аргумента принимает итерируемый объект. Реализация итерации по объекту возможна с помощью метода __iter__().

def __iter__(self):
    return iter(self.__values)

Пример использования:

for el in v:
    print(el)

1
2
3

Теперь реализуем методы конвертации в строку и метод, отвечающий за представление объекта в интерпретаторе.
Первый из них — __str__(), второй — __repr__ ().

def __str__(self) -> str:
    return '<' + ', '.join([str(v) for v in self]) + '>'


def __repr__(self) -> str:
    return 'Vector(' + self.__str__() + ')'

Чтобы протестировать эти методы, воспользуемся функцией print() и интерпретатором Python.

>>> print(v)
<1, 2, 3>
>>> v
Vector(<1, 2, 3>)

Математические магические методы

Теперь мы займемся перегрузкой операторов — сделаем так, чтобы операторы +, -, /, * и т.д. могли использовать наш класс в качестве операнда.

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

Концепция перегрузки операторов одинакова, потому я предоставляю список различных методов и соответствующих операций:

• __add__() — v + 1
• __sub__() — v - 1
• __mul__() — v * 1
• __div__() — v / 1
• __mod__() — v % 1
• __floordiv__() — v / / 1
• __divmod__() — divmod(v, 1)
• __pow__() — v ** 1
• __lshift__() — v << 1
• __rshift__() — v >> 1

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

    def __mul__(self, value):
        if isinstance(value, int) or isinstance(value, float):
            return Vector([value * coor for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v1 * v1 for v1, v2 in zip(value, self)])
        else:
            raise TypeError(f'...')
        
        
    def __div__(self, value):
        if isinstance(value, int) or isinstance(value, float):
            return Vector([coor / value for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v1 / v2 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')
                
                
    def __add__(self, value):
        if isinstance(value, int) or isinstance(value, float):
            return Vector([coor + value for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(...')
                
            return Vector([v1 + v2 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')
                
    
    def __sub__(self, value):
        if isinstance(value, int) or isinstance(value, float):
            return Vector([coor - value for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'Wrong dimension for operand. Expected {self.shape}, got {value.shape}')
                
            return Vector([v1 - v2 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')
                
                
    def __mod__(self, value):
        if isinstance(value, int) or isinstance(value, float):
            return Vector([coor % value for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'Wrong dimension for operand. Expected {self.shape}, got {value.shape}')
                
            return Vector([v1 % v2 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')
                
    
    def __floordiv__(self, value):
        if isinstance(value, int) or isinstance(value, float):
            return Vector([coor // value for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v1 // v2 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')
                
                
    def __divmod__(self, value):
        raise TypeError('This class does not support using with divmod() function.')
        

    def __pow__(self, value):
        if isinstance(value, int) or isinstance(value, float):
            return Vector([coor ** value for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v1 ** v2 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')
                
                
    def __lshift__(self, value):
        if isinstance(value, int) or isinstance(value, float):
            return Vector([coor << value for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v1 << v2 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')


    def __rshift__(self, value):
        if isinstance(value, int) or isinstance(value, float):
            return Vector([coor >> value for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v1 >> v2 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')

Наш объект не поддерживает метод __divmod__(), т.к. использование функции divmod() не совсем соответствует нашей идеи о возвращении нового экземпляра Vector.

Обратные операции

Также существуют магические методы, отвечающие за обратные операции, к примеру, выражение 1 + v вызывает v.__radd__(1).

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

Реализуем все эти методы в нашем классе:

    def __rsub__(self, value):
        
        if isinstance(value, int) or isinstance(value, float):
            return Vector([value - coor for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v2 - v1 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')
 

    def __rpow__(self, value):
        
        if isinstance(value, int) or isinstance(value, float):
            return Vector([value ** coor for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v2 ** v1 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')
                

    def __rdiv__(self, value):
        
        if isinstance(value, int) or isinstance(value, float):
            return Vector([value / coor for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v2 / v1 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')

        
    def __rfloordiv__(self, value):
        
        if isinstance(value, int) or isinstance(value, float):
            return Vector([value // coor for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v2 // v1 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')

            
    def __rmod__(self, value):
        
        if isinstance(value, int) or isinstance(value, float):
            return Vector([value % coor for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v2 % v1 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')

                
    def __rlshift__(self, value):
        
        if isinstance(value, int) or isinstance(value, float):
            return Vector([value << coor for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v2 << v1 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')
                
                
    def __radd__(self, value):
        return self.__add__(value)
    
    
    def __rmul__(self, value):
        return self.__mul__(value)

                
    def __rrshift__(self, value):
        
        if isinstance(value, int) or isinstance(value, float):
            return Vector([value >> coor for coor in self])
        elif isinstance(value, Vector):
            if value.shape != self.shape:
                raise ValueError(f'...')
                
            return Vector([v2 >> v1 for v1, v2 in zip(self, value)])
        else:
             raise TypeError(f'...')

Теперь протестируем выполнение математических операций с нашим вектором
<1, 2, 3>.

>>> v * 2, 3 * v, v * Vector([1, 2, 3])
(Vector(<2, 4, 6>), Vector(<3, 6, 9>), Vector(<1, 4, 9>))

>>> v + 2, v - 1, 1 - v, 1 + v
(Vector(<3, 4, 5>), Vector(<0, 1, 2>), Vector(<0, -1, -2>), Vector(<2, 3, 4>))

>>> v + Vector([1, 2, 3]), v - Vector([0, 1, 0])
(Vector(<2, 4, 6>), Vector(<1, 1, 3>))

>>> v ** 2, 2 ** v, v ** Vector([1, 2, 3])
(Vector(<1, 4, 9>), Vector(<2, 4, 8>), Vector(<1, 4, 27>))

>>> v << 1, v >> 2, 2 >> v, 1 << v
(Vector(<2, 4, 6>), Vector(<0, 0, 0>), Vector(<1, 0, 0>), Vector(<2, 4, 8>))

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

Магические методы какЛогические операции

В Python есть три логические операции — И, ИЛИ, XOR.

Соответствующие им магические методы: __and__(), __or__(), __xor__(). Для них также существуют обратные операции — __rand__(), __ror__() и __rxor__(). Реализация этих методов в нашем классе выглядит следующим образом:

    def __and__(self, value):
        return bool(value) & bool(self)
                
        
    def __or__(self, value):
        return bool(value) | bool(self)
    
    
    def __xor__(self, value):
        return bool(value) ^ bool(self)


    def __and__(self, value):
        return bool(value) & bool(self)
                
        
    def __or__(self, value):
        return bool(value) | bool(self)
    
    
    def __xor__(self, value):
        return bool(value) ^ bool(self)

Здесь есть один очень важный момент — bool(self). Т.е. мы вызываем функцию bool, передав ей текущий экземпляр класса.

Функция bool использует магический метод __bool__(), который возвращает булевое значение, как ни странно.

Наша логика заключается в следующем — если хотя бы один элемент вектора не равен 0, то булевое значение вектора равно True, и False в обратном случае.

def __bool__(self) -> bool:
     for value in self.__values:
         if value != 0: 
            return True 
    return False

Протестируем логические операции с нашим вектором:

>>> v & 1, v & 0, v | 1, v ^ 1
(True, False, True, False)

>>> 1 & v, 0 | 1, 0 ^ v
(True, 1, True)

Заключение

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

Ссылка на код класса из статьи вы можете найти здесь.

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

А также подписывайтесь на группу ВКонтакте, Telegram и YouTube-канал. Там еще больше полезного и интересного для программистов.

Похожее

Простое объяснение методов класса, экземпляра класса и статических методов в Python

Перевод статьи «Python’s Instance, Class, and Static Methods Demystified».

В этой статье я постараюсь объяснить,
что стоит за методами
класса, статическими
методами и обычными методами
экземпляра класса.

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

Обзор статических методов,
методов класса и экземпляра класса

Давайте начнем с написания класса (на
Python 3), который будет содержать простые
примеры методов всех трех видов:

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

Примечание для пользователей Python
2. Декораторы @staticmethod и @classmethod доступны
в Python начиная с версии 2.4, а значит, этот
пример тоже будет работать. Вместо
использования простого объявления
класса class MyClass: вы можете объявить класс
нового стиля, который будет наследоваться
от object, с синтаксисом class MyClass(object):. Все
остальное не требует каких-то уточнений.

Методы экземпляра класса

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

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

Методы экземпляра также могут иметь
доступ к самому классу — при помощи
атрибута self.__class__. Это означает, что они
могут менять состояние не только объекта,
но и класса.

Методы класса

Давайте сравним то, что мы узнали о
методах экземпляра класса, со вторым
методом — MyClass.classmethod. Я обозначил этот
метод при помощи декоратора @classmethod,
чтобы было видно, что это метод класса.

Методы класса вместо параметра self
принимают параметр cls. Этот параметр
при вызове метода указывает не на
экземпляр объекта, а на класс.

Поскольку метод класса имеет доступ
только к аргументу cls, он не может изменять
состояние экземпляра объекта. Для этого
нужен доступ к self. Но, тем не менее, методы
класса могут изменять состояние класса
в целом, что затронет и все экземпляры
этого класса.

Статические методы

Третий метод, MyClass.staticmethod, обозначен
при помощи декоратора @staticmethod, чтобы
показать, что этот метод статический.

Методы такого типа не принимают в
качестве параметра ни self, ни cls (хотя,
безусловно, они свободно могут принимать
другие параметры в любых количествах).

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

Давайте посмотрим, как все
это работает!

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

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

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

Вот что происходит при вызове метода
экземпляра класса:

>>> obj = MyClass()
>>> obj.method()
('instance method called', <MyClass instance at 0x101a2f4c8>)

Мы видим, что method (т. е., метод
экземпляра класса) имеет доступ к
экземпляру объекта (это видно по выводу
<MyClass instance>) при помощи аргумента
self.

При вызове этого метода Python замещает
аргумент self экземпляром объекта (obj). Мы
можем проигнорировать синтаксический
сахар dot-call синтаксиса (obj.method()) и получить
тот же результат, передав экземпляр
объекта вручную:

>>> MyClass.method(obj)
('instance method called', <MyClass instance at 0x101a2f4c8>)

Можете догадаться, что произойдет,
если вы попытаетесь вызвать этот метод
без первоначального создания экземпляра
класса?

Кстати, методы экземпляра класса при
помощи атрибута self.__class__ также могут
иметь доступ и к самому классу. Это
делает данные методы особенно полезными
в условиях ограничений доступа: они
могут изменять состояние экземпляра
объекта и самого класса.

Теперь давайте испытаем метод класса:

>>> obj.classmethod()
('class method called', <class MyClass at 0x101a2f4c8>)

Вызов classmethod() показал, что этот метод
не имеет доступа к объекту <MyClass
instance>. Но у него есть доступ к объекту
<class MyClass>, который представляет сам
класс (в Python вообще все является объектом,
даже классы).

Стоит отметить, что при вызове
MyClass.classmethod() Python автоматически передает
класс в качестве первого аргумента
функции. Это поведение Python запускается,
если метод вызывается при помощи
dot-синтаксиса. В методах экземпляра
класса аналогично работает параметр
self.

Пожалуйста, обратите внимание, что
эти параметры именуются self и cls лишь в
силу соглашений. С тем же успехом вы
можете назвать их the_object и the_class. Важно
то, что они идут первыми в списке
параметров метода.

А теперь давайте вызовем статический
метод:

>>> obj.staticmethod()
'static method called'

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

Просто когда при вызове статического
метода с использованием dot-синтаксиса
не передаются аргументы self или cls, Python
применяет ограничения доступа.

Этот пример подтверждает, что статические
методы не имеют доступа ни к состоянию
экземпляра объекта, ни к состоянию
класса. Они работают как обычные функции,
но при этом относятся к пространству
имен класса (и каждого его экземпляра).

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

>>> MyClass.classmethod()
('class method called', <class MyClass at 0x101a2f4c8>)

>>> MyClass.staticmethod()
'static method called'

>>> MyClass.method()
TypeError: unbound method method() must
    be called with MyClass instance as first
    argument (got nothing instead)

Нам прекрасно удалось вызвать
classmethod() и staticmethod() , но попытка вызвать
метод экземпляра класса method() провалилась
(TypeError).

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

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

Мои примеры будут основаны на классе
Pizza:

class Pizza:
    def __init__(self, ingredients):
        self.ingredients = ingredients

    def __repr__(self):
        return f'Pizza({self.ingredients!r})'

>>> Pizza(['cheese', 'tomatoes'])
Pizza(['cheese', 'tomatoes'])

Примечание. В этом примере кода
(а также в последующих) для форматирования
строки, возвращаемой при помощи __repr__,
мы будем использовать Python
3.6 f-strings. В Python 2 и версиях Python 3 до 3.6
для форматирования строки следует
использовать другие выражения, например:

def __repr__(self):
    return 'Pizza(%r)' % self.ingredients

Фабрики вкусной пиццы и
@classmethod

Наверняка вы знаете, что существует
множество вкусных вариантов пиццы:

Pizza(['mozzarella', 'tomatoes'])
Pizza(['mozzarella', 'tomatoes', 'ham', 'mushrooms'])
Pizza(['mozzarella'] * 4)

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

Это можно сделать красиво и чисто,
используя методы класса в качестве
фабричных
функций для разных видов пиццы:

class Pizza:
    def __init__(self, ingredients):
        self.ingredients = ingredients

    def __repr__(self):
        return f'Pizza({self.ingredients!r})'

    @classmethod
    def margherita(cls):
        return cls(['mozzarella', 'tomatoes'])

    @classmethod
    def prosciutto(cls):
        return cls(['mozzarella', 'tomatoes', 'ham'])

Обратите внимание, что я использую
аргумент cls в фабричных методах margherita
и prosciutto, а не вызываю конструктор Pizza
напрямую.

Вы можете использовать этот прием, чтобы придерживаться принципа DRY (Don’t Repeat Yourself, «Не повторяйся»). Если в какой-то момент мы решим переименовать этот класс, нам не придется обновлять еще и имя конструктора во всех фабричных функциях classmethod.

Что же мы можем сделать при помощи
этих фабричных методов? Давайте испытаем
их:

>>> Pizza.margherita()
Pizza(['mozzarella', 'tomatoes'])

>>> Pizza.prosciutto()
Pizza(['mozzarella', 'tomatoes', 'ham'])

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

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

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

Когда стоит использовать
статические методы

Здесь придумать хороший пример немного
сложнее. Но знаете что? Я просто продолжу
растягивать аналогию с пиццей.

Вот что я придумал:

import math

class Pizza:
    def __init__(self, radius, ingredients):
        self.radius = radius
        self.ingredients = ingredients

    def __repr__(self):
        return (f'Pizza({self.radius!r}, '
                f'{self.ingredients!r})')

    def area(self):
        return self.circle_area(self.radius)

    @staticmethod
    def circle_area(r):
        return r ** 2 * math.pi

Что здесь изменилось? Для начала, я
изменил конструктор и __repr__, чтобы
принимался дополнительный аргумент
radius.

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

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

>>> p = Pizza(4, ['mozzarella', 'tomatoes'])
>>> p
Pizza(4, ['mozzarella', 'tomatoes'])
>>> p.area()
50.26548245743669
>>> Pizza.circle_area(4)
50.26548245743669

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

Как мы уже знаем, статические методы
не имеют доступа к состоянию класса или
объекта, потому что не принимают аргументы
cls или self. Это большое ограничение, но
также и отличный сигнал, показывающий,
что данный метод ни от чего не зависит.

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

Так в чем же польза?

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

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

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

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

Статические методы также имеют
преимущество при тестировании кода.

Поскольку метод circle_area() совершенно
не зависит от остального класса, его
гораздо проще тестировать. Мы можем это
сделать при помощи модульного теста,
не беспокоясь об экземпляре класса в
целом. То есть, этот метод тестируется,
как обычная функция. Опять же, это
облегчает поддержку кода в будущем.

Ключевые выводы

• Для методов экземпляра класса
  наличие самого экземпляра класса
  является обязательным. Доступ к нему
  они могут иметь благодаря параметру
  self.
• Методы класса в экземпляре класса
  не нуждаются. Они не имеют доступа к
  экземпляру класса, но имеют доступ к
  самому классу благодаря параметру cls.
• Статические методы не имеют доступа
  к cls или self. Они действуют как обычные
  функции, но принадлежат к пространству
  имен класса.
• Статические методы и методы класса
  сообщают о намерениях разработчика
  относительно дизайна класса (и в
  определенной степени принудительно
  их осуществляют). Это дает преимущества
  по части поддерживаемости кода.

Метод Python

— классы, объекты и функции в Python

1. Метод Python — цель

В нашем последнем руководстве мы обсудили функций в Python . Сегодня в этом руководстве по методам Python мы обсудим, что такое метод на языке программирования Python. Кроме того, мы изучим метод класса Python и объект Python. Наряду с этим мы изучим функции Python.

Итак, приступим к классу и объекту Python.

Метод Python

2.Введение в метод Python

Вы ведь знаете, что Python — объектно-ориентированный язык, верно? Это означает, что он может работать с классами и объектами для моделирования реального мира. Метод Python — это метка, которую можно вызывать для объекта; это фрагмент кода, который нужно выполнить для этого объекта. Но прежде чем мы начнем углубляться, давайте кратко рассмотрим классы и объекты, и если у вас возникнут какие-либо сомнения в методе Python, спросите в комментарии.
Learn: наследование Python, перегрузка метода и переопределение метода

3.Метод класса Python

Класс Python — это абстрактный тип данных (ADT). Думайте об этом как о проекте. Ракета, сделанная по ее чертежу, идет по плану. Он имеет все свойства, указанные в плане, и ведет себя соответствующим образом. Точно так же класс — это план объекта. В качестве примера мы предлагаем подумать о машине. Класс «Автомобиль» содержит такие свойства, как марка, модель, цвет, топливо и т. Д. Он также поддерживает такие функции, как start (), halt (), drift (), ускорение () и turn ().Тогда объект Hyundai Verna имеет следующие свойства.

марка: «Hyundai»

модель: «Верна»

цвет: «Черный»

топливо: «Дизель»

Здесь это объект класса Car, и мы можем назвать его «car1» или «blackverna».

 >>> класс Автомобиль:
          def __init __ (я, марка, модель, цвет, топливо):
                  self.brand = бренд
                  self.model = модель
                  self.color = цвет
                  я.топливо = топливо
           def start (self):
                  проходить
           def halt (self):
                  проходить
           def дрейф (сам):
                  проходить
           def ускорение (самостоятельно):
                  проходить
           def Turn (self):
                  пройти 

Learn: Python множественное наследование — Python MRO (порядок разрешения методов)

4. Объекты Python

Объект Python — это экземпляр класса.У него могут быть свойства и поведение. Мы только что создали класс Car. Теперь давайте создадим объект blackverna из этого класса. Помните, что вы можете использовать класс для создания любого количества объектов.

 >>> blackverna = Автомобиль ('Hyundai', 'Verna', 'Черный', 'Дизель') 

Это создает объект Car, называемый blackverna, с вышеупомянутыми атрибутами. Мы сделали это, вызвав класс как функцию (синтаксис). Теперь давайте обратимся к его атрибуту топлива. Для этого мы используем оператор точки в Python (.).

 >>> blackverna.fuel 

«Дизель»

Learn: Python Operator Overloading and Python Magic Methods

5. Метод Python

Метод Python похож на функцию Python, но он должен вызываться для объекта. И чтобы создать его, вы должны поместить его в класс. Теперь в этом классе Car у нас есть пять методов, а именно start (), halt (), drift (), speedup () и turn (). В этом примере мы помещаем инструкцию pass в каждый из них, потому что мы еще не решили, что делать.Давайте вызовем метод Python drift () в blackverna.

 >>> blackverna.drift ()
>>> 

Как и функция, метод имеет имя, может принимать параметры и иметь оператор возврата. Возьмем для этого пример.

 >>> class Попробуйте:
        def __init __ (сам):
                проходить
        def printhello (я, имя):
                print (f "Привет, {имя}")
                вернуть имя
>>> obj = Try ()
>>> объект.printhello ('Аюши') 

Привет, Аюши

‘Ayushi’

Здесь метод printhello () имеет имя, принимает параметр и возвращает значение.

• Интересное открытие — Когда мы впервые определили класс Car, мы не передали параметр «self» пяти методам класса. Это нормально работало с атрибутами, но когда мы вызывали метод drift () в blackverna, он выдавал следующую ошибку:

Traceback (последний звонок последний):

Файл «», строка 1, в

blackverna.дрифт ()

TypeError: drift () принимает 0 позиционных аргументов, но дано 1

Исходя из этой ошибки, мы пришли к выводу, что во всех этих методах отсутствует параметр «self». Затем мы добавили его ко всем и снова вызвали drift () в blackverna. Это все еще не сработало.

Наконец, мы снова объявили объект blackverna, а затем вызвали для него drift (). На этот раз все сработало без проблем. Сделайте из этой информации, что хотите.

Learn: Python Counter — Python Collections Type

6.__init __ ()

Если вы знакомы с любым другим объектно-ориентированным языком, вы знаете о конструкторах. В C ++ конструктор — это специальная функция с тем же именем, что и класс, используемая для инициализации атрибутов класса. Здесь в Python __init __ () — это метод, который мы используем для этой цели. Давайте посмотрим на часть __init__ другого класса.

 >>> класс Животное:
       def __init __ (я, вид, пол):
                 self.species = разновидности
                 я.пол = пол
>>> пушистый = Животное ('Собака', 'Самка')
>>> пушистый.гендер 

«Женский»

Здесь мы использовали __init__ для инициализации атрибутов «вид» и «пол».

Однако вам не нужно определять эту функцию, если она вам не нужна в вашем коде.

 >>> класс Try2:
        def привет (сам):
            print ("Привет")
>>> obj2 = Try2 ()
>>> obj2.hello () 

Init — это магический метод, поэтому перед и после него стоит двойное подчеркивание.Мы узнаем о магических методах в следующем разделе этой статьи.

Обучение: разница между методом и функцией в Python

7. Собственные параметры Python

До сих пор вы могли заметить, что мы использовали параметр «self» во всех методах, даже в __init __ (). Это указывает интерпретатору работать с текущим объектом. Это похоже на ключевое слово this в Java. Давайте рассмотрим другой код, чтобы увидеть, как это работает.

 >>> класс Фрукты:
        def printstate (себя, состояние):
               print (f "Апельсин {состояние}")
>>> апельсин = Фрукты ()
>>> оранжевый.printstate ("спелый") 

Апельсин спелый

Как видите, параметр «self» сказал методу действовать с текущим объектом, то есть оранжевым. Возьмем другой пример.

 >>> class Результат:
            def __init __ (я, физ, химия, математика):
                          self.phy = phy
                          self.chem = chem
                          self.math = математика
            def printavg (сам):
                          print (f "Среднее = {(self.phy + self.chem + self.math) / 3} ")
>>> rollone = Результат (86,95,85)
>>> rollone.chem 

95

 >>> rollone.printavg () 

Среднее значение = 88,66666666666667

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

 >>> класс LED:
        def __init __ (сам):
                  self.lit = Ложь
>>> obj = LED ()
>>> obj.lit 

Ложь

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

 >>> класс Try3:
         def __init __ (thisobj, имя):
                   thisobj.name = имя
>>> obj1 = Try3 ('Лев')
>>> obj1.name 

«Лев»

Это все о параметре Python Self

Learn: оператор сравнения в Python с синтаксисом и примерами

Есть еще сомнения в методе Python? Прокомментируйте, пожалуйста.

8. Функции Python и метод

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

1. Пока для объекта вызывается метод, функция является универсальной.
2. Поскольку мы вызываем метод объекта, он связан с ним. Следовательно, он может обращаться к данным внутри класса и работать с ними.
3. Метод может изменить состояние объекта; функция не работает, когда объект передается ей в качестве аргумента.Мы видели это в нашем руководстве по кортежам.

9. Магические методы Python

Еще одна конструкция, которую предоставляет нам Python, — это магические методы Python. Такой метод обозначается двойным подчеркиванием перед его названием и после него. Другое название магического метода — дандер.

Магический метод используется для реализации функций, которые нельзя представить как обычный метод. __init __ () — не единственный волшебный метод в Python; мы узнаем об этом больше в будущем уроке.Но пока мы просто назовем некоторые из магических методов:

__добавить__ для +

__sub__ для —

__mul__ для *

__and__ для &

Однако список на этом не заканчивается.

Learn: Работа в Python — возможности карьерного роста в Python

Это все о методе Python.

10. Заключение: метод Python

Метод Python, каким мы его знаем, очень похож на функцию, за исключением того факта, что он связан с объектом.Теперь вы знаете, как определить метод и использовать метод __init__ и self-параметр, или как вы хотите его назвать. Не забудьте пересмотреть различные методы, которые мы обсуждали в наших руководствах по . Python перечисляет , кортежей, , строк, , устанавливает и словарей в python . Если у вас есть какие-либо сомнения относительно метода Python, спросите.

Номер ссылки

.

Строковые методы Python

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

.

Магических методов в Python

• Подписывайтесь на нас

• Питон
• ASP.NET Core
• MVC
• IoC
• Веб-API
• C #
• TypeScript
• Node.js
• Больше

  ✕

  . Учебники .NET

  • ASP.NET Core
  • ASP.NET MVC
  • IoC
  • веб-API
  • C #
  • LINQ

  Учебники по скриптам

  • TypeScript
  • AngularJS 1
  • Узел.js
  • D3.js
  • jQuery
  • JavaScript

  Другие учебные пособия

  • Python
  • Sass
  • Https

  Тесты навыков

  • ASP.NET Core
  • ASP.NET MVC
  • LINQ
  • C #
  • веб-API
  • IoC
  • TypeScript
  • AngularJS
  • Node.js
  • jQuery
  • JavaScript

• Статьи
• Тесты
• Напишите нам

• Учебники по Python
• Python — начало работы
• Python — Обзор
• Python — настройка среды
• Python — оболочка
• Python — IDLE
• Python — редакторы
• Python — базовый синтаксис
• Python — переменные
• Python — Типы данных
• • Число
  • Строка
  • Список
  • Кортеж
  • Установлен
  • Словарь
• Python — Операторы
• Python — Контроль принятия решений
• Python — цикл пока
• Python — цикл For
• • еще цикл
  • сломать
  • Продолжать
  • проходить
• Python — диапазон ()
• Python — функция
• • Лямбда-функция
• Python — переменная область видимости
• Python — модуль
• • Атрибуты модуля
• Python — встроенные модули
• • Модуль ОС
  • Системный модуль
  • Математический модуль
  • Модуль статистики
  • Модуль Коллекции
  • Случайный модуль
• Python — Пакеты
• Python — Итератор
• Python — Генератор
• Python — функция карты
• Python — функция фильтра
• Python — функция сокращения
• Python — понимание списка
• Python — Рекурсия

.

Список методов в Python — GeeksforGeeks

Эта статья является расширением следующих статей:
Python List
List Methods в Python | Установить 1 (in, not in, len (), min (), max ()…)
Списочные методы в Python | Установить 2 (del, remove (), sort (), insert (), pop (), extend ()…)

Добавление и добавление

• append (): Используется для добавления и добавления элементов в список. Используется для добавления элементов в последнюю позицию списка.
  Синтаксис:

   лист.добавить (элемент) 

  Список = [ «Математика» , «химия» , 1997 , 2000 ] Список . Приложение ( 20544 ) печать ( Список )

  Выход:

   [«Математика», «химия», 1997, 2000, 20544]
   

• insert (): Вставляет элементы в указанную позицию.
  Синтаксис:
  

   list.insert (<позиция, элемент) 

  Примечание. Упомянутая позиция должна быть в пределах диапазона List, так как в этом случае между 0 и 4, иначе вызовет IndexError.

  Список = [ «Математика» , «химия» , 1997 , 2000 ] Список .вставка ( 2 , 10087 ) печать ( Список )

  Выход:

   [«Математика», «химия», 10087, 1997, 2000, 20544]
   

• extend (): Добавляет содержимое в список List2 в конец списка List1.
  Синтаксис:

   List1.extend (Список2) 

  Список1 = [ 1 , 2 , 3 ] Список2 = [ 2 , 3 , 4 , 5 ] Список1.расширить (List2) печать (Список1) List2.extend (Список1) печать (Список2)

  Выход:

   [1, 2, 3, 2, 3, 4, 5]
  [2, 3, 4, 5, 1, 2, 3, 2, 3, 4, 5] 

функции sum (), count (), index (), min () и max () списка

• sum (): Вычисляет сумму всех элементов списка.
  Синтаксис:

   сум (список) 

  Список = [ 1 , 2 , 3 , 4 , 5 ] печать ( сумма ( Список ))

  Выход:

   15
   

  Что произойдет, если числовое значение не используется в качестве параметра?
  Сумма вычисляется только для числовых значений, в противном случае выдается ошибка TypeError.
  См. Пример:

  Список = [ 'gfg' , 'abc' , 3 ] печать ( сумма ( Список ))

  Выход:

   Traceback (последний звонок последний):
    Файл "", строка 1, в
      сумма (Список)
  TypeError: неподдерживаемые типы операндов для +: 'int' и 'str'
   

• count (): Вычисляет общее количество вхождений данного элемента списка.
  Синтаксис:

   List.count (элемент) 

  Список = [ 1 , 2 , 3 , 1 , 2 , 1 , 2 , 3 , 2 , 1 ] печать ( Список .количество ( 1 ))

  Выход:

   4
   

• length: Вычисляет общую длину списка.
  Синтаксис:

   len (имя_списка) 

  Список = [ 1 , 2 , 3 , 1 , 2 , 1 , 2 , 3 , 2 , 1 ] печать ( лен ( Список ))

  Выход:

   10
   

• index (): Возвращает индекс первого вхождения.Начальный и конечный индексы не являются обязательными параметрами.
  Синтаксис:

   List.index (элемент [, начало [, конец]]) 

  Список = [ 1 , 2 , 3 , 1 , 2 , 1 , 2 , 3 , 2 , 1 ] печать ( Список .индекс ( 2 ))

  Выход:

   1
   

  Другой пример:

  Список = [ 1 , 2 , 3 , 1 , 2 , 1 , 2 , 3 , 2 , 1 ] печать ( Список .индекс ( 2 , 2 ))

  Выход:

   4
   

  Список = [ 1 , 2 , 3 , 1 , 2 , 1 , 2 , 3 , 2 , 1 ] печать ( "После проверки в диапазоне индекса от 2 до 4" ) печать ( Список .индекс ( 2 , 2 , 5 )) печать ( "После проверки в диапазоне от 2 до 3" ) печать ( Список .index ( 2 , 2 , 4 ))

  Выход:

  После проверки в диапазоне индексов от 2 до 4
  4
  После проверки в диапазоне от 2 до 3
  Отслеживание (последний вызов последний):
    Файл "", строка 1, в
      Список.индекс (2,2,4)
  ValueError: tuple.index (x): x не в кортеже
   

• min (): Вычисляет минимум всех элементов списка.
  Синтаксис:

   мин. (Список) 

  Список = [ 2,3 , 4,445 , 3 , 5,33 , 1,054 , 2,5 ] печать ( мин ( Список ))

  Выход:

   1.054
   

• max (): Вычисляет максимум всех элементов списка.
  Синтаксис:

   макс. (Список) 

  Список = [ 2,3 , 4,445 , 3 , 5,33 , 1,054 , 2,5 ] печать ( макс ( Список ))

  Выход:

   5.33
   

Функции sort () и reverse ()

• reverse (): Сортировка заданной структуры данных (как кортежа, так и списка) в порядке возрастания. Key и reverse_flag не являются обязательными параметрами, а reverse_flag устанавливается в False, если через sorted () ничего не передается.
  Синтаксис:

   отсортировано ([список [, ключ [, Reverse_Flag]]])
   list.sort ([ключ, [Reverse_flag]]) 

  Список = [ 2.3 , 4,445 , 3 , 5,33 , 1,054 , 2,5 ] Список . Сортировка (обратный = Истинный ) печать ( Список )

  Выход:

   [5.33, 4.445, 3, 2.5, 2.3, 1.054]
   

  Список = [ 2,3 , 4,445 , 3 , 5,33 , 1,054 , 2,5 ] отсортировано ( Список ) печать ( Список )

  Выход:

   [1.054, 2.3, 2.5, 3, 4.445, 5.33]
   

Удаление элементов списка

Чтобы удалить один или несколько элементов, то есть удалить элемент, можно использовать множество встроенных функций, таких как pop () и remove (), и ключевые слова, такие как del.

• pop (): Индекс не является необходимым параметром, если не указан, принимает последний индекс.
  Синтаксис:

   list.pop ([индекс]) 

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

  Список = [ 2,3 , 4,445 , 3 , 5,33 , 1,054 , 2,5 ] печать ( Список .pop ())

  Выход:

   2,5
   

  Список = [ 2.3 , 4,445 , 3 , 5,33 , 1,054 , 2,5 ] печать ( Список .pop ( 0 ))

  Выход:

   2,3
   

• del (): Элемент, который нужно удалить, упоминается с использованием имени списка и индекса.
  Синтаксис:

   del list.[индекс] 

  Список = [ 2,3 , 4,445 , 3 , 5,33 , 1,054 , 2,5 ] del Список [ 0 ] печать ( Список )

  Выход:

   [4.445, 3, 5,33, 1,054, 2,5] 

• remove (): Элемент, который нужно удалить, упоминается с использованием имени и элемента списка.
  Синтаксис:

   list.remove (элемент) 

  Список = [ 2,3 , 4,445 , 3 , 5,33 , 1,054 , 2,5 ] Список .удалить ( 3 ) печать ( Список )

  Выход:

   [2.3, 4.445, 5.33, 1.054, 2.5]
   

Автор статьи Piyush Doorwar . Если вам нравится GeeksforGeeks, и вы хотели бы внести свой вклад, вы также можете написать статью с помощью provide.geeksforgeeks.org или отправить ее по электронной почте на [email protected]. Смотрите вашу статью на GeeksforGeeks

.