ฉันได้อ่านตัวอย่างใน python docs แล้ว แต่ก็ยังไม่สามารถเข้าใจได้ว่าวิธีนี้มีความหมายอย่างไร ใครช่วยได้บ้าง นี่คือตัวอย่างสองตัวอย่างจาก python docs

>>> from collections import defaultdict

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1
...
>>> d.items()
[('i', 4), ('p', 2), ('s', 4), ('m', 1)]

และ

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> for k, v in s:
...     d[k].append(v)
...
>>> d.items()
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

พารามิเตอร์intและlistมีไว้เพื่ออะไร

โดยปกติแล้วพจนานุกรม Python จะส่ง a KeyErrorหากคุณพยายามรับรายการที่มีรหัสที่ไม่ได้อยู่ในพจนานุกรม defaultdictในทางตรงกันข้ามก็จะสร้างรายการใด ๆ ที่คุณพยายามที่จะเข้าถึง (ให้แน่นอนพวกเขาไม่อยู่เลย) ในการสร้างรายการ "เริ่มต้น" มันจะเรียกวัตถุฟังก์ชั่นที่คุณส่งไปยังตัวสร้าง (แม่นยำยิ่งขึ้นมันเป็นวัตถุ "เรียกได้" โดยพลการซึ่งรวมถึงฟังก์ชั่นและวัตถุประเภท) สำหรับตัวอย่างแรกรายการเริ่มต้นจะถูกสร้างขึ้นโดยใช้ซึ่งจะกลับวัตถุจำนวนเต็มint() 0สำหรับตัวอย่างที่สองรายการเริ่มต้นถูกสร้างขึ้นโดยใช้list()ซึ่งจะส่งกลับวัตถุรายการว่างเปล่าใหม่

defaultdictหมายความว่าหากไม่พบรหัสในพจนานุกรมจากนั้นแทนที่จะKeyErrorถูกโยนทิ้งรายการใหม่จะถูกสร้างขึ้น ชนิดของรายการใหม่นี้ถูกกำหนดโดยอาร์กิวเมนต์ของ defaultdict

ตัวอย่างเช่น:

somedict = {}
print(somedict[3]) # KeyError

someddict = defaultdict(int)
print(someddict[3]) # print int(), thus 0

defaultdict

"พจนานุกรมมาตรฐานมีวิธี setdefault () สำหรับดึงค่าและสร้างค่าเริ่มต้นหากไม่มีค่าในทางตรงข้ามdefaultdictให้ผู้เรียกระบุค่าเริ่มต้น (ค่าที่จะส่งคืน) ล่วงหน้าเมื่อคอนเทนเนอร์เริ่มต้น"

ตามที่กำหนดโดยDoug HellmannในPython Standard Library ตามตัวอย่าง

วิธีใช้ defaultdict

นำเข้า defaultdict

>>> from collections import defaultdict

เริ่มต้น defaultdict

เริ่มต้นมันผ่าน

callableเป็นอาร์กิวเมนต์แรก (จำเป็น)

>>> d_int = defaultdict(int)
>>> d_list = defaultdict(list)
>>> def foo():
...     return 'default value'
... 
>>> d_foo = defaultdict(foo)
>>> d_int
defaultdict(<type 'int'>, {})
>>> d_list
defaultdict(<type 'list'>, {})
>>> d_foo
defaultdict(<function foo at 0x7f34a0a69578>, {})

** kwargsเป็นอาร์กิวเมนต์ที่สอง (เป็นทางเลือก)

>>> d_int = defaultdict(int, a=10, b=12, c=13)
>>> d_int
defaultdict(<type 'int'>, {'a': 10, 'c': 13, 'b': 12})

หรือ

>>> kwargs = {'a':10,'b':12,'c':13}
>>> d_int = defaultdict(int, **kwargs)
>>> d_int
defaultdict(<type 'int'>, {'a': 10, 'c': 13, 'b': 12})

มันทำงานอย่างไร

เช่นเดียวกับคลาสลูกของพจนานุกรมมาตรฐานมันสามารถทำหน้าที่เดียวกันทั้งหมดได้

