📌  相关文章
📜  面向对象的快捷方式

📅  最后修改于: 2021-01-04 04:42:29             🧑  作者: Mango

本章详细讨论Python的各种内置函数，文件I / O操作和重载概念。

Python内置函数

Python解释器具有许多称为内置函数的函数，可以随时使用。在最新版本中， Python包含68个内置函数，如下表所示-

BUILT-IN FUNCTIONS
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
delattr() hash() memoryview() set()

本节简要讨论一些重要功能-

len()函数

len()函数获取字符串，列表或集合的长度。它返回对象的长度或项目数，其中object可以是字符串，列表或集合。

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

len()函数内部类似于list .__ len __()或tuple .__ len __() 。因此，请注意len()仅适用于具有__ len __()方法的对象。

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

但是，实际上，由于以下原因，我们更喜欢len()而不是__len __()函数-

  • 效率更高。而且，不必编写特定方法来拒绝访问诸如__len__之类的特殊方法。

  • 易于维护。

  • 它支持向后兼容。

反转(seq)

它返回反向迭代器。 seq必须是具有__reversed __()方法或支持序列协议(__len __()方法和__getitem __()方法)的对象。当我们想从头到尾遍历项目时，通常用于for循环。

>>> 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=", ")

最后的for循环显示正常列表的反向列表以及两个自定义序列的实例。输出结果表明reversed()对这三个函数均有效，但是当我们定义__reversed__时，结果却大不相同。

输出

执行上面给出的代码时，您可以观察到以下输出：

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

枚举

enumerate()方法向可迭代对象添加一个计数器，并返回枚举对象。

枚举()的语法是-

enumerate(iterable, start = 0)

在这里，第二个参数start是可选的，默认情况下，索引以零(0)开头。

>>> # Enumerate
>>> names = ['Rajesh', 'Rahul', 'Aarav', 'Sahil', 'Trevor']
>>> enumerate(names)

>>> list(enumerate(names))
[(0, 'Rajesh'), (1, 'Rahul'), (2, 'Aarav'), (3, 'Sahil'), (4, 'Trevor')]
>>>

因此enumerate()返回一个迭代器，该迭代器产生一个元组，该元组保留所传递序列中元素的计数。由于返回值是一个迭代器，因此直接访问它不是很有用。 enumerate()的更好方法是将计数保持在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

标准库中还有许多其他函数，这是一些更广泛使用的函数的另一个列表-

  • hasattr，getattr，setattr和delattr，这允许通过其字符串名称来操纵对象的属性。

  • all和any，它们接受一个可迭代的对象，如果所有或任何一项的评估结果为true，则返回True 。

  • nzip，它接受两个或多个序列，并返回一个新的元组序列，其中每个元组都包含来自每个序列的单个值。

文件I / O

文件的概念与术语“面向对象的编程”相关联。 Python封装了操作系统抽象提供的接口，该接口允许我们使用文件对象。

内置函数open()用于打开文件并返回文件对象。这是一个有两个参数中最常用的函数-

open(filename, mode)

open()函数调用两个参数，第一个是文件名，第二个是模式。在此模式下，只读模式可以为“ r”，仅写模式可以为“ w”(一个具有相同名称的现有文件将被删除)，而“ a”打开该文件以进行追加，写入该文件的所有数据都会自动添加到最后。 “ r +”打开文件以供读取和写入。默认模式为只读。

在Windows上，附加到模式的’b’以二进制模式打开文件，因此也有’rb’，’wb’和’r + b’之类的模式。

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

在某些情况下，我们只想追加到现有文件而不是覆盖它，因为我们可以提供值“ a”作为模式参数，以追加到文件末尾，而不是完全覆盖现有文件内容。

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

打开文件进行读取后，我们可以调用read，readline或readlines方法来获取文件的内容。 read方法根据第二个参数是否为“ b”，将文件的全部内容返回为str或bytes对象。

为了提高可读性，并避免一次读取大文件，通常最好直接在文件对象上使用for循环。对于文本文件，它将一次读取每一行，我们可以在循环体内对其进行处理。但是，对于二进制文件，最好使用read()方法读取固定大小的数据块，并传递参数以读取最大字节数。

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

通过对文件对象执行write方法写入文件，会将字符串(二进制数据字节)对象写入文件。 writelines方法接受字符串序列，并将每个迭代的值写入文件。 writelines方法不会在序列中的每个项目之后添加新行。

最后，当我们完成文件的读取或写入后，应调用close()方法，以确保将所有缓冲的写操作写入磁盘，确保已正确清理了文件，并将与该文件绑定的所有资源释放回了该文件。操作系统。调用close()方法是一种更好的方法，但是从技术上讲，当脚本存在时，这将自动发生。

方法重载的替代方法

方法重载是指具有多个名称相同的方法，它们接受不同的参数集。

给定单个方法或函数，我们可以自行指定参数数量。根据函数定义，可以使用零，一，两个或更多参数来调用它。

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')

输出

Hello
Hello Rahul

默认参数

函数也是对象

可调用对象是可以接受一些参数的对象，并且可能会返回一个对象。函数是Python最简单的可调用对象，但是还有其他一些类，例如类或某些类实例。

Python中的每个函数都是一个对象。对象可以包含方法或函数，但对象不一定是函数。

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)

在上面的代码中，我们能够将两个不同的函数作为参数传递给我们的第三个函数，并为每个函数获得不同的输出-

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

可调用对象

就像函数是可以在其上设置属性的对象一样，可以创建一个可以被当作函数调用的对象。

在Python，可以使用函数调用语法来调用具有__call __()方法的任何对象。