来自 威尼斯国际官方网站 2019-12-18 15:28 的文章
当前位置: 威尼斯国际官方网站 > 威尼斯国际官方网站 > 正文

数据结构

上一篇:流程序调整制-Python<二>

元组,创设格局生机勃勃组以逗号隔断的值

a = 3,4,5
print a
#所以明显print加上逗号隔开的值并不是元组,而只是打印分隔符
print 3,4,5```
#创建元组的元组

nested_tup = (1,2,3),(4,6)
print nested_tup

  1. 因为列表具有pop、append、insert方法,因而列表能够充当堆、栈使用。由于品质难点,不建议充作堆。(堆:队列优先,先进先出(FIFO—first in first out)栈:先进后出(FILO—First-In/Last-Out卡塔尔(قطر‎)
  2. 列表的pop、insert方法,使得列表能够作为队列使用,先入先出,不过在列表的始发做插入只怕弹出都相当慢,因为要运动别的因素。必要用到行列,建议利用collections.deque。
  3. 能够使用map来创造队列,map(func,*iterables)

    >>> list(map(lambda x:x**2,range(23)))
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484]
    
  4. 始建列表的"[威尼斯国际官方网站 , ]",能够分包复杂的表明式,和嵌套函数

    >>> test=[ x**2 for x in range(3) ]
    >>> test
    [0, 1, 4]
    
  5. 列表删除成分方法及删除列表方法:remove、pop、clear、del。remove与pop都只能删除一个元素、clear清空驶列车表。del能够切成片删除。

    >>> test=[0,1,2,3,4]
    >>> test.remove(3)
    >>> test
    [0, 1, 2, 4]
    
    >>> test=[0,1,2,3,4]
    >>> test.pop()
    4
    >>> test
    [0, 1, 2, 3]
    >>>
    >>> test.pop(1)
    1
    >>> test
    [0, 2, 3]
    >>>
    
    >>> test=[0,1,2,3,4]
    >>> test.clear()
    >>> test
    []
    
    >>> test=[0,1,2,3,4]
    >>> del test[0:2]
    >>> test
    [2, 3, 4]
    >>> del test[:]
    >>> test
    []
    >>> del test
    >>> test
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'test' is not defined
    >>>
    
  6. 队列主要以下两种档案的次序:

    • 3种为主种类类型(Basic Sequence Types卡塔尔(قطر‎:list、tuple、range (补:range(卡塔尔国函数再次来到的结果是多少个莫西干发型行列的对象,实际不是列表。tuple便是元组)
    • 专程管理公事的叠合种类类型(Text Sequence Types卡塔尔:str
    • 特意管理二进制数据的增大连串类型(Binary Sequence Types卡塔尔(英语:State of Qatar): bytes、bytearray、memoryview

    国有国法体系是还是不是可被矫正分类:

    • 可变体系: list
    • 不行变种类:tuple、str
  7. tuple元组是专门的学问的行列类型,不扶持个别项目分配

    >>> a=6,7,8,89,9
    >>> a
    (6, 7, 8, 89, 9)
    >>> a[0]=2
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object does not support item assignment
    >>>
    

    不过tuple能够分包可变对象

    >>> a=43,4,5,6,[4,4,4,4]
    >>> a
    (43, 4, 5, 6, [4, 4, 4, 4])
    >>> a[4][0]=99999
    >>> a
    (43, 4, 5, 6, [99999, 4, 4, 4])
    >>>
    
  8. tuple的创制,当为空成分和叁个要素的状态

    >>> a=()
    >>> a
    ()
    >>> a=0,
    >>> a
    (0,)
    >>>
    

    tuple的解压缩

    >>> a,b,c=3,4,5
    >>> a
    3
    >>> b
    4
    >>> c
    5
    >>>
    

    tuple的打包

    >>> a=3,4,5,5
    >>> a
    (3, 4, 5, 5)
    >>>
    
  9. 字典的键必需是不可变的目的,举例字符串、数字、元组且元祖无法平素或直接的饱含可变对象。字典的健不可感到列表,因为列表能够行使索引分配、del 切成片 、append、extend等艺术校正list对象。

  10. 想要在相反的情状下循环二个列表,可以利用reversed函数

    >>> for i in reversed(range(1,6,1)):
    ...     print(i)
    ...
    5
    4
    3
    2
    1
    >>>
    
  11. is 、 is not 推断成分是或不是等于

    >>> a=[]
    >>> b=[]
    >>> a is b
    False
    >>> a=9
    >>> b=9
    >>> a is b
    True
    >>> a is not b
    False
    >>>
    
  12. in、not in 决断是或不是在有些系列里

    >>> test="basecee"
    >>> 'a' in test
    True
    >>> 'f' in test
    False
    >>> 'f' not in test
    True
    >>> "ba" in test
    True
    
  13. 不无的可比运算符都有同生机勃勃的优先级,比全部的数值运算符都要低。 这里‘< ,>’优先级低于‘+’

    >>> 6+8>12
    True
    >>> 13<6+9
    True
    >>>
    
  14. 布尔运算符的初期级低于比较运输符

    >>> 12==10 or 10==10
    True
    >>> 10>5 and 9<0
    False
    >>>
    

调用tuple(卡塔尔(英语:State of Qatar)函数将持有种类可能迭代器调换成元组

print tuple([3,4,2])
print tuple('strings')```

 

