Питон кортежи: Кортежи (tuple) | Python 3 для начинающих и чайников

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

В общем, те кому не интересно — читают следующую новость, а остальных — прошу пройти .

Python для начинающих. Глава третья. «List, tuple, etc.»

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

>>> t = (2, 2.05, "Hello")
>>> t
(2, 2.0499999999999998, 'Hello')
>>> (a, b, c) = t
>>> print a, b, c
2 2.05 Hello
>>> z, y, x = t
>>> print z, y, x
2 2.05 Hello
>>> a=1
>>> b=2
>>> a,b=b,a
>>> print a,b
2 1
>>> x = 12,
>>> x
(12,)

Списки

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

Простое перечисление:

>>> a = [2, 2.25, "Python"]
>>> a
[2, 2.25, 'Python']

>>> b = list("help")
>>> b
['h', 'e', 'l', 'p']

>>> c = [x ** 3 for x in range(20) if x%2==1]
>>> c
[1, 27, 125, 343, 729, 1331, 2197, 3375, 4913, 6859]

Кроме того, для списков определен ряд методов.
append(x) Добавляет элемент в конец последовательности
count(x) Считает количество элементов, равных x
extend(s) Добавляет к концу последовательности последовательность s
index(x) Возвращает наименьшее i, такое, что s[i] == x. Возбуждает исключение ValueError, если x не найден в s
insert(i, x) Вставляет элемент x в i-й промежуток
pop(i) Возвращает i-й элемент, удаляя его из последовательности
reverse() Меняет порядок элементов s на обратный
sort([cmpfunc]) Сортирует элементы s. Может быть указана своя функция сравнения cmpfunc

Для преобразования кортежа в список есть функция list, для обратной операции — tuple.

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

>>> s = [0, 1, 2, 3, 4]
>>> print s[0], s[-1], s[3]
0 4 3
>>> s[2] = -2
>>> print s
[0, 1, -2, 3, 4]
>>> del s[2]
>>> print s
[0, 1, 3, 4]