แต่ในกรณีที่ผ่านคีย์ที่ไม่รู้จักมันจะส่งกลับค่าเริ่มต้นแทนข้อผิดพลาด ตัวอย่างเช่น:

>>> d_int['a']
10
>>> d_int['d']
0
>>> d_int
defaultdict(<type 'int'>, {'a': 10, 'c': 13, 'b': 12, 'd': 0})

ในกรณีที่คุณต้องการเปลี่ยนค่าเริ่มต้นเขียนทับ default_factory:

>>> d_int.default_factory = lambda: 1
>>> d_int['e']
1
>>> d_int
defaultdict(<function <lambda> at 0x7f34a0a91578>, {'a': 10, 'c': 13, 'b': 12, 'e': 1, 'd': 0})

หรือ

>>> def foo():
...     return 2
>>> d_int.default_factory = foo
>>> d_int['f']
2
>>> d_int
defaultdict(<function foo at 0x7f34a0a0a140>, {'a': 10, 'c': 13, 'b': 12, 'e': 1, 'd': 0, 'f': 2})

ตัวอย่างในคำถาม

ตัวอย่างที่ 1

เนื่องจาก int ถูกส่งผ่านเป็น default_factory คีย์ใด ๆ ที่ไม่รู้จักจะส่งกลับค่า 0 ตามค่าเริ่มต้น

ตอนนี้เมื่อสตริงถูกส่งผ่านในลูปมันจะเพิ่มจำนวนตัวอักษรเหล่านั้นเป็น d

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> d.default_factory
<type 'int'>
>>> for k in s:
...     d[k] += 1
>>> d.items()
[('i', 4), ('p', 2), ('s', 4), ('m', 1)]
>>> d
defaultdict(<type 'int'>, {'i': 4, 'p': 2, 's': 4, 'm': 1})

ตัวอย่างที่ 2

เนื่องจากรายการถูกส่งผ่านเป็น default_factory คีย์ใด ๆ ที่ไม่รู้จัก (ไม่มีอยู่) จะส่งคืน [] (เช่นรายการ) ตามค่าเริ่มต้น

ในขณะที่รายการ tuples ถูกส่งผ่านในลูปมันจะผนวกค่าใน d [color]

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> d.default_factory
<type 'list'>
>>> for k, v in s:
...     d[k].append(v)
>>> d.items()
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
>>> d
defaultdict(<type 'list'>, {'blue': [2, 4], 'red': [1], 'yellow': [1, 3]})

พจนานุกรมเป็นวิธีที่สะดวกในการจัดเก็บข้อมูลเพื่อการสืบค้นในภายหลังโดยใช้ชื่อ (รหัส) คีย์ต้องเป็นวัตถุที่ไม่เปลี่ยนแปลงและไม่เหมือนใคร ค่าในพจนานุกรมสามารถเป็นอะไรก็ได้ สำหรับแอ็พพลิเคชันจำนวนมากค่าเป็นชนิดง่าย ๆ เช่นจำนวนเต็มและสตริง

มันน่าสนใจมากขึ้นเมื่อค่าในพจนานุกรมคือการรวบรวม (รายการ, dicts, ฯลฯ ) ในกรณีนี้ค่า (รายการว่างหรือ dict) จะต้องเริ่มต้นในครั้งแรกที่มีการใช้คีย์ที่กำหนด ขณะนี้ค่อนข้างง่ายที่จะทำด้วยตนเองประเภท defaultdict อัตโนมัติและลดความซับซ้อนของการดำเนินงานประเภทนี้ defaultdict ทำงานเหมือนกับ dict ปกติ แต่เริ่มต้นได้ด้วยฟังก์ชั่น (“ default factory”) ที่ไม่มีการขัดแย้งและให้ค่าเริ่มต้นสำหรับคีย์ที่ไม่มีอยู่

ค่าเริ่มต้นจะไม่เพิ่ม KeyError คีย์ใด ๆ ที่ไม่มีอยู่จะได้รับค่าส่งคืนโดยค่าเริ่มต้นจากโรงงาน

from collections import defaultdict
ice_cream = defaultdict(lambda: 'Vanilla')

ice_cream['Sarah'] = 'Chunky Monkey'
ice_cream['Abdul'] = 'Butter Pecan'

