腾讯课堂——基础数据类型(dict字典)

初识字典

标准类型
数字
字符串
列表
字典
元组

  

字典是Python语言中唯一的映射类型。

  定义:{key1:value1,key2:value2}

        1、键与值用冒号“:”分开;
        2、项与项用逗号“,”分开;
  特性:

      1.key-value结构

        2.key必须可hash、且必须为不可变数据类型、必须唯一

        3.可存放任意多个值、可修改、可以不唯一

        4.无序

字典的创建

  person = {"name": "alex", ‘age‘: 20}
  或
  person = dict(name=‘seven‘, age=20)
  person = dict({"name": "egon", ‘age‘: 20})
  person = dict(([‘name‘,‘苑昊‘],[‘文周‘,18]))
  {}.fromkeys(seq,100) #不指定100默认为None

  注意:

>>> dic={}.fromkeys([‘k1‘,‘k2‘],[])
>>> dic
{‘k1‘: [], ‘k2‘: []}
>>> dic[‘k1‘].append(1)
>>> dic
{‘k1‘: [1], ‘k2‘: [1]} 

字典的常用操作

  键、值、键值对

    1、dic.keys() 返回一个包含字典所有KEY的列表;
    2、dic.values() 返回一个包含字典所有value的列表;
    3、dic.items() 返回一个包含所有(键,值)元祖的列表;
    4、dic.iteritems()、dic.iterkeys()、dic.itervalues() 与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表;

  新增

    1、dic[‘new_key‘] = ‘new_value‘ 

    2、dic.setdefault(key, None) ,如果字典中不存在Key键,由 dic[key] = default 为它赋值;

  删除

    1、dic.pop(key[,default]) 和get方法相似。如果字典中存在key,删除并返回key对应的vuale;如果key不存在,且没有给出default的值,则引发keyerror异常;

    2、dic.clear() 删除字典中的所有项或元素;

  修改

    1、dic[‘key‘] = ‘new_value‘,如果key在字典中存在,‘new_value‘将会替代原来的value值。

    2、dic.update(dic2) 将字典dic2的键值对添加到字典dic中。

  查看

    1、dic[‘key‘],返回字典中key对应的值,若key不存在字典中,则报错;

    2、adict.get(key, default = None) 返回字典中key对应的值,若key不存在字典中,则返回default的值(default默认为None);   

  循环

  长度

字典的工厂函数

class dict(object):
    """
    dict() -> new empty dictionary
    dict(mapping) -> new dictionary initialized from a mapping object‘s
        (key, value) pairs
    dict(iterable) -> new dictionary initialized as if via:
        d = {}
        for k, v in iterable:
            d[k] = v
    dict(**kwargs) -> new dictionary initialized with the name=value pairs
        in the keyword argument list.  For example:  dict(one=1, two=2)
    """
    def clear(self): # real signature unknown; restored from __doc__
        """ D.clear() -> None.  Remove all items from D. """
        pass

    def copy(self): # real signature unknown; restored from __doc__
        """ D.copy() -> a shallow copy of D """
        pass

    @staticmethod # known case
    def fromkeys(*args, **kwargs): # real signature unknown
        """ Returns a new dict with keys from iterable and values equal to value. """
        pass

    def get(self, k, d=None): # real signature unknown; restored from __doc__
        """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
        pass

    def items(self): # real signature unknown; restored from __doc__
        """ D.items() -> a set-like object providing a view on D‘s items """
        pass

    def keys(self): # real signature unknown; restored from __doc__
        """ D.keys() -> a set-like object providing a view on D‘s keys """
        pass

    def pop(self, k, d=None): # real signature unknown; restored from __doc__
        """
        D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
        If key is not found, d is returned if given, otherwise KeyError is raised
        """
        pass

    def popitem(self): # real signature unknown; restored from __doc__
        """
        D.popitem() -> (k, v), remove and return some (key, value) pair as a
        2-tuple; but raise KeyError if D is empty.
        """
        pass

    def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
        """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
        pass

    def update(self, E=None, **F): # known special case of dict.update
        """
        D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
        In either case, this is followed by: for k in F:  D[k] = F[k]
        """
        pass

    def values(self): # real signature unknown; restored from __doc__
        """ D.values() -> an object providing a view on D‘s values """
        pass

    def __contains__(self, *args, **kwargs): # real signature unknown
        """ True if D has a key k, else False. """
        pass

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __eq__(self, *args, **kwargs): # real signature unknown
        """ Return self==value. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, y): # real signature unknown; restored from __doc__
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __ge__(self, *args, **kwargs): # real signature unknown
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs): # real signature unknown
        """ Return self>value. """
        pass

    def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
        """
        dict() -> new empty dictionary
        dict(mapping) -> new dictionary initialized from a mapping object‘s
            (key, value) pairs
        dict(iterable) -> new dictionary initialized as if via:
            d = {}
            for k, v in iterable:
                d[k] = v
        dict(**kwargs) -> new dictionary initialized with the name=value pairs
            in the keyword argument list.  For example:  dict(one=1, two=2)
        # (copied from class doc)
        """
        pass

    def __iter__(self, *args, **kwargs): # real signature unknown
        """ Implement iter(self). """
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    def __le__(self, *args, **kwargs): # real signature unknown
        """ Return self<=value. """
        pass

    def __lt__(self, *args, **kwargs): # real signature unknown
        """ Return self<value. """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs): # real signature unknown
        """ Return self!=value. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __sizeof__(self): # real signature unknown; restored from __doc__
        """ D.__sizeof__() -> size of D in memory, in bytes """
        pass

    __hash__ = None