索引元组

print nested_tup[1][1]
#元组是不可变的,但是如果在元组插槽中的元素是可变的,也可以修改其中的可变对象,比如这样
tup = tuple(['foo',[1,2],True])
print tup
#第2个元素是个列表可变,所以可以修改列表中的元素,比如这样
tup[1].append(3)
print tup```
#元组通过加号进行产生更长的元组

翻阅网站:

对于独有三个因素的元组,必得在该因素后边加上逗号,鲜明表示是元组,否则就只怕按其自己的数据类型进行管理了

print (3,None,'foo')+(6,0)+('bar',)

对元组乘以以个整数,约等于连接该元组的多少个别本

print (3,None,'foo')*3```

元组拆包

tup = (4,5,6)
a,b,c=tup
print a,b,c
#嵌套元组也能解包
tup = (4,5,(6,7))
a,b,(c,d)=tup
print a,b,c,d
#利用解包实现数据交换
a = 5;b = 4;print a,b
a,b = b,a;print a,b
#利用解包进行迭代,对由元组或者列表组成的序列进行迭代
seq = ((1,2,3),(4,5,6),(7,8,9))
for a,b,c in seq:
    print a,b,c
#元组方法,count(),计算参数的出现次数,只能统计第一层元素出现多少次,不能具体到底层
print seq.count(1)```

#列表,序列包括,列表,元组,还有字符串,只有列表是可变的

list(卡塔尔(قطر‎函数将种类类型转变来列表

a_list = [2,3,4,None]
print a_list,list(tup),list("strings")

append()方法

a_list.append("love")

insert(卡塔尔(英语:State of Qatar)方法把成分插入到钦命地点

a_list.insert(4,"i")

pop(卡塔尔国方法移除而且再次来到内定索引处的成分

a_list.pop(3)

remove(卡塔尔国方法找到第贰个切合需求的值并从列表删除

a_list.remove(4)

in操作符判别列表中是还是不是含有某些值

print 4 in a_list
print a_list```

列表的统黄金时代+和extend(卡塔尔(قطر‎方法

b_list = [7,8,(2,3)]
x = [4,None,'foo']
#a.extend()调用后返回值是一个None,所以必须调用a才能显示extend()方法执行后的效果
a_list.extend([4,None,'foo'])
print a_list + b_list,a_list
#+代表的列表合并是新建一个新列表然后赋值的操作,而extend()方法是原地进行操作的,效率会好一点
#排序,sort()方法
a = [1,4,3,5,(8,6)]
#利用reverse参数,指明反向排序
a.sort(reverse=True)
#sort()方法是原地排序操作,直接改变原始的序列
print a
b = ["love","i",'you']
b.sort(key=len)
print b```

#序列的切片操作

规定传入[]的start和stop

seq = [7,2,4,5,32,6,4,7]

从没传到start或然stop的就暗中认可从连串早先恐怕终止算起

print seq[1:3],seq[:5],seq[3:]
print seq[-4:],seq[-6:-2]

比如左侧成分现身比侧面成分晚的话,再次来到空体系

print seq[-4:-5]

累计步长,完成行反革命序

print seq[::-1],seq[3::-1]```

嵌入种类函数

#enumerate()函数返回序列的索引和对应索引的值
some = ["a","b","c"]
for i,value in enumerate(some):
    print "It's ",str(i),"and the value is ",value
#enumerate()还可以求取一个将序列值映射到其所在位置的字典(假定序列值是唯一的,这样字典的键才能是唯一的)
some_list = ["foo","bar","baz"]
#一个推导式
mapping = dict((v,i) for i,v in enumerate(some_list))
print mapping```

#sorted()函数

将别的种类再次来到二个新的不改变列表,可是原列表不爆发变化,然而列表的sort(卡塔尔方法会原地对列表进行排序

sort_some_list = sorted(some_list)
print sort_some_list,some_list,sorted("horse race")

应用sorted(卡塔尔(英语:State of Qatar)函数与set结合起来获得贰个由种类中独一成分组成的不改变列表

print sorted(set("this is just some string"))```

zip(卡塔尔函数将四个类别的要素实行配成对,发生三个新种类

seq1 = ['foo','bar','baz']
seq2 = ['one','two','three']
print zip(seq1,seq2)
#zip()可以接受任意数量的序列,最终得到的元组数量由最短的序列决定
#常见用法是同时迭代多个序列,结合enumerate()函数使用,典型的序列解包的应用
for i,(a,b) in enumerate(zip(seq1,seq2)):
    print ('%d: %s %s' %(i,a,b))
#对已经压缩的序列,zip()对该序列进行解压,其实是将一组行转换为一组列
pitcher = zip(seq1,seq2)
#*说明参数要传入一个元组,元组包含两个元素,因此就是把pitcher[1]作为参数传入zip了,然后zip的作用是结合产生新序列,与first和last相对应
first,last = zip(*pitcher)
print first,last```

#reversed()函数用于得到一个序列的逆序,返回一个迭代器

本文由威尼斯国际官方网站发布于威尼斯国际官方网站,转载请注明出处:数据结构

关键词: