python编程的逻辑_带Python的AI –逻辑编程

深碍√TFBOYSˉ_ 2022-12-10 01:27 228阅读 0赞

![python编程的逻辑][python]

python编程的逻辑

# 带Python的AI –逻辑编程 **(**AI with Python – Logic Programming**)** #

In this chapter, we will focus logic programming and how it helps in Artificial Intelligence.

在本章中，我们将重点介绍逻辑编程及其在人工智能中的帮助。

We already know that logic is the study of principles of correct reasoning or in simple words it is the study of what comes after what. For example, if two statements are true then we can infer any third statement from it.

我们已经知道，逻辑是对正确推理原理的研究，或者简单来说就是对之后发生的事情的研究。 例如，如果两个语句为真，那么我们可以从中推断出任何第三条语句。

### 概念 **(**Concept**)** ###

Logic Programming is the combination of two words, logic and programming. Logic Programming is a programming paradigm in which the problems are expressed as facts and rules by program statements but within a system of formal logic. Just like other programming paradigms like object oriented, functional, declarative, and procedural, etc., it is also a particular way to approach programming.

逻辑编程是逻辑和编程这两个词的结合。 逻辑编程是一种编程范例，其中问题通过程序语句在形式逻辑系统中表示为事实和规则。 就像其他面向对象的，函数式的，声明式的和过程式的编程范例一样，它也是一种进行编程的特殊方式。

## 如何解决逻辑编程问题 **(**How to Solve Problems with Logic Programming**)** ##

Logic Programming uses facts and rules for solving the problem. That is why they are called the building blocks of Logic Programming. A goal needs to be specified for every program in logic programming. To understand how a problem can be solved in logic programming, we need to know about the building blocks − Facts and Rules −

逻辑编程使用事实和规则来解决问题。 这就是为什么它们被称为逻辑编程的基础。 需要为逻辑编程中的每个程序指定一个目标。 要了解如何在逻辑编程中解决问题，我们需要了解构件-事实和规则-

### 事实 **(**Facts**)** ###

Actually, every logic program needs facts to work with so that it can achieve the given goal. Facts basically are true statements about the program and data. For example, Delhi is the capital of India.

实际上，每个逻辑程序都需要处理事实，以便可以实现给定的目标。 事实基本上是关于程序和数据的真实陈述。 例如，德里是印度的首都。

### 规则 **(**Rules**)** ###

Actually, rules are the constraints which allow us to make conclusions about the problem domain. Rules basically written as logical clauses to express various facts. For example, if we are building any game then all the rules must be defined.

实际上，规则是使我们能够对问题领域做出结论的约束条件。 规则基本上写成逻辑从句来表达各种事实。 例如，如果我们要开发任何游戏，那么必须定义所有规则。

Rules are very important to solve any problem in Logic Programming. Rules are basically logical conclusion which can express the facts. Following is the syntax of rule −

规则对于解决逻辑编程中的任何问题非常重要。 规则基本上是可以表达事实的逻辑结论。 以下是规则的语法-

A∶− B1,B2,...,Bn.

A∶− B1，B2，...，B n

Here, A is the head and B1, B2, ... Bn is the body.

在这里，A是头部，B1，B2，... Bn是身体。

For example − ancestor(X,Y) :- father(X,Y).

例如-祖先(X，Y)：-父亲(X，Y)。

ancestor(X,Z) :- father(X,Y), ancestor(Y,Z).

祖先(X，Z)：-父亲(X，Y)，祖先(Y，Z)。

This can be read as, for every X and Y, if X is the father of Y and Y is an ancestor of Z, X is the ancestor of Z. For every X and Y, X is the ancestor of Z, if X is the father of Y and Y is an ancestor of Z.

对于每个X和Y，如果X是Y的父亲，并且Y是Z的祖先，X是Z的祖先，那么对于每个X和Y，如果X是Y，则X是Z的祖先。 Y的父亲，Y是Z的祖先。

## 安装有用的软件包 **(**Installing Useful Packages**)** ##

For starting logic programming in Python, we need to install the following two packages −

为了在Python中启动逻辑编程，我们需要安装以下两个软件包-

### 康仁 **(**Kanren**)** ###

It provides us a way to simplify the way we made code for business logic. It lets us express the logic in terms of rules and facts. The following command will help you install kanren −

它为我们提供了一种简化为业务逻辑编写代码的方式。 它使我们可以根据规则和事实来表达逻辑。 以下命令将帮助您安装kanren-