print(ice_cream['Sarah'])
>>>Chunky Monkey

print(ice_cream['Joe'])
>>>Vanilla

นี่เป็นอีกตัวอย่างในการใช้ defaultdict เราสามารถลดความซับซ้อนได้

from collections import defaultdict
# Time complexity O(n^2)
def delete_nth_naive(array, n):
    ans = []
    for num in array:
        if ans.count(num) < n:
            ans.append(num)
    return ans

# Time Complexity O(n), using hash tables.
def delete_nth(array,n):
    result = []
    counts = defaultdict(int)

    for i in array:
        if counts[i] < n:
            result.append(i)
            counts[i] += 1
    return result


x = [1,2,3,1,2,1,2,3]
print(delete_nth(x, n=2))
print(delete_nth_naive(x, n=2))

โดยสรุปเมื่อใดก็ตามที่คุณต้องการพจนานุกรมและค่าของแต่ละองค์ประกอบควรเริ่มต้นด้วยค่าเริ่มต้นให้ใช้ defaultdict

มีคำอธิบายที่ดีของ defaultdicts ที่นี่: http://ludovf.net/blog/python-collections-defaultdict/

โดยทั่วไปแล้วพารามิเตอร์intและรายการเป็นฟังก์ชั่นที่คุณผ่าน จำไว้ว่า Python ยอมรับชื่อฟังก์ชั่นเป็นอาร์กิวเมนต์ intส่งคืนค่า 0 โดยค่าเริ่มต้นและรายการส่งคืนรายการว่างเมื่อถูกเรียกด้วยวงเล็บ

ในพจนานุกรมปกติถ้าในตัวอย่างของคุณฉันลองโทรd[a]ฉันจะได้รับข้อผิดพลาด (KeyError) เนื่องจากมีเฉพาะคีย์ m, s, i และ p เท่านั้นและคีย์ a ยังไม่ได้เริ่มต้น แต่ใน defaultdict มันใช้ชื่อฟังก์ชั่นเป็นอาร์กิวเมนต์เมื่อคุณพยายามที่จะใช้คีย์ที่ยังไม่ได้เริ่มต้นมันก็จะเรียกฟังก์ชั่นที่คุณผ่านและกำหนดค่ากลับเป็นค่าของคีย์ใหม่

เนื่องจากคำถามเกี่ยวกับ "วิธีการทำงาน" ผู้อ่านบางคนอาจต้องการเห็นน็อตและสลักเกลียวเพิ่มเติม โดยเฉพาะวิธีการที่เป็นปัญหาคือ__missing__(key)วิธีการ ดู: https://docs.python.org/2/library/collections.html#defaultdict-objects

คำตอบนี้แสดงให้เห็นถึงวิธีการใช้__missing__(key)ประโยชน์อย่างแท้จริงยิ่งขึ้น: https://stackoverflow.com/a/17956989/1593924

เพื่อชี้แจงความหมายของ 'callable' นี่คือเซสชันแบบโต้ตอบ (จาก 2.7.6 แต่ควรทำงานใน v3 ด้วย):

>>> x = int
>>> x
<type 'int'>
>>> y = int(5)
>>> y
5
>>> z = x(5)
>>> z
5

>>> from collections import defaultdict
>>> dd = defaultdict(int)
>>> dd
defaultdict(<type 'int'>, {})
>>> dd = defaultdict(x)
>>> dd
defaultdict(<type 'int'>, {})
>>> dd['a']
0
>>> dd
defaultdict(<type 'int'>, {'a': 0})

นั่นคือการใช้ defaultdict ทั่วไปมากที่สุด (ยกเว้นการใช้ตัวแปร x อย่างไม่มีจุดหมาย) คุณสามารถทำสิ่งเดียวกันกับ 0 เป็นค่าเริ่มต้นที่ชัดเจน แต่ไม่ใช่ด้วยค่าง่าย ๆ :

>>> dd2 = defaultdict(0)

Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    dd2 = defaultdict(0)
TypeError: first argument must be callable

แต่จะใช้งานได้ดังต่อไปนี้เพราะมันส่งผ่านฟังก์ชั่นง่าย ๆ (มันจะสร้างฟังก์ชั่นนิรนามที่ไม่มีข้อโต้แย้งและส่งกลับ 0 เสมอ):

