Python数据结构之——列表

列表

创建类表

  1. list('Hello') : 创建列表: ['H','e','l','l','o']

索引

通过索引可以在列表中查找某个单一元素

var = 'Hello,World' # 字符串就是一个由字符组成的列表

print var[0]
print var[-1]

# result: H
# result: d

分片

通过分片可以在列表中查找一定范围的元素

var = 'Hello,World'

print var[2:5]  # 从索引为2的元素开始,到索引为4的元素,不包含第五个元素
print var[-3:-1] # 同上
print var[2:] # 从索引为2的元素开始,到最后,包含最后一个元素
print var[:-1] #从索引为0的元素开始,到最后,不包含最后一个元素

# result: llo
# result: rl
# result: ello,World
# result: Hello,Worl

print var[-1:-3] # 如何左面的索引元素比右面的索引元素晚出现,那么结果一直[]

分片的步长

分片默认的步长为 1,如果要更改步长可以使用如下格式[X:Y:step length]

步长的取值可以是正整数,也可以是负整数,但是不以为0。如果步长是负整数,既从右向左取元素。

number = [1,2,3,4,5,6,7,8,9,10]

print number[::1] # 设置步长为1
print number[::2] # 设置步长为2
print number[::-2] # 设置步长为-2

# result: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# result: [1, 3, 5, 7, 9]
# result: [10, 8, 6, 4, 2]

列表的操作

连接

只有相同类型的列表之间才可以进行相加连接

print [1,2,3] + [4,5,6]

# result: [1,2,3,4,5,6]

print [1,2,3] + 'Demo'  # 这是错误的,因为两个列表不是同一个类型

乘法

正整数X与列表相乘会生成新的列表,在新的列表中,原来的列表被重复了X次。

print 'Python' * 5

# result: PythonPythonPythonPythonPython

print [12] * 5
# result: [12,12,12,12,12]

成员资格检测

Python中成员资格的检测非常的方便 只要使用 in 就可以了,其返回值为Boolean类型

name = 'CoderInfo'
print 'Info' in user # result: True

users = [['coder',25],['info',26]]
print ['coder',24] in users  # result: True
print ['coder',23] in users  # result: False

# 如果用MongoDB的话就会发现Bson格式的表内查询 在Python中是如此的方便啊。

列表的几个应用函数

  1. len(lst) # 返回列表中元素的个数
  2. max(lst) # 返回列表中值最大的元素
  3. min(lst) # 返回列表中值最小的元素
  4. lst.append(x) # 在list的末尾添加新的对象
  5. lst.count(x) # 计算x在list中出现的次数
  6. lst.extend(another_list) # 将another_list添加到list中去, 等效于lst[len(list):] = another_list
  7. lst.index(element) # 用于找出element 在list中的索引值
  8. lst.insert(index,value) # 用于将value 插入到list中索引为index的位置 效果等同于 lst[index:index] = [value]
  9. lst.pop(index) # 用于移除list中索引为index的元素,默认自动移除最后一个元素,返回值为被移除的元素
  10. lst.remove(element) # 用于移除列表中的第一次出现的element 元素,没有返回值
  11. lst.reverse() # 用于将lst这个列表倒序过来  等同于 list(reversed(list))
  12. lst.sort() # 将lst 按一定的顺序排序
lst = [1,3,7,5]

# len demo:
print len(lst) # result: 4

# max demo:
print max(lst) # result: 7

# min demo:
print min(lst) # result: 1

# append demo:
lst.append('append') 
print lst # result: [1,3,7,5,'append']

# count demo:
count_demo_list = [1,1,[1,1],3,3]
print count_demo_list.count(1) # result: 2

# extend demo:
lst.extend(count_demo_list) # extend 看着貌似与[X,X,X,X] + [Y,Y,Y] 一样但其实是不同的,+ 会生成新的字符串并没有改变list,而extend直接改变了list
print lst # result: [1, 3, 7, 5, 'append', 1, 1, [1, 1], 3, 3]

# index demo:
names = ['wang','zhang','CoderInfo','li']
print names.index('CoderInfo') # result: 2

# insert demo:
names.insert(2,'123')
print names # result: ['wang','zhang',123,'CoderInfo','li']

# pop demo:
num = [1,2,3,4]
print num.pop() # result: 4
print num.pop(0) # result: 1

# remove demo:
names = ['coder','info','coder','test']
names.remove('coder')
print names # result: ['info','coder','test']

# reverse demo:
name = ['coder','test','info']
name.reverse()
print name # result: ['info','test','coder']

# sort demo:
num = [2,1,3,6,5,4]
num.sort()
print num # result: [1,2,3,4,5,6] 

# sorted demo:
lst.sort() 与 sorted(lst) 的不同,sorted(lst) 并没有更改lst的排序,而是生成了一个排好顺序的副本,并返回
num = [2,1,3,6,5,4]
nums = sorted(num)
print nums result: [1,2,3,4,5,6]
print num  result: [2,1,3,6,5,4]

更改列表内容

通过索引更改列表

numbers = [6,6,6,6,6]
numbers[0] = 1

# numbers[10] = 1 这个操作是错误的,list不可以为索引不存在的元素赋值

print numbers # result: [0,6,6,6,6]

通过索引删除列表中的某个元素

users = ['Coder','Info','Moon']

del users[1]  # 这个同样也不可以删除索引不存在的元素

print users  # result: ['Coder','Moon']

通过分片更改列表

分片操作的主要作用是一次可以为多个元素赋值

name = list('CoderInfo')
name[5:] = 'demo'

print name # result: ['C', 'o', 'd', 'e', 'r', 'd', 'e', 'm', 'o']

# 当然Python中也可以使用与原来不等长的list进行赋值

name[5:] = PythonInfo

print name # result: ['C','o','d','e','r','P','y','t','h','o','n','I','n','f','o']

# 利用分片也可以对同时删除多个list中的元素
name[5:] = [] 或者 del name[5:]

print name # result: ['C','o','d','e','r']

# 通过分片将一个list插入到另外一个list中
name[2:2] = [1,2,3]
print name # result: ['C','o',1,2,3,'d','e','r']













你可能感兴趣的:(Python数据结构之——列表)