python学习（3）——【python中的元组相关的知识】

1）python元组介绍
2）python元组的创建（两种方法）
3）python元组不可修改
4）python元组的访问
5）python元组的排序
6）python元组连接和计算
7）python将多个列表\元组\字符串合成元组
8）python用生成器推导式创建元组）

————————————————————————————————————————————————

1）python元组介绍：

元组（tuple）不同于列表，前面的文章中讲解列表时强调列表是一个可变序列，它可以任意的修改（增删改查）其中的元素，但是元组不同，元组是不可变序列，也就是说元组中的元素是无法进行修改的。因此，元组没有增加元素、修改元素、删除元素相关的函数，所以在元组的学习中，我们只要掌握元组的创建、删除，元组中元素的访问和计数即可。元组支持的操作有：

1.索引访问
2.切片操作
3.连接操作
4.成员关系操作
5.比较运算操作
6.计数：len()、sum()、max()、min() 等

元组可以执行的操作：


2）python元组的创建（两种方法）：

方法一：（直接创建法，类似于直接创建字符串和列表的方法）

>>> aa=()        >>> bb=12,'ak',True     >>> cc=(12,'ak',True)     >>> dd=(1)            >>> ee=(1,)
>>> aa           >>> bb                  >>> cc                    >>> dd                >>> ee
()               (12, 'ak', True)        (12, 'ak', True)          1                    (1,)
>>> type(aa)     >>> type(bb)            >>> type(cc)              >>> type(dd)          >>> type(ee)
<class 'tuple'>  <class 'tuple'>         <class 'tuple'>           <class 'int'>         <class 'tuple'>

1） 通过上面的五个直接创建元组的实例要知道创建元组时小括号可以省略；
2） 如果元组中只有一个元素则元素后要加逗号，这是因为如果不加逗号解释器会把小括号中唯一的元素当成是int型；

方法二：（利用内置函数tuple()）

>>> aa=tuple()      >>> bb=tuple("fao23g*$")                   >>> cc=tuple(range(6))
>>> aa              >>> bb                                     >>> cc
()                  ('f', 'a', 'o', '2', '3', 'g', '*', '$')   (0, 1, 2, 3, 4, 5)
       
<class 'tuple'>                                       

>>> bb=tuple(12,'ak',True)                                >>> bb=tuple(12)
Traceback (most recent call last):                        Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>                  File "<pyshell#38>", line 1, in <module>
    bb=tuple(12,'ak',True)                                   bb=tuple(12)
TypeError: tuple expected at most 1 argument, got 3       TypeError: 'int' object is not iterable

>>> dd=tuple([1,43,2])        >>> ee=tuple(['nfoa','ajgo','343'])
>>> dd                        >>> ee
(1, 43, 2)                    ('nfoa', 'ajgo', '343')

1）通过上面的七个利用内置函数tuple()创建元组的实例要知道tuple中的参数一定要是一个迭代对象（例如：字符串、range(数字)、元素类型相同的的列表、数字（无论是int、float、double都可以））；
2）可迭代对象中的列表中的元素一定要是同种类型，同时如果可迭代对象是字符串则一定要全都是字符串、数字就一定要却是数字，一定不能混合，混合的对象不是可迭代对象；
3）tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组；
4）list()可以接收元组、字符串、其他序列类型、迭代器等生成元组；

3）python元组不可修改：

>>> aa=(123,'ak','aof')
>>> aa
(123, 'ak', 'aof')
>>> aa[2]
'aof'
>>> aa[2]=23
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    aa[2]=23
TypeError: 'tuple' object does not support item assignment

虽然通过dir(aa) 可以查看到tuple可以使用内置的__add__函数添加元组元素，但是，添加元素之后的元组是一个新的元组，而原来的元组aa还是最初的那些元素没有新的增加，所以内置的__add__函数与元组的不可更改性不冲突。

>>> aa=(123, 'ak', 'aof')              >>> bb=aa.__add__(('ak',3343))
>>> aa                                 >>> bb
(123, 'ak', 'aof')                     (123, 'ak', 'aof', 'ak', 3343)
>>> id(aa)                             >>> id(bb)
1527569785920                          1527568726752

4）python元组的访问：

元组中元素的访问方法和列表是一样的，只不过需要注意列表访问返回的是列表对象，而元组访问返回的是元组对象。


5）python元组的排序：

在前面关于列表的学习中，我们知道列表的排序方法中有一种是利用 list.sorted() 函数对原列表对象进行修改，但是由于元组是不可变对象不支持被修改，所以元组中并没有这个函数可以使用，如果我们要对元组进行排序，只能使用内置函数 sorted(tupleobj)，并且会生成一个新的列表对象将排序后的元组中的元素存放成一个列表，原来的元组并不会被修改。

