February 29, 2016

Python para iniciantes – Tuplas (Objetos Imutáveis)

Tuplas são estruturas de dados muito parecidas com as listas, mas com algumas diferenças, uma delas e mais importante, é que as tuplas são imutáveis, ou seja, após criadas não podem ter seu estado alterado e qualquer operação feita sobre elas irão gerar um novo objeto, ou seja, uma nova tupla.

Para definir uma tupla utilizamos dois parênteses ( ), ou não, rs, como assim, vamos lá:

>>> t = ('a', 'b') # podemos definir uma tupla desta forma.

>>> t

('a', 'b')

>>> t = 'a', 'b' # desta forma.

>>> t

('a', 'b')

>>> t = tuple(['a', 'b']) # assim, utilizando a função built-in tuple passando uma sequência qualquer.

>>> t

('a', 'b')

>>> t = tuple('abc') # até mesmo assim.

>>> t

('a', 'b', 'c')

Como visto no exemplo acima existem muitas formas de se definir uma tupla, mas uma delas me chama atenção, que é o segundo exemplo, onde definimos a tupla sem parênteses, assim t = ‘a’, ‘b’, porque diferente do que se pensa, não são os parênteses que definem uma tupla, mas as vírgulas, bem interessante isto, portanto o exemplo abaixo também criaria uma tupla.

>>> t = 'a',

>>> t

('a',)

Enquanto este outro exemplo não:

>>> t = ('a')

>>> t

'a' # retornou uma string e não uma tupla

Como encontrar um elemento em uma tupla:

>>> t = ('a', 'b', 'c')

>>> 'b' in t

True # sim, 'b' está na tupla 't'

Fazendo Slicing em uma tupla:

>>> t = ('a', 'b', 'c')

>>> t[1:3] # retorna elementos a partir do índice 1 até o índice 2

('b', 'c')

>>> t[:2] # retorna elementos a partir do índice 0 até o índice 1

('a', 'b')

>>> t[-2:] # retorna elementos a partir do índice -2(penúltimo item) até o fim.

('b', 'c')

Tuplas tem poucos métodos, apenas dois para ser mais exato:

>>> t = ('a', 'b', 'a', 1, 2, len)

>>> t.index('a') # mostra a posição da primeira ocorrência do elemento na lista

0 # o elemento 'a' está primeiramente na posição 0

>>> t.count('a') # quantidade de elementos 'a' na lista

>>> len(t) # len não é uma função da tupla mas sim uma função built-in do python que retorna o tamanho dela e de outras sequências.

Operações com tuplas:

>>> t = ('a', 'b') + ('c',) # somar duas tuplas

>>> t

('a', 'b', 'c')

>>> t += (3,)

('a', 'b', 'c', 3)

>>> t = ('a', 'b')

>>> t * 3 # equiavalente à ('a', 'b') + ('a', 'b') + ('a', 'b')

('a', 'b', 'a', 'b', 'a', 'b')

Por que utilizar tuplas?

Tuplas são mais rápidas que listas. Se você precisa apenas definir um conjunto de valores constantes e depois percorrê-los de alguma forma, então opte por tuplas.

Deixo aqui também um pensamento sobre tuplas e listas:
“Tupla congela uma Lista e Lista descongela uma Tupla.”

Obrigado e até próxima

February 24, 2016

Python para iniciantes – Listas (Objetos mutáveis)

Listas em Python são estrutura de dados que podem armazenar qualquer tipo de valor, inteiros, strings, floats, funções, classes, … e outros tipos.

- Podemos dizer que as Listas são como os arrays de outras linguagens de programação.
- As listas não armazenam realmente os objetos dentro dela, mas sim a referência de memória desses objetos.

Criando uma lista:

>>> l = ['a', 'b', 'c']

>>> l

['a', 'b', 'c']

>>> l[0] # retorna o primeiro item da lista

'a'

>>> l[2] # retorna o terceiro item da lista

'c'

>>> l[-1] # retorna o último elemento de lista, repare que a contagem dos índices de trás para frente inicia em -1

'c'

Como mostrado acima é bem simples criar uma Lista de dados em Python, basta envolver os elementos com colchetes [ ] e separar os elementos por vírgulas.

