Detaillierte Einführung in Python-Tupel und -Wörterbücher

1. Tupel

1. Ausdruck des Tupels

（1,2,3,4）
（'olive',123）
（"python",）

Tupel erstellen:

a=tuple((1,2,3,))
b=("python",)

2. TupelfunktionenAttribute

class tuple(object):
    """
    tuple() -> empty tuple
    tuple(iterable) -> tuple initialized from iterable's items
    
    If the argument is a tuple, the return value is the same object.
    """
    def count(self, value): # real signature unknown; restored from __doc__
        """ T.count(value) -> integer -- return number of occurrences of value """
        return 0
    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
        """
        T.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.
        """
        return 0
    def __add__(self, *args, **kwargs): # real signature unknown
        """ Return self+value. """
        pass
    def __contains__(self, *args, **kwargs): # real signature unknown
        """ Return key in self. """
        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, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass
    def __getnewargs__(self, *args, **kwargs): # real signature unknown
        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 __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass
    def __init__(self, seq=()): # known special case of tuple.__init__
        """
        tuple() -> empty tuple
        tuple(iterable) -> tuple initialized from iterable's items
        
        If the argument is a tuple, the return value is the same object.
        # (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
    def __mul__(self, *args, **kwargs): # real signature unknown
        """ Return self*value.n """
        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 __rmul__(self, *args, **kwargs): # real signature unknown
        """ Return self*value. """
        pass
tuple

3. Einführung in einige funktionale Attribute von Tupeln

Tupel sind sehr Ähnlich wie Listen, aber die Elemente von Tupeln können nicht geändert werden, sodass viele Funktionen, die Listen haben, in Tupeln nicht verfügbar sind.

1) count(self, value):

Zählt die Anzahl der Wertelemente im Tupel und gibt einen int-Wert zurück.

a=(1,2,3,4,1,2,3,1,2,)
b=a.count(1)
print(a,type(a))
print(b,type(b))
#运行结果
(1, 2, 3, 4, 1, 2, 3, 1, 2) <class &#39;tuple&#39;>
3 <class &#39;int&#39;>
demo

2)index(self, value, start=None, stop=None):

index, Suche im Tupel Position, an der das Wertelement zum ersten Mal erscheint. Der Standardwert ist None und der int-Wert wird zurückgegeben. ist nicht im Tupel, wird zurückgegeben.

a=(1,2,3,4,1,2,3,1,2,)
b=a.index(3)
print(a,len(a))
print(b,type(b))
#运行结果
(1, 2, 3, 4, 1, 2, 3, 1, 2) 9
2 <class &#39;int&#39;>
demo

3) add(self, *args, **kwargs):

Füge ein neues Element zum Tupel hinzu, die neuen Elemente müssen in Form von Tupeln hinzugefügt werden, wodurch ein neues Tupel entsteht.

a=(1,2,3,4)
b=a.__add__((5,1))   #括号理给出的必须是元组
print(a,type(a))
print(b,type(b))
#运行结果
(1, 2, 3, 4) <class &#39;tuple&#39;>
(1, 2, 3, 4, 5, 1) <class &#39;tuple&#39;>
demo

4) enthält(self, *args, **kwargs):

Bestimmen Sie, ob das Tupel ein Element enthält, kehrt zurück ein boolescher Wert.

a=(1,2,3,4,1,2,3,1,2,)
b=a.__contains__(2)
c=a.__contains__(5)
print(a)
print(b)
print(c)
#运行结果
(1, 2, 3, 4, 1, 2, 3, 1, 2)
True
False
demo

2. Wörterbuch

1. Wörterbuchausdrücke erstellen:

{"name":"olive","age":18}

2. Funktionsattribute des Wörterbuchs

a={"name":"olive","age":18}
b=dict({"name":"lusi","age":18})

3. Einführung in einige Funktionsattribute des Wörterbuchs

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

1 )clear(self):
Alle Elemente im Wörterbuch löschen.

2) copy(self):

a={"name":"olive","age":18}
b=a.clear()
print(a)
print(b)
#运行结果
{}
None

Kopieren Sie ein Tupel, was einer flachen Kopie entspricht.

3) fromkeys(*args, **kwargs):[fromkeys(seq,value=None)]

a={"name": "olive","age":18}
b=a.copy()
print(a,id(a),id("name"))
print(b,id(b),id("name"))
#赋值
c={"name": "lusi","age":18}
d=c
print(c,id("name"))
print(d,id("name"))
#浅拷贝
e={"name": "shy","age":18}
f=copy.copy(e)
print(e,id(e),id("name"))
print(f,id(f),id("name"))
#运行结果
{'name': 'olive', 'age': 18} 2915224 2019840
{'name': 'olive', 'age': 18} 2915304 2019840
{'name': 'lusi', 'age': 18} 2019840
{'name': 'lusi', 'age': 18} 2019840
{'name': 'shy', 'age': 18} 5584616 2019840
{'name': 'shy', 'age': 18} 5586056 2019840

Erstellen Sie ein neues Wörterbuch für seq Der Schlüssel des Wörterbuchs, der Wert ist der Wert des Wörterbuchs und der Standardwert ist „Keine“. Geeignet zum Erstellen eines Wörterbuchs mit identischen Werten.

4) get(self, k, d=None):

a={"hunan": "changsha","guangdong":"guangzhou","jiangsu":"nanjing",'hubei':"wuhan"}
b=dict.fromkeys(a,"good")
c=dict.fromkeys(["a","b","c"],"abc")
d=dict.fromkeys("abcc")           
print(a)
print(b)
print(c)
print(d)
#运行结果
{'guangdong': 'guangzhou', 'hubei': 'wuhan', 'hunan': 'changsha', 'jiangsu': 'nanjing'}
{'hubei': 'good', 'guangdong': 'good', 'hunan': 'good', 'jiangsu': 'good'}
{'c': 'abc', 'b': 'abc', 'a': 'abc'}
{'c': None, 'b': None, 'a': None}   #seq给出的字符串c是重复的，但是创建的键只取一个。

Erhalten Sie das Wörterbuch mit dem Schlüssel-k-Wert Wenn k nicht im Wörterbuch enthalten ist, wird der d-Wert angegeben und d ist standardmäßig „None“.

5)

a={"a":1,"b":2,"c":3,"d":4}
b=a.get("a")
c=a.get("e")
d=a.get("e",5)
print(a)
print(b)
print(c)
print(d)
#运行结果
{'b': 2, 'a': 1, 'c': 3, 'd': 4}
1
None
5

items(self):

Eine Methode zum Durchlaufen des Wörterbuchs und zum Hinzufügen jedes Schlüsselpaars Das Wörterbuch zu Value bildet ein Tupel und gibt diese Tupel in einem listenähnlichen dict_items zurück.

6) Tasten (selbst):

a={"a":1,"b":2,"c":3,"d":4}
b=a.items()
print(a)
print(b,type(b))
#运行结果
{'d': 4, 'c': 3, 'a': 1, 'b': 2}
dict_items([('d', 4), ('c', 3), ('a', 1), ('b', 2)]) <class &#39;dict_items&#39;>

Eine Methode zum Durchlaufen von Wörterbuchtasten und zum Zurückgeben einer Liste wie dict_keys, genau wie die Die Verwendung der Artikelmethode ist gleich.

7) Werte (selbst):

a={"a":1,"b":2,"c":3,"d":4}
b=a.keys()
print(a)
print(b,type(b))
#运行结果
{'b': 2, 'a': 1, 'c': 3, 'd': 4}
dict_keys(['b', 'a', 'c', 'd']) <class &#39;dict_keys&#39;>

Eine Methode zum Durchlaufen des Wörterbuchwerts und zum Zurückgeben einer Liste. Hat wie dict_values ​​die gleiche Verwendung wie die Methode items.

8)

pop(self, k, d=None):

a={"a":1,"b":2,"c":3,"d":4}
b=a.values()
print(a)
print(b,type(b))
#运行结果
{'c': 3, 'd': 4, 'b': 2, 'a': 1}
dict_values([3, 4, 2, 1]) <class &#39;dict_values&#39;>

und Die Verwendung der get-Methode ist ähnlich, außer dass get dazu dient, den Wert mit Schlüssel k im Wörterbuch abzurufen, während pop dazu dient, den Wert mit Schlüssel k aus dem Wörterbuch herauszunehmen. Wenn der Schlüssel k nicht im Wörterbuch enthalten ist und d nicht der Standardwert ist, ist der erhaltene Wert der d-Wert. Wenn d der Standardwert None ist, wird ein KeyError gemeldet.

a={"a":1,"b":2,"c":3,"d":4}
b=a.pop("a")
c=a.pop("e","five")
print(a)
print(b,type(b))
print(c,type(c))
#运行结果
{'c': 3, 'd': 4, 'b': 2}
1 <class &#39;int&#39;>
five <class &#39;str&#39;>

9)

popitem(self):

从字典中随机取出一组键值，返回一个新的元组。如果字典中无键值可取，则KeyError报错。

a={"a":1,"b":2,"c":3,"d":4}
b=a.popitem()
print(a)
print(b,type(b))
#运行结果
{'d': 4, 'b': 2, 'a': 1}
('c', 3) <class &#39;tuple&#39;>

10）setdefault(self, k, d=None):

从字典中获取键为k的值，当字典中包含键k值时，功能和get基本一致，当字典中不包含键k值时，在原字典上添加上键为k的初始键值对，并返回值d。

a={"a":1,"b":2,"c":3,"d":4}
b=a.setdefault("a")
c=a.setdefault("e")
d=a.setdefault("f",6)
print(a)
print(b)
print(c)
print(d)
#运行结果
{'f': 6, 'c': 3, 'a': 1, 'e': None, 'b': 2, 'd': 4}
1
None
6

11）update(self, E=None, **F):

给字典新增元素，没有返回值。用法：dict.update(dict2)。

a={"a":1,"b":2,"c":3,"d":4}
b=a.update({"e":5})
print(a)
print(b)
#运行结果
{'c': 3, 'b': 2, 'd': 4, 'a': 1, 'e': 5}
None

12）contains(self, *args, **kwargs):

判断列表中是否包含某个键值对，返回布尔值。用法：dict.contains(keys)。

a={"a":1,"b":2,"c":3,"d":4}
b=a.__contains__("a")
print(a)
print(b)
#运行结果
{'a': 1, 'd': 4, 'c': 3, 'b': 2}
True

13）delitem(self, *args, **kwargs):

删除字典中的某个键值对，没有返回值。用法：dict.delitem(keys)。

a={"a":1,"b":2,"c":3,"d":4}
b=a.__delitem__("a")
print(a)
print(b)
#运行结果
{'c': 3, 'b': 2, 'd': 4}
None

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in Python-Tupel und -Wörterbücher. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!