Python元组Tuple基础知识点总结

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time  : 2020/4/17 21:23
# @Author: xuhui
# @File  : Tuple.py
import operator

print()
print("`````aaaaaaaaa`````")
print()

# ！！！元组的创建
# 多元素元组的创建
print("```(1)```")
#    方法一：通过小括号()来创建
tuple1 = (1, 2, 3, 4, 5)
print(tuple1)
#    方法二：任意无括号，以逗号隔开的数据，默认为元组
tuple2 = 6, 7, 8, 9, 10
print(tuple2)
# 单元素元组的创建
print("```(2)```")
# !注意：创建单元素元组是使用元素后加","（逗号）的方式来避免混淆
#       tuple_x = (number)（number是任意一个数），创建出来的tuple_x是一个int类型的变量，而不是一个元组
#       相应的，tuple_y = ("String")（String是任意一个字符串）,创建出来的tuple_y是一个str类型的变量，而不是一个元组
tuple3 = (8)
print(type(tuple3))
tuple4 = ("String")
print(type(tuple4))
tuple5 = (8,)
print(type(tuple5))
# 创建空元组
print("```(3)```")
#    方法一：等号后面使用小括号()，小括号()中什么都不写
tuple6 = ()
print(type(tuple6))
#    方法二：使用tuple()函数，什么参数也不加，来构建空元组
tuple7 = tuple()
print(type(tuple7))
# 通过tuple()函数可将迭代器（如：列表、元组、字符串、字典等）转化为元组
print("```(4)```")
# ！注意：tuple()函数不能将非迭代器（如：数字等）转化成元组
#    1.通过tuple(list_x)函数将列表转化为元组，即用list_x中的所有元素作为新元组的元素来创建一个新元组
list1 = ["1", "2", "3", "4"]
tuple8 = tuple(list1)
print(tuple8)
#    2.通过tuple(tuple_x)函数将元组转化成元组，即用tuple_x中的所有元素作为新元组的元素来创建一个新元组
tuple9 = tuple(("r0", "r1", "r2", "r3", "r4"))
print(tuple9)
#    3.通过tuple(String_x)函数将字符串转换成元组，即用String_x中的所有字符作为新元组的元素来创建一个新元组
tuple10 = tuple("String")
print(tuple10)
#    4.通过tuple(dict_x)函数将字典转换成元组，即用dict_x中的所有key值作为新元组的元素来创建一个新元组
tuple11 = tuple({"id": "0001", "Name": "Jack", "Age": 22, "Sex": "男"})
print(tuple11)

print()
print("`````bbbbbbbbb`````")
print()

# ！！！获取元组中元素
# 获取元组中元素，可通过与获取列表元素相同的方法来获取元组元素
print("```(1)```")
print(tuple9[0])
print(tuple9[-1])
# 元组的切片
print("```(2)```")
#    1.若要通过元组的切片取出元组tuple_x中所有元素，可使用tuple_x[:]
print(tuple9[:])
#    2.若要取出tuple_x中序号为1到序号为3的元素（序号为3的元素也取），应使用tuple_x[1:4]（左闭右开规则）
print(tuple9[1:4])
#    3.若要取出tuple_x（共五个元素）中序号-3到序号-5的所有元素（序号为-3和序号为-5的元素也取）
#      应使用tuple_x[:-2]（左开右闭原则）
print(tuple9[:-2])
#    4.若要取出tuple_x（元素数量不确定），取出最后两个元素，应使用tuple_x[-2:]
print(tuple9[-2:])

print()
print("`````ccccccccc`````")
print()

# ！！！修改元组中元素
# ！注意：元组具有不可修改性————不可对元组中的元素的地址进行修改（即，不可对元组中元素进行直接赋值操作）
print("```(1)```")
# tuple9[0] = "r11"
# -->  TypeError: 'tuple' object does not support item assignment
# 若要将tuple9[0]改为"r11"，只能通过重新对整个元组赋值，重新赋值前后的两个元组不是同一个元组，即使变量名相同
print(id(tuple9))
tuple9 = ("r11", "r1", "r2", "r3", "r4")
print(id(tuple9))
print(tuple9)
# ！更要注意：若元组中有列表等（可在不改变元素地址的前提下对自身进行修改的，即具有可修改性）元素，
#           可以通过改变元组中的列表元素来达到间接改变元组的目的；
#           此方式并不违背元组的不可修改性，因为元组中存放的其实是各元素的地址
#           只要不改变个元素的地址就可以对各个元素进行操作。
print("```(2)```")
info = 2
print(id(info))
info = 8
print(id(info))
list2 = [1, 2]
print(id(list2))
list2.append(3)
print(id(list2))
tuple12 = ("a", 1, list2)
print(tuple12)
list2.append(4)
print(tuple12)
# 若要向元组中添加元素，可采取元组拼接的方式，等同于元组重新赋值，元组地址改变
print("```(3)```")
print(id(tuple12))
tuple12 += (11, 22)
print(tuple12)
print(id(tuple12))

print()
print("`````ddddddddd`````")
print()

# ！！！元组的运算
# 元组的加法，tuple_x = tuple_y + tuple_z，则tuple_x为tuple_y与tuple_z这两个元组的拼接（每个元素指向的位置与之前一样）
print("```(1)```")
tuple13 = tuple9 + tuple12
list2.append(5)
print(tuple13)
# 元组的乘法，tuple_x = tuple_y * n，则tuple_x为n个tuple_y的拼接（每个元素指向的位置与之前一样）
print("```(2)```")
tuple14 = tuple12 * 3
list2.append(6)
print(tuple14)

print()
print("`````eeeeeeeee`````")
print()