Fazendo Slicing em uma Lista:

>>> l = ['a', 'b', 'c']

>>> l[1:3] # retorna elementos a partir do índice 1 até o índice 2

['b', 'c']

>>> l[:2] # retorna elementos a partir do índice 0 até o índice 1

['a', 'b']

>>> l[-2:] # retorna elementos a partir do índice -2(penúltimo item) até o fim.

['b', 'c']

Adicionando elementos em uma Lista:

>>> l = ['a', 'b', 'c']

>>> l.append('d')

>>> l

'a', 'b', 'c', 'd'

>>> l.append(['e', 'f'])

>>> l

'a', 'b', 'c', 'd', ['e', 'f'] # repare que foi adicionado uma lista na última posição.

>>> l.extend(['g', 'h'])

>>> l

'a', 'b', 'c', 'd', ['e', 'f'], 'g', 'h' # repare que ao contrário de .append o método .extend decompõe a lista que foi passada como argumento e coloca um item por posição na lista original.

>>> l.insert(1, 'w') # adiciona a string 'w' na posição 1 da lista

>>> l

'a', 'w', 'b', 'c', 'd', ['e', 'f'], 'g', 'h'

Removendo elementos de uma lista:

>>> l = ['a', 'b', 'c', 'a']

>>> l.remove('a')

>>> l

['b', 'c', 'a'] # repare que apenas a primeria ocorrência de 'a' foi removida

>>> l.pop() # remove o último elemento da lista e o retorna.

'a'

>>> l

['b', 'c']

>>> l.remove('a') # repare que não é possível remover um elemento que não existe :)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: list.remove(x): x not in list

Operações em Listas:

>>> l = [1] + [2, 'a'] # somar duas listas, equiavalente à [1].extend([2, 'a'])

>>> l

[1, 2, 'a']

>>> l += [3] # equivalente à l.extend([3])

[1, 2, 'a', 3]

>>> l = ['a', 'b']

>>> l * 3 # equiavalente à ['a', 'b'] + ['a', 'b'] + ['a', 'b']

['a', 'b', 'a', 'b', 'a', 'b']

Porque Lista são objetos mutáveis (muito importante):

Um Objeto mutável é aquele que pode ser alterado após a sua criação, ou seja, podemos alterar o estado do objeto sem termos que criar uma cópia do mesmo. Por exemplo:

>>> l = ['a', 3.14]

>>> id(l) # a função built-in retorna o endereço de memória do objeto.

1234567 # endereço de memória simbóĺico.

>>> l.append('b')

>>> l

['a', 3.14, 'b']

>>> id(l)

1234567 # o endereço de memória não foi alterado, ou seja, é o mesmo objeto ainda.

>>> l.reverse() # inverte a lista

['b', 3.14, 'a']

>>> id(l)

1234567 # de novo o endereço de memória não foi alterado.

Repare que as operações na lista acima afetaram sempre o mesmo objeto, sem criar outros.

Referências em Listas:

>>> l = ['a', 'b']

>>> w = l

>>> w, l

(['a', 'b'], ['a', 'b'])

>>> id(l), id(w)

(1234567, 1234567) # repare que o endereço de memória é o mesmo para 'l' e 'w'

>>> w.append('c')

>>> w, l

(['a', 'b', 'c'], ['a', 'b', 'c']) # importante: 'l' também foi alterado, pois 'l' e 'w' apontam para o mesmo endereço de memória.

>>> id(l), id(w)

(1234567, 1234567) # mesmo endereço de memória

O exemplo acima, mostra que em Python atribuições a partir de Listas geram referências, por isso a variável “L” e “w” apontam para o mesmo endereço de memória.

Se tudo é referência então como criar uma cópia de uma Lista?

>>> l = ['a', 'b']

>>> w = l[:] # cria uma cópia de 'l'

id(l), id(w)

(1234567, 9876543)

Observe que endereço de memória não é mais o mesmo, ou seja, temos duas variáveis, cada uma apontando para seu endereço de memória.

Até o próximo post

February 22, 2016

