Python Dictionary – ทุกสิ่งที่คุณต้องรู้

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

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

มีความหลากหลายมากและสามารถรองรับคอลเลกชันที่เปลี่ยนแปลงและสั่งซื้อได้โดยไม่ต้องใช้คีย์ซ้ำ

ขณะที่เราเจาะลึก พจนานุกรม Pythonในบทความนี้ คุณจะพบว่าพจนานุกรมเหล่านั้นเป็นเครื่องมือที่ทรงพลังสำหรับการจัดระเบียบและเข้าถึงข้อมูลของคุณ

ดังนั้น อย่าลืมทำความคุ้นเคยกับพจนานุกรม Pythonแบบเจาะลึกเพื่อปลดล็อกศักยภาพทั้งหมดในโครงการของคุณ!

สารบัญ

• ทำความเข้าใจพจนานุกรม Python
• วิธีสร้างพจนานุกรม Python
  • การใช้วงเล็บปีกกา
  • ใช้ตัวสร้าง Dict
• วิธีเข้าถึงองค์ประกอบพจนานุกรม
  • การใช้คีย์
  • ใช้วิธีการรับ
• วิธีแก้ไของค์ประกอบพจนานุกรม
  • การเพิ่มองค์ประกอบใหม่
  • การอัปเดตองค์ประกอบที่มีอยู่
• การลบองค์ประกอบพจนานุกรม
  • คำหลัก Del
  • วิธีการที่ชัดเจน
• วิธีการทั่วไปในพจนานุกรมมีอะไรบ้าง?
  • กุญแจ
  • ค่า
  • รายการ
  • อัปเดต
  • โผล่
  • ป๊อปปี้เตม
• การใช้พจนานุกรม Python
  • วนซ้ำพจนานุกรม
  • ความเข้าใจในพจนานุกรมคืออะไร?
  • พจนานุกรมที่ซ้อนกันคืออะไร?
• กรณีการใช้พจนานุกรมทั่วไป

ทำความเข้าใจพจนานุกรม Python

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

หากต้องการสร้างพจนานุกรม คุณสามารถใช้วงเล็บปีกกา ( { } ) ล้อมรอบรายการคู่คีย์-ค่าที่คั่นด้วยเครื่องหมายจุลภาค ตัวอย่างเช่น:

your_dict = {"key1": "value1", "key2": "value2", "key3": "value3"}

โปรดทราบว่าพจนานุกรมใน Python นั้นไม่แน่นอน ซึ่งหมายความว่าคุณสามารถแก้ไขเนื้อหาได้หลังจากที่สร้างขึ้น หากต้องการเพิ่มหรืออัปเดตคู่คีย์-ค่า เพียงใช้ไวยากรณ์ต่อไปนี้:

your_dict["new_key"] = "new_value"

#You can also update an old key's value
your_dict["old_key"] = "new_value"

เมื่อต้องการเข้าถึงค่าในพจนานุกรม คุณจำเป็นต้องใช้คีย์เท่านั้น:

value = your_dict["key1"]

ในกรณีที่คุณพยายามเข้าถึงคีย์ที่ไม่มีอยู่ในพจนานุกรม คุณจะพบ KeyError เพื่อหลีกเลี่ยงปัญหานี้ คุณสามารถใช้เมธอด get() ได้:

value = your_dict.get("non_existent_key", "default_value")

สิ่งหนึ่งที่คุณต้องจำไว้คือพจนานุกรม Python ไม่สามารถมีคีย์ที่ซ้ำกันได้ แต่ละคีย์ต้องไม่ซ้ำกันและเป็นประเภทข้อมูลที่ไม่เปลี่ยนรูป

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

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

การลบองค์ประกอบออกจากพจนานุกรมทำได้โดยใช้ คำสำคัญ del :

del your_dict["key1"]

พวกเขายังมีหลายวิธีในการวนซ้ำผ่านเนื้อหา ตัวอย่างเช่น คุณสามารถวนซ้ำคีย์พจนานุกรม ค่า หรือแม้แต่ทั้งสองอย่าง:

for key in your_dict.keys():
    print(key)

for value in your_dict.values():
    print(value)

for key, value in your_dict.items():
    print(key, value)

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

วิธีสร้างพจนานุกรม Python

มีสองวิธีหลักในการสร้างพจนานุกรม Python: การใช้วงเล็บปีกกาและตัวสร้างdict()

การใช้วงเล็บปีกกา

