Python 列表和元组
1,数据结构基本知识
数据结构是以某种方式(例如编码) 组合起来的数据元素(数字 字符 和其他数据)的汇集体,最为基本的数据结构,称之为序列(sequence)
其中,在Python中,我们常见的数据类型和数据结构如下:
数据类型:
- 整数型 int() : 数字的整数
- 浮点型 float() : 数字带小数
- 字符串 str() : 用 ‘’ 或者 “” 引用的任意文本
- 布尔型bool() :
True 和False
数据结构分为： # 数据结构 可以相互嵌套,参见2.1示例
- 列表 list : 可以修改,使用方括号表示,逗号区分各个子元素,其中字符串需 单引号或 双引号区分 ["你好","中国",2018,"改革开放40周年"]
- 元祖 tuple :不可以修改,使用圆括号表示,
- 字典 dict :
- 集合 set :
本次,主要讲述列表与元组的知识.
2.列表内容
2.1 列表基础知识
- 列表,,使用方括号表示,逗号区分各个子元素,其中字符串需 单引号或 双引号区分 ["你好","中国",2018,"改革开放40周年"]
lst1 = ["你好","中国",2018,"年,改革开放40周年"] lst2 = ["反法西斯","胜利",73,"周年"] lst3 = lst1 +lst2 # 列表相加,也就是合并 lst4 = [lst1 +lst2] # 嵌套两个列表 print(lst3) print(lst4)
- 效果如下:
['你好', '中国', 2018, '年,改革开放40周年', '反法西斯', '胜利', 73, '周年'] [['你好', '中国', 2018, '年,改革开放40周年', '反法西斯', '胜利', 73, '周年']]
2.2 列表操作:
- 索引 list[X] :列表中,各个子元素位置自0开始,list[x]表示第几位元素,此称之为 索引(indexing)
lst1 = ["你好","中国",2018,"年,改革开放40周年"] lst2 = lst1[1] print(lst1[0]) print(lst2) print(type(lst1[0])) print(type(lst1[2]))
效果如下:
你好 中国 <class 'str'> <class 'int'>
- 切片 slicing : 使用切片来访问特定范围内的元素,为此,可使用2个索引和冒号分割,来定位具体元素
lst1 = ["你好","中国",2018,"年,改革开放40周年"] lst2 = lst1[1:2] # 方括号内的索引,表示自左向右,顾头不顾尾的选取. print(lst2) print(type(lst2)) lst3 = lst1[1:] # 方括号内的第二位数字为空,表示自左向右,自第"1"位开始索引,至结束. print(lst3) lst4 = lst1[:3] # 方括号内的第一位数字为空,表示自左向右,自起始开始索引,至结束第3-1=2位前结束. print(lst4) lst5 = lst1[1:-2] # 表示自左向右,自第"1"开始索引,至结束第-2位前结束. print(lst5) lst6 = lst1[2:-2] # 表示自左向右,自第"2"开始索引,至结束第-2位前结束.. print(lst6) lst7 = lst1[0:5:2] # 最后一个2,表示步长意思,跳过选取.. print(lst7) lst8 = ["反法西斯","胜利",73,"周年"] print(lst1 + lst8) # 列表相加 print(2 * lst8) # 列表乘法 print(lst8 * 2) # 列表乘法
效果如下:
['中国'] <class 'list'> ['中国', 2018, '年,改革开放40周年'] ['你好', '中国', 2018] ['中国'] [] ['你好', 2018] ['你好', '中国', 2018, '年,改革开放40周年', '反法西斯', '胜利', 73, '周年'] ['反法西斯', '胜利', 73, '周年', '反法西斯', '胜利', 73, '周年'] ['反法西斯', '胜利', 73, '周年', '反法西斯', '胜利', 73, '周年']
- 成员资格 in : in 是成员资格运算符,它检查是否满足指定条件,并返回True 或Flase
lst1 = ["你好","中国",2018,"年,改革开放40周年"] lst2 = ["你好"] str1 = "你好","中国",2018,"年,改革开放40周年" str2 = "你好" lst3 = lst1[0] print(lst2 in lst1) # 列表成员资格审查,显然不支持列表与列表的in 资格审查 print(lst2 == lst3) # 列表成员资格审查,显然不支持列表与列表的比较 print(str2 in str1) #字符串的资格审查,显然支持字符串的资格审查 print(str2 == str1[0]) #字符串的比较运算,显然支持字符串的比较运算 print(str1[0]) #字符串1的索引 print(str2[0]) #字符串2的索引 print("----完美分割线-----") print(len(str1)) #len()函数在字符串的应用 print(len(lst1)) #len()函数在列表的应用
效果如下:
False
False
True
True
你好
你
----完美分割线-----
4
4- list() 字符串转列表 可以实现 修改列表 删除元素 赋值元素等工作
import string # join函数在string 中 str1 = "你好", "中国", 2018, "年,改革开放40周年" str2 = "你好" str3 = "*手牵手*" str8 = "," lst4 = ["你好", "中国", 2018, "年,改革开放40周年"] lst1 = list(str1) # 字符串转成列表,结果以列表生成 lst2 = list(str2) # 字符串转成列表,结果以列表生成 print(lst1) print(lst2) str4 = str3.join(str2) # 将str3合并str2中,结果以字符串生成 print(str4) str5 = str3.join(str(x) for x in lst4) # 将str3合并到lst4中,结果以字符串形式生成 print(str5) str6 = str8.join(str(x) for x in lst4) # 将str8合并到lst4中,结果以字符串形式生成 print(str6)
效果如下:
['你好', '中国', 2018, '年,改革开放40周年'] ['你', '好'] 你*手牵手*好 你好*手牵手*中国*手牵手*2018*手牵手*年,改革开放40周年 你好,中国,2018,年,改革开放40周年
- list修改元素/ 删除元素 切片赋值和一系列方法
lst1 = ["python","java","c++","vb"] lst1[1] = "Basic" print(lst1) lst1[1] = 2018 print(lst1) lst1 = lst1*3 # 下一个代码将给列表1的第11位赋值修改为2019,但目前lst1没有底11位,因此重新定义列表大小 # None 空列表与初始化 按要求,不允许给予列表超出位置赋值,因此初始化空列表可以用 lst=[] ,如果创建10位的空,可以用[]*10表示.或者[None]*10 print(lst1) lst1[10] = 2019 # 变值第10位 为2019 print(lst1) print("*****完美分割线*****") print(len(lst1)) del lst1[1] # 删除第1位 java print(lst1) print(len(lst1))
效果如下:
['python', 'Basic', 'c++', 'vb'] ['python', 2018, 'c++', 'vb'] ['python', 2018, 'c++', 'vb', 'python', 2018, 'c++', 'vb', 'python', 2018, 'c++', 'vb'] ['python', 2018, 'c++', 'vb', 'python', 2018, 'c++', 'vb', 'python', 2018, 2019, 'vb'] *****完美分割线***** 12 ['python', 'c++', 'vb', 'python', 2018, 'c++', 'vb', 'python', 2018, 2019, 'vb'] 11
切片是一个极其强大的功能,能够给切片赋值,使得列表具备更大的弹性,最为重要的是 在不改变列表元素的情况下(有可能位置变动),增加新元素
lst1 = ["中国", "美国", "日本", "加拿大"] lst2 = ["中国", "美国", "日本", "加拿大"] lst1[1:2] = ["美国", "欧盟"] print(lst1) lst1[1] = "欧盟" print(lst1) lst1[1] = "美国", "欧盟" # 针对某一位列表元素,但赋值两个字符串,将以元组格式插入 print(type(lst1[1])) print(lst1) lst1[1:2] = "美国", "欧盟" print(lst1) lst1[-1:-2] = "美国", "欧盟" lst2[-2:-1] = "美国", "欧盟" print(lst1) print(lst2) lst2[-2:-1] = "美国", "欧盟" print(lst2) print(type(lst1[-2])) lst2[-2] = [] # 针对某一位列表元素,但赋值两个字符串,将以元组格式插入 print(lst2) print(lst1) lst2[1:-2] = [] # 将1- -2位赋值为空列表 lst2[1] = "2" print(type(lst2[1])) lst2[1] = 1 print(type(lst2[1])) lst1[1:-2] = "" # 将1- -2位赋值为空 print(lst2) print(lst1) print(len(lst1)) print("*****完美分割线1******") lst1 = ["中国", "美国", "日本", "加拿大"] lst2 = lst1.append("德国") # append 函数 就地添加对象元素到 列表 末尾,返回none print(lst1) print(lst2) print("*****完美分割线2******") lst3 = ["中国", "美国", "日本", "加拿大"] lst4 = lst3.clear() # clear 函数 就地添加清空列表,返回none print(lst3) print(lst4) print("*****完美分割线3******") lst5 = ["中国", "美国", "日本", "加拿大"] lst6 = lst5 # 改变其中一个会改变另一个值 print(lst6) lst6[1] = "欧盟" print(lst6) print(lst5) print("*****完美分割线4******") lst5 = ["中国", "美国", "日本", "加拿大"] lst7 = lst5.copy() # copy 常规复制,只是将一个表关联到另外一个表,不会改变其值 print(lst5) lst7[1] = "欧盟" print(lst7) print(lst5) print("*****完美分割线5******") print(lst5.count("中国")) # count 只能统计一层的数据出现次数 lst8 = ["中国", "美国", "日本", ["中国", "加拿大"]] print(lst8.count("中国")) print("*****完美分割线6******") lst5 = ["中国", "美国", "日本", "加拿大"] lst6 = ["中国", "美国", "日本", "加拿大"] lst10 = lst5.extend(lst6) # extend 就地扩展括号中的列表到前面引用的列表中,返回None print(lst10) print(lst5) print("*****完美分割线7******") lst14 = ["中国", "美国", "日本", "加拿大"] lst15 = ["中国", "美国", "日本", "加拿大"] print(lst14 + lst15) # 常规拼接 print(lst14) # 常规拼接,不改变原表 print("*****完美分割线8******") lst11 = ["中国", "美国", "日本", "加拿大"] lst12 = ["中国", "美国", "日本", "加拿大"] lst11[len(lst11):] = lst12 # 切片赋值,效果与extend一致 print(lst11) lst13 = ["中国", "美国", "日本", "加拿大"] lst13[len(lst13):] = lst13 print(lst13) print("*****完美分割线9******") lst17 = ["中国", "美国", "日本", "加拿大"] print(lst17.index("中国")) # index 返回查找的给定值 在列表中 出现的第一次索引位置 lst18 = ["中国", "美国", "日本", "加拿大"] print(lst18.insert(1, "中国")) # insert 将给定值 根据给定的位置索引,添加进列表,返回值 none lst18.insert(1, "中国") print(lst18) # 原表已被修改,返回完整列表 print("*****完美分割线10******") lst20 = ["中国", "美国", "日本", "加拿大"] lst20.pop(2) # pop 将根据给定的位置索引,删除列表元素,唯一一个列表返回非none值的方法,默认删除最后一个元素. print(lst20) lst21 = ["中国", "美国", "日本", "加拿大"] lst22 = lst21.pop() # pop 将根据给定的位置索引,删除列表元素,唯一一个列表返回非none值的方法,默认删除最后一个元素. print(lst22) print(type(lst22)) # pop 默认删除最后一个元素.返回值为字符串 print("*****完美分割线11******") lst23 = ["中国", "美国","中国" ,"日本", "加拿大"] lst24 = lst23.remove("加拿大") # remove 将根据给定的"值",删除列表中,第一次出现的位置的元素,返回none值. print(lst23) print(lst24) print(type(lst24)) print("*****完美分割线12******") lst25 = ["中国", "美国","中国" ,"日本", "加拿大"] lst26 = lst25.reverse() # reverse 将根据给定的列表,反顺序排列.返回none 值 print(lst25) print(lst26) print(type(lst26)) print("*****完美分割线13******\n") lst27 = ["中国", "美国","中国" ,"日本", "加拿大"] lst28 = lst27.sort() # sort将根据给定的列表,就地排序.返回none 值,相当于直接改原表,因此如果需要改变副本,原表不变,只能用下下的代码 print(lst27) print(lst28) print(type(lst28)) lst29 = ["中国", "美国","中国" ,"日本", "加拿大"] lst30 = lst29.copy() # 使用copy ,保留lst29的原始表,lst30直接修改, lst30.sort() print(lst30) print(lst29) lst29 = ["中国", "美国","中国" ,"日本", "加拿大"] lst30 = sorted(lst29) # 使用sorted函数 ,直接将排序结果给lst30,保留lst29的原始表,lst30是返回结果, print(lst30) print(lst29) str1 = "中国" str2 = sorted(str1) # 字符串同样可以使用sorted函数 ,直接将排序结果给str2,保留str1的原始字符串,str2是列表形式返回. print(str2) print(str1) print(type(str2)) print(type(str1)) print("*****完美分割线14******\n") lst31 = ["中国", "美国","中国" ,"日本", "加拿大"] lst32= lst31.sort( key = len) # 高级排序,探索sort()内部的关键参数 key print(lst31) print(lst32) print(type(lst32)) lst33 = ["中国", "美国","中国" ,"日本", "加拿大"] lst34 = sorted(lst33,key = len) # 高级排序,探索sorted()内部的关键参数 key print(lst34) print(lst33) print("*****完美分割线15******\n") lst35 = ["中国", "美国","中国" ,"日本", "加拿大"] lst36= lst35.sort( reverse = True) # 高级排序,探索sort()内部的关键参数 reverse print(lst35) print(lst36) print(type(lst36)) lst37 = ["中国", "美国","中国" ,"日本", "加拿大"] lst38 = sorted(lst37,reverse = False) # 高级排序,探索sorted()内部的关键参数 reverse print(lst38) print(lst37) print(type(lst38)) lst39 = ["中国", "美国","中国" ,"日本", "加拿大"] lst40 = sorted(lst39,reverse= "加拿大") # 高级排序,探索sorted()内部的关键参数 key print(lst40) print(lst39) print(type(lst40))
效果如下:
['中国', '美国', '欧盟', '日本', '加拿大'] ['中国', '欧盟', '欧盟', '日本', '加拿大'] <class 'tuple'> ['中国', ('美国', '欧盟'), '欧盟', '日本', '加拿大'] ['中国', '美国', '欧盟', '欧盟', '日本', '加拿大'] ['中国', '美国', '欧盟', '欧盟', '日本', '美国', '欧盟', '加拿大'] ['中国', '美国', '美国', '欧盟', '加拿大'] ['中国', '美国', '美国', '美国', '欧盟', '加拿大'] <class 'str'> ['中国', '美国', '美国', '美国', [], '加拿大'] ['中国', '美国', '欧盟', '欧盟', '日本', '美国', '欧盟', '加拿大'] <class 'str'> <class 'int'> ['中国', 1, '加拿大'] ['中国', '欧盟', '加拿大'] 3 *****完美分割线1****** ['中国', '美国', '日本', '加拿大', '德国'] None *****完美分割线2****** [] None *****完美分割线3****** ['中国', '美国', '日本', '加拿大'] ['中国', '欧盟', '日本', '加拿大'] ['中国', '欧盟', '日本', '加拿大'] *****完美分割线4****** ['中国', '美国', '日本', '加拿大'] ['中国', '欧盟', '日本', '加拿大'] ['中国', '美国', '日本', '加拿大'] *****完美分割线5****** 1 1 *****完美分割线6****** None ['中国', '美国', '日本', '加拿大', '中国', '美国', '日本', '加拿大'] *****完美分割线7****** ['中国', '美国', '日本', '加拿大', '中国', '美国', '日本', '加拿大'] ['中国', '美国', '日本', '加拿大'] *****完美分割线8****** ['中国', '美国', '日本', '加拿大', '中国', '美国', '日本', '加拿大'] ['中国', '美国', '日本', '加拿大', '中国', '美国', '日本', '加拿大'] *****完美分割线9****** 0 None ['中国', '中国', '中国', '美国', '日本', '加拿大'] *****完美分割线10****** ['中国', '美国', '加拿大'] 加拿大 <class 'str'> *****完美分割线11****** ['中国', '美国', '中国', '日本'] None <class 'NoneType'> *****完美分割线12****** ['加拿大', '日本', '中国', '美国', '中国'] None <class 'NoneType'> *****完美分割线13****** ['中国', '中国', '加拿大', '日本', '美国'] None <class 'NoneType'> ['中国', '中国', '加拿大', '日本', '美国'] ['中国', '美国', '中国', '日本', '加拿大'] ['中国', '中国', '加拿大', '日本', '美国'] ['中国', '美国', '中国', '日本', '加拿大'] ['中', '国'] 中国 <class 'list'> <class 'str'> *****完美分割线14****** ['中国', '美国', '中国', '日本', '加拿大'] None <class 'NoneType'> ['中国', '美国', '中国', '日本', '加拿大'] ['中国', '美国', '中国', '日本', '加拿大'] *****完美分割线15****** ['美国', '日本', '加拿大', '中国', '中国'] None <class 'NoneType'> ['中国', '中国', '加拿大', '日本', '美国'] ['中国', '美国', '中国', '日本', '加拿大'] <class 'list'> ['美国', '日本', '加拿大', '中国', '中国'] ['中国', '美国', '中国', '日本', '加拿大'] <class 'list'>
元组 元组相对于列表,不可修改,因此元组少了一些方法,但元组创建也非常简单:圆括号内,字符之间以逗号区分.
tuple1= 1,2,3 #元组的语法也非常简单,产生元组只需将字符逗号区分 print(tuple1) tuple2= ( ) #元产生空元组只需使用空圆扩号表示即可,即便里面有空格也可 print(tuple2) tuple3= (4,) #元产生1个位置的元组,必须用逗号 print(tuple3) tuple4= 3*(42) #返回126 print(tuple4) tuple5= 3*( 42,) #元组与列表类似,返回一个重复3次42,的元组 print(tuple5) tuple6= tuple([1,2,3]) #元组换型,如果目标是列表,就按列表各个元素建立元组 print(tuple6) print(type(tuple6[1])) tuple7= tuple("123") #元组换行,如果目标是字符串,就按各个字符建立元组 print(tuple7) print(type(tuple7[1])) tuple8= tuple((1 , 2 , 3) ) #元组换型 ,如果目标是元组,就原封不动变动它 print(tuple8) print(type(tuple8[1])) #以上2个表明,列表中字符的格式,最终会遗传到元组中.
效果如下:
(1, 2, 3) () (4,) 126 (42, 42, 42) (1, 2, 3) <class 'int'> ('1', '2', '3') <class 'str'> (1, 2, 3) <class 'int'>
