Python学习心得——列表和元组的操作方法

列表(list)

再三考虑，我决定用代码来做一个总结（可能并不完善，若以后学到更多的再进行补充），如下：

- 对列表的简单操作

#!/usr/bin/env python
#-*- coding:utf-8 -*-

#def一个列表
fruits=["apple","banana","watermelon","cherry","lemon"]

#显示列表的元素
print "fruits:",fruits

#len()函数获得list元素个数（文本编辑里记得用"print"显示结果，字符命令行可以不用）
print "Length of fruits: ",len(fruits)

#用索引来访问代码中的每个元素(与数组类似，从0开始，注意不要越界）
print "fruits[0]: ",fruits[0]
#可以用"-n"取倒数第n个元素,如“-2”访问倒数第二个元素
print "fruits[-2]: ",fruits[-2]
#用方括号截取list中的元素
print "fruits[:4]: ",fruits[:4]	#从索引为0的元素截取到索引小于4的元素
print "fruits[1:3]: ",fruits[1:3] #从索引为1的元素截取到索引小于3的元素
print "fruits[1:]: ",fruits[1:]	#从索引为1的元素开始截取整个列表

#list.append()追加元素到list末尾
fruits.append("grape")	#括号内只能有一个参数，可以添加list和tuple
print "After fruits.append(): ",fruits

#list.insert()把元素插入到list指定位置
fruits.insert(1,"pear")	#"1"代表指定位置的索引，"pear"代表插入的元素
#插入后
print "After fruits.insert(),fruits is:",fruits

#list.pop()删除list末尾的元素
fruits.pop()
print "After fruits.pop(),fruits is: ",fruits

#list.pop(i)删除索引为i的元素
fruits.pop(0)
print "After fruits.pop(0),fruits is: ",fruits

#直接赋值替换掉相应位置的元素
fruits[2]="peach"
print "After fruits[2]=""'peach'"",fruits is: ",fruits

运行截图如下，可以自行运行代码查看

- 对列表的其他操作：(以下代码为命令提示符中输入并运行）
1.del语句执行删除操作：
1)删除列表中的某个元素（注：不要用系统关键词作为变量名，我这里用了，下面2）中出现了不一样的显示）：

list=[1,2,3,4]	#def一个列表
list			#查看列表中的元素
del list[0]		#删除列表的第一个元素
list			#查看执行删除操作后的列表元素

2）删除整个列表（注：变量名不要用系统关键词，我用了list作为该列表的名字，出现了不一样的结果）：

list=[1,2,3,4,5]	#def一个列表
list			#显示列表中的元素
del list		#删除整个列表
list			#显示删除后列表情况（不报错，显示list含义）

number=[1,2,3,4]	#def一个列表
number			#显示列表中的元素
del number		#删除整个列表
number			#显示删除后列表情况（会报错）

2.可以用“+”将多个列表连接起来：

list1=[1,2]		
list2=[3,4]
list3=[5,6]
list1+list2+list3		#将三个列表连接起来并输出连接后结果

3.可以用“*” 将一个列表的所有元素复制多次构成一个列表（在这里补充一下列表中可以包含不同类型的元素）：

list1=[1,(1,2),[5,6],"aa"]	#def一个包含实数、tuple（元组）、list（列表）、字符串类型的列表
list1*2				#复制list1中的所有元素并输出
list1*3

4."x in list"判断元素"x"是否在某列表里,在时结果为Ture,不在时结果为False（“x not in list"与之相反)

"aa" in list1	#看字符串"aa"是否在list1中
"bb" in list1	#看字符串"bb"是否在list1中

当元素在列表中的列表或者元组中时，不能越级判断,判断仅为某元素是否在该列表中，或某元素的元素是否在该元素中，而不能判断某元素中的元素是否在该列表中:

5 in list1
[5,6] in list1
5 in list1[2]

5.”for x in list"进行迭代操作（下次整理迭代时详写）

for x in list1:	#依次将list1中的元素赋给X
    print x          #打印x的值（注意缩进）

(不注意缩进会报错)
6.list同样具有强制类型转换操作：

name="Markel"			#def一个字符串类型变量
list(name)			#将字符串类型转换成列表类型
fruits=("apple","pear")		#def一个元组类型变量
list(fruits)			#将元组类型转换成列表类型