>>> dd2 = defaultdict(lambda: 0)
>>> dd2
defaultdict(<function <lambda> at 0x02C4C130>, {})
>>> dd2['a']
0
>>> dd2
defaultdict(<function <lambda> at 0x02C4C130>, {'a': 0})
>>> 

และด้วยค่าเริ่มต้นที่แตกต่างกัน:

>>> dd3 = defaultdict(lambda: 1)
>>> dd3
defaultdict(<function <lambda> at 0x02C4C170>, {})
>>> dd3['a']
1
>>> dd3
defaultdict(<function <lambda> at 0x02C4C170>, {'a': 1})
>>> 

ของฉันเอง 2 ¢: คุณสามารถ subclass defaultdict:

class MyDict(defaultdict):
    def __missing__(self, key):
        value = [None, None]
        self[key] = value
        return value

นี่อาจเป็นประโยชน์สำหรับกรณีที่ซับซ้อนมาก

พฤติกรรมของdefaultdictสามารถเลียนแบบได้อย่างง่ายดายโดยใช้dict.setdefaultแทนd[key]ในทุกสาย

กล่าวอีกนัยหนึ่งรหัส:

from collections import defaultdict

d = defaultdict(list)

print(d['key'])                        # empty list []
d['key'].append(1)                     # adding constant 1 to the list
print(d['key'])                        # list containing the constant [1]

เทียบเท่ากับ:

d = dict()

print(d.setdefault('key', list()))     # empty list []
d.setdefault('key', list()).append(1)  # adding constant 1 to the list
print(d.setdefault('key', list()))     # list containing the constant [1]

ความแตกต่างเพียงอย่างเดียวคือการใช้defaultdictlist constructor จะถูกเรียกเพียงครั้งเดียวและการใช้dict.setdefaultlist constructor จะถูกเรียกบ่อยกว่า (แต่รหัสอาจถูกเขียนซ้ำเพื่อหลีกเลี่ยงสิ่งนี้หากจำเป็นจริงๆ)

บางคนอาจโต้แย้งว่ามีการพิจารณาประสิทธิภาพการทำงาน แต่หัวข้อนี้เป็นเขตที่วางทุ่นระเบิด โพสต์นี้แสดงให้เห็นว่าไม่มีการเพิ่มขึ้นของประสิทธิภาพในการใช้ defaultdict ตัวอย่างเช่น

IMO, defaultdict เป็นชุดที่เพิ่มความสับสนมากกว่าผลประโยชน์ให้กับรหัส ไร้ประโยชน์สำหรับฉัน แต่คนอื่นอาจคิดแตกต่างกัน

เครื่องมือ defaultdict เป็นที่เก็บในคลาสของ Python คล้ายกับที่เก็บพจนานุกรม (dict) ตามปกติ แต่มีความแตกต่างเดียว: ชนิดข้อมูลของเขตข้อมูลค่าจะถูกระบุเมื่อเริ่มต้น

ตัวอย่างเช่น:

from collections import defaultdict

d = defaultdict(list)

d['python'].append("awesome")

d['something-else'].append("not relevant")

d['python'].append("language")

for i in d.items():

    print i

ภาพพิมพ์นี้:

('python', ['awesome', 'language'])
('something-else', ['not relevant'])

ฉันคิดว่ามันใช้งานได้ดีที่สุดแทนคำสั่ง switch case ลองนึกภาพถ้าเรามีคำสั่งเปลี่ยนกรณีดังต่อไปนี้:

option = 1

switch(option) {
    case 1: print '1st option'
    case 2: print '2nd option'
    case 3: print '3rd option'
    default: return 'No such option'
}

ไม่มีswitchคำสั่งกรณีที่มีอยู่ในหลาม defaultdictเราสามารถบรรลุเดียวกันโดยใช้

from collections import defaultdict

def default_value(): return "Default Value"
dd = defaultdict(default_value)

dd[1] = '1st option'
dd[2] = '2nd option'
dd[3] = '3rd option'

print(dd[4])    
print(dd[5])    
print(dd[3])

มันพิมพ์:

Default Value
Default Value
3rd option