Python para iniciantes – Strings (Objetos Imutáveis)

“Python para Iniciantes”, nesta série de posts vamos abordar um pouco sobre essa linguagem incrível que é o Python e que mudou para melhor meu dia dia como desenvolvedor WEB e também a de milhares de pessoas que querem e precisam entregar projetos de qualidade em prazos relativamente curtos. A intenção dessa aula, é apresentar ao estudante uma visão de como trabalhar como Strings em Python, então vamos lá: Tudo em Python é objeto, inclusive as strings:

>>> my_first_string = "Olá, eu sou uma string"

>>> type(my_first_string)

str

No exemplo acima o tipo da variável my_first_string é str, que é o tipo que representa strings em Python. Em Python Strings são imutáveis. O que é isso? Objetos imutáveis são aqueles que não podem ser alterados, ou seja, esses mantém seu estado após criados e quando existe a necessidade de serem alterados eles se multiplicam, vamos a um expemplo:

>>> va = "meninO"

>>> vb = va

>>> va[5] = "A"

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'str' object does not support item assignment

No exemplo acima não foi possível atribuir o valor “A” na sexta posição da string “menino“, pois como o erro lançado nos diz: “O tipo string não suporta atribuição de item”, portanto não é possível alterar apenas uma posição da variável “va“. Para tal precisariamos atribuir novamente o valor da variável va:

>>> va = "meninO"

>>> vb = va

>>> id(va), id(vb) # id() -> função built-in que retorna a identidade de um objeto

123456, 123456 # os números aqui são apenas ilustrativos, mas eles sempre serão iguais neste momento

# pois apontam para o mesmo endereço de memória neste instante.

>>> print (va, vb)

meninO meninO # repare que o valor de va e vb são iguais

>>> va = "meninA" # neste momento um novo objeto é criado

>>> id(va), id(vb)

345434, 123456 # repare que o endereço de memória de 'va' foi alterado, o que significa que foi criada uma nova variável.

>>> print(va, vb)

meninA meninO # repare que apenas o valor de 'va' mudou, enquanto o valor de 'vb' continuou o mesmo.

>>> vc = va.capitalize()

>>> print(va, vc)

meninA Menina # 'va' não mudou mas 'vc' ganhou um M maiúsculo

Resumindo: qualquer operação em uma string, sempre gera um novo objeto e isso também vale para os tipos int, float, long, complex, tuple … Tendo em mente que uma nova string será gerada a cada operação, devemos tomar cuidado com coisas assim:

1	>>> va = "muitas" + "strings" + "para" + "concatenar"

Pois dessa forma o Python vai concatenar as strings assim (((“muitas” + “strings”) + “para”) + “concatenar”), de duas em duas, gerando mais processamento. Portanto o jeito pythonico de se fazer é utilizando o método join(), que concatena tudo de uma única vez, assim:

1	>>> ''.join(["muitas", "strings", "para", "concatenar"])

Como retornar o tamanho de uma string?

É bem tranquilo, basta utilizar a função built-in len().

>>> my_string = "qual meu tamanho"

>>> len(my_string)

>>> nome.__len__() # a função len() busca pela implementação __len__() do objeto

Como retornar uma parte da string (substring) em Python?

1	>>> nome = "abcdef"

A sintaxe para retornar o pedaço de uma string é nome[START:END:STEP]
Mas antes de começar vamos entender a diferença entre Python índices(index) e slices.
Índices(index) enumeram os elementos enquando slices enumeram os espaços entre os elementos. A imagem abaixo pode explicar melhor:

Na sintaxe nome[START:END]
START reflete as duas primeiras linhas da imagem acima, que equivale a posição real, iniciando em zero da esquerda para direita e em -1 da direita para a esquerda. Portanto falamos que o índice START é fechado.
END reflete as duas últimas linhas da imagem acima, que equivale a (posição desejada - 1) e por isso falamos que o índice END é aberto.

Por índice:
nome[index] # caracter que está na posição index, que equivale à nome.__getitem__(index)

Por slicing:
nome[start:end] # caracteres que comecem da posição start até end-1
nome[start:] # caracteres que comecem da posição start e vão até o fim
nome[:end] # caracteres que comecem da posição 0(do início) até end-1
nome[:] # caracteres que comecem da posição 0 até o fim. Faz uma cópia da string

Indices negativos também são permitos

Por índice:
nome[-1] # caracteres começam de trás para frente, onde -1 é o último item da string.

Por slicing:
nome[-2:] # caracteres que comecem do penúltimo até o fim da string
nome[:-2] # pega todos os caracteres menos os dois últimos.

Temos também os passos (steps)

a[start:end:step] # caracteres que comecem da posição start até end-1, onde step é um valor numérico e inteiro que indica o passo, por exemplo:
nome[:5:2] # caracteres que comecem da posição 0 até 5-1, pulando de 2 em 2

>>> nome = "abcdef"

>>> nome[2] # retorna 'c', equivale à nome.__getitem__(2)

>>> nome[1:5] # retorna 'bcde' equivale à nome.__getitem__(slice(1, 5))

>>> nome[1:] # retorna 'bcdef'

>>> nome[:3] # retorna 'abc'

>>> nome[:] # retorna 'abcdef'

>>> nome[-1] # retorna 'f'

>>> nome[-2:] # retorna 'ef'

>>> nome[:-2] # retorna 'abcd'

>>> nome[:5:2] # retorna 'ace' equivale à nome.__getitem__(slice(0, 5, 2))

>>> nome[::-1] # retorna 'fedcba'. Obs: inverte a string

Alguns métodos interessantes do objeto String:

>>> va = "teste métodos"

>>> va.split() # retorna uma lista

['teste', 'métodos']

>>> a.capitalize() # retorna o primeiro caracter com letra maiúscula

Teste métodos

>>> a.title() # retorna os primeiros caracteres de cada palavra com letra maiúscula

Teste Métodos

>>> a.upper() # retorna todos os caracteres com letra maiúscula

TESTE MÉTODOS

>>> a.count("e") # retorna a quantidade de caracteres encontrados

>>> va = "dia: {0} mes: {1} ano: {2}".format(10, 8, 2014) # injetar outras strings

'dia: 10 mes: 8 ano: 2014'

>>> va = "dia: {} mes: {} ano: {}".format(10, 8, 2014) # em Python 3 não precisamos passar os índices

'dia: 10 mes: 8 ano: 2014'

Obrigado e até a próximo post

February 11, 2016

Diferenças entre o Python 2 e o Python 3

Em breve, mais cedo ou mais tarde, teremos que migrar uma aplicação feita em Python 2.x para Python 3, não tem jeito é o nosso destino e porque migrar?

Como está escrito na wiki oficial do Python:
Python 2.7 é legado e o Python 3 é o presente e o futuro da linguagem.

Python 3 foi lançado em 2008, já a versão final do Python 2, a versão 2.7, saiu por volta de 2010, mas já com a decisão que a família 2.x não teria grandes releases. E desde então a versão 3.x vem sendo melhorada e conta com versões estáveis desde então, como por exemplo as versões 3.3 em 2012, 3.4 em 2014 e 3.5 em 2015.

Uma das primeiras mudanças que vemos no Python 3 é na função print, que agora realmente é uma função:

Python 2:

1	>>> print "o valor eh: ", 2*15 # o valor eh: 30

Python 3:

1	>>> print ("o valor eh: ", 2*15) # o valor eh: 30

Podemos também usar alguns argumentos novos na função print como por exemplo o end e o sep:

>>> print ("o valor eh", 2*15, sep=": ")

o valor eh: 30

>>> print ("o valor eh", 2*15, sep=": ", end="!\n") # o \n garante uma nova linha

o valor eh: 30!

Divisão entre números inteiros mudou um pouco:

No Python 2.x a divisão entre 3 / 2 sempre retorna 1, mas no Python 3 o resultado é 1,5 (que bom né, rs), porque agora a divisão não depende mais do tipo do denominador e do numerador.

Se for necessário utilizar o comportamento antigo utilize duas barras, assim: 3 // 2

True e False agora são palavras reservadas:

No Python 2 podiamos fazer algumas coisas estranhas como:

>>> True = "Ai, ai, ai"

>>> False = "Ai, ai, ai"

>>> True == False

True # -> viiixi

No Python 3 finalmente isso não é mais possível:

>>> True = "Ai, ai, ai"

File "<ipython-input-47-7885763f8a8f>", line 1

True = "Ai, ai, ai"

SyntaxError: can't assign to keyword

Raising exceptions:

No Python 2.x podiamos usar a velha e nova sintaxe. No Python 3 podemos usar apenas a nova:
Python 2:

>>> raise IOError, "file error" # -> velha sintaxe

---------------------------------------------------------------------------

IOError Traceback (most recent call last)

in ()

----> 1 raise IOError, "file error"

IOError: file error

>>> raise IOError("file error") # -> nova sintaxe

# mesmo error de cima

Python 3:
Só assim:

1	>>> raise IOError("file error")

Manipulando exceções:

No Python 3 temos que usar obrigatoriamente a palavra chave “as”
Python 2:

>>> try:

forçar um erro aqui

exception ErrorName, err:

print err

Python 3:

>>> try:

forçar um erro aqui

exception ErrorName as err:

print (err)

Unpacking avançado:

Agora podemos fazer coisas do tipo:

>>> a, *resto, b = range(10) # colocar o meio da sequência na variável resto

>>> a, resto, b

(0, [1, 2, 3, 4, 5, 6, 7, 8], 9)

>>> a, b, *resto = ["x", "p", "t", "o"]

>>> a

"x"

>>> resto

['t', 'o']

>>> b

"p"

“keyword-only” arguments:

1 2	>>> def fn(a, b, option=True): >>> ....

Com a função acima em mente vamos imaginar que você precisa que o parâmetro option seja usado da forma como está no contrato da função, ou seja, deve ser passado como no exemplo abaixo:

>>> fn(1, 2, option=False)
e nunca
>>> fn(1, 2, 3) # -> desse modo, o parâmetro option teria o valor 3 e não é o que queremos.

Felizmente no Python 3 isso é possivel, basta adicionar o argumento de quantidade indefinida de parâmetros posicionais, aqui representado por *args, como no exemplo abaixo:

1 2	>>> def fn(a, b, *args, option=True): >>> ....

E assim dessa forma podemos chamar a função fn desse jeito:
>>> fn(1, 2, 3): # -> o parâmetro de valor 3 foi enviado para o argumento *args.
E o parâmetro option continua com o valor True.

Poderiamos utilizar dessa forma, que também funcionaria:
>>> fn(1, 2, 3, 4, option=False) # -> os parâmetro 3 e 4 foram enviados para o argumento *args.

Tudo agora é iterator

Se você fizer no Python 2.x:

>>> def my_sum(n):

ret = 0

for i in range(n+1):

ret += i

return ret

>>> my_sun(100000000)

Tem grandes chances do seu computador travar, bem travado. Por que? Porque a função range() tenta alocar neste caso um espaço na memória com 100000000 posições, detonando a memória da máquina. Já no Python 3 isso não acontece porque a função range() retorna uma espécie de iterator que vai liberando a memória a cada loop.
Com isso a função xrange() do Python 2.x foi eleminada sem dó, pois o range() agora faz o papel que ela fazia.
Por isso em Python 3, range, zip, map, list, etc, são todos iterators.
Se você precisa de uma lista basta fazer isto: list(range(10))

Comparar tudo com tudo, não pode mais:

Python 2:

>>> '3' > 2

True

>>> 'dois' > 1 # essa foi fo@$%!

True

No Python 3 isso não pode mais, melhor assim né:

>>> '3' > 2

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: unorderable types: str() > int()

O método .next() dos iterators foi para o /dev/null

No Python 2.x podemos utilizar a função built-in next() e também o método .next() de um iterator. Já no Python 3 isso mudou, ficamos apenas com a função next().
Python 2:

>>> my_generator = (letter for letter in 'abcdefg')

>>> my_generator.next()

>>> next(my_generator )

Python 3:

>>> my_generator = (letter for letter in 'abcdefg')

>>> my_generator.next()

---------------------------------------------------------------------------

AttributeError Traceback (most recent call last)

<ipython-input-36-125f388bb61b> in <module>()

----> 1 my_generator.next()

AttributeError: 'generator' object has no attribute 'next'

>>> next(my_generator )

O método has_key(), aquele dos dicionários, não existe mais:

Em Python 2, poderia ser feito:

>>> d = {"a": 1, "b": 2}

>>> d.has_key("a")

>>> True

No Python 3, temos que usar o operado in:

1 2	>>> "a" in d >>> True

Variáveis de controle em List comprehensions não mais afetam o escopo a sua volta:

Python 2:

>>> i = 1

>>> print 'before: i =', i

>>> print 'comprehension: ', [i for i in range(5)]

>>> print 'after: i =', i

before: i = 1

comprehension: [0, 1, 2, 3, 4]

after: i = 4 # repare aqui o valor 4. O valor de i após o loop

Python 3:

>>> i = 1

>>> print('before: i =', i)

>>> print('comprehension:', [i for i in range(5)])

>>> print('after: i =', i)

before: i = 1

comprehension: [0, 1, 2, 3, 4]

after: i = 1 # repare aqui o valor 1, o mesmo antes de rodar o loop

Finalmente o tipo enumerado faz parte da biblioteca padrão do Python:

No Python 3.4, agora temos:

>>> from enum import Enum

>>> class Animal(Enum):

DOG = 1

CAT = 2

>>> Animal.DOG

<Animal.DOG: 1>

>>> Animal.DOG.value

O raw_input não existe mais:

No Python 2.x temos o raw_input e o input para fazer a leitura dos dados do teclado. O raw_input lê strings em geral e o input lê apenas números.
No python 3 existe apenas o input que lê tudo como strings, então se você precisa de uma entrada numérica basta converter assim:

>>> dia = int(input('Digite o dia do seu nascimento:'))

>>> Digite o dia do seu nascimento:

>>> type(dia)

>>> <class 'int'>

Nome de variáveis unicode:

>>> évariavel = “será que funciona”

>>> évariavel

“será que funciona” # -> funciona

>>> import math

>>> π = math.pi

>>> π

3.141592653589793

Valeuuuu,

Referências que usei para criar este post:
https://docs.python.org/3/whatsnew/3.0.html
https://asmeurer.github.io/python3-presentation/slides.html#1
https://pythonhelp.wordpress.com/2013/09/01/o-que-mudou-no-python-3/
http://sebastianraschka.com/Articles/2014_python_2_3_key_diff.html#future_module

February 8, 2016

Utilizando Pyenv e Pyenv-virtualenv e aposentando o virtualenv “ou não”.

Utilizei por muito tempo o virtualenv para criar ambientes python isolados e assim com tranquilidade, instalar pacotes python a vontade sem ter que me preocupar com versões e compatibilidades entre os pacotes, porque estes estariam sempre isolados no seu ambiente virtual. Isso é legal, muito legal, mas agora além de me preocupar com os pacotes instalados, também tive a necessidade de escolher a versão do python que eu queria usar no meu ambiente virtual. E isso o virtualenv não resolve por completo. Por exemplo:

Quero criar um ambiente virtual com a versão do Python 2.7.6 e um outro com a versão 3.5.1. E ai, como faço? É ai que entra o pyenv + pyenv-virtualenv, pois com o pyenv conseguimos instalar facilmente versões diferentes do python na mesma máquina e alternar entre elas apenas com um simples comando. Já o pyenv-virtualenv é um plugin do pyenv que nos permite criar ambientes isolados escolhendo a versão do Python antes de criá-los.Chique né e como começar?

Primeiro vamos instalar algumas dependências:

1	$ sudo apt-get install -y make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev git

Agora vamos instalar o pyenv, com o comando abaixo (Ps: este é o comando que encontrei no site oficial, ver aqui):

1	$ sudo curl -L https://raw.githubusercontent.com/yyuu/pyenv-installer/master/bin/pyenv-installer \| bash

Após finalizado a instalação, adicione as linhas abaixo ao seu .bashrc:

$ echo 'export PATH="$HOME/.pyenv/bin:$PATH"' >> ~/.bashrc

$ echo 'eval "$(pyenv init -)"' >> ~/.bashrc

$ echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.bashrc

E para surtir efeito as linhas adicionadas acima, rode:

1	$ source ~/.bashrc

Com isso o pyenv está instalado e se digitarmos pyenv na console veremos:

$ pyenv

pyenv 20160202-2-gf2f703d

Usage: pyenv <command> [<args>]

Some useful pyenv commands are:

commands List all available pyenv commands

local Set or show the local application-specific Python version

global Set or show the global Python version

shell Set or show the shell-specific Python version

install Install a Python version using python-build

uninstall Uninstall a specific Python version

rehash Rehash pyenv shims (run this after installing executables)

version Show the current Python version and its origin

versions List all Python versions available to pyenv

which Display the full path to an executable

whence List all Python versions that contain the given executable

See `pyenv help <command>' for information on a specific command.

For full documentation, see: https://github.com/yyuu/pyenv#readme

Agora podemos listar as versões do python instaladas, digitando:

$ pyenv versions

* system (set by /home/mateus/.pyenv/version)

Para listar as versões python disponíveis:

1	$ pyenv install -l

E assim podemos escolher qual versão do python instalar, vou escolher a 3.5.1

1	$ pyenv install 3.5.1

agora digite novamente:

$ pyenv versions

* system (set by /home/mateus/.pyenv/version)

3.5.1

e você verá que existem duas versões instaladas. E para escolher a versão 3.5.1, basta digitar:

1	$ pyenv global 3.5.1

agora digite python na console e você verá que a versão global do python no sistema é a 3.5.1:

$ python

Python 3.5.1 (default, Feb 7 2016, 18:12:41)

[GCC 4.8.4] on linux

Type "help", "copyright", "credits" or "license" for more information.

>>> import sys

>>> sys.path

['', '/home/mateus/.pyenv/versions/3.5.1/lib/python35.zip', '/home/mateus/.pyenv/versions/3.5.1/lib/python3.5', '/home/mateus/.pyenv/versions/3.5.1/lib/python3.5/plat-linux', '/home/mateus/.pyenv/versions/3.5.1/lib/python3.5/lib-dynload', '/home/mateus/.pyenv/versions/3.5.1/lib/python3.5/site-packages']

>>>

Até aqui tudo ok e legal, mas precisamos criar ainda nosso virtual environment, para isso vamos instalar o plugin pyenv-virtualenv:

1	$ git clone https://github.com/yyuu/pyenv-virtualenv.git ~/.pyenv/plugins/pyenv-virtualenv

Caso você receba a mensagem:

1	fatal: destination path '/home/mateus/.pyenv/plugins/pyenv-virtualenv' already exists and is not an empty directory.

É porque pyenv-virtualenv foi instalado logo lá no começo junto com a instalação do pyenv.

Enfim vamos criar nosso primeiro virtualenv:

1	$ pyenv virtualenv system my_venv_2.7.x

ative-o digitando:

1	$ pyenv activate my_venv_2.7.x

agora digite python e você verá que a versão usada para criar o virtualenv foi a padrão que veio instalada no sistema antes mesmo de você instalar o pyenv. No meu caso foi a 2.7.6

Para criar com outra versão do python, basta digitar por exemplo:

1	$ pyenv vistualenv 3.5.1 my_env_3.5.1

Agora podemos criar ambientes virtuais isolados como o virtualenv fazia mas com uma vantagem, ainda podemos escolher qual versão do python usar, legal né.

Quanto ao título deste post [ Utilizando Pyenv e Pyenv-virtualenv e aposentando o virtualenv "ou não". ], ficou escrito desta forma porque estudando o pyenv e o “original” virtualenv (aquele de raiz), descobri que também é posível escolher a versão do python ao se criar um ambiente virtual com o nosso velho amigo “virtualenv”, desta forma:

1	$ virtualenv -p $(which python) my_venv_de_raiz

Aqui criamos um ambiente virtual a moda antiga, mas com a versão atual do python que foi setada pelo comando pyenv global. Bem interessante também.

Ficamos por aqui, abraços e até o próximo post.