序列：基本的数据结构，序列中的每个元素都有编号（索引），第一个元素的索引是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']
列表常用方法
- 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
- clear
就地清空原列表
list1 = ['hello', 'world']
listClear1 = list1.clear()
print(listClear1)
print(list1)
None
[]
- 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']
- count
计算指定元素在列表中出现的次数
list5 = [1,2,3,1,1,1,2]
myC = list5.count(1)
#myC的类型是Int,与字符串连接时需要转化为字符串
print("1 在 list5 中出现的次数是：" + str(myC))
1 在 list5 中出现的次数是：4
- 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']
- 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))
- 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
- 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
- remove
就地删除，无返回值。删除列表中的指定元素，如果列表中不存在该指定元素，报错，所以也先用in查看下包含关系再做删除
list8 = "hello"
list9 = list(list8)
removeRes = list9.remove('e')
print(list8) #hello
print(removeRes)#None
print(list9) #['h', 'l', 'l', 'o']
- reverse
就地反转，不返回值。
list10 = ["a","b","c","d"]
reverseRes = list10.reverse()
print(reverseRes) #None
print(list10) #['d', 'c', 'b', 'a']
- sort
就地排序，且不返回任何值。
list11 = ['a','b','h','c']
sortRes = list11.sort()
print(list11) #['a', 'b', 'c', 'h']
print(sortRes) #None
- 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']