Python 开发者的高级 Python 概念

2024 年 08 月 29 日 | 阅读 9 分钟

在学习 Python 的过程中，我们进行了大量的练习，并努力深入理解 Python 的核心概念。实现所学知识需要大量的努力和奉献。在这里，我们提到了一些基本和高级的 Python 概念，这将有助于您作为一名 Python 开发人员提高效率。

一旦您对这些主题有了实践经验，您就可以实现复杂的解决方案。下面是 Python 中的高级主题列表。

Python 中一切皆对象是如何实现的？
推导式
闭包和装饰器
生成器和迭代器协议
上下文管理器
扩展关键字参数 (*args, **kwargs)
@staticmethod 和 @classmethod
继承和封装
运算符重载
Python 包和程序布局

让我们进入第一个主题。

Python 中一切皆对象是如何实现的？

正如我们在 Python 官方文档中读到的那样——“Python 中一切皆对象”。字符串是对象，列表是对象，函数是对象，甚至模块也是对象。一切都是对象，因为它可以被赋值给一个变量，或者作为参数传递给一个函数。任何你可以放在等号右边的东西都是（或者创建）Python 中的一个对象。

示例 -

def hello():
	print("say hello")
hi = hello()
"say hello"
hello()
"say hello"

对象

对象有两个属性 -

一个身份 (id)
一个值（可变和不可变）

可变 - 当我们修改项目时，id 不会改变。例如 - 字典、列表、集合。

不可变 - 我们无法更改元素。例如 - 字符串、整数、元组。

推导式

Python 中的推导式允许我们编写简洁的代码来使用已定义的序列创建新序列（例如列表、集合、字典等）。Python 提供了以下四种类型的推导式

列表推导式
字典推导式
集合推导式
生成器推导式

列表推导式

列表推导式是定义新列表的良好设计方式。下面是列表推导式的基本结构。

语法 -

示例 - 不使用列表推导式

given_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
output = []
# Using loop for constructing output list
for i in given_list:
    if i % 2 == 0:
        output.append(i) 
print("Output List using for loop:", output)

输出

Output List using for loop: [2, 4, 6, 8, 10]

示例 - 使用列表推导式

given_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list_comp_example = [i for i in given_list if i % 2 == 0]
print("Output List using list comprehensions:", list_comp_example)

输出

Output List using list comprehensions: [2, 4, 6, 8, 10]

字典推导式

Python 也允许我们将推导式与字典一起使用，就像列表推导式一样；我们也可以使用字典推导式创建字典。字典推导式的语法如下所示。

示例 -

示例 - 不使用字典推导式

given_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
output = {}
# Using loop for constructing output list
for i in given_list:
    if i % 2 == 0:
        output[i] = i ** 3
print("Output List using for loop:", output)

输出

Output List using for loop: {2: 8, 4: 64, 6: 216, 8: 512, 10: 1000}

集合推导式

集合推导式与列表推导式非常相似。它们之间唯一的区别是集合推导式使用花括号 { }。让我们看下面的例子来理解集合推导式。

示例 - 不使用集合推导式

given_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
output = set()
# Using loop for constructing output list
for i in given_list:
    if i % 2 == 0:
        output.add(i)
print("Output List using for loop:", output)

输出

Output List using for loop: {2, 4, 6, 8, 10}

示例 - 使用集合推导式

given_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
output = set()
set_using_comp = {var for var in given_list if var % 2 == 0}
print("Output Set using set comprehensions:",
                              set_using_comp)

输出

Output Set using set comprehensions: {2, 4, 6, 8, 10}

生成器推导式

生成器推导式与列表推导式非常相似。一个区别是生成器推导式使用圆括号，而列表推导式使用方括号。

让我们看下面的例子来理解生成器推导式。

示例 -

given_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
output_gen = (var for var in given_list if var % 2 == 0)
  
for var in output_gen:
    print(var, end = ' ')

输出

多重推导式

values = [(x,y) for x in range(5) for y in range(3)]
values = []
for x in range(5):
    for y in range(3):
        values.append((x,y))

嵌套推导式

values = [[y*3 for y in range(x)] for x in range(10)]
	
	values = []
	for x in range(10):
	    inner = []
	    for y in range(x):
	        inner.append(y*3)
	    values.append(inner)