วิธีหนึ่งที่คุณสามารถใช้เพื่อสร้างพจนานุกรมคือการใช้วงเล็บปีกกา ( {} ) หากต้องการเริ่มต้นพจนานุกรมเปล่า คุณสามารถใช้empty_dict = { }

หากต้องการสร้างพจนานุกรมที่มีคู่คีย์-ค่า ให้แยกคีย์และค่าด้วยทวิภาค จากนั้น คั่นแต่ละคู่ด้วยเครื่องหมายจุลภาค:

python_dict = {
    'key1': 'value1',
    'key2': 'value2',
    'key3': 'value3'
}

เมื่อใช้รูปแบบนี้ คุณได้สร้างพจนานุกรม Python ที่มีคู่คีย์-ค่าสามคู่ โปรดจำไว้ว่าคีย์ต้องไม่ซ้ำกันในขณะที่ค่าพจนานุกรมสามารถทำซ้ำได้

ใช้ตัวสร้าง Dict

อีกวิธีหนึ่งในการสร้างพจนานุกรม Python คือการใช้ตัวสร้างdict() หากต้องการสร้างพจนานุกรมเปล่า ให้เรียกใช้ฟังก์ชันนี้โดยไม่มีอาร์กิวเมนต์: empty_dict = dict( )

ในการสร้างพจนานุกรมโดยใช้ ตัวสร้าง dict()คุณสามารถใช้ไวยากรณ์ต่อไปนี้:

python_dict = dict(
    key1='value1',
    key2='value2',
    key3='value3'
)

วิธีนี้ยังสร้างพจนานุกรม Python ที่มีองค์ประกอบคีย์-ค่าสามรายการ โปรดทราบว่า ตัวสร้าง dict()ไม่ต้องการเครื่องหมายอัญประกาศรอบๆ คีย์ ซึ่งไม่เหมือนกับเมธอดวงเล็บปีกกา

อย่างไรก็ตาม ค่าในพจนานุกรมยังคงต้องการเครื่องหมายอัญประกาศรอบๆ

ตอนนี้คุณคุ้นเคยกับวิธีสร้างพจนานุกรม Python สองวิธีแล้ว คุณสามารถเริ่มใช้มันในโค้ดของคุณและควบคุมคุณสมบัติอันทรงพลังในแอปพลิเคชันของคุณ

How to Access Dictionary Elements

In this section, you will learn about different ways to access elements in a dictionary. Dictionaries store data in key-value pairs, and you can access each dictionary value using their respective keys.

We will cover two popular methods: Using keys and the get method.

Using Keys

One of the most straightforward ways to access dictionary elements is by using the keys. To get the value of a particular dictionary key, simply put the key inside square brackets next to the dictionary name:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name_value = my_dict['name']

phone_value = mydict['phone-number']

In this example, name_value would store the string ‘John’. Note that if you try to access a nonexistent key, Python will raise a KeyError.

Using Get Method

An alternative to using keys directly is the get() method, which allows you to access dictionary elements without the risk of raising a KeyError. Instead, the get method returns a default value if the specified key is not found:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name_value = my_dict.get('name', 'Key not found')
country_value = my_dict.get('country', 'Key not found')

In this example, name_value would store the string ‘John‘ as before since the ‘name‘ key is present in the dictionary. However, country_value will store the default value ‘Key not found‘ since the ‘country‘ key does not exist in the dictionary.

The get() method provides a more flexible way of accessing dictionary elements, as it allows you to handle missing keys gracefully. You can choose to use either method depending on your requirements and the possibility of encountering nonexistent keys.

How to Modify Dictionary Elements

In this section, you’ll learn how to modify elements within a Python dictionary. There are two primary operations for accomplishing this: adding new elements and updating existing ones.

Both of these methods will help you maintain the accuracy and usefulness of your dictionary. Let’s look at them:

1. Adding New Elements

Adding a new element to a dictionary is simple. To do so, specify the new key-value pair using an assignment operator, like this:

your_dict = {"key1": "value1", "key2": "value2"}
your_dict["new_key"] = "new_value"

After executing the above code snippet, your dictionary will now include the new pair:

{"key1": "value1", "key2": "value2", "new_key": "new_value"}

You can also add multiple key-value pairs at once by using the dictionary’s update() method

new_elements = {"key3": "value3", "key4": "value4"}
your_dict.update(new_elements)

Now, your dictionary will contain the following entries:

{"key1": "value1", "key2": "value2", "key3": "value3", "key4": "value4"}

1. Updating Existing Elements

