Heim > Artikel > Backend-Entwicklung > Detaillierte grafische Erläuterung des Python-Set-Typs (Listen-Tupel-Dikt-Set-Generator)
Zu den in
Python integrierten Sammlungstypen gehören list, tuple, set und dict.
Liste: sieht aus wie Array, ist aber leistungsfähiger als Array und unterstützt Funktionen wie Indizierung, Slicing, Suche und Addition.
Tupel-Tupel: Die Funktion ähnelt der Liste, aber nach der Generierung sind die Länge und die Elemente nicht variabel (die Elemente der Elemente sind immer noch variabel), was eine leichtere und sicherere Liste zu sein scheint.
Dictionary-Dikt: Eine Hash-Tabelle mit Schlüssel-Wert-Paar-Struktur, die dieselben Eigenschaften wie ein Schlüssel hat, ist ungeordnet und nicht wiederholbar, und das Hinzufügen, Löschen und Ändern ist praktisch Und schnell.
Set: Ein ungeordneter und sich nicht wiederholender Satz, der nur Schlüssel und keine Werte enthält. Ich hoffe, dass Python nicht so ist Wert, daher werden viele Hinweise weggelassen.
Generator:
wird als Generator oder Listenverständnis bezeichnet, bei dem es sich um einen speziellen Datentyp handelt Es handelt sich eigentlich nicht um eine Datenstruktur, sondern enthält nur den Algorithmus und den temporären Zustand und hat die Funktion der Iteration.
Sehen Sie sich zunächst die Speichernutzung an und verwenden Sie Generatoren, um Mengen, Diktate, Generatoren, Tupel und Listen mit 100.000 Elementen zu generieren. Der von Diktat, Menge, Liste und Tupel verbrauchte Speicher nimmt nacheinander ab, und auch die Größe der generierten Objekte bleibt gleich. Da der Generator keine Datentabelle generiert, muss er keinen Speicher verbrauchen:import sys from memory_profiler import profile @profile def create_data(data_size): data_generator = (x for x in xrange(data_size)) data_set = {x for x in xrange(data_size)} data_dict = {x:None for x in xrange(data_size)} data_tuple = tuple(x for x in xrange(data_size)) data_list = [x for x in xrange(data_size)] return data_set, data_dict, data_generator, data_tuple, data_list data_size = 100000 for data in create_data(data_size): print data.__class__, sys.getsizeof(data) Line # Mem usage Increment Line Contents ================================================ 14.6 MiB 0.0 MiB @profile def create_data(data_size): 14.7 MiB 0.0 MiB data_generator = (x for x in xrange(data_size)) 21.4 MiB 6.7 MiB data_set = {x for x in xrange(data_size)} 29.8 MiB 8.5 MiB data_dict = {x:None for x in xrange(data_size)} 33.4 MiB 3.6 MiB data_tuple = tuple(x for x in xrange(data_size)) 38.2 MiB 4.8 MiB data_list = [x for x in xrange(data_size)] 38.2 MiB 0.0 MiB return data_set, data_dict, data_generator, data_tuple, data_list <type 'set'> 4194528 <type 'dict'> 6291728 <type 'generator'> 72 <type 'tuple'> 800048 <type 'list'> 824464Sehen Sie sich noch einmal die Suchleistung an. dict und set sind konstante Suchzeiten (O(1)) und list und Tupel sind lineare Suchzeiten. Verwenden Sie den Generator, um ein Objekt mit bestimmten Größenelementen zu generieren, und verwenden Sie für die Suche zufällig generierte Zahlen:
import time import sys import random from memory_profiler import profile def create_data(data_size): data_set = {x for x in xrange(data_size)} data_dict = {x:None for x in xrange(data_size)} data_tuple = tuple(x for x in xrange(data_size)) data_list = [x for x in xrange(data_size)] return data_set, data_dict, data_tuple, data_list def cost_time(func): def cost(*args, **kwargs): start = time.time() r = func(*args, **kwargs) cost = time.time() - start print 'find in %s cost time %s' % (r, cost) return r, cost #返回数据的类型和方法执行消耗的时间 return cost @cost_time def test_find(test_data, data): for d in test_data: if d in data: pass return data.__class__.__name__ data_size = 100 test_size = 10000000 test_data = [random.randint(0, data_size) for x in xrange(test_size)] #print test_data for data in create_data(data_size): test_find(test_data, data) 输出: ---------------------------------------------- find in <type 'set'> cost time 0.47200012207 find in <type 'dict'> cost time 0.429999828339 find in <type 'tuple'> cost time 5.36500000954 find in <type 'list'> cost time 5.53399991989Ein Satz von 100 Elementen, Suche Bei 1000 W ist der Unterschied deutlich zu erkennen. Diese Zufallszahlen sind jedoch alle in der Sammlung zu finden. Ändern Sie die Zufallszahlenmethode so, dass die Hälfte der generierten Zahlen gefunden werden kann und die andere Hälfte nicht gefunden werden kann. Aus den gedruckten Informationen ist ersichtlich, dass Liste und Tupel noch schlechter abschneiden, wenn die Hälfte der schlechtesten Suchbeispiele vorhanden ist.
def randint(index, data_size): return random.randint(0, data_size) if (x % 2) == 0 else random.randint(data_size, data_size * 2) test_data = [randint(x, data_size) for x in xrange(test_size)] 输出: ---------------------------------------------- find in <type 'set'> cost time 0.450000047684 find in <type 'dict'> cost time 0.397000074387 find in <type 'tuple'> cost time 7.83299994469 find in <type 'list'> cost time 8.27800011635Die Anzahl der Elemente erhöht sich von 10 auf 500. Statistiken über die Zeit, die jeweils für die Suche benötigt wird, werden verwendet, um die Zeitverbrauchskurve anzupassen. Die Ergebnisse beweisen dies dict und set spielen keine Rolle bei der Anzahl der Elemente. Da die Elemente wachsen, zeigen dict und tuple eine lineare Wachstumszeit:
import matplotlib.pyplot as plot from numpy import * data_size = array([x for x in xrange(10, 500, 10)]) test_size = 100000 cost_result = {} for size in data_size: test_data = [randint(x, size) for x in xrange(test_size)] for data in create_data(size): name, cost = test_find(test_data, data) #装饰器函数返回函数的执行时间 cost_result.setdefault(name, []).append(cost) plot.figure(figsize=(10, 6)) xline = data_size for data_type, result in cost_result.items(): yline = array(result) plot.plot(xline, yline, label=data_type) plot.ylabel('Time spend') plot.xlabel('Find times') plot.grid() plot.legend() plot.show()Der Unterschied in der Iterationszeit ist sehr gering und Diktat und Satz erfordern etwas mehr Zeit:
@cost_time def test_iter(data): for d in data: pass return data.__class__ .__name__ data_size = array([x for x in xrange(1, 500000, 1000)]) cost_result = {} for size in data_size: for data in create_data(size): name, cost = test_iter(data) cost_result.setdefault(name, []).append(cost) #拟合曲线图 plot.figure(figsize=(10, 6)) xline = data_size for data_type, result in cost_result.items(): yline = array(result) plot.plot(xline, yline, label=data_type) plot.ylabel('Time spend') plot.xlabel('Iter times') plot.grid() plot.legend() plot.show()Der Zeitverbrauch für das Löschen von Elementen ist unten dargestellt. 1000 Elemente werden zufällig gelöscht. Der Tupeltyp kann keine Elemente löschen, daher wird kein Vergleich durchgeführt:
@cost_time def test_dict_add(test_data, data): for d in test_data: data[d] = None return data.__class__ .__name__ @cost_time def test_set_add(test_data, data): for d in test_data: data.add(d) return data.__class__ .__name__ @cost_time def test_list_add(test_data, data): for d in test_data: data.append(d) return data.__class__ .__name__ #初始化数据,指定每种类型对应它添加元素的方法 def init_data(): test_data = { 'list': (list(), test_list_add), 'set': (set(), test_set_add), 'dict': (dict(), test_dict_add) } return test_data #每次检测10000增量大小的数据的添加时间 data_size = array([x for x in xrange(10000, 1000000, 10000)]) cost_result = {} for size in data_size: test_data = [x for x in xrange(size)] for data_type, (data, add) in init_data().items(): name, cost = add(test_data, data) #返回方法的执行时间 cost_result.setdefault(data_type, []).append(cost) plot.figure(figsize=(10, 6)) xline = data_size for data_type, result in cost_result.items(): yline = array(result) plot.plot(xline, yline, label=data_type) plot.ylabel('Time spend') plot.xlabel('Add times') plot.grid() plot.legend() plot.show()
Das obige ist der detaillierte Inhalt vonDetaillierte grafische Erläuterung des Python-Set-Typs (Listen-Tupel-Dikt-Set-Generator). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!