python-检查奇数/偶数并更改数字大小的输出

我有几个问题要解决，我有点困了。 问题是编写一个程序，让用户输入一个奇数（检查是否为奇数），然后根据输入的大小打印一个倒置的星形金字塔

例如，如果您输入5，它将显示

*****
 ***
  *

因此，我的问题是双重的

1） 如何检查它是偶数还是奇数？我尝试了

如果数字/2==int

，希望它能做些什么，而互联网告诉我如果数字%2==0，应该做

，但这不起作用

 2）如何改变每行中间的星号？
非常感谢您对这两个问题的任何帮助。
1）我如何检查它是偶数还是奇数？我尝试了“IfNumber/2==int”，希望它能做些什么，而互联网告诉我去做“IfNumber%2==0”，但这不起作用

def isEven(number):
        return number % 2 == 0

给你完整的答案毫无意义，因为这是家庭作业，所以这里有几个要点：

偶数或奇数：

number % 2 == 0

这绝对是一个很好的方法来判断你的号码是否是偶数

如果您不知道
%
，则会进行模运算，模运算是
数字
除以
2的剩余部分

打印金字塔：

number % 2 == 0

第一条建议：要打印
******
，您可以执行
打印“*”*5

第二条建议：为了使星号居中，你需要找出在星号前要写多少空格。然后，您可以使用
print”“*1+“*”*3

我会告诉你这是公平的。所以奇数就是这里的else语句。“%”是mod符号，它返回除法后的余数。所以本质上我们是说，如果这个数字可以被2整除，我们可以安全地假设它是偶数。否则就很奇怪了（这是一个完美的关联！）

至于星号的位置，你需要在星号前面加上与其所在行相关的空格数。在你的例子中

***** line 0
***   line 1
*     line 2

我们将需要相应的空间

0*****
01***
012*

关于打印输出，以下是我将如何使用（部分：对齐文本并指定宽度）：

确定长度后，说
length=11
：

rowstring = '{{: ^{length:d}}}'.format(length = length) # center aligned, space-padded format string of length <length>
for i in xrange(length, 0, -2): # iterate from top to bottom with step size 2
    print rowstring.format( '*' * i )

rowstring='{{：^{length:d}}'。格式（length=length）#中心对齐，空格填充的长度格式字符串
对于x范围内的i（长度，0，-2）：#以步长2从上到下迭代
打印rowstring.format（'*'*i）
有很多方法可以检查int值是奇数还是偶数。
我将向您展示两种主要方式：

number = 5

def best_way(number):
    if number%2==0:
        print "even"
    else:
        print "odd"

def binary_way(number):
    if str(bin(number))[len(bin(number))-1]=='0':
        print "even"
    else:
        print "odd"
best_way(number)
binary_way(number)

希望它有助于
简单但快速：

la = lambda x : "even" if not x % 2 else "odd"

>>> def is_odd(a):
...     return bool(a - ((a>>1)<<1))
...
>>> print(is_odd(13))
True
>>> print(is_odd(12))
False
>>>

具有%2的模2解是好的，但这需要除法和减法。由于计算机使用二进制算法，因此更有效的解决方案是：

# This first solution does not produce a Boolean value. 
is_odd_if_zero = value & 1

# or

is_odd = (value & 1) == 1

# or

is_even = (value & 1) == 0

以下是我的解决方案：

def is_even(n):
    r=n/2.0
    return True if r==int(r) else False

我想最简单最基本的方法就是这样

import math

number = int (input ('Enter number: '))

if number % 2 == 0 and number != 0:
    print ('Even number')
elif number == 0:
    print ('Zero is neither even, nor odd.')
else:
    print ('Odd number')

只是基本条件和数学。它也关注零，它既不是偶数，也不是奇数，你通过输入给出你想要的任何数字，所以它是非常可变的

def main():
    n = float(input('odd:'))
    while n % 2 == 0:
        #if n % 2 == 1: No need for these lines as if it were true the while loop would not have been entered.
            #break not required as the while condition will break loop
        n = float(input('odd:'))


    for i in range(int((n+1)/2)):
        print(' '*i+'*'*int((n-2*i))+' '*i)

main()

#第1部分确保输入的是奇数。第2部分打印三角形
示例指令
给定一个整数，
n
，执行以下条件操作：


如果n为奇数，则打印为奇数
如果n为偶数且在2到5的范围内，则打印不奇怪
如果n为偶数且在6到20的范围内，请打印
如果n为偶数且大于20，则打印不奇怪

