1.列表知识汇总

序列：基本的数据结构，序列中的每个元素都有编号（索引），第一个元素的索引是0，第二个元素的索引是1，依次类推
为什么从0计数：从0开始指出相对于序列开头的偏移量。同时可以绕到序列末尾，用负索引表示序列末尾元素的位置
eg1

# 列表中的元素可以不是同一种类型
edward = ["grid",1.0]
edward2 = ["bird",2]
print(edward)
print(edward2)
# 列表可以包含其他的列表
edward3 = [edward,edward2]
print(edward3)

['grid', 1.0]
['bird', 2]
[['grid', 1.0], ['bird', 2]]

列表操作

索引

#字符串就是由字符组成的序列
greet = "Hello"
print("第一个元素："+greet[0])
#使用内建函数计算列表的长度，最后一个元素的索引是长度减一
print("最后一个元素："+greet[len(greet)-1])
#最后一个元素的下标是-1，往前数是-2，-3...
print("倒数第二个元素："+greet[-2])
#字符串以及其他的序列字面量，可以直接对其使用索引
print("第二个元素："+"Hello"[1])
#如果函数返回一个序列，则函数也可以直接使用索引
four = input("please input a string : ")[3]
print("输入的字符串的第四个元素是：%s" %four)

第一个元素：H
最后一个元素：o
倒数第二个元素：l
第二个元素：e
please input a string : world
输入的字符串的第四个元素是：l

切片

使用切片来访问特定范围内的元素。可以使用两个索引，并用冒号 ： 进行分隔。包含第一个索引指定的元素，不包含最后一个索引指定的元素

numbers = [1,2,3,4,5,6,7,8,9,10]
print(numbers[0:3])
#第二个索引超过实际的索引值，仍能正常打印
print(numbers[0:20])
print(numbers[-3:9])
#第一个索引的元素位置必须比第二索引的元素位置要小，否则打印空序列
print(numbers[-3:1])
#省略第一个索引，切片始于序列开头
print(numbers[:-3])
#省略第2个索引，切片结束与序列结尾，且包含最后一个元素
print(numbers[-3:])
#省略第一个，第二个索引，表示整个序列
print(numbers[:])

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

切片之步长

#全部的奇数，步长是2
print(numbers[0:10:2])
#全部的偶数，步长是2
print(numbers[1:10:2])
#步长为负，表示从右边向左边提取元素，且第一个索引必须大于第二个索引
print(numbers[10:0:-2])
#第六个元素到序列开始，然后反向提取
print(numbers[5::-2])
#从序列结尾到第六个元素（不包含），反向提取
print(numbers[:5:-2])

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

序列相加

#用加运算符连接列表
list1 = ["h","e","l"]
list2 = ["l","o"]
list3 = list1 + list2
print(list3)
#不能拼接不同类型的序列
# TypeError: can only concatenate list (not "str") to list
str = "world"
list4 = list3 + str
print(list4)

序列乘法

#序列与数相乘表示重复这个序列来创建一个新的序列
pythons = "python " * 5
print(pythons)

world = ["bye","bye"]
byes = world * 2
print(byes)

空列表 [ ]
使用None 初始化列表

emptyList = []
noneList = [None] * 8
print("emptyList len = %s" %(len(emptyList))) #0
print("noneList len = %s" %(len(noneList)))  #8

成员包含

in 或 not in

father = "father"
print("fa" in father) #True
print("wa" in father) #False
print("wa" not in father)#True
fathers = ["foo","sd"]
print("foo" in fathers)#True
print("wan" in fathers)#False
print("han" not in fathers)#True

序列成员包含

database = [["li",123],["zhao",234],["qian",456]]
userName = input("please input your name : ")
password = input("please input your password : ")
#实际上database 中的123 是数值类型，所以要进行类型转化
password = int(password)
if [userName,password] in database :
    print("login success!")
else:
    print("login failure!")

please input your name : li
please input your password : 123
login success!

列表常用函数

函数list

#使用list 函数将字符串转为序列
str1 = "hello"
strToList = list(str1)
print(strToList)

#将序列转为字符串
list1 = ["w","o","r","l","d"]
listToStr = ','.join(list1)
listToStr2 = '！'.join(list1)
print("使用逗号隔开 ： "+listToStr)
print("使用叹号隔开 ： "+listToStr2)

['h', 'e', 'l', 'l', 'o']
使用逗号隔开 ： w,o,r,l,d
使用叹号隔开 ： w！o！r！l！d

给元素赋值

old = ["x","y","z"]
#使用空列表清空
old = []
old = "s"
#old = "s"后，old已经成为字符串类型，而字符串类型为不可变类型，所以old[0] = "w"报错
# old[0] = "w"
old = ["a","b","c"]
#修改第一个元素的值
old[0] = "d"
#['d', 'b', 'c']
print(old)

删除元素
删除单个元素和范围删除

old = ["a","b","d","f"]
#删除一个元素
del old[1]
#删除切片（范围）元素
print(old) #['a', 'd', 'f']
del old[-1:]
print(old) #['a', 'd']

切片赋值
eg1

hi = list("hi")
hi[1:] = "ello"
print("".join(hi)) #hello

eg2 插入新元素