扩展关键字参数

我们在 Python 中使用参数来调用函数。有时我们需要使用关键字参数或位置参数，关键字参数通常可以使函数调用更加明确。

扩展格式参数语法

函数定义侧的参数 -

示例 -

def hyper(*lengths):
    i = iter(lengths)
    v = next(i)
    for length in i:
        v *= length
    return v
print(hyper(1, 2, 3, 4, 5))

输出

扩展实际参数语法

函数调用侧的参数。

示例 -

argument = (1, 2, 3, 4, 5)
def print_args(arg1, arg2, *args):
    print(arg1)
    print(arg2)
    print(args)
print_args(*argument)

输出

1
2
(3, 4, 5)

闭包和装饰器

要理解闭包和装饰器，我们应该了解局部函数 -

局部函数

它是一个函数内部的函数，用于专门的、一次性的函数。它类似于 lambda 表达式，但更通用，有助于代码组织和可读性。

通过 LEGB 规则进行作用域解析

在 Python 中，LEGB 规则用于决定命名空间的作用域解析搜索顺序。

作用域按层次结构（最高到最低/最窄到最广）列出如下

局部 (L) - 在函数/类内部定义。
封闭 (E) - 在封闭函数内部定义（嵌套函数概念）。
全局 (G) - 在最顶层定义。
内置 (B) - Python 内置模块中的保留名称。

让我们理解以下示例 -

示例 -

def func():    
    def local_func():
        a = 'hello, '
        b = 'world'
        return a + b
    x = 1
    y = 2
    return x + y

返回函数

def outer():
    def inner():
        print('inner')
    return inner

闭包

它保持对早期作用域中对象的引用。让我们理解下面的例子 -

示例 -

def outer_function(x):
    def inner_function(y):
        return x+y
    return inner_funtion
add_plus= outer_function(30)
add_plus(20)

输出

装饰器

装饰器是 Python 中一个重要、强大且有用的工具，因为它允许程序员在不改变实际定义的情况下修改函数或类的行为。装饰器允许我们包装另一个函数，以扩展被包装函数的行为而无需永久修改它。让我们理解下面的例子 -

示例 -

def change_upper(f):
    print("change_upper")
    def wrap(*args, **kwargs):
        print("wrap")
        x = f(*args, **kwargs)
        return x.upper()
    return wrap
@change_upper
def my_name(name):
    print("my_name")
    return name

输出

change_upper

生成器和可迭代协议

可迭代对象 - 可以传递给内置 iter() 函数以获取迭代器的对象。
迭代器 - 可以传递给内置 next() 函数以获取下一个项目的对象。

示例 -

iterator = iter(iterable)
item = next(iterator)

生成器

生成器函数像普通函数一样定义，但它在需要生成值时使用 yield 关键字而不是 return。如果 def 的主体包含 yield，则该函数会自动成为生成器函数。

yield 语句用于定义生成器；yield 关键字与 return 不同，因为它会暂停函数执行，返回值，保存所有状态，然后在后续调用时继续。

示例 -

def my_gen():
    n = 1
    print('This is printed first')
    # Generator function contains yield statements
    yield n

    n += 1
    print('This is printed second')
    yield n

    n += 1
    print('This is printed at last')
    yield n

# Using for loop
for item in my_gen():
    print(item)  

为什么在 Python 中使用生成器？

易于实现
内存高效
表示无限流
管道生成器

示例 -

def PowTwoGen(max = 0):
    n = 0
    while n < max:
        yield 2 ** n
        n += 1

上下文管理器

上下文管理器用于管理资源。文件操作或数据库连接等资源的使用非常普遍。资源是有限的，因此我们需要管理它们。因此，主要问题在于确保在使用后释放这些资源。如果用户有一种自动设置和分解资源的机制，那将非常有益。在 Python 中，可以通过使用上下文管理器来实现，从而简化资源的正确处理。执行文件操作最常见的方法是使用下面显示的关键字。

示例 -

# Python program showing
# a use of with keyword
with open("test.txt") as f:
	data = f.read()

@staticmethod @classmethod

@classmethod 允许我们访问类属性。如果您不需要使用 cls 对象，请使用 @staticmethod。

Python 静态方法可以在子类中被重写。下面是静态方法和类方法之间的区别。

