Hướng dẫn how to use function in dictionary in python - cách sử dụng hàm trong từ điển trong python

Xem thảo luận

Cải thiện bài viết

Lưu bài viết

  • Đọc
  • Bàn luận
  • Xem thảo luận

    Cải thiện bài viết

    Lưu bài viết

    Đọc

    Bàn luận

    Đưa ra một từ điển, gán các khóa của nó là các cuộc gọi chức năng.

    Python3

    Trường hợp 1: Không có params. & Nbsp;

    Cách được sử dụng để đạt được nhiệm vụ này là, tên chức năng được giữ làm giá trị từ điển và trong khi gọi bằng các phím, dấu ngoặc ‘[] được thêm vào.

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    5
    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    6

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    7
    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    8
    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    9

    # make a dictionary of US states and major cities
    cities = {'San Diego':'CA', 'New York':'NY', 'Detroit':'MI'}
    
    # define a function to use on such a dictionary
    def find_city [map, city]:
        # does something, returns some value
        if city in map:
            return map[city]
        else:
            return "Not found"
    
    # then add a final dict element that refers to the function
    cities['_found'] = find_city
    
    0
    # make a dictionary of US states and major cities
    cities = {'San Diego':'CA', 'New York':'NY', 'Detroit':'MI'}
    
    # define a function to use on such a dictionary
    def find_city [map, city]:
        # does something, returns some value
        if city in map:
            return map[city]
        else:
            return "Not found"
    
    # then add a final dict element that refers to the function
    cities['_found'] = find_city
    
    1

    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    3
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    4
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    5
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    6
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    7
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    8

    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    9
    # make a dictionary of US states and major cities
    cities = {'San Diego':'CA', 'New York':'NY', 'Detroit':'MI'}
    
    # define a function to use on such a dictionary
    def find_city [map, city]:
        # does something, returns some value
        if city in map:
            return map[city]
        else:
            return "Not found"
    
    # then add a final dict element that refers to the function
    cities['_found'] = find_city
    
    1
    def do_ping[self, arg]:
        return 'Pong, {0}!'.format[arg]
    
    def do_ls[self, arg]:
        return '\n'.join[os.listdir[arg]]
    
    dispatch = {
        'ping': do_ping,
        'ls': do_ls,
    }
    
    def process_network_command[command, arg]:
        send[dispatch[command][arg]]
    
    1
    def do_ping[self, arg]:
        return 'Pong, {0}!'.format[arg]
    
    def do_ls[self, arg]:
        return '\n'.join[os.listdir[arg]]
    
    dispatch = {
        'ping': do_ping,
        'ls': do_ls,
    }
    
    def process_network_command[command, arg]:
        send[dispatch[command][arg]]
    
    2
    def do_ping[self, arg]:
        return 'Pong, {0}!'.format[arg]
    
    def do_ls[self, arg]:
        return '\n'.join[os.listdir[arg]]
    
    dispatch = {
        'ping': do_ping,
        'ls': do_ls,
    }
    
    def process_network_command[command, arg]:
        send[dispatch[command][arg]]
    
    3

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : This is Gfg's value
    

    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    3
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    4
    def do_ping[self, arg]:
        return 'Pong, {0}!'.format[arg]
    
    def do_ls[self, arg]:
        return '\n'.join[os.listdir[arg]]
    
    dispatch = {
        'ping': do_ping,
        'ls': do_ls,
    }
    
    def process_network_command[command, arg]:
        send[dispatch[command][arg]]
    
    6
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    6
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    7
    def do_ping[self, arg]:
        return 'Pong, {0}!'.format[arg]
    
    def do_ls[self, arg]:
        return '\n'.join[os.listdir[arg]]
    
    dispatch = {
        'ping': do_ping,
        'ls': do_ls,
    }
    
    def process_network_command[command, arg]:
        send[dispatch[command][arg]]
    
    9

    Đầu ra

    Python3

    Trường hợp 2: với params & nbsp;

    Nhiệm vụ gọi với các params tương tự như trường hợp trên, các giá trị được truyền trong khi gọi hàm bên trong giá đỡ như trong các cuộc gọi chức năng thông thường.

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    5
    >>> def f[]:
    ...   print 1
    ... 
    >>> print f
    
    
    1

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    7
    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    8
    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    9

    # make a dictionary of US states and major cities
    cities = {'San Diego':'CA', 'New York':'NY', 'Detroit':'MI'}
    
    # define a function to use on such a dictionary
    def find_city [map, city]:
        # does something, returns some value
        if city in map:
            return map[city]
        else:
            return "Not found"
    
    # then add a final dict element that refers to the function
    cities['_found'] = find_city
    
    0
    # make a dictionary of US states and major cities
    cities = {'San Diego':'CA', 'New York':'NY', 'Detroit':'MI'}
    
    # define a function to use on such a dictionary
    def find_city [map, city]:
        # does something, returns some value
        if city in map:
            return map[city]
        else:
            return "Not found"
    
    # then add a final dict element that refers to the function
    cities['_found'] = find_city
    
    1

    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    3
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    4
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    5
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    6
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    7
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    8

    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    9
    # make a dictionary of US states and major cities
    cities = {'San Diego':'CA', 'New York':'NY', 'Detroit':'MI'}
    
    # define a function to use on such a dictionary
    def find_city [map, city]:
        # does something, returns some value
        if city in map:
            return map[city]
        else:
            return "Not found"
    
    # then add a final dict element that refers to the function
    cities['_found'] = find_city
    
    1
    def do_ping[self, arg]:
        return 'Pong, {0}!'.format[arg]
    
    def do_ls[self, arg]:
        return '\n'.join[os.listdir[arg]]
    
    dispatch = {
        'ping': do_ping,
        'ls': do_ls,
    }
    
    def process_network_command[command, arg]:
        send[dispatch[command][arg]]
    
    1
    def do_ping[self, arg]:
        return 'Pong, {0}!'.format[arg]
    
    def do_ls[self, arg]:
        return '\n'.join[os.listdir[arg]]
    
    dispatch = {
        'ping': do_ping,
        'ls': do_ls,
    }
    
    def process_network_command[command, arg]:
        send[dispatch[command][arg]]
    
    2
    def do_ping[self, arg]:
        return 'Pong, {0}!'.format[arg]
    
    def do_ls[self, arg]:
        return '\n'.join[os.listdir[arg]]
    
    dispatch = {
        'ping': do_ping,
        'ls': do_ls,
    }
    
    def process_network_command[command, arg]:
        send[dispatch[command][arg]]
    
    3

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    


    Tôi là người mới bắt đầu Python, và tôi vừa học được một kỹ thuật liên quan đến từ điển và chức năng. Cú pháp rất dễ dàng và nó có vẻ như là một điều tầm thường, nhưng cảm giác Python của tôi đang ngứa ran. Một cái gì đó cho tôi biết đây là một khái niệm sâu sắc và rất pythonic và tôi không hoàn toàn nắm bắt được tầm quan trọng của nó. Ai đó có thể đặt tên cho kỹ thuật này và giải thích làm thế nào/tại sao nó hữu ích?Can someone put a name to this technique and explain how/why it's useful?

    Kỹ thuật này là khi bạn có một từ điển Python và một chức năng mà bạn dự định sử dụng trên nó. Bạn chèn một phần tử bổ sung vào dict, có giá trị là tên của hàm. Khi bạn đã sẵn sàng gọi chức năng, bạn sẽ đưa ra cuộc gọi một cách gián tiếp bằng cách tham khảo phần tử Dict, chứ không phải chức năng theo tên.

    Ví dụ tôi làm việc là từ học Python theo cách khó khăn, tái bản lần 2. .

    Để diễn dải:

    # make a dictionary of US states and major cities
    cities = {'San Diego':'CA', 'New York':'NY', 'Detroit':'MI'}
    
    # define a function to use on such a dictionary
    def find_city [map, city]:
        # does something, returns some value
        if city in map:
            return map[city]
        else:
            return "Not found"
    
    # then add a final dict element that refers to the function
    cities['_found'] = find_city
    

    Sau đó các biểu thức sau đây là tương đương. Bạn có thể gọi chức năng trực tiếp hoặc bằng cách tham chiếu phần tử Dict có giá trị là hàm.

    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    

    Ai đó có thể giải thích tính năng ngôn ngữ này là gì, và có lẽ nơi nào nó được chơi trong chương trình "thực"? Bài tập đồ chơi này đủ để dạy tôi cú pháp, nhưng không đưa tôi đến đó.

    hỏi ngày 9 tháng 1 năm 2013 lúc 20:10Jan 9, 2013 at 20:10

    3

    Sử dụng một dict, bạn hãy dịch khóa thành một người có thể gọi được. Chìa khóa không cần phải được mã hóa cứng, như trong ví dụ của bạn.

    Thông thường, đây là một dạng công văn người gọi, trong đó bạn sử dụng giá trị của một biến để kết nối với một hàm. Nói một quy trình mạng gửi cho bạn mã lệnh, ánh xạ công văn cho phép bạn dịch mã lệnh một cách dễ dàng thành mã thực thi:

    def do_ping[self, arg]:
        return 'Pong, {0}!'.format[arg]
    
    def do_ls[self, arg]:
        return '\n'.join[os.listdir[arg]]
    
    dispatch = {
        'ping': do_ping,
        'ls': do_ls,
    }
    
    def process_network_command[command, arg]:
        send[dispatch[command][arg]]
    

    Lưu ý rằng hàm nào chúng ta gọi bây giờ phụ thuộc hoàn toàn vào giá trị của

    f = Foo[]
    f.find_city['bar']
    
    1. Khóa cũng không phải khớp với nhau; Nó thậm chí không phải là một chuỗi, bạn có thể sử dụng bất cứ thứ gì có thể được sử dụng làm khóa và phù hợp với ứng dụng cụ thể của bạn.

    Sử dụng phương thức công văn là an toàn hơn các kỹ thuật khác, chẳng hạn như

    f = Foo[]
    f.find_city['bar']
    
    2, vì nó giới hạn các lệnh cho phép những gì bạn đã xác định trước. Chẳng hạn, không có kẻ tấn công nào lén lút tiêm
    f = Foo[]
    f.find_city['bar']
    
    3 qua bàn điều phối.

    Đã trả lời ngày 9 tháng 1 năm 2013 lúc 20:13Jan 9, 2013 at 20:13

    Martijn Pietersmartijn PietersMartijn Pieters

    14.1k10 Huy hiệu vàng56 Huy hiệu bạc57 Huy hiệu đồng10 gold badges56 silver badges57 bronze badges

    5

    @Martijn Pieters đã làm rất tốt việc giải thích kỹ thuật này, nhưng tôi muốn làm rõ điều gì đó từ câu hỏi của bạn.

    Điều quan trọng cần biết là bạn không lưu trữ "tên của hàm" trong từ điển. Bạn đang lưu trữ một tham chiếu đến chính chức năng. Bạn có thể thấy điều này bằng cách sử dụng

    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    3 trên chức năng.NOT storing "the name of the function" in the dictionary. You are storing a reference to the function itself. You can see this using a
    >>> find_city [cities, 'New York']
    NY
    
    >>> cities['_found'][cities, 'New York']
    NY
    
    3 on the function.

    >>> def f[]:
    ...   print 1
    ... 
    >>> print f
    
    

    f = Foo[]
    f.find_city['bar']
    
    5 chỉ là một biến tham chiếu chức năng bạn đã xác định. Sử dụng từ điển cho phép bạn nhóm giống như mọi thứ, nhưng nó không khác gì gán hàm cho một biến khác.

    >>> a = f
    >>> a
    
    >>> a[]
    1
    

    Tương tự, bạn có thể vượt qua một chức năng như một đối số.

    >>> def c[func]:
    ...   func[]
    ... 
    >>> c[f]
    1
    

    Đã trả lời ngày 9 tháng 1 năm 2013 lúc 20:25Jan 9, 2013 at 20:25

    Unholysamplerunholysamplerunholysampler

    7,7131 Huy hiệu vàng28 Huy hiệu bạc38 Huy hiệu đồng1 gold badge28 silver badges38 bronze badges

    1

    Lưu ý rằng lớp Python thực sự chỉ là một đường cú pháp cho từ điển. Khi bạn làm:

    class Foo[object]:
        def find_city[self, city]:
            ...
    

    khi bạn gọi

    f = Foo[]
    f.find_city['bar']
    

    thực sự giống như:

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    0

    mà sau khi giải quyết tên, giống như:

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    1

    Một kỹ thuật hữu ích là ánh xạ đầu vào của người dùng vào các cuộc gọi lại. Ví dụ:

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    2

    Điều này có thể được viết thay thế trong lớp:

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    3

    Bất kỳ cú pháp gọi lại nào tốt hơn phụ thuộc vào ứng dụng cụ thể và sở thích của lập trình viên. Cái trước là phong cách chức năng hơn, sau này được định hướng đối tượng nhiều hơn. Cái trước có thể cảm thấy tự nhiên hơn nếu bạn cần sửa đổi các mục trong từ điển hàm động [có thể dựa trên đầu vào của người dùng]; Loại thứ hai có thể cảm thấy tự nhiên hơn nếu bạn có một tập hợp các bản đồ cài đặt trước khác nhau có thể được chọn một cách linh hoạt.

    Đã trả lời ngày 10 tháng 1 năm 2013 lúc 3:23Jan 10, 2013 at 3:23

    Nói dối Ryanlie RyanLie Ryan

    12.2k1 Huy hiệu vàng 30 Huy hiệu bạc41 Huy hiệu đồng1 gold badge30 silver badges41 bronze badges

    4

    Có 2 kỹ thuật nhảy vào tâm trí tôi mà bạn có thể đề cập đến, cả hai đều không phải là Pythonic ở chỗ chúng rộng hơn một ngôn ngữ.

    1. Kỹ thuật ẩn/đóng gói thông tin và sự gắn kết [chúng thường đi đôi với nhau nên tôi đang gộp chúng lại với nhau].

    Bạn có một đối tượng có dữ liệu và bạn gắn một phương thức [hành vi] rất gắn kết với dữ liệu. Nếu bạn cần thay đổi chức năng, mở rộng chức năng hoặc thực hiện bất kỳ thay đổi nào khác, người gọi sẽ không cần thay đổi [giả sử không cần phải truyền dữ liệu bổ sung].

    2. Công văn bảng

    Không phải trường hợp cổ điển, bởi vì chỉ có một mục nhập có chức năng. Tuy nhiên, các bảng công văn được sử dụng để tổ chức các hành vi khác nhau bằng một khóa để chúng có thể nhìn lên và được gọi là động. Tôi không chắc bạn có suy nghĩ của bạn về điều này không vì bạn không đề cập đến chức năng theo cách năng động, nhưng không có gì bạn vẫn đạt được ràng buộc muộn hiệu quả [cuộc gọi "gián tiếp"].

    Sự đánh đổi

    Một điều cần lưu ý là những gì bạn đang làm sẽ hoạt động tốt với một không gian tên đã biết của các phím. Tuy nhiên, bạn có nguy cơ va chạm giữa dữ liệu và các chức năng với không gian tên không xác định của các phím.

    Đã trả lời ngày 10 tháng 1 năm 2013 lúc 1:34Jan 10, 2013 at 1:34

    Dietbuddhadietbuddhadietbuddha

    8,59723 Huy hiệu bạc36 Huy hiệu đồng23 silver badges36 bronze badges

    1

    Tôi đăng giải pháp này mà tôi nghĩ là khá chung chung và có thể hữu ích vì nó được giữ đơn giản và dễ dàng để thích nghi với các trường hợp cụ thể:

    The original dictionary is : {'Gfg': , 'is': 5, 'best': 9}
    The required call result : 44
    
    4

    Người ta cũng có thể xác định một danh sách trong đó mỗi phần tử là một đối tượng hàm và sử dụng phương thức

    f = Foo[]
    f.find_city['bar']
    
    6 được tích hợp trong phương thức. Tín dụng cho tất cả cho cảm hứng và hợp tác.

    "Nghệ sĩ vĩ đại là người đơn giản", Henri Frederic Amiel

    Đã trả lời ngày 2 tháng 12 năm 2016 lúc 15:07Dec 2, 2016 at 15:07

    Chúng ta có thể sử dụng chức năng trong python từ điển không?

    Trong Python, mọi thứ đều là một đối tượng, vì vậy từ điển có thể được truyền như một đối số cho một hàm như các biến khác được truyền.the dictionary can be passed as an argument to a function like other variables are passed.

    Làm thế nào để bạn áp dụng một chức năng cho một từ điển?

    Làm thế nào để bạn áp dụng một hàm cho mỗi giá trị trong từ điển?Sử dụng khả năng hiểu từ điển để ánh xạ một hàm trên tất cả các giá trị trong từ điển.Sử dụng cú pháp {key: f [giá trị] cho khóa, giá trị trong dict.items []} để áp dụng hàm f cho mỗi giá trị trong Dictionary Dict.Use the syntax {key: f[value] for key, value in dict. items[]} to apply the function f to each value in the dictionary dict .

    Dict [] và {} giống nhau?

    Như chúng ta có thể thấy, Dict [] rõ ràng là chậm hơn {}.Đặc biệt, nếu từ điển được khởi tạo với nhiều yếu tố, nó có tác động rất lớn nếu mã của bạn cần 0,04ms hoặc gần 0,08ms để tạo từ điển của bạn.Ngay cả khi bạn khởi tạo một từ điển trống, nó vẫn chậm hơn.dict[] is obviously slower than {}. Especially, if the dictionary is initialized with many elements, it has a huge impact if your code needs 0.04ms or almost 0.08ms to create your dictionary. Even when you initialize an empty dictionary, it is slower.

    Bài Viết Liên Quan

    Chủ Đề