Что делают квадратные скобки в python

Справочник по языку Python3.

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

Операции с изменяемым множеством set в Python.

Здесь перечислены операции с изменяемыми множеством `set` с их описанием и примерами использования в коде. Напоминаем, что множеством `set` поддерживают все операции доступные неизменяемым множествам `frozenset`.

Методы типов bytes и bytearray.

Байтовые строки `bytes` и объекты `bytearray` взаимодействуют не только с операндами одного типа, но и с любыми байтовыми объектами. Методы в байтовых строках `bytes` и `bytearray` объектах не принимают текстовые строки в качестве своих аргуме

Методы типа memoryview в Python.

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

Методы открытого файла в Python.

Прежде чем начинать что-то делать с файлом, его необходимо открыть его с помощью встроенной функции open(). Эта функция создает объект файла file object, который будет использоваться для вызова методов, которые представлены ниже.

Встроенные функции Python.

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

Встроенные исключения в Python.

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

Синтаксис async/await в Python.

Для написания параллельного (асинхронного) кода с использованием синтаксиса async/await создана библиотека asyncio, которая будет рассмотрена в разделе «Стандартная библиотека Python3».

Подробное руководство по индексам и срезам в Python.

Python использует квадратные скобки [ и ] для доступа к отдельным элементам последовательности. За кулисами, индекс, который используется для доступа к отдельным элементам последовательности представляет собой объект среза slice() принимающий три аргумента: slice(start, stop, step).

Реализации параллельных вычислений в Python.

Параллелизм работает над несколькими вычислениями одновременно. Используя многопоточность threading, позволяя нескольким потокам работать по очереди. Используя многопоточность multiprocessing и делать сразу несколько вычислений, используя несколько ядер процессора. Проводится исследование.

Функциональное программирование в Python.

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

Общие принципы оптимизации кода Python.

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

Рефакторинг кода в Python.

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

Типы данных Python

Числа имеют четыре типа в Python. Int, float, сложный и длинный.

 int_num = 10 #int value float_num = 10.2 #float value complex_num = 3.14j #complex value long_num = 1234567L #long value

Тип данных String

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

 a_str = 'Hello World' print(a_str) #output will be whole string. Hello World print(a_str[0]) #output will be first character. H print(a_str[0:5]) #output will be first five characters. Hello

Тип данных списка

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

 list = [123,'abcd',10.2,'d'] #can be a array of any data type or single data type. list1 = ['hello','world'] print(list) #will ouput whole list. [123,'abcd',10.2,'d'] print(list[0:2]) #will output first two element of list. [123,'abcd'] print(list1 * 2) #will gave list1 two times. ['hello','world','hello','world'] print(list + list1) #will gave concatenation of both the lists. [123,'abcd',10.2,'d','hello','world']

Тип данных кортежа

Списки заключены в квадратные скобки [], и их элементы и размер могут быть изменены, а кортежи заключены в скобки () и не могут быть обновлены. Кортежи неизменны.

 tuple = (123,'hello') tuple1 =('world') print(tuple) #will output whole tuple. (123,'hello') print(tuple[0]) #will output first value. (123) print(tuple + tuple1) #will output (123,'hello','world') tuple[1]='update' #this will give you error.

Тип данных словаря

Словарь состоит из пар ключ-значение. Он заключен в фигурные скобки <>, а значения можно назначать и получать к ним доступ в квадратных скобках [].

 dic= print(dic) #will output all the key-value pairs. print(dic['name']) #will output only value with 'name' key. 'red' print(dic.values()) #will output list of values in dic. ['red',10] print(dic.keys()) #will output list of keys. ['name','age']

Установить типы данных

Наборы представляют собой неупорядоченные наборы уникальных объектов, существует два типа наборов:

Наборы — они изменчивы и новые элементы могут быть добавлены после определения наборов

 basket = print(basket) # duplicates will be removed > a = set('abracadabra') print(a) # unique letters in a > a.add('z') print(a) >

Замороженные наборы — они неизменны, и новые элементы не могут быть добавлены после его определения.

 b = frozenset('asdfagsa') print(b) > frozenset() cities = frozenset(["Frankfurt", "Basel","Freiburg"]) print(cities) > frozenset()

В каких случаях пишутся квадратные скобки в Python? [закрыт]

Хотите улучшить этот вопрос? Переформулируйте вопрос так, чтобы он был сосредоточен только на одной проблеме.

Закрыт 4 года назад .
В каких случаях пишутся квадратные скобки в Python?
Отслеживать
13.7k 12 12 золотых знаков 43 43 серебряных знака 75 75 бронзовых знаков
задан 16 янв 2019 в 18:06
Quiet Games Quiet Games
1 1 1 золотой знак 1 1 серебряный знак 2 2 бронзовых знака
В тех, где это допустимо по синтаксису и уместно в контексте решаемой задачи.
16 янв 2019 в 18:18

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Тогда, когда создается/используется список как тип данных, подробнее можешь почитать, загуглив «списки Python» или по ссылке.