>>> l = range(12)
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> l[1:3]
[1, 2]
>>> l[-1:]
[11]
>>> l[::2]
[0, 2, 4, 6, 8, 10]
>>> l[0:1]=[-1,-1,-1]
>>> l
[-1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> del l[:3]
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

Словарь (хэш, предопределенный массив) – изменяемая структура данных, предназначенная для хранения элементов вида ключ: значение. Все легко показывается на примере.

Создаем хеши.

>>> h2 = {1:"one", 2:"two", 3:"three"}
>>> h3 = {0:"zero", 5:"five"}
>>> h4 = {"z":1, "y":2, "x":3}
#Цикл по паре ключ-значение
>>> for key, value in h2.items():
...     print key, " ", value
...
1   one
2   two
3   three

#Цикл по ключам
>>> for key in h3.keys():
...     print key, " ", h3[key]
...
0   zero
5   five

#Цикл по значениям
>>> for v in h4.values():
...     print v
...
2
3
1

#Добавление элементов из другого хеша
>>> h2.update(h4)

#Количество пар в хеше
>>> len(h2)
6

Объекты этого типа предназначены для работы с внешними данными. Чаще всего данному объекту соответствует файл на диске, но это далеко не всегда так. Файловые объекты должны поддерживать основные методы: read(), write(), readline(), readlines(), seek(), tell(), close() и т.п.

Следующий пример показывает копирование файла:

f1 = open("file1.txt", "r")
f2 = open("file2.txt", "w")
for line in f1.readlines():
  f2.write(line)
f2.close()
f1.close()

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

import urllib
f1 = urllib.urlopen("http://python.onego.ru") 

Python | Кортежи

Кортежи

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

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

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

user = ("Tom", 23)
print(user)

Также для определения кортежа мы можем просто перечислить значения через запятую без применения скобок:

user = "Tom", 23
print(user)

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

user = ("Tom",)

Для создания кортежа из списка можно передать список в функцию tuple(), которая возвратит кортеж:

users_list = ["Tom", "Bob", "Kate"]
users_tuple = tuple(users_list)
print(users_tuple)      # ("Tom", "Bob", "Kate")

Обращение к элементам в кортеже происходит также, как и в списке по индексу. Индексация начинается также с нуля при получении элементов с начала списка и с -1 при получении элементов с конца списка:

users = ("Tom", "Bob", "Sam", "Kate")
print(users[0])     # Tom
print(users[2])     # Sam
print(users[-1])     # Kate

# получим часть кортежа со 2 элемента по 4
print(users[1:4])       # ("Bob", "Sam", "Kate")

Но так как кортеж — неизменяемый тип (immutable), то мы не сможем изменить его элементы. То есть следующая запись работать не будет:

users[1] = "Tim"

При необходимости мы можем разложить кортеж на отдельные переменные:

user = ("Tom", 22, False)
name, age, isMarried = user
print(name)             # Tom
print(age)              # 22
print(isMarried)        # False

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

def get_user():
    name = "Tom"
    age = 22
    is_married = False
    return name, age, is_married


user = get_user()
print(user[0])              # Tom
print(user[1])              # 22
print(user[2])              # False

С помощью встроенной функции len() можно получить длину кортежа:

user = ("Tom", 22, False)
print(len(user))		# 3

Перебор кортежей

Для перебора кортежа можно использовать стандартные циклы for и while. С помощью цикла for:

user = ("Tom", 22, False)
for item in user:
    print(item)

С помощью цикла while:

user = ("Tom", 22, False)

i = 0
while i < len(user):
    print(user[i])
    i += 1

Как для списка с помощью выражения элемент in кортеж можно проверить наличие элемента в кортеже:

user = ("Tom", 22, False)
name = "Tom"
if name in user:
    print("Пользователя зовут Tom")
else:
    print("Пользователь имеет другое имя")

Сложные кортежи

Один кортеж может содержать другие кортежи в виде элементов. Например:

countries = (
    ("Germany", 80.2, (("Berlin",3.326), ("Hamburg", 1.718))),
    ("France", 66, (("Paris", 2.2),("Marsel", 1.6)))
)

for country in countries:
    countryName, countryPopulation, cities = country
    print("\nCountry: {}  population: {}".format(countryName, countryPopulation))
    for city in cities:
        cityName, cityPopulation = city
        print("City: {}  population: {}".format(cityName, cityPopulation))

Здесь кортеж countries, который представляет страны, состоит из кортежей, каждый из которых — отдельная страна.

Вложенные кортежи имеют три элемента: название страны, численность ее населения и города. Города представляют отдельный кортеж, где каждый отдельный город — это вложенный кортеж, содержащий название города и численность его населения.

кортежей Python

Tuple

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

Пример

Создать кортеж:

thistuple = («яблоко», «банан», «вишня»)
печать (thistuple)

Доступ к элементам кортежа

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

Пример

Напечатайте второй элемент в кортеже:

thistuple = («яблоко», «банан», «вишня»)
печать (thistuple [1])

Отрицательная индексация

Отрицательное индексирование означает начало с конца, -1 относится к последнему пункту, -2 относится ко второму последнему пункту и т. Д.

Пример

Распечатать последний элемент кортежа:

thistuple = («яблоко», «банан», «вишня»)
печать (thistuple [-1])

Диапазон индексов

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

При указании диапазона возвращаемым значением будет новый кортеж с указанные предметы.

Пример

Верните третий, четвертый и пятый предмет:

thistuple = («яблоко», «банан», «вишня», «апельсин», «киви», «дыня», «манго»)
Печать (thistuple [2: 5])

Примечание: Поиск начинается с индекса 2 (включен) и заканчивается индексом 5 (не включен).

Помните, что первый элемент имеет индекс 0.

Диапазон отрицательных индексов

Укажите отрицательные индексы, если вы хотите начать поиск с конца кортеж:

Пример

В этом примере возвращаются элементы из индекса -4 (включен) в индекс -1 (исключен)

thistuple = («яблоко», «банан», «вишня», «апельсин», «киви», «дыня», «манго»)
печать (thistuple [-4: -1])

Изменить значения кортежа

После создания кортежа вы не можете изменять его значения.Кортежи неизменяемы , или неизменной , как это и называется.

Но есть обходной путь. Вы можете преобразовать кортеж в список, изменить список и преобразовать список обратно в кортеж.

Пример

Преобразуйте кортеж в список, чтобы иметь возможность его изменить:

print (x)

цикл через кортеж

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

Пример

Переберите элементы и выведите значения:

thistuple = («яблоко», «банан», «вишня»)
для х в трижды:
отпечаток (х)

Подробнее о для циклов вы узнаете в нашей главе Python For Loops.

Проверьте, существует ли предмет

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

Пример

Проверьте, присутствует ли «яблоко» в кортеже:

thistuple = («яблоко», «банан», «вишня»)
если «яблоко» в thistuple:
отпечаток («Да,« яблоко »в кортеже фруктов»)

Длина кортежа

Чтобы определить, сколько элементов в кортеже, используйте метод len () :

Пример

Выведите количество элементов в кортеже:

thistuple = («яблоко», «банан», «вишня»)
print (len (thistuple))

Добавить товары

После создания кортежа вы не можете добавлять в него элементы.Кортежи неизменяемы .

Пример

Невозможно добавить элементы в кортеж:

thistuple = («яблоко», «банан», «вишня»)
thistuple [3] = «orange» # Это вызовет ошибку
print (thistuple)

Попробуй сам »

---

Создать кортеж с одним предметом

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

Пример

Один элемент кортежа, запомните запятую:

thistuple = («яблоко»,)
print (type (thistuple))

# НЕ кортеж
thistuple = («apple»)
печать (тип (thistuple))

Попробуй сам »

---

Удалить объекты

Примечание: Невозможно удалить элементы в кортеже.

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

Пример

Ключевое слово del может удалить кортеж полностью:

thistuple = («яблоко», «банан», «вишня»)
дель thistuple
print (thistuple) # это вызовет ошибку, потому что кортеж больше не существует

Попробуй сам »

---

Присоединиться к двум кортежам

Чтобы объединить два или более кортежей, вы можете использовать + оператор:

Пример

Соединить два кортежа:

tuple1 = («a», «b», «c»)
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2
печать (tuple3)

Попробуй сам »

---

Кортеж () Конструктор

Также возможно использовать конструктор tuple () для создания кортежа.

Пример

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

thistuple = tuple ((«яблоко», «банан», «вишня»)) # обратите внимание на двойные круглые скобки
печать (thistuple)

Попробуй сам »

---

Методы кортежей

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

Метод	Описание
count ()	Возвращает число раз, когда указанное значение встречается в кортеже
index ()	Выполняет поиск кортежа для указанного значения и возвращает позицию, в которой оно было найдено

---

---

,

Python Tuple (с примерами)

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

---

Создание кортежа

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

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

  # Различные типы кортежей

# Пустой кортеж
my_tuple = ()
печать (my_tuple)

# Кортеж с целыми числами
my_tuple = (1, 2, 3)
печать (my_tuple)

# кортеж со смешанными типами данных
my_tuple = (1, "Hello", 3.4)
печать (my_tuple)

# вложенный кортеж
my_tuple = ("мышь", [8, 4, 6], (1, 2, 3))
печать (my_tuple)  

Выход

  ()
(1, 2, 3)
(1, «Привет», 3.4)
(«мышь», [8, 4, 6], (1, 2, 3))  

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

  my_tuple = 3, 4,6, "собака"
печать (my_tuple)

# также возможна распаковка кортежей
a, b, c = my_tuple

печать (а) № 3
печать (б) № 4.6
print (c) # собака  

Выход

  (3, 4,6, «собака»)
3
4,6
собака  

Создать кортеж с одним элементом немного сложно.

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

  my_tuple = ("привет")
print (type (my_tuple)) # 

# Создание кортежа с одним элементом
my_tuple = ("привет",)
print (type (my_tuple)) # 

# Скобки необязательны
my_tuple = "привет",
print (type (my_tuple)) #   

Выход

  <класс 'ул'>
<класс 'кортеж'>
<класс 'кортеж'>  

---

Access Tuple Elements

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

1. Индексирование

Мы можем использовать оператор индекса [] для доступа к элементу в кортеже, где индекс начинается с 0.

Итак, кортеж с 6 элементами будет иметь индексы от 0 до 5. Попытка получить доступ к индексу за пределами диапазона индекса кортежа (6,7, … в этом примере) вызовет IndexError .

Индекс должен быть целым числом, поэтому мы не можем использовать float или другие типы. Это приведет к TypeError .

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

  # Доступ к элементам кортежа с помощью индексации
my_tuple = ('p', 'e', ​​'r', 'm', 'i', 't')

print (my_tuple [0]) # 'p'
print (my_tuple [5]) # 't'

# IndexError: список индексов вне диапазона
# print (my_tuple [6])

# Индекс должен быть целым числом
# TypeError: индексы списка должны быть целыми числами, а не с плавающей точкой
# my_tuple [2.0]

# вложенный кортеж
n_tuple = ("мышь", [8, 4, 6], (1, 2, 3))

# вложенный индекс
print (n_tuple [0] [3]) # 's'
print (n_tuple [1] [1]) # 4  

Выход

  р
T
s
4  

---

2.Отрицательная индексация

Python допускает отрицательную индексацию для своих последовательностей.

Индекс -1 относится к последнему элементу, -2 — ко второму последнему элементу и т. Д.

  # Отрицательное индексирование для доступа к элементам кортежа
my_tuple = ('p', 'e', ​​'r', 'm', 'i', 't')

# Вывод: 't'
печать (my_tuple [-1])

# Вывод: 'p'
печать (my_tuple [-6])  

Выход

  т
р  

---

3. Нарезка

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

  # Доступ к элементам кортежа с помощью нарезки
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# элементы со 2 по 4
# Вывод: ('r', 'o', 'g')
Печать (my_tuple [1: 4])

# элементы начиная со второго
# Вывод: ('p', 'r')
печать (my_tuple [: - 7])

# элементы с 8 по конец
# Вывод: ('i', 'z')
печати (my_tuple [7:])

# элементы, начинающиеся до конца
# Вывод: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
печать (my_tuple [:])  

Выход

  ('r', 'o', 'g')
('p', 'r')
(«я», «я»)
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')  

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

Нарезка элементов в Python

---

Замена кортежа

В отличие от списков, кортежи неизменны.

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

Мы также можем назначить кортеж различным значениям (переназначение).

  # Изменение значений кортежа
my_tuple = (4, 2, 3, [6, 5])


# TypeError: объект 'tuple' не поддерживает назначение элементов
# my_tuple [1] = 9

# Тем не менее, элемент изменяемого элемента может быть изменен
my_tuple [3] [0] = 9 # Вывод: (4, 2, 3, [9, 5])
печать (my_tuple)

# Кортежи могут быть переназначены
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# Вывод: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
печать (my_tuple)  

Выход

  (4, 2, 3, [9, 5])
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')  

Мы можем использовать оператор + для объединения двух кортежей.Это называется конкатенация .

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

Операции + и * приводят к новому кортежу.

  # Конкатенация
# Вывод: (1, 2, 3, 4, 5, 6)
печать ((1, 2, 3) + (4, 5, 6))

# Повторение
# Вывод: («Повторить», «Повторить», «Повторить»)
печать ((«Повторить»,) * 3)  

Выход

  (1, 2, 3, 4, 5, 6)
(«Повторить», «Повторить», «Повторить»)  

---

Удаление кортежа

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

Однако полное удаление кортежа возможно с помощью ключевого слова del.

  # Удаление кортежей
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# не могу удалить элементы
# TypeError: объект 'tuple' не поддерживает удаление элемента
# del my_tuple [3]

# Может удалить весь кортеж
del my_tuple

# NameError: имя 'my_tuple' не определено
печать (my_tuple)  

Выход

 Traceback  (последний звонок последний):
  Файл "<строка>", строка 12, в <модуле>
NameError: имя 'my_tuple' не определено  

---

Методы кортежей

Методы, которые добавляют или удаляют элементы, недоступны в кортеже.Доступны только следующие два метода.

Некоторые примеры методов кортежей Python:

  my_tuple = ('a', 'p', 'p', 'l', 'e',)

print (my_tuple.count ('p')) # Вывод: 2
print (my_tuple.index ('l')) # Вывод: 3  

Выход

  2
3  

---

Другие операции с кортежами

1. Тест членства Tuple

Мы можем проверить, существует ли элемент в кортеже или нет, используя ключевое слово в .

  # Членский тест в кортеже
my_tuple = ('a', 'p', 'p', 'l', 'e',)

# В операции
print ('a' в my_tuple)
print ('b' в my_tuple)

# Не работает
печать («g» не в my_tuple)  

Выход

  True
Ложь
Правда  

---

2. Итерация по кортежу

Мы можем использовать цикл для для итерации каждого элемента в кортеже.

  # Использование цикла for для итерации по кортежу
для имени в («Джон», «Кейт»):
    печать («Привет», имя)  

Выход

  Привет Джон
Привет Кейт  

---

Преимущества Tuple над списком

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

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

,

кортежей Python

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

Основное различие между кортежами и списками заключается в том, что списки являются изменяемыми, а кортежи — нет. Изменяемый объект — это объект, который можно изменить. Неизменяемый объект — это объект, который содержит фиксированное значение, которое не может быть изменено .Если это нужно изменить, новый объект должен быть создан.

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

Создать кортеж

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

дни недели = («понедельник», «вторник», «среда», «четверг», «пятница»)

На самом деле, кронштейны не являются обязательными.Таким образом, вы также можете сделать это:

дни недели = «понедельник», «вторник», «среда», «четверг», «пятница»

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

# Установите кортежи дни недели = («понедельник», «вторник», «среда», «четверг», «пятница») выходные дни = «суббота», «воскресенье» # Распечатать кортежи печать (по рабочим дням) печать (weekenddays)

Результат

  («Понедельник», «Вторник», «Среда», «Четверг», «Пятница»)
(«Суббота», «Воскресенье»)  

кортежей одного предмета

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

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

а = («собака») b = («собака»,) печать (тип (а)) печати (тип (б))

Результат

  <класс 'ул'>
<класс 'кортеж'>  

Итак, переменная без запятой оказалась строкой. Переменная с запятой стала кортежем.

Кортеж, содержащий список

Кортежи также могут содержать списки. Пример:

# Установить кортеж t = («Банан», [1, 2, 3]) # Распечатать кортеж печать (т)

Результат

  («Банан», [1, 2, 3])  

Доступ к значениям в кортеже

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

# Установить кортеж дни недели = («понедельник», «вторник», «среда», «четверг», «пятница») # Распечатать второй элемент кортежа Печать (дни недели [1])

Результат

  вторник  

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

дни недели = («понедельник», «вторник», «среда», «четверг», «пятница») Печать (дни недели [1: 4])

Результат

  («вторник», «среда», «четверг»)  

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

Доступ к элементу списка в кортеже

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

Нравится:

t = (101, 202, [«Понедельник», «Вторник», «Среда», «Четверг», «Пятница»]) печать (т [2] [1])

Результат

  вторник  

Обновление кортежа

Как уже упоминалось, кортежи содержат фиксированные элементы, и они являются неизменяемыми, что означает, что они не могут быть изменены.Таким образом, вы не можете изменить «Среда» на «Горбатый день» или что-то в этом роде.

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

# Установить и распечатать исходный кортеж выходные дни = («суббота», «воскресенье») печать (weekenddays) # Переназначить и распечатать выходные дни = («Сб», «Солнце») печать (weekenddays)

Результат

  («суббота», «воскресенье»)
(«Сб», «Солнце»)  

Обновление элемента списка в кортеже

Несмотря на то, что вы не можете изменить элементы кортежа, вы можете изменить элементы списка в кортеже.Вот пример этого:

# Назначить кортеж t = (101, 202, [«Понедельник», «Вторник», «Среда», «Четверг», «Пятница»]) печать (т) # Обновить третий элемент списка t [2] [2] = «Горбатый день» печать (т)

Результат

  (101, 202, [«Понедельник», «Вторник», «Среда», «Четверг», «Пятница»])
(101, 202, [«Понедельник», «Вторник», «Горбатый день», «Четверг», «Пятница»])  

Конкатенация кортежей

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

# Установите два кортежа дни недели = («понедельник», «вторник», «среда», «четверг», «пятница») выходные дни = («суббота», «воскресенье») # Установите третий кортеж на значение двух предыдущих все дни = будни + выходные дни # Распечатать их все печать (по рабочим дням) печать (weekenddays) печать (Alldays)

Результат

  («Понедельник», «Вторник», «Среда», «Четверг», «Пятница»)
('Суббота Воскресенье')
(«Понедельник», «Вторник», «Среда», «Четверг», «Пятница», «Суббота», «Воскресенье»)  

Как видите, два исходных кортежа остаются неизменными, а третий содержит все значения из обоих.

Удалить кортеж

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

t = (1,2,3) дель т

именованных кортежей

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

Вот пример создания и ссылки на именованный кортеж:

# Импортировать функцию namedtuple из модуля коллекций из коллекции импорта namedtuple # Установить кортеж Individual = namedtuple («Индивидуальный», «Имя, возраст, рост») пользователь = индивидуальный (имя = «Гомер», возраст = 37, рост = 178) # Распечатать кортеж печать (пользователь) # Распечатать каждый элемент в кортеже печать (user.name) печать (user.age) печать (user.height)

Результат

  Индивидуальный (имя = 'Гомер', возраст = 37, рост = 178)
Homer
37
178  

Таким образом, вместо print (user [0]) для ввода поля имени, мы можем использовать print (user.имя) вместо. И, конечно, то же самое относится ко всем другим областям.

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

,

кортежей Python — GeeksforGeeks

Tuple — это коллекция объектов Python, очень похожая на список. Последовательность значений, хранящихся в кортеже, может быть любого типа, и они индексируются целыми числами.
Значения кортежа синтаксически разделены «запятыми». Хотя это и не является необходимым, более обычно определить кортеж, закрыв последовательность значений в скобках. Это помогает легче понять кортежи Python.

Создание кортежа

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

Примечание — Создание кортежа Python без использования скобок называется упаковкой кортежей.

Программа Python для демонстрации добавления элементов в кортеж.

Tuple1 = () print ( "Начальный пустой кортеж:" ) print (Tuple1) Tuple1 = ( 'Geeks' , 'Для' ) print ( "\ nТупло с использованием строки:" ) print (Tuple1) list1 = [ 1 , 2 , 4 , 5 , 6 ] печать ( "\ nТуплирование с использованием списка:" ) print ( кортеж (list1)) Tuple1 = Tuple ( 'Geeks' ) print ( "\ nТупло с использованием функции:" ) print (Tuple1)

Выход:

 Начальный пустой кортеж:
()

Кортеж с использованием String:
(«Гики», «За»)

Кортеж, используя список:
(1, 2, 4, 5, 6)

Кортеж с использованием функции:
('G', 'e', ​​'e', ​​'k', 's')
 

Создание кортежа со смешанными типами данных.

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

Tuple1 = ( 5 , 'Welcome' , 7 , 'Geeks' ) print ( "\ nТуплет со смешанными типами данных:" ) print (Tuple1) Tuple1 = ( 0 , 1 , 2 , 3 ) Tuple2 = ( 'python' , 'geek' ) Tuple3 = (Tuple1, Tuple2) print ( "\ nТуплет с вложенными кортежами:" ) печать (Tuple3) Tuple1 = ( 'Geeks' ,) * 3 печать ( "\ nТуплет с повторением:" ) print (Tuple1) Tuple1 = ( 'Geeks' ) n = 5 печать ( "\ nТупле с петлей" ) для и в диапазоне ( и (n)): Tuple1 = (Tuple1,) печать (Tuple1)

Выход:

 Кортеж со смешанными типами данных:
(5, «Добро пожаловать», 7, «Гики»)

Кортеж с вложенными кортежами:
((0, 1, 2, 3), ('python', 'geek'))

Кортеж с повторением:
(«Гики», «Гики», «Гики»)

Кортеж с петлей
( 'Вундеркинды',)
(( 'Вундеркинды',),)
((( 'Вундеркинды',),),)
(((( 'Вундеркинды',),),),)
((((( 'Выродки',),),),),)
 

Доступ к кортежам

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

ПРИМЕЧАНИЕ : При распаковке кортежа количество переменных слева должно быть равно количеству значений в данном кортеже a.

Tuple1 = Tuple ( "Geeks" ) print ( "\ nПервый элемент кортежа:" ) print (Tuple1 [ 1 ]) Tuple1 = ( "Вундеркинды" , "Для" , "Вундеркинды" ) a, b, c = Tuple1 print ( "\ nЗначения после распаковки:" ) печать (а) печать (b) печать (с)

Выход:

Первый элемент Tuple:
е

Значения после распаковки:
Geeks
Для
Вундеркиндов 

Конкатенация кортежей

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

Tuple1 = ( 0 , 1 , 2 , 3 ) Tuple2 = ( 'Geeks' , 'Для' , 'Geeks' ) Tuple3 = Tuple1 + Tuple2 print ( "Tuple 1:" ) print (Tuple1) печать ( "\ nTuple2:" ) print (Tuple2) печать ( "\ nТуплирование после объединения:" ) печать (Tuple3)

Выход:

Кортеж 1:
(0, 1, 2, 3)

Tuple2:
(«Гики», «За», «Гики»)

Кортежи после объединения:
(0, 1, 2, 3, «Гики», «За», «Гики»)
 

Нарезка кортежа

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

Tuple1 = Tuple ( 'GEEKSFORGEEKS' ) print ( "Удаление первого элемента:" ) print (Tuple1 [ 1 :]) print ( "\ nТуплекс после изменения последовательности элементов:" ) print (Tuple1 [:: - 1 ]) print ( "\ nПечать элементов в диапазоне 4-9:" ) print (Tuple1 [ 4 : 9 ])

Выход:

Удаление первого элемента:
(«E», «E», «K», «S», «F», «O», «R», «G», «E», «E», «K», «S»)

Кортеж за последовательностью Элемента меняется на противоположный:
('S', 'K', 'E', 'E', 'G', 'R', 'O', 'F', 'S', 'K', 'E', 'E', ' ГРАММ')

Печатные элементы в диапазоне 4-9:
(«S», «F», «O», «R», «G»)
 

Удаление кортежа

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

Tuple1 = ( 0 , 1 , 2 , 3 , 4 ) del Tuple1 print (Tuple1)

Трассировка

(последний вызов был последним): файл
«/ home / efa50fd0709dec08434191f32275928a.py ”, строка 7, в
print (Tuple1)
NameError: имя‘ Tuple1 ’не определено

встроенных методов

. Перечислить Не более

Встроенная функция	Описание
все ()	Возвращает true, если все элементы верны или если кортеж пуст
любой ()	возвращает true, если какой-либо элемент кортежа имеет значение true. если кортеж пуст, вернуть false
len ()	Возвращает длину кортежа или размер кортежа
()	Возвращает перечислить объект кортежа
()	возвращает максимальный элемент данного кортежа
мин ()	возвращает минимальный элемент данного кортежа
сум ()	Суммирует числа в кортеже
отсортировано ()	вводим элементы в кортеж и возвращаем новый отсортированный список
tuple ()	Конвертируем итерацию в кортеж.

Последние статьи на Tuple

Кортежи Программы

,