To update the value of an existing element, you simply need to reference the key and assign a new value to it:

your_dict["key1"] = "updated_value1"

This change will result in the following dictionary:

{"key1": "updated_value1", "key2": "value2", "key3": "value3", "key4": "value4"}

If you need to update multiple elements at once, use the update() method again. To use it, pass in a new dictionary containing the desired modifications.

For example, let’s update the your_dict dictionary with the values from the updates dictionary:

updates = {"key2": "updated_value2", "key4": "updated_value4"}
your_dict.update(updates)

With these updates applied, the your_dict dictionary will look like this:

{"key1": "updated_value1", "key2": "updated_value2", "key3": "value3", "key4": "updated_value4"}

These operations are essential tools when working as they allow you to keep your data structures up-to-date and accurate.

Deleting Dictionary Elements

In this section, we will explore two common ways to delete dictionary elements in Python: the del keyword and the clear() method.

1. Del Keyword

The del keyword is used to remove a specific key-value pair from a dictionary. It operates in-place and raises a KeyError if the key does not exist in the dictionary. To delete an element, simply use the following syntax:

del my_dict[key]

For example, if you want to delete a key called “brand” from a dictionary named my_dict, you will write:

del my_dict["brand"]

Keep in mind that it is a good practice to ensure that the key exists in the dictionary before using the del keyword. You can do this by checking if the key is in the dictionary:

if "brand" in my_dict:
    del my_dict["brand"]

1. Clear Method

The clear() method is another way to delete dictionary elements. This method removes all dictionary keys and values in one operation, resulting in an empty dictionary.

To use the clear() method on your dictionary, simply call it. For example, if you have an existing dictionary named my_dict and you want to remove all its contents, you would write:

my_dict.clear()

In conclusion, you have learned two methods to delete elements from a Python dictionary: the del keyword for removing individual key-value pairs and the clear() method for emptying an entire dictionary.

What Are Some Common Dictionary Methods?

In this section, we will explore some common Python dictionary methods. These built-in methods will help you manipulate and modify dictionaries to suit your needs.

Keys

To retrieve all the keys from your dictionary, you can use the keys() method. This will return a view object containing all the dictionary’s keys.

For example:

your_dict = {'a': 1, 'b': 2, 'c': 3}
key_view = your_dict.keys()
print(key_view)
# Output: dict_keys(['a', 'b', 'c'])

Values

Similarly, the values() method allows you to obtain all the values stored in the dictionary. This is also presented as a view object.

For instance:

value_view = your_dict.values()
print(value_view)
# Output: dict_values([1, 2, 3])

Items

If you need to access both keys and values simultaneously, use the items() method. This returns a view object containing key-value pairs in the form of tuples.

Let’s look at an example:

item_view = your_dict.items()
print(item_view)
# Output: dict_items([('a', 1), ('b', 2), ('c', 3)])

Update

The update() method allows you to modify your dictionary by adding or updating key-value elements. To use the method, you have to provide a dictionary as an argument.

To merge two dictionaries or update specific keys, use this method:

your_dict.update({'d': 4, 'e': 5})
print(your_dict)
# Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

Pop

เมื่อใช้เมธอด pop() คุณสามารถลบรายการที่ต้องการออกจากพจนานุกรมได้ หากต้องการใช้ ให้ระบุคีย์ที่จะลบเป็นอาร์กิวเมนต์ในเมธอด

เมธอดจะส่งคืนค่าที่เกี่ยวข้องกับคีย์ที่ระบุและลบออกจากพจนานุกรม:

removed_value = your_dict.pop('a')
print(removed_value)
# Output: 1
print(your_dict)
# Output: {'b': 2, 'c': 3, 'd': 4, 'e': 5}

ป๊อปปี้เตม

เมธอดpopitem()ลบคู่คีย์-ค่าสุดท้ายในพจนานุกรม ส่งคืนทูเพิลที่มีคีย์และค่าที่ถูกลบ ตัวอย่างเช่น:

removed_item = your_dict.popitem()
print(removed_item)
# Output: ('e', 5)
print(your_dict)
# Output: {'b': 2, 'c': 3, 'd': 4}

ด้วยการใช้วิธีการเหล่านี้ คุณสามารถจัดการและปรับเปลี่ยนพจนานุกรมของคุณได้อย่างมีประสิทธิภาพเพื่อให้บรรลุงานที่หลากหลาย

การใช้พจนานุกรม Python

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

วนซ้ำพจนานุกรม

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

นี่คือตัวอย่าง:

my_dict = {"apple": 1, "banana": 2, "cherry": 3}

for key, value in my_dict.items():
    print(key, value)

อีกทางหนึ่ง คุณสามารถใช้เมธอดของคีย์ ()และค่า ()เพื่อวนซ้ำคีย์พจนานุกรมหรือค่าอย่างเดียว

ความเข้าใจในพจนานุกรมคืออะไร?

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

นี่คือตัวอย่างของความเข้าใจในพจนานุกรมที่ยกกำลังสองตัวเลขตั้งแต่ 1 ถึง 5:

squared_numbers = {num: num**2 for num in range(1, 6)}

ความเข้าใจในพจนานุกรมอาจมีประโยชน์อย่างมากสำหรับงานต่างๆ เช่น การกรองพจนานุกรมหรือการแปลงค่า

พจนานุกรมที่ซ้อนกันคืออะไร?

พจนานุกรมซ้อนเป็นพจนานุกรมที่มีพจนานุกรมอื่นเป็นค่า สามารถใช้เพื่อแสดงโครงสร้างข้อมูลแบบลำดับชั้นที่ซับซ้อน

นี่คือตัวอย่างของพจนานุกรมที่ซ้อนกัน:

nested_dict = {
    "person1": {"name": "Alice", "age": 30},
    "person2": {"name": "Bob", "age": 24}
}

หากต้องการเข้าถึงองค์ประกอบในพจนานุกรมที่ซ้อนกัน ให้ใช้การจัดทำดัชนีหลายรายการ:

name_p1 = nested_dict["person1"]["name"]

คุณสามารถแก้ไขหรือจัดการองค์ประกอบเพิ่มเติมในพจนานุกรมที่ซ้อนกันได้ตามต้องการ อย่าลืมติดตามคีย์และระดับการซ้อนเมื่อทำงานกับพจนานุกรมที่ซ้อนกันที่ซับซ้อนเพื่อหลีกเลี่ยงความสับสนหรือข้อผิดพลาด

กรณีการใช้พจนานุกรมทั่วไป

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

1. การจัดเก็บข้อมูลคีย์-ค่า : พจนานุกรมเหมาะสำหรับการจัดเก็บข้อมูลด้วยคีย์เฉพาะและค่าที่เกี่ยวข้อง เช่น ชื่อผู้ใช้และข้อมูลผู้ใช้ หรือรหัสผลิตภัณฑ์และรายละเอียดผลิตภัณฑ์:

{
  "username1": {"name": "Alice", "email": "[email protected]"},
  "username2": {"name": "Bob", "email": "[email protected]"}
}

ตัวอย่างนี้สามารถเห็นได้ในวิดีโอนี้เกี่ยวกับวิธีสร้าง Google News Aggregator ใน LuckyTemplates โดยใช้ Python

https://youtu.be/InsDb_DR15E

ในวิดีโอนี้ เราใช้พจนานุกรมเพื่อจัดเก็บค่าข้อมูลที่ได้รับจากการเรียก API ของ GoogleNews

2. การนับการเกิดขึ้น : คุณสามารถใช้พจนานุกรมเพื่อนับการเกิดขึ้นของรายการ เช่น ความถี่ของคำในเอกสาร การใช้คีย์เพื่อแสดงรายการที่ไม่ซ้ำกัน และค่าเพื่อระบุจำนวน คุณสามารถจัดการข้อมูลดังกล่าวได้อย่างมีประสิทธิภาพ

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

3. การแมปคีย์กับค่าหลายค่า : หากคุณต้องการเก็บค่าหลายค่าสำหรับแต่ละคีย์พจนานุกรม คุณสามารถใช้รายการหรือชุดเป็นค่าในพจนานุกรมของคุณ:

{
  "fruits": ["apple", "banana", "mango"],
  "vegetables": ["carrot", "broccoli", "spinach"]
}

4. การแคชผลลัพธ์ที่คำนวณได้ : พจนานุกรมสามารถใช้เพื่อแคชผลลัพธ์ของการดำเนินการที่มีราคาแพง สิ่งนี้มีประโยชน์อย่างยิ่งในเทคนิคการจำและการเขียนโปรแกรมแบบไดนามิก ซึ่งคุณจัดเก็บผลลัพธ์ของการคำนวณเพื่อหลีกเลี่ยงการคำนวณที่ซ้ำซ้อน

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

{
  "python": ["resource1", "resource3"],
  "dictionary": ["resource2", "resource3", "resource4"]
}

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