Отслеживать
user262779
ответ дан 16 янв 2019 в 19:40
Артем Учуаткин Артем Учуаткин
11 1 1 бронзовый знак

В очереди проверок вам могут указать, что это ответ-ссылка. Я ответил «выглядит нормально», т.к. начало ответа пусть и кратко, но говорит про использование скобок в списках — из очереди проверок.

16 янв 2019 в 20:35
typing.Optional[typing.Dict[str, typing.List[int]]] немного не согласен с вами 🙂
16 янв 2019 в 20:40
@AK Спасибо большое 🙂
17 янв 2019 в 23:16

Важное на Мете

Язык Python

Язык python полноценно поддерживает объектно-ориентированную разработку. Минимальный класс в python можно создать следующим образом:

class NewGreatType: pass obj = NewGreatType() type(obj) #

Любой объект в python является объектом какого-либо класса:

type(1) # type(int) # type(NewGreatType) # type(type) #

Эти примеры показывают, что типы данных сами являются объектами класса type . Встроенная функция dir позволяет получить все атрибуты (поля и методы) объекта. Выведем для примера атрибуты объекта False класса bool :

dir(False) # ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', # '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', # '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', # '__getattribute__', '__getnewargs__', '__gt__', '__hash__', # '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', # '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', # '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', # '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', # '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', # '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', # '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', # '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', # 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', # 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

Довольно много для такого простого объекта. Попробуем вызвать метод __or__ :

False.__or__(False) # False False.__or__(True) # True

Вызов этого метода эквивалентен использованию оператора or . Мы обнаружили способ перегрузки операторов в python. Она выполняется с помощью определения «магических» методов, некоторые из которых мы рассмотрим ниже.

Поля и методы

Вспомним класс LorentzVector , с которым мы работали в разделе про классы в C++ и начнем писать его аналог на python:

class LorentzVector: """ Релятивистский вектор """ def __init__(self, t, x): """ x: может быть int, float или list """ self.t = t self.x = x def r2(self): """ Квадрат модуля пространственной компоненты """ if isinstance(self.x, (int, float)): return self.x**2 return sum(map(lambda a: a**2, self.x)) def inv(self): """ Релятивистский инвариант """ return self.t**2 - self.r2()

Метод __init__ является конструктором. Объект self ссылается на сам объект класса (аналог this в C++) и является обязательным первым аргументом всех нестатических методов, включая конструктор. В конструкторе мы определили два поля класса: self.x и self.y . Также мы определили два метода: r2 возвращает квадрат пространственной компоненты вектора, и inv возвращает релятивистский инвариант, соответствующий вектору.

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

Проверим работу класса LorentzVector :

lv1 = LorentzVector(1, 0.5) lv1.t # 1 lv1.x # 0.5 lv1.r2() # 0.25 lv1.inv() # 0.75

lv2 = LorentzVector(1, [0.3, 0.4, 0.0]) lv2.t # 1 lv2.x # [0.3, 0.4, 0.0] lv2.r2() # 0.25 lv2.inv() # 0.75

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

lv = LorentzVector(1, 0.5) hasattr(lv, 'mass') # False lv.mass = 0.3 hasattr(lv, 'mass') # True

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

class LorentzVector: """ Релятивистский вектор """ speed_of_light = 2.99792458e10 # см / с # . LorentzVector.speed_of_light # 29979245800.0

Для задания статического метода необходимо использовать декоратор staticmethod :

class LorentzVector: # . @staticmethod def boost_vector(lv): """ Возвращает boost-вектор для данного вектора """ if isinstance(lv.x, (int, float)): return lv.x / lv.t return list(map(lambda x: x / lv.t, lv.x))

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

С помощью декоратора property можно делать вызов методов, не имеющих аргументов, похожим на обращение к полю класса:

class LorentzVector: # . @property def r2(self): """ Квадрат модуля пространственной компоненты """ if isinstance(self.x, (int, float)): return self.x**2 return sum(map(lambda a: a**2, self.x)) @property def inv(self): """ Релятивистский инвариант """ return self.t**2 - self.r2()

lv1 = LorentzVector(1, 0.5) lv1.t # 1 lv1.x # 0.5 lv1.r2 # 0.25 lv1.inv # 0.75

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

Интеграция пользовательских классов в среду языка выполняется посредством определения специальных методов. Начнём с рассмотрения примера перегрузки арифметического оператора:

class LorentzVector: # . def __add__(self, rhs): """ Сложение двух векторов """ if isinstance(self.x, (int, float)): x_new = self.x + rhs.x else: x_new = list(map(lambda a: sum(a), zip(self.x, rhs.x))) return LorentzVector(self.t + rhs.t, x_new)

Аналогично выполняется перегрузка операторов вычитания ( __sub__ ), умножения ( __mul__ ), деления ( __div__ ), круглых скобок ( __call__ ), квадратных скобок ( __getitem__ ) и т.д.

