Atalhos orientados a objetos

Este capítulo fala em detalhes sobre as várias funções embutidas no Python, operações de I / O de arquivo e conceitos de sobrecarga.

Funções integradas do Python

O interpretador Python tem várias funções chamadas funções integradas que estão prontamente disponíveis para uso. Em sua versão mais recente, Python contém 68 funções integradas, conforme listado na tabela abaixo -

FUNÇÕES INTEGRADAS
abdômen()	dict ()	Socorro()	min ()	setattr ()
todos()	dir ()	hex ()	Próximo()	fatia()
qualquer()	divmod ()	Eu iria()	objeto()	classificado ()
ascii ()	enumerar()	entrada()	out ()	staticmethod ()
bin ()	eval ()	int ()	abrir()	str ()
bool ()	exec ()	isinstance ()	ord ()	soma()
bytearray ()	filtro()	issubclass ()	Pancada()	super()
bytes ()	flutuador()	iter ()	impressão()	tupla ()
chamável ()	formato()	len ()	propriedade()	tipo()
chr ()	Frozenset ()	Lista()	alcance()	vars ()
classmethod ()	getattr ()	locais ()	repr ()	fecho eclair()
compilar()	globais ()	mapa()	invertido ()	__importar__()
complexo()	hasattr ()	max ()	volta()
delattr ()	cerquilha()	memoryview ()	conjunto()

Esta seção discute algumas das funções importantes em breve -

função len ()

A função len () obtém o comprimento de strings, lista ou coleções. Ele retorna o comprimento ou o número de itens de um objeto, onde o objeto pode ser uma string, uma lista ou uma coleção.

>>> len(['hello', 9 , 45.0, 24])
4

a função len () funciona internamente como list.__len__() ou tuple.__len__(). Assim, observe que len () funciona apenas em objetos que têm um __len__() método.

>>> set1
{1, 2, 3, 4}
>>> set1.__len__()
4

No entanto, na prática, preferimos len() ao invés de __len__() funcionar pelos seguintes motivos -

• É mais eficiente. E não é necessário que um método específico seja escrito para recusar o acesso a métodos especiais, como __len__.

• É fácil de manter.

• Ele suporta compatibilidade com versões anteriores.

Invertido (seq)

Ele retorna o iterador reverso. seq deve ser um objeto que possui o método __reversed __ () ou suporta o protocolo de seqüência (o método __len __ () e o método __getitem __ ()). Geralmente é usado emfor loops quando queremos fazer um loop sobre itens de trás para frente.

>>> normal_list = [2, 4, 5, 7, 9]
>>>
>>> class CustomSequence():
   def __len__(self):
      return 5
   def __getitem__(self,index):
      return "x{0}".format(index)
>>> class funkyback():
   def __reversed__(self):
      return 'backwards!'
>>> for seq in normal_list, CustomSequence(), funkyback():
      print('\n{}: '.format(seq.__class__.__name__), end="")
      for item in reversed(seq):
         print(item, end=", ")

O loop for no final imprime a lista reversa de uma lista normal e as instâncias das duas sequências personalizadas. A saída mostra quereversed() funciona em todos os três, mas tem resultados muito diferentes quando definimos __reversed__.

Resultado

Você pode observar a seguinte saída ao executar o código fornecido acima -

list: 9, 7, 5, 4, 2,
CustomSequence: x4, x3, x2, x1, x0,
funkyback: b, a, c, k, w, a, r, d, s, !,

Enumerar

o enumerate () método adiciona um contador a um iterável e retorna o objeto enumerado.

A sintaxe de enumerate () é -

enumerate(iterable, start = 0)

Aqui o segundo argumento start é opcional e, por padrão, o índice começa com zero (0).

>>> # Enumerate
>>> names = ['Rajesh', 'Rahul', 'Aarav', 'Sahil', 'Trevor']
>>> enumerate(names)
<enumerate object at 0x031D9F80>
>>> list(enumerate(names))
[(0, 'Rajesh'), (1, 'Rahul'), (2, 'Aarav'), (3, 'Sahil'), (4, 'Trevor')]
>>>

então enumerate()retorna um iterador que produz uma tupla que mantém a contagem dos elementos na sequência passada. Como o valor de retorno é um iterador, acessá-lo diretamente não é muito útil. Uma abordagem melhor para enumerate () é manter a contagem em um loop for.

>>> for i, n in enumerate(names):
   print('Names number: ' + str(i))
   print(n)
Names number: 0
Rajesh
Names number: 1
Rahul
Names number: 2
Aarav
Names number: 3
Sahil
Names number: 4
Trevor

Existem muitas outras funções na biblioteca padrão, e aqui está outra lista de algumas funções mais utilizadas -

• hasattr, getattr, setattr e delattr, que permite que atributos de um objeto sejam manipulados por seus nomes de string.

• all e any, que aceitam um objeto iterável e retornam True se todos, ou algum, dos itens forem avaliados como verdadeiros.

• nzip, que pega duas ou mais sequências e retorna uma nova sequência de tuplas, onde cada tupla contém um único valor de cada sequência.

