Python 内置容器 之 tuple ( 元组 )

python 的内置容器  ：    有四个 

                    

                     list （列表）        set （集合）        tuple   （元祖）        dict  （字典）

     

Tuple  :   元组   （ ）

           #   元组 这个数据类型 在很多语言中都是没有的，它有点类似于其它编程语言中的枚举类型

           #   可以理解成为一个 常量的组合，Python 中是没有常量的，它是用变量来代替常量的，

           #   是一种不可变的数据类型！！ 

                 一旦一个 元组 创建定义好了，那是不能变，不能够修改里面的元素的！！ 

              

       定义  ：      也是有多种定义（创建）的方式 

                   #    第一种  ： 直接通过 （ ） 来定义 

                          示例 :

t = ( )
type( t )
<class 'tuple'>

                          注  ：    上面就是最最最简单的 元祖定义了，但是，就不会那么定义元组，你

                                     （ ） 里面连个值都没有，都说了，元组是不可变的数据类型，你（）里

                                       连值都没有，那就没什么作用。

                                       上面的定义方式主要是告诉大家 （ ） 就指的是 元组 类型！！

                        示例  ：  

                                       我们给 元组 （） 里面给上值 看看 ：

season = ('春','夏','秋','冬')
type(season)
<class 'tuple'>

                     注 ：  哎对嘛！ 里面给上值，就看着很美了！！

                #    第二种  ：  直接通过 tuple( )  来创建      

 wuxing = tuple( ('金','木','水','火','土') )
 type(wuxing)
<class 'tuple'>
 print(wuxing)
('金', '木', '水', '火', '土')

                    注    ：    上示就是通过 tuple( )  直接创建的，注意的是 tuple( ) 外面这个 （ ）

                                    是不能丢的！！！

                    注   ：     tuple ( )  这种形式，也是支持在 （ ） 里面放一个  列表 集合  甚至再放一个

                                   元组的，可以利用 tuple ( ) 和 集合 列表 等进行数据转换！

                    拓展  ：    

                                请先看一个示例  ：       

 a = (1)
 b = ( )

                                #   请思考一下 a  和  b 的数据类型  ： 

                                     b  是 元组 但是  a  却不是元组 ，看下示验证 ：

 type(a)
<class 'int'>
 type(b)
<class 'tuple'>

                                    什么情况？？？  b  是元组 ，而  a  却不是元组？？？？？

                                    这是为什么呢？？？？？？ 

                                    

                                    问题就在 a  的括号里的数值 （1） 里面只有一个数值！！

                                    我们确信的是  （ ） 在Python 里就是代表的是 元组的数据类型，这一点是

                                    毫无疑问的！！ 

                                    但是有个特殊情况 ：

                                    大家先想一想，我们在前面进行最基本的数学运算的时候，是不是也用到

                                    过 （ ），而它在数学计算的时候，它表示的是什么呢？？

                                    （3+5）*8   他代表的是一种  优先级   

                                    因此在Python 中 （1） 它默认表示你想提升 数字1的优先级别！！

                                    a=(1)     就表示 a = 1 ，a 就是 数字 1  

                       那问题来了，那我现在就是想要 一个 元组，而且，我现在就是想要给元组里就只放

                       一个数字，那我怎么办呢？？？

                       =====>>>>  :    

 a=(1,)
 type(a)
<class 'tuple'>

                     就是在 数字后面加上一个 逗号 ,   

                     

                     注意 ：   Python 中， (1)  和   （1,）  的区别！！ 

       访问  ：  有两种方法 

                     #     通过 下标 访问 

  season
('春', '夏', '秋', '冬')
 season[0]
'春'
 season[1]
'夏'
 season[2]
'秋'
 season[3]
'冬'

                      注  ：  访问元素的时候 是 [ 元素 ]    [ 0 ]   [ 1 ]           

                                 上示 是通过 正数下标 访问！

 season[-1]
'冬'
>>> season[-2]
'秋'
>>> season[-3]
'夏'
>>> season[-4]
'春'

                       注 ：   也可通过 负数下标访问 元素 

                       那我们能不能对 元组 进行修改呢？？

                       前面虽然说了 不能，我想再试试 ：

 season[1]='spring'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

                        得 ： 看来是真不能对 元组 进行 修改 ，会报错！！！

               #   通过 切片 访问（获得）元素 

                    切片 ： 遵循  左闭右开  原则 ！！，切片的实质其实还是 访问 下标

zz
('春', '夏', '秋', '冬', 1, 5, 3, 6, 9)
zz[0:7]
('春', '夏', '秋', '冬', 1, 5, 3)
zz[0:3]
('春', '夏', '秋')
zz[4:8]
(1, 5, 3, 6)
 zz[5:15]
(5, 3, 6, 9)

                    注 ： 左闭右开

                            [ 0 : 7 ]   :   取第一个元素 至 第六个元素   

                            [ 5 : 15 ]  :  可以看到 15 已经超出了 整个元组的元素，所以，默认就是至最后一

                                              个元素

        

 zz[:5]
('春', '夏', '秋', '冬', 1)
>>> zz[4:]
(1, 5, 3, 6, 9)
>>> zz[:]
('春', '夏', '秋', '冬', 1, 5, 3, 6, 9)

                    注 ：  切片操作中 第一个元素 和 第二个 元素 都可以省略

                              [ : 5 ]  :  代表 从第一个元素就开始取 

                              [ 4 : ]  :  代表从第5个元素取一直取到结束 

                              [  ： ]  :  代表 取出 全部元素 

                     

zz[1:5:2]
('夏', '冬')
>>> zz[1:8:3]
('夏', 1, 6)

                  注  ：  这时，发现 切片还可以有 第三个元素 表示 步长 

                             步长  ：  就是每隔几个 取元素 

                             [ 1 : 5 : 2 ]  :  从第2个元素 取到第 4 个元素，每隔 2 个元素取出

                             [ 1 : 8 : 3 ]  :  从第2个元素 取到 第 7 个 元素，每隔 3 个元素取出

遍历  ：   也是两种方法  For  和 While  都可以 

                #     For  :        

season
('春', '夏', '秋', '冬')
 for i in season :
    print(i)
春
夏
秋
冬

                #    While  :     

index = 0 
 while index<len(season):
    print(season[index])
    index +=1
春
夏
秋
冬

常用方法 ：

                    元组的常用方法相比较而言还是很少的，因为它不支持更改数据类型！！    

                    所以，它的方法我们讲的是 ：

                    count( )    index( )    

                    

                    count  (  )       统计元组中 元素出现的次数     

 season
('春', '夏', '秋', '冬')
season.count('春')
1

                      index  (  )       返回 元组 中 元素 的下标 

 season
('春', '夏', '秋', '冬')
>>> season.index('春')
0
>>> season.index('夏')
1
>>> season.index('秋')
2
>>> season.index('冬')
3