7.列表可以使用python其他的函数：

1. 比较两列表的元素：cmp(list1,list2)
   若list1>list2，则返回1
   若list1 若list1=list2，则返回0

#两列表的长度可以不同

#从左往右比较，元素不相等即可出结果，列表1先有元素大于列表2中同位置元素则列表1大，反之，则列表2大；
list1=[2,1,,3,4]
list2=[1,4,5,6]
print cmp(list1,list2)		#输出1
print cmp(list2,list1)		#输出-1

#若两列表元素相同，长度一样，则两列表一样大；
list3=[1,2,3,4]
list4=[1,2,3,4]
print cmp(list3,list4)		#输出0

#若列表长度不等，但在相等长度范围内元素相同，则长度大的列表大
list5=[1,2,3,4,5]
list6=[1,2,3,4]
print cmp(list5,list6)		#输出1

2. 返回列表元素的最大值：max(list1)

list1=[2,1,4,8,6]
print max(list1)		#输出8

3. 返回列表元素的最小值：min(list2)

list2=[7,5,6,3,0,1]
print min(list2)		#输出0

4. 统计某个元素在列表中出现的次数：list1.count(x)

list1=[0,1,2,3,0,0,2]
print list1.count(0)	#输出3
print list1.count(1)	#输出1
print list1.count(2)	#输出2
print list1.count(4)	#输出0

5. 在列表末尾追加一个列表的值：list1.extend(list2)

#list1本身的值发生了改变
list1=[1,2,3,4]
lsit2=[5,6,7,8]
list1.extend(list2)
print list1	 #输出[1,2,3,4,5,6,7,8]

6. 在列表中查找元素：list1,index(x[,start[,end]])

#x:查找的对象
#start：查找的起始位置
#end：查找的结束位置
list1=[1,2,3,4,5,6,1]
print list1.index(1)	#输出0，仅返回从左往右第一个遇到的索引位置

print list1.index(0)	#报错：0 is not in list

print list1.index(1,1)	#输出6，从索引为1的位置开始查找
print list1.index(2,2)	#报错：2 is not in list,从索引为2的位置开始查找

print list1.index(1,1,6)#报错：1 is not in list,从索引为1的元素开始，到索引小于6的元素结束
print list1.index(1,1,7)#输出6

7. 移除列表中某个值(仅移除第一个遇见的元素）：list1.remove(x)

list1=[1,2,3,4,1]
list1.remove(1)
print list1	#输出[2,3,4,1]

8. 反向列表中的元素：list1.reverse()

#list1本身被改变
list1=[1,2,3,4]
list1.reverse()
print list1	#输出[4,3,2,1]

9. 将列表排序：list1.sort(cmp=None,key=None,reverse=False)
   cmp:没有指定的话按系统默认的比较函数进行比较，指定了自定义的比较函数，就会按照自己写的函数的方法进行比较
   key:可以指定的用来比较的元素，只有一个参数，取自可迭代对象
   reverse：值为False是升序排序（默认），值为True是降序排序
   这里贴一个元组的代码的图吧，主要理一下key的作用，原理是一样的
   
   

元组（tuple）

对元组的操作方法和对列表的类似，区别在于元组一旦初始化就不能够修改，
所以不能使用append(),pop(),insert()
也不可以对元组中的元素重新赋值，但可以重新给元组赋值

num=(1,2,3,4)
num[0]=8	#错
num=(5,6,7,8)	#对

2.不可以删除元组中的元素，但可以删除该元组：

3.元组中同样可以有不同类型，元组中的list中的元素可以改变，但元组指向的list不能变，即可以对元组中元素的元素进行操作（注意：该元组元素本身要可以进行操作，如：list）

number=(1,2,3,[4,5,6])	#def一个含有列表的元组
number[3]=[7,8]		#修改列表，报错
number[3][0]=7		#修改列表中的元素，可行
number			#显示修改后元组的元素
number[3].append(8)	#在列表末尾增加一个元素，可行
number			#显示增加后元组的元素

4.元组也可进行强制类型转换：

number=[8，9，0]		#定义一个列表
tuple(number)		#转列表为元组

5.注意：定义只有一个元素的元组时要在元素末尾+“，”

fruits=("apple",)

6.其他操作方法类比列表即可。