pip install kanren

### 象征 **(**SymPy**)** ###

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. The following command will help you install SymPy −

SymPy是用于符号数学的Python库。 它旨在成为功能齐全的计算机代数系统(CAS)，同时保持代码尽可能的简单，以便于理解和易于扩展。 以下命令将帮助您安装SymPy-

pip install sympy

## 逻辑程序范例 **(**Examples of Logic Programming**)** ##

Followings are some examples which can be solved by logic programming −

以下是一些可以通过逻辑编程解决的示例-

### 匹配数学表达式 **(**Matching mathematical expressions**)** ###

Actually we can find the unknown values by using logic programming in a very effective way. The following Python code will help you match a mathematical expression −

实际上，我们可以通过非常有效的方式使用逻辑编程来找到未知值。 以下Python代码将帮助您匹配数学表达式-

Consider importing the following packages first −

考虑先导入以下软件包-

from kanren import run, var, fact
    from kanren.assoccomm import eq_assoccomm as eq
    from kanren.assoccomm import commutative, associative

We need to define the mathematical operations which we are going to use −

我们需要定义将要使用的数学运算-

add = 'add'
    mul = 'mul'

Both addition and multiplication are communicative processes. Hence, we need to specify it and this can be done as follows −

加法和乘法都是交流过程。 因此，我们需要指定它，可以按照以下步骤进行操作-

fact(commutative, mul)
    fact(commutative, add)
    fact(associative, mul)
    fact(associative, add)

It is compulsory to define variables; this can be done as follows −

必须定义变量； 这可以做到如下-

a, b = var('a'), var('b')

We need to match the expression with the original pattern. We have the following original pattern, which is basically (5+a)\*b −

我们需要将表达式与原始模式匹配。 我们有以下原始模式，基本上是(5 + a)\* b-

Original_pattern = (mul, (add, 5, a), b)

We have the following two expressions to match with the original pattern −

我们有以下两个表达式与原始模式匹配-

exp1 = (mul, 2, (add, 3, 1))
    exp2 = (add,5,(mul,8,1))

Output can be printed with the following command −

可以使用以下命令打印输出-

print(run(0, (a,b), eq(original_pattern, exp1)))
    print(run(0, (a,b), eq(original_pattern, exp2)))

After running this code, we will get the following output −

运行此代码后，我们将获得以下输出-

((3,2))
    ()

The first output represents the values for **a** and **b**. The first expression matched the original pattern and returned the values for **a** and **b** but the second expression did not match the original pattern hence nothing has been returned.

第一个输出代表**a**和**b**的值。 第一个表达式匹配原始模式并返回**a**和**b**的值，但是第二个表达式不匹配原始模式，因此未返回任何内容。

## 检查素数 **(**Checking for Prime Numbers**)** ##

With the help of logic programming, we can find the prime numbers from a list of numbers and can also generate prime numbers. The Python code given below will find the prime number from a list of numbers and will also generate the first 10 prime numbers.

借助逻辑编程，我们可以从数字列表中找到素数，还可以生成素数。 下面给出的Python代码将从数字列表中找到素数，还将生成前10个素数。

Let us first consider importing the following packages −

让我们首先考虑导入以下软件包-

from kanren import isvar, run, membero
    from kanren.core import success, fail, goaleval, condeseq, eq, var
    from sympy.ntheory.generate import prime, isprime
    import itertools as it

Now, we will define a function called prime\_check which will check the prime numbers based on the given numbers as data.

现在，我们将定义一个名为prime\_check的函数，该函数将根据给定的数字作为数据检查素数。

def prime_check(x):
    if isvar(x):
       return condeseq([(eq,x,p)] for p in map(prime, it.count(1)))
    else:
       return success if isprime(x) else fail

Now, we need to declare a variable which will be used −

现在，我们需要声明一个将使用的变量-

x = var()
    print((set(run(0,x,(membero,x,(12,14,15,19,20,21,22,23,29,30,41,44,52,62,65,85)),
    (prime_check,x)))))
    print((run(10,x,prime_check(x))))

The output of the above code will be as follows −

上面的代码输出如下：

{19, 23, 29, 41}
    (2, 3, 5, 7, 11, 13, 17, 19, 23, 29)

## 解决难题 **(**Solving Puzzles**)** ##

Logic programming can be used to solve many problems like 8-puzzles, Zebra puzzle, Sudoku, N-queen, etc. Here we are taking an example of a variant of Zebra puzzle which is as follows −

