【原创】《笨办法学python》(6)--关于list和tuple

一 列表，元组 和字典的概念

我整理了一个比较的表，可能不全，逐渐完善吧

		是否可修改	是否有序	是否有重复	备注
tuple	index-value	不可修改	有序	可有重复
str		不可修改	有序	可有重复	特别的list
list	index-value	可修改	有序	可有重复
dict	key:value	可修改	无序	无重复
set	key	可修改	无序	无重复	无value的dict

 

二 列表的各种方法

 

之前我把  tuple 和 list都认为是 index-obj 现在看了一些python其实变量都只是对 obj的引用

所以暂时我认为 都是用的value,并不是真正存储了obj（可能理解还是不对的，继续学习吧）

所以我认为 tuple 和 list 都是 index----value-obj模式

 

无参数/其他特殊参数的

.sort()                      #可以有特殊参数

.reverse()       

list.clear()

list.copy()

 

操作index的方法

list.pop(index)

 

操作 value/obj的方法

list.append(value/obj)

list.extend(list-obj)

list.index(value/obj)  返回index

list.remove(value/obj)

list.count(value/obj)

 

 

操作index 和 ,value/obj

.insert(index,value/obj)

list.pop()

 

对象的方法可用实现和操作一样的效果

dir(object)

可看这个对象下的各种方法

下表是我自己的总结,现在最没搞清楚就是 del list[0]  这种算什么？

list.
功能		方法名	参数	参数	返回值	等同	对应方法
增加	往末尾增加	append(obj)	obj			list[index+1]=obj	.pop()
增加	list作为1个obj整体，多维list	append(list)	obj
增加	在指定位置插入，其他后移	insert(index.obj)				list[1:1]=obj	.remove()
增加	扩展列表元素，加入的是多个元素	extend(list)	list
删除	删除最后1个	.pop()			返回删除的obj		append()
删除	删除指定index的	.pop(index)	index		返回删除的obj
删除	全部删除	.clear()				=[]
删除	删除	.remove(obj)	obj			好像只能用del???	.insert()
排序	排序--混合型可能报错无法排序	.sort()
排序	可选参数	.sort(fuc)	key=	reverse=
排序	逆序	.reverse()
查找	查找index,根据索引查找obj	.index(obj)	obj		index
查找	查找obj数量,只查这一层	.count(obj)			obj个数

    补充  .copy() 方法

（1） 新手注意：方法，都是    object. func(),是圆括号，不要受列表的影响是[]

（2）方法得先看下，object下是否有，有的才能  object. func() 这么用

 

# -*- coding:utf-8 -*-
#先看下list 再看下元组
#list有很多方法，需要记下


list1=[1,2,3,4,5]
list2=["a","b","c","d","e"]
list3=["apple","pear","banana","cherry","orange"]
list4=["一","二","三","四","五"]


#---------------pat1:打印list--------------------------
print list1
print list2
print list3
print list4

#打印某个元素
print list1[0]   #1
print list3[1]   #"pear"
print list2[-2]  #"d"




#------------part2 循环打印，直接循环value，循环key查value的----------
#循环打印 和 系统保留关键词？
#for xx in list    
#这个句式不带参数，就会默认是循环所有list里的value，前面的定义的for的XX默认为就是value

#这么写可以?？
print "\n"
for suibian_name in list3:
	print suibian_name  #这里好像写的有问题？

#这样也可以，但好像都是对 value做的操作
print "\n"
for luan_name1 in list3:
	print "the value is %s"   %luan_name1
	
#这样也可以，循环数字,然后作为key，去逐个取list里的值。
#反正python里也不需要事先声明变量类型，除非要用变量的值。
print "\n"
for i in range(0,5):
	print "the %d value is %s"   %(i,list3[i])	
	
# list的名字怎么查？？ 好像list3.name不行。


#循环其中一部分也可以
print "\n"
for i in range(0,3):
	print " the %d value is %s"   %(i,list3[i])	

	
#-------------part3:append,insert--------------------------

list10=[]		#虽然变量类型不用事先声明，但是list等还是得先声明，否则系统咋知道你这个是变量？列表？
print("\n")
for y in range(0,10):
	list10.append(y)
	print "print cycle_inside",list10
print "\n","print cycle_outside",list10
	

#-------------part4:insert--------------------------
#append总是加到-1的位置
#insert指定key和value这一对值。
print("\n")
list10.insert(0,999)
print list10
	
#-------------part5:count--------------------------

print("\n")
list10.insert(1,88)
list10.insert(1,88)
list10.insert(1,88)
print list10
print list10.count   #方法应该是至少有圆括号，这样不报错，但会显示一个语句?
print list10.count(88) #这里指定的要查找的value是哪个，可以查到个数。
	
#-------------part6:index--------------------------
#index() 是index(value) 去返回key啊，千万别理解反！！
print("\n")
print list10
print list10.index(4)
print list10[4]

#-------------part7:remove--------------------------
#remove的还是value,操作key只能  list[key]这样！！！？
print("\n")
print list10
list10.remove(88)
print list10.remove(88) #这么写不报错，但没意义是none，因为remove操作不返回任何，只做操作。


#-------------part8:sort()和reverse()--------------------------

print("\n","paixu")
print list10
list10.sort()
print list10
list10.reverse()
print list10


	

