web-dev-qa-db-fra.com

Imprimez pi à un certain nombre de décimales - Python

L’un des défis de w3resources est d’imprimer pi en décimales. Voici mon code:

from math import pi

fraser = str(pi)

length_of_pi = []

number_of_places = raw_input("Enter the number of decimal places you want to 
see: ")

for number_of_places in fraser:
    length_of_pi.append(str(number_of_places))

print "".join(length_of_pi)

Pour une raison quelconque, il imprime automatiquement pi sans prendre en compte les entrées. Toute aide est la bienvenue :)

pythonpi
4
Fraser

Pourquoi pas simplement format en utilisant number_of_places:

''.format(pi)
>>> format(pi, '.4f')
'3.1416'
>>> format(pi, '.14f')
'3.14159265358979'

Et plus généralement:

>>> number_of_places = 6
>>> '{:.{}f}'.format(pi, number_of_places)
'3.141593'

Dans votre approche initiale, j'imagine que vous essayez de choisir un nombre de chiffres en utilisant number_of_places comme variable de contrôle de la boucle, ce qui est assez compliqué mais ne fonctionne pas dans votre cas car le number_of_digits initial entré par l'utilisateur n'est jamais utilisé. Au lieu de cela, il est remplacé par les valeurs iteratee de la chaîne pi.

9
Moses Koledoye

Les solutions proposées utilisant np.pi, math.pi, etc. fonctionnent uniquement en double précision (~ 14 chiffres). Pour obtenir une précision supérieure, vous devez utiliser la multi-précision, par exemple le package mpmath

>>> from mpmath import mp
>>> mp.dps = 20    # set number of digits
>>> print(mp.pi)
3.1415926535897932385

Utiliser np.pi donne un résultat erroné

>>> format(np.pi, '.20f')
3.14159265358979311600

Comparez à la vraie valeur:

3.14159265358979323846264338327...
5
Jonas Adler

Comme cette question a déjà des réponses utiles, je voudrais juste dire comment j'ai créé un programme ayant le même objectif, qui est très similaire à celui de la question.

from math import pi
i = int(input("Enter the number of decimal places: "))
h = 0
b = list()
for x in str(pi):
    h += 1
    b.append(x)
    if h == i+2:
        break

h = ''.join(b)
print(h)

Merci d'avoir lu.

0
vedang joshi

Votre solution semble faire le tour de la mauvaise chose:

for number_of_places in fraser:

Pour 9 places, cela s'avère être quelque chose comme:

for "9" in "3.141592653589793":

Ce qui boucle trois fois, un pour chaque "9" trouvé dans la chaîne. Nous pouvons réparer votre code:

from math import pi

fraser = str(pi)

length_of_pi = []

number_of_places = int(raw_input("Enter the number of decimal places you want: "))

for places in range(number_of_places + 1):  # +1 for decimal point
    length_of_pi.append(str(fraser[places]))

print "".join(length_of_pi)

Mais ceci limite toujours n à être inférieur à len(str(math.pi)), inférieur à 15 dans Python 2. Donnée une n sérieuse, elle rompt

> python test.py
Enter the number of decimal places you want to see: 100
Traceback (most recent call last):
  File "test.py", line 10, in <module>
    length_of_pi.append(str(fraser[places]))
IndexError: string index out of range
>

Pour faire mieux, nous devons calculer nous-mêmes l’IP. L’évaluation en série est l’une des approches suivantes:

# Rewrite of Henrik Johansson's ([email protected])
# pi.c example from his bignum package for Python 3
#
# Terms based on Gauss' refinement of Machin's formula:
#
# arctan(x) = x - (x^3)/3 + (x^5)/5 - (x^7)/7 + ...

from decimal import Decimal, getcontext

TERMS = [(12, 18), (8, 57), (-5, 239)]  # ala Gauss

def arctan(talj, kvot):

    """Compute arctangent using a series approximation"""

    summation = 0

    talj *= product

    qfactor = 1

    while talj:
        talj //= kvot
        summation += (talj // qfactor)
        qfactor += 2

    return summation

number_of_places = int(input("Enter the number of decimal places you want: "))
getcontext().prec = number_of_places
product = 10 ** number_of_places

result = 0

for multiplier, denominator in TERMS:
    denominator = Decimal(denominator)
    result += arctan(- denominator * multiplier, - (denominator ** 2))

result *= 4  # pi == atan(1) * 4
string = str(result)

# 3.14159265358979E+15 => 3.14159265358979
print(string[0:string.index("E")])

Nous pouvons maintenant prendre une grande valeur de n:

> python3 test2.py
Enter the number of decimal places you want: 100
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067
>
0
cdlane