逻辑编程可用于解决许多问题，例如8难题，Zebra难题，Sudoku，N-queen等。这里我们以Zebra难题的变体示例为例-

There are five houses.
    The English man lives in the red house.
    The Swede has a dog.
    The Dane drinks tea.
    The green house is immediately to the left of the white house.
    They drink coffee in the green house.
    The man who smokes Pall Mall has birds.
    In the yellow house they smoke Dunhill.
    In the middle house they drink milk.
    The Norwegian lives in the first house.
    The man who smokes Blend lives in the house next to the house with cats.
    In a house next to the house where they have a horse, they smoke Dunhill.
    The man who smokes Blue Master drinks beer.
    The German smokes Prince.
    The Norwegian lives next to the blue house.
    They drink water in a house next to the house where they smoke Blend.

We are solving it for the question **who owns zebra** with the help of Python.

我们正在借助Python解决**谁拥有斑马**的问题。

Let us import the necessary packages −

让我们导入必要的包-

from kanren import *
    from kanren.core import lall
    import time

Now, we need to define two functions − **left()** and **next()** to check whose house is left or next to who’s house −

现在，我们需要定义两个函数**-left()**和**next()**来检查谁的房子是谁的房子或谁的房子旁边的人-

def left(q, p, list):
       return membero((q,p), zip(list, list[1:]))
    def next(q, p, list):
       return conde([left(q, p, list)], [left(p, q, list)])

Now, we will declare a variable house as follows −

现在，我们将声明一个变量房子，如下所示：

houses = var()

We need to define the rules with the help of lall package as follows.

我们需要借助lall包定义规则，如下所示。

There are 5 houses −

有5间房子-

rules_zebraproblem = lall(
       (eq, (var(), var(), var(), var(), var()), houses),
    
       (membero,('Englishman', var(), var(), var(), 'red'), houses),
       (membero,('Swede', var(), var(), 'dog', var()), houses),
       (membero,('Dane', var(), 'tea', var(), var()), houses),
       (left,(var(), var(), var(), var(), 'green'),
       (var(), var(), var(), var(), 'white'), houses),
       (membero,(var(), var(), 'coffee', var(), 'green'), houses),
       (membero,(var(), 'Pall Mall', var(), 'birds', var()), houses),
       (membero,(var(), 'Dunhill', var(), var(), 'yellow'), houses),
       (eq,(var(), var(), (var(), var(), 'milk', var(), var()), var(), var()), houses),
       (eq,(('Norwegian', var(), var(), var(), var()), var(), var(), var(), var()), houses),
       (next,(var(), 'Blend', var(), var(), var()),
       (var(), var(), var(), 'cats', var()), houses),
       (next,(var(), 'Dunhill', var(), var(), var()),
       (var(), var(), var(), 'horse', var()), houses),
       (membero,(var(), 'Blue Master', 'beer', var(), var()), houses),
       (membero,('German', 'Prince', var(), var(), var()), houses),
       (next,('Norwegian', var(), var(), var(), var()),
       (var(), var(), var(), var(), 'blue'), houses),
       (next,(var(), 'Blend', var(), var(), var()),
       (var(), var(), 'water', var(), var()), houses),
       (membero,(var(), var(), var(), 'zebra', var()), houses)
    )

Now, run the solver with the preceding constraints −

现在，使用前面的约束运行求解器-

solutions = run(0, houses, rules_zebraproblem)

With the help of the following code, we can extract the output from the solver −

借助以下代码，我们可以从求解器中提取输出：

output_zebra = [house for house in solutions[0] if 'zebra' in house][0][0]

The following code will help print the solution −

以下代码将帮助打印解决方案-

print ('\n'+ output_zebra + 'owns zebra.')

The output of the above code would be as follows −

上面代码的输出如下-

German owns zebra.

> 翻译自: [https://www.tutorialspoint.com/artificial\_intelligence\_with\_python/artificial\_intelligence\_with\_python\_logic\_programming.htm][https_www.tutorialspoint.com_artificial_intelligence_with_python_artificial_intelligence_with_python_logic_programming.htm]

python编程的逻辑

[python]: /images/20221123/92a84bc022434765bad10f48c445673c.png
[https_www.tutorialspoint.com_artificial_intelligence_with_python_artificial_intelligence_with_python_logic_programming.htm]: https://www.tutorialspoint.com/artificial_intelligence_with_python/artificial_intelligence_with_python_logic_programming.htm