Lorsque nous ne savons pas combien de paramètres transmettre à la fonction, par exemple lorsque nous transmettons une liste ou un tuple, nous utilisons *args :
def func(*args):
for i in args:
print(i)
func(3,2,1,4,7)
3
2
1
4
7Quand nous ne le faisons pas. Je ne sais pas combien de paramètres transmettre. Lorsque vous utilisez des arguments de mots-clés, utilisez **kwargs pour collecter les arguments de mots-clés :
def func(**kwargs):
for i in kwargs:
print(i,kwargs[i])
func(a=1,b=2,c=7)
a.1
b.2
c.7Utilisez la commande os.remove(filename) ou os.unlink(filename)
Vous pouvez accéder aux modules écrits en Python en C via :
Module = = PyImport_ImportModule（“<modulename>”）
Il s'agit d'un opérateur de division d'étage, utilisé pour diviser deux opérandes, le résultat est le quotient, et seuls les nombres avant le point décimal sont affichés.
Par exemple, 10 // 5 = 2 et 10,0 // 5,0 = 2,0.
Les espaces de début d'une chaîne sont des espaces qui apparaissent avant le premier caractère non espace de la chaîne.
Nous utilisons la méthode Istrip() pour le supprimer de la chaîne.
’ Data123 '.lstrip()
Résultat :
'Data123 ’
La chaîne initiale contient à la fois des caractères de début et de suffixe. L'appel à Istrip() supprime les espaces de début. utilisez la méthode rstrip().
'Data123 '.rstrip() 'Data123'
a,b = 0, 1 while b<100: print (b) a, b = b, a+b
Si la chaîne ne contient que des caractères numériques, vous pouvez utiliser la fonction int() pour la convertir en entier.
int(‘22’)
Vérifions le type de variable :
type('22') <class'str'> type(int('22')) <class'int'>
Pour générer des nombres aléatoires, nous pouvons importer la fonction random() du module random.
from random import random random() 0.013501571090371978
Nous pouvons également utiliser la fonction randint(), qui prend deux paramètres pour représenter un intervalle et renvoie un entier aléatoire dans l'intervalle.
from random import randint randint(2,7) 4
Le moyen le plus simple est d'utiliser la méthode capitalize().
'daxie'.capitalize() 'Daxie'
Pour ce problème, nous pouvons utiliser la méthode isalnum().
'DATA123'.isalnum() True 'DATA123!'.isalnum() False
Nous pouvons également utiliser d'autres méthodes :
'123'.isdigit()#检测字符串是否只由数字组成 True '123'.isnumeric()#只针对unicode对象 True 'data'.islower()#是否都为小写 True 'Data'.isupper()#是否都为大写 False
La connexion en Python consiste à connecter deux séquences ensemble. Nous utilisons l'opérateur + pour compléter :
'22'+'33' ‘2233' [1,2,3]+[4,5,6] [1, 2,3, 4, 5, 6] (2,3)+(4) TypeError Traceback (most recent call last) <ipython-input-7-69a1660f2fc5> in <module> ----> 1 (2,3)+(4) TypeError: can only concatenate tuple (not "int") to tuple
Une erreur s'est produite ici car (4) est considéré comme un entier. Modifiez-le et exécutez à nouveau :
(2,3)+(4,) (2, 3,4)
Quand une fonction s'appelle directement ou indirectement lors de son appel, c'est de la récursion. Mais pour éviter une boucle infinie, il doit y avoir une condition de fin. Par exemple :
def facto(n): if n==1: return 1 return n*facto(n-1) facto(5) 120
Le générateur générera une série de valeurs pour l'itération, c'est donc un objet itérable.
Il calcule en continu l'élément suivant pendant la boucle for et termine la boucle for dans des conditions appropriées.
Nous définissons une fonction qui "donne" les valeurs une par une, puis utilisons une boucle for pour la parcourir.
def squares(n):
i=1
while(i<=n):
yield i**2
i+=1
for i in squares(5):
print(i)
1
4
9
16
25Iterator est un moyen d'accéder aux éléments d'une collection.
L'objet itérateur commence à accéder à partir du premier élément de la collection jusqu'à ce que tous les éléments aient été accédés.
Les itérateurs ne peuvent qu'avancer et non reculer. Nous créons des itérateurs en utilisant la fonction inter().
odds=iter([1,2,3,4,5]) #每次想获取一个对象时，我们就调用next()函数 next (odds) 1 next (odds) 2 next (odds) 3 next (odds) 4 next (odds) 5
1) Lorsque nous utilisons un générateur, nous créons une fonction lorsque nous utilisons un itérateur, nous utilisons les fonctions intégrées iter() et next(); 2) Dans le générateur, nous utilisons le mot-clé «yield’ pour générer/retourner un objet à chaque fois ;
3) Vous pouvez personnaliser le nombre d'instructions «yield’ est sauvegardé à chaque fois que la boucle est mise en pause. Les itérateurs n'ont besoin que d'un objet itérable pour itérer, et il n'est pas nécessaire d'utiliser des variables locales
5) Vous pouvez implémenter votre propre itérateur en utilisant des classes, mais vous ne pouvez pas implémenter de générateurs
6) Les générateurs fonctionnent rapidement et ont une syntaxe simple, plus simple ; ;
7) Les itérateurs peuvent économiser plus de mémoire.
Q66. A quoi sert la fonction zip() ?
Les novices en Python ne sont peut-être pas très familiers avec cette fonction. zip() peut renvoyer un itérateur de tuples.
[(«a’,1), («b’, 2), («c’, 3)]
Ici, la fonction zip() associe les éléments de données dans les deux listes et crée un tuple à partir d'eux.
Q67. Comment utiliser Python pour savoir dans quel répertoire vous vous trouvez actuellement ?
Nous pouvons utiliser la fonction/méthode getcwd() pour l'importer depuis le module os.
os.getcwd()
‘C:Users37410Desktop code»
Q68.
C'est aussi relativement simple, il suffit d'appeler la fonction len() sur la chaîne dont nous voulons calculer la longueur.
8
Q69. Comment supprimer le dernier objet de la liste ?
Supprimez et renvoyez le dernier objet ou obj de la liste.
list.pop（obj = list [-1]）
有时，当我们想要遍历列表时，一些方法会派上用场。
1）filter（）
过滤器允许我们根据条件逻辑过滤一些值。
list（filter（lambda x：x> 5，range（8））） [6,7] 2）map（）
Map将函数应用于iterable中的每个元素。
list（map（lambda x：x ** 2，range（8））） [0,1,4,9,16,25,36,49] 3）reduce（）
在我们达到单个值之前，Reduce会反复减少序列顺序。
from functools import reduce reduce（lambda x，y：xy，[1,2,3,4,5]） -13
def list_sum（num_List）：如果len（num_List）== 1： return num_List [0] else： return num_List [0] + list_sum（num_List [1：]） print（list_sum（[3,4,5,6,11]）） 29
import random def random_line（fname）： lines = open（fname）.read（）.splitlines（） return random.choice（lines） print（random_line（'test.txt'））
def file_lengthy（fname）： open（fname）as f： for i，l in enumerate（f）： pass return i + 1 print（“file of lines：”，file_lengthy（“test.txt”））
import os os.chdir('C:\Users\lifei\Desktop') with open('Today.txt') as today: count=0 for i in today.read(): if i.isupper(): count+=1 print(count)
以下代码可用于在Python中对列表进行排序：
list = ["1", "4", "0", "6", "9"] list = [int(i) for i in list] list.sort() print (list) Django有关
对于Django框架遵循MVC设计，并且有一个专有名词：MVT，
M全拼为Model，与MVC中的M功能相同，负责数据处理，内嵌了ORM框架；
V全拼为View，与MVC中的C功能相同，接收HttpRequest，业务处理，返回HttpResponse；
T全拼为Template，与MVC中的V功能相同，负责封装构造要返回的html，内嵌了模板引擎
Flask是一个“微框架”，主要用于具有更简单要求的小型应用程序。
Pyramid适用于大型应用程序，具有灵活性，允许开发人员为他们的项目使用数据库，URL结构，模板样式等正确的工具。
Django也可以像Pyramid一样用于更大的应用程序。它包括一个ORM。
Django架构
开发人员提供模型，视图和模板，然后将其映射到URL，Django可以为用户提供服务。
Django使用SQLite作为默认数据库，它将数据作为单个文件存储在文件系统中。
如过你有数据库服务器-PostgreSQL，MySQL，Oracle，MSSQL-并且想要使用它而不是SQLite，那么使用数据库的管理工具为你的Django项目创建一个新的数据库。
无论哪种方式，在您的（空）数据库到位的情况下，剩下的就是告诉Django如何使用它。
这是项目的settings.py文件的来源。
我们将以下代码行添加到setting.py文件中：
DATABASES ={‘default’: {‘ENGINE’: ‘django.db.backends.sqlite3’, ‘NAME’: os.path.join(BASE_DIR, ‘db.sqlite3’),
这是我们在Django中使用write一个视图的方法：
from django.http import HttpResponse import datetime def Current_datetime(request): now =datetime.datetime.now() html ="<html><body>It is now %s</body></html>"%now return HttpResponse(html)
返回当前日期和时间，作为HTML文档。
模板是一个简单的文本文件。
它可以创建任何基于文本的格式，如XML，CSV，HTML等。
模板包含在评估模板时替换为值的变量和控制模板逻辑的标记（％tag％）。
Django提供的会话允许您基于每个站点访问者存储和检索数据。
Django通过在客户端放置会话ID cookie并在服务器端存储所有相关数据来抽象发送和接收cookie的过程。
所以数据本身并不存储在客户端。
从安全角度来看，这很好。
在Django中，有三种可能的继承样式：
抽象基类：当你只希望父类包含而你不想为每个子模型键入的信息时使用；
多表继承：对现有模型进行子类化，并且需要每个模型都有自己的数据库表。
代理模型：只想修改模型的Python级别行为，而无需更改模型的字段。
数据分析
map函数执行作为第一个参数给出的函数，该函数作为第二个参数给出的iterable的所有元素。
如果给定的函数接受多于1个参数，则给出了许多迭代。
我们可以使用下面的代码在NumPy数组中获得N个最大值的索引：
importnumpy as np arr =np.array([1, 3, 2, 4, 5]) print(arr.argsort()[-3:][::-1]) 4 3 1
Q86.如何用Python/ NumPy计算百分位数？
importnumpy as np a =np.array([1,2,3,4,5] p =np.percentile(a, 50) #Returns 50th percentile, e.g. median print(p) 3
1）Python的列表是高效的通用容器。
它们支持（相当）有效的插入，删除，追加和连接，Python的列表推导使它们易于构造和操作。
2）有一定的局限性
它们不支持元素化加法和乘法等“向量化”操作，可以包含不同类型的对象这一事实意味着Python必须存储每个元素的类型信息，并且必须在操作时执行类型调度代码在每个元素上。
3）NumPy不仅效率更高，也更方便
Vous obtenez de nombreuses opérations vectorielles et matricielles, ce qui peut parfois éviter un travail inutile.
4) Les tableaux NumPy sont plus rapides
Vous pouvez utiliser NumPy, FFT, convolution, recherche rapide, statistiques de base, algèbre linéaire, histogrammes, etc.
Les décorateurs en Python sont utilisés pour modifier ou injecter du code dans des fonctions ou des classes.
À l'aide de décorateurs, vous pouvez envelopper un appel de méthode de classe ou de fonction afin qu'un morceau de code soit exécuté avant ou après l'exécution du code d'origine.
Les décorateurs peuvent être utilisés pour vérifier les autorisations, modifier ou suivre les paramètres transmis aux méthodes, enregistrer les appels à des méthodes spécifiques, etc.
Dans un monde idéal, NumPy ne contient que les types de données et opérations de tableau les plus élémentaires, tels que l'indexation, le tri, le remodelage et les fonctions d'éléments de base.
2) Tout le code numérique résidera dans SciPy. Malgré cela, NumPy maintient toujours son objectif de compatibilité ascendante et s'efforce de conserver toutes les fonctionnalités prises en charge par son prédécesseur.
Ainsi, bien qu'appartenant de manière plus appropriée à SciPy, NumPy inclut toujours certaines fonctions d'algèbre linéaire. Quoi qu'il en soit, SciPy contient une version plus complète du module d'algèbre linéaire et de nombreux autres algorithmes numériques que tout autre.
Si vous utilisez Python pour des calculs scientifiques, il est recommandé d'installer NumPy et SciPy. La plupart des nouvelles fonctionnalités appartiennent à SciPy plutôt qu'à NumPy.
Comme pour le traçage 2D, les graphiques 3D dépassent la portée de NumPy et SciPy, mais tout comme le cas 2D, il existe des packages qui s'intègrent à NumPy.
Matplotlib fournit un traçage 3D de base dans le sous-package mplot3d, tandis que Mayavi utilise le puissant moteur VTK pour fournir une variété de fonctions de visualisation 3D de haute qualité.
Crawler et framework effrayant
Scrapy est un framework d'exploration Python avec une efficacité d'exploration extrêmement élevée et une personnalisation élevée, mais il ne prend pas en charge la distribution.
Scrapy-redis est un ensemble de composants basés sur la base de données redis et fonctionnant sur le framework scrapy, qui permet à scrapy de prendre en charge des stratégies distribuées. Le côté Slaver partage la file d'attente des éléments, la file d'attente des demandes et l'empreinte digitale des demandes définies dans la base de données redis côté maître. .
Étant donné que Redis prend en charge la synchronisation maître-esclave et que les données sont mises en cache en mémoire, les robots d'exploration distribués basés sur Redis sont très efficaces dans la lecture à haute fréquence des requêtes et des données.
Python est livré avec : urllib, urllib2
Tiers : requêtes
Framework : Scrapy
Les modules urllib et urllib2 effectuent des opérations liées à la demande d'URL, mais ils fournissent des fonctions différentes.
urllib2. : urllib2.urlopen peut accepter un objet Request ou une URL (lors de l'acceptation d'un objet Request, vous pouvez définir les en-têtes d'une URL). la raison pour laquelle urllib et urllib2 sont souvent utilisés ensemble
scrapy est un framework encapsulé. Il comprend un téléchargeur, un analyseur, une gestion des journaux et des exceptions, basé sur le multi-threading.
La méthode torsadée présente des avantages pour explorer et développer un site Web unique fixe ; cependant, pour explorer 100 sites Web sur plusieurs sites Web, elle n'est pas assez flexible en termes de traitement simultané et distribué, ce qui la rend peu pratique à ajuster et à développer.
request est une bibliothèque HTTP. Elle est uniquement utilisée pour faire des requêtes. Pour les requêtes HTTP, c'est une bibliothèque puissante qui est gérée par vous-même. Elle a une plus grande flexibilité, une concurrence élevée et un déploiement distribué. flexible pour les fonctions peut être mieux implémenté.
Q93. Quels sont vos moteurs MySQL couramment utilisés ? Quelles sont les différences entre les moteurs ?
1) InnoDB prend en charge les transactions, mais pas MyISAM. La transaction est une méthode de traitement de haut niveau. Par exemple, si une erreur se produit dans une série d'ajouts, de suppressions ou de modifications, elle peut être annulée et restaurée, mais MyISAM ne le peut pas.
MyISAM est plus adapté aux applications axées sur ; requêtes et insertions. InnoDB est plus adapté aux applications qui nécessitent des modifications fréquentes et impliquent une sécurité plus élevée
3) InnoDB prend en charge les clés étrangères, mais MyISAM ne le prend pas en charge
4) MyISAM est le moteur par défaut, et InnoDB doit l'être. spécifié.
5) InnoDB ne le prend pas en charge. Index de type FULLTEXT
6) InnoDB n'enregistre pas le nombre de lignes dans la table, par exemple, lors de la sélection de count(*) dans la table, InnoDB doit ; parcourez l'intégralité du tableau pour calculer le nombre de lignes, mais MyISAM n'a qu'à simplement le lire. Enregistrez simplement le nombre de lignes.
Notez que lorsque l'instruction count(*) contient la condition Where, MyISAM doit également analyser la table entière
7) Pour les champs auto-croissants, InnoDB doit contenir un index de ce champ uniquement, mais dans la table MyISAM ; cela peut être Créer un index commun avec d'autres champs ;
8) Lors de l'effacement de la table entière, InnoDB supprime les lignes une par une, ce qui est très lent. MyISAM reconstruira la table ;
9) InnoDB prend en charge les verrous de ligne (dans certains cas, la table entière est verrouillée, comme la mise à jour de l'ensemble de tables a=1 où un utilisateur comme ‘%lee%’
Q94. Décrivez comment le scrapy Le framework exécute le mécanisme ?
Récupérez le premier lot d'URL de start_urls et envoyez la requête. La requête est transmise au planificateur par le moteur et placée dans la file d'attente des requêtes,
.Le planificateur transmet la requête dans la file d'attente des requêtes au téléchargeur pour obtenir la ressource de réponse correspondant à la requête, et transmet la réponse à la méthode d'analyse écrite par lui-même pour le traitement d'extraction :
Si les données requises sont extraites, elles sont transmises passez au fichier pipeline pour traitement ;
2) Si l'URL est extraite, continuez à effectuer les étapes précédentes (envoyez la demande d'URL, et le moteur transmettra la demande au planificateur et la mettra dans la file d'attente...) jusqu'à ce qu'il n'y ait plus de requête dans la file d'attente des requêtes et que le programme se termine.
Joignez plusieurs tables pour la requête, y compris principalement la jointure interne, la jointure gauche, la jointure droite, la jointure complète (jointure externe)
Pour le code gourmand en E/S (traitement de fichiers, robots d'exploration Web, etc.), le multithreading peut améliorer efficacement l'efficacité (s'il y a des opérations d'E/S sous un seul thread, une attente d'E/S se produira, entraînant une perte de temps inutile,
et l'activation du multi-threading peut améliorer efficacement l'efficacité du thread A. En attendant, passez automatiquement au thread B, afin de ne pas gaspiller les ressources CPU, améliorant ainsi l'efficacité de l'exécution du programme).
Dans le processus de collecte de données proprement dit, vous devez prendre en compte non seulement les problèmes de vitesse et de réponse du réseau, mais également les conditions matérielles de votre propre machine pour configurer le multi-processus ou le multi-thread.
1) Optimisez les index, les instructions SQL et analysez les requêtes lentes ;
2) Optimisez le matériel ; utilisez le SSD, utilisez la technologie de file d'attente de disque (RAID0, RAID1, RDID5), etc.
3) Utilisez la propre technologie de partitionnement de table de MySQL ; , la superposition des données dans différents fichiers peut améliorer l'efficacité de la lecture du disque ;
4) Choisissez un moteur de table approprié et optimisez les paramètres
5) Effectuez une mise en cache, une statique et une distribution au niveau de l'architecture ;
6) Utilisez des méthodes de stockage plus rapides, telles que NoSQL pour stocker les données fréquemment consultées
1)ip
2)bandwidth
3)cpu
4)io
1) Scrapy est livré avec
2) Interface payante
1) L'anti-exploration des en-têtes demandé aux utilisateurs via l'anti-exploration des en-têtes est la stratégie anti-exploration la plus courante.
Vous pouvez ajouter des en-têtes directement au robot et copier l'agent utilisateur du navigateur dans les en-têtes du robot ou modifier la valeur du référent avec le nom de domaine du site Web cible.
2) Anti-crawler basé sur le comportement de l'utilisateur
En détectant le comportement de l'utilisateur, tel que la même adresse IP visitant la même page plusieurs fois sur une courte période, ou le même compte effectuant la même opération plusieurs fois sur une courte période du temps.
La plupart des sites Web se trouvent dans la première situation. Pour cette situation, l'utilisation d'un proxy IP peut la résoudre.
Vous pouvez écrire un robot d'exploration spécial pour explorer les adresses IP proxy publiées sur Internet et les enregistrer toutes après détection.
Une fois que vous disposez d'un grand nombre d'adresses IP proxy, vous pouvez modifier une adresse IP toutes les quelques requêtes. Ceci est facile à faire dans les requêtes ou dans urllib2, afin de pouvoir facilement contourner le premier anti-crawler.
Pour le deuxième cas, vous pouvez attendre aléatoirement quelques secondes après chaque demande avant de faire la demande suivante.
Certains sites Web présentant des failles logiques peuvent contourner la restriction selon laquelle le même compte ne peut pas faire la même demande plusieurs fois sur une courte période en demandant plusieurs fois, en se déconnectant, en se reconnectant et en continuant à demander.
3) Anti-crawler pour les pages dynamiques
Utilisez d'abord Fiddler pour analyser la requête réseau. Si nous pouvons trouver la requête ajax et analyser les paramètres spécifiques et la signification spécifique de la réponse, nous pouvons utiliser la méthode ci-dessus.
Utilisez des requêtes ou urllib2 pour simuler des requêtes ajax et analysez le format JSON de la réponse pour obtenir les données requises.
Mais certains sites Web chiffrent tous les paramètres de la requête ajax et ne peuvent pas construire la requête avec les données dont ils ont besoin.
Dans ce cas, utilisez selenium+phantomJS pour appeler le noyau du navigateur et utilisez phantomJS pour exécuter js afin de simuler des opérations humaines et déclencher des scripts js dans la page.
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
