python---列表，元组，字典，集合

知识点一：列表类型

           1.定义

<class 'list'>

             1）有序容器型数据、可变数据类型

             2）作用：存储多个值，方便按照顺序提取数据，比如存储一些名字

# 姓名列表
name_list=['Simon','Andy','Mark','Eric','Jicky']
# 一个列表可以存放各种类型的数据
l=['Simon',56,2.3,[1,2,3],{'Andy':45}]

          2.方法

             1）增

                   a）在列表末尾添加元素：append()方法

numList=[1,4,6,4,2,5,8,3]
numList.append(0)
print(numList)

                    b）在列表中间插入元素：insert()方法

numList=[1,4,6,4,2,5,8,3]
numList.insert(3,44) #在索引3的位置插入元素44
print(numList)

                     c）一次性往列表末尾添加多个元素 括号里放列表：extend() 方法

numList=[1,4,6,4,2,5,8,3]
numList.extend([2,3,4]) # 在列表末尾添加一个列表[2,3,4]
print(numList)

                      d）两个列表相加也可以

numList=[1,4,6,4,2,5,8,3]
name_list=['Simon','Andy','Mark','Eric','Jicky']
newList=numList+name_list
print(newList)

                2）删

                     a）删除末尾一个元素并返回删除的元素：pop()方法

numList=[1,4,6,4,2,5,8,3]
num=numList.pop() #删除最后一个元素3
print(numList)
print(num)

                     b）按照元素索引删除：pop(索引)方法、del()函数

numList=[1,4,6,4,2,5,8,3]
num=numList.pop(3) #删除索引为3的元素4
print(numList)
print(num)
del(numList[2]) #删除numList列表中索引为2 的元素
print(numList)

                      c）按照元素名字删除：remove(元素名)方法

