python元组知识点_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("```(2)```")

# 1.如果两个元组长度相等

# 从两元组第一个元素开始比较，若左侧元组第一个元素>右侧元组第一个元素，直接返回True；

# 若左侧元组第一个元素 (1, 100)

print(info)

info = (2, 100) > (3, 8)

print(info)

info = (1, 2, 100) > (1, 2, 8)

print(info)

# 2.如果两个元组长度不等

# 从两元组第一个元素开始比较，若左侧元组第一个元素>右侧元组第一个元素，直接返回True；

# 若左侧元组第一个元素 (1, -1111)

print(info)

# 两个元组进行 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))