Parlons de l'essai Python en huit parties

​Bonjour camarades, aujourd'hui je vais vous emmener passer en revue les problèmes de base de python. Nous savons tous que python est un langage interprété et que son efficacité est inférieure à celle des autres langages. Ce inférieur n'est qu'un temps d'exécution légèrement inférieur, mais bon, achetez. c'est trivial dans de nombreux scénarios

Avec la syntaxe facile à comprendre et à apprendre, vous pouvez effectuer plus de travail en peu de temps et l'efficacité du développement deviendra plus élevée

En même temps, python est livré avec divers prêts- Les bibliothèques créées sont disponibles pour que nous puissions les utiliser dans le développement de programmes. Python est également relativement facile à maintenir. Python nous fournit une bibliothèque de code de base très complète, couvrant un grand nombre de contenus tels que le réseau, les fichiers, l'interface graphique, la base de données, le texte, etc. . On l'appelle clairement « piles intégrées (piles incluses) ». Développées en Python, de nombreuses fonctions n'ont pas besoin d'être écrites à partir de zéro, il suffit d'utiliser des fonctions prêtes à l'emploi.

En plus des bibliothèques intégrées, Python dispose également d'un grand nombre de bibliothèques tierces, qui sont des éléments développés par d'autres pour que vous puissiez les utiliser directement. Bien entendu, si le code que vous développez est bien encapsulé, il peut également être utilisé comme bibliothèque tierce pour que d’autres puissent l’utiliser.

Qu'est-ce qu'un générateur Python ?

générateur, il existe deux façons de générer des objets générateurs : l'une est la génération de liste avec parenthèses :

g1 = (x for x in range(10))

L'autre est dans la définition de fonction Contient le mot-clé rendement :

def fib(max):
n, a, b = 0, 0, 1
while n < max:yield b
a, b = b, a + b
n = n + 1
return 'done'g2 = fib(8)

Pour les objets générateurs g1 et g2, vous pouvez obtenir en continu la valeur de l'élément suivant via next(g1), s'il n'y a plus d'élément, une erreur StopIteration sera signalée

Vous pouvez également obtenir la valeur de l'élément via une boucle for.

L'avantage du générateur est qu'il ne prend pas beaucoup de mémoire, il suffit de calculer la valeur de l'élément lors de son utilisation.

Que sont les itérateurs Python ?

Ce qui peut être utilisé dans les boucles for en Python est appelé itérable Itérable, y compris list/set/tuple/str/dict et d'autres structures et générateurs de données, vous pouvez utiliser l'instruction suivante pour déterminer si un objet est itérable :

from collections import Iterableisinstance(x, Iterable)

Iterator Iterator signifie qu'il peut être appelé par la fonction next() et renvoie continuellement la valeur suivante jusqu'à ce que les générateurs soient tous des itérateurs, mais les structures de données telles que les listes ne peuvent pas être utilisées ; par l'instruction suivante, la liste devient Iterator :

iter([1,2,3,4,5])

Les générateurs sont tous des itérateurs, mais les itérateurs ne sont pas nécessairement des générateurs.

Quelle est la différence entre une liste et un tuple ?

list a une longueur variable, mais le tuple est immuable ;

list peut changer la valeur des éléments, mais le tuple ne le peut pas ;

list prend en charge l'ajout de pop et d'autres méthodes, mais le tuple ne prend pas en charge

 ;

Comment list et dict sont-ils implémentés en Python ?
• Liste : il s'agit essentiellement d'un tableau séquentiel, mais l'expansion du tableau est exponentielle à chaque fois. Par conséquent, lorsque des données sont ajoutées et supprimées dynamiquement, la structure physique du tableau ne changera pas fréquemment. il bénéficie de l'efficacité du parcours séquentiel de table (via angulaire L'index est combiné avec l'adresse physique de l'en-tête de table pour calculer la position de l'élément cible), ce qui rend les performances globales de la liste de Python relativement bonnes

dict : Il s'agit essentiellement d'une liste séquentielle, mais l'index de l'emplacement de stockage de chaque élément n'est pas déterminé par l'ordre d'insertion, mais est généré dynamiquement par la clé via un algorithme de hachage et d'autres mécanismes, c'est-à-dire que la clé est hachée pour générer. l'emplacement où la valeur doit être stockée, puis la valeur est stockée ; donc la complexité temporelle de la requête de dict est O(1)

Par conséquent, la clé de dict ne peut être qu'un objet hachable, c'est-à-dire un type immuable ;

Les processeurs multicœurs peuvent-ils être utilisés ensemble en utilisant le multithreading en Python ?

Il existe quelque chose appelé Global Interpreter Lock (GIL) en Python, qui garantira qu'un seul de vos multiples threads est exécuté à tout moment.

La vitesse d'exécution des threads est très rapide, ce qui vous fera penser à tort que les threads sont exécutés en parallèle, alors qu'en fait ils sont tous exécutés à tour de rôle. Après le traitement au niveau GIL, la surcharge d’exécution sera augmentée.

Les tâches multicœurs peuvent être réalisées via plusieurs processus.

La différence entre py3 et py2

print est une fonction dans py3, mais juste un mot-clé dans py2

L'encodage par défaut des fichiers py3 est utf8, et l'encodage par défaut des fichiers py2 est ascii

La str de py3 est une chaîne Unicode, tandis que la str de py2 est en octets

La range() de py3 renvoie un objet itérable, la range() de py2 renvoie une liste, xrange() renvoie un objet itérable, la Division de py3 renvoie float, celle de py2 division renvoie int

Objets variables et objets immuables

Objets variables : list, dict, set

Objets immuables : bool, int, float, tuple, str …

La différence entre les itérateurs et objets itérables

Classes d'objets itérables, vous devez personnaliser la méthode magique __iter__(), et les objets instanciés des classes range et list sont tous des objets itérables

Classe Iteration Iter, vous devez personnaliser __iter__() et __next__ () méthodes magiques. Utilisez la fonction iter() pour créer un itérateur d'objets itérables

Closure

Closure est une fonction imbriquée qui utilise les variables ou les paramètres de la fonction externe et sa fonction externe. renvoie la fonction interne

可以保存外部函数内的变量，不会随着外部函数调用完而销毁

什么是装饰器?

装饰器是一个接收函数作为参数的闭包函数

它可以在不修改函数内部源代码的情况下，给函数添加额外的功能

import time
def calc_time(func):
def inner():
t1 = time.time()
func()
t2 = time.time()
print('cost time: {}s'.format(t2-t1))
return inner

什么是元类? 使用场景

元类是创建类的类，type还有继承自type的类都是元类

作用: 在类定义时（new, init）和 类实例化时(call) 可以添加自定义的功能

使用场景: ORM框架中创建一个类就代表数据库中的一个表，但是定义这个类时为了统一需要把里面的类属性全部改为小写，这个时候就要用元类重写new方法，把attrs字典里的key转为小写

GIL(Global Interpreter Lock)

全局解释器锁

全局解释器锁(Global Interpreter Lock)是计算机程序设计语言解释器用于同步线程的一种机制，它使得任何时刻仅有一个线程在执行。

即便在多核处理器上，使用 GIL 的解释器也只允许同一时间执行一个线程，常见的使用 GIL 的解释器有CPython与Ruby MRI。可以看到GIL并不是Python独有的特性，是解释型语言处理多线程问题的一种机制而非语言特性。

GIL的设计初衷?

单核时代高效利用CPU, 针对解释器级别的数据安全(不是thread-safe 线程安全)。首先需要明确的是GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。

当Python虚拟机的线程想要调用C的原生线程需要知道线程的上下文，因为没有办法控制C的原生线程的执行，所以只能把上下文关系传给原生线程，同理获取结果也是线 程在python虚拟机这边等待。那么要执行一次计算操作，就必须让执行程序的线程组串行执行。

为什么要加在解释器,而不是在其他层?

展开 GIL锁加在解释器一层，也就是说Python调用的Cython解释器上加了GIL锁，因为你python调用的所有线程都是原生线程。原生线程是通过C语言提供原生接口，相当于C语言的一个函数。

你一调它，你就控制不了了它了，就必须等它给你返回结果。只要已通过python虚拟机 ，再往下就不受python控制了，就是C语言自己控制了。

加在Python虚拟机以下加不上去，只能加在Python解释器这一层。

GIL的实现是线程不安全?为什么?

python2.x和3.x都是在执行IO操作的时候，强制释放GIL，使其他线程有机会执行程序。

Python2.x Python使用计数器ticks计算字节码，当执行100个字节码的时候强制释放GIL，其他线程获取GIL继续执行。ticks可以看作是Python自己的计数器，专门作用于GIL，释放后归零，技术可以调整。

Python3.x Python使用计时器，执行时间达到阈值后，当前线程释放GIL。总体来说比Python3.x对CPU密集型任务更好，但是依然没有解决问题。

什么是 lambda 表达式？

简单来说，lambda表达式通常是当你需要使用一个函数，但是又不想费脑袋去命名一个函数的时候使用，也就是通常所说的匿名函数。

lambda表达式一般的形式是：关键词lambda后面紧接一个或多个参数，紧接一个冒号“：”，紧接一个表达式

什么是深拷贝和浅拷贝？

赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。

浅拷贝 copy.copy：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）

深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）{copy模块的deep.deepcopy()函数}​

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!