精华内容
下载资源
问答
  • //总结:数组,字典,集合的相同点和不同点  //相同点:都属于collection(集合), 用来存储多个对象, 并不限制对象的类型,  //不同点:  //1.作用:  //数组:管理有序的集合,  //字典:管理的是有对应关系的数据...
    //总结:数组,字典,集合的相同点和不同点
            
    //相同点:都属于collection(集合), 用来存储多个对象并不限制对象的类型,
            
    //不同点:
            
    //1.作用:
                
    //数组:管理有序的集合,
                
    //字典:管理的是有对应关系的数据的集合
                
    //集合:管理的是无序并且具有互异性的元素的集合
            
    //2.特点:
                 
    //数组:有序并且元素可以重复
                 
    //字典:无序每一个元素都是一对键值对.一个key只能对应一个value, 但是一个value可以对应多个key, key是唯一的
                
    //集合:无序互异性
            
    //3.取值方式:
                
    //数组:根据下标取出对应元素
                
    //字典:根据key获得相对应的value
                
    //集合:anyObject  ---- 集合的效率最大化
            
    //4.快速遍历:都是使用for in----遍历时不能修改遍历的集合
                
    //数组:遍历出的是数组中的元素
                
    //字典:遍历出的是字典中的key, 通过key再取出对应的value
                
    //集合:遍历出来的是集合中的元素
            
    //5.创建对象的方法初始化方法                便利构造器
                
    //数组:       initWithObjects:              arrayWithObjects:
                
    //字典:       initWithObjectsAndKeys:    dictionaryWithObjectsAndKeys:
                
    //集合:       initWithObjects:              setWithObjects:
    展开全文
  • 列表,元组,集合字典是python中经常用到的工具,而且各类型之间有许多相同的地方,今天这篇文章就简略的梳理一下各自的相同点和不同点以及用法等

    组合数据类型——列表,元组,集合,字典

    数据类型关键字比较 列表 元组 字典 集合
    是否可重复存储
    是否可修改
    是否有序列

    (字典在python3.6之前存储的数据是没有顺序的,3.6及之后的版本,字典存储的数据变得有序。)

    列表(list)

    列表的特点:有顺序的,可以修改的,可以存放重复的,不同数据类型的多个数据

    列表的声明

    1. 声明空列表
      list1 = []
      list2 = list()
      声明空列表有以上两种方式
    2. 声明非空列表
      直接声明:lst = [1, 2, 3, 3, "a", "b", [4, 5]]  推荐方法用list()声明:lst = list((1, 2, 3, 4, 5)) 不推荐,太繁琐
      列表中的数据是可以不同数据类型的,可以重复的数据。

    列表的操作

    lst = [“a”]

    • 列表增加数据
      lst.append()在列表末尾追加一个数据
      在这里插入图片描述
      lst.extend()在列表末尾追加多个数据,也可以理解为合并两个列表的数据
      在这里插入图片描述
      lst.insert(0, “b”)在索引为0的数据前增加一个数据,即指定位置增加数据。
      在这里插入图片描述

    • 列表修改数据
      lst[索引] = ‘新数据’,通过索引对原位置数据进行覆盖,完成修改的目的
      在这里插入图片描述

    • 列表查询数据
      lst[索引] 通过索引查找指定位置的数据
      lst.sort()将列表数据从小到大排列,注意列表中的数据必须是可以相互之间进行比较的数据;

      [注意]: sorted() 和 sort() 的区别: 1. sort()是应用在 list 上的函数, 而 sorted()可以对所有的可迭代对象进行操作 2. list 的 sort 方法是作用在原列表上, 无返回值;内建函数 sorted 是将排序后的结果 返回一个新的 list,原 list 不发生改变

      lst.reverse()将数据从大到小排列。
      使用for循环遍历整个列表数据
      在这里插入图片描述
      lst.count(数据)查询列表中数据出现的次数
      lst.index(数据)查询列表中数据第一次出现的位置;但是超出列表末尾之外的索引总是会导致错误,对列表末尾范围之外赋值也是如此

    • 列表删除数据
      lst.pop()默认删除提取列表最后的一个数据
      lst.remove()指定删除数据
      del lst[]使用python命令删除列表数据
      在这里插入图片描述

    • 列表的其他操作:
      lst = [1, 2, 3, 4, 5]
      max(lst) 获取列表最大值
      min(lst)获取列表最小值
      sum(lst)列表中的数据求和
      以上三种列表的数据都必须是数值型数据。

    元组(tuple)

    元组的特点:有顺序的,不可修改的,可以存放重复的,不同数据类型的多个数据

    元素的声明

    声明空元组
    t = tuple()  推荐,可读性高
    t = ()    不推荐,容易混淆

    声明一个元素的元组
    t = tuple([“a”])  推荐
    t = (“a”,)  不推荐
    在声明一个元素的元组时不可以忽略逗号。

    声明多个元素的元组
    t = tuple([“a”, “b”, “c”])  不推荐,繁琐
    t = (“a”, “b”, “c”)  推荐
    在这里插入图片描述

    元组的操作

    因为元组时不可修改的数据类型,所以元组只有删除整个元组和查询的操作

    • 元组的查询
      元组的查询和列表的一样
      t = (“a”, “b”, “c”)
      t[索引]  通过索引进行数据查询
      t[起始位置:结束位置:步长]   元组通过切片完成数据查询
      通过for循环完成对列表数据的查询
      for i in t:
       print(i)
      在这里插入图片描述
      t.count(数据) 获取元组中数据的个数
      t.index(数据) 获取元组中数据第一次出现的位置

    字典(dict)

    字典的特点:没有顺序的,可修改的,键不可以重复,值可以重复,值可以是不同数据类型的多个数据

    字典的声明

    声明空列表
    d = {}
    d = dict()
    声明非空列表
    d = {“key”: “value”, “name”: “张三”} 推荐,直观易懂
    d = dict([(“key”, “value”), (“name”, “张三”)]) 不推荐,繁琐
    d = dict(key=“value”, name=“张三”) 还行,比较简单
    在这里插入图片描述

    字典的操作

    增加键值对操作

    方法 描述
    变量名[key]=value 通过 key 添加 value 值,如果 key 存在则覆盖
    setdefault(key,default_value) 指定 key 和 value,如果 key 存在则不覆盖

    删除操作

    方法 描述
    pop 弹出,返回并删除指定键对应的值 dict.pop(‘key’)
    popitem 随机弹出一个键值元组,这里随机的原因是因为字典无序
    clear 清空字典
    del 删除整个字典,或者通过字典的 key 删除对应键值对;Python 内置方法,不是字典独有 的方法

    修改操作

    方法 描述
    字典名[key]=value 通过 key 添加 value 值,如果 key 存在则覆盖
    update() 传递一个字典,如果 key 相同则覆盖,没有的 key 则添加

    查询操作

    方法 描述
    根据 key 查找 通过制定的 key 找对应的值 dict[‘key’]
    keys() 包含字典所有 key 的 dict_keys 对象,该对象可以转换为列表
    values () 包含字典所有的 value 的 dict_keys 对象,该对象可以转换为列表
    get() 以键取值,如果指定键不存在,默认返回 None,可以指定返回内容
    update() 以字典格式更新指定键的内容,如果键不存在,创建键和值
    items() 返回字典键值呈元组形式的格式
    len() 测量字典,键值对的个数(整体)

    集合(set)

    集合的特点:没有顺序的,可修改的,不可以重复的,可以是不同数据类型的多个数据

    集合的声明

    声明空集合
    s = set()
    声明非空集合
    (1). 变量名={元素 1,元素 2,元素 3,…}
    (2). 变量名=set(序列) 例如 变量名=set(元组,自动,字符串)

    集合的操作

    增加元素操作

    方法 描述
    add() s.add(元素)
    update() s.update({元素4, 元素5})

    在这里插入图片描述
    删除元素操作

    方法 描述
    pop() s.pop()随机删除一个元素
    remove() s.remove(元素4)指定删除一个元素
    clear() s.clear()清空集合
    del s 删除集合

    在这里插入图片描述

    遍历集合操作

    方法 描述
    for i in s:
     print(i)
    通过for循环遍历集合所有数据

    在这里插入图片描述
    集合的其他操作

    方法 描述
    ‘discard’ 删除一个指定的数据,如果数据不存在什么都不做
    ‘isdisjoint’ 判断元素是否在集合中
    ‘issubset’ s1 集合中的数据是不是包含在 s2 集合中,等价于 s1 < s2
    ‘issuperset’ s1 集合是不是包含了 s2 集合中你的数据,等价于 s1 > s2
    ‘difference’ 获取 s1 集合和 s2 集合的差集
    ‘difference_update’ 获取 s1 和 s2 的差集并将结果数据更新前集合中
    ‘intersection’ 获取 s1 集合和 s2 集合的交集
    ‘intersection_update’ 获取 s1 和 s2 的交集并将结果更新到前集合中
    ‘symmetric_difference’ 获取 s1 和 s2 共同的差集
    ‘symmetric_difference_update’ 获取共同的差集并更新到 前集合中
    ‘union’ 获取 s1 和 s2 的并集
    ‘update’ 获取 s1 和 s2 的并集,并将数据更新给 s1
    展开全文
  • Python中的tuple元组dict字典的用法

    千次阅读 2019-03-19 17:02:49
    1.tuple元组 (1)元组的基本知识 ...c)元组列表的相同点: 都是一种容器,都可以同时存储不同类型的数据 (2)元组的创建 创建空列表:list1 = [] 创建有元素的列表:list1 =[元素1,元素2,,,,...

    1.tuple元组

    (1)元组的基本知识

    a)概念:是一种有序的集合

    b)元组和列表的区别:

    格式: 元组:(),列表:[ ];

    列表中的元素可以进行增加和删除操作,但是,元组中的元素不能进行修改

    c)元组和列表的相同点:

    都是一种容器,都可以同时存储不同类型的数据

    (2)元组的创建

    创建空列表:list1 = []

    创建有元素的列表:list1 = [元素1,元素2,,,,]

    创建空元组:tuple = ()

    创建有元素的元组:tuple = (元素1,元素2,,,,)

    注意:和列表类似,在元组中可以存储重复元素,同时存储不同类型的数据;

               当元组中只有一个元素,tuple1 = (10)等价于tuple1 = 10,为了消除歧义,添加逗号如:tuple1 = (10,)

    (3)元组的访问

    获取值:语法如:元组名称[索引]

    #1.创建空元组
    tuple1 = ()
    
    #2.创建带有元素的元组
    tuple2 = (10,20,30)
    
    #1.获取元组值
    tuple1 = (10,20,30,40,50)
    print(tuple1[1])
    #法一:获取元组中的最后一个值:从前向后获取
    print(tuple1[4])
    #法二:获取元组中的最后一个值:从后向前获取,-1表示最后一个元素
    print(tuple1[-1])
    
    #2.修改元素值:不支持元素的修改,指的是不能更改地址,可以修改内容,此处特殊情况
    tuple2 = (1,3,43,5,[54,54,5])
    print(tuple2)
    list1 = tuple2[4]
    list1[1] = 100
    print(tuple2)
    
    #3.删除元组
    del tuple2

     

    (4)元组的操作

    组合:tuple1 + tuple2

    重复:tuple1 * 3                         #注意:组合和重复都是生成了一个新的元组,原来的元组不发生任何改变

    判断元素是否在元组中:in 和 not in

    元组截取【切片】:tuple1[2:4]    #截取2到4的元素,包前不包后,包头不包尾

                                     tuple1[2:]      #截取索引为2以后的元素,包括元素2

                                     tuple1[:4]      #截取从开头到4的元素,不包括元素4

    获取元组中元素的个数: len(tuple1)

    获取元组中元素的最大值和最小值: max(tuple1)和min(tuple1)

    元组和列表之间的相互转换:取长补短,转换前后不是以前的元组了

    list1 = list(tuple1)
    tuple2 = tuple(list2)

    遍历元组:

    a)直接遍历元素

    for element in tuple1:
        print(element)

     b)遍历索引:本质上遍历的是列表

    for i in range(len(tuple1)):
        print(tuple1[i])

    c)同时遍历索引和元素

    for i,element in enumerate(tuple1):
        print(i,element)

    (5)二维元组 :当做一维元组处理

    tuple1 = ((5,54,5,45),(5,6,46,56),(6,6,6,5))
    print(tuple[1][1])

    二维元组的遍历:嵌套循环

    for subTuple in tuple1:
        for element in subTuple:
            print(element)

     

    2.dict字典

    (1)字典dict的基本知识

    a)概念:查询学生成绩,将学生作为key,将成绩作为value进行村塾,方便查找【一一对应】

    b)本质:也是一种存储数据的容器

    c)特点:数据以键值的形式存储,具有快速查找的优势

    注意:字典是无序的,键重要,值跟着键走。

    键值的特点:字典中的key必须是唯一的、字典中的key必须是不可变的(如:tuple,数字型和字符串)

    (2)字典的访问

    a)创建:语法:字典名称 = {key1:value1,key2:value2,,,,,}

    #1.创建空字典
    dict1 = {}
    
    #2.创建有键值对的字典
    dict2 = {"zhangsan":60,"jack":90}
    print(dict2)
    

    b)获取:通过Key获取Value

    dict3 = {"zhangsan":60,"jack":90,"tom":80}
    #通过key获取value
    score = dict3["jack"]
    print(score)

    注意:如果key不存在,则通过get功能,返回None,程序不会报错

    result = dict3.get("lisi")
    print(result)
    if result == None:
        print("lisi不存在的")
    else
        print("存在")

    (4)字典的操作

    a)添加:如果键值存在,则dict3["jack"] = 100,表示给此键值增添元素

                    如果键值不存在,则dict3["bob"] = 75,表示增加键值对

    b)删除:删除指定的key,则对应的value也会随之删除,如:dict3.pop["tom"]

    c)遍历

    dict1 = {"zhangsan":60,"jack":90,"tom":80}
    
    #1.获取key
    for key in dict1:
        value = dict1[key]
        print("%s = %d"%(key,value))
    
    #2.只获取value
    #注意:将所有的value重新生成一个列表
    list1 = dict.values()
    for value in list1:
        print(value)
    
    #3.获取key:dict.keys()
    for i,key in enumerate(dict1):
        print(i,key)
        print(dict1[key])
    
    #4.同时获取value和key,python中特有
    for key,value in dict1.items():
        print(key,value)

    练习:

    1.逐一显示指定字典中的所有的键,并且显示结束之后输出总键数

    #1.逐一显示指定字典中的所有的键,并且显示结束之后输出总键数
    num = 0
    dict1 = {"x":1,"y":2,"z":3}
    for key in dict1:
        num += 1
        print(key)
    print(num)
    
    for key in dict1.keys():
        print(key)
    print(len(dict1))

    2.list1 = [0,1,2,3,4,5,6],list2 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],以list1中的元素作为key,list2中元素作为value,生成一个新的字典dict2

    list1 = [0,1,2,3,4,5,6]
    list2 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]
    dict2 = {}
    
    i = 0
    if len(list1) == len(list2):
        while i < len(list1):
            dict2[list1[i]] = list2[i]
            i += 1
    print(dict2)

    展开全文
  • 元组,字典集合的相关操作 1.元组定义 对比 列表元组 相同点: 保存任意数据类型 有序数据类型(下标索引, 切片) 循环遍历(while for) 不同点: 列表[] 元组() 列表可变数据类型(增删改查) 元组是...

    从0基础学习Python(Day5)

    元组,字典,集合的相关操作

    1.元组的定义

    • 对比

      • 列表和元组

        • 相同点:

          • 保存任意数据类型
          • 有序的数据类型(下标索引, 切片)
          • 循环遍历(while for)
        • 不同点:

          • 列表[] 元组()
          • 列表可变的数据类型(增删改查) 元组是不可变的数据类型(查)
    • 格式:

      tuple = (元素1, 元素2, ...)
    • 空元组

      ()
      tuple()
    • 有且只有一个元素的元组

      tuple = (元素,)
    • len()函数

      • str
      • list
      • tuple

    2.元组的相关操作

    • 结论:

      • 不可变的类型

      • 有序的数据类型

        • 下标索引
        • 切片
      • 循环

        • for
          • 可迭代对象
        • while
        • in
        • not in
        • index
        • count
    • 思考:

      • 为什么Python会提出这种类型?
      • 保证数据的安全

    3.字典的定义

    • 作用: 保存任意数据类型, 而且无序

      • 不支持下标索引和切片
    • 格式:

      dict = {key1: value1, key2: value2, ...}
    • 空的字典

      {}
      dict()
    • len()函数

      • str
      • list
      • tuple
      • dict

    4.字典的定义的注意点

    • 字典的key不能重复, 如果重复只会保留一个
    • 字典的value可以重复, 因为通过不同的key获取value
    • 字典的key不能出现任何可变的数据类型, 保证key的唯一性
    • 字典的key一般都是选取字符串类型居多

    5.字典的常见操作1

    • 查看元素

      dict[key]
    • 修改元素

      dict[key] = new_value
    • 添加元素

      dict[new_key] = new_value
    • 删除元素

      • del

        del dict[key]
      • clear()

    6.字典的常见操作2

    • len
    • keys
    • values
    • items
    • in not in 判断key是否存在

    7.字典的三种取值方式

    • 通过key获取value
    • 通过setdefault
    • 通过get
    # 字典
    info_dict = {'name': '小明', 'age': 20, 'no': '007'}
    
    # 01: value = dict[key]
    # value = info_dict['name']
    # print(value)
    
    # 02:setdefault
    # 格式: dict.setdefault(k, default)
    # dict.setdefault(k)
    # 0201: 如果key存在, 返回对应的value
    # value = info_dict.setdefault('name')
    # print(value)
    
    # 0202: 如果key不存在, 返回None , 并且会把新的key和None保存到字典中
    # value = info_dict.setdefault('name1')
    # print(value)
    # print(info_dict)
    
    # dict.setdefault(k, default)
    # 0203:如果key存在, 返回对应的value
    # value = info_dict.setdefault('name', '哈哈')
    # print(value)
    
    # 0204:如果key不存在, 而且设置defaule, 返回defaule , 并且会把新的key和defaule保存到字典中
    # value = info_dict.setdefault('name1', '哈哈')
    # print(value)
    # print(info_dict)
    
    # 03: get
    # 格式: dict.get(k, default)
    # dict.get(k)
    # 0301: 如果key存在, 返回对应的value
    # value = info_dict.get('name')
    # print(value)
    
    # 0302: 如果key不存在, 返回None, 字典没有任何变化
    # value = info_dict.get('name1')
    # print(value)
    # print(info_dict)
    
    
    # dict.get(k, default)
    # 0303:如果key存在, 返回对应的value
    # value = info_dict.get('name', '哈哈')
    # print(value)
    
    # 0304:如果key不存在, 而且设置defaule, 返回defaule , 字典没有任何变化
    value = info_dict.get('name1', '哈哈')
    print(value)
    print(info_dict)
    • 空值类型
      • None
      • NoneType
      • 如果想创建变量但是还不想赋值可以使用None

    8.遍历

    • 字典的遍历

      • key

      • value

      • items

      • 如果同时获取key和value

        for k, v in dict.items():
          	pass
    • 如果循环遍历str list tuple 得到对应的元素的同时也获取他的索引

      for i, value in enumerate(str 或者 list 或者 tuple):
      		pass

    9.集合的定义

    • 特点:

      • 保存任意数据类型的数据, 但是不能有可变的类型
      • 它是一个变的数据类型
      • 它是一个无序的数据类型
    • 格式:

      set = {元素1, 元素2, ...}
    • 空集合:

      set()
    • for循环

      for value in set:
        	pass

    10.集合的相关操作

    • 添加

      • add
        • list.append
      • update
        • list.extend
    • 删除

      • pop

        • 随机的删除一个元素
      • remove

        • 有删除, 没有报错
      • discard

        • 有删除, 没有不报错

    11.集合的作用

    • 去重

      set(容器类型)
    • 交集

      set1 & set2
    • 并集

      set1 | set2

    Day5-------END

    展开全文
  • 字符串、列表不同,python的字典并没有数据顺序差别。 字典每个键值对由逗号分割,值可以是不同类型,但是键必须是相同类型且不能重复。 a={"abc":123,"def":456} 这从算法上就很好理解,同一类型值在...
  • 相同点: 列表元组都是一个可以放置任意数据类型有序集合; 列表元组都支持负数索引; 列表元组都支持切片操作; 列表元组都可以随意嵌套。 不同点: 列表是动态(mutable):长度大小不固定,可以随意...
  • 集合

    2020-09-09 23:58:16
    集合分为可变集合和不可变集合,可变集合(set):可添加和删除元素,非可哈希的,不能用作字典的键,也不能做其他集合的元素 集合不能出现重复元素,否则将只保留一个相同元素 2 集合的使用 参考资料:python中集合...
  • 字典数组 区别

    2016-01-09 13:21:00
    总结:字典,集合....的相同点和不同点 <span style="font-size:18px;"> /** * * 相同点:都属于collection(集合),用来存储多个对象,并不限制对象的类型 * 不同点: * 1.作用: * 数...
  • C# 集合及练习题目

    2016-07-28 15:42:00
    System.Collections命名空间包含接口和类,这些接口和类定义各种对象(如列表、队列、位数组、哈希表和字典的集合集合和数组是异同: 相同点:  (1)两者都实现了IList、ICollection、IEnumerable接口;  ...
  • go arrayslice区别

    千次阅读 2018-12-31 22:22:16
    相同点 属于集合类型,值都可以用来存储某一种类型值(或者说元素) 区别(最大的不同) 数组长度固定,数组是值类型(值类型有基本数据类型,结构体类型),slice值长度可变,属于引用类型(引用类型:...
  • 相同点:都是一组数据有序结构 区别:列表数据类型可不同;而数组数据类型相同。 3.二维数据----列表 由多个一维数据构成,是一维数据组合形式。 4.多维数据----列表 由一维或二维数据在新维度上扩展形成。 ...
  • 故心故心故心故心小故冲啊 文章目录一、Set增删改查遍历二、Map遍历三、WeakSet WeakMapWeakSetWeakMap参考文献 如果要用一句话来描述,我们可以说 Set是一种叫做集合的数据结构,Map是一...不同点集合是以[值
  • Python中基本数据类型区别

    千次阅读 2018-11-01 21:08:38
    set集合和dict字典的区别 唯一区别: set没有对应的value值 两者都是可变类型,即不可哈希 两者的内部元素是不可变类型,即可哈希 利用哈希算法,进行计算元素在存在的生命周期中有对应唯一的哈希值,就是可哈希,...
  • 从运营商手中夺取权力,交给制造商、开发商消费者,iPhone完全改变了运营商制造商行为,其崭新商业模式改变了移动业务游戏规则,截至2008年6月,App Store汇集了30万个苹果批准“应用程序”,App Store...
  • python学习笔记(六)

    2018-11-14 09:43:00
    (3)集合和字典都能同时更新多个元素,update;(4)列表是有序,可以进行排序,集合中元素为同一数据类型时也是有序不同数据类型时是无序;(5)列表和元组都能返回值下标;(6)列表、字典、集合都有.....
  • 于是自己整理下本系列知识点的上章内容。 <p><img alt="moiunt-Fuji" src="https://img-blog.csdnimg.cn/img_convert/9163d187b3ed0250bfb92d452d1cceb5.png" /></p> 以下为正文: <p><strong>数据结构是...
  • Python基础 task3

    2019-05-15 20:21:57
    1.dict字典 1)定义 字典是另一种可变容器模型,且可存储任意类型对象。 字典的每个键值对(key=>...列表和字典的 比较: 相同点:都可以存储多个数据 不同点:列表示有序的对象集合(有索引号) 字...
  • ets dets

    2013-09-24 21:24:00
    相同点:etsdets都提供“键—值”搜索表 不同点:ets驻留在内存,dets驻留在磁盘 特点:ets表dets表可以被多个进程共享,因此通过这两个模块可以实现数据间交换 一 ets表 实现原理:散列表二叉树 表...
  • 不幸是,虽然关系型数据库历经了约30年发展,有成熟理论大量实践基础,但是,大多数设计、开发人员在设计数据库结构时仍然是“跟着感觉走”,根据业务需要编程方便,把字段这张表放几个那张表放几个...
  • 数据分析学习

    2017-07-30 16:11:59
    列表和数组比较 相同点:都是一组数据有序结构 不同点:数据类型(列表数据类型可不相同,数组必须相同)   二维数据:由多个一维数据构成,是一维数据组合形式. 多维数据:由一维或二维数据在新维度上...
  • 列表与元组

    2020-12-20 14:45:34
    列表是Python内置类型,是一种有序集合,可以随时添加删除其中元素。 列表元组是Python中最常用两种数据结构,字典是第三种。 相同点: 1.都是序列 2.都可以存储任何数据类型 3.可以通过索引访问 不同点:...
  • 一款非常好WPF编程宝典2010 源代码

    热门讨论 2014-04-14 09:57:41
    相同的命令 257 10.4.3 使用命令参数 259 10.4.4 跟踪翻转命令 259 10.5 结束语 263 第11章 资源 264 11.1 程序集资源 264 11.1.1 添加资源 264 11.1.2 检索资源 266 11.1.3 pack URI 267 11.1.4 内容...
  • 不幸是,虽然关系型数据库历经了约30年发展,有成熟理论大量实践基础,但是,大多数设计、开发人员在设计数据库结构时仍然是“跟着感觉走”,根据业务需要编程方便,把字段这张表放几个那张表放几个...
  • 而比较用户对象功能则允许您对所选对象进行比较,将不同点可视化,并运行或保存应用必要变动SQL脚本。  导出用户对象——该工具可以导出用户所选对象DDL(数据定义语言)语句。您可以方便为其他用户重新...
  • 本章内容 ...这样写对于新手是比较有好处,因为这一类操作复杂(或者说操作多)数据类型,操作之间存在着相同点(占多比例)和不同点。要想学好python,最基本数据类型一定要深入掌握。  工具:...

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

集合和字典的相同点和不同点