old = ["a","b","d","f"]
#在第三个位置插入c
old[2:2] = "c"
print(old)#['a', 'b', 'c', 'd', 'f']

列表常用方法

1. append
   就地修改原列表

#将一个对象附加到列表末尾
#在列表末尾加一个字符串
list1 = ["hello"]
list1.append("world")
print(list1)
#在列表末尾加一个列表
list1.append(["ha","hei"])
print(list1)
#在列表末尾加个元组
list1.append(("bye","bye"))
print(list1)
#在列表末尾加个数值
list11 = list1.append(3.14)
print(list1)
#看下apped返回的结果是什么？None
print(list11)

['hello', 'world']
['hello', 'world', ['ha', 'hei']]
['hello', 'world', ['ha', 'hei'], ('bye', 'bye')]
['hello', 'world', ['ha', 'hei'], ('bye', 'bye'), 3.14]
None

2. clear
   就地清空原列表

list1 = ['hello', 'world']
listClear1 = list1.clear()
print(listClear1)
print(list1)

None
[]

3. copy
   复制列表，会产生一个新的列表

#list3与list2关联，修改list3也会修改list2
list2 = ['hello', 'world']
list3 = list2
list3.append("how")
print(list2)
#list4 是list2的副本，修改list4之后不会修改list2
list4 = list2.copy()
list4.append("here")
print(list2)
print(list4)

['hello', 'world', 'how']
['hello', 'world', 'how']
['hello', 'world', 'how', 'here']

4. count
   计算指定元素在列表中出现的次数

list5 = [1,2,3,1,1,1,2]
myC = list5.count(1)
#myC的类型是Int,与字符串连接时需要转化为字符串
print("1 在 list5 中出现的次数是：" + str(myC))

1 在 list5 中出现的次数是：4

5. extend
   就地修改原列表，将多个值附加在列表末尾

list5 = [1,2,3,1,1,1,2]
list6 = list5.extend(["he","hea"])
print(list6)#None
print(list5)#[1, 2, 3, 1, 1, 1, 2, 'he', 'hea']

6. index
   查找指定元素在序列中第一次的位置，如果没有找到会报错，所以最好先使用in 判断下要查内容是否在序列中是否存在，再求第一次出现时的索引

list7 = [1, 2, 3, 1, 1, 1, 2, 'he', 'hea']
if "he" in list7 :
    heIndex = list7.index("he")
    #通过下标获取列表中的元素
    heStr = list7[heIndex]
    print("在 list7 索引 %d 对应的元素是 ： %s" %(heIndex,heStr))
else:
    print("he 在 list7中找不到")

在 list7 索引 7 对应的元素是 ： he

可以在指定的范围中搜索index(object,start,end) 搜索范围包括start 不包括end

list7 = [1, 2, 3, 1, 1, 1, 2, 'he', 'hea']
#he 的下标是7，所以在3-8中可以找到
print("范围查询 %d"  %list7.index("he",3,8))
#由于结束位置是7，实际搜索的是从3-6，不会包含结束的索引位置，所以报错ValueError: 'he' is not in list
print("范围查询 %d" %list7.index("he",3,7))

7. insert
   指定在列表某个位置插入对象，就地修改

list7 = [1, 2, 3, 1, 1, 1, 2, 'he', 'hea']
result1 = list7.insert(3,["bao","zha"])
print(list7) #[1, 2, 3, ['bao', 'zha'], 1, 1, 1, 2, 'he', 'hea']
print(result1) #None

8. pop
   pop()从列表中删除最后一个元素，并将其返回
   pop(x) 从列表中删除索引x的元素，并将其返回

list7 = [1, 2, 3, 1, 1, 1, 2, 'he', 'hea']
#出栈列表第三个元素
popResult1 = list7.pop(2)
print(popResult1)
print(list7)
#出栈列表最后一个元素
popResult2 = list7.pop()
print(popResult2)
print(list7)
#还可以支持负数，最后一个元素是-1，倒数第二个是-2，依次类推
list8 = ['h','e','l','j','w']
print(list8.pop(-2))

3
[1, 2, 1, 1, 1, 2, 'he', 'hea']
hea
[1, 2, 1, 1, 1, 2, 'he']
j 

9. remove
   就地删除，无返回值。删除列表中的指定元素，如果列表中不存在该指定元素，报错，所以也先用in查看下包含关系再做删除

list8 = "hello"
list9 = list(list8)
removeRes = list9.remove('e')
print(list8) #hello
print(removeRes)#None
print(list9) #['h', 'l', 'l', 'o']

10. reverse
    就地反转，不返回值。

list10 = ["a","b","c","d"]
reverseRes = list10.reverse()
print(reverseRes) #None
print(list10)  #['d', 'c', 'b', 'a']

11. sort
    就地排序，且不返回任何值。

list11 = ['a','b','h','c']
sortRes = list11.sort()
print(list11) #['a', 'b', 'c', 'h']
print(sortRes) #None

12. sorted
    不修改原序列，而是返回一个排序后的序列

list12 = ['a','b','h','c']
#sorted()是python的内置函数，不是是list的函数所以直接使用，将列表作为sorted的参数
list13 = sorted(list12)
print(list12) #['a', 'b', 'h', 'c']
print(list13) #['a', 'b', 'c', 'h']