精华内容
下载资源
问答
  • python中列表 元组 字典 集合的区别

    千次阅读 2018-12-14 10:23:23
    列表 元组 集合 字典 英文 list tuple set dict 定义 定义[],数据之间使用,分割 定义(),数据之间用,分割 定义用 {} 或 set() 字典的每个键值 key=>value 对用冒号 ...
     列表元组集合字典
    英文listtuplesetdict
    定义定义[],数据之间使用,分割定义(),数据之间用,分割定义用 {} 或 set()字典的每个键值 key=>value 对用冒号 : 分割,每个键值对之间用逗号 , 分割
    是否可读写读写只读读写读写
    可否重复
    数据类型任意类型对象任意类型对象任意类型对象任意类型对象
    存储方式键(不能重复)键值对(键不能重复)
    是否有序有序有序无序无序,自动正序
    初始化[1,'a'](1,'a'){1,2}{'a':1,'b':'kk'}
    空值的定义[] 或者 list()()或 tuple()set(){}或者dict()
    支持的操作索引,切片,合同,删除,修改索引

    S | T 并   S - T 差

    S & T 交  S ^ T 补

    S <= T 或 S < T

    S >= T 或 S > T

    S |= T 并

    S &= T 交

    S ^= T 补

    增、删、改、查

    key in d:键值key是否在d中,是返回True,否则返回False。

    读取通过偏移读取 通过偏移读取 S.pop()随机返回S的一个元素,更新S,若S为空产生KeyError异常

    通过键而不是偏移量来读取 

    查 get(),setdefault(),has_key()

    通过dict提供的get()方法,如果key不存在,可以返回None,或者自己指定的value

    d[k]:返回关键字对于的值

    添加

    append(object)函数 向列表中追加据,

    会把添加的数据放在列表中的最后一个位置

    insert(index,object)函数 向列表中插入一条数据

    extend(iterable)函数  可以将另外一个列表中的数据添加到该表中

                 iterable:可迭代对象  列表、字符串、字典、元组

    不能修改S.add(x) 如果x不在集合S中,将x增加到Sd['sex'] = 'man'
    修改

    列表[索引]=数据 classname[1]='new'

    index(object:数据, start:开始搜索的位置,stop:结束搜索的位置) 

    不能修改集合元素不可更改d['Age'] = 8;
    删除

    pop删除末尾元素 classname.pop()

    pop删除指定元素pop(i) classname.pop(1)

    del list_1[4]

    使用remove(object)函数,根据数据内容删除  要删除的内容必须在列表中,否则会报错

    移除列表中所有的数据

    list_1.clear()

    不能修改

    S.discard(x)移除S中元素x,如果x不在集合S中,不报错

    S.remove(x)移除S中元素x,如果x不在集合S中,产生KeyError异常

    S.clear()移除S中所有元素

     

    删 pop()
    '''通过指定的key值,删除字典的一个键值对
    返回被删除的key对应的value

    del dict['Name']; # 删除键是'Name'的条目
    dict.clear();     # 清空词典所有条目
    del dict ;        # 删除词典

    排序

    升序  列表.sort()

    降序 列表.sort(reverse=True)

    倒序,反转 列表.reverse()

    不能修改
    统计

    len(列表) 列表的长度

    列表.count(数据)  数据在列表中出现的次数

    len(元组) 元组的长度

    列表.count(数据)  数据在元组中出现的次数

    len(S)返回集合S的元素个数

    len():返回字典中键—值对的数量

     

    应用场景

    1、列表存储相同类型的数据
    2、通过迭代遍历,在循环内部,

    针对列表中的每一项元素,执行相同的操作

     

    1.查找和插入的时间随着元素的增加而增加 
    2.占用空间小,浪费内存很少 
    所以,dict是用空间来换取时间的一种方法

    1、函数的参数和返回值,一个函数可以接收任意多个参数,一次返回多个数据
    2、格式字符串,格式化字符串后面的()本质就是一个元组
    3、让列表不可以被修改(保护数据安全)

     

    1.比列表操作速度快 
    2.对数据“写保护“ 
    3.可用于字符串格式化中 
    4.可作为字典的key

    包含关系比较

    x in S 判断S中元素x, x在集合S中,返回True,否则返回False

    x not in s

    数据去重:集合类型所有元素无重复

    set(x)将其他类型变量x转变为集合类型

     

    zip函数可以实现两个类别组合成字典

    1.查找和插入的速度极快,不会随着key的增加而增加 
    2.需要占用大量的内存,内存浪费多 

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    序列 : 序列是一个基类类型   可以衍生为字符串类型、元组类型、列表类型

    通用操作符: x in s 如果x是序列s的元素,返回True,否则返回False

                          x not in s 如果x是序列s的元素,返回False,否则返回True

                         s + t 连接两个序列s和t

                         s*n 或 n*s 将序列s复制n次

                        s[i] 索引,返回s中的第i个元素, i是序列的序号

                      s[i: j] 或 s[i: j: k] 切片,返回序列s中第i到j以k为步长的元素子序列

    通用方法和函数: len(s) 返回序列s的长度,即元素个数

                               min(s) 返回序列s的最小元素, s中元素需要可比较

                               max(s) 返回序列s的最大元素, s中元素需要可比较

                                s.index(x) 或
                                 s.index(x, i, j) 返回序列s从i开始到j位置中第一次出现元素x的位置

                                s.count(x) 返回序列s中出现x的总次数

     

    如有疑问或者不对的地方,欢迎留言评论

    展开全文
  • python3中列表 元组 字典 集合的区别

    千次阅读 2017-08-16 19:53:29
    python中列表元组字典集合的区别   列表:清单可重复,类型可不同 list 元组: 类似列表不可修改类型 tuple 集合:就是我们数学学的集合应用是去重 set 字典:字典存储键值对数据价值是查询,通过键,查找值 dict ...


       

    列表:清单可重复,类型可不同 list

    元组: 类似列表不可修改类型  tuple

    集合:就是我们数学学的集合应用是去重 set

    字典:字典存储键值对数据价值是查询,通过键,查找值 dict

     

     

    列表元组字典集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。

        1)列表

        什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单。比如,统计过去一周我们买过的东西,把这些东西列出来,就是清单。由于我们买一种东西可能不止一次,所以清单中是允许有重复项的。如果我们扩大清单的范围,统计我们过去一周所有的花费情况,那么这也是一个清单,但这个清单里会有类别不同的项,比如我们买东西是一种花费,交水电费也是一种花费,这些项的类型是可以使不同的python的列表个跟清单的道理是一样的,特点就是:可重复,类型可不同。类型不同也是跟数组最本质的区别了。python里的列表用“[]”表示:  

    lst = ['arwen',123]
    print lst[0] 
    print lst[1]

    lst[0] = 'weiwen'

      向list中添加项有两种方法:appendextendappend

      (2)元组

      元组和列表在结构上没有什么区别,唯一的差异在于元组是只读的,不能修改。元组用“()”表示,如:

    tup =('arwen',123)
    print tup[0]   可以用切片的方法读取(切片是指顺序)
    print tup[1]   而可不可以修改是指能不能重新赋值

      (3)集合就是我们数学学的集合,没有什么特殊的定义。集合最好的应用是去重。集合没有特殊的表示方法,而是通过一个set函数转换成集合,如:

    lst = [ 1, 1, 0]

    lst_set = set( lst )  #lst_set 1 , 0

    tup = (2, 2, 1)

    tup_set = set( tup) # tup_set2 , 1

    for item in lst_set:

    print item

      (4)最后一个是字典。字典存储键值对数据,如:

    {1:a,2:b,3:c}

      字典最外面用大括号,每一组用冒号连起来,然后各组用逗号隔开。

      字典最大的价值是查询,通过键,查找值。

     

    展开全文
  • 密码字典集合

    2013-09-13 09:58:03
    密码字典集合
  • Python数据结构列表字典集合元组详细解析 列表 基本操作函数 迭代操作 列表加深学习 字典和元组交互 元组 基本操作函数 集合 基本操作函数 字典 基本操作函数 字典加深学习 列表元组集合字典相互转换 列表...

    Python数据结构(列表、字典、集合、元组)详细解析

    列表

    1.列表是Python中使用最频繁的数据类型
    2.列表可以完成大多数集合类的数据结构实现。
    3.列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)
    4.和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表
    5.List内置了有很多方法,例如append()、pop()等等
    6.List可以使用+操作符进行拼接
    7.[注意]与Python字符串不一样的是,列表中的元素是可以改变的

    基本操作函数

    1.索引,切片,加,乘,检查成员
    2.增加、删除、连接分割、排序倒序

    list1=[1,2,3.0,4,5.0]
    list2=['6','7','8','8','8']
    list3=['One','Two','Three']
    list4=[1,2,3]
    print(len(list1))
    print(list2.count('8'))
    print(list1[0])
    print(list1[-1])
    print(list1[1:3])
    print(list1[1:])
    print(list1*2)
    print(list1+list2)
    
    if(1 in list1):
        print("1在列表list1中")
    
    print('list1中最大元素对应下标为{0}'.format(list1.index(max(list1))))
    print([list1,list2,list3])
    ##增加
    list1.append(6)
    list1.insert(2,2.5)
    list1.extend([7,8])
    print(list1)
    ##减小
    del list1[2],list1[5]
    list1.remove(7) #删除具体的值
    pop_value=list1.pop(5)
    print('pop_value={0}'.format(pop_value))
    print(list1)
    ##连接与分割
    join_list='--'.join(list2)  #join只能了解全是字符串的列表
    print(join_list)
    split_list=join_list.split('--',2)  #最后一个数字代表分割的次数,如果想全部分割则使用-1(默认)
    print(split_list)
    
    list1.reverse() #反向
    print(list1)
    list1.sort()    #排序
    print(list1)
    
    list_copy=list1.copy() 返回列表的浅复制,等于a[:]
    5
    3
    1
    5.0
    [2, 3.0]
    [2, 3.0, 4, 5.0]
    [1, 2, 3.0, 4, 5.0, 1, 2, 3.0, 4, 5.0]
    [1, 2, 3.0, 4, 5.0, '6', '7', '8', '8', '8']
    1在列表list1中
    list1中最大元素对应下标为4
    [[1, 2, 3.0, 4, 5.0], ['6', '7', '8', '8', '8'], ['One', 'Two', 'Three']]
    [1, 2, 2.5, 3.0, 4, 5.0, 6, 7, 8]
    pop_value=8
    [1, 2, 3.0, 4, 5.0]
    6--7--8--8--8
    ['6', '7', '8--8--8']
    [5.0, 4, 3.0, 2, 1]
    [1, 2, 3.0, 4, 5.0]
    

    迭代操作

    1.zip两个列表操作
    2.list映射解析
    3.创建二维列表

    for q,a in zip(list3,list4):
        print('{0}:{1}'.format(q,a))
        print('%s:%s'%(q,a))
    
    print([elem*2 for elem in list1]) #list 的映射解析
    print([[x, x**2] for x in list1])
    
    def _add_str(str):
        return str+'_add'
    print([_add_str(add_str) for add_str in list2])
    
    list_filter=[elem for elem in list1 if elem !=2]
    print(list_filter)
    
    list5=['One','Two','Three']
    list6=[1,2,3]
    print(["{0}-{1}".format(x,y) for x in list5 for y in list6])
    
    print(["{0}-{1}".format(list5[i],list6[i]) for i in range(len(list5))])
    
    print([str(i) for i in range(1, 6)])
    
    for i, v in enumerate(['tic', 'tac', 'toe']):
        print(i, v,end=";")
    print('')
    for i in reversed(range(1, 10, 2)):
        print(i,end=';')
    print('')
    for i in sorted(range(1, 10, 2)):
        print(i,end=';')
    print('')   
    print([i for i in range(4)])
    
    a = (i for i in range(4))
    print(next(a))
    print(next(a))
    One:1
    One:1
    Two:2
    Two:2
    Three:3
    Three:3
    [2, 4, 6.0, 8, 10.0]
    [[1, 1], [2, 4], [3.0, 9.0], [4, 16], [5.0, 25.0]]
    ['6_add', '7_add', '8_add', '8_add', '8_add']
    [1, 3.0, 4, 5.0]
    ['One-1', 'One-2', 'One-3', 'Two-1', 'Two-2', 'Two-3', 'Three-1', 'Three-2', 'Three-3']
    ['One-1', 'Two-2', 'Three-3']
    ['1', '2', '3', '4', '5']
    0 tic;1 tac;2 toe;
    9;7;5;3;1;
    1;3;5;7;9;
    [0, 1, 2, 3]
    0
    1
    

    列表加深学习

    列表推导式的执行顺序:各语句之间是嵌套关系,左边第二个语句是最外层,依次往右进一层,左边#第一条语句是最后一层
    [x*y for x in range[1,5] if x > 2 for y in range[1,4] if x < 3]
    他的执行顺序是
    for x in range[1,5]
    #if x > 2
    #for y in range[1,4]
    #if x < 3
    #x*y

    matrix = [
    ...     [1, 2, 3, 4],
    ...     [5, 6, 7, 8],
    ...     [9, 10, 11, 12],
    ... ]
    print(matrix)
    print([[row[i] for row in matrix] for i in range(4)])
    transposed = []
    for i in range(4):
        transposed.append([row[i] for row in matrix])
    print(transposed)
    
    #创建二维列表格式:list_2d = [[0 for col in range(cols)] for row in range(rows)]
    list_2d = [ [0 for i in range(5)] for i in range(5)]  #创建
    print(list_2d)
    list_2d[0].append(3)
    list_2d[0].append(5)
    print(list_2d)
    
    
    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
    [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
    [[0, 0, 0, 0, 0, 3, 5], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
    

    字典和元组交互

    ##列表与字典
    params_dict={'One':1,'Two':2,'Three':3}
    list_parse_dict=['%s=%s'%(k,v) for k,v in params_dict.items()]
    print(list_parse_dict)
    ##列表与元组
    tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 ) #元组
    tuple_to_list=list(tuple)
    print(tuple_to_list)
    ['One=1', 'Two=2', 'Three=3']
    ['abcd', 786, 2.23, 'runoob', 70.2]
    

    元组

    元组与列表的区别,元组它的关键是不可变性,元组提供了一种完整的约束。
    1.[注意]元组(tuple)与列表类似,不同之处在于元组的元素不能修改
    2.元组写在小括号(())里,元素之间用逗号隔开
    3.元组中的元素值是不允许修改的,但我们可以对元组进行连接组合
    4.函数的返回值一般为一个。而函数返回多个值的时候,是以元组的方式返回的

    基本操作函数

    tuple1 = ( '1', 'a' , 2.0, 'b', 3 )
    #索引操作与列表一致
    tuple0 = ()    # 空元组
    tuple2 = (20,) # 一个元素,需要在元素后添加逗号
    ('abcd', 786, 2.23, 'runoob', 70.2)
    

    集合

    集合(set)是一个无序不重复元素的序列。基本功能是进行成员关系测试和删除重复元素
    1.可以使用大括号{}或者set()函数创建集合,注意:创建一个空集合必须用 set() 而不是{},因为{}是用来创建一个空字典

    基本操作函数

    set1 = {'One', 'One', 'Two', 'Two', 'Three', 'Four','Five'}
    print(set1) #输出集合,重复的元素被自动去掉
    if('One' in set1) :
        print('One在集合set1中')
    #集合运算
    set2=set('abracadabra')
    set3=set('alacazam')
    print(set2)
    print(set2 - set3) # a和b的差集
    print(set2 | set3) # a和b的并集
    print(set2 & set3) # a和b的交集
    print(set2 ^ set3) # a和b中不同时存在的元素
    
    
    {'Two', 'One', 'Four', 'Five', 'Three'}
    One在集合set1中
    {'c', 'd', 'r', 'a', 'b'}
    {'b', 'd', 'r'}
    {'c', 'd', 'l', 'r', 'm', 'z', 'a', 'b'}
    {'c', 'a'}
    {'d', 'b', 'm', 'l', 'z', 'r'}
    {'c', 'd', 'r', 'a', 'b'}
    

    字典

    d = {key1 : value1, key2 : value2 }
    1.字典是无序的对象集合,列表是有序的对象结合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
    2.键(key)必须使用不可变类型。
    3.管字典中有多少项,in操作符花费的时间都差不多
    def example(d):
    for c in d:
    print(c)
    其中:d 是一个字典对象

    基本操作函数

    dict = {}
    dict['One'] = 1
    dict[2] = 'Two'
    dict['Three']=3
    dict['Five']=5
    dict2={'ONE':1, 'TWO':2, 'THREE': 3}
    
    print(dict)
    print(dict2)
    del dict['Five']
    print(dict)
    
    print(dict['One'])
    print(dict.keys())
    print(dict.values())
    for k,v in dict2.items():
        print(k,":",v)
    dict.clear() #清空字典
    del dict #删除字典
    type(dict2)
    
    dict_pop_key,dcit_pop_value=dict2.popitem()
    print('pop-{0}:{1}'.format(dict_pop_key,dcit_pop_value))#随机返回并删除字典中的一对键和值(一般删除末尾对)
    for k, v in dict2.items():
        print(k, v,end=";")
    
    
    dict4={2:'Two',3:'Three',1:'One'}
    sorted(dict4.keys())
    
    {'One': 1, 2: 'Two', 'Three': 3, 'Five': 5}
    {'ONE': 1, 'TWO': 2, 'THREE': 3}
    {'One': 1, 2: 'Two', 'Three': 3}
    1
    dict_keys(['One', 2, 'Three'])
    dict_values([1, 'Two', 3])
    ONE : 1
    TWO : 2
    THREE : 3
    pop-THREE:3
    ONE 1;TWO 2;
    
    
    
    
    [1, 2, 3]
    

    字典加深学习

    #字典是支持无限极嵌套的
    citys={
        '北京':{
            '朝阳':['国贸','CBD','天阶','我爱我家','链接地产'],
            '海淀':['圆明园','苏州街','中关村','北京大学'],
            '昌平':['沙河','南口','小汤山',],
            '怀柔':['桃花','梅花','大山'],
            '密云':['密云A','密云B','密云C']
        },
        '河北':{
            '石家庄':['石家庄A','石家庄B','石家庄C','石家庄D','石家庄E'],
            '张家口':['张家口A','张家口B','张家口C'],
            '承德':['承德A','承德B','承德C','承德D']
        }
    }
    for i in citys['北京']:
        print(i)
    print('-----------------------')
    for i in citys['北京']['海淀']:
        print(i)
    朝阳
    海淀
    昌平
    怀柔
    密云
    -----------------------
    圆明园
    苏州街
    中关村
    北京大学
    

    列表、元组、集合、字典相互转换

    列表元组转其他

    ###列表转集合(去重)
    list1 = [1,2,3,4]
    print(set(list1))
    #两个列表转字典
    list1 = ['key1','key2','key3']
    list2 = ['1','2','3']
    print(dict(zip(list1,list2)))
    #嵌套列表转字典
    list3 = [['key1','value1'],['key2','value2'],['key3','value3']]
    print(dict(list3))
    # 列表、元组转字符串
    list2 = ['a', 'a', 'b']
    print(''.join(list2))
    tup1 = ('a', 'a', 'b')
    print(''.join(tup1))
    {1, 2, 3, 4}
    {'key1': '1', 'key2': '2', 'key3': '3'}
    {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
    aab
    aab
    

    字典转其他

    # 字典key和value互转
    dic2 = {'a': 1, 'b': 2, 'c': 3}
    print({value:key for key, value in dic2.items()})
    {1: 'a', 2: 'b', 3: 'c'}
    

    字符串转其他

    # 字符串转列表
    s = 'aabbcc'
    print(list(s))
    # 字符串转元组
    print(tuple(s))
    # 字符串转集合
    print(set(s))
    # 字符串转字典
    dic = eval("{'name':'ljq', 'age':24}")
    print(dic)
    # 切分字符串
    a = 'a b c'
    a.split(' ')
    
    ['a', 'a', 'b', 'b', 'c', 'c']
    ('a', 'a', 'b', 'b', 'c', 'c')
    {'b', 'a', 'c'}
    {'name': 'ljq', 'age': 24}
    
    
    
    
    
    ['a', 'b', 'c']
    

    辛苦总结:),第一次写博客。如果写的好,请支持我下面的资源

    pycharm工程python调用OpenCV实现USB摄像头实时人脸检测
    http://download.csdn.net/download/zou19900101/10208407
    pycharm工程pyQt5使用matplotlib绘图源码
    http://download.csdn.net/download/zou19900101/10207077
    pyqt5快速入门教程
    http://download.csdn.net/download/zou19900101/10197371
    Qt编写高逼格弹幕
    http://download.csdn.net/download/zou19900101/10145524
    Qt高仿360界面设计
    http://download.csdn.net/download/zou19900101/10145518
    Qt编写跨平台串口通信(Window+Linux)
    http://download.csdn.net/download/zou19900101/10145513
    OpenCV两种方法显示中文
    http://download.csdn.net/download/zou19900101/10010181
    wrote by zoushaoyuan 2018-01-19

    展开全文
  • python字符串, 列表, 字典, 集合方法说明
  • 列表 元组 集合字典区别与函数用法

    千次阅读 2019-09-25 15:31:25
    理解Python中列表,元组,字典集合的区别 列表,元组,字典集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。 1.列表(List) 什么是列表呢?我觉得列表就是...

    理解Python中列表,元组,字典,集合的区别

    列表,元组,字典,集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。

    1.列表(List)

    什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单。比如,统计过去一周我们买过的东西,把这些东西列出来,就是清单。
    由于我们买一种东西可能不止一次,所以清单中是允许有重复项的。如果我们扩大清单的范围,统计我们过去一周所有的花费情况,
    那么这也是一个清单,但这个清单里会有类别不同的项,比如我们买东西是一种花费,交水电费也是一种花费,这些项的类型是可以使不同的。
    python的列表个跟清单的道理是一样的,特点就是:可重复,类型可不同。类型不同也是跟数组最本质的区别了。python里的列表用“[]”表示。

    #定义一个列表
    listA = [‘a’, ‘b’, ‘c’, 1, 2]

    listA[1] # ‘b’

    向 list 中增加元素

    1.使用append 向list 的末尾追加单个元素。(把列表当做堆栈使用——后进(后出))

    #listA = [‘a’, ‘b’, ‘c’, 1, 2, 3]
    listA.append(3)

    2.使用 insert 将单个元素插入到list 中。数值参数是插入点的索引

    在下标为3处插入一个元素,listA = [‘a’, ‘b’, ‘c’, ‘d’, 1, 2, 3]

    listA.insert(3, ‘d’)

    3.使用 extend 用来连接 list

    listA = [‘a’, ‘b’, ‘c’, ‘d’, 1, 2, 3, 7, 8]

    listA.extend([7, 8])

    获取列表的长度

    print len(listA) # 9

    在 list 中搜索

    listA.index(3) # index 在 list 中查找一个值的首次出现并返回索引值。
    listA.index(‘100’) # 如果在 list 中没有找到值,Python 会引发一个异常。

    print 5 in listA # 要测试一个值是否在 list 内,使用 in。如果值存在,它返回 True,否则返为 False 。

    从 list 中删除元素

    listA.remove(3) # remove 从 list 中 仅仅 删除一个值的首次出现。如果在 list 中没有找到值,Python 会引发一个异常

    print listA.pop() # pop 它会做两件事:删除 list 的最后一个元素,然后返回删除元素的值。(把列表当做堆栈使用——(后进)后出)

    还有一种把列表当做队列使用,最先进入的元素最先释放(先进先出)

    不过,列表这样用效率不高。相对来说从列表末尾添加和弹出很快;

    在头部插入和弹出很慢(因为,为了一个元素,要移动整个列表中的所有元素)。

    遍历list

    for item in listA:
    print item

    extend (扩展) 与 append (追加) 的看起来类似,但实际上完全不同。

    extend 接受一个参数,这个参数总是一个 list,并且把这个 list 中的每个元素添加到原 list 中。
    append 接受一个参数,这个参数可以是任何数据类型,并且简单地追加到 list 的尾部。

    2.元组(Tuple)

    元组和列表在结构上没有什么区别,唯一的差异在于元组是只读的,不能修改。元组用“()”表示

    #定义一个元组
    tuple1 = (1,2,‘a’,4,‘5’,6)

    定义了一个元组之后就无法再添加或修改元组中的元素

    print tuple1[2] # ‘a’ 元组的元素都有确定的顺序。元组的索引也是以0为基点的
    print tuple1[-1] # ‘5’ 负的索引从元组的尾部开始计数
    print tuple1[1:3] # (2, ‘a’) 元组也可以进行切片操作。对元组切片可以得到(返回)新的元组,原元组不变

    可以使用 in 运算符检查某元素是否存在于元组中。

    print 1 in tuple1 # True

    #使用for in 进行遍历元组
    for item in tuple1:
    print item

    如果需要获取item的序号 可以使用下面的遍历方法:

    for index in range(len(tuple1)): #range(len(tuple1))就是生成一个自然排序列表
    print tuple1[index]

    还可以使用内置的enumerate函数

    for index, item in enumerate(tuple1):
    print ‘%i, %s’ % (index, item)

    3.字典(Dictionary)

    字典定义了键和值之间一对一的关系,但它们是以无序的方式储存的。 Python 中的 dictionary 像 Java 中的 Hashtable 类的实例。定义 Dictionary 使用一对大(花)括号” { } “

    Dictionary 不只是用于存储字符串。Dictionary 的值可以是任意数据类型,包括字符串、整数、对象,甚至其它的 dictionary。
    在单个 dictionary 里,dictionary 的值并不需要全都是同一数据类型,可以根据需要混用和匹配。

    定义一个字典

    dict1 = {‘name’ : ‘yeoman’, ‘age’ : 24, ‘sex’ : ‘Male’}

    dict1[‘name’] = ‘yuanm’ # 为一个已经存在的 dictionary key 赋值,将简单覆盖原有的值。
    dict1[‘Age’] = 25 # 在 Python 中是区分大小写的 age和Age是完全不同的两个key

    从字典中删除元素

    del dict1[‘sex’] # del 允许您使用 key 从一个 dictionary 中删除独立的元素

    dict1.clear() # clear 从一个 dictionary 中清除所有元素

    4.集合(Set)

    Python的集合(set)和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素.
    集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.由于集合是无序的,所以,sets 不支持 索引, 分片, 或其它类序列(sequence-like)的操作。

    集合也存在不可变形式,frozenset为固定集合.
    set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。
    注意:想要创建空集合,你必须使用 set() 而不是 {} ,后者用于创建空字典
    可以通过一个set函数转换成集合,如:

    lst = [ 1, 1, 0]

    lst_set = set( lst ) #lst_set 为1 , 0

    tup = (2, 2, 1)

    tup_set = set( tup) # tup_set为2 , 1

    for item in lst_set:
    print item

    使用 set 函数创建集合

    list1 = [6, 7, 7, 8, 8, 9]
    set2 = set(list1)

    set2.add(10) # 添加新元素
    print set2 # set([8, 9, 10, 6, 7]) 去掉重复内容,而且是无序的

    set3 = frozenset(list1)
    #set3.add(10) # 固定集合不能添加元素,会报错AttributeError: ‘frozenset’ object has no attribute ‘add’

    集合有并集,交集,求差操作

    a & b 并集:intersection() 方法返回一个新集合,包含在两个集合中同时出现的所有元素。

    a | b 交集:union() 方法返回一个新集合,包含在两个 集合中出现的元素。

    a - b 差集:difference() 方法返回的新集合中,包含所有在 集合A出现但未在集合B中的元素。

    a ^ b 对称差集:symmetric_difference() 方法返回一个新集合,包含所有只在其中一个集合中出现的元素。

    删除元素

    set2.discard(6) # 当元素不存在时,不会引发异常
    set2.remove(6) # 与discard的区别在于,如果没有要删除的元素,remove会引发一个异常
    set2.pop() # 因为set是无序的,所以pop会随机的从set中删除一个元素

    展开全文
  • 今天小编就为大家分享一篇python 列表字典集合的添加和删除操作,有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Python3.9字典集合.pptx

    2021-05-03 21:33:05
    Python3.9字典集合.pptx
  • 常用字典密码集合常用字典密码集合常用字典密码集合
  • 老男孩 Python 自动化开发 02 Python数据结构 列表 元组 字典 集合 共16页.rar
  • 如有错误,欢迎留言指出讨论 1 列表特点: 1) 有序的,写进去什么顺序输出还是什么顺序,也可排序 2) 可以修改 ...3 字典特点: 1) 没有下标,是键值对形式的,查找速度快 2) 无序的 3) 键是...
  • 说完列表字典,说完字典集合,滚雪球学 Python

    千次阅读 多人点赞 2021-02-27 22:24:39
    列表、元组、字典集合,学Python一个都离不了
  • 详解元组、列表字典集合<一>

    千次阅读 2018-01-10 14:25:22
    列表 字典 集合 一、元组(tuple) 1.元组的创建(可以把元组看作一个容器,任何数据类型都可以放在里面) 通过赋值方法创建元组 In [5]: t = ("hello",2.3,2,True,{1:"hello",2:"world"},)In [6]: type(t) Out[6]: ...
  • 文章目录列表列表更新元素列表增加元素列表删除元素列表的其他操作元组删除元组元组的其他操作字典字典删除元素字典的其他操作集合集合添加元素集合删除元素其他操作 列表 创建一个列表,只要把逗号分隔的不同的数据...
  • 常用密码字典集合,1000w+个密码字典集合
  • 无线密码破解字典集合,经典ap无线破解wap2字典结合
  • 在Python中有四种内建的数据结构——列表、元组和字典集合。我们将会学习如何使用它们,以及它们如何使编程变得简单 一、列表list 是处理一组有序项目的数据结构,即你可以在一个列表中存储一个 序列 ...
  • 下面小编就为大家带来一篇关于Python元祖,列表,字典,集合的比较。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了Python字符串、列表、元组、字典集合,结合实例形式详细分析了Python字符串、列表、元组、字典集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下
  • 列表推导、字典推导、集合推导就是用更简单、简洁的方法生成列表字典集合。 1.列表推导(List Comprehension) """列表推导 list""" sl=[1,2,3,4,5] rl=[x+5 for x in sl] print rl #[6, 7, 8, 9, 10] ...
  • python字符串 列表 元组 字典 集合的相互转化

    千次阅读 多人点赞 2018-03-25 14:52:21
    1.字符串转化列表 s = 'hello python' li = list(s) print li print type(s) print type(li) 结果 ['h', 'e', 'l', 'l', 'o', ' ', 'p', 'y', 't', 'h', 'o', 'n'] &lt;type 'str'&gt; &lt;type ...
  • python中的列表、元祖、字典集合

    千次阅读 2017-08-16 18:16:27
    python中的列表、元祖、字典集合
  • 本文详细归纳整理了Python中列表字典、元组、集合数据结构。分享给大家供大家参考。具体分析如下: 列表:复制代码 代码如下:shoplist = [‘apple’, ‘mango’, ‘carrot’, ‘banana’] 字典:复制代码 代码如下...
  • 很全面的讲解了Python列表 字典 文件操作等知识 很详细很有范 值得下载拥有
  • 1.列表操作#查看donkey的类型 donkey = [] type(donkey) #定义一个列表 donkey = [1,2,3,5,6] donkey #定义一个列表 donkey = list([1,2,3,5]) donkey1 = list(['sfsfdsf']) #将两个列表连接在一起结果[1,2,3,5,'...
  • 常用弱口令字典集合.7z
  • 密码破解最常用的字典集合,包括各种类型字典,也可组成组合字典,破解效率更高,对于大多数密码可以破解。
  • 可变数据类型:列表 字典 集合 序列: 列表,字符串,元组,集合字典 有序序列:列表,字符串,元组(有序功能特点:索引 遍历 切片) 无序序列:集合字典 一. 列表 建立 方式一: 列表名=list(元素) 方式二:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 235,201
精华内容 94,080
关键字:

列表字典集合