python基础004----列表&元组

一、列表

1、概述

       列表是一个有序的、可修改的，元素以逗号分割，以中括号包围的序列。列表里面的数据类型是可变的，甚至可以嵌套一个列表。

       注：列表的索引和字符串的索引类似，但不完全相同，因为列表可以修改，所以我们可以通过列表的索引来修改列表。
2、定义

     创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：         

list=[] #定义一个空列表
list1= ["a", "b", "c", "d","d", "c", "f"]
list2 = ['Google', 'Runoob', 1997, 2000] #列表里面的数据类型是可变的，甚至可以嵌套一个列表
list3=[['a', 'b', 'c'], [1, 2, 3]]   #嵌套列表
print('输出嵌套列表：',list3)
print('输出嵌套列表中的某个元素：',list3[0][1])
list2 +=list1
print('输出列表拼接结果：',list2)

输出结果：

    

      注：列表可以进行索引，切片，加，乘，检查成员。与字符串的索引一样，列表索引从 0 开始，第二个索引是 1；索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

3、列表内建函数

（1）添加

        

 代码实例：        

list=[] #定义一个空列表
list1= ["a", "b", "c", "d","d", "c", "f"]
list2 = ['Google', 'Runoob', 1997, 2000] #列表里面的数据类型是可变的，甚至可以嵌套一个列表
print('输出list：',list)
list.append(1)     #追加，在列表末尾添加新的元素
list.append(2)
print('append末尾追加元素',list)
list.extend(list1) #将指定序列的元素依次追加到列表的尾部（列表的合并）
print('extend末尾追加列表',list)
list.insert(3,7)   #将指定的元素插入到对应的索引位上，注意负索引
list.insert(-1,9)
print('insert在指定位置插入指定元素',list)

输出结果：

        

 

（2）删除

       

 代码实例：

list=[] #定义一个空列表
list1= ["a", "b", "c", "d","d", "c", "f"]
list2 = ['Google', 'Runoob', 1997, 2000] #列表里面的数据类型是可变的，甚至可以嵌套一个列表
#删除
print('输出list1：',list1)
list1.pop()             #返回并删除指定索引位上的元素，默认删除最后一个（索引为-1）
print('pop默认删除列表最后一个元素',list1)
list1.pop(1)
print('pop删除索引为1的元素',list1)
list1.remove('d')       #移除列表中某个值的第一个匹配项
print('remove删除第一个d',list1)
print('clear清空列表',list1.clear())
del(list1)                  #删除整个列表或者列表的数据，del是python内置功能，不是列表独有。
print('del删除列表',list1)

输出结果：

    

 

 （3）查找

       

代码实例：

list=[] #定义一个空列表
list1= ["a", "b", "c", "d","d", "c", "f"]
list2 = ['Google', 'Runoob', 1997, 2000] #列表里面的数据类型是可变的，甚至可以嵌套一个列表
list3=[['a', 'b', 'c'], [1, 2, 3]]   #嵌套列表
#查找
print('输出list1：',list1)
print('输出list1中的第二个元素：',list1[2] )     #截取
print('输出list1中第二个到倒数第二个元素：',list1[2:-2] )     #截取
print('输出list1中除第一个之外的元素：',list1[1:] )        #截取
print('count统计列表中元素d的个数：',list1.count('d') )     #计数，统计并返回某个元素在列表中出现的次数
print('index查找到第一个d的索引是：',list1.index('d') )     #查找，从左到右返回查找到的第一个指定元素的索引，没找到报错
print('in查找1在不在列表中：',1 in list1)     #查找元素是否在列表中，在返回true，否则返回false
print('in查找"a"在不在列表中：',"a" in list1)
print('index没找到指定元素的索引报错：',list1.index('g') )

输出结果：

    

 

  （4）排序

          

代码实例：

list=[] #定义一个空列表
list1= ["a", "b", "c", "d","d", "c", "f"]
list2 = ['Google', 'Runoob', 1997, 2000] #列表里面的数据类型是可变的，甚至可以嵌套一个列表
list3=[['a', 'b', 'c'], [1, 2, 3]]   #嵌套列表
#排序----注意：列表内不同数据类型之间，不能进行比较，否则会报错
print('输出list1：',list1)
list1.reverse()            #反向列表中的元素
print('reverse排序后输出--倒序：',list1)
list1.sort()
print('sort排序后输出,默认升序：',list1)
list1.sort(reverse=True)
print('sort排序后输出,true为降序：',list1)

输出结果：

    

   （5）总结

            

 

二、元组

