Python之序列（列表&元组&字典&集合）

一、列表（list）

1.1 介绍

1.列表：存储成组的信息，一系列按特定顺序的元素组成 【大多数列表都是动态的】

 【列表名称一般为复数，如letters、cars、names
    格式：listName=['  ', /"  "]  
    索引从0而不是1开始，-1，-2……索引分别代表倒数第一、二  个元素】

1.2.通过索引访问列表元素

{	cars=['玛莎拉蒂','凯迪拉克','劳斯莱斯']
	print(cars[0]) 
	玛莎拉蒂		}

1.3.修改、添加和删除元素

        ---修改：listName[索引值]="  "             //重新赋值
改变范围元素的值：listName[0:5]=[value,~/value]
		     改表步长修改元素：listName[::2]=[~] 	//步长为2
 ---添加：listName.append("元素名")   // [ə'pɛnd]，附加
     空列表添：listName.append(“元素名”)
  ~~
【expend()	//扩展为序列】
            插入：listName.insert(索引值 ," ")     //必须指定索引和值
  listName[3:3]=[' ']
        ---删除： del listName[索引值]
	               . pop(索引值) //检索并删除，默认最后一个   //[pɑp], 取出
 		       remove("元素名"）//存在重复的删除第一个值
  . clear()	//清空列表
【都可根据切片删除 [ : ] 
pop() remove() 都为方法； del为语句】

1.4 组织列表（调整元素排列顺序）

#####1.临时正反序(函数：sorted( ))
print( sorted(listName) )
print( sorted(listName,reverse=True) )
#####2.永久正反序(方法：sort( ))
listName.sort()
listName.sort(reverse=True)
//listName.sort(key=lambda a:a[-1]) //按照最后一个字母排序
#####3.查看列表长度
len(listName)
【发生IndexError(索引错误)时可以打印长度/索引值-1来找出逻辑错误】

1.5 操作列表（对每个元素采取相同措施）

#####1.遍历列表
cars=[‘大众’,‘奔驰’,‘QQ’]
for car in cars:
print(car) 【变量单数，列表名复数，“ : ” 缩进】
/for car in range(0,len(cars)):
print(cars[car])
【避免缩进错误！】

#####2.函数range(firstNum，finalNum)打印数字
【Tips：从第一个值开始打印到最后一个索引前一个值结束！】

#####3.创建数值列表（存储数字集合）,函数list()转化为列表

{
list( range(1,11) )	


}
{
创建一个1-10的平方的数字列表
squares=[]
for value in range(1,11):
	    		  squares.append(value*value)
print(squares)	}
【 print(list('abc'))			//str转list
     print( list(('a','b','c')) )		//tuple转list 】

#####4.统计数字列表
min() /max() /sum()		//求列表中最小/最大/和值

#####5.列表解析 (将for循环和新建元素合并成一行，并自动附加新元素)
如1-10平方可以：
squares=[value*value for value in range(1,11)]
列表名=[表达式 循环给表达式提供值]

1.6. 列表切片（使用列表一部分）

syntax：listName[起始索引：结束索引]
【和range()一样不取终止值! 】

players=['关羽','张飞','赵云','韩信','姜子牙']
print(players[2:4])【赵云 韩信 //Tips：对应元素为+1，当前4】
print(players[:3])
print(players[2:])
print(players[-2:])
}

A.遍历切片

print(newValue)

B.复制列表

-newListName=listName[ : ]	//将整个列表切片赋值给newListName
-newListName=listName.copy()
			//listName2=listName1会造成共享引用

1.7 补充

重复
listName*n //n表示：打印次数
检测某element首位置
listName.index(elementName)

统计某个element出现次数
print(listName.count(elementName))

二、元组（tuple）

2.1 特点

无序
不可变的序列
可包含任意对象的集合
下标访问
任意嵌套
不可变原位改变

2.2 定义一个元组

tupleName=(element_0,element_1)

2.3 访问一个元组

print(tupleName[0])

2.4 通过切片访问特定范围元素

print(tupleName[:])

2.5 不可修改、删除

2.6 定义一个只有一个元素的元组

one_tuple=("one",)	//需要加入一个“,”

2.7 循环遍历元组

for t in range(0,len(tupleName)):
	print(tupleName[t])
/for t in tupleName:
	print(t)

2.8 元组排序

newTupleName=sorted(tupleName)
//排序后，会返回一个新的list,元组本身不会变