Методы __str__ и __repr__ отвечают за текстовое представление объекта. Метод __str__ вызывается, когда объект передается в функцию print или в форматированную строку, и служит для «неформального» представления объекта. Метод __repr__ должен возвращать строку, которая содержит всю информацию о состоянии объекта и по которой объект может быть восстановлен. Если определен только метод __repr__ , то он будет вызываться в функции print вместо метода __str__ .

Если передать объект LorentzVector в функцию print , не определяя специальных методов, то мы получим что-то подобное:

lv = LorentzVector(1, 0.5) print(lv) # __main__.LorentzVector object at 0x7f50a36dfeb0>

Функция print вывела тип объекта и адрес, по которому он расположен в памяти.

Определим метод __repr__ :

class LorentzVector: # . def __repr__(relf): """ Текстовое представление вектора """ return f'LorentzVector [self.t>, self.x>]'

lv = LorentzVector(1, 0.5) print(lv) # LorentzVector [1, 0.5]

Мы рассмотрели лишь некоторые из доступных специальных методов. Рекомендуем ознакомиться с полным списком в документации.

Наследование

Язык python позволяет выполнять наследование классов. Класс-потомок имеет доступ ко всем полям и методам класса-предка. Все классы в python являются наследниками класса object . Об класса object наш класс LorentzVector наследует большинство своих атрибутов:

lv = LorentzVector(1, 0.5) isinstance(lv, object) # True dir(lv) # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', # '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', # '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', # '__module__', '__ne__', '__new__', '__reduce__', # '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', # '__str__', '__subclasshook__', '__weakref__', 'inv', 'mass', # 'r2', 'sum', 't', 'x']

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

from typing import NamedTuple class FourVector(NamedTuple): # """ Релятивистский вектор """ t: float # такой синтаксис используется для задания r: list # полей кортежа и аннотации их типов @property def r2(self): """ Квадрат модуля пространственной компоненты """ return sum(map(lambda a: a**2, self.r)) @property def inv(self): """ Релятивистский инвариант """ return self.t**2 - self.r2() def __repr__(relf): """ Текстовое представление вектора """ return f'FourVector [self.t>, self.r>]'

Новая реализация яснее показывает структуру нашего типа данных. Для создания объекта FourVector необходимо задать значения полям t и r :

fv1 = FourVector(1, [0.3, 0.4, 0.0]) fv2 = FourVector(t=1, r=[0.3, 0.4, 0.0]) fv3 = FourVector(t=1, r=[0.5]) fv4 = FourVector(t=1, r=0.5) fv3.r2 # 0.25 fv4.r2 # TypeError: 'float' object is not iterable

При создании объекта fv4 мы нарушили соглашение и передали в поле r объект float вместо list . Это привело к ошибке при вызове метода r2 . При определении класса FourVector мы использовали аннотацию типов ( t: float ).

Больше информации о наследовании в python можно найти в документации.

Полиморфизм в python

Реализация полиморфизма в python сильно отличается от его реализации в C++. Полиморфизм в C++ реализуется с помощью инструментов наследования и шаблонов. Динамическая типизация python позволяет использовать гораздо более гибкие инструменты полиморфизма. Переменные, аргументы функций и атрибуты классов в python могут в разных контекстах иметь разные типы и даже менять тип со временем. Таким образом, все объекты в python изначально полиморфны.

В такой ситуации возникает вопрос о том как описывать ограничения на допустимые типы объектов. Здесь на помощь приходит принцип утиной типизации (duck typing), дословно состоящий в том, что «если что-то выглядит как утка и крякает как утка, значит это утка». Иными словами, если объект предоставляет необходимый интерфейс, то мы можем с ним работать вне зависимости от его типа. Для поддержки этого подхода в python реализованы инструменты для проверки свойств объектов:

# проверяет является ли obj объектом типа int или float isinstance(obj, (int, float)) # проверяет имеет ли obj атрибут norm hasattr(obj, 'norm') # является ли класс FourVector подклассом NamedTuple issubclass(FourVector, NamedTuple)

Столь гибкая типизация приводит к необходимости качественной документации кода. Хорошим стилем является описание всех контрактов функции или метода в его строке комментария. Значительно улучшает читаемость кода и аннотация типов.

Резюме

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

Концепция ООП в python не является основной, как в C++, однако средства ООП составляют важную часть языка, и их понимание необходимо для грамотной разработки на python, поскольку все типы объектов в python являются классами.

Источники

docs.python.org/3/reference/datamodel
docs.python.org/3/tutorial/classes
docs.python.org/3/library/typing
Python Inheritance
Понимаем декораторы в Python’e, шаг за шагом (habr)
Введение в аннотации типов Python (habr)

Введение
Настройка рабочей среды
Язык C++
Язык Python
- Основы синтаксиса языка python
- Строки
- Стандартные модули python, часть I
- ООП в python
- Стандартные модули II
- Итераторы и генераторы
- Вычисления с библиотекой numpy
- Визуализация данных с matplotlib
Читать:
Как отключить whatsapp на время на iphone