E / S de arquivo

O conceito de arquivos está associado ao termo programação orientada a objetos. Python envolveu a interface fornecida pelos sistemas operacionais em abstração que nos permite trabalhar com objetos de arquivo.

o open()A função embutida é usada para abrir um arquivo e retornar um objeto de arquivo. É a função mais comumente usada com dois argumentos -

open(filename, mode)

A função open () chama dois argumentos, o primeiro é o nome do arquivo e o segundo é o modo. Aqui, o modo pode ser 'r' para modo somente leitura, 'w' apenas para gravação (um arquivo existente com o mesmo nome será apagado) e 'a' abre o arquivo para anexar, quaisquer dados gravados no arquivo são adicionados automaticamente até o fim. 'r +' abre o arquivo para leitura e gravação. O modo padrão é somente leitura.

No Windows, 'b' anexado ao modo abre o arquivo no modo binário, portanto, também existem modos como 'rb', 'wb' e 'r + b'.

>>> text = 'This is the first line'
>>> file = open('datawork','w')
>>> file.write(text)
22
>>> file.close()

Em alguns casos, queremos apenas anexar ao arquivo existente em vez de sobrescrevê-lo, para isso poderíamos fornecer o valor 'a' como um argumento de modo, para anexar ao final do arquivo, em vez de sobrescrever completamente o arquivo existente conteúdo.

>>> f = open('datawork','a')
>>> text1 = ' This is second line'
>>> f.write(text1)
20
>>> f.close()

Depois que um arquivo é aberto para leitura, podemos chamar o método read, readline ou readlines para obter o conteúdo do arquivo. O método read retorna todo o conteúdo do arquivo como um objeto str ou bytes, dependendo se o segundo argumento é 'b'.

Para facilitar a leitura e evitar a leitura de um arquivo grande de uma vez, geralmente é melhor usar um loop for diretamente em um objeto de arquivo. Para arquivos de texto, ele lerá cada linha, uma de cada vez, e podemos processá-la dentro do corpo do loop. Para arquivos binários, no entanto, é melhor ler blocos de dados de tamanho fixo usando o método read (), passando um parâmetro para o número máximo de bytes a serem lidos.

>>> f = open('fileone','r+')
>>> f.readline()
'This is the first line. \n'
>>> f.readline()
'This is the second line. \n'

Gravar em um arquivo, por meio do método write em objetos de arquivo, gravará um objeto string (bytes para dados binários) no arquivo. O método writelines aceita uma sequência de strings e grava cada um dos valores iterados no arquivo. O método writelines não acrescenta uma nova linha após cada item na sequência.

Finalmente, o método close () deve ser chamado quando terminarmos de ler ou escrever o arquivo, para garantir que qualquer gravação em buffer seja gravada no disco, que o arquivo tenha sido devidamente limpo e que todos os recursos vinculados ao arquivo sejam liberados de volta para o sistema operacional. É uma abordagem melhor chamar o método close (), mas tecnicamente isso acontecerá automaticamente quando o script existir.

Uma alternativa para sobrecarga de método

A sobrecarga de método refere-se a vários métodos com o mesmo nome que aceitam diferentes conjuntos de argumentos.

Dado um único método ou função, podemos especificar o número de parâmetros nós mesmos. Dependendo da definição da função, ela pode ser chamada com zero, um, dois ou mais parâmetros.

class Human:
   def sayHello(self, name = None):
      if name is not None:
         print('Hello ' + name)
      else:
         print('Hello ')

#Create Instance
obj = Human()

#Call the method, else part will be executed
obj.sayHello()

#Call the method with a parameter, if part will be executed
obj.sayHello('Rahul')

Resultado

Hello
Hello Rahul

Argumentos Padrão

Funções também são objetos

Um objeto chamável é um objeto que pode aceitar alguns argumentos e possivelmente retornará um objeto. Uma função é o objeto chamável mais simples em Python, mas existem outros também como classes ou certas instâncias de classe.

Cada função em um Python é um objeto. Os objetos podem conter métodos ou funções, mas o objeto não é uma função necessária.

def my_func():
   print('My function was called')
my_func.description = 'A silly function'
def second_func():

   print('Second function was called')

   second_func.description = 'One more sillier function'

def another_func(func):
   print("The description:", end=" ")
   print(func.description)
   print('The name: ', end=' ')
   print(func.__name__)
   print('The class:', end=' ')
   print(func.__class__)
   print("Now I'll call the function passed in")
   func()

another_func(my_func)
another_func(second_func)

No código acima, somos capazes de passar duas funções diferentes como argumento para a nossa terceira função e obter saídas diferentes para cada uma -

The description: A silly function
The name: my_func
The class: 
      
        Now I'll call the function passed in My function was called The description: One more sillier function The name: second_func The class: 
       
         Now I'll call the function passed in Second function was called 
       
      

callable objects

Just as functions are objects that can have attributes set on them, it is possible to create an object that can be called as though it were a function.

In Python any object with a __call__() method can be called using function-call syntax.