一、列表
1、列表
list ,是一个类，
li = [1,2,"nicholas"]
li是通过list类创建的对象。
2、list特点：
用中括号括起来，用逗号分割每个元素，列表中的元素可以是数字，可以是字符串，也可以是一个列表，甚至作为元素的列表也可以存在列表,布尔值也可以作为元素。
列表是有序的，元素可以被修改。
列表是一个可迭代对象。
列表相当于一个集合，内部可以放置任何东西。
如：
li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
3、可以通过索引、切片取值
例子
li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True] print(li[2]) print(li[1:3])
输出结果
9 [12, 9]
4、可以用for循环、while循环
for循环：
li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
for i in li :
print(i)
输出结果
1 12 9 age ['尼古拉斯', ['19', 10], '庞麦郎'] alex True
while循环
li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
count = len(li)
i = 0
while i < count:
v = li[i]
print(v)
i = i + 1
输出结果
1 12 9 age ['尼古拉斯', ['19', 10], '庞麦郎'] alex True
5、列表的元素可以被修改
a、通过索引删除修改
例子
li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True] li[1] = 8 #通过索引直接赋值给某个元素 print(li)
输出结果
[1, 8, 9, 'age', ['尼古拉斯', ['19', 10], '庞麦郎'], 'alex', True]
del 删除
例子
li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True] del li[1] #通过del加索引直接删除某个元素 print(li)
输出结果
[1, 9, 'age', ['尼古拉斯', ['19', 10], '庞麦郎'], 'alex', True]
b、通过切片删除修改
例子
li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True] li[1:3] = [8,18] #通过切片的方式直接赋值修改元素，注意要加中括号，组成一个列表 print(li)
输出结果
[1, 8, 18, 'age', ['尼古拉斯', ['19', 10], '庞麦郎'], 'alex', True]
例子
li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True] del li[1:3] #通过切片的方式直接删除元素 print(li)
输出结果
[1, 'age', ['尼古拉斯', ['19', 10], '庞麦郎'], 'alex', True]
6、列表也支持in操作
列表中的元素以逗号进行分割，各个作为一个整体。
li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True] v = "age" in li print(v)
输出结果
True
分析：这里的判断是不是在列表里是用完整的元素，即"age",
而"ag" in li则会输出False,同理，这个例子中"尼古拉斯"in li也会输出False.
7、列表多层索引的操作
可以使用下标索引来访问列表中的值
举个例子
我想获取"19"
li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True] v =li[4][1][0] print(v)
输出结果
19
分析：这里是一层一层的索引的
"19"所在的元素在第一层索引位置是4
v=li[4] ，这里的li[4]就是["尼古拉斯", ["19", 10], "庞麦郎"]这个整体，
同样的li[4][1]实际是["19", 10]，继续根据位置进行索引获取"19"即可。
8、字符串转换为列表，列表转为字符串
a、字符串转换为列表
str1 = "nicholas" v =list(str1) print(v)
输出结果
['n', 'i', 'c', 'h', 'o', 'l', 'a', 's']
字符串转列表可以直接用list，这里list会把字符串的每个字符循环一遍，输出以每个字符为元素的列表。
或者直接
v = list("nicholas")
b、列表转为字符串
如果用str直接将列表转为字符串
li = ["nicholas","niu","bi"] v =str(li) print(v)
输出结果
['nicholas', 'niu', 'bi']
分析：这里确实可以将li转为字符串，但是这里只是将li这个列表整体作为一个字符串即"['nicholas', 'niu', 'bi']",要想实现列表里元素的合并，并拼接成字符串需要for循环或者用join（）。
for循环转字符串
例子
如果列表里元素都是字符串
li = ["nicholas","niu","bi"]
s = ""
for i in li:
s = s + i
print(s)
输出结果
nicholasniubi
在列表里元素都是字符串的情况下可以用
join()可以比较简单实现
li = ["nicholas","niu","bi"] s = "".join(li) print(s)
输出结果
nicholasniubi
但是如果列表里元素包含数字或者其他的类型，只能用for循环实现对列表元素拼接转为字符串
li = ["nicholas","niu","bi",8,18,True]
s = ""
for i in li:
s = s + str(i)
#注意这里要把i转换为字符串类型，否则会报错
print(s)
输出结果
nicholasniubi818True
二、列表方法
1、append()
在列表末尾追加新的对象
li = ["nicholas","niu","bi",8,18,True] li.append(99) print(li)
输出结果
['nicholas', 'niu', 'bi', 8, 18, True, 99]
再举个例子
li = ["nicholas","niu","bi",8,18,True]
li.append(168)
li.append("99")
li.append("nick")
print(li)
输出结果
['nicholas', 'niu', 'bi', 8, 18, True, 168, '99', 'nick']
分析：注意这里是直接在列表里进行修改的，并不需要重新对li.append()进行变量的重命名。
2、clear()
清空列表
li = ["nicholas","niu","bi",8,18,True] li.clear() print(li)
输出结果
[]
结合append举个例子
li = ["nicholas","niu","bi",8,18,True] li.clear() li.append(99) print(li)
输出结果
[99]
分析：在这里我们可以看到，clear、append都是直接对列表进行操作的。
3、copy()
举个例子
li = ["nicholas","niu","bi",8,18,True] v = li.copy() #这里由于是复制，所以需要一个新的变量以满足赋值需要 print(v)
输出结果
['nicholas', 'niu', 'bi', 8, 18, True]
这里的复制是浅拷贝。
4、count()
统计某个元素在列表中出现的次数
li = ["nicholas","niu","bi",8,18,True] v = li.count(8) #count这里必须包含一个参数，不能为空，为空则报错。 print(v)
输出结果
1
5、extend()
在列表末尾一次性追加另一个序列中的多个值
举个例子
li1 = ["nicholas","niu","bi",8,18,True] li2 = ["nicholas","niu","bi",8,18,True] li1.append([16,"nick"]) li2.extend([16,"nick"]) print(li1) print(li2)
输出结果
['nicholas', 'niu', 'bi', 8, 18, True, [16, 'nick']] ['nicholas', 'niu', 'bi', 8, 18, True, 16, 'nick']
分析：这里append的追加是把后面的参数作为一个整体，追加到原列表成为最后一个元素。extend这里的追加是把参数做了一个循环依次添加到原列表中，相当于内部执行for循环。
6、index（）
从列表中找出某个值第一个匹配项的索引位置,根据index的参数获取其当前列表的索引位置，从左边开始。
li = ["nicholas","niu","bi",8,18,True,8]
v = li.index("niu")
print(v)
输出结果
1
再举个例子
li = ["nicholas","niu","bi",8,18,True,8] v = li.index(8) print(v)
输出结果
3
这里列表中有2个8，但是index只会输出从左向右遇到的第一个的位置。
例子
li = ["nicholas","niu","bi",8,18,True,8,9] v = li.index(8,4,8) #这里的index(8,4,8),其中第一个8是表示要寻找的对象，“4,8”表示从列表的索引第4个位置开始寻找到第8个位置结束 print(v)
输出结果
6
分析：这里我们可以看到index寻找列表内容也可以规定寻找位置。
7、insert()
将对象插入列表
li = ["nicholas","niu","bi",8,18,True,8,9] li.insert(7,4) print(li)
输出结果
['nicholas', 'niu', 'bi', 8, 18, True, 8, 4, 9]
分析：insert的第一个参数规定了要插入的指定位置，第二个参数是插入的内容。
8、pop()
删除某个值，并可以获取当前删除的值
没有指定索引，默认删除最后一个元素
，这里只能是索引，或者没有参数，不能指定具体元素
li = ["nicholas","niu","bi",8,18,True,8,9] v = li.pop(7) # li.pop(7),如果不需要获取被删除的值可以直接这样写 print(li) print(v)
输出结果
['nicholas', 'niu', 'bi', 8, 18, True, 8] 9
9、remove()
移除列表中某个值的第一个匹配项，这里可以指定元素
li = ["nicholas","niu","bi",8,18,True,8,9] li.remove(8) print(li)
输出结果
['nicholas', 'niu', 'bi', 18, True, 8, 9]
例子2
li = ["nicholas","niu","bi",8,18,True,8,9]
li.remove("niu")
print(li)
输出结果
['nicholas', 'bi', 8, 18, True, 8, 9]
分析：这里remove（）参数是要删除的对象，会删除从左到右遇到的第一个匹配的对象。
10、reverse()
将当前列表进行反转
li = ["nicholas","niu","bi",8,18,True,8,9] li.reverse() print(li)
输出结果
[9, 8, True, 18, 8, 'bi', 'niu', 'nicholas']
11、sort（）
对原列表进行排序
li1 = ["nicho","las","ciu","bi"] li2 = [1,3,490,23,50] li1.sort() li2.sort() print(li1) print(li2)
输出结果
['bi', 'ciu', 'las', 'nicho'] [1, 3, 23, 50, 490]
分析：这里的排序要求列表是全部是字符串或者数字，根据英文首字母顺序或者数字的从小到大进行排序。如果列表既包含字符串又包含数字则会进行报错。
这里是根据ascii码表确定的顺序进行排序的。
例子
li = [1,3,490,23,50] li.sort(reverse = True) print(li)
输出结果
[490, 50, 23, 3, 1]
分析：这里的sort()加上参数reverse =True 会进行反向的排序。
三、元组
1、元组
tuple,
tu = (111,22,33,44)
2、元组的特点
元组的元素不可被修改，不能被增加或者删除
元组的元素可以是字符串、数字、布尔值、列表。
推荐一般写元组在小括号的最后加一个逗号。
tu = (111,"nicholas",[1,2,"18"],true,)
元组也是一个可迭代对象。
3、元组的索引、切片
tu = (2,3,"nicholas",["你好","hello",12,],True，) v1 = tu[3] v2 = tu[2:4] print(v1) print(v2)
输出结果
['你好', 'hello', 12]
('nicholas', ['你好', 'hello', 12])
4、 元组可以被for循环
tu = (2,3,"nicholas",["你好","hello",12,],True)
for i in tu :
print(i)
输出结果
2 3 nicholas ['你好', 'hello', 12] True
5、字符串、列表、元组的相互转换
字符串转元组
s1 = "nicholas" s2 = "168" v1 = tuple(s1) v2 = tuple(s2) print(v1) print(v2)
输出结果
('n', 'i', 'c', 'h', 'o', 'l', 'a', 's')
('1', '6', '8')
分析：这里tuple相当于内部执行了一个for循环。
列表转元组
li1= [1,2,"nicholas",True] v = tuple(li1) print(v)
输出结果
(1, 2, 'nicholas', True)
分析：这里tuple相当于内部执行了一个for循环。
元组转字符串
对于列表里只有字符串也可以用join来合成一个整体元素。当然这里也可以用for循环。
如：
tu1= ["nicholas","niu","bi"] v = "".join(tu1) print(v)
输出结果
nicholasniubi
6、元组也是有序的，可以通过多层索引取值
例子
tu = ("nicholas",1,3,"niu",[2,"nick",[22,"hello"]],"bi")
v = tu[4][2][0]
print(v)
输出结果
22
这里的多层索引取值与列表类似。
7、元组的第一个元素整体不能被修改，但是第二层的如列表是可以被修改的，如删除、增加。
例子
tu = ("nicholas",1,3,"niu",[2,"nick",[22,"hello"]],"bi")
tu[4][2] = 8
print(tu)
输出结果
('nicholas', 1, 3, 'niu', [2, 'nick', 8], 'bi')
四、元组的方法
1、count()
获取指定元素在元组中出现的次数
tu = ("nicholas",1,3,"niu",[2,"nick"],"bi",8,1)
v = tu.count(1)
print(v)
输出结果
2
2、index（）
获取某一个值的索引位置
例子
tu = ("nicholas",1,3,"niu",[2,"nick"],"bi",8,"niu")
v = tu.index("niu")
print(v)
输出结果
3
分析：这里与列表类似，index只会输出从左向右遇到的第一个的位置。
五、字典
1、dict ｛key:value｝
key：value 是一个键值对
2、字典的value可以是任何值（字符串、数字、列表、元组、布尔值），同时可以进行嵌套。
3、字典的key不能是列表、字典 注意true、false可能和1和0重复。
布尔值truefalse在内存中就存储为1 .
如果两个key是相同的，只能显示一个
4、字典是无序的，多层索引取值
例子1
dic = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
print(dic)
输出结果
{'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
例子2
如何找到上面例子中的第三个键值对中的value中的'kk3': (11,22)中的11呢?
dic = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
v = dic["k3"][5]["kk3"][0]
print(v)
输出结果
11
分析：由于字典的键值对是成对出现的，而且是无序的，这里只能先指定key,这里的
dic["k3"]=[11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]
同样的
dic["k3"][5]=
{'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}
dic["k3"][5]["kk3"] =(11, 22)
最终用
dic["k3"][5]["kk3"][0]获取了值11.
字典由于是无序的，无法进行切片
（注：从python3.6开始，字典是有序的，即你每次打印字典内容都是一样的。但是这只是现在版本的一个功能，目前并未作为一个语法，所以现在仍然可以认为python3中字典是无序的。时间20180316。来源：超链接）
5、字典的删除
字典的删除用del，具体方式与字典的多层索引类似
如需要删除'kk1': 'vv1',
则可以这样写
dic = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
del dic["k3"][5]["kk1"]
print(dic)
输出结果
{'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
如需删除"k1": 18
则可以这样写
dic = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
del dic["k1"]
print(dic)
输出结果
{'k2': True, 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}
6、字典的for循环
在字典的for循环中，默认只会输出字典的keys
如：
dic = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
for item in dic:
print(item)
输出结果
k1 k2 k3 k4
如果想要输出values可以这样写
dic = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
for item in dic.values():
print(item)
输出结果
18
True
[11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]
(11, 22, 33, 44)
想要输出keys也可以这样写
dic = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
for item in dic.keys():
print(item)
输出结果
k1 k2 k3 k4
如果想同时输出keys、values
则可以这样写
dic = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
for k,v in dic.items():
print(k,v)
输出结果
k1 18
k2 True
k3 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]
k4 (11, 22, 33, 44)
分析：这里用的是字典的items()方法
7、字典的in判断
例子
dic = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
v1= "k4"in dic
v2= "18"in dic
print(v1,v2)
输出结果
True False
分析：
分析：这里默认判断的是key,如果想判断value可以这样写
v1= "k4"in dic.values()
六、字典的方法
1、clear（）
和列表中的用法类似。
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
dic.clear()
print(dic)
输出结果
{}
2、copy（）
和列表中的用法类似。
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
v = dic.copy()
print(v)
输出结果
{'k1': 18, 'k2': True, 'k3': [0, 'ni'], 'k4': (11, 22, 33, 44)}
3、fromkeys()
用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
语法：
dict.fromkeys(seq[, value]))
例子
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
v = dic.fromkeys([1,2,3])
print(v)
输出结果
{1: None, 2: None, 3: None}
分析：这里以fromkeys()第一个参数作为生成字典额keys,如果没有第二个参数则默认values为None
例子
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
v = dic.fromkeys([1,2,3],"nicholas")
print(v)
输出结果
{1: 'nicholas', 2: 'nicholas', 3: 'nicholas'}
分析：这里以fromkeys（）的第一个参数作为keys,第二个参数统一作为各个keys的值。
4、get()
根据key获取值，key不存在时，可以指定默认值
例子
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
v = dic.get("k1","no")
print(v)
输出结果
18
分析：get()第一个参数是要取回的key,第二个参数是如果key不存在返回的内容。这时这里的"no"被忽略了。
例子
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
v = dic.get("k11","no")
print(v)
输出结果
no
分析：这里可以看到，当取回的值不存在时，get()返回了规定的内容。
5、items()
以列表返回可遍历的(键, 值) 元组数组。
例子
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
v= dic.items()
print(v)
输出结果
dict_items([('k1', 18), ('k2', True), ('k3', [0, 'ni']), ('k4', (11, 22, 33, 44))])
6、keys()
以列表返回一个字典所有的键。
例子
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
v= dic.keys()
print(v)
输出结果
dict_keys(['k1', 'k2', 'k3', 'k4'])
7、pop()
删除并获取被删除的值
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
dic.pop("k2")
print(dic)
输出结果
{'k1': 18, 'k3': [0, 'ni'], 'k4': (11, 22, 33, 44)}
例子
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
v = dic.pop("k2")
#这里获取删除的key的值
print(dic,v)
#这里获取删除的key的值
print(dic,v)
输出结果
{'k1': 18, 'k3': [0, 'ni'], 'k4': (11, 22, 33, 44)} True
8、popitem()
随机返回并删除字典中的一对键和值(一般删除末尾对)。
如果字典已经为空，却调用了此方法，就报出KeyError异常。
例子
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
"k4": (11,22,33,44)
}
v = dic.popitem()
print(dic,v)
输出结果
{'k1': 18, 'k2': True, 'k3': [0, 'ni']} ('k4', (11, 22, 33, 44))
这里也返回了被删除的键值位值
还可以这样写
dic = {
"k1": 18,
"k2": True,
"k3": [0,"ni"],
}
k,v = dic.popitem()
#这里把被删除的字典的key赋值给k,被删除的value赋值给v
print(dic,k,v)
输出结果
{'k1': 18, 'k2': True} k3 [0, 'ni']
9、setdefault()
setdefault()设置键和值，
如果key已存在，不设置，获取当前key对应的值
如果key不存在，设置，如果键不存在于字典中，将会添加键并将值设为默认值，返回新加入字典的键的值。
例子
dic = {
"k1": 18,
"k2": True,
}
v = dic.setdefault("k1",123)
print(dic,v)
输出结果
{'k1': 18, 'k2': True} 18
分析：这里的键"k1"已经存在，获取原"k1"的值18
例子
dic = {
"k1": 18,
"k2": True,
}
v = dic.setdefault("k12",123)
print(dic,v)
输出结果
{'k1': 18, 'k2': True, 'k12': 123} 123
分析：setdefault（）里的键位在原字典不存在，所以键值位值被添加进去，同时返回了值。
10、update()
更新字典，已经存在的直接覆盖掉，没有的直接加上去
例子
dic = {
"k1": 18,
"k2": True,
}
dic.update({"k1":12,"k12":123})
print(dic)
输出结果
{'k1': 12, 'k2': True, 'k12': 123}
分析：这里可以看到,"k1"的值被直接修改了，原字典没有的"k12"直接被添加进去了。
update()还可以这样写
dic = {
"k1": 18,
"k2": True,
}
print(dic)
dic.update(k1 = "1",k2 = "2",k5 = "5")
print(dic)
输出结果
{'k1': 18, 'k2': True}
{'k1': '1', 'k2': '2', 'k5': '5'}
分析：可以看到新的字典是update参数里等号左右两边生成的键值位值
11、values()
以列表返回字典中的所有值。
例子
dic = {
"k1": 18,
"k2": True,
}
v = dic.values()
print(dic)
print(v)
输出结果
{'k1': 18, 'k2': True}
dict_values([18, True])
七、重点知识
1、数字中的int()
2、字符串的方法
a、replace()
b、find()
c、join()
d、strip()
e、startswith()
f、split()
g、upper()
h、lower()
i、format()
3、列表的方法
append()、extend（）、insert()
索引、切片、循环
4、元组
索引、切片、循环
一级元素整体不能被修改
5、字典的方法
get()、update（）、keys()、values()
、items()
八、布尔值
true 、false
以下布尔值都为假
None 空
"" '' 空字符串
()空元组
[]空列表
{}空字典
0