numList=[1,4,6,4,2,5,8,3]
numList.remove(4) #删除元素4（从左往右删除第一个）
print(numList

                      d）清空列表：clear()方法

numList=[1,4,6,4,2,5,8,3]
numList.clear() # 清空numList列表
print(numList)

                 3）查

                      a）索引：索引是指元素在列表中的位置，从0开始计算

numList=[1,4,6,4,2,5,8,3]
print(numList[2]) # 从左到右，从0开始
print(numList[-1]) # -1表示最后一个

                      b）查询元素索引：index()方法

numList=[1,4,6,4,2,5,8,3]
print(numList.index(4)) #有就返回第一个索引
print(numList.index(34)) #没有就报错

                      c）切片：截取列表中的一段（顾头不顾尾）

numList=[1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4]
print(numList[2:5]) # 索引2到4的元素
print(numList[:3]) # 从左到索引2的位置
print(numList[2:]) # 从索引2到最后
print(numList[2:10:2]) #从2到9，步长为2

                       d）查询列表长度：len()函数

numList=[1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4]
print(len(numList))

                       e）查找最值：最大值max()函数 最小值min()函数

numList=[1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4]
print(max(numList))
print(min(numList))

                        f）成员函数in not in 判断元素在不在列表中

numList=[1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4]
print(2 in numList)
print(4 not in numList)

                   4）改

                         a）直接赋值

numList=[1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4]
numList[3]=123 #将索引3的元素改为123
print(numList)

                         b）列表反序：reverse()方法

numList=[1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4]
numList.reverse()
print(numList)

                          c）列表排序：sort()方法、sorted()函数

numList=[1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4]
numList.sort() # 直接将原列表排序
print(numList)
newList=sorted(numList) # 将列表元素排序，返回排序结果不改变原列表
print(numList)
print(newList)

知识点二：元组类型

           1.定义

<class 'tuple'>

              1）有序不可变容器数据类型

              2）用于存储多个不需要改变的数据，用法与列表类似，但是不可变

           2.方法

##元组是不可变类型，因此不能删改和添加 但是提取元组可以进行加法拼接

t1=(1,2,3)
t2=(2,3,4)
t3=t1+t2
print(t3)

##元组的查询方式跟列表相同

                1）索引：索引是指元素在元组中的位置，从0开始计算

numTuple=(1,4,6,4,2,5,8,3)
print(numTuple[2]) # 从左到右，从0开始
print(numTuple[-1]) # -1表示最后一个

                 2）查询元素索引：index()方法

numTuple=(1,4,6,4,2,5,8,3)
print(numTuple.index(4)) #有就返回第一个索引
print(numTuple.index(34)) #没有就报错

                 3）切片：截取列表中的一段（顾头不顾尾）

numTuple=(1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4)
print(numTuple[2:5]) # 索引2到4的元素
print(numTuple[:3]) # 从左到索引2的位置
print(numTuple[2:]) # 从索引2到最后
print(numTuple[2:10:2]) #从2到9，步长为2

                  4）查询列表长度：len()函数

numTuple=(1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4)
print(len(numTuple))

                   5）查找最值：最大值max()函数 最小值min()函数

numTuple=(1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4)
print(max(numTuple))
print(min(numTuple))

                    6）成员函数in not in 判断元素在不在元组中

numTuple=(1,4,6,4,2,5,8,3,4,2,34,32,3,765,46,4)
print(2 in numTuple)
print(4 not in numTuple)

##元组是不可变类型，通常情况下是不可以改变的，但是在某些特殊情况下，可以使用一些方法改变元组

                    7）将元组转换成列表进行更改、添加

numTuple=(1,2,3,4,5,6,7)
numList=list(numTuple) # 将元组转换成列表
numList.append(8) # 为列表添加元素
numTuple=tuple(numList) # 将列表转换成元组
print(numTuple)

                     8）元组内的列表是可以改变的

numTuple=(1,2,3,4,5,6,7,[1,2,3]) # 元组内包含列表
numTuple[7][1]='python' # 更改列表里面的元素
print(numTuple)

知识点三：字典类型

           1.定义

<class 'dict'>

             1）定义：存储多个键值对的无序可变容器型数据类型

             2）作用：以key:value键值对形式存储的数据。比如一个人的基本信息（姓名、年龄、家庭住址、学校等）

             3）在字典中键key必须是唯一的不可变类型，值value可以是任意数据类型

             4）因此字典中键key不可重复，值value可以重复

# 按照现实中字典去理解，键key理解为一个汉字，值value理解为这个汉字所在的页码
# 一个汉字只有一个页码（不考虑多音字），一个页码可以对应多个汉字
name_dict={'刘':33,'王':45,'章':53,'张':53,'李':43}
print(type(name_dict))

         2.方法

            1）增

                  a）直接赋值一个没有的键key即可

name_dic = {'刘': 33, '王': 45, '章': 53, '张': 53, '李': 43}
name_dic['赵']=55
print(name_dic)

             2）删

                   a）清空字典：clear()方法

name_dic = {'刘': 33, '王': 45, '章': 53, '张': 53, '李': 43}
name_dic.clear()
print(name_dic)

                   b）直接删除字典的键：del()函数

name_dic = {'刘': 33, '王': 45, '章': 53, '张': 53, '李': 43}
del(name_dic['王'])
print(name_dic)
# 删除键之后对应的值也就删除了

                   c）取出字典中键值对进行使用：pop()方法

name_dic = {'刘': 33, '王': 45, '章': 53, '张': 53, '李': 43}
name=name_dic.pop('刘')
print(name_dic)
print(name) # 删除字典中键值对，并返回键对应的值

                   d）取出字典展示的最后一对键值对：popitem()方法

name_dic = {'刘': 33, '王': 45, '章': 53, '张': 53, '李': 43}
name=name_dic.popitem() #取出最后一个键值对
print(name_dic)
print(name) # 返回键值对的元组

##注意：字典是无序类型，因此popitem()方法删除的是编译器展示顺序的最后一个，其实字典内部是没有先后顺序 的。

             3）查

                   a）按键查找值：直接查键

Simon={'name':'Simon','age':29,'height':175}
print(Simon['age']) # 有键就返回对应的值
print(Simon['weight']) # 无键就报错

                    b）按键查找值：get()方法

Simon={'name':'Simon','age':29,'height':175}
print(Simon.get('age')) # 有键就返回对应的值
print(Simon.get('weight')) # 无键就返回None

                     c）取出所有的键key：keys()方法

Simon={'name':'Simon','age':29,'height':175}
print(Simon.keys())

                       d）取出所有的值value：values()方法

Simon={'name':'Simon','age':29,'height':175}
print(Simon.values())

                        e）取出所有键值对：items()方法

Simon={'name':'Simon','age':29,'height':175}
print(Simon.items())

                          f）成员运算：in not in

Simon={'name':'Simon','age':29,'height':175}
print('name' in Simon)
print('hobby'not in Simon)

                    4）改

                          a）直接重新赋值

Simon={'name':'Simon','age':29,'height':175}
Simon['age']=30
print(Simon)

                          b）更新字典：update()方法

Simon={'name':'Simon','age':29,'height':175}
other={'hobby':'python','address':'JiangSu'}
Simon2={'age':30,'height':175}
Simon.update(other) # 原字典没有的键，直接添加进去
print(Simon)
Simon.update(Simon2)# 原字典已有的键，修改新的值
print(Simon)

                          c）设置默认值：setdefault()方法

Simon={'name':'Simon','age':29,'height':175}
hobby=Simon.setdefault('hobby','python') # 原字典没有的键，直接添加进去，返回新值
print(Simon,hobby)
name=Simon.setdefault('name','Andy') # 原字典已有的键,不改变原值，返回原值
print(Simon,name)

知识点四：集合类型

           1.定义

<class 'set'>

             1） 无序不重复可变类型数据

             2）作用：常用作关系运算

name_set={'Simon','Andy','Mark','Eric','Jackie'}
# 集合中元素不能重复且都为不可变类型

          2.方法

             1）增

name_set={'Simon','Andy','Mark','Eric','Jackie'}
name_set.add('James')
print(name_set)

             2）删

                   a）删除展示出来的第一个：pop()方法

name_set={'Simon','Andy','Mark','Eric','Jackie'}
print(name_set)
name_set.pop()
print(name_set)

        ##注意：由于每次展示的集合顺序都不一样，因此pop()删除的对象是不确定的  

                   b）指定元素删除：remove()方法

name_set={'Simon','Andy','Mark','Eric','Jackie'}
print(name_set)
name_set.remove('Andy')
print(name_set)

              3）改

name_set={'Simon','Andy','Mark','Eric','Jackie'}
name_set.update(['Simon','Coco'])
print(name_set)

        3.关系运算

           1）交集

set1={1,2,3,4,5,6,7,8}
set2={4,5,6,7,8,9,10}
print(set1&set2) # 得到两个集合共同部分

          2）并集

set1={1,2,3,4,5,6,7,8}
set2={4,5,6,7,8,9,10}
print(set1|set2) # 得到两个集合全部数据（去重）

         3）差集

set1={1,2,3,4,5,6,7,8}
set2={4,5,6,7,8,9,10}
print(set1-set2) # 除去set1与set2重复的数据后，set1剩余的数据

         4）去重作用

##因为集合可以进行关系运算，因此可以用来进行列表去重操作

##缺点：无法保证原数据的顺序、原数据必须全为不可变类型才可以

l=[1,2,4,5,34,21,2,1,5,4,2,1,1,3,4,5,6,3,2,3]
s=set(l)
l=list(s)
print(l)