# ！！！删除元组
# ！注意：由于元组的不可修改性，元组中的元素是不能单独删除的
# 删除元组指的是将整个元组都删除掉，且
del tuple14
# print(tuple14)
# -->NameError: name 'tuple14' is not defined

print()
print("`````fffffffff`````")
print()

# ！！！元组的整体合并
# tuple_x = tuple_y, tuple_z，则tuple_x成为由（tuple_y整体作为一个元素和tuple_z整体作为一个元素）构成的新元组
print(tuple1)
print(tuple2)
tuple15 = tuple1, tuple2
print(tuple15)

print()
print("`````ggggggggg`````")
print()

# ！！！可通过分片方法构建一个新的元组
tuple16 = tuple1[:3]
print(tuple16)

print()
print("`````hhhhhhhhh`````")
print()

# ！！！元组的成员关系操作符in，not in
# in，用来判断某个值是不是 在元组中，在的话返回True
info = 1 in tuple1
print(info)
# not in，用来判断某个值是不是 不在元组中，不在的话返回True
info = 1 not in tuple1
print(info)

print()
print("`````iiiiiiiii`````")
print()

# ！！！元组的逻辑操作符>，<，==
# 两个元组进行==比较时(等于比较)
print("```(1)```")
#    从两元组第一个元素开始比较，不相等，直接返回False；相等，比较下一个；若两个元组的所有元素对应相等，则返回True
#    ！注意：若两个元组长度不相等也会返回False，即==指的是元组的长度、元素全部相等
info = (1, ) == (1, )
print(info)
info = (1, ) == (1, 3)
print(info)
info = (1, "s") == (1, 4)
print(info)
info = (1, "s") == (1, "s")
print(info)
info = (1, 1, 3) == (1, 1, 4)
print(info)
# 两个元组进行>比较时(大于比较)
print("```(2)```")
#    1.如果两个元组长度相等
#    从两元组第一个元素开始比较，若左侧元组第一个元素>右侧元组第一个元素，直接返回True；
#                           若左侧元组第一个元素<右侧元组第一个元素，直接返回False；
#                           若左侧元组第一个元素==右侧元组第一个元素，比较下一个元素；
info = (2, 8) > (1, 100)
print(info)
info = (2, 100) > (3, 8)
print(info)
info = (1, 2, 100) > (1, 2, 8)
print(info)
#    2.如果两个元组长度不等
#    从两元组第一个元素开始比较，若左侧元组第一个元素>右侧元组第一个元素，直接返回True；
#                           若左侧元组第一个元素<右侧元组第一个元素，直接返回False；
#                           若左侧元组第一个元素==右侧元组第一个元素，比较下一个元素；
#    较短元组（共n个元素）中所有元素都与较长元组中前n个相等，那么比较长度，谁长谁就大
info = (1, ) > (1, -1111)
print(info)
# 两个元组进行<比较时(小于比较)，规则与大于比较时类似
#
# 可将两变量比较后返回的布尔值作为元组的元素创建元组
print("```(3)```")
tuple17 = (1, 8 > 9, 10)
print(tuple17)
info = False in tuple17
print(info)
info = "False" in tuple17
print(info)

print()
print("`````jjjjjjjjj`````")
print()

# ！！！元组系统内置函数（较常用的几个）
# cmp(tuple_x, tuple_y)，比较tuple_x与tuple_y
# ！注意Python3.x中已经没有cmp()方法了
# 若要实现比较功能，可引入operator模块，适合任何对象
# 该模块中的eq(x,y)方法实现比较，x与y相等返回True，不等(类型不一样也是不等)返回False
print("```(1)```")
print(operator.eq((1, 1), (1, 1)))
print(operator.eq((1, ), (1, 1)))
print(operator.eq("s", (1, 1)))
print(operator.eq("s", 1))
print(operator.eq("s", "s"))
print(operator.eq(0, "0"))
# len(tuple_x)，计算tuple_x中元素个数
print("```(2)```")
print(len((0, 1, 2, 999, 10086)))
# max(tuple_x)，返回tuple_x中元素最大值
# ！注意只有当tuple_x中元素全部为同一类型（都为int类型、都为str类型、都为列表或者都为元组）时才可以使用
print("```(3)```")
print(max(([1], [])))
# min(tuple_x)，返回tuple_x中元素最小值
# ！注意只有当tuple_x中元素全部为同一类型（都为int类型、都为str类型、都为列表或者都为元组）时才可以使用
print("```(4)```")
print(min(("s", "-1")))
# tuple_x.count(y)，统计tuple_x元组中含有多少个y
print("```(5)```")
print(().count(0))
print((0, 1, 2, 0, 0, 0, 0, 0, 0).count(0))

# tuple_x.index(value,begin,end)，用于从tuple_x中找出第一个匹配value的索引位置，如果value不在tuple_x中会报一个异常
# begin为开始检索的位置，默认为0
# end为结束检索的位置，默认为元组的长度length(序号为length的元素不参与检索，依旧是左闭右开规则)
# 指定end前必须指定begin，否则会报错
print("```(6)```")
# print((1, 2, 3, 4, 5).index(0))
# -->ValueError: tuple.index(x): x not in tuple
print((1, 2, 0, 0, 0).index(0))
print((1, 2, 0, 0, 0).index(0, 3, 4))
# print((1, 2, 0, 0, 0).index(0, 3, 3))
# -->ValueError: tuple.index(x): x not in tuple

# print((1, 2, 0, 0, 0).index(0, , 3))
# -->File "E:/A-PythonProject/E-BP3-Test/Tuple.py", line 246
# -->print((1, 2, 0, 0, 0).index(0, , 3))
# -->                               ^
# -->SyntaxError: invalid syntax
print((1, 2, 0, 0, 0).index(0, 4))