16.1. "os" --- Diversas interfaces de sistema operacional
*********************************************************

**Código fonte:** Lib/os.py

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

Este módulo fornece uma maneira simples de usar funcionalidades que
são dependentes de sistema operacional. Se desejar ler ou escrever um
arquivo, veja "open()"; se o que quer é  manipular estruturas de
diretórios, veja o módulo "os.path"; e se quiser ler todas as linhas,
de todos os arquivos, na linha de comando, veja o módulo "fileinput".
Para criar arquivos e diretórios temporários, veja o módulo
"tempfile"; e, para manipulação em alto nível de arquivos e
diretórios, veja o módulo "shutil".

Notas sobre a disponibilidade dessas funções:

* O modelo dos módulos dependentes do sistema operacional embutidos no
  Python é tal que, desde que a mesma funcionalidade esteja
  disponível, a mesma interface é usada; por exemplo, a função
  "os.stat(path)" retorna informações estatísticas sobre *path* no
  mesmo formato (que é originado com a interface POSIX).

* Extensões específicas a um sistema operacional também estão
  disponíveis através do módulo: mod:*os*, mas usá-las é,
  naturalmente, uma ameaça à portabilidade.

* Todas as funções que aceitam nomes de caminhos ou arquivos, aceitam
  objetos bytes e string, e resultam em um objeto do mesmo tipo, se um
  caminho ou nome de arquivo for retornado.

* Uma nota "Disponibilidade: Unix" significa que essa função é
  comumente encontrada em sistemas Unix. Não faz nenhuma reivindicação
  sobre sua existência em um sistema operacional específico.

* <br>

Nota:

  Todas as funções nesse módulo levantam a exceção "OSError", no caso
  de nomes e caminhos de arquivos inválidos ou inacessíveis, ou no
  caso de outros argumentos que possuem o tipo correto, mas não são
  aceitos pelo sistema operacional.

exception os.error

   Um apelido para a exceção embutida "OSError".

os.name

   O nome do módulo importado, dependente do sistema operacional.
   Atualmente, os seguintes nomes foram registrados:  "'posix'",
   "'nt'", "'java'".

   Ver também:

     "sys.platform" tem uma granularidade mais fina.  "os.uname()"
     fornece informação de versões dependentes do sistema.

     O módulo "platform" fornece verificações detalhadas sobre a
     identificação do sistema.


16.1.1. Nomes de arquivos, argumentos de linha de comando e variáveis de ambiente
=================================================================================

Em Python, nomes de arquivos, argumentos de linha de comando e
variáveis de ambiente são representados usando o tipo string. Em
alguns sistemas, é necessária a decodificação dessas seqüências de
caracteres, de e para bytes, antes de transmiti-las ao sistema
operacional. O Python usa a codificação do sistema de arquivos para
realizar essa conversão (consulte  "sys.getfilesystemencoding()").

Alterado na versão 3.1: Em alguns sistemas a conversão, usando a
codificação do sistema de arquivos, pode falhar. Neste caso, o Python
usa o surrogateescape encoding error handler,  o que significa que
bytes não decodificados são substituídos por um caractere Unicode
U+DCxx na decodificação, e estes são novamente traduzidos para o byte
original na codificação.

A codificação do sistema de arquivos deve garantir a decodificação
bem-sucedida de todos os bytes abaixo de 128. Se a codificação do
sistema de arquivos não fornecer essa garantia, as funções da API
poderão gerar UnicodeErrors.


16.1.2. Parâmetros de Processo
==============================

Essas funções e itens de dados fornecem informações e operam no
processo e usuário atuais.

os.ctermid()

   Retorna o nome do arquivo correspondente ao terminal de controle do
   processo.

   Disponibilidade: Unix.

os.environ

   Um objeto *mapping* representando uma string do ambiente. Por
   exemplo, "environ['HOME']" é o nome do caminho do seu diretório
   pessoal (em algumas plataformas), e é equivalente a
   "getenv("HOME")" em C.

   Este mapeamento é capturado na primeira vez que o módulo "os" é
   importado, normalmente durante a inicialização do Python, como
   parte do processamento do arquivo "site.py".  Mudanças no ambiente
   feitas após esse momento não são refletidas em "os.environ", exceto
   pelas mudanças feitas modificando "os.environ" diretamente.

   Se a plataforma suportar a função "putenv()", esse mapeamento pode
   ser usado para modificar o ambiente, além de consultá-lo.
   "putenv()" será chamado automaticamente quando o mapeamento for
   modificado.

   No Unix, chaves e valores usam "sys.getfilesystemencoding()" e o
   manipulador de erros  "'surrogateescape'". Use "environb" se quiser
   usar uma codificação diferente.

   Nota:

     Chamar a função "putenv()" diretamente não muda "os.environ", por
     isso é melhor modificar "os.environ".

   Nota:

     Em algumas plataformas, incluindo FreeBSD e Mac OS X, a
     modificação de "environ" pode causar vazamentos de memória.
     Consulte a documentação do sistema para "putenv()".

   Se a função "putenv()" não for fornecida, uma cópia modificada
   desse mapeamento pode ser passada para as funções apropriadas de
   criação de processos, para fazer com que os processos filhos usem
   um ambiente modificado.

   Se a plataforma suportar a função "unsetenv()", os itens nesse
   mapeamento poderão ser excluídos para remover variáveis de
   ambiente. "unsetenv()" será chamado automaticamente quando um item
   é excluído de "os.environ", e quando um dos métodos "pop()" ou
   "clear()"  é chamado.

os.environb

   Versão bytes "environ":  um objeto *mapping* representando o
   ambiente como byte strings. "environ" e "environb" são
   sincronizados (modificar "environb" atualiza "environ", e vice
   versa).

   "environb" só está disponível se "supports_bytes_environ" for True.

   Novo na versão 3.2.

os.chdir(path)
os.fchdir(fd)
os.getcwd()

   Essas funções são descritas em: Arquivos e Diretórios.

os.fsencode(filename)

   Codifica *filename* como *path-like*  para a codificação do sistema
   de arquivos com o manipulador de erros "'surrogateescape'", ou
   "'strict'" no Windows; retorna "bytes" inalterado.

   "fsdecode()" é a função reversa.

   Novo na versão 3.2.

   Alterado na versão 3.6: Suporte adicionado para aceitar objetos que
   implementam a interface "os.PathLike"

os.fsdecode(filename)

   Decodifica *filename* como *path-like*  da codificação do sistema
   de arquivos com o manipulador de erros "'surrogateescape'", ou
   "'strict'" no Windows; retorna "str" inalterada.

   "fsencode()" é a função reversa.

   Novo na versão 3.2.

   Alterado na versão 3.6: Suporte adicionado para aceitar objetos que
   implementam a interface "os.PathLike"

os.fspath(path)

   Retorna a representação do sistema de arquivos do caminho.

   Se "str" ou "bytes" é passado, é retornado inalterado. Caso
   contrário o método  "__fspath__()" é chamado, e seu valor é
   retornado, desde que seja um objeto "str" ou "bytes". Em todos os
   outros casos, a exceção "TypeError" é gerada.

   Novo na versão 3.6.

class os.PathLike

   Uma classe base abstrata *abstract base class* para objetos
   representando um caminho do sistema de arquivos, por exemplo
   "pathlib.PurePath".

   Novo na versão 3.6.

   abstractmethod __fspath__()

      Retorna a representação do caminho do sistema de arquivos do
      objeto.

      O método deverá retornar somente objetos "str" ou "bytes",
      preferencialmente "str".

os.getenv(key, default=None)

   Retorna o valor da variável de ambiente *key* se existir, ou
   *default*, se não. *key*, *default* e o resultado são str.

   No Unix, chaves e valores são decodificados com a função
   "sys.getfilesystemencoding()" e o o manipulador de erros
   "'surrogateescape'". Use "os.getenvb()" se quiser usar uma
   codificação diferente.

   Disponibilidade: a maioria dos sabores de Unix, Windows.

os.getenvb(key, default=None)

   Retorna o valor da variável de ambiente *key*, se existir, ou
   *default*, se não existir. *key*, *default* e o resultado são
   bytes.

   "getenvb()" só estará disponível se "supports_bytes_environ" for
   True.

   Disponibilidade: maioria das distribuições Unix.

   Novo na versão 3.2.

os.get_exec_path(env=None)

   Retorna a lista de diretórios que serão buscados por um executável
   nomeado, semelhante a um shell, ao iniciar um processo. *env*,
   quando especificado, deve ser um dicionário de variáveis de
   ambiente para procurar o PATH. Por padrão, quando *env* é "None",
   "environ" é usado.

   Novo na versão 3.2.

os.getegid()

   Retorna o efetivo ID do grupo do processo atual. Isso corresponde
   ao bit "set id" no arquivo que está sendo executado no processo
   atual.

   Disponibilidade: Unix.

os.geteuid()

   Retorna o efetivo ID de usuário do processo atual.

   Disponibilidade: Unix.

os.getgid()

   Retorna o ID real do grupo do processo atual.

   Disponibilidade: Unix.

os.getgrouplist(user, group)

   Retornar lista de IDs de grupos aos quais *user* pertence. Se
   *group* não estiver na lista, será incluído; normalmente, *group* é
   especificado como o campo de ID do grupo, a partir do registro de
   senha para *user*.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.getgroups()

   Retorna a lista de IDs de grupos suplementares associados ao
   processo atual.

   Disponibilidade: Unix.

   Nota:

     No Mac OS X, o comportamento da função "getgroups()" difere um
     pouco de outras plataformas Unix. Se o interpretador Python foi
     compilado para distribuição na versão "10.5" ou anterior,
     "getgroups()" retorna a lista de ids de grupos efetivos,
     associados ao processo de usuário atual; esta lista é limitada a
     um número de entradas definido pelo sistema, tipicamente 16, e
     pode ser modificada por chamadas para "setgroups()" se tiver o
     privilégio adequado. Se foi compilado para distribuição na versão
     maior que "10.5", "getgroups()" retorna a lista de acesso de
     grupo atual para o usuário associado ao id de usuário efetivo do
     processo; a lista de acesso de grupo pode mudar durante a vida
     útil do processo, e ela não é afetada por chamadas para
     "setgroups()", e seu comprimento não é limitado a 16. O valor da
     constante  "MACOSX_DEPLOYMENT_TARGET", pode ser obtido com
     "sysconfig.get_config_var()".

os.getlogin()

   Retorna o nome do usuário conectado no terminal de controle do
   processo. Para a maioria dos propósitos, é mais útil usar
   "getpass.getuser()", já que esse último verifica as variáveis de
   ambiente "LOGNAME" ou "USERNAME" para descobrir quem é o usuário, e
   retorna para "pwd.getpwuid(os.getuid())[0]" para obter o nome de
   login do ID do usuário real atual.

   Disponibilidade: Unix, Windows.

os.getpgid(pid)

   Retorna o ID do grupo de processo com *pid*. Se *pid* for 0, o ID
   do grupo do processo atual é retornado.

   Disponibilidade: Unix.

os.getpgrp()

   Retorna o ID do grupo de processo atual.

   Disponibilidade: Unix.

os.getpid()

   Retorna o id do processo atual.

os.getppid()

   Retorna o ID do processo pai. Quando o processo pai é encerrado, no
   Unix, o ID retornado é o do processo init(1); no Windows, ainda é o
   mesmo ID, que já pode ser reutilizado por outro processo.

   Disponibilidade: Unix, Windows.

   Alterado na versão 3.2: Adicionado suporte para Windows.

os.getpriority(which, who)

   Obtém prioridade de agendamento de programa. O valor *which* é um
   entre "PRIO_PROCESS", "PRIO_PGRP" ou "PRIO_USER", e *who* é
   interpretado em relação a *which* (um identificador de processo
   para "PRIO_PROCESS", identificador do grupo de processos para
   "PRIO_PGRP" e um ID de usuário para "PRIO_USER"). Um valor zero
   para *who* indica (respectivamente) o processo de chamada, o grupo
   de processos do processo de chamada ou o ID do usuário real do
   processo de chamada.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.PRIO_PROCESS
os.PRIO_PGRP
os.PRIO_USER

   Parâmetros para as funções "getpriority()" e "setpriority()".

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.getresuid()

   Retorna uma tupla (ruid, euid, suid) indicando os IDs de usuário
   reais, efetivos e salvos do processo atual.

   Disponibilidade: Unix.

   Novo na versão 3.2.

os.getresgid()

   Retorna uma tupla (rgid, egid, sgid) indicando os IDs de grupo
   reais, efetivos e salvos do processo atual.

   Disponibilidade: Unix.

   Novo na versão 3.2.

os.getuid()

   Retorna o ID de usuário real do processo atual.

   Disponibilidade: Unix.

os.initgroups(username, gid)

   Chama o initgroups() do sistema para inicializar a lista de acesso
   ao grupo com todos os grupos dos quais o nome de usuário
   especificado é membro, mais o ID do grupo especificado.

   Disponibilidade: Unix.

   Novo na versão 3.2.

os.putenv(key, value)

   Define a variável de ambiente denominada *key* como a string
   *value*. Tais mudanças no ambiente afetam os subprocessos iniciados
   com "os.system()", "popen()" ou "fork()" and "execv()".

   Disponibilidade: a maioria dos sabores de Unix, Windows.

   Nota:

     Em algumas plataformas, incluindo FreeBSD e Mac OS X, a
     configuração "environ" pode causar vazamento de memória. Consulte
     a documentação do sistema para putenv.

   Quando há suporte a "putenv()", as atribuições para itens em
   "os.environ" são automaticamente convertidas em chamadas
   correspondentes para "putenv()"; no entanto, chamadas para
   "putenv()" não atualiza "os.environ", então é realmente preferível
   atribuir itens a "os.environ".

os.setegid(egid)

   Define o ID do grupo efetivo do processo atual.

   Disponibilidade: Unix.

os.seteuid(euid)

   Define o ID de usuário efetivo do processo atual.

   Disponibilidade: Unix.

os.setgid(gid)

   Define o ID do grupo do processo atual.

   Disponibilidade: Unix.

os.setgroups(groups)

   Define a lista de IDs de grupo suplementares associados ao processo
   atual como *groups*. *groups* deve ser uma sequência e cada
   elemento deve ser um número inteiro identificando um grupo. Esta
   operação normalmente está disponível apenas para o superusuário.

   Disponibilidade: Unix.

   Nota:

     No Mac OS X, o tamanho de *groups* não pode exceder o número
     máximo definido pelo sistema de IDs de grupo efetivos,
     normalmente 16. Consulte a documentação de "getgroups()" para
     casos em que ele pode não retornar o mesmo conjunto de listas de
     grupos chamando setgroups().

os.setpgrp()

   Executa a chamada de sistema "setpgrp()" ou "setpgrp (0, 0)"
   dependendo da versão implementada (se houver). Veja o manual do
   Unix para a semântica.

   Disponibilidade: Unix.

os.setpgid(pid, pgrp)

   Faz a chamada de sistema "setpgid()" para definir o ID do grupo do
   processo com *pid* para o grupo de processos com o id *pgrp*. Veja
   o manual do Unix para a semântica.

   Disponibilidade: Unix.

os.setpriority(which, who, priority)

   Define a prioridade de agendamento de programa. O valor *which* é
   um entre "PRIO_PROCESS", "PRIO_PGRP" ou "PRIO_USER", e *who* é
   interpretado em relação a *which* (um identificador de processo
   para "PRIO_PROCESS", identificador do grupo de processos para
   "PRIO_PGRP" e um ID de usuário para "PRIO_USER"). Um valor zero
   para *who* indica (respectivamente) o processo de chamada, o grupo
   de processos do processo de chamada ou o ID do usuário real do
   processo de chamada. *priority* é um valor na faixa de -20 a 19. A
   prioridade padrão é 0; prioridades menores resultam em agendamento
   um mais favorável.

   Disponibilidade: Unix

   Novo na versão 3.3.

os.setregid(rgid, egid)

   Define os IDs de grupo real e efetivo do processo atual

   Disponibilidade: Unix.

os.setresgid(rgid, egid, sgid)

   Define os IDs de grupo real, efetivo e salvo do processo atual

   Disponibilidade: Unix.

   Novo na versão 3.2.

os.setresuid(ruid, euid, suid)

   Define os IDs de usuário real, efetivo e salvo do processo atual

   Disponibilidade: Unix.

   Novo na versão 3.2.

os.setreuid(ruid, euid)

   Define os IDs de usuário real e efetivo do processo atual.

   Disponibilidade: Unix.

os.getsid(pid)

   Executa a chamada de sistema "getsid()".  Veja o manual do Unix
   para semântica.

   Disponibilidade: Unix.

os.setsid()

   Executa a chamada de sistema "setsid()". Veja o manual do Unix para
   semântica.

   Disponibilidade: Unix.

os.setuid(uid)

   Define o ID de usuário do processo atual.

   Disponibilidade: Unix.

os.strerror(code)

   Retorna a mensagem de erro correspondente ao código de erro em
   *code*. Nas plataformas em que "strerror()" retorna "NULL" quando
   recebe um número de erro desconhecido, "ValueError" é gerada.

os.supports_bytes_environ

   "True" se o tipo de sistema operacional nativo do ambiente estiver
   em bytes (ex., "False" no Windows).

   Novo na versão 3.2.

os.umask(mask)

   Define o umask numérico atual e retorna o umask anterior.

os.uname()

   Retorna informações identificando o sistema operacional atual. O
   valor retornado é um objeto com cinco atributos.

   * "sysname" - nome do sistema operacional

   * "nodename" - nome da máquina na rede (definido pela
     implementação)

   * "release" - versão do sistema operacional

   * "version" - versão do sistema operacional

   * "machine" - identificador de hardware

   Para compatibilidade com versões anteriores, esse objeto também é
   iterável, comportando-se como uma cinco tupla contendo "sysname",
   "nodename", "release", "version" e "machine" nessa ordem.

   Alguns sistemas truncam "nodename" para 8 caracteres ou para o
   componente principal; uma maneira melhor de obter o nome do host é
   "socket.gethostname()" ou até mesmo
   "socket.gethostbyaddr(socket.gethostname())".

   Disponibilidade: distribuicões recentes de Unix

   Alterado na versão 3.3: Retorna tupla alterada de uma tupla para um
   objeto tipo tupla com atributos nomeados.

os.unsetenv(key)

   Cancela (exclui) a variável de ambiente denominada *key*. Tais
   mudanças no ambiente afetam subprocessos iniciados com
   "os.system()", "popen()" ou "fork()" e "execv()".

   Quando "unsetenv()" é suportado, a exclusão de itens em
   "os.environ" é automaticamente traduzida para uma chamada
   correspondente a "unsetenv()"; no entanto, chamadas a "unsetenv()"
   não atualizam "os.environ", por isso, na verdade é preferível
   excluir itens de "os.environ".

   Disponibilidade: a maioria dos sabores de Unix, Windows.


16.1.3. Criação de Objetos Files
================================

This function creates new *file objects*.  (See also "open()" for
opening file descriptors.)

os.fdopen(fd, *args, **kwargs)

   Retorna um objeto de arquivo aberto conectado ao descritor de
   arquivo *fd*.  Este é um apelido para a função embutida "open()" e
   aceita os mesmos argumentos. A única diferença é que o primeiro
   argumento de "fdopen()" deve ser sempre um inteiro.


16.1.4. Operações dos Descritores de Arquivos
=============================================

Estas funções operam em fluxos de E/S referenciados usando descritores
de arquivos.

Descritores de arquivos são pequenos números inteiros correspondentes
a um arquivo que foi aberto pelo processo atual. Por exemplo, a
entrada padrão geralmente é o descritor de arquivo 0, a saída padrão 1
e erro padrão 2. Outros arquivos abertos por um processo serão então
atribuídos 3, 4, 5, e assim por diante. O nome "descritor de arquivo"
é um pouco enganoso; em plataformas UNIX, sockets e pipes também são
referenciados como descritores de arquivos.

O método "fileno()" pode ser usado para obter o descritor de arquivo
associado a um *file object* quando solicitado. Note-se que usar o
descritor de arquivo diretamente ignorará os métodos do objeto de
arquivo, ignorando aspectos como buffer interno de dados.

os.close(fd)

   Fecha o descritor de arquivo * fd >>*<<.

   Nota:

     Esta função destina-se a E/S de baixo nível e deve ser aplicada a
     um descritor de arquivo retornado por "os.open()" ou "pipe()".
     Para fechar um "objeto arquivo" retornado pela função embutida
     "open()" ou by "popen()" ou "fdopen()", use seu método "close()".

os.closerange(fd_low, fd_high)

   Feche todos os descritores de arquivo de *fd_low* (inclusivo) a
   *fd_high* (exclusivo), ignorando erros. Equivalente a (mas muito
   mais rápido do que):

      for fd in range(fd_low, fd_high):
          try:
              os.close(fd)
          except OSError:
              pass

os.device_encoding(fd)

   Retorna uma string descrevendo a codificação do dispositivo
   associado a *fd* se estiver conectado a um terminal; senão retorna
   "None".

os.dup(fd)

   Retorna uma cópia do descritor de arquivo *fd*. O novo descritor de
   arquivo é non-inheritable.

   No Windows, ao duplicar um fluxo padrão (0: stdin, 1: stdout, 2:
   stderr), o novo descritor de arquivo é inheritable.

   Alterado na versão 3.4: O novo descritor de arquivo agora é não-
   hereditário.

os.dup2(fd, fd2, inheritable=True)

   Duplicate file descriptor *fd* to *fd2*, closing the latter first
   if necessary. The file descriptor *fd2* is inheritable by default,
   or non-inheritable if *inheritable* is "False".

   Alterado na versão 3.4: Adicionar o parâmetro opcional
   *inheritable*.

os.fchmod(fd, mode)

   Altera o modo do arquivo dado por *fd* ao *mode* numérico. Veja a
   documentação de "chmod()" para valores possíveis de *mode*.  A
   partir do Python 3.3, isto é equivalente a "os.chmod(fd, mode)".

   Disponibilidade: Unix.

os.fchown(fd, uid, gid)

   Altera o o ID do proprietário e do grupo do arquivo dado por *fd*
   para o *uid* e *gid* numérico. Para deixar um dos ids inalteradas,
   defina-o como -1. Veja "chown()".  A partir do Python 3.3, isto é
   equivalente a "os.chown(fd, uid, gid)".

   Disponibilidade: Unix.

os.fdatasync(fd)

   Força de gravação de arquivo com descritor de arquivo *fd* no
   disco. Não força a atualização de metadados.

   Disponibilidade: Unix.

   Nota:

     Esta função não está disponível no MacOS.

os.fpathconf(fd, name)

   Retorna informações de configuração de sistema relevantes para um
   arquivo aberto. *name* especifica o valor de configuração para
   recuperar; pode ser uma string que é o nome de um valor do sistema
   definido; estes nomes são especificados em uma série de padrões
   (POSIX.1, Unix 95, Unix 98 e outros). Algumas plataformas definem
   nomes adicionais também. Os nomes conhecidos do sistema operacional
   hospedeiro são dadas no dicionário "pathconf_names". Para variáveis
   ​​de configuração não incluídas neste mapeamento, também é aceito
   passar um número inteiro para *name*.

   Se *name* for uma string e não for conhecida, "ValueError" é
   gerado. Se um valor específico para *name* não for compatível com o
   sistema de host, mesmo que seja incluído no "pathconf_names", um
   erro "OSError" é gerado com "errno.EINVAL" como número do erro.

   Assim como no Python 3.3, é equivalente a "os.pathconf(fd, name)".

   Disponibilidade: Unix.

os.fstat(fd)

   Captura o status do descritor de arquivo *fd*. Retorna um objeto
   "stat_result".

   Assim como no Python 3.3, é equivalente a "os.stat(fd)".

   Ver também: A função "stat()".

os.fstatvfs(fd)

   Retorna informações sobre o sistema de arquivos que contém o
   arquivo associado com descritor de arquivo *fd*, como "statvfs()".
   A partir do Python 3.3, isso equivale a "os.statvfs(fd)".

   Disponibilidade: Unix.

os.fsync(fd)

   Gravação à força no disco de arquivo com descritor de arquivo *fd*.
   No Unix, isto chama a função nativa "fsync()"; no Windows, a função
   de MS "_commit()".

   Se você estiver começando com buffer no Python *file object* *f*,
   primeiro use "f.flush()", e depois use "os.fsync(f.fileno())", para
   garantir que todos os buffers internos associados com *f* sejam
   gravados no disco.

   Disponibilidade: Unix, Windows.

os.ftruncate(fd, length)

   Trunca o arquivo correspondente ao descritor de arquivo *fd*, de
   modo que tenha no máximo *length* bytes de tamanho. A partir do
   Python 3.3, isto é equivalente a "os.truncate(fd, length)".

   Disponibilidade: Unix, Windows.

   Alterado na versão 3.5: Adicionado suporte para o Windows.

os.get_blocking(fd)

   Obtém o modo de bloqueio do descritor de arquivo: "False" se o flag
   "O_NONBLOCK" estiver marcado, "True" se o flag estiver desmarcado.

   Veja também "set_blocking()" e "socket.socket.setblocking()".

   Disponibilidade: Unix.

   Novo na versão 3.5.

os.isatty(fd)

   Retorna "True" se o descritor de arquivo *fd* estiver aberto e
   conectado a um dispositivo do tipo tty, senão "False".

os.lockf(fd, cmd, len)

   Aplica, testa ou remove um bloqueio POSIX em um descritor de
   arquivo aberto. *fd* é um descritor de arquivo aberto. *cmd*
   especifica o comando a ser usado - um dentre  "F_LOCK", "F_TLOCK",
   "F_ULOCK" ou "F_TEST". *len* especifica a seção do arquivo a ser
   bloqueada.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.F_LOCK
os.F_TLOCK
os.F_ULOCK
os.F_TEST

   Flags que especificam qual ação "lockf()" vai realizar.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.lseek(fd, pos, how)

   Define a posição atual do descritor de arquivo *fd* para a posição
   *pos*, modificada por *how*: "SEEK_SET" ou "0" para definir a
   posição em relação ao início do arquivo; "SEEK_CUR" ou "1" para
   defini-la em relação à posição atual; "SEEK_END" ou "2" para
   defini-la em relação ao final do arquivo. Retorna a nova posição do
   cursor em bytes, a partir do início.

os.SEEK_SET
os.SEEK_CUR
os.SEEK_END

   Parâmetros para a function "lseek()". Seus valores são
   respectivamente 0, 1, e 2.

   Novo na versão 3.3: Alguns sistemas operacionais podem suportar
   valores adicionais, como "os.SEEK_HOLE" ou "os.SEEK_DATA".

os.open(path, flags, mode=0o777, *, dir_fd=None)

   Abre o arquivo *path* e define várias flags de acordo com *flags*
   e, possivelmente, seu modo, de acordo com *mode*. Ao computar
   *mode*, o valor atual de umask é iniciar com máscara. Retorna o
   descritor de arquivo para o arquivo recém-aberto. O novo descritor
   de arquivo é non-inheritable.

   Para ler uma descrição dos valores de flags e modos, veja a
   documentação de tempo de execução C; constantes de flag (como
   "O_RDONLY" e "O_WRONLY") são definidas no módulo "os".  Em
   particular, no Windows é necessário adicionar "O_BINARY" para abrir
   arquivos em modo binário.

   Esta função pode suportar paths relative to directory descriptors
   com o parâmetro *dir_fd*.

   Alterado na versão 3.4: O novo descritor de arquivo agora é não-
   hereditário.

   Nota:

     Esta função é destinada a E/S de baixo nível. Para uso normal,
     use a função embutida "open()", que retorna um *file object* com
     os métodos "read()" e "write()" (e muitos mais). Para envolver um
     descritor de arquivo em um objeto de arquivo, use "fdopen()".

   Novo na versão 3.3: O argumento *dir_fd*.

   Alterado na versão 3.5: Se a chamada de sistema é interrompida e o
   tratador de sinal não levanta uma exceção, a função agora tenta
   novamente a chamada de sistema em vez de levantar uma exceção
   "InterruptedError" (consulte **PEP 475** para entender a lógica).

   Alterado na versão 3.6: Aceita um *path-like object*.

As seguintes constantes são opções para o parâmetro *flags* da função
"open()".  Elas podem ser combinadas usando o operador bitwise OR "|".
Algumas delas não estão disponíveis em todas as plataformas. Para
obter descrições de sua disponibilidade e uso, consulte a página do
manual *open(2)* no Unix ou the MSDN no Windows.

os.O_RDONLY
os.O_WRONLY
os.O_RDWR
os.O_APPEND
os.O_CREAT
os.O_EXCL
os.O_TRUNC

   As constantes acima estão disponíveis no Unix e Windows.

os.O_DSYNC
os.O_RSYNC
os.O_SYNC
os.O_NDELAY
os.O_NONBLOCK
os.O_NOCTTY
os.O_CLOEXEC

   As constantes acima estão disponíveis apenas no Unix.

   Alterado na versão 3.3: adiciona a constante "O_CLOEXEC".

os.O_BINARY
os.O_NOINHERIT
os.O_SHORT_LIVED
os.O_TEMPORARY
os.O_RANDOM
os.O_SEQUENTIAL
os.O_TEXT

   As constantes acima estão disponíveis apenas no Windows.

os.O_ASYNC
os.O_DIRECT
os.O_DIRECTORY
os.O_NOFOLLOW
os.O_NOATIME
os.O_PATH
os.O_TMPFILE
os.O_SHLOCK
os.O_EXLOCK

   As constantes acima são extensões e não estarão presentes, se não
   forem definidos pela biblioteca C.

   Alterado na versão 3.4: Adiciona "O_PATH" em sistemas que suportam.
   Adiciona "O_TMPFILE", só está disponível em Linux Kernel 3.11 ou
   mais recente.

os.openpty()

   Abrir um novo par de pseudo-terminal. Retorna um par de descritores
   de arquivos "(master, slave)" para o pty e o tty, respectivamente.
   Os novos descritores de arquivos são non-inheritable. Para uma
   abordagem (ligeiramente) mais portátil, use o módulo "pty".

   Disponibilidade: alguns sabores de Unix

   Alterado na versão 3.4: Os novos descritores de arquivos agora são
   não-herdáveis.

os.pipe()

   Cria um encadeamento. Retorna um par de descritores de arquivos
   "(r, w)" usáveis para leitura e escrita, respectivamente. O novo
   descritor de arquivo é non-inheritable.

   Disponibilidade: Unix, Windows.

   Alterado na versão 3.4: Os novos descritores de arquivos agora são
   não-herdáveis.

os.pipe2(flags)

   Cria um canal com *flags* definidos atomicamente. *flags* podem ser
   construídos por ORing junto a um ou mais destes valores:
   "O_NONBLOCK", "O_CLOEXEC". Retorna um par de descritores de arquivo
   "(r, w)" utilizáveis para leitura e gravação, respectivamente.

   Disponibilidade: alguns sabores de Unix

   Novo na versão 3.3.

os.posix_fallocate(fd, offset, len)

   Garante que espaço em disco suficiente seja alocado para o arquivo
   especificado por *fd* iniciando em *offset* e continuando por *len*
   bytes.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.posix_fadvise(fd, offset, len, advice)

   Anuncia a intenção de acessar dados em um padrão específico,
   permitindo assim que o kernel faça otimizações. O aviso se aplica à
   região do arquivo especificado por *fd*, iniciando em *offset* e
   continuando por *len* bytes. *advice* é um entre
   "POSIX_FADV_NORMAL", "POSIX_FADV_SEQUENTIAL", "POSIX_FADV_RANDOM",
   "POSIX_FADV_NOREUSE", "POSIX_FADV_WILLNEED" ou
   "POSIX_FADV_DONTNEED".

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.POSIX_FADV_NORMAL
os.POSIX_FADV_SEQUENTIAL
os.POSIX_FADV_RANDOM
os.POSIX_FADV_NOREUSE
os.POSIX_FADV_WILLNEED
os.POSIX_FADV_DONTNEED

   Sinalizadores que podem ser usados em *advice* em "posix_fadvise()"
   que especificam o padrão de acesso que provavelmente será usado.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.pread(fd, buffersize, offset)

   Read from a file descriptor, *fd*, at a position of *offset*. It
   will read up to *buffersize* number of bytes. The file offset
   remains unchanged.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.pwrite(fd, str, offset)

   Write *bytestring* to a file descriptor, *fd*, from *offset*,
   leaving the file offset unchanged.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.read(fd, n)

   Read at most *n* bytes from file descriptor *fd*. Return a
   bytestring containing the bytes read.  If the end of the file
   referred to by *fd* has been reached, an empty bytes object is
   returned.

   Nota:

     Esta função destina-se a E/S de baixo nível e deve ser aplicada a
     um descritor de arquivo retornado por "os.open()" ou "pipe()".
     Para ler um "objeto arquivo" retornado pela função embutida
     "open()" ou por "popen()" ou "fdopen()", ou "sys.stdin", use seus
     métodos "read()" ou "readline()".

   Alterado na versão 3.5: Se a chamada de sistema é interrompida e o
   tratador de sinal não levanta uma exceção, a função agora tenta
   novamente a chamada de sistema em vez de levantar uma exceção
   "InterruptedError" (consulte **PEP 475** para entender a lógica).

os.sendfile(out, in, offset, count)
os.sendfile(out, in, offset, count[, headers][, trailers], flags=0)

   Copy *count* bytes from file descriptor *in* to file descriptor
   *out* starting at *offset*. Return the number of bytes sent. When
   EOF is reached return 0.

   A primeira notação de função é suportada por todas as plataformas
   que definem "sendfile()".

   On Linux, if *offset* is given as "None", the bytes are read from
   the current position of *in* and the position of *in* is updated.

   The second case may be used on Mac OS X and FreeBSD where *headers*
   and *trailers* are arbitrary sequences of buffers that are written
   before and after the data from *in* is written. It returns the same
   as the first case.

   On Mac OS X and FreeBSD, a value of 0 for *count* specifies to send
   until the end of *in* is reached.

   All platforms support sockets as *out* file descriptor, and some
   platforms allow other types (e.g. regular file, pipe) as well.

   Os aplicativos de plataforma cruzada não devem usar os argumentos
   *headers*, *trailers* e *flags*.

   Disponibilidade: Unix.

   Nota:

     Para um wrapper de nível superior de "sendfile()", consulte
     "socket.socket.sendfile()".

   Novo na versão 3.3.

os.set_blocking(fd, blocking)

   Define o modo de bloqueio do descritor de arquivo especificado.
   Define o sinalizador "O_NONBLOCK" se bloqueio for "False"; do
   contrário, limpa o sinalizador.

   Veja também "get_blocking()" e "socket.socket.setblocking()".

   Disponibilidade: Unix.

   Novo na versão 3.5.

os.SF_NODISKIO
os.SF_MNOWAIT
os.SF_SYNC

   Parâmetros para a função "sendfile()", se a implementação tiver
   suporte a eles.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.readv(fd, buffers)

   Read from a file descriptor *fd* into a number of mutable *bytes-
   like objects* *buffers*. "readv()" will transfer data into each
   buffer until it is full and then move on to the next buffer in the
   sequence to hold the rest of the data. "readv()" returns the total
   number of bytes read (which may be less than the total capacity of
   all the objects).

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.tcgetpgrp(fd)

   Retorna o grupo de processos associado ao terminal fornecido por
   *fd* (um descritor de arquivo aberto conforme retornado por
   "os.open()").

   Disponibilidade: Unix.

os.tcsetpgrp(fd, pg)

   Define o grupo de processos associado ao terminal fornecido por
   *fd* (um descritor de arquivo aberto conforme retornado por
   "os.open()") para *pg*.

   Disponibilidade: Unix.

os.ttyname(fd)

   Retorna uma string que especifica o dispositivo de terminal
   associado ao descritor de arquivo *fd*. Se *fd* não estiver
   associado a um dispositivo de terminal, uma exceção é levantada.

   Disponibilidade: Unix.

os.write(fd, str)

   Write the bytestring in *str* to file descriptor *fd*. Return the
   number of bytes actually written.

   Nota:

     Esta função destina-se a E/S de baixo nível e deve ser aplicada a
     um descritor de arquivo retornado por "os.open()" ou "pipe()".
     Para escrever um "objeto arquivo" retornado pela função embutida
     "open()" ou por "popen()" ou "fdopen()", ou "sys.stdout" ou
     "sys.stderr", use seu método "write()".

   Alterado na versão 3.5: Se a chamada de sistema é interrompida e o
   tratador de sinal não levanta uma exceção, a função agora tenta
   novamente a chamada de sistema em vez de levantar uma exceção
   "InterruptedError" (consulte **PEP 475** para entender a lógica).

os.writev(fd, buffers)

   Write the contents of *buffers* to file descriptor *fd*. *buffers*
   must be a sequence of *bytes-like objects*. Buffers are processed
   in array order. Entire contents of first buffer is written before
   proceeding to second, and so on. The operating system may set a
   limit (sysconf() value SC_IOV_MAX) on the number of buffers that
   can be used.

   "writev()" writes the contents of each object to the file
   descriptor and returns the total number of bytes written.

   Disponibilidade: Unix.

   Novo na versão 3.3.


16.1.4.1. Consultando o tamanho de um terminal
----------------------------------------------

Novo na versão 3.3.

os.get_terminal_size(fd=STDOUT_FILENO)

   Retorna o tamanho da janela do terminal como "(columns, lines)",
   tupla do tipo "terminal_size".

   O argumento opcional "fd" (padrão "STDOUT_FILENO", ou saída padrão)
   especifica qual descritor de arquivo deve ser consultado.

   Se o descritor de arquivo não estiver conectado a um terminal, uma
   "OSError" é levantada.

   "shutil.get_terminal_size()" é a função de alto nível que
   normalmente deve ser usada, "os.get_terminal_size" é a
   implementação de baixo nível.

   Disponibilidade: Unix, Windows.

class os.terminal_size

   Uma subclasse de tupla, contendo "(columns, lines)" do tamanho da
   janela do terminal.

   columns

      Largura da janela do terminal em caracteres.

   lines

      Altura da janela do terminal em caracteres.


16.1.4.2. Herança de descritores de arquivo
-------------------------------------------

Novo na versão 3.4.

Um descritor de arquivo tem um sinalizador "herdável" que indica se o
descritor de arquivo pode ser herdado por processos filho. Desde o
Python 3.4, os descritores de arquivo criados pelo Python não são
herdáveis por padrão.

No UNIX, os descritores de arquivo não herdáveis são fechados em
processos filho na execução de um novo programa, outros descritores de
arquivo são herdados.

No Windows, identificadores não herdáveis e descritores de arquivo são
fechados em processos filho, exceto para fluxos padrão (descritores de
arquivo 0, 1 e 2: stdin, stdout e stderr), que são sempre herdados.
Usando as funções "spawn*", todos os identificadores herdáveis e todos
os descritores de arquivo herdáveis são herdados. Usando o módulo
"subprocess", todos os descritores de arquivo, exceto fluxos padrão,
são fechados, e os manipuladores herdáveis são herdados apenas se o
parâmetro *close_fds* for "False".

os.get_inheritable(fd)

   Obtém o sinalizador "herdável" do descritor de arquivo especificado
   (um booleano).

os.set_inheritable(fd, inheritable)

   Define o sinalizador "herdável" do descritor de arquivo
   especificado.

os.get_handle_inheritable(handle)

   Obtém o sinalizador "herdável" do manipulador especificado (um
   booleano).

   Availability: Windows.

os.set_handle_inheritable(handle, inheritable)

   Define o sinalizador "herdável" do manipulador especificado.

   Availability: Windows.


16.1.5. Arquivos e Diretórios
=============================

Em algumas plataformas Unix, muitas dessas funções suportam um ou mais
destes recursos:

* **specifying a file descriptor:** For some functions, the *path*
  argument can be not only a string giving a path name, but also a
  file descriptor.  The function will then operate on the file
  referred to by the descriptor.  (For POSIX systems, Python will call
  the "f..." version of the function.)

  You can check whether or not *path* can be specified as a file
  descriptor on your platform using "os.supports_fd".  If it is
  unavailable, using it will raise a "NotImplementedError".

  If the function also supports *dir_fd* or *follow_symlinks*
  arguments, it is an error to specify one of those when supplying
  *path* as a file descriptor.

* **paths relative to directory descriptors:** If *dir_fd* is not
  "None", it should be a file descriptor referring to a directory, and
  the path to operate on should be relative; path will then be
  relative to that directory.  If the path is absolute, *dir_fd* is
  ignored.  (For POSIX systems, Python will call the "...at" or
  "f...at" version of the function.)

  You can check whether or not *dir_fd* is supported on your platform
  using "os.supports_dir_fd".  If it is unavailable, using it will
  raise a "NotImplementedError".

* **not following symlinks:** If *follow_symlinks* is "False", and the
  last element of the path to operate on is a symbolic link, the
  function will operate on the symbolic link itself instead of the
  file the link points to.  (For POSIX systems, Python will call the
  "l..." version of the function.)

  You can check whether or not *follow_symlinks* is supported on your
  platform using "os.supports_follow_symlinks".  If it is unavailable,
  using it will raise a "NotImplementedError".

os.access(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)

   Usa o uid/gid real para testar o acesso ao *path*. Observe que a
   maioria das operações usará o uid/gid efetivo, portanto, essa
   rotina pode ser usada em um ambiente suid/sgid para testar se o
   usuário de chamada tem o acesso especificado ao *path*. *mode* deve
   ser "F_OK" para testar a existência de *path*, ou pode ser o OU
   inclusivo de um ou mais dos "R_OK", "W_OK", e "X_OK" para testar as
   permissões. Retorna "True" se o acesso for permitido, "False" se
   não for. Veja a página man do Unix *access(2)* para mais
   informações.

   Esta função pode suportar a especificação de caminhos relativos aos
   descritores de diretório e não seguir os links simbólicos.

   Se *effective_ids* for "True", "access()" irá realizar suas
   verificações de acesso usando o uid/gid efetivo ao invés do uid/gid
   real. *effective_ids* pode não ser compatível com sua plataforma;
   você pode verificar se está ou não disponível usando
   :data:ʻos.supports_effective_ids`. Se não estiver disponível,
   usá-lo levantará uma "NotImplementedError".

   Nota:

     Usar "access()" para verificar se um usuário está autorizado a,
     por exemplo, abrir um arquivo antes de realmente fazer isso
     usando "open()" cria uma brecha de segurança, porque o usuário
     pode explorar o curto intervalo de tempo entre a verificação e a
     abertura do arquivo para manipulá-lo. É preferível usar as
     técnicas: term:*EAFP*. Por exemplo:

        if os.access("myfile", os.R_OK):
            with open("myfile") as fp:
                return fp.read()
        return "some default data"

     É melhor escrito como:

        try:
            fp = open("myfile")
        except PermissionError:
            return "some default data"
        else:
            with fp:
                return fp.read()

   Nota:

     As operações de E/S podem falhar mesmo quando "access()" indica
     que elas teriam sucesso, particularmente para operações em
     sistemas de arquivos de rede que podem ter semântica de
     permissões além do modelo de bits de permissão POSIX usual.

   Alterado na versão 3.3: Adicionados os parâmetros *dir_fd*,
   *effective_ids* e *follow_symlinks*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.F_OK
os.R_OK
os.W_OK
os.X_OK

   Valores a serem passados como o parâmetro *mode* de "access()" para
   testar a existência, legibilidade, capacidade de escrita e
   executabilidade de *path*, respectivamente.

os.chdir(path)

   Altera o diretório de trabalho atual para *path*.

   Esta função pode ter suporte a especificar um descritor de arquivo.
   O descritor deve fazer referência a um diretório aberto, não a um
   arquivo aberto.

   Novo na versão 3.3: Adicionado suporte para especificar *path* como
   um descritor de arquivo em algumas plataformas.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.chflags(path, flags, *, follow_symlinks=True)

   Define os sinalizadores de *path* para os *flags* numéricos.
   *flags* podem assumir uma combinação (OU bit a bit) dos seguintes
   valores (conforme definido no módulo "stat"):

   * "stat.UF_NODUMP"

   * "stat.UF_IMMUTABLE"

   * "stat.UF_APPEND"

   * "stat.UF_OPAQUE"

   * "stat.UF_NOUNLINK"

   * "stat.UF_COMPRESSED"

   * "stat.UF_HIDDEN"

   * "stat.SF_ARCHIVED"

   * "stat.SF_IMMUTABLE"

   * "stat.SF_APPEND"

   * "stat.SF_NOUNLINK"

   * "stat.SF_SNAPSHOT"

   Esta função pode ter suporte a não seguir links simbólicos.

   Disponibilidade: Unix.

   Novo na versão 3.3: O argumento *follow_symlinks*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.chmod(path, mode, *, dir_fd=None, follow_symlinks=True)

   Altera o modo de *path* para o *mode* numérico. *mode* pode assumir
   um dos seguintes valores (conforme definido no módulo "stat") ou
   combinações de OU bit a bit deles:

   * "stat.S_ISUID"

   * "stat.S_ISGID"

   * "stat.S_ENFMT"

   * "stat.S_ISVTX"

   * "stat.S_IREAD"

   * "stat.S_IWRITE"

   * "stat.S_IEXEC"

   * "stat.S_IRWXU"

   * "stat.S_IRUSR"

   * "stat.S_IWUSR"

   * "stat.S_IXUSR"

   * "stat.S_IRWXG"

   * "stat.S_IRGRP"

   * "stat.S_IWGRP"

   * "stat.S_IXGRP"

   * "stat.S_IRWXO"

   * "stat.S_IROTH"

   * "stat.S_IWOTH"

   * "stat.S_IXOTH"

   Esta função pode ter suporte a especificar um descritor de arquivo,
   caminhos relativos aos descritores de diretório e não seguir os
   links simbólicos.

   Nota:

     Embora o Windows tenha suporte ao "chmod()", você só pode definir
     o sinalizador de somente leitura do arquivo com ele (através das
     constantes "stat.S_IWRITE" e "stat.S_IREAD" ou um valor inteiro
     correspondente). Todos os outros bits são ignorados.

   Novo na versão 3.3: Adicionado suporte para especificar *path* como
   um descritor de arquivo aberto e os argumentos *dir_fd* e
   *follow_symlinks*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.chown(path, uid, gid, *, dir_fd=None, follow_symlinks=True)

   Altera o proprietário e o id de grupo de *path* para *uid* e *gid*
   numéricos. Para deixar um dos ids inalterado, defina-o como -1.

   Esta função pode ter suporte a especificar um descritor de arquivo,
   caminhos relativos aos descritores de diretório e não seguir os
   links simbólicos.

   Consulte "shutil.chown()" para uma função de alto nível que aceita
   nomes além de ids numéricos.

   Disponibilidade: Unix.

   Novo na versão 3.3: Added support for specifying an open file
   descriptor for *path*, and the *dir_fd* and *follow_symlinks*
   arguments.

   Alterado na versão 3.6: Suporta um *path-like object*.

os.chroot(path)

   Altere o diretório raiz do processo atual para *path*

   Disponibilidade: Unix.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.fchdir(fd)

   Altera o diretório de trabalho atual para o diretório representado
   pelo descritor de arquivo *fd*. O descritor deve se referir a um
   diretório aberto, não a um arquivo aberto. No Python 3.3, isso é
   equivalente a "os.chdir(fd)".

   Disponibilidade: Unix.

os.getcwd()

   Retorna uma string representando o diretório de trabalho atual.

os.getcwdb()

   Retorna uma bytestring representando o diretório de trabalho atual.

os.lchflags(path, flags)

   Define os sinalizadores de *path* para os *flags* numéricos, como
   "chflags()", mas não segue links simbólicos. No Python 3.3, isso é
   equivalente a "os.chflags(path, flags, follow_symlinks=False)".

   Disponibilidade: Unix.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.lchmod(path, mode)

   Altera o modo de *path* para o *mode* numérico. Se o caminho for um
   link simbólico, isso afetará o link simbólico em vez do destino.
   Veja a documentação de "chmod()" para valores possíveis de *mode*.
   No Python 3.3, isso é equivalente a "os.chmod(path, mode,
   follow_symlinks=False)".

   Disponibilidade: Unix.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.lchown(path, uid, gid)

   Altera o proprietário e o id de grupo de *path* para *uid* e *gid*
   numéricos. Esta função não seguirá links simbólicos. No Python 3.3,
   isso é equivalente a "os.chown(path, uid, gid,
   follow_symlinks=False)".

   Disponibilidade: Unix.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.link(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True)

   Cria um link físico apontando para *src* chamado *dst*.

   Esta função pode suportar a especificação de *src_dir_fd* e/ou
   *dst_dir_fd* para fornecer caminhos relativos a descritores de
   diretório e não seguir links simbólicos.

   Disponibilidade: Unix, Windows.

   Alterado na versão 3.2: Adicionado suporte ao Windows.

   Novo na versão 3.3: Adiciona os argumentos *src_dir_fd*,
   *dst_dir_fd* e *follow_symlinks*.

   Alterado na versão 3.6: Aceita o termos a *path-like object* para
   *src* e *dst*.

os.listdir(path='.')

   Return a list containing the names of the entries in the directory
   given by *path*.  The list is in arbitrary order, and does not
   include the special entries "'.'" and "'..'" even if they are
   present in the directory.

   *path* pode ser um *objeto caminho ou similar*. Se *path* for do
   tipo "bytes" (direta ou indiretamente por meio da interface
   "PathLike"), os nomes de arquivo retornados também serão do tipo
   "bytes"; em todas as outras circunstâncias, eles serão do tipo
   "str".

   Esta função também pode ter suporte a especificar um descritor de
   arquivo; o descritor de arquivo deve fazer referência a um
   diretório.

   Nota:

     Para codificar nomes de arquivos "str" para "bytes", use
     "fsencode()".

   Ver também:

     A função "scandir()" retorna entradas de diretório junto com
     informações de atributo de arquivo, dando melhor desempenho para
     muitos casos de uso comuns.

   Alterado na versão 3.2: O parâmetro *path* tornou-se opcional.

   Novo na versão 3.3: Added support for specifying an open file
   descriptor for *path*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.lstat(path, *, dir_fd=None)

   Executa o equivalente a uma chamada de sistema "lstat()" no caminho
   fornecido. Semelhante a "stat()", mas não segue links simbólicos.
   Retorna um objeto "stat_result".

   Em plataformas que não têm suporte a links simbólicos, este é um
   alias para "stat()".

   No Python 3.3, isso é equivalente a "os.stat(path, dir_fd=dir_fd,
   follow_symlinks=False)".

   Esta função também pode ter suporte a caminhos relativos a
   descritores de diretório.

   Ver também: A função "stat()".

   Alterado na versão 3.2: Adicionado suporte para links simbólicos do
   Windows 6.0 (Vista).

   Alterado na versão 3.3: Adicionado o parâmetro *dir_fd*.

   Alterado na versão 3.6: Aceita o termos a *path-like object* para
   *src* e *dst*.

os.mkdir(path, mode=0o777, *, dir_fd=None)

   Cria um diretório chamado *path* com o modo numérico *mode*.

   Se o diretório já existe, "FileExistsError" é levantada.

   Em alguns sistemas, *mode* é ignorado. Onde ele é usado, o valor
   atual do umask é primeiro mascarado. Se bits diferentes dos últimos
   9 (ou seja, os últimos 3 dígitos da representação octal do *mode*)
   são definidos, seu significado depende da plataforma. Em algumas
   plataformas, eles são ignorados e você deve chamar "chmod()"
   explicitamente para defini-los.

   Esta função também pode ter suporte a caminhos relativos a
   descritores de diretório.

   Também é possível criar diretórios temporários; veja a função
   "tempfile.mkdtemp()" do módulo "tempfile".

   Novo na versão 3.3: O argumento *dir_fd*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.makedirs(name, mode=0o777, exist_ok=False)

   Função de criação recursiva de diretório. Como "mkdir()", mas torna
   todos os diretórios de nível intermediário necessários para conter
   o diretório folha.

   The *mode* parameter is passed to "mkdir()"; see the mkdir()
   description for how it is interpreted.

   If *exist_ok* is "False" (the default), an "OSError" is raised if
   the target directory already exists.

   Nota:

     "makedirs()" ficará confuso se os elementos do caminho a serem
     criados incluírem "pardir" (por exemplo, ".." em sistemas UNIX).

   Esta função trata os caminhos UNC corretamente.

   Novo na versão 3.2: O parâmetro *exist_ok*.

   Alterado na versão 3.4.1: Antes do Python 3.4.1, se *exist_ok*
   fosse "True" e o diretório existisse, "makedirs()" ainda levantaria
   um erro se *mode* não correspondesse ao modo do diretório
   existente. Como esse comportamento era impossível de implementar
   com segurança, ele foi removido no Python 3.4.1. Consulte
   bpo-21082.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.mkfifo(path, mode=0o666, *, dir_fd=None)

   Cria um FIFO (um encadeamento nomeado) chamado *path* com o modo
   numérico *mode*. O valor atual de umask é primeiro mascarado do
   modo.

   Esta função também pode ter suporte a caminhos relativos a
   descritores de diretório.

   FIFOs são canais que podem ser acessados como arquivos regulares.
   FIFOs existem até que sejam excluídos (por exemplo, com
   "os.unlink()"). Geralmente, os FIFOs são usados como ponto de
   encontro entre os processos do tipo "cliente" e "servidor": o
   servidor abre o FIFO para leitura e o cliente para escrita. Observe
   que "mkfifo()" não abre o FIFO -- apenas cria o ponto de encontro.

   Disponibilidade: Unix.

   Novo na versão 3.3: O argumento *dir_fd*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.mknod(path, mode=0o600, device=0, *, dir_fd=None)

   Cria um nó de sistema de arquivos (arquivo, arquivo especial de
   dispositivo ou canal nomeado) chamado *path*. *mode* especifica as
   permissões de uso e o tipo de nó a ser criado, sendo combinado (OU
   bit a bit) com um de "stat.S_IFREG", "stat.S_IFCHR", "stat.S_IFBLK"
   , e "stat.S_IFIFO" (essas constantes estão disponíveis em "stat").
   Para "stat.S_IFCHR" e "stat.S_IFBLK", *device* define o arquivo
   especial do dispositivo recém-criado (provavelmente usando
   "os.makedev()"), caso contrário, ele será ignorado.

   Esta função também pode ter suporte a caminhos relativos a
   descritores de diretório.

   Disponibilidade: Unix.

   Novo na versão 3.3: O argumento *dir_fd*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.major(device)

   Extrai o número principal de dispositivo de um número bruto de
   dispositivo (normalmente o campo "st_dev" ou "st_rdev" de "stat").

os.minor(device)

   Extrai o número secundário de dispositivo de um número bruto de
   dispositivo (geralmente o campo "st_dev" ou "st_rdev" de "stat").

os.makedev(major, minor)

   Compõe um número de dispositivo bruto a partir dos números de
   dispositivo principais e secundários.

os.pathconf(path, name)

   Retorna informações de configuração do sistema relevantes para um
   arquivo nomeado. *name* especifica o valor de configuração a ser
   recuperado; pode ser uma string que é o nome de um valor de sistema
   definido; esses nomes são especificados em vários padrões (POSIX.1,
   Unix 95, Unix 98 e outros). Algumas plataformas também definem
   nomes adicionais. Os nomes conhecidos do sistema operacional do
   host são fornecidos no dicionário "pathconf_names". Para variáveis
   de configuração não incluídas nesse mapeamento, passar um número
   inteiro para *name* também é aceito.

   Se *name* for uma string e não for conhecida, "ValueError" é
   gerado. Se um valor específico para *name* não for compatível com o
   sistema de host, mesmo que seja incluído no "pathconf_names", um
   erro "OSError" é gerado com "errno.EINVAL" como número do erro.

   Esta função tem suporte a especificar um descritor de arquivo.

   Disponibilidade: Unix.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.pathconf_names

   Nomes de mapeamento de dicionário aceitos por "pathconf()" e
   "fpathconf()" para os valores inteiros definidos para esses nomes
   pelo sistema operacional do host. Isso pode ser usado para
   determinar o conjunto de nomes conhecidos pelo sistema.

   Disponibilidade: Unix.

os.readlink(path, *, dir_fd=None)

   Retorna uma string representando o caminho para o qual o link
   simbólico aponta. O resultado pode ser um nome de caminho absoluto
   ou relativo; se for relativo, pode ser convertido para um caminho
   absoluto usando "os.path.join(os.path.dirname(path), result)".

   Se o *path* for um objeto string (direta ou indiretamente por meio
   de uma interface "PathLike"), o resultado também será um objeto
   string e a chamada pode levantará um UnicodeDecodeError. Se o
   *path* for um objeto de bytes (direto ou indireto), o resultado
   será um objeto de bytes.

   Esta função também pode ter suporte a caminhos relativos a
   descritores de diretório.

   Disponibilidade: Unix, Windows

   Alterado na versão 3.2: Adicionado suporte para links simbólicos do
   Windows 6.0 (Vista).

   Novo na versão 3.3: O argumento *dir_fd*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.remove(path, *, dir_fd=None)

   Remove (delete) the file *path*.  If *path* is a directory,
   "OSError" is raised.  Use "rmdir()" to remove directories.

   Esta função pode suportar paths relative to directory descriptors.

   No Windows, a tentativa de remover um arquivo que está em uso causa
   o surgimento de uma exceção; no Unix, a entrada do diretório é
   removida, mas o armazenamento alocado para o arquivo não é
   disponibilizado até que o arquivo original não esteja mais em uso.

   Esta função é semanticamente idêntica a "unlink()".

   Novo na versão 3.3: O argumento *dir_fd*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.removedirs(name)

   Remove os diretórios recursivamente. Funciona como "rmdir()",
   exceto que, se o diretório folha for removido com sucesso,
   "removedirs()" tenta remover sucessivamente todos os diretórios pai
   mencionados em *path* até que um erro seja levantado (que é
   ignorado, porque geralmente significa que um diretório pai não está
   vazio). Por exemplo, "os.removedirs('foo/bar/baz')" primeiro
   removerá o diretório "'foo/bar/baz'", e então removerá "'foo/bar'"
   e "'foo'" se estiverem vazios. Levanta "OSError" se o diretório
   folha não pôde ser removido com sucesso.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)

   Rename the file or directory *src* to *dst*.  If *dst* is a
   directory, "OSError" will be raised.  On Unix, if *dst* exists and
   is a file, it will be replaced silently if the user has permission.
   The operation may fail on some Unix flavors if *src* and *dst* are
   on different filesystems.  If successful, the renaming will be an
   atomic operation (this is a POSIX requirement).  On Windows, if
   *dst* already exists, "OSError" will be raised even if it is a
   file.

   Esta função pode suportar a especificação de *src_dir_fd* e/ou
   *dst_dir_fd* para fornecer caminhos relativos a descritores de
   diretório.

   Se você quiser sobrescrita multiplataforma do destino, use
   "replace()".

   Novo na versão 3.3: Os argumentos *src_dir_fd* e *dst_dir_fd*.

   Alterado na versão 3.6: Aceita o termos a *path-like object* para
   *src* e *dst*.

os.renames(old, new)

   Diretório recursivo ou função de renomeação de arquivo. Funciona
   como "rename()", exceto que a criação de qualquer diretório
   intermediário necessário para tornar o novo nome de caminho bom é
   tentada primeiro. Após a renomeação, os diretórios correspondentes
   aos segmentos de caminho mais à direita do nome antigo serão
   removidos usando "removedirs()".

   Nota:

     Esta função pode falhar com a nova estrutura de diretório criada
     se você não tiver as permissões necessárias para remover o
     arquivo ou diretório folha.

   Alterado na versão 3.6: Aceita um *objeto caminho ou similar* para
   *old* e *new*.

os.replace(src, dst, *, src_dir_fd=None, dst_dir_fd=None)

   Renomeia o arquivo ou diretório *src* para *dst*. Se *dst* for um
   diretório, "OSError" será levantada. Se *dst* existir e for um
   arquivo, ele será substituído silenciosamente se o usuário tiver
   permissão. A operação pode falhar se *src* e *dst* estiverem em
   sistemas de arquivos diferentes. Se for bem-sucedido, a renomeação
   será uma operação atômica (este é um requisito POSIX).

   Esta função pode suportar a especificação de *src_dir_fd* e/ou
   *dst_dir_fd* para fornecer caminhos relativos a descritores de
   diretório.

   Novo na versão 3.3.

   Alterado na versão 3.6: Aceita o termos a *path-like object* para
   *src* e *dst*.

os.rmdir(path, *, dir_fd=None)

   Remove (delete) the directory *path*.  Only works when the
   directory is empty, otherwise, "OSError" is raised.  In order to
   remove whole directory trees, "shutil.rmtree()" can be used.

   Esta função pode suportar paths relative to directory descriptors.

   Novo na versão 3.3: O parâmetro *dir_fd*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.scandir(path='.')

   Return an iterator of "os.DirEntry" objects corresponding to the
   entries in the directory given by *path*. The entries are yielded
   in arbitrary order, and the special entries "'.'" and "'..'" are
   not included.

   Usar "scandir()" em vez de "listdir()" pode aumentar
   significativamente o desempenho do código que também precisa de
   tipo de arquivo ou informações de atributo de arquivo, porque os
   objetos "os.DirEntry" expõem essas informações se o sistema
   operacional fornecer ao digitalizar um diretório. Todos os métodos
   de "os.DirEntry" podem realizar uma chamada de sistema, mas
   "is_dir()" e "is_file()" normalmente requerem apenas uma chamada de
   sistema para links simbólicos; "os.DirEntry.stat()" sempre requer
   uma chamada de sistema no Unix, mas requer apenas uma para links
   simbólicos no Windows.

   *path* pode ser um *objeto caminho ou similar*. Se *path* for do
   tipo "bytes" (direta ou indiretamente por meio da interface
   "PathLike"), o tipo do atributo "name" e "path" de cada
   "os.DirEntry" serão "bytes"; em todas as outras circunstâncias,
   eles serão do tipo "str".

   O iterador "scandir()" suporta o protocolo *gerenciador de
   contexto* e tem o seguinte método:

   scandir.close()

      Fecha o iterador e libera os recursos adquiridos.

      Isso é chamado automaticamente quando o iterador se esgota ou é
      coletado como lixo, ou quando ocorre um erro durante a iteração.
      No entanto, é aconselhável chamá-lo explicitamente ou usar a
      instrução "with".

      Novo na versão 3.6.

   O exemplo a seguir mostra um uso simples de "scandir()" para exibir
   todos os arquivos (excluindo diretórios) no *path* fornecido que
   não começa com "'.'". A chamada "entry.is_file()" geralmente não
   fará uma chamada de sistema adicional:

      with os.scandir(path) as it:
          for entry in it:
              if not entry.name.startswith('.') and entry.is_file():
                  print(entry.name)

   Nota:

     Em sistemas baseados no Unix, "scandir()" utilize o sistema
     opendir() e as funções readdir(). No Windows, será utilizado o
     Win32 FindFirstFileW e a função FindNextFileW.

   Novo na versão 3.5.

   Novo na versão 3.6: Adicionado suporte para o protocolo
   *gerenciador de contexto* e o método "close()". Se um iterador
   "scandir()" não estiver esgotado nem explicitamente fechado, uma
   "ResourceWarning" será emitida em seu destruidor.A função aceita um
   *objeto caminho ou similar*.

class os.DirEntry

   Objeto produzido por "scandir()" para expor o caminho do arquivo e
   outros atributos de arquivo de uma entrada de diretório.

   "scandir()" fornecerá o máximo possível dessas informações sem
   fazer chamadas de sistema adicionais. Quando uma chamada de sistema
   "stat()" ou "lstat()" é feita, o objeto "os.DirEntry" irá armazenar
   o resultado em cache.

   As instâncias de "os.DirEntry" não devem ser armazenadas em
   estruturas de dados de longa duração; se você sabe que os metadados
   do arquivo foram alterados ou se passou muito tempo desde a chamada
   de "scandir()", chame "os.stat(entry.path)" para obter informações
   atualizadas.

   Como os métodos "os.DirEntry" podem fazer chamadas ao sistema
   operacional, eles também podem levantar "OSError". Se você precisa
   de um controle muito refinado sobre os erros, você pode pegar
   "OSError" ao chamar um dos métodos "os.DirEntry" e manipular
   conforme apropriado.

   Para ser diretamente utilizável como um *objeto caminho ou
   similar*, "os.DirEntry" implementa a interface "PathLike".

   Atributos e métodos em uma instância de "os.DirEntry" são os
   seguintes:

   name

      O nome do arquivo base da entrada, relativo ao argumento *path*
      de "scandir()".

      O atributo "name" será "bytes" se o argumento *path* de
      "scandir()" for do tipo "bytes" e, caso contrário, "str". Usa
      "fsdecode()" para decodificar nomes de arquivos de bytes.

   path

      The entry's full path name: equivalent to
      "os.path.join(scandir_path, entry.name)" where *scandir_path* is
      the "scandir()" *path* argument.  The path is only absolute if
      the "scandir()" *path* argument was absolute.

      O atributo "path" será "bytes" se o argumento *path* de
      "scandir()" for do tipo "bytes" e, caso contrário, "str". Usa
      "fsdecode()" para decodificar nomes de arquivos de bytes.

   inode()

      Retorna o número de nó-i da entrada.

      O resultado é armazenado em cache no objeto "os.DirEntry". Use
      "os.stat(entry.path, follow_symlinks=False).st_ino" para obter
      informações atualizadas.

      Na primeira chamada sem cache, uma chamada de sistema é
      necessária no Windows, mas não no Unix.

   is_dir(*, follow_symlinks=True)

      Retorna "True" se esta entrada for um diretório ou um link
      simbólico apontando para um diretório; retorna "False" se a
      entrada é ou aponta para qualquer outro tipo de arquivo, ou se
      ele não existe mais.

      Se *follow_symlinks* for "False", retorna "True" apenas se esta
      entrada for um diretório (sem seguir os links simbólicos);
      retorna "False" se a entrada for qualquer outro tipo de arquivo
      ou se ele não existe mais.

      O resultado é armazenado em cache no objeto "os.DirEntry", com
      um cache separado para *follow_symlinks* "True" e "False". Chama
      "os.stat()" junto com "stat.S_ISDIR()" para buscar informações
      atualizadas.

      Na primeira chamada sem cache, nenhuma chamada do sistema é
      necessária na maioria dos casos. Especificamente, para links não
      simbólicos, nem o Windows nem o Unix requerem uma chamada de
      sistema, exceto em certos sistemas de arquivos Unix, como
      sistemas de arquivos de rede, que retornam "dirent.d_type ==
      DT_UNKNOWN". Se a entrada for um link simbólico, uma chamada de
      sistema será necessária para seguir o link simbólico, a menos
      que *follow_symlinks* seja "False".

      Este método pode levantar "OSError", tal como "PermissionError",
      mas "FileNotFoundError" é capturada e não levantada.

   is_file(*, follow_symlinks=True)

      Retorna "True" se esta entrada for um arquivo ou um link
      simbólico apontando para um arquivo; retorna "False" se a
      entrada é ou aponta para um diretório ou outra entrada que não
      seja de arquivo, ou se ela não existe mais.

      Se *follow_symlinks* for "False", retorna "True" apenas se esta
      entrada for um arquivo (sem seguir os links simbólicos); retorna
      "False" se a entrada for um diretório ou outra entrada que não
      seja um arquivo, ou se ela não existir mais.

      O resultado é armazenado em cache no objeto "os.DirEntry".
      Chamadas de sistema em cache feitas e exceções levantadas são
      conforme "is_dir()".

   is_symlink()

      Retorna "True" se esta entrada for um link simbólico (mesmo se
      quebrado); retorna "False" se a entrada apontar para um
      diretório ou qualquer tipo de arquivo, ou se ele não existir
      mais.

      O resultado é armazenado em cache no objeto "os.DirEntry". Chama
      "os.path.islink()" para buscar informações atualizadas.

      Na primeira chamada sem cache, nenhuma chamada do sistema é
      necessária na maioria dos casos. Especificamente, nem o Windows
      nem o Unix exigem uma chamada de sistema, exceto em certos
      sistemas de arquivos Unix, como sistemas de arquivos de rede,
      que retornam "dirent.d_type == DT_UNKNOWN".

      Este método pode levantar "OSError", tal como "PermissionError",
      mas "FileNotFoundError" é capturada e não levantada.

   stat(*, follow_symlinks=True)

      Retorna um objeto "stat_result" para esta entrada. Este método
      segue links simbólicos por padrão; para estabelecer um link
      simbólico, adicione o argumento "follow_symlinks=False".

      On Unix, this method always requires a system call. On Windows,
      it only requires a system call if *follow_symlinks* is "True"
      and the entry is a symbolic link.

      No Windows, os atributos "st_ino", "st_dev" e "st_nlink" da
      "stat_result" são sempre definidos como zero. Chame "os.stat()"
      para obter esses atributos.

      O resultado é armazenado em cache no objeto "os.DirEntry", com
      um cache separado para *follow_symlinks* "True" e "False". Chama
      "os.stat()" para buscar informações atualizadas.

   Note que há uma boa correspondência entre vários atributos e
   métodos de "os.DirEntry" e de "pathlib.Path". Em particular, o
   atributo "name" tem o mesmo significado, assim como os métodos
   "is_dir()", "is_file()", "is_symlink()" e "stat()".

   Novo na versão 3.5.

   Alterado na versão 3.6: Adicionado suporte para a interface
   "PathLike". Adicionado suporte para caminhos "bytes" no Windows.

os.stat(path, *, dir_fd=None, follow_symlinks=True)

   Obtém o status de um arquivo ou um descritor de arquivo. Executa o
   equivalente a uma chamada de sistema "stat()" no caminho fornecido.
   *path* pode ser especificado como uma string ou bytes -- direta ou
   indiretamente através da interface "PathLike" -- ou como um
   descritor de arquivo aberto. Retorna um objeto "stat_result".

   Esta função normalmente segue links simbólicos; para efetuar stat
   em um link simbólico, adicione o argumento "follow_symlinks=False",
   ou use "lstat()".

   Esta função tem suporte a especificar um descritor de arquivo e não
   seguir links simbólicos.

   Exemplo:

      >>> import os
      >>> statinfo = os.stat('somefile.txt')
      >>> statinfo
      os.stat_result(st_mode=33188, st_ino=7876932, st_dev=234881026,
      st_nlink=1, st_uid=501, st_gid=501, st_size=264, st_atime=1297230295,
      st_mtime=1297230027, st_ctime=1297230027)
      >>> statinfo.st_size
      264

   Ver também: As funções "fstat()" e "lstat()".

   Novo na versão 3.3: Adicionados os argumentos *dir_fd* e
   *follow_symlinks*, especificando um descritor de arquivo em vez de
   um caminho.

   Alterado na versão 3.6: Aceita um *path-like object*.

class os.stat_result

   Objeto cujos atributos correspondem aproximadamente aos membros da
   estrutura "stat". É usado para o resultado de "os.stat()",
   "os.fstat()" e "os.lstat()".

   Atributos:

   st_mode

      Modo de arquivo: tipo de arquivo e bits de modo de arquivo
      (permissões).

   st_ino

      Dependente da plataforma, mas se diferente de zero, identifica
      exclusivamente o arquivo para um determinado valor de "st_dev".
      Tipicamente:

      * o número do nó-i no Unix,

      * o índice de arquivo no Windows

   st_dev

      Identificador do dispositivo no qual este arquivo reside.

   st_nlink

      Número de links físicos.

   st_uid

      Identificador de usuário do proprietário do arquivo.

   st_gid

      Identificador de grupo do proprietário do arquivo.

   st_size

      Tamanho do arquivo em bytes, se for um arquivo normal ou um link
      simbólico. O tamanho de um link simbólico é o comprimento do
      nome do caminho que ele contém, sem um byte nulo final.

   Timestamps:

   st_atime

      Tempo do acesso mais recente expresso em segundos.

   st_mtime

      Tempo da modificação de conteúdo mais recente expresso em
      segundos.

   st_ctime

      Dependente da plataforma:

      * a hora da mudança de metadados mais recente no Unix,

      * a hora de criação no Windows, expresso em segundos.

   st_atime_ns

      Hora do acesso mais recente expresso em nanossegundos como um
      número inteiro.

   st_mtime_ns

      Hora da modificação de conteúdo mais recente expressa em
      nanossegundos como um número inteiro.

   st_ctime_ns

      Dependente da plataforma:

      * a hora da mudança de metadados mais recente no Unix,

      * a hora de criação no Windows, expresso em nanossegundos como
        um número inteiro.

   See also the "stat_float_times()" function.

   Nota:

     O significado e resolução exatos dos atributos "st_atime",
     "st_mtime", and "st_ctime" dependem do sistema operacional e do
     sistema de arquivos. Por exemplo, em sistemas Windows que usam os
     sistemas de arquivos FAT ou FAT32, "st_mtime" tem resolução de 2
     segundos, e "st_atime" tem resolução de apenas 1 dia. Consulte a
     documentação do sistema operacional para obter detalhes.Da mesma
     forma, embora "st_atime_ns", "st_mtime_ns" e "st_ctime_ns" sejam
     sempre expressos em nanossegundos, muitos sistemas não fornecem
     precisão de nanossegundos. Em sistemas que fornecem precisão de
     nanossegundos, o objeto de ponto flutuante usado para armazenar
     "st_atime", "st_mtime" e "st_ctime" não pode preservar tudo, e
     como tal será ligeiramente inexato . Se você precisa dos carimbos
     de data/hora exatos, sempre deve usar "st_atime_ns",
     "st_mtime_ns" e "st_ctime_ns".

   Em alguns sistemas Unix (como Linux), os seguintes atributos também
   podem estar disponíveis:

   st_blocks

      Número de blocos de 512 bytes alocados para o arquivo. Isso pode
      ser menor que "st_size"/512 quando o arquivo possuir lacunas.

   st_blksize

      Tamanho de bloco "preferido" para E/S eficiente do sistema de
      arquivos. Gravar em um arquivo em partes menores pode causar uma
      leitura-modificação-reescrita ineficiente.

   st_rdev

      Tipo de dispositivo, se for um dispositivo nó-i.

   st_flags

      Sinalizadores definidos pelo usuário para arquivo.

   Em outros sistemas Unix (como o FreeBSD), os seguintes atributos
   podem estar disponíveis (mas só podem ser preenchidos se o root
   tentar usá-los):

   st_gen

      Número de geração do arquivo.

   st_birthtime

      Horário da criação do arquivo.

   Em sistemas Mac OS, os seguintes atributos também podem estar
   disponíveis:

   st_rsize

      Tamanho real do arquivo.

   st_creator

      Criador do arquivo.

   st_type

      Tipo de arquivo.

   On Windows systems, the following attribute is also available:

   st_file_attributes

      Atributos de arquivos no Windows: membro "dwFileAttributes" da
      estrutura "BY_HANDLE_FILE_INFORMATION" retornada por
      "GetFileInformationByHandle()". Veja as constantes
      "FILE_ATTRIBUTE_*" no módulo "stat".

   O módulo padrão "stat" define funções e constantes que são úteis
   para extrair informações de uma estrutura "stat". (No Windows,
   alguns itens são preenchidos com valores fictícios.)

   Para compatibilidade com versões anteriores, uma instância de
   "stat_result" também é acessível como uma tupla de pelo menos 10
   inteiros, fornecendo os membros mais importantes (e portáveis) da
   estrutura "stat", na ordem "st_mode", "st_ino", "st_dev",
   "st_nlink", "st_uid", "st_gid", "st_size", "st_atime", "st_mtime",
   "st_ctime". Mais itens podem ser adicionados no final por algumas
   implementações. Para compatibilidade com versões mais antigas do
   Python, acessar "stat_result" como uma tupla sempre retorna
   inteiros.

   Novo na versão 3.3: Adicionados os membros "st_atime_ns",
   "st_mtime_ns" e "st_ctime_ns".

   Novo na versão 3.5: Adicionado o membro "st_file_attributes" no
   Windows.

   Alterado na versão 3.5: Windows agora retorna o arquivo de índice
   como "st_ino" quando disponível.

os.stat_float_times([newvalue])

   Determine whether "stat_result" represents time stamps as float
   objects. If *newvalue* is "True", future calls to "stat()" return
   floats, if it is "False", future calls return ints. If *newvalue*
   is omitted, return the current setting.

   For compatibility with older Python versions, accessing
   "stat_result" as a tuple always returns integers.

   Python now returns float values by default. Applications which do
   not work correctly with floating point time stamps can use this
   function to restore the old behaviour.

   The resolution of the timestamps (that is the smallest possible
   fraction) depends on the system. Some systems only support second
   resolution; on these systems, the fraction will always be zero.

   It is recommended that this setting is only changed at program
   startup time in the *__main__* module; libraries should never
   change this setting. If an application uses a library that works
   incorrectly if floating point time stamps are processed, this
   application should turn the feature off until the library has been
   corrected.

   Obsoleto desde a versão 3.3.

os.statvfs(path)

   Perform a "statvfs()" system call on the given path.  The return
   value is an object whose attributes describe the filesystem on the
   given path, and correspond to the members of the "statvfs"
   structure, namely: "f_bsize", "f_frsize", "f_blocks", "f_bfree",
   "f_bavail", "f_files", "f_ffree", "f_favail", "f_flag",
   "f_namemax".

   Duas constantes de nível de módulo são definidas para os
   sinalizadores de bit do atributo "f_flag": se "ST_RDONLY" for
   definido, o sistema de arquivos é montado somente leitura, e se
   "ST_NOSUID" estiver definido, a semântica dos bits setuid/setgid é
   desabilitada ou não é suportada.

   Constantes de nível de módulo adicionais são definidas para
   sistemas baseados em GNU/glibc. São elas "ST_NODEV" (impede o
   acesso aos arquivos especiais do dispositivo), "ST_NOEXEC" (não
   permite a execução do programa), "ST_SYNCHRONOUS" (as escritas são
   sincronizadas de uma vez), "ST_MANDLOCK" (permitir bloqueios
   obrigatórios em um sistema de arquivos), "ST_WRITE" (escrever no
   arquivo/diretório/symlink), "ST_APPEND" (arquivo somente anexado),
   "ST_IMMUTABLE" (arquivo imutável), "ST_NOATIME" (não atualiza os
   tempos de acesso), "ST_NODIRATIME" (não atualiza os tempos de
   acesso ao diretório), "ST_RELATIME" (atualiza o atime relativo ao
   mtime/ctime).

   Esta função tem suporte a especificar um descritor de arquivo.

   Disponibilidade: Unix.

   Alterado na versão 3.2: As constantes "ST_RDONLY" e "ST_NOSUID"
   foram adicionadas.

   Novo na versão 3.3: Added support for specifying an open file
   descriptor for *path*.

   Alterado na versão 3.4: As constantes "ST_NODEV", "ST_NOEXEC",
   "ST_SYNCHRONOUS", "ST_MANDLOCK", "ST_WRITE", "ST_APPEND",
   "ST_IMMUTABLE", "ST_NOATIME", "ST_NODIRATIME" e "ST_RELATIME" foram
   adicionadas.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.supports_dir_fd

   A "Set" object indicating which functions in the "os" module permit
   use of their *dir_fd* parameter.  Different platforms provide
   different functionality, and an option that might work on one might
   be unsupported on another.  For consistency's sakes, functions that
   support *dir_fd* always allow specifying the parameter, but will
   raise an exception if the functionality is not actually available.

   To check whether a particular function permits use of its *dir_fd*
   parameter, use the "in" operator on "supports_dir_fd".  As an
   example, this expression determines whether the *dir_fd* parameter
   of "os.stat()" is locally available:

      os.stat in os.supports_dir_fd

   Atualmente os parâmetros *dir_fd* funcionam apenas em plataformas
   Unix; nenhum deles funciona no Windows.

   Novo na versão 3.3.

os.supports_effective_ids

   A "Set" object indicating which functions in the "os" module permit
   use of the *effective_ids* parameter for "os.access()".  If the
   local platform supports it, the collection will contain
   "os.access()", otherwise it will be empty.

   To check whether you can use the *effective_ids* parameter for
   "os.access()", use the "in" operator on "supports_effective_ids",
   like so:

      os.access in os.supports_effective_ids

   Currently *effective_ids* only works on Unix platforms; it does not
   work on Windows.

   Novo na versão 3.3.

os.supports_fd

   A "Set" object indicating which functions in the "os" module permit
   specifying their *path* parameter as an open file descriptor.
   Different platforms provide different functionality, and an option
   that might work on one might be unsupported on another.  For
   consistency's sakes, functions that support *fd* always allow
   specifying the parameter, but will raise an exception if the
   functionality is not actually available.

   To check whether a particular function permits specifying an open
   file descriptor for its *path* parameter, use the "in" operator on
   "supports_fd". As an example, this expression determines whether
   "os.chdir()" accepts open file descriptors when called on your
   local platform:

      os.chdir in os.supports_fd

   Novo na versão 3.3.

os.supports_follow_symlinks

   A "Set" object indicating which functions in the "os" module permit
   use of their *follow_symlinks* parameter.  Different platforms
   provide different functionality, and an option that might work on
   one might be unsupported on another.  For consistency's sakes,
   functions that support *follow_symlinks* always allow specifying
   the parameter, but will raise an exception if the functionality is
   not actually available.

   To check whether a particular function permits use of its
   *follow_symlinks* parameter, use the "in" operator on
   "supports_follow_symlinks".  As an example, this expression
   determines whether the *follow_symlinks* parameter of "os.stat()"
   is locally available:

      os.stat in os.supports_follow_symlinks

   Novo na versão 3.3.

os.symlink(src, dst, target_is_directory=False, *, dir_fd=None)

   Cria um link simbólico apontando para *src* chamado *dst*.

   No Windows, um link simbólico representa um arquivo ou um diretório
   e não se transforma no destino dinamicamente. Se o alvo estiver
   presente, o tipo de link simbólico será criado para corresponder.
   Caso contrário, o link simbólico será criado como um diretório se
   *target_is_directory* for "True" ou um link simbólico de arquivo (o
   padrão) caso contrário. Em plataformas não Windows,
   *target_is_directory* é ignorado.

   Symbolic link support was introduced in Windows 6.0 (Vista).
   "symlink()" will raise a "NotImplementedError" on Windows versions
   earlier than 6.0.

   Esta função pode suportar paths relative to directory descriptors.

   Nota:

     On Windows, the *SeCreateSymbolicLinkPrivilege* is required in
     order to successfully create symlinks. This privilege is not
     typically granted to regular users but is available to accounts
     which can escalate privileges to the administrator level. Either
     obtaining the privilege or running your application as an
     administrator are ways to successfully create symlinks.A exceção
     "OSError" é levantada quando a função é chamada por um usuário
     sem privilégios.

   Disponibilidade: Unix, Windows.

   Alterado na versão 3.2: Adicionado suporte para links simbólicos do
   Windows 6.0 (Vista).

   Novo na versão 3.3: Adicionado o argumento *dir_fd* e agora permite
   *target_is_directory* em plataformas não Windows.

   Alterado na versão 3.6: Aceita o termos a *path-like object* para
   *src* e *dst*.

os.sync()

   Força a escrita de tudo para o disco.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.truncate(path, length)

   Trunca o arquivo correspondente ao *path*, de modo que tenha no
   máximo *length* bytes.

   Esta função tem suporte a especificar um descritor de arquivo.

   Disponibilidade: Unix, Windows.

   Novo na versão 3.3.

   Alterado na versão 3.5: Adicionado suporte para o Windows.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.unlink(path, *, dir_fd=None)

   Remove (exclui) o arquivo *path*. Esta função é semanticamente
   idêntica à "remove()"; o nome "unlink" é seu nome Unix tradicional.
   Por favor, veja a documentação de "remove()" para mais informações.

   Novo na versão 3.3: O parâmetro *dir_fd*.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.utime(path, times=None, *[, ns], dir_fd=None, follow_symlinks=True)

   Define os tempos de acesso e modificação do arquivo especificado
   por *path*.

   "utime()" aceita dois parâmetros opcionais, *times* e *ns*. Eles
   especificam os horários definidos no *path* e são usados da
   seguinte forma:

   * Se *ns* for especificado, deve ser uma tupla de 2 elementos na
     forma "(atime_ns, mtime_ns)" onde cada membro é um int
     expressando nanossegundos.

   * Se *times* não for "None", deve ser uma tupla de 2 elementos na
     forma "(atime, mtime)" onde cada membro é um int ou ponto
     flutuante expressando segundos.

   * Se *times* for "None" e *ns* não for especificado, isso é
     equivalente a especificar "ns=(atime_ns, mtime_ns)" onde ambos os
     tempos são a hora atual.

   É um erro especificar tuplas para ambos *times* e *ns*.

   Whether a directory can be given for *path* depends on whether the
   operating system implements directories as files (for example,
   Windows does not).  Note that the exact times you set here may not
   be returned by a subsequent "stat()" call, depending on the
   resolution with which your operating system records access and
   modification times; see "stat()".  The best way to preserve exact
   times is to use the *st_atime_ns* and *st_mtime_ns* fields from the
   "os.stat()" result object with the *ns* parameter to *utime*.

   Esta função pode ter suporte a especificar um descritor de arquivo,
   caminhos relativos aos descritores de diretório e não seguir os
   links simbólicos.

   Novo na versão 3.3: Added support for specifying an open file
   descriptor for *path*, and the *dir_fd*, *follow_symlinks*, and
   *ns* parameters.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.walk(top, topdown=True, onerror=None, followlinks=False)

   Gera os nomes dos arquivos em uma árvore de diretório percorrendo a
   árvore de cima para baixo ou de baixo para cima. Para cada
   diretório na árvore com raiz no diretório *top* (incluindo o
   próprio *top*), ele produz uma tupla de 3 elementos "(dirpath,
   dirnames, filenames)".

   *dirpath* is a string, the path to the directory.  *dirnames* is a
   list of the names of the subdirectories in *dirpath* (excluding
   "'.'" and "'..'"). *filenames* is a list of the names of the non-
   directory files in *dirpath*. Note that the names in the lists
   contain no path components.  To get a full path (which begins with
   *top*) to a file or directory in *dirpath*, do
   "os.path.join(dirpath, name)".

   Se o argumento opcional *topdown* for "True" ou não especificado, o
   triplo para um diretório é gerado antes dos triplos para qualquer
   um de seus subdiretórios (os diretórios são gerados de cima para
   baixo). Se *topdown* for "False", o triplo para um diretório é
   gerado após os triplos para todos os seus subdiretórios (os
   diretórios são gerados de baixo para cima). Não importa o valor de
   *topdown*, a lista de subdiretórios é recuperada antes que as
   tuplas para o diretório e seus subdiretórios sejam geradas.

   Quando *topdown* é "True", o chamador pode modificar a lista de
   *dirnames* no local (talvez usando "del" ou atribuição de fatia), e
   "walk()" só recursará nos subdiretórios cujos nomes permanecem em
   *dirnames*; isso pode ser usado para podar a busca, impor uma ordem
   específica de visita, ou mesmo informar à função "walk()" sobre os
   diretórios que o chamador cria ou renomeia antes de retomar
   "walk()" novamente. Modificar *dirnames* quando *topdown* for
   "False" não tem efeito no comportamento da caminhada, porque no
   modo de baixo para cima os diretórios em *dirnames* são gerados
   antes do próprio *dirpath* ser gerado.

   Por padrão, os erros da chamada de "scandir()" são ignorados. Se o
   argumento opcional *onerror* for especificado, deve ser uma função;
   ela será chamado com um argumento, uma instância da exceção
   "OSError". Ele pode relatar o erro para continuar com a caminhada
   ou levantar a exceção para abortar a caminhada. Observe que o nome
   do arquivo está disponível como o atributo "filename" do objeto de
   exceção.

   Por padrão, a função "walk()" não vai seguir links simbólicos que
   resolvem para diretórios. Defina *followlinks* como "True" para
   visitar diretórios apontados por links simbólicos, em sistemas que
   oferecem suporte a eles.

   Nota:

     Esteja ciente de que definir *followlinks* para "True" pode levar
     a recursão infinita se um link apontar para um diretório pai de
     si mesmo. "walk()" não mantém registro dos diretórios que já
     visitou.

   Nota:

     Se você passar um nome de caminho relativo, não mude o diretório
     de trabalho atual entre as continuações de "walk()". : func:
     *walk* nunca muda o diretório atual, e presume que seu chamador
     também não.

   Este exemplo exibe o número de bytes obtidos por arquivos não
   pertencentes ao diretório em cada diretório no diretório inicial,
   exceto que ele não olha em nenhum subdiretório CVS:

      import os
      from os.path import join, getsize
      for root, dirs, files in os.walk('python/Lib/email'):
          print(root, "consumes", end=" ")
          print(sum(getsize(join(root, name)) for name in files), end=" ")
          print("bytes in", len(files), "non-directory files")
          if 'CVS' in dirs:
              dirs.remove('CVS')  # don't visit CVS directories

   No próximo exemplo (implementação simples de "shutil.rmtree()"),
   andar na árvore de baixo para cima é essencial, "rmdir()" não
   permite excluir um diretório antes que o diretório esteja vazio:

      # Delete everything reachable from the directory named in "top",
      # assuming there are no symbolic links.
      # CAUTION:  This is dangerous!  For example, if top == '/', it
      # could delete all your disk files.
      import os
      for root, dirs, files in os.walk(top, topdown=False):
          for name in files:
              os.remove(os.path.join(root, name))
          for name in dirs:
              os.rmdir(os.path.join(root, name))

   Alterado na versão 3.5: Esta função agora chama "os.scandir()" em
   vez de "os.listdir()", tornando-a mais rápida reduzindo o número de
   chamadas a "os.stat()".

   Alterado na versão 3.6: Aceita um *path-like object*.

os.fwalk(top='.', topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=None)

   Se comporta exatamente como "walk()", exceto que produz um tupla de
   4 elementos "(dirpath, dirnames, filenames, dirfd)", e tem suporte
   a "dir_fd".

   *dirpath*, *dirnames* e *filenames* são idênticos à saída de
   "walk()" e *dirfd* é um descritor de arquivo que faz referência ao
   diretório *dirpath*.

   Esta função sempre tem suporte a caminhos relativos aos descritores
   de diretório e não seguir links simbólicos. Observe, entretanto,
   que, ao contrário de outras funções, o valor padrão "fwalk()" para
   *follow_symlinks* é "False".

   Nota:

     Uma vez que "fwalk()" produz descritores de arquivo, eles só são
     válidos até a próxima etapa de iteração, então você deve
     duplicá-los (por exemplo, com "dup()") se quiser mantê-los por
     mais tempo.

   Este exemplo exibe o número de bytes obtidos por arquivos não
   pertencentes ao diretório em cada diretório no diretório inicial,
   exceto que ele não olha em nenhum subdiretório CVS:

      import os
      for root, dirs, files, rootfd in os.fwalk('python/Lib/email'):
          print(root, "consumes", end="")
          print(sum([os.stat(name, dir_fd=rootfd).st_size for name in files]),
                end="")
          print("bytes in", len(files), "non-directory files")
          if 'CVS' in dirs:
              dirs.remove('CVS')  # don't visit CVS directories

   No próximo exemplo, percorrer a árvore de baixo para cima é
   essencial: "rmdir()" não permite excluir um diretório antes que o
   diretório esteja vazio:

      # Delete everything reachable from the directory named in "top",
      # assuming there are no symbolic links.
      # CAUTION:  This is dangerous!  For example, if top == '/', it
      # could delete all your disk files.
      import os
      for root, dirs, files, rootfd in os.fwalk(top, topdown=False):
          for name in files:
              os.unlink(name, dir_fd=rootfd)
          for name in dirs:
              os.rmdir(name, dir_fd=rootfd)

   Disponibilidade: Unix.

   Novo na versão 3.3.

   Alterado na versão 3.6: Aceita um *path-like object*.


16.1.5.1. Atributos estendidos do Linux
---------------------------------------

Novo na versão 3.3.

Estas funções estão todas disponíveis apenas no Linux.

os.getxattr(path, attribute, *, follow_symlinks=True)

   Retorna o valor do atributo estendido do sistema de arquivos
   *attribute* para *path*. *attribute* pode ser bytes ou str (direta
   ou indiretamente por meio da interface "PathLike"). Se for str, ele
   é codificado com a codificação do sistema de arquivos.

   Esta função tem suporte a especificar um descritor de arquivo e não
   seguir links simbólicos.

   Alterado na versão 3.6: Aceita um *objeto caminho ou similar* para
   *path* e *attribute*.

os.listxattr(path=None, *, follow_symlinks=True)

   Retorna uma lista dos atributos estendidos do sistema de arquivos
   em *path*. Os atributos na lista são representados como strings
   decodificadas com a codificação do sistema de arquivos. Se *path*
   for "None", "listxattr()" irá examinar o diretório atual.

   Esta função tem suporte a especificar um descritor de arquivo e não
   seguir links simbólicos.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.removexattr(path, attribute, *, follow_symlinks=True)

   Remove o atributo estendido do sistema de arquivos *attribute* do
   *path*. *attribute* deve ser bytes ou str (direta ou indiretamente
   por meio da interface "PathLike"). Se for uma string, ele é
   codificado com a codificação do sistema de arquivos.

   Esta função tem suporte a especificar um descritor de arquivo e não
   seguir links simbólicos.

   Alterado na versão 3.6: Aceita um *objeto caminho ou similar* para
   *path* e *attribute*.

os.setxattr(path, attribute, value, flags=0, *, follow_symlinks=True)

   Define o atributo de sistema de arquivos estendido *attribute* em
   *path* como *value*. *attribute* deve ser um bytes ou str sem NULs
   embutidos (direta ou indiretamente por meio da interface
   "PathLike"). Se for um str, ele é codificado com a codificação do
   sistema de arquivos. *sinalizadores* podem ser "XATTR_REPLACE" ou
   "XATTR_CREATE". Se "XATTR_REPLACE" é fornecido e o atributo não
   existe, "EEXISTS" será levantado. Se "XATTR_CREATE" for fornecido e
   o atributo já existir, o atributo não será criado e "ENODATA" será
   levantado.

   Esta função tem suporte a especificar um descritor de arquivo e não
   seguir links simbólicos.

   Nota:

     Um bug nas versões do kernel Linux inferiores a 2.6.39 fez com
     que o argumento *flags* fosse ignorado em alguns sistemas de
     arquivos.

   Alterado na versão 3.6: Aceita um *objeto caminho ou similar* para
   *path* e *attribute*.

os.XATTR_SIZE_MAX

   O tamanho máximo que o valor de um atributo estendido pode ter.
   Atualmente, são 64 KiB no Linux.

os.XATTR_CREATE

   Este é um valor possível para o argumento *flags* em "setxattr()".
   Indica que a operação deve criar um atributo.

os.XATTR_REPLACE

   Este é um valor possível para o argumento *flags* em "setxattr()".
   Indica que a operação deve substituir um atributo existente.


16.1.6. Gerenciamento de processo
=================================

Estas funções podem ser usadas para criar e gerenciar processos.

As várias funções "exec*" pegam uma lista de argumentos para o novo
programa carregado no processo. Em cada caso, o primeiro desses
argumentos é passado para o novo programa como seu próprio nome, e não
como um argumento que um usuário pode ter digitado em uma linha de
comando. Para o programador C, este é o "argv[0]" passado para um
programa "main()". Por exemplo, "os.execv('/bin/echo', ['foo',
'bar'])" imprimirá apenas "bar" na saída padrão; "foo" parecerá ser
ignorado.

os.abort()

   Gera um sinal "SIGABRT" para o processo atual. No Unix, o
   comportamento padrão é produzir um despejo de memória; no Windows,
   o processo retorna imediatamente um código de saída "3". Esteja
   ciente de que chamar esta função não chamará o manipulador de sinal
   Python registrado para "SIGABRT" com "signal.signal()".

os.execl(path, arg0, arg1, ...)
os.execle(path, arg0, arg1, ..., env)
os.execlp(file, arg0, arg1, ...)
os.execlpe(file, arg0, arg1, ..., env)
os.execv(path, args)
os.execve(path, args, env)
os.execvp(file, args)
os.execvpe(file, args, env)

   Todas essas funções executam um novo programa, substituindo o
   processo atual; eles não voltam. No Unix, o novo executável é
   carregado no processo atual e terá a mesma identificação de
   processo do chamador. Os erros serão relatados como exceções de
   "OSError".

   O processo atual é substituído imediatamente. Objetos de arquivos
   abertos e descritores não são descarregados, então se houver dados
   em buffer nesses arquivos abertos, você deve descarregá-los usando
   "sys.stdout.flush()" ou "os.fsync()" antes de chamar uma função
   "exec*".

   As variantes "l" e "v" das funções "exec*" diferem em como os
   argumentos da linha de comando são passados. As variantes "l" são
   talvez as mais fáceis de trabalhar se o número de parâmetros for
   fixo quando o código for escrito; os parâmetros individuais
   simplesmente se tornam parâmetros adicionais para as funções
   "execl*()". As variantes "v" são boas quando o número de parâmetros
   é variável, com os argumentos sendo passados em uma lista ou tupla
   como o parâmetro *args*. Em qualquer caso, os argumentos para o
   processo filho devem começar com o nome do comando que está sendo
   executado, mas isso não é obrigatório.

   As variantes que incluem um "p" próximo ao final ("execlp()",
   "execlpe()", "execvp()" e "execvpe()") usarão a variável de
   ambiente "PATH" para localizar o programa *file*. Quando o ambiente
   está sendo substituído (usando uma das variantes "exec*e",
   discutidas no próximo parágrafo), o novo ambiente é usado como
   fonte da variável "PATH" As outras variantes, "execl()",
   "execle()", "execv()" e "execve()", não usarão a variável "PATH"
   para localizar o executável; *path* deve conter um caminho absoluto
   ou relativo apropriado.

   Para "execle()", "execlpe()", "execve()" e "execvpe()" (observe que
   todos eles terminam em "e"), o parâmetro *env* deve ser um
   mapeamento que é usado para definir as variáveis de ambiente para o
   novo processo (elas são usadas no lugar do ambiente do processo
   atual); as funções "execl()", "execlp()", "execv()" e "execvp()"
   fazem com que o novo processo herde o ambiente do processo atual.

   Para "execve()" em algumas plataformas, *path* também pode ser
   especificado como um descritor de arquivo aberto. Esta
   funcionalidade pode não ser compatível com sua plataforma; você
   pode verificar se está ou não disponível usando "os.supports_fd".
   Se não estiver disponível, usá-lo vai levantar uma
   "NotImplementedError".

   Disponibilidade: Unix, Windows.

   Novo na versão 3.3: Added support for specifying an open file
   descriptor for *path* for "execve()".

   Alterado na versão 3.6: Aceita um *path-like object*.

os._exit(n)

   Sai do processo com status *n*, sem chamar manipuladores de
   limpeza, liberando buffers de stdio etc.

   Nota:

     A forma padrão de sair é "sys.exit(n)". "_exit()" normalmente só
     deve ser usado no processo filho após uma função "fork()".

Os seguintes códigos de saída são definidos e podem ser usados com
"_exit()", embora não sejam obrigatórios. Eles são normalmente usados
para programas de sistema escritos em Python, como um programa de
entrega de comando externo de servidor de e-mail.

Nota:

  Alguns deles podem não estar disponíveis em todas as plataformas
  Unix, pois há algumas variações. Essas constantes são definidas onde
  são definidas pela plataforma subjacente.

os.EX_OK

   Código de saída que significa que ocorreu nenhum erro.

   Disponibilidade: Unix.

os.EX_USAGE

   Código de saída que significa que o comando foi usado
   incorretamente, como quando o número errado de argumentos é
   fornecido.

   Disponibilidade: Unix.

os.EX_DATAERR

   Código de saída que significa que os dados inseridos estavam
   incorretos.

   Disponibilidade: Unix.

os.EX_NOINPUT

   Código de saída que significa que um arquivo de entrada não existe
   ou não pôde ser lido.

   Disponibilidade: Unix.

os.EX_NOUSER

   Código de saída que significa que um usuário especificado não
   existe.

   Disponibilidade: Unix.

os.EX_NOHOST

   Código de saída que significa que um host especificado não existe.

   Disponibilidade: Unix.

os.EX_UNAVAILABLE

   Código de saída que significa que um serviço necessário está
   indisponível.

   Disponibilidade: Unix.

os.EX_SOFTWARE

   Código de saída que significa que um erro interno do software foi
   detectado.

   Disponibilidade: Unix.

os.EX_OSERR

   Código de saída que significa que um erro do sistema operacional
   foi detectado, como a incapacidade de fazer fork ou criar um
   encadeamento.

   Disponibilidade: Unix.

os.EX_OSFILE

   Código de saída que significa que algum arquivo do sistema não
   existia, não pôde ser aberto ou teve algum outro tipo de erro.

   Disponibilidade: Unix.

os.EX_CANTCREAT

   Código de saída que significa que um arquivo de saída especificado
   pelo usuário não pôde ser criado.

   Disponibilidade: Unix.

os.EX_IOERR

   Código de saída que significa que ocorreu um erro ao fazer E/S em
   algum arquivo.

   Disponibilidade: Unix.

os.EX_TEMPFAIL

   Código de saída que significa que ocorreu uma falha temporária.
   Isso indica algo que pode não ser realmente um erro, como uma
   conexão de rede que não pôde ser feita durante uma operação de nova
   tentativa.

   Disponibilidade: Unix.

os.EX_PROTOCOL

   Código de saída que significa que uma troca de protocolo foi
   ilegal, inválida ou não compreendida.

   Disponibilidade: Unix.

os.EX_NOPERM

   Código de saída que significa que não havia permissões suficientes
   para executar a operação (mas sem intenção de causar problemas do
   sistema de arquivos).

   Disponibilidade: Unix.

os.EX_CONFIG

   Código de saída que significa que ocorreu algum tipo de erro de
   configuração.

   Disponibilidade: Unix.

os.EX_NOTFOUND

   Código de saída que significa algo como "uma entrada não foi
   encontrada".

   Disponibilidade: Unix.

os.fork()

   Faz um fork de um processo filho. Retorna "0" no filho e o ID de
   processo do filho no pai. Se ocorrer um erro, uma "OSError" é
   levantada.

   Note that some platforms including FreeBSD <= 6.3 and Cygwin have
   known issues when using fork() from a thread.

   Aviso:

     Veja "ssl" para aplicações que usam o módulo SSL com fork().

   Disponibilidade: Unix.

os.forkpty()

   Faz um fork de um processo filho, usando um novo pseudoterminal
   como o terminal de controle do filho. Retorna um par de "(pid,
   fd)", onde *pid* é "0" no filho, o novo ID de processo do filho no
   pai e *fd* é o descritor de arquivo do lado mestre do
   pseudoterminal. Para uma abordagem mais portátil, use o módulo
   "pty". Se ocorrer um erro, "OSError" é levantada.

   Disponibilidade: alguns sabores de Unix

os.kill(pid, sig)

   Envia o sinal *sig* para o processo *pid*. Constantes dos sinais
   específicos disponíveis na plataforma host são definidas no módulo
   "signal".

   Windows: Os sinais "signal.CTRL_C_EVENT" e
   "signal.CTRL_BREAK_EVENT" são sinais especiais que só podem ser
   enviados para processos de console que compartilham uma janela de
   console comum, por exemplo, alguns subprocessos. Qualquer outro
   valor para *sig* fará com que o processo seja encerrado
   incondicionalmente pela API TerminateProcess e o código de saída
   será definido como *sig*. A versão Windows de "kill()"
   adicionalmente leva identificadores de processo para ser morto.

   Veja também "signal.pthread_kill()".

   Novo na versão 3.2: Suporte ao Windows.

os.killpg(pgid, sig)

   Envia o sinal *sig* para o grupo de processo *pgid*.

   Disponibilidade: Unix.

os.nice(increment)

   Adiciona *increment* ao nível de "nice" do processo. Retorna um
   novo nível de "nice".

   Disponibilidade: Unix.

os.plock(op)

   Bloqueia os segmentos do programa na memória. O valor de *op*
   (definido em "<sys/lock.h>") determina quais segmentos estão
   bloqueados.

   Disponibilidade: Unix.

os.popen(cmd, mode='r', buffering=-1)

   Abre um encadeamento, também conhecido como "pipe", de ou para o
   comando *cmd*. O valor de retorno é um objeto arquivo aberto
   conectado ao encadeamento, que pode ser lido ou escrito dependendo
   se *mode* é "'r'" (padrão) ou "'w'". O argumento *buffering* tem o
   mesmo significado que o argumento correspondente para a função
   embutida "open()". O objeto arquivo retornado lê ou escreve strings
   de texto em vez de bytes.

   O método "close" retorna "None" se o subprocesso foi encerrado com
   sucesso, ou o código de retorno do subprocesso se houve um erro. Em
   sistemas POSIX, se o código de retorno for positivo, ele representa
   o valor de retorno do processo deslocado para a esquerda em um
   byte. Se o código de retorno for negativo, o processo foi encerrado
   pelo sinal dado pelo valor negado do código de retorno. (Por
   exemplo, o valor de retorno pode ser "- signal.SIGKILL" se o
   subprocesso foi eliminado.) Em sistemas Windows, o valor de retorno
   contém o código de retorno inteiro com sinal do processo filho.

   Isso é implementado usando "subprocess.Popen"; consulte a
   documentação desta classe para maneiras mais poderosas de gerenciar
   e se comunicar com subprocessos.

os.spawnl(mode, path, ...)
os.spawnle(mode, path, ..., env)
os.spawnlp(mode, file, ...)
os.spawnlpe(mode, file, ..., env)
os.spawnv(mode, path, args)
os.spawnve(mode, path, args, env)
os.spawnvp(mode, file, args)
os.spawnvpe(mode, file, args, env)

   Executa o programa *path* em um novo processo.

   (Observe que o módulo "subprocess" fornece recursos mais poderosos
   para gerar novos processos e recuperar seus resultados; usar esse
   módulo é preferível a usar essas funções. Verifique especialmente a
   seção Replacing Older Functions with the subprocess Module.)

   Se *mode* for "P_NOWAIT", esta função retorna o id do processo do
   novo processo; se *mode* for "P_WAIT", retorna o código de saída do
   processo se ele sair normalmente, ou "-signal", onde *signal* é o
   sinal que matou o processo. No Windows, o id de processo será na
   verdade o identificador do processo, portanto, pode ser usado com a
   função "waitpid()".

   As variantes "l" e "v" das funções "spawn*" diferem em como os
   argumentos de linha de comando são passados. As variantes "l" são
   talvez as mais fáceis de trabalhar se o número de parâmetros for
   fixo quando o código for escrito; os parâmetros individuais
   simplesmente se tornam parâmetros adicionais para as funções
   "spawnl*()". As variantes "v" são boas quando o número de
   parâmetros é variável, com os argumentos sendo passados em uma
   lista ou tupla como o parâmetro *args*. Em ambos os casos, os
   argumentos para o processo filho devem começar com o nome do
   comando que está sendo executado.

   As variantes que incluem um segundo "p" próximo ao final
   ("spawnlp()", "spawnlpe()", "spawnvp()" e "spawnvpe()") usarão a
   variável de ambiente "PATH" para localizar o programa *file*.
   Quando o ambiente está sendo substituído (usando uma das variantes
   "spawn*e", discutidas no próximo parágrafo), o novo ambiente é
   usado como fonte da variável "PATH" As outras variantes,
   "spawnl()", "spawnle()", "spawnv()" e "spawnve()", não usarão a
   variável "PATH" para localizar o executável; *path* deve conter um
   caminho absoluto ou relativo apropriado.

   Para "spawnle()", "spawnlpe()", "spawnve()" e "spawnvpe()" (observe
   que todos eles terminam em "e"), o parâmetro *env* deve ser um
   mapeamento que é usado para definir as variáveis de ambiente para o
   novo processo (elas são usadas no lugar do ambiente do processo
   atual); as funções "spawnl()", "spawnlp()", "spawnv()" e
   "spawnvp()" fazem com que o novo processo herde o ambiente do
   processo atual. Note que as chaves e os valores no dicionário *env*
   devem ser strings; chaves ou valores inválidos farão com que a
   função falhe, com um valor de retorno de "127".

   Como exemplo, as seguintes chamadas a "spawnlp()" e "spawnvpe()"
   são equivalentes:

      import os
      os.spawnlp(os.P_WAIT, 'cp', 'cp', 'index.html', '/dev/null')

      L = ['cp', 'index.html', '/dev/null']
      os.spawnvpe(os.P_WAIT, 'cp', L, os.environ)

   Availability: Unix, Windows.  "spawnlp()", "spawnlpe()",
   "spawnvp()" and "spawnvpe()" are not available on Windows.
   "spawnle()" and "spawnve()" are not thread-safe on Windows; we
   advise you to use the "subprocess" module instead.

   Alterado na versão 3.6: Aceita um *path-like object*.

os.P_NOWAIT
os.P_NOWAITO

   Valores possíveis para o parâmetro *mode* para a família de funções
   "spawn*". Se qualquer um desses valores for fornecido, as funções
   "spawn*()" retornarão assim que o novo processo for criado, com o
   id do processo como o valor de retorno.

   Disponibilidade: Unix, Windows.

os.P_WAIT

   Valor possível para o parâmetro *mode* para a família de funções
   "spawn*". Se for fornecido como *mode*, as funções "spawn*()" não
   retornarão até que o novo processo seja executado até a conclusão e
   retornará o código de saída do processo em que a execução foi bem-
   sucedida, ou "-signal" se um sinal interromper o processo.

   Disponibilidade: Unix, Windows.

os.P_DETACH
os.P_OVERLAY

   Valores possíveis do o parâmetro *mode* para a família de funções
   "spawn*". Eles são menos portáteis do que os listados acima.
   "P_DETACH" é semelhante a "P_NOWAIT", mas o novo processo é
   separado do console do processo de chamada. Se "P_OVERLAY" for
   usado, o processo atual será substituído; a função "spawn*" não
   retornará.

   Availability: Windows.

os.startfile(path[, operation])

   Inicia um arquivo com sua aplicação associada.

   Quando *operation* não é especificado ou não está "'open'", isso
   atua como um clique duplo no arquivo no Windows Explorer, ou como
   fornecer o nome do arquivo como um argumento para o comando
   **start** do console interativo de comandos: o arquivo é aberto com
   qualquer aplicação (se houver) com a extensão associada.

   Quando outra *operation* é fornecida, ela deve ser um "verbo de
   comando" que especifica o que deve ser feito com o arquivo. Verbos
   comuns documentados pela Microsoft são "'print'" e "'edit'" (para
   serem usados em arquivos), bem como "'explore'" e "'find'" (para
   serem usados em diretórios).

   "startfile()" retorna assim que a aplicação associada é iniciada.
   Não há opção de aguardar o fechamento da aplicação e nenhuma
   maneira de recuperar o status de saída da aplicação. O parâmetro
   *path* é relativo ao diretório atual. Se você quiser usar um
   caminho absoluto, certifique-se de que o primeiro caractere não
   seja uma barra ("'/'"); a função Win32 "ShellExecute()" subjacente
   não funciona se for. Use a função "os.path.normpath()" para
   garantir que o caminho esteja devidamente codificado para Win32.

   Para reduzir a sobrecarga de inicialização do interpretador, a
   função Win32 "ShellExecute()" não é resolvida até que esta função
   seja chamada pela primeira vez. Se a função não puder ser
   resolvida, "NotImplementedError" será levantada.

   Availability: Windows.

os.system(command)

   Executa o comando (uma string) em um subshell. Isso é implementado
   chamando a função C padrão "system()", e tem as mesmas limitações.
   Alterações em "sys.stdin" etc. não são refletidas no ambiente do
   comando executado. Se *command* gerar qualquer saída, ela será
   enviada ao fluxo de saída padrão do interpretador.

   No Unix, o valor de retorno é o status de saída do processo
   codificado no formato especificado para "wait()". Observe que POSIX
   não especifica o significado do valor de retorno da função C
   "system()", então o valor de retorno da função Python é dependente
   do sistema.

   No Windows, o valor de retorno é aquele retornado pelo shell do
   sistema após a execução de *command*. O shell é fornecido pela
   variável de ambiente Windows "COMSPEC": normalmente é **cmd.exe**,
   que retorna o status de saída da execução do comando; em sistemas
   que usam um shell não nativo, consulte a documentação do shell.

   O módulo "subprocess" fornece recursos mais poderosos para gerar
   novos processos e recuperar seus resultados; usar esse módulo é
   preferível a usar esta função. Veja a seção Replacing Older
   Functions with the subprocess Module na documentação do
   "subprocess" para algumas receitas úteis.

   Disponibilidade: Unix, Windows.

os.times()

   Retorna os tempos atuais de processo globais. O valor de retorno é
   um objeto com cinco atributos:

   * "user" - tempo do usuário

   * "system" - tempo do sistema

   * "children_user" - tempo do usuário de todos os processo filhos

   * "children_system" - tempo do sistema de todos os processo filhos

   * "elapsed" - tempo real decorrido desde um ponto fixo no passado

   Para compatibilidade com versões anteriores, esse objeto também se
   comporta como uma tupla de 5 elementos contendo "user", "system",
   "children_user", "children_system" e "elapsed`" nessa ordem.

   See the Unix manual page *times(2)* or the corresponding Windows
   Platform API documentation. On Windows, only "user" and "system"
   are known; the other attributes are zero.

   Disponibilidade: Unix, Windows.

   Alterado na versão 3.3: Retorna tupla alterada de uma tupla para um
   objeto tipo tupla com atributos nomeados.

os.wait()

   Aguarda a conclusão de um processo filho e retorna uma tupla
   contendo seu pid e indicação de status de saída: um número de 16
   bits, cujo byte baixo é o número do sinal que matou o processo e
   cujo byte alto é o status de saída (se o sinal número é zero); o
   bit alto do byte baixo é definido se um arquivo principal foi
   produzido.

   Disponibilidade: Unix.

os.waitid(idtype, id, options)

   Wait for the completion of one or more child processes. *idtype*
   can be "P_PID", "P_PGID" or "P_ALL". *id* specifies the pid to wait
   on. *options* is constructed from the ORing of one or more of
   "WEXITED", "WSTOPPED" or "WCONTINUED" and additionally may be ORed
   with "WNOHANG" or "WNOWAIT". The return value is an object
   representing the data contained in the "siginfo_t" structure,
   namely: "si_pid", "si_uid", "si_signo", "si_status", "si_code" or
   "None" if "WNOHANG" is specified and there are no children in a
   waitable state.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.P_PID
os.P_PGID
os.P_ALL

   Estes são os valores possíveis para *idtype* em "waitid()". Eles
   afetam como *id* é interpretado.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.WEXITED
os.WSTOPPED
os.WNOWAIT

   Sinalizadores que podem ser usados em *options* em "waitid()" que
   especificam por qual sinal filho esperar.

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.CLD_EXITED
os.CLD_DUMPED
os.CLD_TRAPPED
os.CLD_CONTINUED

   Estes são os valores possíveis para "si_code" no resultado
   retornado por "waitid()".

   Disponibilidade: Unix.

   Novo na versão 3.3.

os.waitpid(pid, options)

   Os detalhes desta função diferem no Unix e no Windows.

   No Unix: Aguarda a conclusão de um processo filho dado pelo id de
   processo *pid* e retorna uma tupla contendo seu id de processo e
   indicação de status de saída (codificado como para "wait()"). A
   semântica da chamada é afetada pelo valor do inteiro *options*, que
   deve ser "0" para operação normal.

   Se *pid  for maior que ``0``, :func:`waitpid` solicita informações
   de status para aquele processo específico. Se *pid* for "0", a
   solicitação é para o status de qualquer filho no grupo de processos
   do processo atual. Se *pid* for "-1", a solicitação pertence a
   qualquer filho do processo atual. Se *pid* for menor que "-1", o
   status é solicitado para qualquer processo no grupo de processos
   "-pid" (o valor absoluto de *pid*).

   Uma "OSError" é levantada com o valor de errno quando a chamada de
   sistema retorna -1.

   No Windows: Aguarda a conclusão de um processo fornecido pelo
   identificador de processo *pid* e retorna uma tupla contendo *pid*,
   e seu status de saída deslocado 8 bits para a esquerda (o
   deslocamento torna o uso da função em várias plataformas mais
   fácil). Um *pid* menor ou igual a "0" não tem nenhum significado
   especial no Windows e levanta uma exceção. O valor de inteiros
   *options* não tem efeito. *pid* pode se referir a qualquer processo
   cujo id é conhecido, não necessariamente um processo filho. As
   funções "spawn*" chamadas com "P_NOWAIT" retornam manipuladores de
   processo adequados.

   Alterado na versão 3.5: Se a chamada de sistema é interrompida e o
   tratador de sinal não levanta uma exceção, a função agora tenta
   novamente a chamada de sistema em vez de levantar uma exceção
   "InterruptedError" (consulte **PEP 475** para entender a lógica).

os.wait3(options)

   Semelhante a "waitpid()", exceto que nenhum argumento de id de
   processo é fornecido e uma tupla de 3 elementos contendo a id do
   processo da criança, indicação de status de saída e informações de
   uso de recursos é retornada. Consulte "resource"."getrusage()" para
   obter detalhes sobre as informações de uso de recursos. O argumento
   da opção é o mesmo fornecido para "waitpid()" e "wait4()".

   Disponibilidade: Unix.

os.wait4(pid, options)

   Semelhante a "waitpid()", exceto uma tupla de 3 elementos, contendo
   a id do processo da filho, indicação de status de saída e
   informações de uso de recursos é retornada. Consulte
   "resource"."getrusage()" para obter detalhes sobre as informações
   de uso de recursos. Os argumentos para "wait4()" são os mesmos que
   aqueles fornecidos a "waitpid()".

   Disponibilidade: Unix.

os.WNOHANG

   A opção para "waitpid()" retornar imediatamente se nenhum status de
   processo filho estiver disponível imediatamente. A função retorna
   "(0, 0)" neste caso.

   Disponibilidade: Unix.

os.WCONTINUED

   Esta opção faz com que os processos filhos sejam relatados se eles
   foram continuados a partir de uma parada de controle de tarefa
   desde que seu status foi relatado pela última vez.

   Availability: some Unix systems.

os.WUNTRACED

   Esta opção faz com que os processos filhos sejam relatados se eles
   tiverem sido interrompidos, mas seu estado atual não foi relatado
   desde que foram interrompidos.

   Disponibilidade: Unix.

As funções a seguir recebem um código de status do processo conforme
retornado por "system()", "wait()" ou "waitpid()" como parâmetro. Eles
podem ser usados ​​para determinar a disposição de um processo.

os.WCOREDUMP(status)

   Retorna "True" se um despejo de núcleo *(core dump)* foi gerado
   para o processo; caso contrário, retorna "False".

   Disponibilidade: Unix.

os.WIFCONTINUED(status)

   Return "True" if the process has been continued from a job control
   stop, otherwise return "False".

   Disponibilidade: Unix.

os.WIFSTOPPED(status)

   Return "True" if the process has been stopped, otherwise return
   "False".

   Disponibilidade: Unix.

os.WIFSIGNALED(status)

   Return "True" if the process exited due to a signal, otherwise
   return "False".

   Disponibilidade: Unix.

os.WIFEXITED(status)

   Return "True" if the process exited using the *exit(2)* system
   call, otherwise return "False".

   Disponibilidade: Unix.

os.WEXITSTATUS(status)

   If "WIFEXITED(status)" is true, return the integer parameter to the
   *exit(2)* system call.  Otherwise, the return value is meaningless.

   Disponibilidade: Unix.

os.WSTOPSIG(status)

   Retorna o sinal que causou a interrupção do processo.

   Disponibilidade: Unix.

os.WTERMSIG(status)

   Return the signal which caused the process to exit.

   Disponibilidade: Unix.


16.1.7. Interface do agendador
==============================

Essas funções controlam como o tempo de CPU de um processo é alocado
pelo sistema operacional. Eles estão disponíveis apenas em algumas
plataformas Unix. Para informações mais detalhadas, consulte suas
páginas man do Unix.

Novo na versão 3.3.

As políticas de agendamento a seguir serão expostas se houver suporte
pelo sistema operacional.

os.SCHED_OTHER

   A política de agendamento padrão.

os.SCHED_BATCH

   Política de agendamento para processos com uso intensivo de CPU que
   tenta preservar a interatividade no resto do computador.

os.SCHED_IDLE

   Política de agendamento para tarefas em segundo plano de prioridade
   extremamente baixa.

os.SCHED_SPORADIC

   Política de agendamento para programas de servidor esporádicos.

os.SCHED_FIFO

   Uma política de agendamento Primeiro a Entrar, Primeiro a Sair
   (FIFO).

os.SCHED_RR

   Uma política de agendamento round-robin.

os.SCHED_RESET_ON_FORK

   Este sinalizador pode ser operado em OU com qualquer outra política
   de agendamento. Quando um processo com este sinalizador definido
   bifurca, a política de agendamento e a prioridade de seu filho são
   redefinidas para o padrão.

class os.sched_param(sched_priority)

   Esta classe representa parâmetros de agendamento ajustáveis
   ​​usados ​​em "sched_setparam()", "sched_setscheduler()" e
   "sched_getparam()". É imutável.

   Neste momento, há somente um único parâmetro possível:

   sched_priority

      A prioridade de agendamento para uma política de agendamento.

os.sched_get_priority_min(policy)

   Obtém o valor mínimo de prioridade para *policy*. *policy* é uma
   das constantes de política de agendamento acima.

os.sched_get_priority_max(policy)

   Obtém o valor máximo de prioridade para *policy*. *policy* é uma
   das constantes de política de agendamento acima.

os.sched_setscheduler(pid, policy, param)

   Define a política de agendamento para o processo com PID *pid*. Um
   *pid* de 0 significa o processo de chamada. *policy* é uma das
   constantes de política de agendamento acima. *param* é uma
   instância de "sched_param".

os.sched_getscheduler(pid)

   Retorna a política de agendamento para o processo com PID *pid*. Um
   *pid* de 0 significa o processo de chamada. O resultado é uma das
   constantes de política de agendamento acima.

os.sched_setparam(pid, param)

   Define os parâmetros de agendamento para o processo com PID *pid*.
   Um *pid* de 0 significa o processo de chamada. *param* é uma
   instância de "sched_param".

os.sched_getparam(pid)

   Retorna os parâmetros de agendamento como uma instância de
   "sched_param" para o processo com PID *pid*. Um *pid* de 0
   significa o processo de chamada.

os.sched_rr_get_interval(pid)

   Retorna o quantum round-robin em segundos para o processo com PID
   *pid*. Um *pid* de 0 significa o processo de chamada.

os.sched_yield()

   Libera a CPU voluntariamente.

os.sched_setaffinity(pid, mask)

   Restringe o processo com PID *pid* (ou o processo atual se zero)
   para um conjunto de CPUs. *mask* é um iterável de inteiros que
   representam o conjunto de CPUs às quais o processo deve ser
   restrito.

os.sched_getaffinity(pid)

   Retorna o conjunto de CPUs ao qual o processo com PID *pid* (ou o
   processo atual se zero) está restrito.


16.1.8. Diversas Informações de Sistema
=======================================

os.confstr(name)

   Retorna valores de configuração do sistema com valor de string.
   *name* especifica o valor de configuração a ser recuperado; pode
   ser uma string que é o nome de um valor de sistema definido; esses
   nomes são especificados em vários padrões (POSIX, Unix 95, Unix 98
   e outros). Algumas plataformas também definem nomes adicionais. Os
   nomes conhecidos pelo sistema operacional host são fornecidos como
   as chaves do dicionário "confstr_names". Para variáveis ​​de
   configuração não incluídas nesse mapeamento, passar um número
   inteiro para *name* também é aceito.

   Se o valor de configuração especificado por *name* não for
   definido, retorna "None".

   Se *name* for uma string e não for conhecida, "ValueError" é
   levantada. Se um valor específico para *name* não for compatível
   com o sistema de host, mesmo que seja incluído em "confstr_names",
   uma "OSError" é levantada com "errno.EINVAL" como número do erro.

   Disponibilidade: Unix.

os.confstr_names

   Nomes de mapeamento de dicionário aceitos por "confstr()" para os
   valores inteiros definidos para esses nomes pelo sistema
   operacional do host. Isso pode ser usado para determinar o conjunto
   de nomes conhecidos pelo sistema.

   Disponibilidade: Unix.

os.cpu_count()

   Retorna o número de CPUs do sistema. Retorna "None" se não
   determinado.

   Este número não é equivalente ao número de CPUs que o processo
   atual pode usar. O número de CPUs utilizáveis ​​pode ser obtido com
   "len(os.sched_getaffinity(0))"

   Novo na versão 3.4.

os.getloadavg()

   Retorna o número de processos na fila de execução do sistema em
   média nos últimos 1, 5 e 15 minutos ou levanta "OSError" se a média
   de carga não foi obtida.

   Disponibilidade: Unix.

os.sysconf(name)

   Retorna valores de configuração do sistema com valor inteiro. Se o
   valor de configuração especificado por *name* não estiver definido,
   "-1" é retornado. Os comentários sobre o parâmetro *name* para
   "confstr()" se aplicam aqui também; o dicionário que fornece
   informações sobre os nomes conhecidos é fornecido por
   "sysconf_names".

   Disponibilidade: Unix.

os.sysconf_names

   Nomes de mapeamento de dicionário aceitos por "sysconf()" para os
   valores inteiros definidos para esses nomes pelo sistema
   operacional do host. Isso pode ser usado para determinar o conjunto
   de nomes conhecidos pelo sistema.

   Disponibilidade: Unix.

Os dados a seguir são usados para suportar operações de manipulação de
path. Estão definidos e disponíveis para todas as plataformas.

Operações de nível mais alto em nomes de caminho são definidos no
módulo "os.path".

os.curdir

   A string constante usada pelo sistema operacional para se referir
   ao diretório atual. Isso é "'.'" para Windows e POSIX. Também
   disponível via "os.path".

os.pardir

   A string constante usada pelo sistema operacional para se referir
   ao diretório pai. Isso é "'..'" para Windows e POSIX. Também
   disponível via "os.path".

os.sep

   O caractere usado pelo sistema operacional para separar os
   componentes do nome do caminho. Este é "'/'" para POSIX e "'\\'"
   para Windows. Observe que saber disso não é suficiente para ser
   capaz de analisar ou concatenar nomes de caminho -- use
   "os.path.split()" e "os.path.join()" -- mas ocasionalmente é útil.
   Também disponível via "os.path".

os.altsep

   Um caractere alternativo usado pelo sistema operacional para
   separar os componentes do nome de caminho, ou "None" se apenas um
   caractere separador existir. Isso é definido como "'/'" em sistemas
   Windows onde "sep" é uma contrabarra. Também disponível via
   "os.path".

os.extsep

   O caractere que separa o nome do arquivo base da extensão; por
   exemplo, o "'.'" em "os.py". Também disponível via "os.path".

os.pathsep

   O caractere convencionalmente usado pelo sistema operacional para
   separar os componentes do caminho de pesquisa (como em "PATH"),
   como "':'" para POSIX ou "';'" para Windows. Também disponível via
   "os.path".

os.defpath

   O caminho de pesquisa padrão usado por "exec*p*" e "spawn*p*" se o
   ambiente não tiver uma chave "'PATH'". Também disponível via
   "os.path".

os.linesep

   A string usada para separar (ou melhor, encerrar) linhas na
   plataforma atual. Pode ser um único caractere, como "'\n'" para
   POSIX, ou múltiplos caracteres, por exemplo, "'\r\n'" para Windows.
   Não use *os.linesep* como terminador de linha ao escrever arquivos
   abertos em modo de texto (o padrão); use um único "'\n'" ao invés,
   em todas as plataformas.

os.devnull

   O caminho do arquivo do dispositivo nulo. Por exemplo:
   "'/dev/null'" para POSIX, "'nul'" para Windows. Também disponível
   via "os.path".

os.RTLD_LAZY
os.RTLD_NOW
os.RTLD_GLOBAL
os.RTLD_LOCAL
os.RTLD_NODELETE
os.RTLD_NOLOAD
os.RTLD_DEEPBIND

   Sinalizadores para uso com as funções "setdlopenflags()" e
   "getdlopenflags()". Veja a página man do Unix *dlopen(3)* para
   saber o que significam os diferentes sinalizadores.

   Novo na versão 3.3.


16.1.9. Números aleatórios
==========================

os.getrandom(size, flags=0)

   Obtém até *size* bytes aleatórios. Esta função pode retornar menos
   bytes que a quantia requisitada.

   Esses bytes podem ser usados ​​para propagar geradores de número
   aleatório no espaço do usuário ou para fins criptográficos.

   "getrandom()" depende da entropia obtida de drivers de dispositivos
   e outras fontes de ruído ambiental. A leitura desnecessária de
   grandes quantidades de dados terá um impacto negativo sobre outros
   usuários dos dispositivos "/dev/random" e "/dev/urandom".

   O argumento sinalizadores é uma máscara de bits que pode conter
   zero ou mais dos seguintes valores operados com OU juntos:
   "os.GRND_RANDOM" e "GRND_NONBLOCK".

   Veja também A página do manual do Linux sobre getrandom().

   Disponibilidade: Linux 3.17 e mais novos.

   Novo na versão 3.6.

os.urandom(size)

   Retorna uma string de *size* bytes aleatórios próprios para uso
   criptográfico.

   Esta função retorna bytes aleatórios de uma fonte de aleatoriedade
   específica do sistema operacional. Os dados retornados devem ser
   imprevisíveis o suficiente para aplicações criptográficos, embora
   sua qualidade exata dependa da implementação do sistema
   operacional.

   No Linux, se a chamada de sistema "getrandom()" estiver disponível,
   ela é usada no modo bloqueante: bloqueia até que o pool de entropia
   urandom do sistema seja inicializado (128 bits de entropia são
   coletados pelo kernel). Veja a **PEP 524** para a justificativa. No
   Linux, a função "getrandom()" pode ser usada para obter bytes
   aleatórios no modo não bloqueante (usando a sinalização
   "GRND_NONBLOCK") ou para pesquisar até que o pool de entropia
   urandom do sistema seja inicializado.

   Em um sistema semelhante ao Unix, bytes aleatórios são lidos do
   dispositivo "/dev/urandom". Se o dispositivo "/dev/urandom" não
   estiver disponível ou não for legível, a exceção
   "NotImplementedError" é levantada.

   No Windows, será usado "CryptGenRandom()".

   Ver também:

     O módulo "secrets" fornece funções de nível mais alto. Para uma
     interface fácil de usar para o gerador de números aleatórios
     fornecido por sua plataforma, consulte "random.SystemRandom".

   Alterado na versão 3.6.0: No Linux, "getrandom()" é usado agora no
   modo de bloqueio para aumentar a segurança.

   Alterado na versão 3.5.2: No Linux, se a chamada de sistema
   "getrandom()" bloqueia (o pool de entropia urandom ainda não foi
   inicializado), recorre à leitura "/dev/urandom".

   Alterado na versão 3.5: No Linux 3.17 e mais recente, a chamada de
   sistema "getrandom()" agora é usada quando disponível. No OpenBSD
   5.6 e mais recentes, a função C "getentropy()" agora é usada. Essas
   funções evitam o uso de um descritor de arquivo interno.

os.GRND_NONBLOCK

   Por padrão, ao ler de "/dev/random", "getrandom()" bloqueia se
   nenhum byte aleatório estiver disponível, e ao ler de
   "/dev/urandom", ele bloqueia se o pool de entropia não ainda foi
   inicializado.

   Se o sinalizador "GRND_NONBLOCK" estiver definido, então
   "getrandom()" não bloqueia nesses casos, mas, em vez disso, levanta
   "BlockingIOError" imediatamente.

   Novo na versão 3.6.

os.GRND_RANDOM

   Se este bit é definido bytes aleatórios são pegos a partir de
   "/dev/random" ao invés de "/dev/urandom".

   Novo na versão 3.6.