1、概述

       元组是一个有序的、可修改的，元素以逗号分割，以小括号包围的序列。  与列表类似， 不同之处在于元组的元素不能修改。元组使用小括号 ( )，列表使用方括号 [ ]。

       由于元组不可变，所以遍历元组比列表要快（较小的性能提升）。由于元组不可变，所以元组中的数据被“写保护”，这也可以联想到，一些软件重要的数据都是用元组存储。

2、定义

    元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。可以通过( )和tuple( )函数定义，如下所示：   

tup1=()
tup2=(1,2,3,4,5)
tup3=('Google', 'Runoob', 1997, 2000)
tup4 = "a", "b", "c", "d"   #  不需要括号也可以
tup7=(('Google', 'Runoob'), (1997, 2000))   #嵌套元组
print('输出定义的类型：',type(tup4))  #类型为元组--tuple
print('输出嵌套元组：',tup7[1])
print('输出嵌套元组：',tup7[1][0])
#元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
tup7=(50)          # 不加逗号，类型为整型
tup8=(50,)         # 加上逗号，类型为元组
print('不加逗号，类型为整型：',type(tup7),',输出结果:',tup7)
print('加上逗号，类型为元组：',type(tup8),',输出结果:',tup8)

输出结果：

     

元组中只包含一个元素时，需要在元素后面添加逗号的原因：

3、元组内建函数

（1）查找

       

代码实例：

tup1=()
tup2=(1,2,3,4,5,1,2)
tup3=('Google', 'Runoob', 1997, 2000)
tup4 = "a", "b", "c", "d"   #  不需要括号也可以
print('输出定义的类型：',type(tup4))  #类型为元组--tuple
#查找
print('输出tup2中的第二个元素：',tup2[2] )     #截取
print('输出tup2中第二个到倒数第二个元素：',tup2[2:-2] )     #截取
print('输出tup2中除第一个之外的元素：',tup2[1:] )        #截取
print('count统计列表中元素1的个数：',tup2.count(1) )     #计数，统计并返回某个元素在列表中出现的次数
print('index查找到第一个2的索引是：',tup2.index(2) )     #查找，从左到右返回查找到的第一个指定元素的索引，没找到报错
print('index没找到指定元素的索引报错：',tup2.index('g') )

输出结果：

    

 （2）修改元组

          A： 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。

          B :  如果元素值本身是一个可变数据类型的列表，那么其嵌套项可以被改。

代码实例：

tup1=()
tup2=(1,2,3,4,5,1,2)
tup3=('Google', 'Runoob', 1997, 2000)
tup4 = "a", "b", "c", "d"   #  不需要括号也可以
# 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。
tup2+=tup4
print('输出拼接后的元组：',tup2)
#如果元素值本身是一个可变数据类型的列表，那么其嵌套项可以被改
tup5=(1,'s',[1,2])
tup5[2].append(3)
print('输出修改列表后的元组：',tup5)

输出结果：

     

 （3）删除元组

          元组中的元素值是不允许删除的，但我们可以使用del语句删除整个元组，如下实例。

tup1=()
tup2=(1,2,3,4,5,1,2)
tup3=('Google', 'Runoob', 1997, 2000)
tup4 = "a", "b", "c", "d"   #  不需要括号也可以
#删除
del tup3
print ("输出删除后的元组 tup3 : ",tup3)

输出结果：

     

 （4）转化为元组----tuple函数

      tuple函数的功能与list函数基本上一样的，以一个序列作为参数并把它转化为元组，如果参数是元组，那么该参数会被原样返回，示例如下： 

tup1=()
tup2=(1,2,3,4,5,1,2)
tup3=('Google', 'Runoob', 1997, 2000)
tup4 = "a", "b", "c", "d"   #  不需要括号也可以
#转化为元组----tuple函数
print('元组转元组：',tuple(tup3))        #1、元组转元组
list=[1,2,'we','you']
print('列表转元组：',tuple(list))        #2、列表转元组
str='hello,I am Alice! \t'
print('字符串转元组：',tuple(str))       #3、字符串转元组

输出结果： 

   

 

三、列表与元组

1、列表与元组的区别

      （1）元素和列表都是有序的，元素不可修改，列表可修改。

      （2）元素和列表的元素可以是任何类型。

      （3）元组的元素长度可以任意。

 2、关于元组是不可变的

     所谓元组的不可变是指元组所指向的内存中的内容不可变。如下实例：

           

     从上面实例可以看出，重新赋值的tup2元组，绑定到新的对象了，不是修改了原来的对象。