<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Programação — Tutorial Sage v5.9</title>
<link rel="stylesheet" href="_static/sage.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '5.9',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<script type="text/javascript" src="_static/translations.js"></script>
<link rel="shortcut icon" href="_static/favicon.ico"/>
<link rel="top" title="Tutorial Sage v5.9" href="index.html" />
<link rel="next" title="Usando o SageTeX" href="sagetex.html" />
<link rel="prev" title="Sage, LaTeX e Companheiros" href="latex.html" />
<link rel="icon" href="_static/sageicon.png" type="image/x-icon" />
</head>
<body>
<div class="related">
<h3>Navegação</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="Índice Geral"
accesskey="I">índice</a></li>
<li class="right" >
<a href="py-modindex.html" title="Índice de Módulos do Python"
>módulos</a> |</li>
<li class="right" >
<a href="sagetex.html" title="Usando o SageTeX"
accesskey="N">próximo</a> |</li>
<li class="right" >
<a href="latex.html" title="Sage, LaTeX e Companheiros"
accesskey="P">anterior</a> |</li>
<a href="../index.html"><img src="_static/sagelogo.png" style="vertical-align: middle" title="Sage Logo"></a>
<li><a href="index.html">Tutorial Sage v5.9</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="programacao">
<h1>Programação<a class="headerlink" href="#programacao" title="Link permanente para este título">¶</a></h1>
<div class="section" id="carregando-e-anexando-arquivos-do-sage">
<span id="section-loadattach"></span><h2>Carregando e Anexando Arquivos do Sage<a class="headerlink" href="#carregando-e-anexando-arquivos-do-sage" title="Link permanente para este título">¶</a></h2>
<p>A seguir ilustramos como carregar no Sage programas escritos em um
arquivo separado. Crie um arquivo chamado <tt class="docutils literal"><span class="pre">example.sage</span></tt> com o
seguinte conteúdo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">print</span> <span class="s">"Hello World"</span>
<span class="k">print</span> <span class="mi">2</span><span class="o">^</span><span class="mi">3</span>
</pre></div>
</div>
<p>Você pode ler e executar o arquivo <tt class="docutils literal"><span class="pre">example.sage</span></tt> usando o comando
<tt class="docutils literal"><span class="pre">load</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: load "example.sage"</span>
<span class="go">Hello World</span>
<span class="go">8</span>
</pre></div>
</div>
<p>Você também pode anexar um arquivo em Sage à sessão em execução usando
o comando <tt class="docutils literal"><span class="pre">attach</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: attach "example.sage"</span>
<span class="go">Hello World</span>
<span class="go">8</span>
</pre></div>
</div>
<p>Agora se você alterar <tt class="docutils literal"><span class="pre">example.sage</span></tt> e adicionar uma linha em branco
(por exemplo), então o conteúdo de <tt class="docutils literal"><span class="pre">example.sage</span></tt> será
automaticamente recarregado no Sage.</p>
<p>Em particular, <tt class="docutils literal"><span class="pre">attach</span></tt> automaticamente recarrega um arquivo toda
vez que ele for modificado, o que é útil para desenvolver e testar um
programa, enquanto <tt class="docutils literal"><span class="pre">load</span></tt> carrega o arquivo apenas uma vez.</p>
<p>Quando o Sage carrega <tt class="docutils literal"><span class="pre">example.sage</span></tt> ele converte esse arquivo para
o Python, o qual é então executado pelo interpretador do Python. Essa
conversão é mínima; ela essencialmente consiste em encapsular inteiros
em <tt class="docutils literal"><span class="pre">Integer()</span></tt>, números float em <tt class="docutils literal"><span class="pre">RealNumber()</span></tt>, substituir <tt class="docutils literal"><span class="pre">^</span></tt>
por <tt class="docutils literal"><span class="pre">**</span></tt>, e substituir, por exemplo, <tt class="docutils literal"><span class="pre">R.2</span></tt> por <tt class="docutils literal"><span class="pre">R.gen(2)</span></tt>. A
versão convertida de <tt class="docutils literal"><span class="pre">example.sage</span></tt> é armazenada no mesmo diretório
de <tt class="docutils literal"><span class="pre">example.sage</span></tt> e é chamada <tt class="docutils literal"><span class="pre">example.sage.py</span></tt>. Esse arquivo
contém o seguinte código:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">print</span> <span class="s">"Hello World"</span>
<span class="k">print</span> <span class="n">Integer</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span><span class="o">**</span><span class="n">Integer</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
</pre></div>
</div>
<p>Inteiros literais são encapsulados e <tt class="docutils literal"><span class="pre">^</span></tt> é substituído por <tt class="docutils literal"><span class="pre">**</span></tt>.
(Em Python, <tt class="docutils literal"><span class="pre">^</span></tt> significa “ou exclusivo” e <tt class="docutils literal"><span class="pre">**</span></tt> significa
“exponenciação”.)</p>
<p>Esse “” está implementado em <tt class="docutils literal"><span class="pre">sage/misc/interpreter.py</span></tt>.)</p>
<p>Você pode colar código tabulado com muitas linhas no Sage desde que
existam linhas em branco separando blocos de código (isso não é
necessário em arquivos). Todavia, a melhor forma de adicionar tal
código a uma sessão do Sage é salvá-lo em um arquivo e usar
<tt class="docutils literal"><span class="pre">attach</span></tt>, como descrito anteriormente.</p>
</div>
<div class="section" id="criando-codigo-compilado">
<span id="section-compile"></span><h2>Criando Código Compilado<a class="headerlink" href="#criando-codigo-compilado" title="Link permanente para este título">¶</a></h2>
<p>Velocidade é crucial em cálculos matemáticos. Embora o Python seja uma
linguagem conveniente de alto nível, certos cálculos podem ser várias
vezes mais rápidos do que em Python se eles forem implementados usando
tipos estáticos em uma linguagem compilada. Alguns aspectos do Sage
seriam muito lentos se eles fossem escritos inteiramente em Python.
Para lidar com isso, o Sage suporta uma “versão” compilada do Python
chamada Cython (<a class="reference internal" href="bibliography.html#cyt">[Cyt]</a> and <a class="reference internal" href="bibliography.html#pyr">[Pyr]</a>). O Cython é simultaneamente similar
ao Python e ao C. A maior parte das construções em Python, incluindo
“list comprehensions”, expressões condicionais, código como <tt class="docutils literal"><span class="pre">+=</span></tt> são
permitidos; você também pode importar código que você escreveu em
outros módulos em Python. Além disso, você pode declarar variáveis em
C arbitrárias, e qualquer chamada de bibliotecas em C pode ser feita
diretamente. O código resultante é convertido para C e compilado
usando um compilador para C.</p>
<p>Para criar o seu próprio código compilado em Sage, nomeie o arquivo
com uma extensão <tt class="docutils literal"><span class="pre">.spyx</span></tt> (em vez de <tt class="docutils literal"><span class="pre">.sage</span></tt>). Se você está
trabalhando na linha de comando, você pode anexar e carregar código
compilado exatamente como se faz com código interpretado (no momento,
anexar e carregar código em Cython não é suportado no Notebook). A
compilação é realizada implicitamente sem que você tenha que fazer
qualquer coisa explicitamente. Veja
<tt class="docutils literal"><span class="pre">$SAGE_ROOT/examples/programming/sagex/factorial.spyx</span></tt> para um
exemplo de uma implementação compilada para a função fatorial que usa
diretamente a biblioteca GMP em C. Experimente o seguinte, usando cd,
vá para o diretório <tt class="docutils literal"><span class="pre">$SAGE_ROOT/examples/programming/sagex/</span></tt>, e
então faça o seguinte:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: load "factorial.spyx"</span>
<span class="go">***************************************************</span>
<span class="go"> Recompiling factorial.spyx</span>
<span class="go">***************************************************</span>
<span class="go">sage: factorial(50)</span>
<span class="go">30414093201713378043612608166064768844377641568960512000000000000L</span>
<span class="go">sage: time n = factorial(10000)</span>
<span class="go">CPU times: user 0.03 s, sys: 0.00 s, total: 0.03 s</span>
<span class="go">Wall time: 0.03</span>
</pre></div>
</div>
<p>Aqui o sufixo L indica um “long integer” do Python (veja
<a class="reference internal" href="afterword.html#section-mathannoy"><em>O Pré-Processador: Diferenças entre o Sage e o Python</em></a>).</p>
<p>Note que o Sage vai recompilar <tt class="docutils literal"><span class="pre">factorial.spyx</span></tt> se você encerrar e
reiniciar o Sage. A biblioteca compilada e compartilhada é armazenada
em <tt class="docutils literal"><span class="pre">$HOME/.sage/temp/hostname/pid/spyx</span></tt>. Esses arquivos são
excluídos quando você encerra o Sage.</p>
<p>Nenhum pré-processamento (preparsing) é aplicado em arquivos spyx, por
exemplo, <tt class="docutils literal"><span class="pre">1/3</span></tt> vai resultar em 0 em um arquivo spyx em vez do número
racional <img class="math" src="_images/math/217aedbdc339bacc8ba075a2ec16902b098194e3.png" alt="1/3"/>. Se <tt class="docutils literal"><span class="pre">foo</span></tt> é uma função da biblioteca Sage, para
usá-la em um arquivo spyx importe <tt class="docutils literal"><span class="pre">sage.all</span></tt> e use <tt class="docutils literal"><span class="pre">sage.all.foo</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="kn">import</span> <span class="nn">sage.all</span>
<span class="k">def</span> <span class="nf">foo</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
<span class="k">return</span> <span class="n">sage</span><span class="o">.</span><span class="n">all</span><span class="o">.</span><span class="n">factorial</span><span class="p">(</span><span class="n">n</span><span class="p">)</span>
</pre></div>
</div>
<div class="section" id="acessando-funcoes-em-c-em-arquivos-separados">
<h3>Acessando Funções em C em Arquivos Separados<a class="headerlink" href="#acessando-funcoes-em-c-em-arquivos-separados" title="Link permanente para este título">¶</a></h3>
<p>É fácil também acessar funções em C definidas em arquivos *.c
separados. Aqui vai um exemplo. Crie os arquivos <tt class="docutils literal"><span class="pre">test.c</span></tt> e
<tt class="docutils literal"><span class="pre">test.spyx</span></tt> no mesmo diretório contendo:</p>
<p>Código C puro: <tt class="docutils literal"><span class="pre">test.c</span></tt></p>
<div class="highlight-python"><pre>int add_one(int n) {
return n + 1;
}</pre>
</div>
<p>Código Cython: <tt class="docutils literal"><span class="pre">test.spyx</span></tt>:</p>
<div class="highlight-python"><pre>cdef extern from "test.c":
int add_one(int n)
def test(n):
return add_one(n)</pre>
</div>
<p>Então o seguinte funciona:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: attach "test.spyx"</span>
<span class="go">Compiling (...)/test.spyx...</span>
<span class="go">sage: test(10)</span>
<span class="go">11</span>
</pre></div>
</div>
<p>Se uma biblioteca <tt class="docutils literal"><span class="pre">foo</span></tt> adicional é necessária para compilar código
em C gerado a partir de um arquivo em Cython, adicione a linha <tt class="docutils literal"><span class="pre">clib</span>
<span class="pre">foo</span></tt> no arquivo fonte em Cython. De forma similar, um arquivo em C
adicional <tt class="docutils literal"><span class="pre">bar</span></tt> pode ser incluído na compilação declarando <tt class="docutils literal"><span class="pre">cfile</span>
<span class="pre">bar</span></tt>.</p>
</div>
</div>
<div class="section" id="scripts-independentes-em-python-sage">
<span id="section-standalone"></span><h2>Scripts Independentes em Python/Sage<a class="headerlink" href="#scripts-independentes-em-python-sage" title="Link permanente para este título">¶</a></h2>
<p>O seguinte script em Sage fatora inteiros, polinômios, etc:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c">#!/usr/bin/env sage -python</span>
<span class="kn">import</span> <span class="nn">sys</span>
<span class="kn">from</span> <span class="nn">sage.all</span> <span class="kn">import</span> <span class="o">*</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">)</span> <span class="o">!=</span> <span class="mi">2</span><span class="p">:</span>
<span class="k">print</span> <span class="s">"Usage: </span><span class="si">%s</span><span class="s"> <n>"</span><span class="o">%</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="k">print</span> <span class="s">"Outputs the prime factorization of n."</span>
<span class="n">sys</span><span class="o">.</span><span class="n">exit</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="k">print</span> <span class="n">factor</span><span class="p">(</span><span class="n">sage_eval</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">]))</span>
</pre></div>
</div>
<p>Para usar esse script, sua <tt class="docutils literal"><span class="pre">SAGE_ROOT</span></tt> precisa estar na sua variável
PATH. Se o script acima for chamado <tt class="docutils literal"><span class="pre">factor</span></tt>, aqui está um exemplo
de como usá-lo:</p>
<div class="highlight-python"><pre>bash $ ./factor 2006
2 * 17 * 59
bash $ ./factor "32*x^5-1"
(2*x - 1) * (16*x^4 + 8*x^3 + 4*x^2 + 2*x + 1)</pre>
</div>
</div>
<div class="section" id="tipo-de-dados">
<h2>Tipo de Dados<a class="headerlink" href="#tipo-de-dados" title="Link permanente para este título">¶</a></h2>
<p>Cada objeto em Sage possui um tipo bem definido. O Python possui
diversos tipos de dados, e a biblioteca do Sage adiciona ainda mais.
Os tipos de dados de Python incluem strings, listas, tuplas, inteiros
e floats, como ilustrado:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: s = "sage"; type(s)</span>
<span class="go"><type 'str'></span>
<span class="go">sage: s = 'sage'; type(s) # you can use either single or double quotes</span>
<span class="go"><type 'str'></span>
<span class="go">sage: s = [1,2,3,4]; type(s)</span>
<span class="go"><type 'list'></span>
<span class="go">sage: s = (1,2,3,4); type(s)</span>
<span class="go"><type 'tuple'></span>
<span class="go">sage: s = int(2006); type(s)</span>
<span class="go"><type 'int'></span>
<span class="go">sage: s = float(2006); type(s)</span>
<span class="go"><type 'float'></span>
</pre></div>
</div>
<p>Além disso, o Sage acrescenta vários outros tipos. Por exemplo,
espaços vetoriais:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: V = VectorSpace(QQ, 1000000); V</span>
<span class="go">Vector space of dimension 1000000 over Rational Field</span>
<span class="go">sage: type(V)</span>
<span class="go"><class 'sage.modules.free_module.FreeModule_ambient_field_with_category'></span>
</pre></div>
</div>
<p>Apenas certas funções podem ser aplicadas sobre <tt class="docutils literal"><span class="pre">V</span></tt>. Em outros
softwares de matemática, essas seriam chamadas usando a notação
“funcional” <tt class="docutils literal"><span class="pre">foo(V,...)</span></tt>. Em Sage, algumas funções estão anexadas ao
tipo (ou classe) de <tt class="docutils literal"><span class="pre">V</span></tt>, e são chamadas usando uma sintaxe orientada
a objetos como em Java ou C++, por exemplo, <tt class="docutils literal"><span class="pre">V.foo()</span></tt>. Isso ajuda a
manter o espaço de variáveis global sem milhares de funções, e permite
que várias funções diferentes com comportamento diferente possam ser
chamadas foo, sem a necessidade de usar um mecanismo de identificação
de tipos (ou casos) para decidir qual chamar. Além disso, se você
reutilizar o nome de uma função, essa função continua ainda disponível
(por exemplo, se você chamar algo <tt class="docutils literal"><span class="pre">zeta</span></tt>, e então quiser calcular o
valor da função zeta de Riemann em 0.5, você continua podendo digitar
<tt class="docutils literal"><span class="pre">s=.5;</span> <span class="pre">s.zeta()</span></tt>).</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: zeta = -1</span>
<span class="go">sage: s=.5; s.zeta()</span>
<span class="go">-1.46035450880959</span>
</pre></div>
</div>
<p>Em alguns casos muito comuns, a notação funcional usual é também
suportada por conveniência e porque expressões matemáticas podem
parecer confusas usando a notação orientada a objetos. Aqui vão alguns
exemplos.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: n = 2; n.sqrt()</span>
<span class="go">sqrt(2)</span>
<span class="go">sage: sqrt(2)</span>
<span class="go">sqrt(2)</span>
<span class="go">sage: V = VectorSpace(QQ,2)</span>
<span class="go">sage: V.basis()</span>
<span class="go"> [</span>
<span class="go"> (1, 0),</span>
<span class="go"> (0, 1)</span>
<span class="go"> ]</span>
<span class="go">sage: basis(V)</span>
<span class="go"> [</span>
<span class="go"> (1, 0),</span>
<span class="go"> (0, 1)</span>
<span class="go"> ]</span>
<span class="go">sage: M = MatrixSpace(GF(7), 2); M</span>
<span class="go">Full MatrixSpace of 2 by 2 dense matrices over Finite Field of size 7</span>
<span class="go">sage: A = M([1,2,3,4]); A</span>
<span class="go">[1 2]</span>
<span class="go">[3 4]</span>
<span class="go">sage: A.charpoly('x')</span>
<span class="go">x^2 + 2*x + 5</span>
<span class="go">sage: charpoly(A, 'x')</span>
<span class="go">x^2 + 2*x + 5</span>
</pre></div>
</div>
<p>Para listar todas as funções para <img class="math" src="_images/math/019e9892786e493964e145e7c5cf7b700314e53b.png" alt="A"/>, use completamento tab.
Simplesmente digite <tt class="docutils literal"><span class="pre">A.</span></tt>, então tecle <tt class="docutils literal"><span class="pre">[tab]</span></tt> no seu teclado, como
descrito em <a class="reference internal" href="interactive_shell.html#section-tabcompletion"><em>Busca Reversa e Completamento Tab</em></a>.</p>
</div>
<div class="section" id="listas-tuplas-e-sequencias">
<h2>Listas, Tuplas e Sequências<a class="headerlink" href="#listas-tuplas-e-sequencias" title="Link permanente para este título">¶</a></h2>
<p>O tipo de dados lista armazena elementos de um tipo arbitrário. Como
em C, C++, etc. (mas diferentemente da maioria dos sistemas de álgebra
computacional), os elementos da lista são indexados a partir do
<img class="math" src="_images/math/bc1f9d9bf8a1b606a4188b5ce9a2af1809e27a89.png" alt="0"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: v = [2, 3, 5, 'x', SymmetricGroup(3)]; v</span>
<span class="go">[2, 3, 5, 'x', Symmetric group of order 3! as a permutation group]</span>
<span class="go">sage: type(v)</span>
<span class="go"><type 'list'></span>
<span class="go">sage: v[0]</span>
<span class="go">2</span>
<span class="go">sage: v[2]</span>
<span class="go">5</span>
</pre></div>
</div>
<p>(Quando se indexa uma lista, é permitido que o índice não seja um int
do Python!) Um Inteiro do Sage (ou Racional, ou qualquer objeto que
possua um método <tt class="docutils literal"><span class="pre">__index__</span></tt>) também ira funcionar.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: v = [1,2,3]</span>
<span class="go">sage: v[2]</span>
<span class="go">3</span>
<span class="go">sage: n = 2 # SAGE Integer</span>
<span class="go">sage: v[n] # Perfectly OK!</span>
<span class="go">3</span>
<span class="go">sage: v[int(n)] # Also OK.</span>
<span class="go">3</span>
</pre></div>
</div>
<p>A função <tt class="docutils literal"><span class="pre">range</span></tt> cria uma lista de int’s do Python (não Inteiros do
Sage):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: range(1, 15)</span>
<span class="go">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]</span>
</pre></div>
</div>
<p>Isso é útil quando se usa “list comprehensions” para construir listas:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: L = [factor(n) for n in range(1, 15)]</span>
<span class="go">sage: print L</span>
<span class="go">[1, 2, 3, 2^2, 5, 2 * 3, 7, 2^3, 3^2, 2 * 5, 11, 2^2 * 3, 13, 2 * 7]</span>
<span class="go">sage: L[12]</span>
<span class="go">13</span>
<span class="go">sage: type(L[12])</span>
<span class="go"><class 'sage.structure.factorization_integer.IntegerFactorization'></span>
<span class="go">sage: [factor(n) for n in range(1, 15) if is_odd(n)]</span>
<span class="go">[1, 3, 5, 7, 3^2, 11, 13]</span>
</pre></div>
</div>
<p>Para mais sobre como criar listas usando “list comprehensions”, veja
<a class="reference internal" href="bibliography.html#pyt">[PyT]</a>.</p>
<p>Fatiamento de lista (list slicing) é um recurso fantástico. Se <tt class="docutils literal"><span class="pre">L</span></tt> é
uma lista, então <tt class="docutils literal"><span class="pre">L[m:n]</span></tt> retorna uma sub-lista de <tt class="docutils literal"><span class="pre">L</span></tt> obtida
começando do <img class="math" src="_images/math/f5047d1e0cbb50ec208923a22cd517c55100fa7b.png" alt="m"/>-ésimo elemento e terminando no
<img class="math" src="_images/math/7955459cf8b75c3ac12c23c393024177d7d56412.png" alt="(n-1)"/>-ésimo elemento, como ilustrado abaixo.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: L = [factor(n) for n in range(1, 20)]</span>
<span class="go">sage: L[4:9]</span>
<span class="go">[5, 2 * 3, 7, 2^3, 3^2]</span>
<span class="go">sage: print L[:4]</span>
<span class="go">[1, 2, 3, 2^2]</span>
<span class="go">sage: L[14:4]</span>
<span class="go">[]</span>
<span class="go">sage: L[14:]</span>
<span class="go">[3 * 5, 2^4, 17, 2 * 3^2, 19]</span>
</pre></div>
</div>
<p>Tuplas são semelhantes à listas, exceto que elas são imutáveis: uma
vez criadas elas não podem ser alteradas.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: v = (1,2,3,4); v</span>
<span class="go">(1, 2, 3, 4)</span>
<span class="go">sage: type(v)</span>
<span class="go"><type 'tuple'></span>
<span class="go">sage: v[1] = 5</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="gr">TypeError</span>: <span class="n">'tuple' object does not support item assignment</span>
</pre></div>
</div>
<p>Sequências são um terceiro tipo de dados do Sage semelhante a listas.
Diferentemente de listas e tuplas, Sequence não é um tipo de dados
nativo do Python. Por definição, uma sequência é mutável, mas usando o
método <tt class="docutils literal"><span class="pre">set_immutable</span></tt> da classe <tt class="docutils literal"><span class="pre">Sequence</span></tt> elas podem ser feitas
imutáveis, como mostra o exemplo a seguir. Todos os elementos da
sequência possuem um parente comum, chamado o universo da sequência.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: v = Sequence([1,2,3,4/5])</span>
<span class="go">sage: v</span>
<span class="go">[1, 2, 3, 4/5]</span>
<span class="go">sage: type(v)</span>
<span class="go"><class 'sage.structure.sequence.Sequence_generic'></span>
<span class="go">sage: type(v[1])</span>
<span class="go"><type 'sage.rings.rational.Rational'></span>
<span class="go">sage: v.universe()</span>
<span class="go">Rational Field</span>
<span class="go">sage: v.is_immutable()</span>
<span class="go">False</span>
<span class="go">sage: v.set_immutable()</span>
<span class="go">sage: v[0] = 3</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="gr">ValueError</span>: <span class="n">object is immutable; please change a copy instead.</span>
</pre></div>
</div>
<p>Sequências são derivadas de listas e podem ser usadas em qualquer
lugar que listas são usadas.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: v = Sequence([1,2,3,4/5])</span>
<span class="go">sage: isinstance(v, list)</span>
<span class="go">True</span>
<span class="go">sage: list(v)</span>
<span class="go">[1, 2, 3, 4/5]</span>
<span class="go">sage: type(list(v))</span>
<span class="go"><type 'list'></span>
</pre></div>
</div>
<p>Como um outro exemplo, bases para espaços vetoriais são sequências
imutáveis, pois é importante que elas não sejam modificadas.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: V = QQ^3; B = V.basis(); B</span>
<span class="go">[</span>
<span class="go">(1, 0, 0),</span>
<span class="go">(0, 1, 0),</span>
<span class="go">(0, 0, 1)</span>
<span class="go">]</span>
<span class="go">sage: type(B)</span>
<span class="go"><class 'sage.structure.sequence.Sequence_generic'></span>
<span class="go">sage: B[0] = B[1]</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="gr">ValueError</span>: <span class="n">object is immutable; please change a copy instead.</span>
<span class="go">sage: B.universe()</span>
<span class="go">Vector space of dimension 3 over Rational Field</span>
</pre></div>
</div>
</div>
<div class="section" id="dicionarios">
<h2>Dicionários<a class="headerlink" href="#dicionarios" title="Link permanente para este título">¶</a></h2>
<p>Um dicionário (também chamado as vezes de lista associativa ou “hash
table”) é um mapeamento de objetos em objetos arbitrários. (Exemplos
de objetos que admitem uma lista associativa são strings e números;
veja a documentação Python em <a class="reference external" href="http://docs.python.org/tut/node7.html">http://docs.python.org/tut/node7.html</a> e
<a class="reference external" href="http://docs.python.org/lib/typesmapping.html">http://docs.python.org/lib/typesmapping.html</a> para detalhes).</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: d = {1:5, 'sage':17, ZZ:GF(7)}</span>
<span class="go">sage: type(d)</span>
<span class="go"><type 'dict'></span>
<span class="go">sage: d.keys()</span>
<span class="go"> [1, 'sage', Integer Ring]</span>
<span class="go">sage: d['sage']</span>
<span class="go">17</span>
<span class="go">sage: d[ZZ]</span>
<span class="go">Finite Field of size 7</span>
<span class="go">sage: d[1]</span>
<span class="go">5</span>
</pre></div>
</div>
<p>A terceira chave (key) ilustra como os índices de um dicionário podem
ser complicados, por exemplo, um anel de inteiros.</p>
<p>Você pode transformar o dicionário acima em uma lista com os mesmos
dados:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: d.items()</span>
<span class="go">[(1, 5), ('sage', 17), (Integer Ring, Finite Field of size 7)]</span>
</pre></div>
</div>
<p>É comum iterar sobre os pares em um dicionário:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: d = {2:4, 3:9, 4:16}</span>
<span class="go">sage: [a*b for a, b in d.iteritems()]</span>
<span class="go">[8, 27, 64]</span>
</pre></div>
</div>
<p>Um dicionário não possui ordem, como o exemplo acima mostra.</p>
</div>
<div class="section" id="conjuntos">
<h2>Conjuntos<a class="headerlink" href="#conjuntos" title="Link permanente para este título">¶</a></h2>
<p>O Python possui um tipo de conjuntos (set) nativo. O principal recurso
que ele oferece é a rápida verificação se um objeto está ou não em um
conjunto, juntamente com as operações comuns em conjuntos.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: X = set([1,19,'a']); Y = set([1,1,1, 2/3])</span>
<span class="go">sage: X</span>
<span class="go">set(['a', 1, 19])</span>
<span class="go">sage: Y</span>
<span class="go">set([1, 2/3])</span>
<span class="go">sage: 'a' in X</span>
<span class="go">True</span>
<span class="go">sage: 'a' in Y</span>
<span class="go">False</span>
<span class="go">sage: X.intersection(Y)</span>
<span class="go">set([1])</span>
</pre></div>
</div>
<p>O Sage também possui o seu próprio tipo de dados para conjuntos que é
(em alguns casos) implementado usando o tipo nativo do Python, mas
possuir algumas funcionalidades adicionais. Crie um conjunto em Sage
usando <tt class="docutils literal"><span class="pre">Set(...)</span></tt>. Por exemplo,</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: X = Set([1,19,'a']); Y = Set([1,1,1, 2/3])</span>
<span class="go">sage: X</span>
<span class="go">{'a', 1, 19}</span>
<span class="go">sage: Y</span>
<span class="go">{1, 2/3}</span>
<span class="go">sage: X.intersection(Y)</span>
<span class="go">{1}</span>
<span class="go">sage: print latex(Y)</span>
<span class="go">\left\{1, \frac{2}{3}\right\}</span>
<span class="go">sage: Set(ZZ)</span>
<span class="go">Set of elements of Integer Ring</span>
</pre></div>
</div>
</div>
<div class="section" id="iteradores">
<h2>Iteradores<a class="headerlink" href="#iteradores" title="Link permanente para este título">¶</a></h2>
<p>Iteradores foram adicionados recentemente ao Python e são
particularmente úteis em aplicações matemáticas. Aqui estão vários
exemplos; veja <a class="reference internal" href="bibliography.html#pyt">[PyT]</a> para mais detalhes. Vamos criar um iterador
sobre o quadrados dos números inteiros até <img class="math" src="_images/math/c4b7944fa276d9ec5b24da0d60c54d903a67dae4.png" alt="10000000"/>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: v = (n^2 for n in xrange(10000000))</span>
<span class="go">sage: v.next()</span>
<span class="go">0</span>
<span class="go">sage: v.next()</span>
<span class="go">1</span>
<span class="go">sage: v.next()</span>
<span class="go">4</span>
</pre></div>
</div>
<p>Criamos agora um iterador sobre os primos da forma <img class="math" src="_images/math/2a1db6fdf22b67fce46356a3e76964125408175b.png" alt="4p+1"/> com
<img class="math" src="_images/math/36f73fc1312ee0349b3f3a0f3bd9eb5504339011.png" alt="p"/> também primo, e observamos os primeiros valores.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: w = (4*p + 1 for p in Primes() if is_prime(4*p+1))</span>
<span class="go">sage: w # in the next line, 0xb0853d6c is a random 0x number</span>
<span class="go"><generator object at 0xb0853d6c></span>
<span class="go">sage: w.next()</span>
<span class="go">13</span>
<span class="go">sage: w.next()</span>
<span class="go">29</span>
<span class="go">sage: w.next()</span>
<span class="go">53</span>
</pre></div>
</div>
<p>Certos anéis, por exemplo, corpos finitos e os inteiros possuem
iteradores associados a eles:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: [x for x in GF(7)]</span>
<span class="go">[0, 1, 2, 3, 4, 5, 6]</span>
<span class="go">sage: W = ((x,y) for x in ZZ for y in ZZ)</span>
<span class="go">sage: W.next()</span>
<span class="go">(0, 0)</span>
<span class="go">sage: W.next()</span>
<span class="go">(0, 1)</span>
<span class="go">sage: W.next()</span>
<span class="go">(0, -1)</span>
</pre></div>
</div>
</div>
<div class="section" id="lacos-funcoes-enunciados-de-controle-e-comparacoes">
<h2>Laços, Funções, Enunciados de Controle e Comparações<a class="headerlink" href="#lacos-funcoes-enunciados-de-controle-e-comparacoes" title="Link permanente para este título">¶</a></h2>
<p>Nós já vimos alguns exemplos de alguns usos comuns de laços (loops)
<tt class="docutils literal"><span class="pre">for</span></tt>. Em Python, um laço <tt class="docutils literal"><span class="pre">for</span></tt> possui uma estrutura tabulada, tal
como</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">5</span><span class="p">):</span>
<span class="go"> print(i)</span>
<span class="go">0</span>
<span class="go">1</span>
<span class="go">2</span>
<span class="go">3</span>
<span class="go">4</span>
</pre></div>
</div>
<p>Note que os dois pontos no final do enunciado (não existe “do” ou “od”
como no GAP ou Maple), e a identação antes dos comandos dentro do
laço, isto é, <tt class="docutils literal"><span class="pre">print(i)</span></tt>. A tabulação é importante. No Sage, a
tabulação é automaticamente adicionada quando você digita <tt class="docutils literal"><span class="pre">enter</span></tt>
após ”:”, como ilustrado abaixo.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: for i in range(5):</span>
<span class="gp">... </span> <span class="k">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="c"># now hit enter twice</span>
<span class="go">0</span>
<span class="go">1</span>
<span class="go">2</span>
<span class="go">3</span>
<span class="go">4</span>
</pre></div>
</div>
<p>O símbolo <tt class="docutils literal"><span class="pre">=</span></tt> é usado para atribuição.
O símbolo <tt class="docutils literal"><span class="pre">==</span></tt> é usado para verificar igualdade:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: for i in range(15):</span>
<span class="gp">... </span> <span class="k">if</span> <span class="n">gcd</span><span class="p">(</span><span class="n">i</span><span class="p">,</span><span class="mi">15</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="gp">... </span> <span class="k">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="go">1</span>
<span class="go">2</span>
<span class="go">4</span>
<span class="go">7</span>
<span class="go">8</span>
<span class="go">11</span>
<span class="go">13</span>
<span class="go">14</span>
</pre></div>
</div>
<p>Tenha em mente como a tabulação determina a estrutura de blocos para
enunciados <tt class="docutils literal"><span class="pre">if</span></tt>, <tt class="docutils literal"><span class="pre">for</span></tt>, e <tt class="docutils literal"><span class="pre">while</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: def legendre(a,p):</span>
<span class="gp">... </span> <span class="n">is_sqr_modp</span><span class="o">=-</span><span class="mi">1</span>
<span class="gp">... </span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">p</span><span class="p">):</span>
<span class="gp">... </span> <span class="k">if</span> <span class="n">a</span> <span class="o">%</span> <span class="n">p</span> <span class="o">==</span> <span class="n">i</span><span class="o">^</span><span class="mi">2</span> <span class="o">%</span> <span class="n">p</span><span class="p">:</span>
<span class="gp">... </span> <span class="n">is_sqr_modp</span><span class="o">=</span><span class="mi">1</span>
<span class="gp">... </span> <span class="k">return</span> <span class="n">is_sqr_modp</span>
<span class="go">sage: legendre(2,7)</span>
<span class="go">1</span>
<span class="go">sage: legendre(3,7)</span>
<span class="go">-1</span>
</pre></div>
</div>
<p>Obviamente essa não é uma implementação eficiente do símbolo de
Legendre! O objetivo é ilustrar vários aspectos da programação em
Python/Sage. A função {kronecker}, que já vem com o Sage, calcula o
símbolo de Legendre eficientemente usando uma biblioteca em C do PARI.</p>
<p>Finalmente, observamos que comparações, tais como <tt class="docutils literal"><span class="pre">==</span></tt>, <tt class="docutils literal"><span class="pre">!=</span></tt>,
<tt class="docutils literal"><span class="pre"><=</span></tt>, <tt class="docutils literal"><span class="pre">>=</span></tt>, <tt class="docutils literal"><span class="pre">></span></tt>, <tt class="docutils literal"><span class="pre"><</span></tt>, entre números irão automaticamente
converter ambos os números para o mesmo tipo, se possível:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: 2 < 3.1; 3.1 <= 1</span>
<span class="go">True</span>
<span class="go">False</span>
<span class="go">sage: 2/3 < 3/2; 3/2 < 3/1</span>
<span class="go">True</span>
<span class="go">True</span>
</pre></div>
</div>
<p>Quase todos pares de objetos podem ser comparados; não se supõe que os
objetos estejam equipados com uma ordem total.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: 2 < CC(3.1,1)</span>
<span class="go">True</span>
<span class="go">sage: 5 < VectorSpace(QQ,3) # output can be somewhat random</span>
<span class="go">True</span>
</pre></div>
</div>
<p>Use bool para desigualdades simbólicas:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: x < x + 1</span>
<span class="go">x < x + 1</span>
<span class="go">sage: bool(x < x + 1)</span>
<span class="go">True</span>
</pre></div>
</div>
<p>Quando se compara objetos de tipos diferentes no Sage, na maior parte
dos casos o Sage tenta encontrar uma coação canônica para ambos os
objetos em um parente comum (veja <a class="reference internal" href="tour_coercion.html#section-coercion"><em>Famílias, Conversão e Coação</em></a> para mais
detalhes). Se isso for bem sucedido, a comparação é realizada entre os
objetos que foram coagidos; se não for bem sucedido, os objetos são
considerados diferentes. Para testar se duas variáveis fazem
referência ao mesmo objeto use <tt class="docutils literal"><span class="pre">is</span></tt>. Como se vê no próximo exemplo,
o int <tt class="docutils literal"><span class="pre">1</span></tt> do Python é único, mas o Inteiro <tt class="docutils literal"><span class="pre">1</span></tt> do Sage não é.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: 1 is 2/2</span>
<span class="go">False</span>
<span class="go">sage: int(1) is int(2)/int(2)</span>
<span class="go">True</span>
<span class="go">sage: 1 is 1</span>
<span class="go">False</span>
<span class="go">sage: 1 == 2/2</span>
<span class="go">True</span>
</pre></div>
</div>
<p>Nas duas linhas seguintes, a primeira igualdade é falsa (<tt class="docutils literal"><span class="pre">False</span></tt>)
porque não existe um morfismo canônico <img class="math" src="_images/math/f9e11f3da55229bf8720bce8e3f18932e20191fc.png" alt="QQ\to \GF{5}"/>, logo
não há uma forma de comparar o <img class="math" src="_images/math/dce34f4dfb2406144304ad0d6106c5382ddd1446.png" alt="1"/> em <img class="math" src="_images/math/a0c8a3534da46e2c30e5fb267dd7afec808bd531.png" alt="\GF{5}"/> com o
<img class="math" src="_images/math/ba8e101dc0e5943893e54746db6f32b4629d4615.png" alt="1 \in \QQ"/>. Em contraste, existe um mapa canônico entre
<img class="math" src="_images/math/b64f4251e07b91d5be522e16faf6c07a69a0af63.png" alt="\ZZ \to \GF{5}"/>, logo a segunda comparação é verdadeira
(<tt class="docutils literal"><span class="pre">True</span></tt>)</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: GF(5)(1) == QQ(1); QQ(1) == GF(5)(1)</span>
<span class="go">False</span>
<span class="go">False</span>
<span class="go">sage: GF(5)(1) == ZZ(1); ZZ(1) == GF(5)(1)</span>
<span class="go">True</span>
<span class="go">True</span>
<span class="go">sage: ZZ(1) == QQ(1)</span>
<span class="go">True</span>
</pre></div>
</div>
<p>ATENÇÃO: Comparação no Sage é mais restritiva do que no Magma, o qual
declara <img class="math" src="_images/math/08ce2169a2f6b9619e29d0023d29e9b0a9a52083.png" alt="1 \in \GF{5}"/> igual a <img class="math" src="_images/math/ba8e101dc0e5943893e54746db6f32b4629d4615.png" alt="1 \in \QQ"/>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: magma('GF(5)!1 eq Rationals()!1') # optional magma required</span>
<span class="go">true</span>
</pre></div>
</div>
</div>
<div class="section" id="otimizacao-profiling">
<h2>Otimização (Profiling)<a class="headerlink" href="#otimizacao-profiling" title="Link permanente para este título">¶</a></h2>
<p>Autor desta seção: Martin Albrecht (<a class="reference external" href="mailto:malb%40informatik.uni-bremen.de">malb<span>@</span>informatik<span>.</span>uni-bremen<span>.</span>de</a>)</p>
<blockquote>
<div>“Premature optimization is the root of all evil.” - Donald Knuth</div></blockquote>
<p>As vezes é útil procurar por gargalos em programas para entender quais
partes gastam maior tempo computacional; isso pode dar uma boa ideia
sobre quais partes otimizar. Python e portanto Sage fornecem várias
opções de “profiling” (esse é o nome que se dá ao processo de
otimização).</p>
<p>O mais simples de usar é o comando <tt class="docutils literal"><span class="pre">prun</span></tt> na linha de comando
interativa. Ele retorna um sumário sobre o tempo computacional
utilizado por cada função. Para analisar (a atualmente lenta! – na
versão 1.0) multiplicação de matrizes sobre corpos finitos, por
exemplo, faça o seguinte:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: k,a = GF(2**8, 'a').objgen()</span>
<span class="go">sage: A = Matrix(k,10,10,[k.random_element() for _ in range(10*10)])</span>
</pre></div>
</div>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: %prun B = A*A</span>
<span class="go"> 32893 function calls in 1.100 CPU seconds</span>
<span class="go">Ordered by: internal time</span>
<span class="go">ncalls tottime percall cumtime percall filename:lineno(function)</span>
<span class="go"> 12127 0.160 0.000 0.160 0.000 :0(isinstance)</span>
<span class="go"> 2000 0.150 0.000 0.280 0.000 matrix.py:2235(__getitem__)</span>
<span class="go"> 1000 0.120 0.000 0.370 0.000 finite_field_element.py:392(__mul__)</span>
<span class="go"> 1903 0.120 0.000 0.200 0.000 finite_field_element.py:47(__init__)</span>
<span class="go"> 1900 0.090 0.000 0.220 0.000 finite_field_element.py:376(__compat)</span>
<span class="go"> 900 0.080 0.000 0.260 0.000 finite_field_element.py:380(__add__)</span>
<span class="go"> 1 0.070 0.070 1.100 1.100 matrix.py:864(__mul__)</span>
<span class="go"> 2105 0.070 0.000 0.070 0.000 matrix.py:282(ncols)</span>
<span class="go"> ...</span>
</pre></div>
</div>
<p>Aqui <tt class="docutils literal"><span class="pre">ncalls</span></tt> é o números de chamadas, <tt class="docutils literal"><span class="pre">tottime</span></tt> é o tempo total
gasto por uma determinada função (excluíndo o tempo gasto em chamadas
de subfunções), <tt class="docutils literal"><span class="pre">percall</span></tt> é o quociente de <tt class="docutils literal"><span class="pre">tottime</span></tt> dividido por
<tt class="docutils literal"><span class="pre">ncalls</span></tt>. <tt class="docutils literal"><span class="pre">cumtime</span></tt> é o tempo total gasto nessa e em todas as
subfunções (isto é, desde o início até o término da execução da
função), <tt class="docutils literal"><span class="pre">percall</span></tt> é o quociente de <tt class="docutils literal"><span class="pre">cumtime</span></tt> dividido pelas
chamadas primitivas, e <tt class="docutils literal"><span class="pre">filename:lineno(function)</span></tt> fornece os dados
respectivos para cada função. A regra prática aqui é: Quanto mais no
topo uma função aparece nessa lista, mais custo computacional ela
acarreta. Logo é mais interessante para ser optimizada.</p>
<p>Como usual, <tt class="docutils literal"><span class="pre">prun?</span></tt> fornece detalhes sobre como usar o “profiler” e
como entender a saída de dados.</p>
<p>A saída de dados pode ser escrita em um objeto para permitir uma
análise mais detalhada:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: %prun -r A*A</span>
<span class="go">sage: stats = _</span>
<span class="go">sage: stats?</span>
</pre></div>
</div>
<p>Note: digitando <tt class="docutils literal"><span class="pre">stats</span> <span class="pre">=</span> <span class="pre">prun</span> <span class="pre">-r</span> <span class="pre">A\*A</span></tt> obtém-se um erro de sintaxe
porque prun é um comando do IPython, não uma função comum.</p>
<p>Para uma representação gráfica dos dados do “profiling”, você pode
usar o “hotspot profiler”, um pequeno script chamado
<tt class="docutils literal"><span class="pre">hotshot2cachetree</span></tt> e o programa <tt class="docutils literal"><span class="pre">kcachegrind</span></tt> (apenas no Unix). O
mesmo exemplo agora com o “hotspot profiler”:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: k,a = GF(2**8, 'a').objgen()</span>
<span class="go">sage: A = Matrix(k,10,10,[k.random_element() for _ in range(10*10)])</span>
<span class="go">sage: import hotshot</span>
<span class="go">sage: filename = "pythongrind.prof"</span>
<span class="go">sage: prof = hotshot.Profile(filename, lineevents=1)</span>
</pre></div>
</div>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: prof.run("A*A")</span>
<span class="go"><hotshot.Profile instance at 0x414c11ec></span>
<span class="go">sage: prof.close()</span>
</pre></div>
</div>
<p>Isso resulta em um arquivo <tt class="docutils literal"><span class="pre">pythongrind.prof</span></tt> no diretório de
trabalho atual. Ele pode ser convertido para o formato cachegrind para
visualização.</p>
<p>Em uma linha de comando do sistema, digite</p>
<div class="highlight-python"><pre>hotshot2calltree -o cachegrind.out.42 pythongrind.prof</pre>
</div>
<p>O arquivo de saída <tt class="docutils literal"><span class="pre">cachegrind.out.42</span></tt> pode ser examinado com
<tt class="docutils literal"><span class="pre">kcachegrind</span></tt>. Note que a convenção de nomes <tt class="docutils literal"><span class="pre">cachegrind.out.XX</span></tt>
precisa ser obedecida.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Tabela de Conteúdo</a></h3>
<ul>
<li><a class="reference internal" href="#">Programação</a><ul>
<li><a class="reference internal" href="#carregando-e-anexando-arquivos-do-sage">Carregando e Anexando Arquivos do Sage</a></li>
<li><a class="reference internal" href="#criando-codigo-compilado">Criando Código Compilado</a><ul>
<li><a class="reference internal" href="#acessando-funcoes-em-c-em-arquivos-separados">Acessando Funções em C em Arquivos Separados</a></li>
</ul>
</li>
<li><a class="reference internal" href="#scripts-independentes-em-python-sage">Scripts Independentes em Python/Sage</a></li>
<li><a class="reference internal" href="#tipo-de-dados">Tipo de Dados</a></li>
<li><a class="reference internal" href="#listas-tuplas-e-sequencias">Listas, Tuplas e Sequências</a></li>
<li><a class="reference internal" href="#dicionarios">Dicionários</a></li>
<li><a class="reference internal" href="#conjuntos">Conjuntos</a></li>
<li><a class="reference internal" href="#iteradores">Iteradores</a></li>
<li><a class="reference internal" href="#lacos-funcoes-enunciados-de-controle-e-comparacoes">Laços, Funções, Enunciados de Controle e Comparações</a></li>
<li><a class="reference internal" href="#otimizacao-profiling">Otimização (Profiling)</a></li>
</ul>
</li>
</ul>
<h4>Tópico anterior</h4>
<p class="topless"><a href="latex.html"
title="capítulo anterior">Sage, LaTeX e Companheiros</a></p>
<h4>Próximo tópico</h4>
<p class="topless"><a href="sagetex.html"
title="próximo capítulo">Usando o SageTeX</a></p>
<h3>Esta Página</h3>
<ul class="this-page-menu">
<li><a href="_sources/programming.txt"
rel="nofollow">Exibir Fonte</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Pesquisa rápida</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<!-- The shading of the "Go" button should be consistent -->
<!-- with the colour of the header and footer. See the file -->
<!-- doc/common/themes/sage/theme.conf for colours used by -->
<!-- the Sage theme. -->
<input type="submit" style="background-color: #B8B9F6" value="Ir" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Digite os termos da busca ou o nome de um módulo, classe ou função.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navegação</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="Índice Geral"
>índice</a></li>
<li class="right" >
<a href="py-modindex.html" title="Índice de Módulos do Python"
>módulos</a> |</li>
<li class="right" >
<a href="sagetex.html" title="Usando o SageTeX"
>próximo</a> |</li>
<li class="right" >
<a href="latex.html" title="Sage, LaTeX e Companheiros"
>anterior</a> |</li>
<a href="../index.html"><img src="_static/sagelogo.png" style="vertical-align: middle" title="Sage Logo"></a>
<li><a href="index.html">Tutorial Sage v5.9</a> »</li>
</ul>
</div>
<div class="footer">
© Copyright 2005--2011, The Sage Development Team.
Criado com <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
<script type="text/javascript">
/*global jQuery, window */
/* Sphinx sidebar toggle. Putting this code at the end of the body
* enables the toggle for the live, static, and offline docs. Note:
* sage.misc.html.math_parse() eats jQuery's dollar-sign shortcut. */
var jq = jQuery;
jq(document).ready(function () {
var bar, bod, bg, fg, key, tog, wid_old, wid_new, resize, get_state, set_state;
bod = jq('div.bodywrapper');
bar = jq('div.sphinxsidebar');
tog = jq('<div class="sphinxsidebartoggle"></div>');
/* Delayed resize helper. Not perfect but good enough. */
resize = function () {
setTimeout(function () {
tog.height(bod.height());
}, 100);
};
jq(window).resize(function () {
resize();
});
/* Setup and add the toggle. See Sphinx v0.5.1 default.css. */
fg = jq('div.sphinxsidebar p a').css('color') || 'rgb(152, 219, 204)';
bg = jq('div.document').css('background-color') || 'rgb(28, 78, 99)';
wid_old = '230px';
wid_new = '5px';
tog.css('background-color', bg)
.css('border-width', '0px')
.css('border-right', wid_new + ' ridge ' + bg)
.css('cursor', 'pointer')
.css('position', 'absolute')
.css('left', '-' + wid_new)
.css('top', '0px')
.css('width', wid_new);
bod.css('position', 'relative');
bod.prepend(tog);
resize();
/* Cookie helpers. */
key = 'sphinxsidebar=';
set_state = function (s) {
var date = new Date();
/* Expiry in 7 days. */
date.setTime(date.getTime() + (7 * 24 * 3600 * 1000));
document.cookie = key + encodeURIComponent(s) + '; expires=' +
date.toUTCString() + '; path=/';
};
get_state = function () {
var i, c, crumbs = document.cookie.split(';');
for (i = 0; i < crumbs.length; i += 1) {
c = crumbs[i].replace(/^\s+/, '');
if (c.indexOf(key) === 0) {
return decodeURIComponent(c.substring(key.length, c.length));
}
}
return null;
};
/* Event handlers. */
tog.mouseover(function (ev) {
tog.css('border-right-color', fg);
}).mouseout(function (ev) {
tog.css('border-right-color', bg);
}).click(function (ev) {
if (bod.hasClass('wide')) {
bod.removeClass('wide');
bod.css('margin-left', wid_old);
bar.css('width', wid_old);
bar.show();
set_state('visible');
} else {
set_state('hidden');
bar.hide();
bar.css('width', '0px');
bod.css('margin-left', wid_new);
bod.addClass('wide');
}
resize();
});
/* Hide the normally visible sidebar? */
if (get_state() === 'hidden') {
tog.trigger('click');
} else {
set_state('visible');
}
});
</script>
</body>
</html>