#--------------part10:二维列表------------

print "\n"
xx1=[[1,2,3],[4,5,6]]
print xx1

#定义不规则的，其他地方，是用空或0代替的?试试
xx2=[[1,2,3],[4,5,6,7]]
print xx2
print xx2[0][2]
#print xx2[0][3] #会out of range 也就是没有所谓补齐数据。没的地方就是没有。

	
	
"""
for luan_name1 in list3:
	print "the %d 's value is %s"   %(key,luan_name1)

	
关于unpack
luan_name = list3

.append
.insert
.count
.pop
.queue
"""
	
	

 三 如何查看对象包含的方法（其实是查看object下的各种方法）

对象.dir

help(对象.方法)

 

四 list的一些“操作+用法”

基于list本身的一些用法

（1） 字符串虽然也可以当做list处理，但是上 str是不能被改变的

         转换  str()  list()

         如果先str(),再list(),再str() 会发现不可被还原了，连list本身的[]和引号都被当成字符串内容了

（2） 如果要改变字符串，用新的变量（或自身）重新赋值为list，然后可以进行各种list操作：增，改，删

（3） 可以用list的索引，来直接进行增，删，改，而不需要用方法

        list1[0]="重新赋值"

        list1[0:2]=list("重新赋值")

        list1[1:1]="在1处插入新值"

（4） 和字典的不同（list 的index 是有序的，不能越界赋值，会报错）

          list2[55] ="aaa"   #如果index 小于55 会报错

         赋值的方法，只能是index范围内的，不能越界。（dict 是无序的，所以不存在越界，没有的key想当于新增items）

 

（5）如果是用 切片的方法删除内容，现在感觉不是很好---可能有办法

name1=[]    #没问题，整体被置空为list[]

但是某个元素或某段切片不能置空，否则会被认为是嵌套了，变成了二维数组

name1[0]=[]   #会被认为第0元素，被重新赋值为了一个数组[]

name1[0]=""   #也不能删除，是一个""元素

list() 

定义错误，list[] 是用来转其他类型的，现在里面是1,2,3.。。没法转

#查了下帮助，list()只能用tuple str等来转化，不能转list等

>>> n=list[1,2,3,4,5,6,7,8,9]

Traceback (most recent call last):

  File "<pyshell#17>", line 1, in <module>

    n=list[1,2,3,4,5,6,7,8,9]

TypeError: 'type' object is not subscriptable

 

五 list的一些具体“方法”

 

（1） list.append(对象/列表)   和 list.extend(列表--iterable)

append(obj) 添加元素或列表

              不能添加空，必须带参数

             也可以添加列表，但是把列表作为整体添加为一个维度的元素

extend() 添加其他列表的内容，不是作为一个整体，追加在最后

              不能添加单个元素，不能添加空，必须带list--iterable这种

（2）list.count(对象)

查找的是对象的个数

并且，只能识别某一层的，并不能统计嵌套多层的list里的所有这种 对象

（3）list.pop(索引)  list.remove()

list.pop(索引：要删第几个元素？)

     1  有返回值，返回的是删除的 数字索引 所指的对象

         因为是按索引找，所以理论上不会重复

      2可以为空，默认删除最后一个

      3 按

list.remove(要删除的第1个对象)

   1 只查找对象

    2只删除第1个对象

 

list.index(对象)

返回索引值index

 

排序

list.reverse()

list.sort(reverse=True)

    如果是混合多维数组，可能报错，但是可以用 reverse

  

list.clear()

列表变成[]

 

max()

min()

len()

 

 

 

六 list的一些 外部操作？

del listA  #del这种算啥，暂且叫外部操作吧

name1.del("a")       #上图可见报错

 del name1[0]

删除对象。。。

     del listA

     del tupleA

    del dictA

 

两个一样的列表，is, in都不行

 is  in 的判断 都只能  元素对列表 吗？  不能列表对列表？

 

七  赋值和浅复制

 

赋值：两者关联改动，listB=listA

浅复制：第一层，两者独立，方法1：使用copy()方法：listB=listA.copy()                   

                                方法2：使用切片操作 listB=listA[:] 或 listB=[0:len(listA)+1]

深复制：完全独立，指向不同的对象  

>>> import copy
>>> listA=[[1,2,3],4,5,6]
>>> listB=listA
>>> listC=listA.copy()
>>> listD=copy.deepcopy(listA)
>>> listA[-1]=999
>>> listA[0][0]=888
>>> listA
[[888, 2, 3], 4, 5, 999]
>>> listB
[[888, 2, 3], 4, 5, 999]
>>> listC
[[888, 2, 3], 4, 5, 6]
>>> listD
[[1, 2, 3], 4, 5, 6]
>>> 

 

八 数组等，不要纯看最外层的类型，内部元素是有较大影响的

包括tuple,list.dict,set等

 

不纯是和外层有关系

和里层的元素（嵌套的类型）还是有关的

 

比如tuple可以用tuple[][]

list.sort() 可能报错,因为无法比较混合类型的，int 和 string

 

tuple的定义

1 只有单个元素，必须这样定义  tuple(1,)  tuple(1)将不被认为是元组！

2 tuple可以嵌套list，这样可以用 []处理 里面的元素