2.9 列表转元组

tuple(listName)

三、字典（dict）

3.1 含义

动态结构(无序、可变)的一系列的-值对，每个键都和一个值相关联，可用使用键来访问相对应的值，将信息关联起来
【Python不关心键值对的添加顺序，只关心键和值的关联关系】

3.2 格式：

dict_name={ 'key':'value', ~~ }

【value:可为：数字、字符串、列表、字典； key值不能相同，后面的会覆盖掉前面的】

3.3 访问字典值

dict_name['keyName']

3.4 添加键-值对

dict_name['newKey']='newValue'

3.5 定义空字典

dict_name={}

3.6 修改字典中的值

	dict_name['key']='newValue'
{//通过修改值判断外星人移动距离
alien_0={'x_position':0,'y_position':25,'speed':"medium"}
 	#将外星人速度调为‘fast’
alien_0['speed']='fast'
记录外星人起始x轴位置
print("Original x-position:" + str(alien_0["x_position"]))
根据外星人速度决定移动多远
if alien_0['x_position']=='slow':
		x_increment=1
elif alien_0["speed"]=='medium':
		x_increment=2
else:
		x_increment=3
将新位置赋给变量
alien_0['x_position']=alien_0['x_position']+x_increment
print("New x_position is:"+str(alien_0['x_position']))	}

3.7 删除键-值

del dict ['key']
//键-值永久删除了

3.8 遍历字典

A.遍历键-值对：

for key,value in dict_name.items():
//利用方法items()将变量key,value放到一个列表中，变量名应有意义！
//返回的为元组，访问元组中键/值：
for item in dict_name.items():
itemy[0/1] 
B.遍历键：
a.遍历所有键：   for key in dict_name.keys( ):
b.按顺序遍历键：for key in sorted(dict_name.keys( )):
c.遍历单个键：key_list=list(dict_name.keys())		 key_list[]  
d.拿到每个键：key1,key2,key3,~=dict_name		 print(key1,key2,key3,~)		//适用于键值对少的字典
C.遍历所有值：   	  for value in dict_name.values( ):
a.为值去重：       for value in set(dict_name.values()):
b.通过value找key:		value_list=list(dict_name.values())
     result=key_list[ value_list.index[ "~" ] ]

3.9 清空字典

dicName.clear()

3.10 嵌套

A.字典列表：（外星人列表）
dicName1={‘key1’:"‘value1’,~}
dicName2={‘key1’:"‘value2’,~}
listName=[dicName1, dicName2]
B.列表字典：（描述每个披萨配料）
dicName={
‘listName’:[’ ‘,’ ']
}
for l_N in dicName[‘listName’]: //遍历字典中指定列表
/for key,value in dicName.items(): //
for v in value: //遍历整个列表字典
C.字典字典：（存储用户信息）
dicName1={
‘dicName2’:{‘key’,‘value’},
}

四、集合（set）

4.1 特点

可变序列，支持原位改变
可包含任意类型
任意嵌套
不允许有重复的对象（自动去重）

4.2 格式

name_set{ ‘set_0’,‘set_1’,‘set_2’ }

4.3 集合去重

//利用集合特性
–对列表去重
id_list = [ ‘id_0’,‘id_1’,‘id_2’,‘id_3’ ]
id_set = set(id_list)
–对字符串去重
string_set = set(“hello”)

4.4 创建空集合

none_set = set { }

4.5 增、删、改、查

name_set = {‘小王’,‘大王’}
– 增：
name_set.add(“Kevin”) //单个添加
name_set.update([“小广”,“大广”],[“WG”]) //添加的是序列
print(name_set)
– 删：
name_set.remove(“WG”) //删除不存在的元素报错
name_set.discard(“WG”) //删除不存在元素不会报错
print(name_set)
– 改：
for n_s in name_set:
if n_s == “小王”:
name_set.remove(n_s)
name_set.add(“Kevin”)
print(name_set)

4.6 交、并集

name_set1 = {‘张三’,‘李四’,‘王五’}
name_set2 = {‘孙七’,‘李四’}
– 交集：
name_set=name_set1 & name_set2
name_set=name_set1.intersection(name_set2)
– 并集：
name_set=name_set1 | name_set2
– 差级：
name_set=name_set1 - name_set2 //从name_set1中去掉交集
name_set=name_set2 - name_set1 //从name_set2中去掉交集
– 对称差级： //并集-交集
name_set=name_set1 ^ name_set2