11.10. "shutil" --- Operações de arquivo de alto nível
******************************************************

**Código Fonte:** Lib/shutil.py

======================================================================

O módulo "shutil" oferece várias operações de alto nível em arquivos e
coleções de arquivos. Em particular, são fornecidas funções que
possuem suporte a cópia e remoção de arquivos. Para operações em
arquivos individuais, veja também o módulo "os".

Aviso:

  Mesmo as funções de cópia de arquivos de nível superior
  ("shutil.copy()", "shutil.copy2()") não podem copiar todos os
  metadados do arquivo.Nas plataformas POSIX, isso significa que o
  proprietário e o grupo do arquivo são perdidos, bem como as ACLs. No
  Mac OS, a bifurcação de recursos e outros metadados não são usados.
  Isso significa que os recursos serão perdidos e o tipo de arquivo e
  os códigos do criador não estarão corretos. No Windows, os
  proprietários de arquivos, ACLs e fluxos de dados alternativos não
  são copiados.


11.10.1. Operações de diretório e arquivos
==========================================

shutil.copyfileobj(fsrc, fdst[, length])

   Copia o conteúdo do objeto do tipo arquivo *fsrc* para o objeto do
   tipo arquivo *fdst*. O número inteiro *length*, se fornecido, é o
   tamanho do buffer. Em particular, um valor negativo *length*
   significa copiar os dados sem repetir os dados de origem em
   pedaços; por padrão, os dados são lidos em pedaços para evitar o
   consumo descontrolado de memória. Observe que, se a posição atual
   do arquivo do objeto *fsrc* não for 0, apenas o conteúdo da posição
   atual do arquivo até o final do arquivo será copiado.

shutil.copyfile(src, dst, *, follow_symlinks=True)

   Copy the contents (no metadata) of the file named *src* to a file
   named *dst* and return *dst*.  *src* and *dst* are path names given
   as strings. *dst* must be the complete target file name; look at
   "shutil.copy()" for a copy that accepts a target directory path.
   If *src* and *dst* specify the same file, "SameFileError" is
   raised.

   O local de destino deve ser gravável; caso contrário, uma exceção
   "OSError" será gerada. Se o *dst* já existir, ele será substituído.
   Arquivos especiais como dispositivos de caractere ou bloco e
   tubulações não podem ser copiados com esta função.

   Se *follow_symlinks* for falso e *src* for um link simbólico, um
   novo link simbólico será criado em vez de copiar o arquivo *src*
   para o qual o arquivo aponta.

   Alterado na versão 3.3: "IOError" costumava ser gerada em vez de
   "OSError". Adicionado argumento *follow_symlinks*. Agora retorna
   *dst*.

   Alterado na versão 3.4: Levanta "SameFileError" em vez de "Error".
   Como a primeira é uma subclasse da última, essa alteração é
   compatível com versões anteriores.

exception shutil.SameFileError

   Essa exceção é gerada se a origem e o destino em "copyfile()" forem
   o mesmo arquivo.

   Novo na versão 3.4.

shutil.copymode(src, dst, *, follow_symlinks=True)

   Copy the permission bits from *src* to *dst*.  The file contents,
   owner, and group are unaffected.  *src* and *dst* are path names
   given as strings. If *follow_symlinks* is false, and both *src* and
   *dst* are symbolic links, "copymode()" will attempt to modify the
   mode of *dst* itself (rather than the file it points to).  This
   functionality is not available on every platform; please see
   "copystat()" for more information.  If "copymode()" cannot modify
   symbolic links on the local platform, and it is asked to do so, it
   will do nothing and return.

   Alterado na versão 3.3: Adicionado argumento *follow_symlinks*.

shutil.copystat(src, dst, *, follow_symlinks=True)

   Copy the permission bits, last access time, last modification time,
   and flags from *src* to *dst*.  On Linux, "copystat()" also copies
   the "extended attributes" where possible.  The file contents,
   owner, and group are unaffected.  *src* and *dst* are path names
   given as strings.

   Se *follow_symlinks* for falso e *src* e *dst* se referirem a links
   simbólicos, "copystat()" operará nos próprios links simbólicos, e
   não nos arquivos aos quais os links simbólicos se referem - lendo
   as informações do link simbólico *src* e gravando as informações no
   link simbólico *dst*.

   Nota:

     Nem todas as plataformas oferecem a capacidade de examinar e
     modificar links simbólicos. O próprio Python pode dizer qual
     funcionalidade está disponível localmente.

     * Se "os.chmod in os.supports_follow_symlinks" for "True",
       "copystat()" pode modificar os bits de permissão de um link
       simbólico.

     * Se "os.utime in os.supports_follow_symlinks" for "True",
       "copystat()" pode modificar as horas da última modificação e do
       último acesso de um link simbólico.

     * Se "os.chflags in os.supports_follow_symlinks" for "True",
       "copystat()" pode modificar os sinalizadores de um link
       simbólico.  ("os.chflags" não está disponível em todas as
       plataformas.)

     Nas plataformas em que algumas ou todas essas funcionalidades não
     estão disponíveis, quando solicitado a modificar um link
     simbólico, "copystat()" copiará tudo o que puder. "copystat()"
     nunca retorna falha.Por favor, veja "os.supports_follow_symlinks"
     para mais informações.

   Alterado na versão 3.3: Adicionado argumento *follow_symlinks* e
   suporte a atributos estendidos do Linux.

shutil.copy(src, dst, *, follow_symlinks=True)

   Copia o arquivo *src* ao arquivo ou diretório *dst*. *src* e *dst*
   devem ser strings. Se *dst* especificar um diretório, o arquivo
   será copiado para *dst* usando o nome do arquivo base de *src*.
   Retorna o caminho para o arquivo recém-criado.

   Se *follow_symlinks* for falso e *src* for um link simbólico, *dst*
   será criado como um link simbólico. Se *follow_symlinks* for
   verdadeiro e *src* for um link simbólico, *dst* será uma cópia do
   arquivo ao qual *src* se refere.

   "copy()" copia os dados do arquivo e o modo de permissão do arquivo
   (consulte "os.chmod()"). Outros metadados, como os tempos de
   criação e modificação do arquivo, não são preservados. Para
   preservar todos os metadados do arquivo do original, use "copy2()".

   Alterado na versão 3.3: Adicionado argumento *follow_symlinks*.
   Agora retorna o caminho para o arquivo recém-criado.

shutil.copy2(src, dst, *, follow_symlinks=True)

   Idêntico a "copy()", exceto que "copy2()" também tenta preservar os
   metadados do arquivo.

   When *follow_symlinks* is false, and *src* is a symbolic link,
   "copy2()" attempts to copy all metadata from the *src* symbolic
   link to the newly-created *dst* symbolic link. However, this
   functionality is not available on all platforms. On platforms where
   some or all of this functionality is unavailable, "copy2()" will
   preserve all the metadata it can; "copy2()" never returns failure.

   "copy2()" usa "copystat()" para copiar os metadados do arquivo. Por
   favor, veja "copystat()" para obter mais informações sobre o
   suporte da plataforma para modificar os metadados do link
   simbólico.

   Alterado na versão 3.3: Adicionado argumento *follow_symlinks*,
   tenta copiar também atributos estendidos do sistema de arquivos
   (atualmente apenas no Linux). Agora retorna o caminho para o
   arquivo recém-criado.

shutil.ignore_patterns(*patterns)

   Esta função de fábrica cria uma função que pode ser usada como um
   chamável para o argumento *ignore* de "copytree()", ignorando
   arquivos e diretórios que correspondem a um dos *patterns* de
   estilo glob fornecidos. Veja o exemplo abaixo.

shutil.copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False)

   Recursively copy an entire directory tree rooted at *src*,
   returning the destination directory.  The destination directory,
   named by *dst*, must not already exist; it will be created as well
   as missing parent directories.  Permissions and times of
   directories are copied with "copystat()", individual files are
   copied using "shutil.copy2()".

   Se *symlinks* for verdadeiro, os links simbólicos na árvore de
   origem são representados como links simbólicos na nova árvore e os
   metadados dos links originais serão copiados na medida do permitido
   pela plataforma; se falso ou omitido, o conteúdo e os metadados dos
   arquivos vinculados são copiados para a nova árvore.

   Quando *symlinks* for falso, se o arquivo apontado pelo link
   simbólico não existir, uma exceção será adicionada na lista de
   erros gerados em uma exceção "Error" no final do processo de cópia.
   Você pode definir o sinalizador opcional *ignore_dangling_symlinks*
   como true se desejar silenciar esta exceção. Observe que esta opção
   não tem efeito em plataformas que não possuem suporte a
   "os.symlink()".

   Se *ignore* for fornecido, deve ser um chamável que receberá como
   argumento o diretório que está sendo visitado por "copytree()", e
   uma lista de seu conteúdo, retornada por "os.listdir()". Como
   "copytree()" é chamada recursivamente, o chamável *ignore* será
   chamado uma vez para cada diretório que é copiado. O chamável deve
   retornar uma sequência de nomes de diretório e arquivo em relação
   ao diretório atual (ou seja, um subconjunto dos itens em seu
   segundo argumento); esses nomes serão ignorados no processo de
   cópia. "ignore_patterns()" pode ser usado para criar um chamável
   que ignore nomes com base em padrões de estilo glob.

   Se uma ou mais exceções ocorrerem, uma "Error" é levantada com uma
   lista dos motivos.

   If *copy_function* is given, it must be a callable that will be
   used to copy each file. It will be called with the source path and
   the destination path as arguments. By default, "shutil.copy2()" is
   used, but any function that supports the same signature (like
   "shutil.copy()") can be used.

   Alterado na versão 3.3: Copia metadados quando *symlinks* for
   falso. Agora, retorna *dst*.

   Alterado na versão 3.2: Adicionado o argumento *copy_function* para
   poder fornecer uma função de cópia personalizada. Adicionado o
   argumento *ignore_dangling_symlinks* para erros silenciosos de
   links simbólicos quando *symlinks* for falso.

shutil.rmtree(path, ignore_errors=False, onerror=None)

   Exclui uma árvore de diretório inteira; *path* deve apontar para um
   diretório (mas não um link simbólico para um diretório). Se
   *ignore_errors* for verdadeiro, os erros resultantes de remoções
   com falha serão ignorados; se falso ou omitido, tais erros são
   tratados chamando um manipulador especificado por *onerror* ou, se
   for omitido, eles levantam uma exceção.

   Nota:

     Em plataformas que suportam as funções baseadas em descritores de
     arquivo necessárias, uma versão resistente a ataques de links
     simbólicos de "rmtree()" é usada por padrão. Em outras
     plataformas, a implementação "rmtree()" é suscetível a um ataque
     de link simbólico: dados o tempo e as circunstâncias apropriados,
     os invasores podem manipular links simbólicos no sistema de
     arquivos para excluir arquivos que eles não seriam capazes de
     acessar de outra forma. Os aplicativos podem usar o atributo de
     função "rmtree.avoids_symlink_attacks" para determinar qual caso
     se aplica.

   Se *onerror* for fornecido, deve ser um chamável que aceite três
   parâmetros: *function*, *path*, e *excinfo*.

   O primeiro parâmetro, *function*, é a função que levantou a
   exceção; depende da plataforma e da implementação. O segundo
   parâmetro, *path*, será o nome do caminho passado para a *função*.
   O terceiro parâmetro, *excinfo*, será a informação de exceção
   retornada por "sys.exc_info()". As exceções levantadas por
   *onerror* não serão detectadas.

   Alterado na versão 3.3: Adicionada uma versão resistente a ataques
   de link simbólico que é usada automaticamente se a plataforma
   suportar funções baseadas em descritor de arquivo.

   rmtree.avoids_symlink_attacks

      Indica se a plataforma e implementação atuais fornecem uma
      versão resistente a ataques de link simbólico de "rmtree()".
      Atualmente, isso só é verdade para plataformas que suportam
      funções de acesso ao diretório baseadas em descritor de arquivo.

      Novo na versão 3.3.

shutil.move(src, dst, copy_function=copy2)

   Move recursivamente um arquivo ou diretório (*src*) para outro
   local (*dst*) e retorna ao destino.

   Se o destino for um diretório existente, *src* será movido para
   dentro desse diretório. Se o destino já existe, mas não é um
   diretório, ele pode ser sobrescrito dependendo da semântica
   "os.rename()".

   Se o destino está no sistema de arquivos atual, então "os.rename()"
   é usado. Caso contrário, *src* é copiado para *dst* usando
   *copy_function* e depois removido. No caso de links simbólicos, um
   novo link simbólico apontando para o destino de *src* será criado
   em ou conforme *dst* e *src* serão removidos.

   If *copy_function* is given, it must be a callable that takes two
   arguments *src* and *dst*, and will be used to copy *src* to *dest*
   if "os.rename()" cannot be used.  If the source is a directory,
   "copytree()" is called, passing it the "copy_function()". The
   default *copy_function* is "copy2()".  Using "copy()" as the
   *copy_function* allows the move to succeed when it is not possible
   to also copy the metadata, at the expense of not copying any of the
   metadata.

   Alterado na versão 3.3: Adicionada manipulação de links simbólicos
   explícitos para sistemas de arquivos externos, adaptando-os ao
   comportamento do GNU **mv**. Agora retorna *dst*.

   Alterado na versão 3.5: Adicionado o argumento nomeado
   *copy_function*.

shutil.disk_usage(path)

   Return disk usage statistics about the given path as a *named
   tuple* with the attributes *total*, *used* and *free*, which are
   the amount of total, used and free space, in bytes.  On Windows,
   *path* must be a directory; on Unix, it can be a file or directory.

   Novo na versão 3.3.

   Disponibilidade: Unix, Windows.

shutil.chown(path, user=None, group=None)

   Altera o proprietário *usuário* e/ou *group* do *path* fornecido.

   *user* pode ser um nome de usuário do sistema ou um uid; o mesmo se
   aplica ao *group*. É necessário pelo menos um argumento.

   Veja também "os.chown()", a função subjacente.

   Disponibilidade: Unix.

   Novo na versão 3.3.

shutil.which(cmd, mode=os.F_OK | os.X_OK, path=None)

   Retorna o caminho para um executável que seria executado se o *cmd*
   fornecido fosse chamado. Se nenhum *cmd* for chamado, retorna
   "None".

   *mode* é uma máscara de permissão passada para "os.access()", por
   padrão determinando se o arquivo existe e é executável.

   Quando nenhum *path* é especificado, os resultados de
   "os.environ()" são usados, retornando o valor de "PATH" ou uma
   alternativa de "os.defpath".

   No Windows, o diretório atual é sempre anexado ao *path*,
   independentemente de você usar o padrão ou fornecer o seu próprio,
   que é o comportamento que o shell de comando usa ao localizar
   executáveis. Além disso, ao encontrar o *cmd* no *path*, a variável
   de ambiente "PATHEXT" é verificada. Por exemplo, se você chamar
   "shutil.which("python")", "which()" irá pesquisar "PATHEXT" para
   saber que deve procurar por "python.exe" dentro dos diretórios de
   *path*. Por exemplo, no Windows:

      >>> shutil.which("python")
      'C:\\Python33\\python.EXE'

   Novo na versão 3.3.

exception shutil.Error

   Esta exceção coleta exceções que são levantadas durante uma
   operação de vários arquivos. Para "copytree()", o argumento de
   exceção é uma lista de tuplas de 3 elementos (*srcname*, *dstname*,
   *exception*).


11.10.1.1. Exemplo de copytree
------------------------------

Este exemplo é a implementação da função "copytree()", descrita acima,
com a docstring omitida. Ele demonstra muitas das outras funções
fornecidas por este módulo.

   def copytree(src, dst, symlinks=False):
       names = os.listdir(src)
       os.makedirs(dst)
       errors = []
       for name in names:
           srcname = os.path.join(src, name)
           dstname = os.path.join(dst, name)
           try:
               if symlinks and os.path.islink(srcname):
                   linkto = os.readlink(srcname)
                   os.symlink(linkto, dstname)
               elif os.path.isdir(srcname):
                   copytree(srcname, dstname, symlinks)
               else:
                   copy2(srcname, dstname)
               # XXX What about devices, sockets etc.?
           except OSError as why:
               errors.append((srcname, dstname, str(why)))
           # catch the Error from the recursive copytree so that we can
           # continue with other files
           except Error as err:
               errors.extend(err.args[0])
       try:
           copystat(src, dst)
       except OSError as why:
           # can't copy file access times on Windows
           if why.winerror is None:
               errors.extend((src, dst, str(why)))
       if errors:
           raise Error(errors)

Outro exemplo que usa o auxiliar "ignore_patterns()":

   from shutil import copytree, ignore_patterns

   copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))

Isso irá copiar tudo, exceto os arquivos ".pyc" e arquivos ou
diretórios cujo nome começa com "tmp".

Outro exemplo que usa o argumento *ignore* para adicionar uma chamada
de registro:

   from shutil import copytree
   import logging

   def _logpath(path, names):
       logging.info('Working in %s', path)
       return []   # nothing will be ignored

   copytree(source, destination, ignore=_logpath)


11.10.1.2. exemplo rmtree
-------------------------

Este exemplo mostra como remover uma árvore de diretório no Windows
onde alguns dos arquivos têm seu conjunto de bits somente leitura. Ele
usa a função de retorno onerror para limpar o bit somente leitura e
tentar remover novamente. Qualquer falha subsequente se propagará.

   import os, stat
   import shutil

   def remove_readonly(func, path, _):
       "Clear the readonly bit and reattempt the removal"
       os.chmod(path, stat.S_IWRITE)
       func(path)

   shutil.rmtree(directory, onerror=remove_readonly)


11.10.2. Operações de arquivamento
==================================

Novo na versão 3.2.

Alterado na versão 3.5: Adicionado suporte ao formato *xztar*.

Utilitários de alto nível para criar e ler arquivos compactados e
arquivados também são fornecidos. Eles contam com os módulos "zipfile"
e "tarfile".

shutil.make_archive(base_name, format[, root_dir[, base_dir[, verbose[, dry_run[, owner[, group[, logger]]]]]]])

   Cria um arquivo compactado (como zip ou tar) e retorna seu nome.

   *base_name* é o nome do arquivo a ser criado, incluindo o caminho,
   menos qualquer extensão específica de formato. *format* é o formato
   do arquivo: um de "zip" (se o módulo "zlib" estiver disponível),
   "tar", "gztar" (se o módulo "zlib" estiver disponível), "bztar" (se
   o módulo "bz2" estiver disponível) ou "xztar" (se o módulo "lzma"
   estiver disponível).

   *root_dir* is a directory that will be the root directory of the
   archive; for example, we typically chdir into *root_dir* before
   creating the archive.

   *base_dir* is the directory where we start archiving from; i.e.
   *base_dir* will be the common prefix of all files and directories
   in the archive.

   *root_dir* e *base_dir* têm com padrão o diretório atual.

   Se *dry_run* for verdadeiro, nenhum arquivo é criado, mas as
   operações que seriam executadas são registradas no *logger*.

   *owner* e *group* são usados ao criar um arquivo tar. Por padrão,
   usa o proprietário e grupo atuais.

   *logger* deve ser um objeto compatível com a **PEP 282**,
   geralmente uma instância de "logging.Logger".

   O argumento *verbose* não é usado e foi descontinuado.

shutil.get_archive_formats()

   Retorna uma lista de formatos suportados para arquivamento. Cada
   elemento da sequência retornada é uma tupla "(nome, descrição)".

   Por padrão, :mod:>>`<<shutil`fornece estes formatos:

   * *zip*: arquivo ZIP (se o módulo "zlib" estiver disponível).

   * *tar*: arquivo tar não comprimido.

   * *gztar*: arquivo tar compactado com gzip (se o módulo "zlib"
     estiver disponível).

   * *bztar*: arquivo tar compactado com bzip2 (se o módulo "bz2"
     estiver disponível).

   * *xztar*: Arquivo tar compactado com xz (se o módulo "lzma"
     estiver disponível).

   Você pode registrar novos formatos ou fornecer seu próprio
   arquivador para quaisquer formatos existentes, usando
   "register_archive_format()".

shutil.register_archive_format(name, function[, extra_args[, description]])

   Registra um arquivador para o formato *name*.

   *function* é o chamável que será usado para descompactar arquivos.
   O chamável receberá o *base_name* do arquivo a ser criado, seguido
   pelo *base_dir* (cujo padrão é "os.curdir") para iniciar o
   arquivamento. Outros argumentos são passados ​​como argumentos
   nomeados *owner*, *group*, *dry_run* e *logger* (como passado em
   "make_archive()").

   Se fornecido, *extra_args* é uma sequência de pares "(nome, valor)"
   que serão usados ​​como argumentos nomeados extras quando o
   arquivador chamável for usado.

   *description* é usado por "get_archive_formats()" que retorna a
   lista de arquivadores. O padrão é uma string vazia.

shutil.unregister_archive_format(name)

   Remove o formato de arquivo *name* da lista de formatos suportados.

shutil.unpack_archive(filename[, extract_dir[, format]])

   Descompacta um arquivo. *filename* é o caminho completo do arquivo.

   *extract_dir* é o nome do diretório de destino onde o arquivo é
   descompactado. Se não for fornecido, o diretório de trabalho atual
   será usado.

   *format* é o formato do arquivo: um de "zip", "tar", "gztar",
   "bztar" ou "xztar". Ou qualquer outro formato registrado com
   "register_unpack_format()". Se não for fornecido,
   "unpack_archive()" irá usar a extensão do nome do arquivo e ver se
   um descompactador foi registrado para essa extensão. Caso nenhum
   seja encontrado, uma "ValueError" é levantada.

shutil.register_unpack_format(name, extensions, function[, extra_args[, description]])

   Registra um formato de descompactação. *name* é o nome do formato e
   *extensions* é uma lista de extensões correspondentes ao formato,
   como ".zip" para arquivos Zip.

   *function* é o chamável que será usado para descompactar arquivos.
   O chamável receberá o caminho do arquivo, seguido pelo diretório
   para o qual o arquivo deve ser extraído.

   Quando fornecido, *extra_args* é uma sequência de tuplas "(nome,
   valor)" que serão passados ​​como argumentos nomeados para o
   chamável.

   *description* pode ser fornecido para descrever o formato e será
   devolvido pela função "get_unpack_formats()".

shutil.unregister_unpack_format(name)

   Cancela o registro de um formato de descompactação. *name* é o nome
   do formato.

shutil.get_unpack_formats()

   Retorna uma lista de todos os formatos registrados para
   desempacotamento. Cada elemento da sequência retornada é uma tupla
   "(name, extensions, description)".

   Por padrão, :mod:>>`<<shutil`fornece estes formatos:

   * *zip*: arquivo ZIP (descompactar arquivos compactados funciona
     apenas se o módulo correspondente estiver disponível).

   * *tar*: arquivo tar não comprimido.

   * *gztar*: arquivo tar compactado com gzip (se o módulo "zlib"
     estiver disponível).

   * *bztar*: arquivo tar compactado com bzip2 (se o módulo "bz2"
     estiver disponível).

   * *xztar*: Arquivo tar compactado com xz (se o módulo "lzma"
     estiver disponível).

   Você pode registrar novos formatos ou fornecer seu próprio
   desempacotador para quaisquer formatos existentes, usando
   "register_unpack_format()".


11.10.2.1. Exemplo de arquivo
-----------------------------

Neste exemplo, criamos um arquivo tar compactado com gzip contendo
todos os arquivos encontrados no diretório ".ssh" do usuário:

   >>> from shutil import make_archive
   >>> import os
   >>> archive_name = os.path.expanduser(os.path.join('~', 'myarchive'))
   >>> root_dir = os.path.expanduser(os.path.join('~', '.ssh'))
   >>> make_archive(archive_name, 'gztar', root_dir)
   '/Users/tarek/myarchive.tar.gz'

O arquivo resultante contém:

   $ tar -tzvf /Users/tarek/myarchive.tar.gz
   drwx------ tarek/staff       0 2010-02-01 16:23:40 ./
   -rw-r--r-- tarek/staff     609 2008-06-09 13:26:54 ./authorized_keys
   -rwxr-xr-x tarek/staff      65 2008-06-09 13:26:54 ./config
   -rwx------ tarek/staff     668 2008-06-09 13:26:54 ./id_dsa
   -rwxr-xr-x tarek/staff     609 2008-06-09 13:26:54 ./id_dsa.pub
   -rw------- tarek/staff    1675 2008-06-09 13:26:54 ./id_rsa
   -rw-r--r-- tarek/staff     397 2008-06-09 13:26:54 ./id_rsa.pub
   -rw-r--r-- tarek/staff   37192 2010-02-06 18:23:10 ./known_hosts


11.10.3. Consultando o tamanho do terminal de saída
===================================================

shutil.get_terminal_size(fallback=(columns, lines))

   Obtém o tamanho da janela do terminal.

   Para cada uma das duas dimensões, a variável de ambiente, "COLUMNS"
   e "LINES" respectivamente, é verificada. Se a variável estiver
   definida e o valor for um número inteiro positivo, ela será usada.

   Quando "COLUMNS" ou "LINES" não está definida, que é o caso comum,
   o terminal conectado a "sys.__stdout__" é consultado invocando
   "os.get_terminal_size()".

   Se o tamanho do terminal não pode ser consultado com sucesso, ou
   porque o sistema não tem suporte a consultas, ou porque não estamos
   conectados a um terminal, o valor dado no parâmetro "fallback" é
   usado. O padrão de "fallback" é "(80, 24)", que é o tamanho padrão
   usado por muitos emuladores de terminal.

   O valor retornado é uma tupla nomeada do tipo "os.terminal_size".

   Veja também: The Single UNIX Specification, Versão 2, Other
   Environment Variables.

   Novo na versão 3.3.