>>> aa=(234,2.23,True,3.34e12) //如果元素中只有数字和bool值进行比较，就会将布尔值变成0或1
>>> aa
(234, 2.23, True, 3340000000000.0)
>>> sorted(aa)
[True, 2.23, 234, 3340000000000.0]  //虽然是对元组进行排序，但其实最后是生成一个新的列表用于存放

##############################################################################################

>>> bb=('aaifjo','fjao32','a',False)  //如果元素中是字符串和bool值进行比较，那么就会报错类型不同无法比较、排序
>>> bb
('aaifjo', 'fjao32', 'a', False)
>>> sorted(bb)
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    sorted(bb)
TypeError: '<' not supported between instances of 'bool' and 'str'

##############################################################################################

>>> cc=('aaifjo','fjao32','a') //字符串进行排序
>>> cc
('aaifjo', 'fjao32', 'a')
>>> sorted(cc)
['a', 'aaifjo', 'fjao32']   //虽然是对元组进行排序，但其实最后是生成一个新的列表用于存放

##############################################################################################

>>> dd=('foj','324',3423)  //如果元素中是字符串和数字进行比较，那么就会报错类型不同无法比较、排序
>>> dd
('foj', '324', 3423)
>>> sorted(dd)
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    sorted(dd)
TypeError: '<' not supported between instances of 'int' and 'str'

6）python元组连接和计算：

>>> aa=10,9,24,18    //定义aa元组
>>> aa
(10, 9, 24, 18)
>>> bb='ak','python','学习'   //定义bb元组
>>> bb
('ak', 'python', '学习')

#将aa和bb进行拼接
>>> aa+bb             //不同类型的对象采用 + 就是连接的作用（类比字符串拼接）
(10, 9, 24, 18, 'ak', 'python', '学习')

#将aa的第一个和第三元素进行 + 
>>> aa[0]+aa[2]      //因为aa的第一个和第三元素都是数字，所以采用 + 就是进行加法运算的作用
34
>>> bb[0]+bb[2]+bb[1]      //因为bb的第一个、第二个和第三元素都是字符串，所以采用 + 就是进行拼接的作用
'ak学习python'

>>> len(aa)   //元组aa长度
4
>>> min(bb)    //元组bb中最小的元素（字符串则根据ascii）
'ak'
>>> max(bb)   //元组bb中最大的元素（字符串则根据ascii）
'学习'
>>> sum(aa)   //元组aa所有元素总和
61

7）python将多个列表\元组\字符串合成元组：

在python中提供了一个函数 zip() 可以将多个列表\元组\字符串对应的位置下的元素组合成一个元组并返回这个zip对象。

#多个元组合成一个元组
>>> aa=10,9,24,18       //定义aa元组
>>> bb='ak','python','学习'      //定义bb元组
>>> cc=zip(aa,bb)
>>> cc
<zip object at 0x000002BC08D6BDC0>
>>> list(cc)
[(10, 'ak'), (9, 'python'), (24, '学习')]


#多个列表合成一个元组
>>> aa=[10, 9, 24, 18]
>>> bb=['ak', 'python', '学习']
>>> cc=zip(aa,bb)
>>> cc
<zip object at 0x000002BC06C52B40>
>>> list(cc)
[(10, 'ak'), (9, 'python'), (24, '学习')]


#多个字符串合成一个元组
>>> aa='python'
>>> bb='学习'
>>> cc=zip(aa,bb)
>>> cc
<zip object at 0x000002BC08C93500>
>>> list(cc)
[('p', '学'), ('y', '习')]

8）python用生成器推导式创建元组：

从形式上看，生成器推导式与列表推导式类似，只不过生成器推导式使用的是小括号。列表推导式是直接生成列表对象，但是生成器推导式生成的既不是元组也不是列表而是一个生成器对象。我们可以通过生成器对象转化为列表或者元组，也可以使用生成器对象中的__next__()方法进行遍历，或者直接作为迭代器对象来使用。但是不管我们以什么方法使用它，元素访问结束后，如果需要再次访问其中的元素则必须重新创建生成器对象。

>>> aa=(x*2 for x in range(5))     //创建了一个生成器推导式aa
>>> aa
<generator object <genexpr> at 0x00000247978F43C0>   //类型既不是元组也不是列表而是一个生成器对象
>>> list(aa)            //通过生成器对象转化为列表或者元组tuple(aa)
[0, 2, 4, 6, 8]
>>> tuple(aa)              
()                          //一个生成器推导式只有一次有效，再次访问则必须重新创建生成器对象

>>> aa=(x*2 for x in range(5))     //生成器推导式aa
>>> aa
<generator object <genexpr> at 0x00000247979BDA50>
>>> aa.__next__()                 //遍历
0          
>>> aa.__next__()
2
>>> aa.__next__()
4
>>> aa.__next__()
6
>>> aa.__next__()
8
>>> aa.__next__()               //此时生成器已经没有元素了
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    aa.__next__()
StopIteration