Python之序列(列表&元组&字典&集合)

版权声明:学研之路长而漫,长情与君总会见! https://blog.csdn.net/Aaron_Miller/article/details/80203486

一、列表

1.列表:存储成组的信息,一系列按特定顺序的元素组成 【大多数列表都是动态的】
 【列表名称一般为复数,如letters、cars、names
    格式:listName=['  ', /"  "]  
    索引从0而不是1开始,-1,-2……索引分别代表倒数第一、二  个元素】
1.通过索引访问列表元素:———————————–
{   cars=['玛莎拉蒂','凯迪拉克','劳斯莱斯']
    print(cars[0]) 
    玛莎拉蒂        }
2.修改、添加和删除元素—————————————
        ---修改: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.临时正反序(函数: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.遍历列表

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)]
列表名=[表达式 循环给表达式提供值]
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会造成共享引用

补充:

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

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

二、元组(tuple)

1.特点
无序
不可变的序列
可包含任意对象的集合
下标访问
任意嵌套
不可变原位改变
2.定义一个元组
tupleName=(element_0,element_1)
3.访问一个元组
print(tupleName[0])
4.通过切片访问特定范围元素
print(tupleName[:])
5.不可修改、删除
6.定义一个只有一个元素的元组
one_tuple=("one",)  //需要加入一个“,”
7.循环遍历元组
for t in range(0,len(tupleName)):
    print(tupleName[t])
/for t in tupleName:
    print(t)
8.元组排序
newTupleName=sorted(tupleName)
  //排序后,会返回一个新的list,元组本身不会变
#####9.列表转元组

tuple(listName)

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

#####2.格式:
<div>
    dict_name={
'key':'value',
~~
             }
</div>
    【value:可为:数字、字符串、列表、字典;
    key值不能相同,后面的会覆盖掉前面的】

#####3.访问字典值
    dict_name['keyName']

#####4.添加键-值对
    dict_name['newKey']='newValue'

#####5.定义空字典
dict_name={}

#####6.修改字典中的值
```python
    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']))  }




<div class="se-preview-section-delimiter"></div>
7.删除键-值
del dict ['key']
//键-值永久删除了
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[ "~" ] ]
#####7.删除键-值
    del dict ['key']
    //键-值永久删除了

#####8.遍历字典
    A.遍历键-值对:
```python
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[ "~" ] ]
9.清空字典

dicName.clear()

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)

1.特点

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

2.格式

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

3.集合去重 //利用集合特性

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

4.创建空集合

none_set = set { }

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)

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

展开阅读全文

没有更多推荐了,返回首页