Imprimer pi à un nombre de décimales

L'un des défis sur w3resources est à imprimer pi à n 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 quelque raison que ce soit, il imprime automatiquement pi sans prise en compte de toutes les entrées. Toute aide serait super 🙂

Le défi est à imprimer pi arrondi à n chiffres après la virgule, ou d'imprimer les n premières décimales de pi?

InformationsquelleAutor Fraser | 2017-07-31

pi python

10

Pourquoi ne pas simplement format à l'aide de 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 originale, je suppose que vous êtes en train de choisir un nombre de chiffres à l'aide de number_of_places comme variable de contrôle de la boucle, ce qui est tout à fait hacky mais ne fonctionne pas dans votre cas, parce que la première number_of_digits entré par l'utilisateur n'est jamais utilisé. C'est au lieu d'être remplacé par l'iteratee les valeurs de la pi chaîne.
- Je pense qu'un peu de défaites tout le défi? Y aurait-il un moyen de modifier le nombre de décimales dans la correspondance à une entrée donnée?
- Il y a le de manière plus générale une partie de la réponse 🙂
- Merci pour la réponse, qui a répondu à ma question. Je suis un débutant total. J'ai essayé de mettre directement la saisie de contenu (pi, ' .inputf) et bien sûr, cela ne fonctionne pas. L' '{ }' vous avez utilisé dans la partie générale de la réponse est un changeur de jeu. Où puis-je en apprendre plus à ce sujet? Merci.
InformationsquelleAutor Moses Koledoye
8

Les solutions proposées à l'aide de np.pi, math.pi, etc ne fonctionne que pour la double précision (~14 chiffres), afin d'obtenir une meilleure précision dont vous avez besoin pour une utilisation en multi-précision, par exemple les mpmath paquet
```
>>> from mpmath import mp
>>> mp.dps = 20    # set number of digits
>>> print(mp.pi)
3.1415926535897932385
```
À l'aide de np.pi donne le mauvais résultat
```
>>> format(np.pi, '.20f')
3.14159265358979311600
```
Comparer à la valeur true:
```
3.14159265358979323846264338327...
```
InformationsquelleAutor Jonas Adler

Votre solution semble être en boucle sur 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":

Qui passe en boucle trois fois, une pour chaque "9" 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 il y a encore des limites n à moins que le len(str(math.pi)), à moins de 15 en Python 2. Étant donné un sérieux n, il se casse:

> 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
>

De faire mieux, nous devons calculer PI nous-mêmes-à l'aide d'une série d'évaluation est une démarche:

# 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")])

Maintenant, nous pouvons prendre une grande valeur de n:

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

InformationsquelleAutor cdlane

Que cette question a déjà des réponses utiles, je voudrais juste partager ce que j'ai créé un programme pour le même but, 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 pour la Lecture.

InformationsquelleAutor vedang_joshi

0

Par exemple le mpmath paquet
```
from mpmath import mp
def a(n):
   mp.dps=n+1
   return(mp.pi)
```
- merci "stackoverflow.com/users/1992679/reegan-miranda" pour le modifier
InformationsquelleAutor Abhishek Bahukhandi

Pourquoi ne pas simplement utiliser:

import numpy as np

def pidecimal(round):
    print(np.round(np.pi, round))

InformationsquelleAutor sai krishna

Vous devez vous connecter pour publier un commentaire.