Hướng dẫn how do you analyze an object in python? - làm thế nào để bạn phân tích một đối tượng trong python?

Nếu điều này là để khám phá để xem những gì đang xảy ra, tôi khuyên bạn nên xem Ipython. Điều này thêm các phím tắt khác nhau để có được tài liệu, thuộc tính và mã nguồn đối tượng. Ví dụ, nối thêm một "?" Đối với một hàm sẽ cung cấp trợ giúp cho đối tượng (thực tế là một lối tắt cho "Trợ giúp (OBJ)", trong đó sử dụng hai? 'S ("

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
41") sẽ hiển thị mã nguồn nếu có sẵn.

Ngoài ra còn có rất nhiều tiện ích bổ sung, như hoàn thành tab, in khá nhiều kết quả, lịch sử kết quả, v.v ... làm cho nó rất tiện dụng cho loại chương trình khám phá này.

Để sử dụng nhiều chương trình hơn của nội tâm, các bản tích hợp cơ bản như

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
42,
import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
43,
import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
44, vv sẽ hữu ích, nhưng bạn rất đáng để bạn kiểm tra mô -đun kiểm tra. Để tìm nạp nguồn của một hàm, hãy sử dụng "
import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
45", ví dụ, áp dụng nó cho chính nó:

>>> print inspect.getsource(inspect.getsource)
def getsource(object):
    """Return the text of the source code for an object.

    The argument may be a module, class, method, function, traceback, frame,
    or code object.  The source code is returned as a single string.  An
    IOError is raised if the source code cannot be retrieved."""
    lines, lnum = getsourcelines(object)
    return string.join(lines, '')

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
46 cũng thường xuyên hữu ích nếu bạn xử lý các chức năng gói hoặc thao tác, vì nó sẽ đưa ra tên và giá trị mặc định của các tham số chức năng.

Trong Python, mọi thứ đều là một đối tượng theo mặc định (các lớp, chức năng, tracbacks, phương thức, mô -đun, v.v.). Chúng ta có thể tạo một đối tượng lớp bằng cách sử dụng phương thức loại () đặc biệt mà không cần sử dụng từ khóa lớp. Đôi khi chúng ta cần phân tích các đối tượng này để hiểu chúng tốt hơn. Python đã cung cấp cho chúng tôi một mô -đun có tên Kiểm tra cho mục đích này. Nó cung cấp một danh sách các phương pháp có thể cho phép chúng tôi kiểm tra các đối tượng Python để hiểu chúng tốt hơn. Nó cho phép chúng tôi thực hiện một danh sách các chức năng dưới mức được đề cập và nhiều hơn nữa trên các đối tượng.type() method without using class keyword. Sometimes we need to analyze these objects to understand them better. Python has provided us with a module named inspect for this purpose. It provides a list of methods that can let us inspect python objects to understand them better. It let us perform a list of the below-mentioned functions and many more on the objects.

  • Kiểm tra chữ ký của chức năng.
  • Tìm ra loại đối tượng.
  • Kiểm tra nội dung của lớp.
  • Kiểm tra nội dung của mô -đun.
  • Truy xuất mã nguồn của phương thức/chức năng.
  • Đối số định dạng của hàm.
  • Nhận thông tin thông tin thông tin.
  • etc.

Thông tin được cung cấp bởi mô -đun kiểm tra có thể được sử dụng để kiểm tra loại, phân tích mã nguồn của các đối tượng, phân tích các lớp và chức năng và giải thích thông tin ngăn xếp trình thông dịch.inspect module can be used for type checking, analyzing source code of objects, analyzing classes and functions, and interpreting interpreter stack information.

Chúng tôi đã chia hướng dẫn của chúng tôi thành các phần và mỗi phần có một danh sách các phương thức thường được sử dụng cho cùng một mục đích.

  • Phương pháp phân tích thông tin liên quan đến loại đối tượng
  • Phương pháp phân tích thông tin liên quan đến mã nguồn đối tượng
  • Phương pháp phân tích các thông tin liên quan đến lớp và chức năng của đối tượng
  • Phương pháp phân tích thông tin liên quan đến chữ ký của đối tượng có thể gọi được
  • Phương pháp phân tích thông tin liên quan đến thông tin Python

Chúng tôi sẽ giải thích danh sách các phương thức trong mỗi phần với các ví dụ đơn giản để chứng minh việc sử dụng các phương pháp đó. Chúng tôi sẽ bắt đầu bằng cách nhập mô -đun kiểm tra.

Là một phần của phần này, chúng tôi sẽ giới thiệu các phương pháp cho phép chúng tôi tìm ra loại đối tượng được đưa ra rằng chúng tôi không có thông tin về nó. Chúng tôi sẽ giới thiệu các phương thức cho chúng tôi biết liệu đối tượng mà chúng tôi đang phân tích là lớp, mô-đun, phương thức, chức năng, traceback, trình tạo, mã, coroutine, tích hợp, v.v.

ismodule ()

Phương thức này lấy đối tượng đầu vào và trả về đúng nếu nó loại mô -đun khác sai. Nó xác định xem đối tượng có phải là mô -đun hay không dựa trên sự hiện diện của các thuộc tính dưới đây trong đối tượng.

  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    47
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    48
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    49

is class () ¶

Phương thức này lấy đối tượng đầu vào và trả về đúng nếu nó loại loại khác sai. Nó xác định xem đối tượng có phải là một lớp hay không dựa trên sự hiện diện của các thuộc tính dưới đây trong đối tượng.

  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    48
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    51

ismethod ()

Phương thức này lấy đối tượng đầu vào và trả về true nếu nó loại phương thức khác sai. Nó xác định xem một đối tượng có phải là phương thức hay không dựa trên sự hiện diện của các thuộc tính dưới đây trong đối tượng.

  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    48
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    53
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    54
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    55

isfunction () ¶

Phương thức này lấy đối tượng đầu vào và trả về true nếu nó là loại chức năng khác sai. Nó xác định xem một đối tượng có phải là một hàm hay không dựa trên sự hiện diện của các thuộc tính dưới đây trong đối tượng.

  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    48
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    53
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    58
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    59
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    60
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    61
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    62

Dưới đây chúng tôi đã giải thích việc sử dụng các phương pháp với các ví dụ đơn giản. Chúng tôi đã tạo một chức năng bổ sung có tên cho các phương thức kiểm tra liên quan đến các đối tượng chức năng.addition for testing methods related to function objects.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

isgeneratorfunction () ¶

Phương thức này lấy đối tượng đầu vào và trả về true nếu nó của loại trình tạo loại khác sai. Nó xác định xem một đối tượng có phải là hàm tạo hay không dựa trên sự hiện diện của các thuộc tính dưới đây trong đối tượng.

  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    48
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    53
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    58
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    59
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    60
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    61
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    62

isgenerator ()

Phương thức này lấy làm đối tượng đầu vào và trả về true nếu nó của loại máy phát khác sai. Nó xác định xem một đối tượng có phải là trình tạo hay không dựa trên sự hiện diện của các thuộc tính dưới đây trong đối tượng.

  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    70
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    71
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    72
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    73
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    74
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    75
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    76
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    77

Dưới đây chúng tôi đã tạo hai trình tạo (một sử dụng hàm và một hàm khác bằng ký hiệu ngoặc đơn) để kiểm tra các chức năng này.

def countGenerator():
    for i in range(100):
        yield i

countGen = (i for i in range(100))


print("Is {} a Generator Function : {}".format(countGenerator.__name__, inspect.isgeneratorfunction(countGenerator)))
print("Is {} a Generator Function : {}".format(addition.__name__, inspect.isgeneratorfunction(addition)))
print()
print("Is {} a Generator : {}".format(countGen.__name__, inspect.isgenerator(countGen)))
print("Is {} a Generator : {}".format(addition.__name__, inspect.isgenerator(addition)))

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False

iscoroutinefunction () ¶

Phương thức này lấy đối tượng đầu vào và trả về true nếu nó có chức năng loại coroutine khác. Nó xác định xem một đối tượng có phải là hàm coroutine hay không dựa trên sự hiện diện của các thuộc tính giống như các đối tượng có trong hàm.

iscode ()

Phương thức này lấy làm đầu vào một đối tượng và trả về đúng nếu nó loại mã khác sai. Nó xác định xem một đối tượng có phải là mã hay không dựa trên sự hiện diện của các thuộc tính dưới đây trong đối tượng.

  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    78
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    79
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    80
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    81
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    82
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    83
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    84
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    85
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    86
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    87
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    88
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    89
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    90
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    91
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    92

Dưới đây chúng tôi đã giải thích làm thế nào chúng ta có thể sử dụng các phương pháp này. Chúng tôi đã tạo một phiên bản khác của phương thức bổ sung với tiền tố từ khóa Async để chỉ ra rằng nó là một coroutine. Chúng ta có thể truy cập mã của một hàm với sự trợ giúp của thuộc tính

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
58 của đối tượng hàm.async keyword prefix to indicate that it’s a coroutine. We can access the code of a function with the help of
import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
58 attribute of the function object.

async def addition_async(**args):
    return sum(args)

print("Is {} a Coroutine Function : {}".format(addition_async.__name__, inspect.iscoroutinefunction(addition_async)))
print("Is {} a Coroutine Function : {}".format(addition.__name__, inspect.iscoroutinefunction(addition)))
print()
print("Is {} a Code : {}".format("addition.__code__", inspect.iscode(addition.__code__)))
print("Is {} a Code : {}".format(addition.__name__, inspect.iscode(addition)))

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False

isTraceBack ()

Phương thức này lấy làm đầu vào một đối tượng và trả về true nếu nó loại TraceBack khác sai. Nó xác định xem một đối tượng có phải là một dấu vết hay không dựa trên sự hiện diện của các thuộc tính dưới đây trong đối tượng.

  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    94
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    95
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    96
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    97

isframe ()

Phương thức này lấy làm đầu vào một đối tượng và trả về true nếu nó loại khung hình khác sai. Nó xác định xem một đối tượng có phải là khung hay không dựa trên sự hiện diện của các thuộc tính dưới đây trong đối tượng.

  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    98
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    99
  • Is random a Module : True
    Is addition a Module : False
    
    Is random a Class : False
    Is Random a Class : True
    Is ChainMap a Class : True
    
    Is addition a Method : False
    Is randint a Method : True
    
    Is addition a Function : True
    Is randint a Function : False
    
    
    00
  • Is random a Module : True
    Is addition a Module : False
    
    Is random a Class : False
    Is Random a Class : True
    Is ChainMap a Class : True
    
    Is addition a Method : False
    Is randint a Method : True
    
    Is addition a Function : True
    Is randint a Function : False
    
    
    01
  • Is random a Module : True
    Is addition a Module : False
    
    Is random a Class : False
    Is Random a Class : True
    Is ChainMap a Class : True
    
    Is addition a Method : False
    Is randint a Method : True
    
    Is addition a Function : True
    Is randint a Function : False
    
    
    02
  • Is random a Module : True
    Is addition a Module : False
    
    Is random a Class : False
    Is Random a Class : True
    Is ChainMap a Class : True
    
    Is addition a Method : False
    Is randint a Method : True
    
    Is addition a Function : True
    Is randint a Function : False
    
    
    03
  • Is random a Module : True
    Is addition a Module : False
    
    Is random a Class : False
    Is Random a Class : True
    Is ChainMap a Class : True
    
    Is addition a Method : False
    Is randint a Method : True
    
    Is addition a Function : True
    Is randint a Function : False
    
    
    04
  • Is random a Module : True
    Is addition a Module : False
    
    Is random a Class : False
    Is Random a Class : True
    Is ChainMap a Class : True
    
    Is addition a Method : False
    Is randint a Method : True
    
    Is addition a Function : True
    Is randint a Function : False
    
    
    05

isbuiltin ()

Phương thức này lấy làm đầu vào một đối tượng và trả về true nếu nó loại từ khóa tích hợp loại khác sai. Nó xác định xem một đối tượng có phải là từ khóa tích hợp hay không dựa trên sự hiện diện của các thuộc tính dưới đây trong đối tượng.

  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    48
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    53
  • import random
    import collections
    
    ## This is a Generic Addition Function.
    ## It can take any number of integer arguments and sum them up.
    def addition(**args):
        '''
        Description: 
            This function takes as input any number of integer arguments, sum them up and returns results.
        
        Params:
        
        *args: List of Values
        '''
        return sum(args)
    
    print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
    print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
    print()
    print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
    print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
    print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
    print()
    print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
    print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
    print()
    print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
    print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
    print()
    
    55

isroutine ()

Phương thức này lấy làm đầu vào một đối tượng và trả về true nếu nó loại thường trình loại (hàm/phương thức) khác.

IsabStract ()

Phương thức này lấy làm đầu vào một đối tượng và trả về đúng nếu nó loại loại cơ sở trừu tượng khác sai.

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True

GetMembers ()

Hàm này lấy đối tượng đầu vào và trả về danh sách các thành viên của đối tượng. Mỗi mục là một bộ của hai giá trị (tên thành viên và giá trị thành viên). Thành viên có thể là phương thức, lớp, thuộc tính, coroutine, v.v.

Nó có một tham số thứ hai có tên vị từ chấp nhận tham chiếu đến một trong các phương thức là*() đã đề cập ở trên làm đầu vào. Sau đó, nó trả về một danh sách với các thành viên trả về đúng cho phương thức đó.predicate which accepts a reference to one of the above-mentioned is*() method as input. It then returns a list with members that return True for that method.

Dưới đây chúng tôi đã gọi phương thức trên mô -đun ngẫu nhiên và phương thức ISCLASS được truyền như một vị từ. Nó chỉ trả về các thành viên của một mô -đun ngẫu nhiên là lớp. Sau đó chúng tôi đã gọi lại phương pháp hai lần với các vị từ khác nhau.random module and passed isclass method as a predicate. It returns only members of a random module which are class. We have then called the method again two times with different predicates.

import random

inspect.getmembers(random, inspect.isclass)

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
0

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
1

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
2

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
3

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
4

getModulename () ¶

Hàm này chấp nhận đường dẫn đến mô -đun và trả về tên mô -đun mà không bao gồm tên gói. Nó dựa trên mô -đun nhập khẩu của Python.importlib module of python.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
5

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
6

Là một phần của phần này, chúng tôi sẽ giới thiệu các phương thức có thể cho chúng tôi biết chi tiết về mã nguồn của đối tượng như mã, nhận xét, tài liệu, tên tệp nguồn, v.v. Chúng tôi sẽ giải thích việc sử dụng các phương thức này bằng cách đơn giản Ví dụ để chứng minh cách sử dụng chúng,

getDoc ()

Hàm này chấp nhận một đối tượng là tham số đầu tiên của nó và trả về chuỗi tài liệu cho đối tượng đó. Nếu đối tượng được cung cấp là một lớp, một phương thức hoặc thuộc tính và tài liệu không có mặt thì nó sẽ cố gắng lấy tài liệu từ hệ thống phân cấp kế thừa.

Chúng tôi đã in chuỗi tài liệu cho mô -đun bộ sưu tập và phương thức bổ sung bên dưới bằng phương pháp này.collections module and addition method below using this method.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
7

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
8

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
9

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

0

Hàm này lấy làm đối tượng đầu vào và trả về một danh sách các nhận xét có trước mã nguồn của đối tượng đó nếu lớp hoặc phương thức của nó. Nếu đối tượng được truyền là một mô -đun thì nó sẽ cố gắng truy xuất các bình luận từ đầu tệp. Nếu không có ý kiến ​​hiện diện thì nó không trả lại.

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

1

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

2

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

3

getModule () ¶

Hàm này lấy một đối tượng làm đầu vào và trả về một tham chiếu đến mô -đun mà nó được xác định. Chúng tôi đã gọi phương thức với chức năng Randint và lớp truy cập từ các mô -đun ngẫu nhiên và bộ sưu tập tương ứng để truy xuất cả hai mô -đun bên dưới.randint function and Counter class from random and collections modules respectively to retrieve both modules below.

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

4

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

5

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

6

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

7

có được file()¶

Hàm này lấy một đối tượng làm đầu vào và trả về tên tệp trong đó đối tượng đó được xác định.

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

8

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

9

def countGenerator():
    for i in range(100):
        yield i

countGen = (i for i in range(100))


print("Is {} a Generator Function : {}".format(countGenerator.__name__, inspect.isgeneratorfunction(countGenerator)))
print("Is {} a Generator Function : {}".format(addition.__name__, inspect.isgeneratorfunction(addition)))
print()
print("Is {} a Generator : {}".format(countGen.__name__, inspect.isgenerator(countGen)))
print("Is {} a Generator : {}".format(addition.__name__, inspect.isgenerator(addition)))
0

def countGenerator():
    for i in range(100):
        yield i

countGen = (i for i in range(100))


print("Is {} a Generator Function : {}".format(countGenerator.__name__, inspect.isgeneratorfunction(countGenerator)))
print("Is {} a Generator Function : {}".format(addition.__name__, inspect.isgeneratorfunction(addition)))
print()
print("Is {} a Generator : {}".format(countGen.__name__, inspect.isgenerator(countGen)))
print("Is {} a Generator : {}".format(addition.__name__, inspect.isgenerator(addition)))
1

def countGenerator():
    for i in range(100):
        yield i

countGen = (i for i in range(100))


print("Is {} a Generator Function : {}".format(countGenerator.__name__, inspect.isgeneratorfunction(countGenerator)))
print("Is {} a Generator Function : {}".format(addition.__name__, inspect.isgeneratorfunction(addition)))
print()
print("Is {} a Generator : {}".format(countGen.__name__, inspect.isgenerator(countGen)))
print("Is {} a Generator : {}".format(addition.__name__, inspect.isgenerator(addition)))
2

getsourcefile () ¶

Hàm này lấy làm đầu vào một đối tượng và trả về tên tệp trong đó mã nguồn của đối tượng có mặt.

def countGenerator():
    for i in range(100):
        yield i

countGen = (i for i in range(100))


print("Is {} a Generator Function : {}".format(countGenerator.__name__, inspect.isgeneratorfunction(countGenerator)))
print("Is {} a Generator Function : {}".format(addition.__name__, inspect.isgeneratorfunction(addition)))
print()
print("Is {} a Generator : {}".format(countGen.__name__, inspect.isgenerator(countGen)))
print("Is {} a Generator : {}".format(addition.__name__, inspect.isgenerator(addition)))
3

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

8

def countGenerator():
    for i in range(100):
        yield i

countGen = (i for i in range(100))


print("Is {} a Generator Function : {}".format(countGenerator.__name__, inspect.isgeneratorfunction(countGenerator)))
print("Is {} a Generator Function : {}".format(addition.__name__, inspect.isgeneratorfunction(addition)))
print()
print("Is {} a Generator : {}".format(countGen.__name__, inspect.isgenerator(countGen)))
print("Is {} a Generator : {}".format(addition.__name__, inspect.isgenerator(addition)))
5

def countGenerator():
    for i in range(100):
        yield i

countGen = (i for i in range(100))


print("Is {} a Generator Function : {}".format(countGenerator.__name__, inspect.isgeneratorfunction(countGenerator)))
print("Is {} a Generator Function : {}".format(addition.__name__, inspect.isgeneratorfunction(addition)))
print()
print("Is {} a Generator : {}".format(countGen.__name__, inspect.isgenerator(countGen)))
print("Is {} a Generator : {}".format(addition.__name__, inspect.isgenerator(addition)))
0

def countGenerator():
    for i in range(100):
        yield i

countGen = (i for i in range(100))


print("Is {} a Generator Function : {}".format(countGenerator.__name__, inspect.isgeneratorfunction(countGenerator)))
print("Is {} a Generator Function : {}".format(addition.__name__, inspect.isgeneratorfunction(addition)))
print()
print("Is {} a Generator : {}".format(countGen.__name__, inspect.isgenerator(countGen)))
print("Is {} a Generator : {}".format(addition.__name__, inspect.isgenerator(addition)))
7

def countGenerator():
    for i in range(100):
        yield i

countGen = (i for i in range(100))


print("Is {} a Generator Function : {}".format(countGenerator.__name__, inspect.isgeneratorfunction(countGenerator)))
print("Is {} a Generator Function : {}".format(addition.__name__, inspect.isgeneratorfunction(addition)))
print()
print("Is {} a Generator : {}".format(countGen.__name__, inspect.isgenerator(countGen)))
print("Is {} a Generator : {}".format(addition.__name__, inspect.isgenerator(addition)))
2

GetSourcelines ()

Hàm này lấy một đối tượng làm đầu vào và trả về một tuple có độ dài hai. Giá trị trong tuple là mã nguồn của đối tượng dưới dạng danh sách các chuỗi và giá trị thứ hai là số dòng trong tệp mà mã bắt đầu. Nó có thể lấy một đối tượng của một loại loại, phương thức, chức năng, coroutine, traceback, khung, mã, v.v.

def countGenerator():
    for i in range(100):
        yield i

countGen = (i for i in range(100))


print("Is {} a Generator Function : {}".format(countGenerator.__name__, inspect.isgeneratorfunction(countGenerator)))
print("Is {} a Generator Function : {}".format(addition.__name__, inspect.isgeneratorfunction(addition)))
print()
print("Is {} a Generator : {}".format(countGen.__name__, inspect.isgenerator(countGen)))
print("Is {} a Generator : {}".format(addition.__name__, inspect.isgenerator(addition)))
9

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False
0

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False
1

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False
2

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False
3

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False
4

GetSource () ¶

Hàm này lấy làm đầu vào một đối tượng và trả về mã nguồn của đối tượng dưới dạng chuỗi. Nó chấp nhận một đối tượng của một loại loại, phương thức, chức năng, coroutine, traceback, vv làm đầu vào.

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False
5

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False
6

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False
7

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False
8

CleanDoc ()

Chức năng này lấy làm tài liệu đầu vào và làm sạch chúng bằng cách loại bỏ các không gian trắng dẫn đầu hoặc theo dõi.

Is countGenerator a Generator Function : True
Is addition a Generator Function : False

Is  a Generator : True
Is addition a Generator : False
9

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

0

Là một phần của phần này, chúng tôi sẽ giới thiệu các phương pháp có thể giúp chúng tôi phân tích lớp và chức năng tốt hơn. Nó có các phương pháp có thể giúp chúng ta hiểu phân cấp lớp, thứ tự phân giải phương thức, đối số chức năng, giá trị đối số chức năng, v.v. Chúng tôi sẽ giải thích việc sử dụng các phương pháp này bằng các ví dụ đơn giản.

getClassTree () ¶

Hàm này lấy làm đầu vào một danh sách các lớp và trả về các lớp được tổ chức theo cấu trúc phân cấp dựa trên sự kế thừa của chúng. Nó trả về một danh sách 2 bộ đếm giá trị làm đầu ra. Giá trị đầu tiên trong tuple là bản thân lớp và giá trị thứ hai là danh sách các lớp cơ sở của lớp đó. Mỗi mục trong danh sách đi trước một danh sách các lớp mà từ đó mục nhập hiện tại kế thừa.

Nó có một tham số có tên duy nhất là sai theo mặc định do đó các mục cho lớp có thể xuất hiện nhiều lần nếu nó được thừa hưởng bởi nhiều lớp. Chúng ta có thể ngăn các mục được lặp lại bằng cách đặt tham số này thành True.unique which is False by default hence entries for the class can be present more than once if it’s inherited by multiple classes. We can prevent repeated entries by setting this parameter to True.

Dưới đây chúng tôi đã tạo ra một hệ thống phân cấp lớp trong đó lớp B và C mở rộng lớp A, lớp D mở rộng B và lớp E mở rộng lớp C. Sau đó, chúng tôi đã chuyển một danh sách các lớp này theo thứ tự tùy ý cho phương pháp này. Nó tổ chức các lớp theo thứ tự mà kế thừa theo sau chúng.

Mục đầu tiên là dành cho một đối tượng không có siêu lớp. Mỗi mục có một siêu lớp hiện tại và một mục trước khi mục đó có một mục cho siêu lớp đó.

async def addition_async(**args):
    return sum(args)

print("Is {} a Coroutine Function : {}".format(addition_async.__name__, inspect.iscoroutinefunction(addition_async)))
print("Is {} a Coroutine Function : {}".format(addition.__name__, inspect.iscoroutinefunction(addition)))
print()
print("Is {} a Code : {}".format("addition.__code__", inspect.iscode(addition.__code__)))
print("Is {} a Code : {}".format(addition.__name__, inspect.iscode(addition)))
1

async def addition_async(**args):
    return sum(args)

print("Is {} a Coroutine Function : {}".format(addition_async.__name__, inspect.iscoroutinefunction(addition_async)))
print("Is {} a Coroutine Function : {}".format(addition.__name__, inspect.iscoroutinefunction(addition)))
print()
print("Is {} a Code : {}".format("addition.__code__", inspect.iscode(addition.__code__)))
print("Is {} a Code : {}".format(addition.__name__, inspect.iscode(addition)))
2

Dưới đây chúng tôi đã tạo ra một lớp khác có tên F mở rộng lớp D và lớp E. Sau đó chúng tôi đã in lại thứ bậc. Chúng tôi cũng đã in phân cấp bằng cách đặt tham số duy nhất thành True để tránh các mục được lặp lại.unique parameter to True to avoid repeated entries.

async def addition_async(**args):
    return sum(args)

print("Is {} a Coroutine Function : {}".format(addition_async.__name__, inspect.iscoroutinefunction(addition_async)))
print("Is {} a Coroutine Function : {}".format(addition.__name__, inspect.iscoroutinefunction(addition)))
print()
print("Is {} a Code : {}".format("addition.__code__", inspect.iscode(addition.__code__)))
print("Is {} a Code : {}".format(addition.__name__, inspect.iscode(addition)))
3

async def addition_async(**args):
    return sum(args)

print("Is {} a Coroutine Function : {}".format(addition_async.__name__, inspect.iscoroutinefunction(addition_async)))
print("Is {} a Coroutine Function : {}".format(addition.__name__, inspect.iscoroutinefunction(addition)))
print()
print("Is {} a Code : {}".format("addition.__code__", inspect.iscode(addition.__code__)))
print("Is {} a Code : {}".format(addition.__name__, inspect.iscode(addition)))
4

async def addition_async(**args):
    return sum(args)

print("Is {} a Coroutine Function : {}".format(addition_async.__name__, inspect.iscoroutinefunction(addition_async)))
print("Is {} a Coroutine Function : {}".format(addition.__name__, inspect.iscoroutinefunction(addition)))
print()
print("Is {} a Code : {}".format("addition.__code__", inspect.iscode(addition.__code__)))
print("Is {} a Code : {}".format(addition.__name__, inspect.iscode(addition)))
5

async def addition_async(**args):
    return sum(args)

print("Is {} a Coroutine Function : {}".format(addition_async.__name__, inspect.iscoroutinefunction(addition_async)))
print("Is {} a Coroutine Function : {}".format(addition.__name__, inspect.iscoroutinefunction(addition)))
print()
print("Is {} a Code : {}".format("addition.__code__", inspect.iscode(addition.__code__)))
print("Is {} a Code : {}".format(addition.__name__, inspect.iscode(addition)))
6

getmro () ¶

Hàm này lấy làm đối tượng lớp đầu vào và trả về danh sách các lớp hình thành thứ tự phân giải phương thức cho lớp này. Đây là các lớp trong đó một thông dịch viên tìm kiếm một phương thức theo thứ tự này khi nó không tìm thấy phương thức trong lớp gốc.

async def addition_async(**args):
    return sum(args)

print("Is {} a Coroutine Function : {}".format(addition_async.__name__, inspect.iscoroutinefunction(addition_async)))
print("Is {} a Coroutine Function : {}".format(addition.__name__, inspect.iscoroutinefunction(addition)))
print()
print("Is {} a Code : {}".format("addition.__code__", inspect.iscode(addition.__code__)))
print("Is {} a Code : {}".format(addition.__name__, inspect.iscode(addition)))
7

async def addition_async(**args):
    return sum(args)

print("Is {} a Coroutine Function : {}".format(addition_async.__name__, inspect.iscoroutinefunction(addition_async)))
print("Is {} a Coroutine Function : {}".format(addition.__name__, inspect.iscoroutinefunction(addition)))
print()
print("Is {} a Code : {}".format("addition.__code__", inspect.iscode(addition.__code__)))
print("Is {} a Code : {}".format(addition.__name__, inspect.iscode(addition)))
8

getfullargspec ()

Hàm này lấy làm đối tượng chức năng đầu vào và trả về một tuple có tên có thông tin về các đối số chức năng và giá trị mặc định. Tuple có tên được trả về có dưới đây được đề cập.

  • Args - Nó có một danh sách các tên tham số vị trí.
  • Varargs - Nó có các tham số
    Is random a Module : True
    Is addition a Module : False
    
    Is random a Class : False
    Is Random a Class : True
    Is ChainMap a Class : True
    
    Is addition a Method : False
    Is randint a Method : True
    
    Is addition a Function : True
    Is randint a Function : False
    
    
    09.
  • VARKW - Nó có các tham số
    Is random a Module : True
    Is addition a Module : False
    
    Is random a Class : False
    Is Random a Class : True
    Is ChainMap a Class : True
    
    Is addition a Method : False
    Is randint a Method : True
    
    Is addition a Function : True
    Is randint a Function : False
    
    
    10.
  • Mặc định - Nó có một danh sách các giá trị mặc định cho n tham số vị trí cuối cùng.
  • KwonlyArss - Nó có một danh sách các tên tham số chỉ từ khóa.
  • KwonlyDefaults - Nó có các giá trị mặc định cho danh sách các tham số chỉ từ khóa.
  • Chú thích - Nó có chi tiết chú thích như một từ điển. Các chú thích là thông tin về loại nếu được cung cấp.

Dưới đây chúng tôi đã cố gắng giải thích việc sử dụng phương pháp với các ví dụ đơn giản.

async def addition_async(**args):
    return sum(args)

print("Is {} a Coroutine Function : {}".format(addition_async.__name__, inspect.iscoroutinefunction(addition_async)))
print("Is {} a Coroutine Function : {}".format(addition.__name__, inspect.iscoroutinefunction(addition)))
print()
print("Is {} a Code : {}".format("addition.__code__", inspect.iscode(addition.__code__)))
print("Is {} a Code : {}".format(addition.__name__, inspect.iscode(addition)))
9

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False
0

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False
1

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False
2

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False
3

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False
4

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False
5

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False
6

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False
7

getcallargs ()

Hàm này có dạng

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

11 cho phép chúng tôi cung cấp đối tượng chức năng và các giá trị của các tham số của nó khi gọi nó. Sau đó, nó sẽ trả về một từ điển trong đó mỗi tham số của hàm được ánh xạ tới các giá trị của chúng.

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False
8

Is addition_async a Coroutine Function : True
Is addition a Coroutine Function : False

Is addition.__code__ a Code : True
Is addition a Code : False
9

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
0

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
1

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
2

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
3

getAttr_static () ¶

Phương thức này có thể được sử dụng để truy xuất các giá trị thuộc tính khi chúng tôi không muốn thực thi mã để truy xuất thuộc tính. Trình thông dịch Python có thể gọi các phương thức

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

12 hoặc
Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

13 khi chúng ta cố gắng truy xuất hoặc kiểm tra sự tồn tại của một thuộc tính bằng các phương thức getAttr () hoặc hasattr (). Nếu chúng ta không muốn các phương thức này được thực thi để truy xuất các giá trị thuộc tính thì chúng ta nên sử dụng phương thức getAttatic ().getattr() or hasattr() methods. If we don't want these methods to be executed to retrieve attribute values then we should use getattr_static() method.

Dưới đây chúng tôi đã giải thích với ví dụ đơn giản về sự khác biệt giữa gọi getAttr () và getAttatic ().getattr() and getattr_static().

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
4

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
5

Là một phần của phần này, chúng tôi sẽ giới thiệu các phương pháp cho phép chúng tôi phân tích chữ ký của các đối tượng có thể gọi được. Nó cho phép chúng tôi truy xuất tên tham số, giá trị mặc định của chúng, chú thích của chúng, v.v.

Chữ ký()¶

Hàm này lấy làm đối tượng hàm đầu vào và trả về đối tượng chữ ký có thông tin về chữ ký của hàm. Nó thậm chí còn giữ thông tin về chú thích của hàm.Signature object which has information about the signature of the function. It even holds information about the annotation of the function.

Dưới đây chúng tôi đã lấy lại chữ ký của một vài chức năng và in chúng.

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
6

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
7

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
8

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
9

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True
0

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True
1

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True
2

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True
3

Chữ ký¶

Chữ ký.from_callable ()

Đối tượng chữ ký có một phương thức có tên từ_callable () cũng cho phép chúng tôi lấy chữ ký là tốt.from_callable() which also lets us retrieve the signature as well.

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True
4

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True
1

Chữ ký.return_annotation¶

Đối tượng chữ ký có thuộc tính return_annotation trả về chú thích của loại trả về của hàm nếu có.return_annotation attribute which returns annotation of the return type of the function if present.

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True
6

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True
7

Chữ ký.replace () ¶

Hàm này cho phép chúng tôi sửa đổi các thuộc tính khác nhau của đối tượng chữ ký. Dưới đây chúng tôi đang sửa đổi chú thích trả lại của hàm bổ sung. Chúng tôi thậm chí có thể sửa đổi các tham số của hàm bằng cách cung cấp danh sách các đối tượng tham số thành tham số tham số trong cuộc gọi đến phương thức này.Parameter objects to parameters parameter in the call to this method.

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True
8

Is tb a Traceback : True
Is addition a Traceback : False

Is tb a Frame : False
Is tb.tb_frame a Frame : True

Is sum a Builtin : True
Is addition a Builtin : False

Is sum a Routine : True
Is addition a Routine : True

Is sum a Abstract Base Class : False
Is Hashable a Abstract Base Class : True
9

Chữ ký.Parameterers¶

Thuộc tính tham số trả về một từ điển được đặt hàng của các tham số của hàm. Nó đặt hàng các tham số theo thứ tự mà chúng có mặt trong chữ ký. Mỗi giá trị trong từ điển là một đối tượng của tham số loại có thông tin về một tham số cụ thể của chữ ký đó.parameters attribute returns an ordered dictionary of parameters of the function. It orders parameters in the order in which they are present in the signature. Each value in the dictionary is an object of type Parameter which has information about a particular parameter of that signature.

import random

inspect.getmembers(random, inspect.isclass)
0

import random

inspect.getmembers(random, inspect.isclass)
1

Chữ ký.bind ()

Hàm này lấy giá trị đầu vào của tham số và trả về đối tượng giới hạn được liên kết từ tham số và các giá trị của chúng. Nó có chữ ký của Mẫu

Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

14 cho phép chúng ta liên kết các giá trị với tham số theo các cách khác nhau (trực tiếp cung cấp chúng dưới dạng danh sách hoặc cung cấp chúng như một từ điển trong đó khóa là tên và giá trị tham số là giá trị tham số).BoundedArguments object which is binding from parameter and their values. It has the signature of the form
Is random a Module : True
Is addition a Module : False

Is random a Class : False
Is Random a Class : True
Is ChainMap a Class : True

Is addition a Method : False
Is randint a Method : True

Is addition a Function : True
Is randint a Function : False

14 which lets us bind values to the parameter in different ways (directly giving them as a list or giving them as a dictionary where the key is parameter name and value is parameter value).

Hàm này sẽ thất bại nếu chúng ta không cung cấp tất cả các đối số cần thiết theo hàm.

import random

inspect.getmembers(random, inspect.isclass)
2

Đối tượng giới hạn có phương thức có tên application_default (), bản đồ các giá trị mặc định thành các tham số không được cung cấp khi tạo đối tượng này bằng phương thức Bind ().BoundedArguments object has method named apply_default() which maps default values to parameters for which value is not provided when creating this object using bind() method.

import random

inspect.getmembers(random, inspect.isclass)
3

import random

inspect.getmembers(random, inspect.isclass)
4

tb = None
try:
    a = 10/0
except Exception as e:
    tb = e.__traceback__

print("Is {} a Traceback : {}".format("tb", inspect.istraceback(tb)))
print("Is {} a Traceback : {}".format(addition.__name__, inspect.istraceback(addition)))
print()
print("Is {} a Frame : {}".format("tb", inspect.isframe(tb)))
print("Is {} a Frame : {}".format("tb.tb_frame", inspect.isframe(tb.tb_frame)))
print()
print("Is {} a Builtin : {}".format(sum.__name__, inspect.isbuiltin(sum)))
print("Is {} a Builtin : {}".format(addition.__name__, inspect.isbuiltin(addition)))
print()
print("Is {} a Routine : {}".format(sum.__name__, inspect.isroutine(sum)))
print("Is {} a Routine : {}".format(addition.__name__, inspect.isroutine(addition)))
print()
print("Is {} a Abstract Base Class : {}".format(sum.__name__, inspect.isabstract(random.Random)))
print("Is {} a Abstract Base Class : {}".format(collections.abc.Hashable.__name__, inspect.isabstract(collections.abc.Hashable)))
9

Chúng ta thậm chí có thể gọi hàm một khi chúng ta có các giá trị liên kết với các tham số trong phiên bản giới hạn.BoundedArguments instance.

import random

inspect.getmembers(random, inspect.isclass)
6

Chữ ký.bind_partial () ¶

Hàm này hoạt động chính xác giống như hàm ind () với sự khác biệt duy nhất mà nó cho phép chúng tôi tạo đối tượng giới hạn mà không cung cấp một số đối số cần thiết.bind() function with the only difference that it let us create BoundedArguments object without providing some required arguments.

Hàm này sẽ không thất bại nếu chúng tôi không cung cấp các đối số cần thiết nhưng khi chúng tôi gọi chức năng thực tế của chúng tôi bằng cách sử dụng giới hạn, nó sẽ không thành công nếu không có đối số được yêu cầu.BoundedArguments, it'll fail if required arguments are not present.

import random

inspect.getmembers(random, inspect.isclass)
7

import random

inspect.getmembers(random, inspect.isclass)
3

import random

inspect.getmembers(random, inspect.isclass)
9

import random

inspect.getmembers(random, inspect.isclass)
6

Tham số¶

Thông tin tham số về Callable được giữ trong đối tượng tham số có mặt trong thuộc tính tham số của đối tượng chữ ký. Dưới đây chúng tôi đã liệt kê các thuộc tính quan trọng của đối tượng tham số.Parameter object which is present in parameters attribute of Signature object. Below we have listed down important attributes of the Parameter object.

  • Tên - Tên của tham số. - The name of parameter.
  • Mặc định - Giá trị mặc định của tham số. - The default value of the parameter.
  • Chú thích - Thông tin loại về tham số. - The type information about parameter.
  • Kiểu - loại tham số. Nó có một trong các giá trị dưới đây. - The type of parameter. It has one of the below values.
    • POSITIONAL_ONLY
    • POSITIONAL_OR_KEYWORD
    • VAR_POSITIONAL
    • KEYWORD_ONLY
    • VAR_KEYWORD

Đối tượng tham số là bất biến do đó chúng ta không thể sửa đổi nó.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
01

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
02

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
03

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
04

Tham số.replace () ¶

Phương thức này cho phép chúng tôi tạo một đối tượng tham số mới bằng cách thay thế giá trị của đối tượng tham số gốc. Chúng tôi đã đề cập trước đó rằng đối tượng tham số là bất biến do đó phương thức này tạo ra một bản sao của nó với các giá trị thuộc tính được thay thế.

Dưới đây chúng tôi đang thay đổi tên tham số, chú thích và giá trị mặc định cho cả hai tham số của phương thức bổ sung để tạo đối tượng tham số mới cho cả hai tham số. Sau đó, chúng tôi đang thay đổi đối tượng chữ ký bằng cách sử dụng phương thức thay thế () của nó để tạo một đối tượng chữ ký mới bằng cách sử dụng các đối tượng tham số mới được tạo này.replace() method to create a new signature object using these newly created parameter objects.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
05

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
06

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
07

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
08

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
09

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
10

Là một phần của phần này, chúng tôi sẽ giới thiệu các phương thức có thể giúp chúng tôi hiểu được dấu vết của trình thông dịch Python khi xảy ra ngoại lệ. Chúng tôi sẽ giải thích việc sử dụng các phương pháp với các ví dụ đơn giản.

Dưới đây chúng tôi đã tạo ra một phương pháp đơn giản thực hiện bộ phận. Sau đó, chúng tôi đã gọi phương thức phân chia với các tham số 10 và 0 trong câu lệnh Try-Except để bắt bộ phận bằng không ngoại lệ. Chúng tôi cũng đã ghi lại các đối tượng Traceback mà chúng tôi sẽ sử dụng sau này khi giải thích các phương pháp của phần này.

Nếu bạn quan tâm đến việc tìm hiểu về cách nắm bắt, định dạng và in dấu vết của các trường hợp ngoại lệ thì xin vui lòng kiểm tra hướng dẫn của chúng tôi trên cùng.

  • Traceback - Làm thế nào để trích xuất, định dạng và in các dấu vết ngăn xếp lỗi trong Python?

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
11

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
12

getframinfo ()

Hàm này lấy làm đối tượng khung đầu vào và trả về thông tin về TraceBack. Nó trả về có tên Tuple Traceback có thông tin như tên tệp, số dòng, hàm gọi, chỉ mục và bối cảnh mã. Dưới đây chúng tôi đã truy xuất Traceback bằng cách sử dụng khung có sẵn từ phiên bản TraceBack mà chúng tôi đã bắt được trước đó. Chúng tôi cũng đã in định dạng theo dõi.

Vui lòng ghi chú rằng tất cả các phương thức của phần này có một đối số có tên ngữ cảnh chấp nhận một số nguyên và trả về nhiều dòng ngữ cảnh đó.context which accepts an integer and returns that many lines of context.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
13

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
14

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
15

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
16

Dưới đây, chúng tôi đã gọi lại chức năng getFrameInfo () nhưng lần này với giá trị ngữ cảnh là 8 sẽ thêm một số dòng xung quanh khung mà chúng tôi đã vượt qua.getframeinfo() function again but this time with a context value of 8 which will add a number of lines around the frame that we passed.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
17

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
18

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
15

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
20

getouterframes ()

Hàm này lấy làm đối tượng khung đầu vào và trả về tất cả các khung bên ngoài bao gồm cả khung được đưa ra dưới dạng tham số. Nó bao gồm các khung có thông tin về các cuộc gọi dẫn đến ngoại lệ. Nó trả về một danh sách các đối tượng Tuple Object FrameInfo có thông tin như tên tệp, số dòng, hàm, chỉ mục và bối cảnh mã. Đối tượng thông tin khung đầu tiên có thông tin về khung mà chúng tôi đã truyền dưới dạng đầu vào và khung cuối cùng có thông tin về cuộc gọi ngoài cùng trên tổng số khung của khung đó.FrameInfo objects which have information like filename, line number, function, index, and code context. The first frame info object has information about the frame which we passed as input and the last frame has information about the outermost call on that frame's total stack.

Dưới đây chúng tôi đã cố gắng lấy lại tất cả các khung bên ngoài của khung từ dấu vết thất bại của chúng tôi. Sau đó chúng tôi đã in tất cả các đối tượng thông tin khung. Chúng tôi đã gọi chức năng Randint của mô -đun ngẫu nhiên với các đối số tiêu cực để nó thất bại và chúng tôi có thể nắm bắt một dấu vết của nó để giải thích việc sử dụng chức năng.randint function of the random module with negative arguments so that it fails and we can capture a trace of it for explaining function usage.

Vui lòng ghi chú rằng thông tin khung thứ hai được in theo đầu ra được định dạng có mã được thực hiện bởi Jupyter Notebook để thực thi mã có trong ô. Hướng dẫn này được tạo ra bằng cách chạy các ví dụ trong một cuốn sổ Jupyter.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
21

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
22

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
23

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
24

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
25

getinnerframes ()

Hàm này lấy cách phiên bản Traceback đầu vào và trả về danh sách các đối tượng Tuple FrameInfo có tên có thông tin về khung của Traceback và tất cả các khung bên trong. Danh sách này có thông tin về các khung có thông tin về các cuộc gọi được thực hiện khi ngoại lệ xảy ra.FrameInfo objects which has information about traceback's frame and all inner frames. This list has information about frames which has information about calls that were made when the exception happened.

Chúng ta có thể thấy bên dưới từ đầu ra được định dạng rằng có bao nhiêu chức năng được gọi để truy xuất các số nguyên ngẫu nhiên.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
26

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
27

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
28

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
29

cây rơm()¶

Phương thức này trả về một danh sách các đối tượng Tuple FrameInfo có thông tin về ngăn xếp của người gọi.FrameInfo objects which have information about the caller's stack.

Chúng tôi có các phương thức được tạo dưới đây gọi nhau và phương thức cuối cùng gọi hàm ngăn xếp (). Nó ghi lại tất cả các cuộc gọi đã xảy ra. Vui lòng kiểm tra đầu ra để xem dấu vết của các cuộc gọi.stack() function. It captures all calls that happened. Please check the output to see the stack trace of calls.

Vui lòng ghi chú rằng chúng tôi chỉ in 5 mục. Lý do đằng sau điều này là vì chúng tôi đã chạy mã trong Jupyter Notebook, trong đó gọi nhiều chức năng để thực thi ô này do đó ngăn xếp có rất nhiều khung không cần thiết sẽ không có mặt khi mã được chạy dưới dạng tập lệnh. Chúng tôi đã loại trừ các khung đó khỏi đầu ra in.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
30

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
31

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
32

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
33

dấu vết()¶

Hàm này trả về một danh sách các đối tượng Tuple Framinfo có tên có thông tin về ngăn xếp giữa khung hiện tại và khung mà ngoại lệ được nêu ra.FrameInfo objects which has information about the stack between the current frame and the frame in which the exception was raised.

Dưới đây chúng tôi đã gọi chức năng randint () với các đối số tiêu cực để nó thất bại và chúng tôi có thể nắm bắt dấu vết để giải thích việc sử dụng phương pháp. Chúng ta có thể thấy rằng ngoại lệ thực sự đã xảy ra ở Randrange nơi nó được xử lý. Chúng ta có thể thấy tất cả các khung giữa các cuộc gọi từ ô bên dưới cho đến khung hình đó.randint() function with negative arguments so that it fails and we can capture trace to explain the usage of the method. We can see that the actual exception happened in randrange where it got handled. We can see all the frames between calls from the below cell till that frame.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
34

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
22

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
36

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
37

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
38

khung hiện tại()¶

Hàm này trả về một đối tượng khung có thông tin về ngăn xếp của người gọi.

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
39

import random
import collections

## This is a Generic Addition Function.
## It can take any number of integer arguments and sum them up.
def addition(**args):
    '''
    Description: 
        This function takes as input any number of integer arguments, sum them up and returns results.
    
    Params:
    
    *args: List of Values
    '''
    return sum(args)

print("Is {} a Module : {}".format(random.__name__, inspect.ismodule(random)))
print("Is {} a Module : {}".format(addition.__name__, inspect.ismodule(addition)))
print()
print("Is {} a Class : {}".format(random.__name__, inspect.isclass(random)))
print("Is {} a Class : {}".format(random.Random.__name__, inspect.isclass(random.Random)))
print("Is {} a Class : {}".format(collections.ChainMap.__name__, inspect.isclass(collections.ChainMap)))
print()
print("Is {} a Method : {}".format(addition.__name__, inspect.ismethod(addition)))
print("Is {} a Method : {}".format(random.randint.__name__, inspect.ismethod(random.randint)))
print()
print("Is {} a Function : {}".format(addition.__name__, inspect.isfunction(addition)))
print("Is {} a Function : {}".format(random.randint.__name__, inspect.isfunction(random.randint)))
print()
40

Điều này kết thúc hướng dẫn nhỏ của chúng tôi giải thích việc sử dụng API của mô -đun kiểm tra. Xin vui lòng cho chúng tôi biết quan điểm của bạn trong phần bình luận.inspect module. Please feel free to let us know your views in the comments section.

Người giới thiệu¶

  • Traceback - Làm thế nào để trích xuất, định dạng và in các dấu vết ngăn xếp lỗi trong Python?