Question

def isPrime(n):
    if n == 1:
        return False
    else:
        for i in range(2,n):
            if n%i == 0:
                return False
            return True

我想知道为什么这个代码在说一个数字是不是一个数字时会省略两个，如果我将n的值设为2，我该如何修复它。

Answer 1

范围（2,2）是空的。

你可以通过

看到它

for i in range(2,2): print(i)

Answer 2

由于range函数，它省略了2：

print(list(range(2,2)))
[]

在您的代码中，如果您想要包含n，则应使用range(2,n+1)

针对此特定问题，您可以执行以下操作：

def isPrime(n):
    if n == 1:
        return False
    elif n == 2:
        return False
    else:
        prime = True
        for i in range(2,n):
            if n%i == 0:
                prime = False
                break
        return prime

print(isPrime(6))

elif捕获了n == 2的特殊情况。另外，我插入了一个额外变量，当模数变为False时，该变量设置为0（因此，变量不是素数）

break确保在余数变为0后停止检查，并且无论您的变量是否为素数，都会返回。

我查了一下，得到了以下结果：

False

表示输入= 6

和

True

表示输入= 11

Answer 3

我是python的新手。大约两天哈哈。但我想我能看出问题所在。范围（a，b）功能计入长度＆＃34; b-a＆＃34; 因为这是一个范围（最高 - 最小）因此，当您使用range（）函数时，请以这种方式写出来：

def isPrime(n):
if n == 1: 
    return False 
else: 
    for i in range(1,n): 
        if n%i == 0: 
            return False 
        return True

print(isPrime(n))

Answer 4

它省略了2，因为range(2, n)是空的，就像其他答案所说的那样。但是，对于n = 2，您希望范围为空，因为您永远不想包含1（每个正整数可以被1整除），而2可以被2整除。通常，您希望使用True因为n可被n整除。

这里的另一个问题是你在for循环中返回True;这意味着在第一次通过循环时n≥3，如果n为奇数，函数将返回return True。解决这个问题的方法就是将n语句归结为缩进级别。这样，如果范围为空，或者仅在检查True是否可被2到n-1（包括2和n-1）之间的每个数字整除后，则返回def isPrime(n): if n == 1: return False else: for i in range(2,n): if n%i == 0: return False return True。看起来应该是这样的：

using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Messages;
using Microsoft.Xrm.Sdk.Query;
using System;
using System.Collections.Generic;

namespace StackOverflow
{
    public class App_ExecuteMultiple 
    {
        private IOrganizationService svc;

        public App_ExecuteMultiple(IOrganizationService svc) 
        {
            this.svc = svc;
        }

        public void Run()
        {
            var multiReq = new ExecuteMultipleRequest()
            {
                Settings = new ExecuteMultipleSettings()
                {
                    ContinueOnError = true,
                    ReturnResponses = true
                },            
                Requests = new OrganizationRequestCollection()
            };

            accountIds().ForEach(i => multiReq.Requests.Add(getAccountRequest(i)));

            contactIds().ForEach(i => multiReq.Requests.Add(getContactRequest(i)));

            var multiResponse = (ExecuteMultipleResponse)svc.Execute(multiReq);

            foreach (var singleResponse in multiResponse.Responses)
            {
                var retrieveResponse = (RetrieveMultipleResponse)singleResponse.Response;

                var attributeName = "";

                var logicalName = retrieveResponse.EntityCollection[0].LogicalName;

                if ( logicalName == "account")
                {
                    attributeName = "name";
                }
                else if (logicalName == "contact")
                {
                    attributeName = "fullname";
                }

                var name = retrieveResponse.EntityCollection[0].GetAttributeValue<string>(attributeName);

                Console.WriteLine(name);
            }
        }

        private RetrieveMultipleRequest getAccountRequest(Guid id)
        {
            return new RetrieveMultipleRequest
            {
                Query = getAccountQuery(id)
            };
        }

