任意长度的python列表元组_Python列表,元组,字典,集合详细操作

菜鸟学Python第五天

数据类型常用操作及内置方法

列表(list)

======================================基本使用======================================

用途

用来存取多个同属性的值，用索引对应值，索引反映的是位置

定义方式

在[]内用逗号分隔开多个任意类型的值

l = [1, 2.2, 'str', 'list', '...'] #l= list([1, 2.2, 'str', 'list', '...'])

类型转换

list可以将str、list、dict、tuple等可以被for循环循环的类型转换为列表。

注：list只可以将dict的key遍历出来

d = {'name': 'Jason', 'age': 23, 'weight': 78, 'height': 183}

L=list(d)print(L)

​

['name', 'age', 'weight', 'height']常用操作+内置的方法

优先掌握的操作

按索引取值：可以正向存取、也可以反向存取

names = ['james', 'curry', 'paul', 'rose']print(names[3]) #正向取值

print(names[-3]) #反向取值

names[1] = 'irving' #按索引更改列表元素

print(names)

​

rose

curry

['james', 'irving', 'paul', 'rose']

​

# 注意：当索引超出范围时，按索引更改列表元素则会报错

切片(顾头不顾尾，步长)

names = ['james', 'curry', 'paul', 'rose']print(names[1:4])

​

['curry', 'paul', 'rose']

长度list.len()：统计列表元素个数

names = ['james', 'curry', 'paul', 'rose']print(len(names))

​4

成员运算in 、 not in：判断字符是否在列表内

list.append() & list.insert() : 追加&插入

names = ['james', 'curry', 'paul', 'rose']

names.append('ivring')print(names)

​

['james', 'curry', 'paul', 'rose', 'ivring']-----------------------------------------------------------names= ['james', 'curry', 'paul', 'rose']

names.insert(1,'ivring')print(names)

​

['james', 'ivring', 'curry', 'paul', 'rose']

注：append的只能从列表的末尾进行添加，insert可以在设定索引位置的前面添加，不设置索引时默认添加在开头

del list[索引]、list.remove(object)、list.pop(索引)：删除

del、remove、 pop的区别

del是通用的删除方式，并不为list特有

remove是按照list内的成员进行删除，而del、pop是按照索引进行删除操作。。

del、remove删除后没有返回值，pop则返回删除的那个成员

names = ['james', 'curry', 'paul', 'rose']del names[3] #删除'rose'

print(names.remove('paul')) #删除‘paul’并打印返回值

print(names.pop(1)) #删除'curry'并打印返回值

print(names) #打印最终列表

​

None#remove返回值为空

curry #pop返回值为‘curry’

['james'] #最终列表

循环

for循环

names = ['james', 'curry', 'paul', 'rose']for i innames:print(i)

需要掌握内容

list.count(object):统计列表中某元素的个数

names = ['james', 'curry', 'paul', 'rose', 'rose', 'rose', 'rose']print(names.count('rose'))

​4

list.extend(iterable):将另一列表内元素添加到原列表中，并赋值给原列表

names = ['james', 'curry', 'paul', 'rose']#print(names.count('rose'))

names1 = ['love', 'Hardon']

names.extend(names1)#将names1添加到names后面并赋值给names，此操作无返回值

print(names)

​

['james', 'curry', 'paul', 'rose', 'love', 'Hardon']

list.index(iterable):从左到右查找列表中某元素第一次出现的位置

names = ['james', 'curry', 'paul', 'rose', 'rose', 'rose', 'rose']print(names.index('rose'))

​3

list.reverse()：将list翻转，并赋值给原列表

names = ['james', 'curry', 'paul', 'rose']

names.reverse()#翻转，此操作无返回值

print(names)

​

['rose', 'paul', 'curry', 'james']

list.sort()：排序（默认从小到大，列表内必须为同一可比较类型）

names = ['james', 'curry', 'paul', 'rose']

names.sort()#排序操作，无返回值

print(names)

​

['curry', 'james', 'paul', 'rose']

======================================该类型总结====================================

存多个值

有序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

元组(tuple)

======================================基本使用======================================

用途

元组就是一个不可变的列表

定义方式

在()内用逗号分隔开多个任意类型的元素（逗号才是关键）

t = (1, 2.2, 'aa') #t = tuple()

print(type(t))

​

类型转换：

t1=tuple('hello')

t2=tuple([1,2,3])print(t1)print(t2)

​

('h', 'e', 'l', 'l', 'o')

(1, 2, 3)常用操作+内置的方法

优先掌握操作：

按照索引取值

切片

长度

成员运算

循环

t = (1, 2, 3, 4, 5)print(t[3]) #索引取值

print(t[1: 3]) #切片操作

print(len(t)) #长度计算

print(2 in t) #成员运算

​4(2, 3)5True

需要掌握操作：

tuple.index(object):从左到右查找某元素在元组中第一次出现的位置

tuple.count(object):统计元组中某元素的个数

t = (1, 2, 3, 3, 4, 5)print(t.index(2))print(t.count(3))

​1

2

======================================该类型总结====================================

存多个值

有序

不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

字典(dict)

======================================基本使用======================================

用途

记录多个值，列表是索引对应值，而字典是key对应值，其中key对value有描述性功能

定义方式

在{}内用逗号分隔开多个元素，每个元素都是key：value的形式，其中key是不可变类型，通常是字符串类型，而value可以是任意类型。

s = {'name':'James','age':'34','height':'203 cm', 'T_tpye':'all_round'}#s = dict({'name':'James','age':'34','height':'203 cm', 'T_tpye':'all_round'})

类型转换：加深理解

#第一种

d=dict(x=1,y=2,z=3)print(d)