ในตัวอย่างข้างต้นddไม่มีปุ่ม 4 หรือ 5 และด้วยเหตุนี้มันจึงพิมพ์ค่าเริ่มต้นซึ่งเราได้กำหนดค่าในฟังก์ชั่นตัวช่วย นี่ค่อนข้างดีกว่าพจนานุกรมดิบที่มีการKeyErrorโยนทิ้งหากไม่มีคีย์ จากนี้เห็นได้ชัดว่าdefaultdictเหมือนคำสั่งกรณีสวิตช์ที่เราสามารถหลีกเลี่ยงความซับซ้อนif-elif-elif-elseบล็อกที่

อีกหนึ่งตัวอย่างที่ดีที่ทำให้ฉันประทับใจมากจากไซต์นี้คือ:

>>> from collections import defaultdict
>>> food_list = 'spam spam spam spam spam spam eggs spam'.split()
>>> food_count = defaultdict(int) # default value of int is 0
>>> for food in food_list:
...     food_count[food] += 1 # increment element's value by 1
...
defaultdict(<type 'int'>, {'eggs': 1, 'spam': 7})
>>>

ถ้าเราพยายามที่จะเข้าถึงรายการอื่น ๆ กว่าeggsและspamเราจะได้รับการนับของ 0

หากไม่มีdefaultdictคุณอาจกำหนดค่าใหม่ให้กับปุ่มที่มองไม่เห็น แต่คุณไม่สามารถแก้ไขได้ ตัวอย่างเช่น:

import collections
d = collections.defaultdict(int)
for i in range(10):
  d[i] += i
print(d)
# Output: defaultdict(<class 'int'>, {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9})

import collections
d = {}
for i in range(10):
  d[i] += i
print(d)
# Output: Traceback (most recent call last): File "python", line 4, in <module> KeyError: 0

ดี defaultdict ยังสามารถเพิ่ม keyerror ในกรณีต่อไปนี้:

    from collections import defaultdict
    d = defaultdict()
    print(d[3]) #raises keyerror

อย่าลืมให้อาร์กิวเมนต์กับ defaultdict เช่น defaultdict (int)

พจนานุกรมมาตรฐานรวมถึงวิธีการ setdefault () สำหรับการดึงค่าและสร้างค่าเริ่มต้นหากไม่มีค่า ในทางตรงกันข้าม defaultdict ให้ผู้เรียกระบุค่าเริ่มต้นล่วงหน้าเมื่อคอนเทนเนอร์ถูกกำหนดค่าเริ่มต้น

import collections

def default_factory():
    return 'default value'

d = collections.defaultdict(default_factory, foo='bar')
print 'd:', d
print 'foo =>', d['foo']
print 'bar =>', d['bar']

มันทำงานได้ดีตราบใดที่มันเหมาะสมสำหรับปุ่มทุกปุ่มที่มีค่าเริ่มต้นเหมือนกัน มันจะมีประโยชน์โดยเฉพาะอย่างยิ่งถ้าเริ่มต้นเป็นประเภทที่ใช้สำหรับการรวมหรือการสะสมค่าเช่นรายการชุดหรือแม้กระทั่ง int เอกสารประกอบไลบรารีมาตรฐานประกอบด้วยตัวอย่างการใช้ defaultdict ด้วยวิธีนี้

$ python collections_defaultdict.py

d: defaultdict(<function default_factory at 0x100468c80>, {'foo': 'bar'})
foo => bar
bar => default value

ในระยะสั้น:

defaultdict(int) - อาร์กิวเมนต์ int ระบุว่าค่าจะเป็นประเภท int

defaultdict(list) - รายการอาร์กิวเมนต์ระบุว่าค่าจะเป็นประเภทรายการ

เอกสารและคำอธิบายนั้นอธิบายได้ด้วยตนเอง:

http://docs.python.org/library/collections.html#collections.defaultdict

ประเภทฟังก์ชั่น (int / str ฯลฯ ) ผ่านเป็นอาร์กิวเมนต์ที่ใช้ในการเริ่มต้นค่าเริ่มต้นสำหรับคีย์ที่กำหนดใด ๆ ที่คีย์ไม่ปรากฏใน dict