示例 -

类方法	静态方法
类方法将 cls（类）作为第一个参数。	静态方法不接受任何特定参数。
类方法可以访问和修改类状态。	静态方法无法访问或修改类状态。
类方法将类作为参数，以了解该类的状态。	静态方法不了解类状态。这些方法用于通过接受一些参数来执行一些实用任务。
此处使用 @classmethod 装饰器。	此处使用 @staticmethod 装饰器。

示例 -

from datetime import date as dt
class Employee:
   def __init__(self, name, age):
      self.name = name
      self.age = age
   
   @staticmethod
   def isAdult(age):
      if age > 18:
         return True
      else:
         return False
   @classmethod
   def emp_from_year(emp_class, name, year):
      return emp_class(name, dt.today().year - year)
   def __str__(self):
      return 'Employee Name: {} and Age: {}'.format(self.name, self.age)
e1 = Employee('Joshep', 29)
print(e1)
e2 = Employee.emp_from_year('Peter', 1997)
print(e2)
print(Employee.isAdult(25))
print(Employee.isAdult(16))

输出

Employee Name: Joshep and Age: 29
Employee Name: Peter and Age: 25
True
False

继承和封装

继承是一种技术，其中一个类获取另一个类的属性。例如，孩子继承其父母的一些特征。通过继承，我们可以重用现有类的字段和方法。因此，继承简化了可重用性，是 OOP 的一个重要概念。

单继承

子类将获取父类的所有功能，并且还可以适应和增强。子类初始化器需要调用基类初始化器，以使整个对象得到初始化。

多重继承

它定义了一个具有多个基类的类。让我们看下面的语法 - 示例 -

运算符重载

Python 运算符适用于内置类。但相同的运算符在不同类型上表现不同。例如，+ 运算符将对两个数字执行算术加法，合并两个列表并连接两个字符串。让我们理解下面的例子 -

示例 -

class Point:
    def __init__(self, x = 0, y = 0):
        self.x = x
        self.y = y
    
    def __str__(self):
        return "({0},{1})".format(self.x,self.y)
    def __add__(self,other):
        x = self.x + other.x
        y = self.y + other.y
        return Point(x,y)
p1 = Point(2,3)
p2 = Point(-1,2)
print(p1 + p2)

输出

(1, 5)

Python 包和程序布局

包是一个可以包含其他模块的模块。PYTHONPATH 环境变量列出添加到 sys.path 的路径。

包是包含其他模块的模块。
包通常作为包含特殊文件的目录实现
__init__.py 文件。
当导入包时，__init__.py 文件会被执行。
包可以包含子包，这些子包本身是通过以下方式实现的
目录中的 __init__.py 文件。
包的模块对象具有 __path__ 属性。

绝对导入： 使用模块完整路径的导入。

结论

在本教程中，我们讨论了一些对开发非常有价值的基本 Python 概念。通过练习这些主题，您可以编写有效且高效的代码，这些主题使 Python 成为一种有益且流行的编程语言。

下一个主题Pycricbuzz 库 - Python 的板球 API

Python 开发者的高级 Python 概念

Python 中一切皆对象是如何实现的？

对象

推导式

列表推导式

字典推导式

集合推导式

生成器推导式

多重推导式

嵌套推导式

扩展关键字参数

闭包和装饰器

生成器和可迭代协议

为什么在 Python 中使用生成器？

上下文管理器

@staticmethod @classmethod

继承和封装

运算符重载

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Python 问题

Python 开发者的高级 Python 概念

Python 中一切皆对象是如何实现的？

对象

推导式

列表推导式

字典推导式

集合推导式

生成器推导式

多重推导式

嵌套推导式

扩展关键字参数

闭包和装饰器

生成器和可迭代协议

为什么在 Python 中使用生成器？

上下文管理器

@staticmethod @classmethod

继承和封装

运算符重载

结论

相关帖子

使用 bcrypt 在 Python 中加密密码

Python vs Scala

Python 程序查找两个列表的交集

Python sys 模块中的函数和文件对象

Python 中的 NamedTuple

Python 如此流行的原因

Python pprint 模块

Python 中的 PyQt 库

Python 中的 choice()

Python int 的位函数 (bit_length,to_bytes 和 from_bytes)

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器