        private QueryExpression getAccountQuery(Guid id)
        {
            return new QueryExpression
            {
                EntityName = "account",
                ColumnSet = new ColumnSet(true),
                Criteria = new FilterExpression
                {
                    FilterOperator = LogicalOperator.And,
                    Conditions =
                    {
                        new ConditionExpression
                        {
                            AttributeName = "accountid",
                            Operator = ConditionOperator.Equal,
                            Values = { id }
                        }
                    }
                }
            };
        }

        private List<Guid> accountIds()
        {
            return new List<Guid>
            {
                new Guid("{04C82C07-98F1-E611-9438-00155D6FD706}"),
                new Guid("{06C82C07-98F1-E611-9438-00155D6FD706}"),
                new Guid("{08C82C07-98F1-E611-9438-00155D6FD706}"),
                new Guid("{0AC82C07-98F1-E611-9438-00155D6FD706}")
            };
        }

        private RetrieveMultipleRequest getContactRequest(Guid id)
        {
            return new RetrieveMultipleRequest
            {
                Query = getContactQuery(id)
            };
        }

        private QueryExpression getContactQuery(Guid id)
        {
            return new QueryExpression
            {
                EntityName = "contact",
                ColumnSet = new ColumnSet(true),
                Criteria = new FilterExpression
                {
                    FilterOperator = LogicalOperator.And,
                    Conditions =
                    {
                        new ConditionExpression
                        {
                            AttributeName = "contactid",
                            Operator = ConditionOperator.Equal,
                            Values = { id }
                        }
                    }
                }
            };
        }

        private List<Guid> contactIds()
        {
            return new List<Guid>
            {
                new Guid("{6AC82C07-98F1-E611-9438-00155D6FD706}"),
                new Guid("{6CC82C07-98F1-E611-9438-00155D6FD706}"),
                new Guid("{6EC82C07-98F1-E611-9438-00155D6FD706}"),
                new Guid("{70C82C07-98F1-E611-9438-00155D6FD706}")
            };
        }
    }
}

Answer 5

“最简单的素性测试是试验除法：给定输入数n，检查从2到√n的任何素数m是否均匀地除n（除法不留余数）。如果n可被任何m整除，则n为复合，否则它是素数。“

Wikipedia article on primality test，看看简单的测试，了解其原理。

看起来你继续划分数字，看看是否有任何数字除以它。你会发现，对于给定的n，可以除以n的最大数是m，例如2 * m = n。首先，索引一直到n是检查每个案例两次。例如：

8 % 1 == 8? 
8 % 2 == 0? -> 8 / 2 = 4
8 % 3 == 0?
8 % 4 == 0? -> 8 / 4 = 2
8 % 5 == 0?
8 % 6 == 0?
8 % 7 == 0?

要减轻这些重复检查：你对i进行平方，只检查除数（i）不大于√n。在这种情况下，n=8，我们停在i = 3，因为我们只是交换除数顺序，并再次检查相同的情况。

另请注意：我们将在n = 5处开始循环，因为我们检查基本情况n = 1,2或3？我们知道4不是素数：

输出：

1 is not prime
2 is prime
3 is prime
4 is not prime
5 is prime
6 is not prime
7 is prime
8 is not prime
9 is not prime

代码：

# Via Trivial division
def isPrime(n):

    # False by definition
    if n <= 1:
        return False

    # Consider 2 and 3 base cases
    # for THIS method of detecting
    # prime numbers (trivial division)
    elif n <= 3:
        return True

    # Check that 2 or 3 divides n
    elif n % 2 == 0 or n % 3 == 0:
        return False

    i = 5

    while (i * i) <= n:

        if n % i == 0 or n % (i + 2):
            return False
        i = i + 6

    return True

#--------------------------------------

j = 1
while j < 10:
    if (isPrime(j)):
        print(str(j) + " is prime")

    else:
        print(str(j) + " is not prime")

    j = j + 1

如果数字是素数？

5 个答案: