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

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

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

  是否可修改是否有序是否有重复备注 
tupleindex-value不可修改有序可有重复 
str 不可修改有序可有重复特别的list
listindex-value可修改有序可有重复 
dictkey:value可修改无序无重复 
setkey可修改无序无重复无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整体,多维listappend(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,这样可以用 []处理 里面的元素

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值