​

{'x': 1, 'y': 2, 'z': 3}#第二种

items = [('name', 'egon'), ('age', 18), ('gender', 'male')]

d=dict(items)print(d)

​

{'name': 'egon', 'age': 18, 'gender': 'male'}

常用操作+内置的方法

优先掌握

按key存取值：可存可取

key存在则为赋值操作，key不存在则添加字典key：value

msg = {'name': 'James', 'age': '34', 'height': '203 cm', 'T_tpye': 'all_round'}

msg['name'] = 'Lebron' #修改key对应的value

msg['team'] = 'lakers' #添加字典key：value

print(msg)

​

{'name': 'Lebron', 'age': '34', 'height': '203 cm', 'T_tpye': 'all_round', 'team': 'lakers'}

dict['key']:没有则报错

dict.get(key):没有报none

msg = {'name': 'James', 'age': '34', 'height': '203 cm', 'T_tpye': 'all_round'}print(dsg['team']) #key 不存在字典中，会报错

print(msg.get('team')) #key 不在字典中返回None

​

KeyError:'team'None

长度len()：统计字典中键值对的个数

成员运算in 或者not in（以字典的key为准）

pop 、popitem(随机删)：删除

使用方法同字典pop，并返回删除key

键keys()，值values()，键值对items()

>>> msg = {'name': 'James', 'age': '34', 'height': '203 cm', 'T_tpye': 'all_round'}>>>msg.keys()

dict_keys(['name', 'age', 'height', 'T_tpye'])>>>msg.values()

dict_values(['James', '34', '203 cm', 'all_round'])>>>msg.items()

dict_items([('name', 'James'), ('age', '34'), ('height', '203 cm'), ('T_tpye', 'all_round')])

循环

msg = {'name': 'James', 'age': '34', 'height': '203 cm', 'T_tpye': 'all_round'}for k, v in msg.items(): #k,v=('name', 'egon')

print(k, v)

​

name James

age34height203cm

T_tpye all_round

需要掌握

dict.update():函数把字典参数 dict2 的 key/value(键/值)对更新到字典 dict 里。

msg = {'name': 'James', 'age': '34'}

msg1= {'height': '203 cm', 'T_tpye': 'all_round'}

msg.update(msg1)#更新操作，无返回值

print(msg)

​

{'name': 'James', 'age': '34', 'height': '203 cm', 'T_tpye': 'all_round'}

dict.setdefault(key,value)：当key存在时不改原值，并返回原值，当key不存在时增加新value

msg = {'name': 'James', 'age': '34'}print(msg.setdefault('age', '35'))print(msg.setdefault('height', '203'))print(msg)

​34

203{'name': 'James', 'age': '34', 'height': '203'}

注：当返回的value不是输入的新value时，标明字典中包含该key，当返回value是输入的心value时则表明之前字典中不包含该key，可以用来判断字典中是否含有某元素。

======================================该类型总结====================================存多个值无序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

集合(set)

======================================基本使用======================================

用途

关系运算

去重

定义方式

在{}内用逗号分隔开多个元素

S = {1,2,3,4,5} #S = set({1,2,3,4,5})

元素的特点：

集合内元素必须是不可变类型

集合内元素无序

集合内元素不可重复

类型转换：

set可以将能用for循环循环的数据类型转换为集合

3. 常用操作+内置的方法

优先掌握

长度len():返回集合内元素个数

成员运算in、not in：判断集合中是否存在某元素

并（合）集set.union(set1, set2...)，快捷键：|

交集set.intersection(set1, set2 ... )，快捷键：&

差集set.difference(set)，快捷键：-

对称差集set.symmetric_difference(set)，快捷键：^

a_club = {'jason', 'tony', 'jay', 'allen'}

b_club= {'rose', 'alice', 'allen', 'tony'}print(a_club | b_club) #并集

print(a_club & b_club) #交集

print(a_club - b_club) #差集，只在a_club中的成员

print(b_club - a_club) #差集，只在b_club中的成员

print(a_club ^ b_club) #对称差集 没有同时在两个集合的成员

​

{'allen', 'jason', 'rose', 'jay', 'alice', 'tony'}

{'allen', 'tony'}

{'jason', 'jay'}

{'alice', 'rose'}

{'jason', 'rose', 'jay', 'alice'}

==：集合中元素完全一致

父集和子集>=、<=：描述的是一种包含和被包含的关系

s1 = {1, 2, 3}

s2= {1, 2, 3}

s3= {1, 2, 3, 4}print(s1 ==s2)print(s3 >=s1)print(s1 <=s3)

​

​

True

True

True

需要掌握

update();更新

s1={1,2,3}

s1.update({3,4,5,6})print(s1)

​

{1, 2, 3, 4, 5, 6}

pop():随机删，并返回删除元素

s1={1,'aa','bb',3}print(s1.pop())

​1

remove()：按元素删，当元素不存在时报错

discard()：按元素删，当元素不存在时不报错

#remove

s1 = {1,'aa','bb',3}

res= s1.remove('bbbbbb')print(s1) #不存在即报错

print(res) #打印返回值（无返回值）

​

KeyError:'bbbbbb'​#discard

s1 = {1,'aa','bb',3}

res= s1.diiscard('bbbbbb')print(s1) #不存在不报错

print(res) #没有返回值

​

{3, 1, 'aa', 'bb'}

None

add()：添加

s1 = {1,'aa','bb',3}

s1.add(4)print(s1)

​

{1, 3, 'aa', 4, 'bb'}

集合的去重的局限性：

只能针对不可变类型*

不能保证原来的顺序

======================================该类型总结====================================

存多个值

无序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）