精华内容
下载资源
问答
  • 转发 TypeScript基础入门之高级类型的映射类型 高级类型 映射类型 一个常见的任务是将一个已知的类型每个属性都变为可选的: interface PersonPartial {  name?: string;  age?: number; } 或者我们想要一...

    转发 TypeScript基础入门之高级类型的映射类型

    高级类型

    映射类型

    一个常见的任务是将一个已知的类型每个属性都变为可选的:

    interface PersonPartial {
        name?: string;
        age?: number;
    }

    或者我们想要一个只读版本:

    interface PersonReadonly {
        readonly name: string;
        readonly age: number;
    }

    这在JavaScript里经常出现,TypeScript提供了从旧类型中创建新类型的一种方式 — 映射类型。 在映射类型里,新类型以相同的形式去转换旧类型里每个属性。 例如,你可以令每个属性成为 readonly类型或可选的。 下面是一些例子:

    type Readonly<T> = {
        readonly [P in keyof T]: T[P];
    }
    type Partial<T> = {
        [P in keyof T]?: T[P];
    }

    像下面这样使用:

    type PersonPartial = Partial<Person>;
    type ReadonlyPerson = Readonly<Person>;

    下面来看看最简单的映射类型和它的组成部分:

    type Keys = 'option1' | 'option2';
    type Flags = { [K in Keys]: boolean };

    它的语法与索引签名的语法类型,内部使用了 for .. in。 具有三个部分:

    1. 类型变量 K,它会依次绑定到每个属性。
    2. 字符串字面量联合的 Keys,它包含了要迭代的属性名的集合。
    3. 属性的结果类型。
    在这个简单的例子里, Keys是硬编码的的属性名列表并且属性类型永远是boolean,因此这个映射类型等同于:

    type Flags = {
        option1: boolean;
        option2: boolean;
    }

    在真正的应用里,可能不同于上面的 Readonly或 Partial。 它们会基于一些已存在的类型,且按照一定的方式转换字段。 这就是 keyof和索引访问类型要做的事情:

    type NullablePerson = { [P in keyof Person]: Person[P] | null }
    type PartialPerson = { [P in keyof Person]?: Person[P] }

    但它更有用的地方是可以有一些通用版本。

    type Nullable<T> = { [P in keyof T]: T[P] | null }
    type Partial<T> = { [P in keyof T]?: T[P] }

    在这些例子里,属性列表是 keyof T且结果类型是 T[P]的变体。 这是使用通用映射类型的一个好模版。 因为这类转换是 同态的,映射只作用于 T的属性而没有其它的。 编译器知道在添加任何新属性之前可以拷贝所有存在的属性修饰符。 例如,假设 Person.name是只读的,那么 Partial<Person>.name也将是只读的且为可选的。

    下面是另一个例子, T[P]被包装在 Proxy<T>类里:

    type Proxy<T> = {
        get(): T;
        set(value: T): void;
    }
    type Proxify<T> = {
        [P in keyof T]: Proxy<T[P]>;
    }
    function proxify<T>(o: T): Proxify<T> {
       // ... wrap proxies ...
    }
    let proxyProps = proxify(props);

    注意 Readonly<T>和 Partial<T>用处不小,因此它们与 Pick和 Record一同被包含进了TypeScript的标准库里:

    type Pick<T, K extends keyof T> = {
        [P in K]: T[P];
    }
    type Record<K extends string, T> = {
        [P in K]: T;
    }

    Readonly, Partial和 Pick是同态的,但 Record不是。 因为 Record并不需要输入类型来拷贝属性,所以它不属于同态:

    type ThreeStringProps = Record<'prop1' | 'prop2' | 'prop3', string>

    非同态类型本质上会创建新的属性,因此它们不会从它处拷贝属性修饰符。

    由映射类型进行推断

    现在你了解了如何包装一个类型的属性,那么接下来就是如何拆包。 其实这也非常容易:

    function unproxify<T>(t: Proxify<T>): T {
        let result = {} as T;
        for (const k in t) {
            result[k] = t[k].get();
        }
        return result;
    }
    
    let originalProps = unproxify(proxyProps);

    注意这个拆包推断只适用于同态的映射类型。 如果映射类型不是同态的,那么需要给拆包函数一个明确的类型参数。

    展开全文
  • 字典是python语言中唯一的映射类型,用花括号{}表示,一个字典条目就是一个键值对,方法keys()返回字典的键列表,values()返回字典的值列表,items()返回字典的键值对列表。字典中的值没有任何限制,它们可以是任意...
  • Python映射类型、集合类型

    千次阅读 2015-07-15 17:03:14
    Python映射类型、集合类型映射类型:字典# coding=utf-8 __author__ = 'zyt'd = {'a': 1, 'b': 2, 'c': 3, 'd': 4} print d.keys() 运行结果: ['a', 'c', 'b', 'd']集合类型:set 可变集合set 不可变集合frozenset ...

    Python映射类型、集合类型

    映射类型:字典

    # coding=utf-8
    __author__ = 'zyt'
    
    d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
    print d.keys()
    
    
    运行结果:
    ['a', 'c', 'b', 'd']

    集合类型:set

    • 可变集合set
    • 不可变集合frozenset
    # coding=utf-8
    __author__ = 'zyt'
    
    s1 = {1, 2, 3, 4}
    s2 = {3, 4, 5, 6}
    print s1 | s2  # 联合union
    print s1 & s2  # 交集
    print s1 - s2  # 差集
    print s1 ^ s2  # 异或,对称差分
    
    # 子集、超集
    print set('shop') <= set('bookshop')  # set('shop')等价于{'s','h','o','p'}
    
    
    运行结果:
    set([1, 2, 3, 4, 5, 6])
    set([3, 4])
    set([1, 2])
    set([1, 2, 5, 6])
    True

    展开全文
  • 映射类型是一类可迭代的键-值数据项的组合,提供了存取数据项及其键和值的方法,在python3中,支持两种无序的映射类型:内置的dict和标准库中的collections.defaultdict类型。 在python3.1后,还引入了一种有序的...

    映射类型是一类可迭代的键-值数据项的组合,提供了存取数据项及其键和值的方法,在python3中,支持两种无序的映射类型:内置的dict和标准库中的collections.defaultdict类型。
    在python3.1后,还引入了一种有序的映射类型:collections.OrderedDict.

    特点:
    • 1.只有可哈希运算的对象可用于映射类型中的键,因此,内置的固定的数据类型都可以用作映射类型中的键(内置固定的类型都可进行哈希运算),目前接触到的固定数据类型有:int、float、complex、bool、str、tuple、frozenset
    • 2.每个键相关联的值可以是任意对象;
    • 3.映射类型也是可迭代的(iterable)。
    • 4.映射类型可以使用比较操作符进行比较,可以使用成员关系符in/not in和内置len()函数。

    1.dict(字典)

    dict数据类型是一种无序的、可变的组合数据类型,其中包含0-n个键值对,键是指向可哈希运算的对象的引用,值可以指向任意对象的引用。由于键是可哈希运算的对象引用,因此保证了键的唯一性;由于dict是可变的,因此可以对dict进行数据项的添加和移除操作;由于dict是无序的,因此没有索引,也不能使用分片操作符进行操作。

    dict的创建

    1.dict()可以作为一个函数调用,此时创建一个空dict:

    >>> dict()
    {}
    >>> 

    dict()中传入一个映射类型的参数时,将返回以该参数为基础的字典,如:

    >>> d1 = {"key1":"value1","key2":"value2"}
    >>> dict(d1)
    {'key1': 'value1', 'key2': 'value2'}
    >>> 

    dict() 还可以接受序列类型的参数,但是前提是序列中的每一个数据项本身是一个包含两个对象的序列,第一个用作键,第二个用作值,如:

    >>> d1 = dict((("k1","v1"),("k2","v2")))   #使用元组创建
    >>> d1
    {'k1': 'v1', 'k2': 'v2'}
    >>> 
    >>> d1 = dict([("k1","v1"),("k2","v2")])   #使用序列创建
    >>> d1
    {'k1': 'v1', 'k2': 'v2'}
    >>> 

    dict() 中还可以关键字参数进行创建,其中键作为关键字,值作为关键字的值,如:

    >>> dict(id=1,name="zhangsan",age=23)
    {'id': 1, 'name': 'zhangsan', 'age': 23}
    >>> 

    注意:关键字必须为有效的python标识符

    2.使用花括号创建dict,空{}会创建一个空的dict,非空dict由多个项组成,每一项由逗号分隔,其中每一项都使用K:V 的形式创建,如:

    >>> dict2 = {"name":"kobe","age":33,"num":24}
    >>> dict2
    {'name': 'kobe', 'age': 33, 'num': 24}
    >>> 

    3.使用字典内涵创建字典(单独列出)

    常用操作符和方法

    操作符:
    [] 用于存取dict中的某一个单值,如:

    >>> d =dict(k1="value1",k2="value2")
    >>> d["k1"]
    'value1'
    >>> 

    =:用于添加或替换dict中某一项,如:

    >>> d = dict()
    >>> d["k1"]="V1"
    >>> d
    {'k1': 'V1'}
    >>> 

    如果存在键k1,则使用“V1”替换原来“k1”的值。

    注意:dict是无序的,不能使用分片操作符[],但这里的[]并非分片操作符。

    del语句:删除某一项,如:

    >>> d
    {'k1': 'value1', 'k2': 'value2'}
    >>> del d["k1"]
    >>> d
    {'k2': 'value2'}
    >>> 

    如果存在指定的键,则移除,如果不存在,则会出现KeyError 异常。
    in/not in:通过键进行成员关系判断,如:

    >>> "k2" in d
    True
    >>> "value2" in d  #通过键进行判断,而不是值
    False
    >>> 

    方法:
    d.clear() :移除dict中所有项;
    d.copy():返回d的浅拷贝:

    >>> d = dict(id = 1,name = "zhangsan",age = 23,gendor = "男")
    >>> d2 = d.copy()
    >>> d2
    {'id': 1, 'name': 'zhangsan', 'age': 23, 'gendor': '男'}
    >>>

    d.fromkeys(s,v):返回一个dict,该dict的键为序列s中的项,值为None或者v,参数v可选:

    >>> d.fromkeys(["k1","k2","k3"],0)
    {'k1': 0, 'k2': 0, 'k3': 0}
    >>> 

    d.get(k):通过给定的键返回对应的值,如果不存在就返回None:

    >>> d.get("name") 
    'zhangsan'
    >>>

    d.get(k,v):通过给定的键返回对应的值,如果不存在就返回v.
    d.items():返回d中所有键值对的字典视图;

    >>> d.items()
    dict_items([('id', 1), ('name', 'zhangsan'), ('age', 23), ('gendor', '男')])
    >>>

    字典视图,是一个只读的并且可迭代的itreable对象,存放了字典的键和值。

    d.keys():返回d中所有键的视图

    >>> d.keys()
    dict_keys(['id', 'name', 'age', 'gendor'])
    >>> 

    d.pop(k):返回并移除d中的k和k对应的值,如果不存在k,出现KeyError异常:
    d.popitem():返回并移除d中任意一个键值对,如果d为空,则产生KeyError异常:

    >>> d.pop("age")     
    23
    >>> d.popitem() 
    ('gendor', '男')
    >>> d.items()
    dict_items([('id', 1), ('name', 'zhangsan')])
    >>> 

    d.setdefalut(k,v):返回d中k的值,如果不存在,就在d中插入k-v:

    >>> d.setdefault("gender","男") 
    '男'
    >>> d.items()
    {'id': 1, 'name': 'zhangsan', 'gender': '男'}
    >>> 

    d.update(i):将i中每个尚未包含在d中的k-v添加到d中,或者将d中包含了i中k-v的键,使用i中的v进行替换,但是i中每一项只能为2个长度,否则出现ValueError异常,也可以使用关键字参数:

    >>> d.update([("weight"),(23)])
    Traceback (most recent call last):
      File "<pyshell#231>", line 1, in <module>
        d.update([("weight"),(23)])
    ValueError: dictionary update sequence element #0 has length 6; 2 is required
    >>> 
    >>> d.update(["kv"])  #ok
    >>> d
    {'id': 1, 'name': 'zhangsan', 'gender': '男', 'k': 'v'}
    >>> 
    >>> d.update(gender = "男")  #关键字参数
    >>> d
    {'id': 1, 'name': 'zhangsan', 'age': 23, 'gender': '男'}
    >>> 

    d.values():返回d中所有值的视图:

    >>> d.values()
    dict_values([1, 'zhangsan', '男'])
    >>> 

    掌握这些基本方法后,就可以对dict进行操作了。

    操作dict

    1.迭代dict:

    可以使用d.items(),d.values(),d.keys()迭代dict,如:

    >>> for item in d.items():    #使用itmes()迭代
             print(item[0],item[1])
    id 1
    name zhangsan
    gender 男
    k v
    >>> 
    >>> for key in d.keys():   #使用keys()迭代
             print(key,d.get(key))
    id 1
    name zhangsan
    gender 男
    k v
    >>> 
    >>> for value in d.values():    #使用values()迭代
             print(value)
    1
    zhangsan
    男
    v
    >>> 

    也可以直接使用dict来遍历,等同于使用d.keys(),如:

    >>> for key in d:
        print(key) 
    id
    name
    gender
    k

    字典视图

    在使用dict.items(),dict.keys(),dict.vaules()时,返回的是一个字典视图,字典视图也可以当做一个iterable,除此之外,字典视图还能支持一些类似集合的操作,如:
    d1v & d2v:返回d1和d2的交集;
    d1v | d2v:返回d1和d2的并集;
    d1v - d2v:返回包含在d1但不包含在d2中的数据项的集合
    d1v ^ d2v:返回d1和d2的对称差集,即交集之外数据项的集合;

    >>> d1 = {}.fromkeys("ABCD",0)
    {'A': 0, 'B': 0, 'C': 0, 'D': 0}
    >>> d2 = {}.fromkeys("ABCDE",0)
    {'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 0}

    使用场景

    1.dict的键是唯一的,因此可以用来存放排他性项的数,这里使用dict.get(k,v)方法来统计一个str中各个字母出现的个数:

    >>> s = "hi,my name is James,nice to meet you"   #字符串
    >>> d = {}     #创建一个空dict字典
    >>> for letter in s.lower():   #将str全部变为小写后进行遍历
            d[letter]=d.get(letter,0)+1    #每次遍历的str作为K,将值+1
    >>> for element in d:
        print("the \"{0}\" occurs {1} times".format(element,d[element]))
    the "h" occurs 1 times
    the "i" occurs 3 times
    the "," occurs 2 times
    the "m" occurs 4 times
    the "y" occurs 2 times
    the " " occurs 6 times
    the "n" occurs 2 times
    the "a" occurs 2 times
    the "e" occurs 5 times
    the "s" occurs 2 times
    the "j" occurs 1 times
    the "c" occurs 1 times
    the "t" occurs 2 times
    the "o" occurs 2 times
    the "u" occurs 1 times
    >>> 

    在这个例子中,通过dict.get(K,V)将遍历的字母和出现的次数分别作为键和值,如果第一次不存在,则d[letter]=get(letter,0)使用默认值0,之后每次都会对letter+1。如果不使用dict.get(k,v),也可以按照如下方式进行:

    >>> for letter in s.lower():
            if letter not in d:
                d[letter] = 0
            d[letter]+=1

    dict.get(k,v)显然是更加巧妙。

    字典内涵

    在之前总结序列类型和集合类型时,为方便创建长的列表和集合,有了列表内涵和集合内涵的概念,同样的,python还提供了字典内涵这个语法用来创建非常长的字典,字典内涵是一个循环表达式,格式如下:
    {keyexpression:valueexpression for key,value in iterable if condition}

    2.collections.defaultdict(默认字典)

    defaultdict是dict的子类,它支持dict的所有的操作和方法。和dict的不同之处在于,如果dict中不包含某一个键,则通过dict[x]取值时出现KeyError异常,但是如果是defaultdict,则会创建一个新的项,键为该键,值为默认值。

    创建collections.defaultdict

    创建collections.defaultdict时,通过collections.defaultdict(),根据参数可以有两种方式进行创建:

    * 1.使用参数类型来创建:
    >>> import collections
    >>> cd1 = collections.defaultdict(int)
    >>> cd2 = collections.defaultdict(list)
    >>> cd3 = collections.defaultdict(str)
    >>> cd1["x"]
    0
    >>> cd2["x"]
    []
    >>> cd3["x"]
    ''
    >>> 

    这里分别使用了int、list、str,他们的默认值分别为0,[],”

    * 2.使用函数名来创建:
    >>> def name():
        return 'zhangsan'
    >>> cd4 = collections.defaultdict(name)
    >>> cd4["x"]
    'zhangsan'
    >>> 

    通过这种方式,可以使默认字典的默认值更加灵活。
    需要注意的是,collections.defaultdict()可以不传入参数或者传入None,但是如果这样,则不支持默认值,比如:

    >>> cd5 = collections.defaultdict()
    >>> cd5["x"]
    Traceback (most recent call last):
      File "<pyshell#254>", line 1, in <module>
        cd5["x"]
    KeyError: 'x'
    >>> 

    有了collections.defaultdict,可以代替dict中的get(k,v)setdefault()方法了。

    展开全文
  • python映射类型相关函数

    千次阅读 2017-08-14 23:14:02
    python映射类型相关函数

    1.dict()

    工厂函数被用来创建字典。如果不提供参数,会生成空字典。当容器类型对象做为一个参数传递给方法 dict() 时很有意思。如果参数是可以迭代的,即,一个序列,或是一个迭代器,或是一个支持迭代的对象,那每个可迭代的元素必须成对出现。在每个值对中,第一个元素是字典的键、第二个元素是字典中的值。见 Python 文档里关于 dict()的例子:

    >>> dict(zip(('x', 'y'), (1, 2)))
    {'y': 2, 'x': 1}
    >>> dict([['x', 1], ['y', 2]])
    {'y': 2, 'x': 1}
    >>> dict([('xy'[i-1], i) for i in range(1,3)])
    {'y': 2, 'x': 1}

    如果输入参数是(另)一个映射对象,比如,一个字典对象,对其调用 dict()会从存在的字典里复制内容来生成新的字典。新生成的字典是原来字典对象的浅复制版本, 它与用字典的内建方法copy() 生成的字典对象是一样的。但是从已存在的字典生成新的字典速度比用 copy()方法慢,推荐使用 copy()。从 Python 2.3 开始, 调用 dict()方法可以接受字典或关键字参数字典。

    >>> dict(x=1, y=2)
    {'y': 2, 'x': 1}
    >>> dict8 = dict(x=1, y=2)
    >>> dict8
    {'y': 2, 'x': 1}
    >>> dict9 = dict(**dict8)
    >>> dict9
    {'y': 2, 'x': 1}
    >>> dict9 = dict8.copy()
    >>> dict9
    {'y': 2, 'x': 1}

    2.len()

    内建函数 len()很灵活。它可用在序列、映射类型和集合上。对字典调用 len(),它会返回所有元素(键-值对)的数目:

    >>> dict2 = {'name': 'earth', 'port': 80}
    >>> dict2
    {'port': 80, 'name': 'earth'}
    >>> len(dict2)
    2

    3.hash()

    内建函数 hash()本身并不是为字典设计的方法, 但它可以判断某个对象是否可以做一个字典的键。将一个对象作为参数传递给 hash(), 会返回这个对象的哈希值。 只有这个对象是可哈希的,才可作为字典的键 (函数的返回值是整数,不产生错误或异常)。如果用比较操作符来比较两个数值,发现它们是相等的,那么即使二者的数据类型不同, 它们也会得到相同的哈希值。如果非可哈希类型作为参数传递给 hash()方法,会产生 TypeError 错误(因此,如果使用这样的对象作为键给字典赋值时会出错):

    >>> hash([])
    Traceback (innermost last): File "<stdin>", line 1, in ?
    TypeError: list objects are unhashable
    >>>
    >>> dict2[{}] = 'foo'
    Traceback (most recent call last): File "<stdin>", line 1, in ?
    TypeError: dict objects are unhashable

    4.映射类型的内建方法(映射类成员方法)

    方法名字作用
    dict.clear()删除字典中所有元素
    dict.copy()返回字典(浅复制)的一个副本
    dict.fromkeys(seq,val=None)创建并返回一个新字典,以 seq 中的元素做该字典的键,val 做该字典中所有键对应的初始值(如果不提供此值,则默认为 None)
    dict.get(key,default=None)对字典 dict 中的键 key,返回它对应的值 value,如果字典中不存在此键,则返回 default 的值(注意,参数 default 的默认值为 None)
    dict.has_key(key)如果键(key)在字典中存在, 返回 True, 否则返回 False. 在 Python2.2版本引入 in 和 not in 后,此方法几乎已废弃不用了,但仍提供一个可工作的接口。
    dict.items()返回一个包含字典中(键, 值)对元组的列表
    dict.keys()返回一个包含字典中键的列表
    dict.iter()方法 iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样,不同的是它们返回一个迭代器,而不是一个列表。
    dict.pop(key[, default])和方法 get()相似,如果字典中 key 键存在,删除并返回 dict[key],如果 key 键不存在,且没有给出 default 的值,引发 KeyError 异常。
    dict.setdefault(key,default=None)和方法 set()相似,如果字典中不存在 key 键,由 dict[key]=default 为它赋值。
    dict.update(dict2)将字典 dict2 的键-值对添加到字典 dict
    dict.values()返回一个包含字典中所有值的列表
    >>> dict2= {'host':'earth', 'port':80}
    >>> dict3= {'host':'venus', 'server':'http'}
    >>> dict2.update(dict3)
    >>> dict2
    {'server': 'http', 'port': 80, 'host': 'venus'}
    >>> dict3.clear()
    >>> dict3
    {}
    展开全文
  • TypeScript的映射类型

    千次阅读 2017-10-27 14:39:00
    映射类型 一个常见的任务是将一个已知的类型每个属性都变为可选的: interface PersonPartial { name?: string; age?: number; } 或者我们想要一个只读版本: interface PersonReadonly { readonly name: ...
  • Python学习笔记:映射类型

    千次阅读 2018-05-05 12:34:23
    字典是Python中唯一内建的映射类型,字典指定值并没有特殊顺序,都存储在一个特殊的键(key)里,键可以是数字、字符串或元组。映射是一种通过名字引用值得数据结构。 1、创建和使用字典 字典由多个键及其...
  • Python中的映射类型详解

    千次阅读 2020-07-18 13:50:11
    映射类型 collections.abc模块中有Mapping和MutableMapping这两个抽象基类,它们的作用事为dict和其他类似的类型定义形式接口 非抽象映射类型一般不会直接继承这些抽象基类,它们会直接对dict或者是collections....
  • 第三篇 映射类型

    2018-05-02 20:21:56
    1 映射类型中的字典python中通过名称访问各个值的数据结构称为映射;字典是python唯一的内置映射类型(key-value),其中key可以是数字、字符串或元组。1.1 字典的定义#创建字典data={'a11':1,'a22':2,'a22':3}#使用...
  • 映射类型:字典

    千次阅读 2018-01-02 14:58:42
    字典:如果想将值分组到一个结构中,并且通过编号对其进行引用,列表就能派上用场了。字典是一种通过名字引用值的数据结构,字典中的值并没有特殊的顺序,但是都是存储在一个特定的键(Key)里,键可以是数字、字符串...
  • Mapping,映射,相当于关系型数据库创建语句,定义文档字段及其类型、索引与存储方式。通常会涉及如下方面: 文档中哪些字段需要定义成全文索引字段。...1.1 映射类型 Elasticsearch支持meta-fields...
  • Python3入门之——映射类型

    千次阅读 2020-08-31 23:20:02
    映射是键值数据项的组合
  • 文章目录1.ElasticSearch 映射1.1 映射分类1.2 类型推断2.ElasticSearch 字段类型2.1 核心类型2.1.1 字符串类型2.1.2 数字类型2.1.3 日期类型2.1.4 布尔类型(boolean)2.1.5 二进制类型(binary)2.1.6 范围类型2.2...
  • # 下面代码报错:元组和列表不能直接相加 #print(a_tuple + [-20 , -30]) a_list = [20, 30, 50, 100] b_list = ['a', 'b', 'c'] # 计算列表相加 sum_list = a_list + b_list print(sum_list) # [20, 30, 50, 100,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 339,577
精华内容 135,830
关键字:

列表是映射类型吗