任意长度的python列表元组_python列表，元组，字典，集合简介

列表list：

可变类型

有序，可以被索引

作用，保存东西，并且可以存放多种东西，方便取出

定义：[]中可以有多个任意类型的值，用逗号分隔

s = [1,2,'3','字符串']

1：索引，切片：

和字符串的操作是相同的(索引切片都是相同的)

2：长度：

len()　　　　#获取列表有多少个值

3：常用方法 ：

.append(*) #在列表最后一位添加

.insert(1,2) #在列表的第1位添加2

.extend(*) #将元素循环加入列表

del l[1] #删除l列表序列1的元素

.pop(*) #删除 *这个值，并且被删除的值可以被获取

.remove() #指定删除某个元素

元组tuple:

作用：能存储多个元素，元素间用逗号隔开，定义和列表相同，不过不能被修改，用小括号括起来

"""

能存多个值

不能被修改

有序列

不可变

"""

定义：

t = (a,b,'c',4,[5,6])

必须传入可循环的

定义元组一般要在后面加个逗号，不然就会被定义成其他元素，

在定义容器类型的时候，哪怕内部只有一个元素，那也要用逗号隔开，区分一下(元组)

虽然元组不能改，但元组内部的东西是可以修改的，

t = (1,2,[3,4])

t2= '修改了'

print(t)

>>>

123,['修改了',4]

1：长度

len()　　　　#获取元组有几个元素

2.循环

for i in t:

print(i)　　#通过序列打印值

3.成员运算

in 和 not in

4.常用方法

.count() #计数

.index() #查找

字典dict:

作用：能存多组，key:value

无序

只会暴露key，不会暴露value

key是对value,key通常是字符串

这个key只能是不可变类型(数字，字符串，元组)，

value可以是任意数据类型

#字典的key不能重复，要标识一条数据，如果出现重复，那么就取最后一个键值对

"""存多个值

无序

可变

"""

定义字典

d1 = {'user':'cly','passwd':'1234'}

d1= dict(name='cly',passwd=123) 　　#通过关键字传参l=[

['name','cly']

['passwd','1234']

]for k, v in l: 　　　#'name','cly'd1[k]=v================d1= dict(l)

1：len(): #长度

获取键值对的个数

2：新增，改变：

d3['123'] = 123

3：删除

d3['name'] #删除'name'的键值对

pop('name') #弹出，在字典中会弹出value，但键值对都会被删除

当键不存在的时候，直接就报错

clear() #清空

4：方法(1)

.keys() #拿keypython2:

一次性全部打印出来，变成列表

python3：

要用到的时候才给你

.values()#拿value和keys差不多，不过是拿values的

.items()

列表套元组，元组第一个是key,第二个是value

.get('user'[,'没有这个key'])

获取通过字典的key('user')拿value,如果key不存在的话，他就返回None，或者传第二个参数，如果你的key不存在，他就会返回第二个你写好的信息,

dict.formkeys('name')

快速创造字典，通过for循环进行创建

d1= dict.fromkeys(['name','passwd'],123)print(d1)>>>{'name':123,'passwd':123}

.popitem()#尾部弹出键值对(元组).setdefault()#d1.setdefault('name','xxoo')#当键存在就不修改值，并且可以返回原本的值返回给你如果键不存在，那么就会新建一个键值对，并且可以返回新增的值返回给你

.update()

d1= {'name':'cly''passwd':'1234'}

d2= {'age':17}

d1.update(d2)#update(age=17)

print(d2)>>>{'name':'cly''passwd':'1234','age':17}

5：循环

for i in d1 :

print(i)#会打印d1这个字典的所有key

集合set

s1 = {1,2,3}

定义方法：

s1 = set((1,))

定义空集合

s1 = {} #如果只写了一个大括号{}，那么python会把它当成字典，

空集合：

s1 = set()

"""

作用

1.关系运算

2.去除重复

"""

集合的元素必须遵循三个原则：

1：每个元素必须是(可哈希)不可变类型

#可变：不可hash列表，字典

#不可变：可hash,数字，字符串，元组

2：多个元素不能重复，如果重复，他会去重

3：不能索引，因为无序

1：len() #获取元素的个数

2：集合运算：

两个都有的：s1 & s2 #交集

只有s1的：s1 - s2 #差集

只有s2的：s2 - s1

没有两个都有的：s1 ^ s2 #对称差集

所有元素(不重复)：s1 | s2 #

3：父集，子集

s1 = {1,2,3,4,55}

s2= {1,2}

父集：print(s1 >= s2) #s1是不是包含s2

.issubest()

子集：print(s2 <= s1) #s2是不是在s2中

.issupset()

3：==

s = {1,2,3}

s1 = {1,3,2}

s == s1 --->True

4：常用方法

.add(123) #将元素直接塞进去

.discard(1) #删除

.remove() #删除，没有不报错，返回None

集合set

s1 = {1,2,3}

定义方法：

s1 = set((1,))

定义空集合

s1 = {} #如果只写了一个大括号{}，那么python会把它当成字典，

空集合：

s1 = set()

"""

作用

1.关系运算

2.去除重复

"""

集合的元素必须遵循三个原则：

1：每个元素必须是(可哈希)不可变类型

#可变：不可hash列表，字典

#不可变：可hash,数字，字符串，元组

2：多个元素不能重复，如果重复，他会去重

3：不能索引，因为无序

1：len() #获取长度

2：集合运算：

两个都有的：s1 & s2 #交集

只有s1的：s1 - s2 #差集

只有s2的：s2 - s1

没有两个都有的：s1 ^ s2 #对称差集

所有元素(不重复)：s1 | s2 #

3：父集，子集

s1 = {1,2,3,4,55}

s2 = {1,2}

父集：

print(s1 >= s2) #s1是不是包含s2

.issubest()

子集：

print(s2 <= s1) #s2是不是在s2中

.issupset()

4：==

s = {1,2,3}

s1 = {1,3,2}

s == s1 --->True

5：常用方法

.add(123) #将元素直接塞进去

.discard(1) #删除

.remove()#删除，没有不报错，返回None