python（元组）

 

创建空元组

方式1：
    变量 = ()

方式2：
    变量 = tuple()

创建单个元素的元组

方式1：
    变量= (值,)

方式2：
    变量 = 值,

创建多个元素的元组

方式1：
    变量 = (值,值...)

方式2：
    变量 = 值,值...

 注：

•    tuple 元组,其实跟列表差不多，存一组数，一旦创建，不能修改。元组是只读列表

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"    # 元组赋值时，可以不写括号

•  元组本身不可变，如果元组中包含其他可变元素，那么这些可变元素可以改变（tuple的不可变限制只是在一个纬度上：元素的类型。可理解为：tuple的元素所保存的内容（数值或内存地址）是不允许修改的，但地址映射的对象自身是可以修改的。）。元组不能利用索引修改元素的值。

t = ('a','b',['c','d'],1)
t[2][0]='x'
t[2][1]=5
print(t)    #('a', 'b', ['x', 5], 1)

• 组中元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用 

tup1 = (50)
tup2 = (50,)
print(type(tup1),type(tup2))  
#打印结果：<class 'int'> <class 'tuple'>

 基本操作

访问元素

变量[索引]

注意： 元组中的元素，只允许访问，无法修改，删除 及 添加。

序列操作

序列操作：索引，分片，最大值，最小值，长度，加法，乘法...

元组相加

变量 = 元组1 + 元组2
结果：新的元组

元组相乘

变量 = 元组 * 整数
结果：新的元组

索引操作

变量[索引]      只能访问不能修改和删除

分片

格式：变量[:]                      获取整个元组的元素
格式：变量[开始索引:]               从开始索引的元组截取末尾
格式：变量[:结束索引]               从开头截取到结束索引之前
格式：变量[开始索引:结束索引]         从开始索引位置截取到结束索引之前
格式：变量[开始索引:结束索引:间隔值]   从开始索引位置按照间隔值截取到结束索引之前
成员检测

格式：值 in 元组          作用：检测一个值是否在元组当中

格式：值 not in 元组      作用：检测一个值是否不再元组当中

元组内涵/元组推导式

基本格式：

格式： 变量 = (i for i in 元组)
结果：不是元组而是一个生成器

带条件格式：

格式： 变量 = (i for i in 元组 if 条件表达式)
结果：不是元组而是一个生成器

多循环推导式：

格式： 变量 = (x+y for x in 元组1 for y in 元组2)
结果：不是元组而是一个生成器   x+y可以是其他操作

带条件的多循环推导式：

格式： 变量 = (x+y for x in 元组1 for y in 元组2 if 条件表达式)
结果：不是元组而是一个生成器   x+y可以是其他操作

 修改元组中元素的方法

Ⅰ.修改元组内特定位置的值，可以先将元组转换成其他可变的类型（如，列表），然后再将其转换成元组类型

t1 = (1, 2, 3, 1, 2, 3, 4)
#将元组类型转换成列表类型
list1 = list(t1)      # list1 = [1, 2, 3, 1, 2, 3, 4]
#修改列表
list1[1] = 'python'
list1.append(["a", "b"])
#将列表类型转换成元组类型
t1 = tuple(list1)   #  t1 = (1, "python", 3, 1, 2, 3, 4,["a", "b"]）

 Ⅱ.间接方法

#将tup1 = (1, 2, 4, 5)变为(1, 2, 3, 4, 5)
tup1 = (1, 2, 4, 5)
tup1 = tup1[:2] + (3,) + tup1[2:]
print(tup1)

元组内置函数

len()

获取元组的长度

max()

获取元组中的最大值

min()

获取元组中的最小值

tuple()

创建空元组或者将其他序列转化为元组类型

ndex(

获取指定值在元组中的索引值
格式：元组.index(值)
返回值：整数

count()

计算某个值在元组中出现的次数
格式：元组.count(值)
返回值：整数

 namedtuple(具名元组)

 通过collections.namedtuple 这个工厂函数，来构造一个带字段名的元组。

namedtuple 对象的定义如以下格式：

collections.namedtuple(typename, field_names, verbose=False, rename=False) 

返回一个具名元组子类 typename，其中参数的意义如下：

typename：元组名称

field_names: 元组中元素的名称

rename: 如果元素名称中含有 python 的关键字，则必须设置为 rename=True

verbose: 默认就好

下面来看看声明一个具名元组及其实例化的方法：

import collections
#方法一
User = collections.namedtuple('User',['name','age','id'])
#方法二
User = collections.namedtuple('User','name age id')
user = User('张三','20','20180101')
print(user)     #打印结果：User(name='张三', age='20', id='20180101')

collections.namedtuple('User', 'name age id') 创建一个具名元组，需要两个参数，一个是类名，另一个是类的各个字段名。后者可以是有多个字符串组成的可迭代对象，或者是有空格分隔开的字段名组成的字符串。具名元组可以通过字段名或者位置来获取一个字段的信息。

具名元组的特有属性:

类属性 _fields：包含这个类所有字段名的元组 类方法 _make(iterable)：接受一个可迭代对象来生产这个类的实例 实例方法 _asdict()：把具名元组以 collections.OrdereDict 的形式返回，可以利用它来把元组里的信息友好的展示出来

from collections import namedtuple
#创建User类
User = namedtuple('User',['name','sex','age'])
#实例化对象
user = User('张三','男',20)
#可以通过_make方法实例化对象
user1 = User('李四','男',23)
#打印所有字段名
print(user._fields)
#获取对象的属性
print(user.name)
print(user.sex)
print(user.age)
#使用_replace方法修改对象的属性
user = user._replace(age=22)
print(user.age)
#可通过_asdict方法将User对象转换成字典
print(user._asdict())

#打印结果
('name', 'sex', 'age')
张三
男
20
22
OrderedDict([('name', '张三'), ('sex', '男'), ('age', 22)])