dict的工厂函数

原文地址:https://www.cnblogs.com/l-hf/p/11528867.html

时间: 2024-11-09 06:58:31

腾讯课堂——基础数据类型(dict字典)的相关文章

腾讯课堂——基础数据类型(set集合)

认识集合 由一个或多个确定的元素所构成的整体叫做集合. 集合中的元素有三个特征: 1.确定性(集合中的元素必须是确定的) 2.互异性(集合中的元素互不相同.例如:集合A={1,a},则a不能等于1) 3.无序性(集合中的元素没有先后之分),如集合{3,4,5}和{3,5,4}算作同一个集合. *集合概念存在的目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中某个值 集合的定义 s = {1,2,3,1} #定义可变集合 >>> set_test=set('hello

腾讯课堂——基础数据类型(tuple元祖)

初识元祖 标准类型 数字 字符串 列表 字典 元组 定义:与列表类似,只不过[]改成() 特性: 1.可存放多个值 2.不可变 3.按照从左到右的顺序定义元组元素,下标从0开始顺序访问,有序 元祖的创建 ages = (11, 22, 33, 44, 55) 或 ages = tuple((11, 22, 33, 44, 55)) 顺序及下标图示 元祖的常用操作 索引 切片 循环 长度 包含 元祖的特性详解 1.可存放多个值 如果元祖中只有一个值 t = (1,) t = (1) #<==>t

Py西游攻关之基础数据类型(四)-字典

Py西游攻关之基础数据类型 - Yuan先生 https://www.cnblogs.com/yuanchenqi/articles/5782764.html 七 Dictionary(字典) 字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据.python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的.可哈希表示key必须是不可变类型,如:数字.字符串.元组. 字典(dictionary)是除列表意

python基础数据类型之字典dict和集合set及其他(for,enumerate,range)。

2.6字典dict. 2.6.1 字典的初识 1. 列表可以存储大量的数据类型,但是如果数据量大的话,他的查询速度比较慢. 2. 列表只能按照顺序存储,数据与数据之间关联性不强. 所以针对于上的缺点,说咱们需要引入另一种容器型的数据类型,解决上面的问题,这就需要dict字典. 数据类型可以按照多种角度进行分类,就跟咱们人一样,人按照地域可以划分分为亚洲人,欧洲人,美洲人等,但是按照肤色又可以分为白种人,黄种人,黑种人,等等,数据类型可以按照不同的角度进行分类,先给大家按照可变与不可变的数据类型的

python基础数据类型一(字典)

字典 列表可以存储大量的数据类型,但是只能按照顺序存储,数据与数据之间关联性不强. 所以咱们需要引入一种容器型的数据类型,解决上面的问题,这就需要dict字典. 字典(dict)是python中唯?的?个映射类型.他是以{ }括起来的键值对组成. 在dict中key是 唯?的.在保存的时候, 根据key来计算出?个内存地址. 然后将key-value保存在这个地址中. 这种算法被称为hash算法, 所以, 切记, 在dict中存储的key-value中的key必须是可hash的 可以改变的都是不

python基础数据类型之字典+集合

一.数据类型之字典 字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据.python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的.可哈希表示key必须是不可变类型,如:数字.字符串.元组. 字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型.列表是有序的对象结合,字典是无序的对象集合.两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取. 总结:1.字

初识基础数据类型 dict,set

字典 ? 字典(dict)是python中唯一一个映射类型,在python中key是唯一的,在保存的时候,根据key计算出一个内存地址,然后将key-value保存在这个地址中,这种算法被称为hash算法.所以,在dict中存储的键值对中的key必须是可哈希的.(可以改变的都是不可哈希的,那么可哈希的就意味着不可变.)这是为了能准确地计算内存地址而规定的.还有,dict保存的数据不是按照我们添加进去的顺序保存的,是按照hash表的顺序保存的,而hash表不是连续的,所以不能进行切片工作,只能通过

Python零基础入门(11)-------dict 字典表

dict 字典表属于映射的数据类型 特性:通过键(key),而不是通过下标访问数据 包含任意对象的无序集合 可变长度,可任意嵌套 属于"可变映射" 分类 对象引用表(Hash Table) 声明:   d = { } 是一个空的字典表.字典表是一个 {key: value} 的形式.key 只能是不可变的元素(可变类型List就不可以). 从下面图片你也可以看出 dict 字典表 是一个无序的集合.是通过内部Hash算法排序的 key 只能是不可变类型的数据.可变类型就会抛出错误信息

Python:基础数据类型--字典

基础数据类型--字典 Python字典是另一种可变容器模型,且可存储任意类型对象,如字符串.数字.元组等其他容器模型. 字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,格式如下所示: 键必须是唯一的,但值则不必. d = {key1 : value1, key2 : value2 } 字典:增 dic = {'name': '老男孩','age': 10000, 'sex': '男'} dic['hobby'] = 'old