列表、元祖、字典、集合

列表、元祖、字典、集合
    列表创建和删除
        创建
            listname = [element1、element2、elementn]         
            tuplename = (element1、element2、elementn)
            dictionaryname = {'key1':'value1','key2':'value2','keyn':'valuen'}
            setname = {element1、element2、elementn}     # 不重复的元素，无序可变序列
            setname = set(iterable) # iterable转换为集合的可迭代对象
              
            
            
            emptylist = [] 
            emptytuple = ()
            dictionary = {}
            dictionary = dict()  
            setname = set()   # 创建空集合
            
            # dict() 方法可以创建一个空字典，还可以通过已用数据快速创建字典
                dictionary = dict(zip(list1,list2))  # zip() 多个列表或元祖对应位置的元素组合为元祖，返回包含这些内容的zip对象    [zɪp]
                                                       如果长度不同，与最短的列表长度相同
                                                       可以将zip对象转换为字典，列表，元祖
                dictionary = dict(list1=value1,list2=value2,list3=value3)
                dictionary = dict(list1=value1,list2=value2,list3=value3)
                dictionary = dict.fromkeys(list1)
                
                tuplename = ('')  listname =['']  dictionary = {tuplename:listname}
                
            
            list(data)  # 创建数值列表，可以是range对象、字符串、元祖或者其他可迭代的对象
            tuple(data) # 创建数值元祖，可以是range对象、字符串、元祖或者其他可迭代的对象
        
        删除
            del listname
            del tuplename
            del dictionary
            del setname
            
        
    访问
        print(listname)
        print(tuplename)
        print(dictionary)
        
        print(listname[index,slicing])
        print(tuplename[index,slicing])
        print(dictionary[key])        # 根据指定的键得到相应的结果
        dictionary.get(key[,default]  # get()方法取得指定键的值    default 当指定的键不存在时，返回一个默认值，如果省略，则返回None
    
    
    遍历
        for item in listname                          [ˈaɪtəm]
        for item in tuplename   
            # 输出item
        dictionary.item()        # item()方法可以获取字典的"键-值对"元祖列表
        for item in dictionary.item()    # 遍历该元祖列表，得到的是元祖中的各个元素
        
        
        for index,item in enumerate(listname)         [ˈɪndeks]   [ɪˈnjuːməreɪt] 
        for index,item in enumerate(tuplename)
            # 输出index ,item 
        for key,value in dictionary.item()     # 获取到具体的每个键和值  另外还有values()keys()方法，返回字典的“值”和“键”列表、元祖、字典、集合
        
    
    
    
    
    添加、修改和删除元素    （加号两个相同类型的序列连接
        添加元素
            listname.append(obj)           # 添加到末尾的对象                 [əˈpend]
            listname.insert(obj)           # 向列表的指定位置插入元素         [ɪnˈsɜːt]
            listname.extend(seq)           # 把seq 这个列表中的全部元素添加到listname后面 [ɪkˈstend]
            dictionary[key]=vaule          # 键与存在的键不重复时，变成添加
            setname.add(element)           # 只能使用字符串、数字及布尔类型的True或者False,不能使用列表、元祖等可迭代对象
        
            
        列表修改元素
            listname[index]= ''            # 通过索引获取该元素，然后再为其重新赋值即可
        元祖修改元素
            tuplename = ('1',)             # 元祖只有一个元素后，元素的后面加一个','
            tuplename = ('2',)
        字典修改元素
            dictionary[key]=vaule          #  键与存在的键重复时，“值”进行替换，相当于修改字典的元素
            
            
        删除元素
            del listname[index]            # 通过索引删除
            listname.remove(element)       # 删除一个不确定其位置的元素                    [rɪˈmuːv]
            元祖为不可变序列，不可以删除元祖里的元素
            del dictionary[key]
            dictionary.clear()             # clear()方法清除全部元素，变成空字典
            dictionary.pop()               # pop()删除并返回指定"键"的元素
            dictionary.popitem()           # popitem() 删除并返回一个字典中的元素   
            setname.remove(element)        # 移除指定元素
            setname.pop()                  # 移除一个元素
            setname.clear()                # 清空集合
            
            
            
    
    
    对列表进行统计计算
        listname.count(obj)                # obj 该对象的次数  精确匹配
        listname.index(obj)                # obj 指定元素在列表中首次出现的位置 精确匹配
        sum(iterable[,start])              # 统计数值列表中各元素的和   iterable  要统计的列表
    
    对列表进行排序
        listname.sort(key = None,reverse=False)     # key = str.lower 不缺分大小写 否则先对大写排序  ，默认升序  False 则表示为升序，True 则表示为降序[sɔːt]
    
    使用内置的sorted()
        sorted(iterable,key = None,reverse=False)   # 会建立一个原列表的副本
    
    列表推导式
        import random    # 引入标准库               [ˈrændəm]
        list = [Expression for var in range]      # 生成指定范围的数值列表                     [ɪkˈspreʃn]
        randomlist = [random.randint(10,100 for i in range(1,5)]
        
        newlist = [Expression for var in list]    # 根据列表生成指定需求的列表  
        newlist = [Expression for var in list if condition]
        
    
    元祖推导式
        import random
        randomnumber = (Expression for var in range)  # 生成的结果是一个生成器对象
        randomnumber = (random.randint(10,100 for i in range(1,5))
        
        randomnumber = tuple()         #  转换为元祖
            遍历之后，原生成器对象不存在，再使用该生成器对象，都必须重新创建一个生成器对象
                _next__()     # __next__()进行遍历
                for 循环       # for循环进行遍历
    
    
    字典推导式
        import random
        randomdict = {i:random.randint(10,100 for i in range(1,5)}
        
        list1 = []
        list2 = []

        
        
    生成二维列表
     
     
    集合的交集、并集和差集运算
        交集            &    setname1 & setname2
        并集            |    setname1 | setname2
        差集            -    setname1 - setname2
        对称差集运算    ^    setname1 ^  setname2