Как создать кортеж пустого кортежа в Python? — python
tuple() является единственным подлинным пустым кортежем, но() и ((),) создают кортеж длины 1, который содержит кортеж длины 0 — но не сам кортеж длины ноль.
Если вы хотите получить ответ на вопрос «как создать пустой (или нулевой длины) кортеж… Я нашел этот пост с поиском» как создать пустой кортеж «, то понял, что это не тот же вопрос, но мог быть ошибочно принятым за этот вопрос (как и при поиске), поэтому я хотел бы дать ответ на:
Как вы просто создаете пустой кортеж?
исходный вопрос может ввести вас в заблуждение, так как исходные ответы почти достаточно хороши, как пустой кортеж, но не пройдут один тест.
(), создаст «пустой» кортеж, как предложено в предыдущих ответах с ((),), который также будет работать, как и (((((((),)))))) на самом деле вы можете использовать любое число из внешних скобок вы выбираете, они просто работают как скобки. Однако при печати кортежа python добавляет один набор внешних скобок.
пустые скобки — это нестандартное представление ‘no value’, а добавление запятой в конце делает кортеж из ‘no value’. Но это кортеж с записью ‘no value’, а не пустой кортеж.
Примечание. Это не кортеж нулевой длины, как показали другие примеры. Внешний кортеж — это кортеж с одним значением, просто у этого значения есть пустой кортеж. Таким образом, это создает пустой кортеж внутри другого кортежа, а другой кортеж не является пустым. Для истинно пустого кортежа, используйте tuple() хотя() ведет себя примерно так же, это не совсем правильно.
>>> a = (),
>>> type(a)
<class 'tuple'>
>>> len(a)
1
>>> a
((),)
>>> len(a[0]) # the inside tuple is empty, just not the outside one
0
Аналогично, для кортежа длины 1, но со значением (ноль в случае b и «» для примера с c)
>>> b = 0,
>>> type(b)
<class 'tuple'>
>>> len(b)
1
>>>b
(0,)
# now with an empty string
>>> c = "",
>>> type(c)
<class 'tuple'>
>>> len(c)
1
>>>c
('',)
>>> len (c[0]) # same len of c[0] as with 'empty' tuple
0
Таким образом, внешние скобки включены для отображения кортежа, но на самом деле не являются частью кортежа и не нужны для создания кортежа.
Однако все эти методы скобок не являются пустыми на внешнем уровне, что также имеет прецеденты.
>>> a = ((),) # extra brackets just to show same as other answers
>>> len(a)
1
>>> if a:
print("not empty")
not empty
>>> e = tuple()
>>> len(e)
0
>>> type(e)
<class 'tuple'>
>>> if e:
print("not empty")
>>> # note...did not print...so e acts as false as an empty tuple should
Поэтому, если вам действительно нужен подлинный пустой кортеж, используйте tuple(), но если все, что вам нужно, достаточно близко, вы можете использовать ((),)
qaru.site
Преобразование строки Python в кортеж без разделения символов Ru Python
Вы можете просто сделать (a,) . Нет необходимости использовать функцию. (Обратите внимание, что запятая необходима.)
По сути, tuple(a) означает создание кортежа содержимого a , а не кортежа, состоящего из самого себя. «Содержимое» строки (то, что вы получаете, когда вы ее перебираете) – это ее символы, поэтому она разделяется на символы.
Посмотрите учебник Python на кортежи :
Особой проблемой является построение кортежей, содержащих 0 или 1 элемент: синтаксис имеет некоторые дополнительные причуды для их размещения. Пустые кортежи создаются пустой парой круглых скобок; кортеж с одним элементом создается, следуя значению с запятой (недостаточно заключить в круглые скобки одно значение). Уродливый, но эффективный. Например:
>>> empty = () >>> singleton = 'hello', # <-- note trailing comma >>> len(empty) 0 >>> len(singleton) 1 >>> singleton ('hello',)
Если вы помещаете только пару круглых скобок вокруг вашего строкового объекта, они будут только превращать это выражение в выражение в скобках (выделение добавлено):
Список выражений в скобках дает то, что дает список выражений: если список содержит хотя бы одну запятую, он дает кортеж; в противном случае он дает единственное выражение, которое составляет список выражений.
Пустая пара круглых скобок дает пустой объект кортежа. Поскольку кортежи неизменяемы, применяются правила для литералов (т. Е. Два вхождения пустого кортежа могут или не могут дать один и тот же объект).
Обратите внимание, что кортежи не формируются скобками, а используются с помощью оператора запятой.
Исключением является пустой кортеж, для которого требуются круглые скобки, что позволяет безраздельно «ничего» в выражениях вызывать неоднозначность и допускать совпадение опечаток с неотображаемыми.
То есть (предполагая Python 2.7),
a = 'Quattro TT' print tuple(a) # <-- you create a tuple from a sequence # (which is a string) print tuple([a]) # <-- you create a tuple from a sequence # (which is a list containing a string) print tuple(list(a)) # <-- you create a tuple from a sequence # (which you create from a string) print (a,) # <-- you create a tuple containing the string print (a) # <-- it's just the string wrapped in parentheses Ожидается выход:
('Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T') ('Quattro TT',) ('Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T') ('Quattro TT',) Quattro TT Чтобы добавить примечания к заявлению печати. Когда вы пытаетесь создать одноэлементный кортеж как часть инструкции печати в Python 2.7 (как и в print (a,) ), вам нужно использовать форму в скобках, потому что конечная запятая для print a, также будет считаться частью заявление печати и, следовательно, заставить строку новой строки подавляться с выхода, а не создаваемый кортеж:
Символ «\ n» записывается в конце, если оператор печати не заканчивается запятой.
В Python 3.x большинство из приведенных выше примеров использования в примерах действительно повысят SyntaxError , потому что в Python 3 print превращается в функцию (вам нужно добавить дополнительную пару круглых скобок). Но особенно это может вызвать путаницу:
print (a,) # <-- this prints a tuple containing `a` in Python 2.x # but only `a` in Python 3.x Я использую эту функцию для преобразования строки в кортеж
def parse_tuple(string): try: s = eval(str(string)) if type(s) == tuple: return s return except: return Применение
foo = '("A","B","C",)' value = parse_tuple(foo) # Result: ('A', 'B', 'C') В вашем случае вы делаете
value = parse_tuple("('%s',)" % a) Subclassing кортеж, в котором некоторые из этих подклассов могут потребоваться однострочные экземпляры, бросает что-то интересное.
class Sequence( tuple ): def __init__( self, *args ): # initialisation... self.instances = [] def __new__( cls, *args ): for arg in args: assert isinstance( arg, unicode ), '# arg %s not unicode' % ( arg, ) if len( args ) == 1: seq = super( Sequence, cls ).__new__( cls, ( args[ 0 ], ) ) else: seq = super( Sequence, cls ).__new__( cls, args ) print( '# END new Sequence len %d' % ( len( seq ), )) return seq NB, как я узнал из этого потока, вы должны поместить запятую после args[ 0 ] .
Линия печати показывает, что одна строка не разделяется.
NB запятая в конструкторе подкласса теперь становится необязательной:
Sequence( u'silly' ) или
Sequence( u'silly', ) www.rupython.com
python Именованный кортеж в словарь — python
Случай № 1: одномерный кортеж
TUPLE_ROLES = (
(912,"Role 21"),
(913,"Role 22"),
(925,"Role 23"),
(918,"Role 24"),
)
TUPLE_ROLES[912] #==> Error because it is out of bounce.
TUPLE_ROLES[ 2] #==> will show Role 23.
DICT1_ROLE = {k:v for k, v in TUPLE_ROLES }
DICT1_ROLE[925] # will display "Role 23"
Случай № 2: двумерный кортеж
Пример: DICT_ROLES [961] # покажет «Back-End Programmer»
NAMEDTUPLE_ROLES = ( ('Company', ( ( 111, 'Owner/CEO/President'), ( 113, 'Manager'), ( 115, 'Receptionist'), ( 117, 'Marketer'), ( 119, 'Sales Person'), ( 121, 'Accountant'), ( 123, 'Director'), ( 125, 'Vice President'), ( 127, 'HR Specialist'), ( 141, 'System Operator'), )), ('Restaurant', ( ( 211, 'Chef'), ( 212, 'Waiter/Waitress'), )), ('Oil Collector', ( ( 211, 'Truck Driver'), ( 213, 'Tank Installer'), ( 217, 'Welder'), ( 218, 'In-house Handler'), ( 219, 'Dispatcher'), )), ('Information Technology', ( ( 912, 'Server Administrator'), ( 914, 'Graphic Designer'), ( 916, 'Project Manager'), ( 918, 'Consultant'), ( 921, 'Business Logic Analyzer'), ( 923, 'Data Model Designer'), ( 951, 'Programmer'), ( 953, 'WEB Front-End Programmer'), ( 955, 'Android Programmer'), ( 957, 'iOS Programmer'), ( 961, 'Back-End Programmer'), ( 962, 'Fullstack Programmer'), ( 971, 'System Architect'), )), ) #Thus, we need dictionary/set T4 = {} def main(): for k, v in NAMEDTUPLE_ROLES: for k1, v1 in v: T4.update ( {k1:v1} ) print (T4[961]) # will display 'Back-End Programmer' # print (T4) # will display all list of dictionary main()
qaru.site
Что такое «названные кортежи» в Python? Ru Python
Именованные кортежи в основном легкие в создании, легкие типы объектов. Именованные экземпляры кортежей можно ссылаться с помощью разметки типа объекта или стандартного кортежа. Они могут использоваться аналогично struct или другим общим типам записей, за исключением того, что они являются неизменными. Они были добавлены в Python 2.6 и Python 3.0, хотя есть рецепт для реализации в Python 2.4 .
Например, принято представлять точку как кортеж (x, y) . Это приводит к следующему коду:
pt1 = (1.0, 5.0) pt2 = (2.5, 1.5) from math import sqrt line_length = sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2) Используя именованный кортеж, он становится более читаемым:
from collections import namedtuple Point = namedtuple('Point', 'x y') pt1 = Point(1.0, 5.0) pt2 = Point(2.5, 1.5) from math import sqrt line_length = sqrt((pt1.x-pt2.x)**2 + (pt1.y-pt2.y)**2) Однако названные кортежи по-прежнему обратно совместимы с обычными кортежами, поэтому все еще будут работать:
Point = namedtuple('Point', 'x y') pt1 = Point(1.0, 5.0) pt2 = Point(2.5, 1.5) from math import sqrt # use index referencing line_length = sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2) # use tuple unpacking x1, y1 = pt1 Таким образом, вы должны использовать именованные кортежи вместо кортежей, где бы вы ни думали, что обозначение объекта сделает ваш код более питоновым и более легко читаемым . Я лично начал использовать их для представления очень простых типов значений, особенно при передаче их в качестве параметров функций. Это делает функции более читабельными, не видя контекста упаковки кортежа.
Кроме того, вы также можете заменить обычные неизменяемые классы, у которых нет функций , только поля с ними. Вы даже можете использовать свои названные типы кортежей в качестве базовых классов:
class Point(namedtuple('Point', 'x y')): [...] Однако, как и в случае с кортежами, атрибуты в названных кортежах неизменяемы:
>>> Point = namedtuple('Point', 'x y') >>> pt1 = Point(1.0, 5.0) >>> pt1.x = 2.0 AttributeError: can't set attribute Если вы хотите изменить значения, вам нужен другой тип. Существует удобный рецепт для изменяемых типов записей, которые позволяют вам устанавливать новые значения для атрибутов.
>>> from rcdtype import * >>> Point = recordtype('Point', 'x y') >>> pt1 = Point(1.0, 5.0) >>> pt1 = Point(1.0, 5.0) >>> pt1.x = 2.0 >>> print(pt1[0]) 2.0 Однако я не знаю какой-либо формы «именованного списка», которая позволяет добавлять новые поля. Вы можете просто использовать словарь в этой ситуации. Именованные кортежи могут быть преобразованы в словари, используя pt1._asdict() который возвращает {'x': 1.0, 'y': 5.0} и может работать со всеми обычными функциями словаря.
Как уже отмечалось, вы должны проверить документацию для получения дополнительной информации, из которой были построены эти примеры.
namedtuple является заводской функцией для создания кортежа. С этим классом мы можем создавать кортежи, которые также вызываются по имени.
import collections #Create a namedtuple class with names "a" "b" "c" Row = collections.namedtuple("Row", ["a", "b", "c"], verbose=False, rename=False) row = Row(a=1,b=2,c=3) #Make a namedtuple from the Row class we created print row #Prints: Row(a=1, b=2, c=3) print row.a #Prints: 1 print row[0] #Prints: 1 row = Row._make([2, 3, 4]) #Make a namedtuple from a list of values print row #Prints: Row(a=2, b=3, c=4) namedtuples – отличная функция, они идеальный контейнер для данных. Когда вам нужно «хранить» данные, вы должны использовать кортежи или словари, например:
user = dict(name="John", age=20) или:
user = ("John", 20) Словарный подход является подавляющим, поскольку dict изменяются и медленнее, чем кортежи. С другой стороны, кортежи являются неизменными и легкими, но не имеют удобочитаемости для большого количества записей в полях данных.
namedtuples являются идеальным компромиссом для обоих подходов, имеют большую читаемость, легковесность и неизменность (плюс они полиморфны!).
Чтобы понять именованные кортежи, вам сначала нужно знать, что такое кортеж. Кортеж по существу является неизменным (не может быть изменен на месте в памяти).
Вот как вы можете использовать регулярный кортеж:
>>> student_tuple = 'Lisa', 'Simpson', 'A' >>> student_tuple ('Lisa', 'Simpson', 'A') >>> student_tuple[0] 'Lisa' >>> student_tuple[1] 'Simpson' >>> student_tuple[2] 'A' Вы можете развернуть кортеж с последовательной распаковкой:
>>> first, last, grade = student_tuple >>> first 'Lisa' >>> last 'Simpson' >>> grade 'A' Именованные кортежи – это кортежи, которые позволяют обращаться к своим элементам по имени, а не только по индексу!
Вы делаете namedtuple следующим образом:
>>> from collections import namedtuple >>> Student = namedtuple('Student', ['first', 'last', 'grade']) Вы также можете использовать одну строку с именами, разделенными пробелами, немного более ч
www.rupython.com