导入数学
n=int（输入（））
如果n%2==1：
印刷品（“怪异”）
elif n%2==0且n在范围（2,6）内：
打印（“不奇怪”）
elif n%2==0且n在范围（6,21）内：
印刷品（“怪异”）
如果n%2==0且n>20：
打印（“不奇怪”）
这是一个简单的代码。你可以尝试一下，轻松掌握知识

n = int(input('Enter integer : '))
    if n % 2 == 3`8huhubuiiujji`:
        print('digit entered is ODD')
    elif n % 2 == 0 and 2 < n < 5:
        print('EVEN AND in between [2,5]')
    elif n % 2 == 0 and 6 < n < 20:
        print('EVEN and in between [6,20]')
    elif n % 2 == 0 and n > 20:
       print('Even and greater than 20')

n=int（输入（'Enter integer:'））
如果n%2==3`8huhubuiiujji`:
打印（'输入的数字为奇数'）
如果n%2==0且220：
打印（'均匀且大于20'）

等等…
这里的一些解决方案引用了各种“是偶数”操作所需的时间，特别是
n%2
vs
n&1
，而没有系统地检查这是如何随
n
的大小而变化的，这证明是对速度的预测

简而言之，如果你使用的是合理大小的数字

基本上，当你达到“任意精度”时，模的运算速度会逐渐变慢，而按位运算则保持不变。此外，请注意这一点上的
10**-7
乘法器，即每秒可以进行约3000万次（小整数）检查

以下是Python 2.7.16的相同绘图：


这显示了Python新版本的优化

我的机器上只有这些版本的Python，但可以重新运行其他版本的Python。在1和1e100之间有51个
n
s（在对数刻度上均匀分布），对于每个点，我做的等效操作如下：

timeit('n % 2', f'n={n}', number=niter) 

其中，
niter
计算为使
timeit
花费约0.1秒，并重复5次。对
n
的稍微笨拙的处理是为了确保我们没有对全局变量查找进行基准测试，因为全局变量查找比局部变量慢。这些值的平均值用于绘制线，各个值被绘制为点。
我的解决方案基本上有两个字符串，使用-，我们得到正确的索引：

res = ["Even", "Odd"]
print(res[x & 1])

请注意，它似乎比其他备选方案慢：

#!/usr/bin/env python3
import math
import random
from timeit import timeit

res = ["Even", "Odd"]

def foo(x):
    return res[x & 1]

def bar(x):
    if x & 1:
        return "Odd"
    return "Even"

la = lambda x : "Even" if not x % 2 else "Odd"

iter = 10000000

time = timeit('bar(random.randint(1, 1000))', "from __main__ import bar, random", number=iter)
print(time)
time = timeit('la(random.randint(1, 1000))', "from __main__ import la, random", number=iter)
print(time)
time = timeit('foo(random.randint(1, 1000))', "from __main__ import foo, random", number=iter)
print(time)

输出：

8.05739480999182

8.170479692984372

8.892275177990086
模数法是常用的方法。我们也可以这样做，以检查是否奇数或
#!/usr/bin/env python3
import math
import random
from timeit import timeit

res = ["Even", "Odd"]

def foo(x):
    return res[x & 1]

def bar(x):
    if x & 1:
        return "Odd"
    return "Even"

la = lambda x : "Even" if not x % 2 else "Odd"

iter = 10000000

time = timeit('bar(random.randint(1, 1000))', "from __main__ import bar, random", number=iter)
print(time)
time = timeit('la(random.randint(1, 1000))', "from __main__ import la, random", number=iter)
print(time)
time = timeit('foo(random.randint(1, 1000))', "from __main__ import foo, random", number=iter)
print(time)

def f(a):
    if (a//2)*2 == a:
        return 'even'
    else:
        return 'odd'

def isodd(i):
    return(bool(i>>0&1))

>>> isodd(2)
False
>>> isodd(3)
True
>>> isodd(4)
False

def nearodd(f):
    return int(f/2)*2+1

nearodd(4.9)
5

nearodd(7.2)
7

nearodd(8)
9  

def oddOrEven(num):
    if num%2 == 0:
        print("even")

    else: 
        for i in range(num):
            for j in range(i+1):
                print(" ", end="")
            for m in range(num-i, 0, -1):
                print("* ", end="")
            print()

 * * * * *
  * * * *
   * * *
    * *
     *