Type Python hints from starting to Practice

Chat Python 2021-10-25 20:43:24
type python hints starting practice

Photos

Python Je suppose que tout le monde est déjà familier,Même l'argument selon lequel il est utile ou inutile peut être fatigué.Mais quoi qu'il en soit,,En tant que langue qui sera ajoutée à l'examen d'entrée à l'Université, elle a encore ses caractéristiques uniques,Aujourd'hui, nous allons commencer à parler Python.



Python Est un langage dynamique fortement typé


《Lisse Python》Dans un livre,Si une langue convertit rarement implicitement un type,C'est un langage fortement typé,Par exemple Java、C++ Et Python C'est un langage fortement typé.

Lecture étendue:PythonUn langage fortement typé,Ou un langage de type faible?

Photos

△  Python Forte représentation typologique de

En même temps, si une langue convertit souvent implicitement le type , C'est un langage faiblement typé ,PHP、JavaScript Et Perl C'est un langage de type faible.

Photos

△   Langage dynamique faiblement dactylographié :JavaScript

Bien sûr, cet exemple simple de comparaison ci - dessus , Ce n'est pas exactement Python Est un langage fortement typé,Parce que Java Même soutien integer Et string Ajouter une opération ,Et Java Est une langue fortement dactylographiée.Donc,《Lisse Python》 Le livre contient également des définitions des types statiques et dynamiques : La langue de vérification des types au moment de la compilation est la langue de type statique , .La langue pour vérifier le type au moment de l'exécution est la langue de type dynamique . Le langage statique nécessite un type de déclaration ( Certaines langues modernes utilisent la dérivation de type pour éviter les déclarations de type partiel ).

Photos

En résumé,À propos de Python C'est un langage dynamique et fortement dactylographié qui est évident et n'est pas controversé .



Type Hints Une enquête préliminaire


Python In PEP 484(Python Enhancement Proposals,Python Proposition améliorée)[https://www.python.org/dev/peps/pep-0484/]Proposé par Type Hints(Note de type).Encore renforcé Python Est une caractéristique d'un langage fortement typé ,Il est là. Python3.5 Pour la première fois .Utiliser Type Hints On pourrait écrire un Python Code, Il semble plus conforme au style de langage fortement typé .

Deux greeting Fonctions:

  • L'écriture normale est la suivante::

name = "world"
def greeting(name): return "Hello " + name
greeting(name)
  • Oui. Type Hints Est rédigé comme suit::

name: str = "world"
def greeting(name: str) -> str: return "Hello " + name
greeting(name)

Par PyCharm Par exemple,Lors de l'écriture du Code IDE Est dimensionné en fonction du type de fonction , Vérification de type des paramètres passés à la fonction . Si vous trouvez que le type d'argument ne correspond pas à l'annotation du type de paramètre de la fonction, vous serez invité comme suit :

Photos



Structure commune des données Type Hints Écrire


Ça passe par un greeting La fonction montre Type Hints Utilisation de, Ensuite, on va Python Structure commune des données Type Hints Écrire pour une étude plus approfondie .

Paramètres par défaut

Python La fonction prend en charge les paramètres par défaut , Voici les paramètres par défaut Type Hints Écrire, Il suffit d'écrire le type entre la variable et le paramètre par défaut .

def greeting(name: str = "world") -> str: return "Hello " + name
greeting()

Type personnalisé

Pour les types personnalisés,Type Hints Peut également être un bon soutien . C'est écrit comme Python Il n'y a pas de différence entre les types intégrés .

class Student(object): def __init__(self, name, age): self.name = name self.age = age

def student_to_string(s: Student) -> str: return f"student name: {s.name}, age: {s.age}."
student_to_string(Student("Tim", 18))

Lorsque les dimensions de type sont personnalisées ,IDE Le type peut également être vérifié .

Photos

Type de conteneur

Lorsque nous voulons ajouter une dimension de type à un type de conteneur intégré , En raison de l'opérateur d'annotation de type [] In Python Le milieu représente l'opération de tranchage , Une erreur de syntaxe est donc soulevée . Par conséquent, les types de conteneurs intégrés ne peuvent pas être utilisés directement comme annotations ,Besoin de typing Importer les annotations de type conteneur correspondantes dans le module ( Généralement en majuscules initiales de type intégré ).

from typing import List, Tuple, Dict
l: List[int] = [1, 2, 3]
t: Tuple[str, ...] = ("a", "b")
d: Dict[str, int] = { "a": 1, "b": 2,}

Mais PEP 585[https://www.python.org/dev/peps/pep-0585/]L'émergence de,On peut l'utiliser directement Python Type intégré pour, Sans erreur de syntaxe .

l: list[int] = [1, 2, 3]
t: tuple[str, ...] = ("a", "b")
d: dict[str, int] = { "a": 1, "b": 2,}

Alias de type

Certains types de nidification complexes sont longs à écrire , En cas de répétition ,Ça va être douloureux., Le Code ne sera pas assez propre .

config: list[tuple[str, int], dict[str, str]] = [ ("127.0.0.1", 8080), { "MYSQL_DB": "db", "MYSQL_USER": "user", "MYSQL_PASS": "pass", "MYSQL_HOST": "127.0.0.1", "MYSQL_PORT": "3306", },]
def start_server(config: list[tuple[str, int], dict[str, str]]) -> None: ...
start_server(config)

Ceci peut être résolu en alias le type , Noms de variables similaires .

Config = list[tuple[str, int], dict[str, str]]

config: Config = [ ("127.0.0.1", 8080), { "MYSQL_DB": "db", "MYSQL_USER": "user", "MYSQL_PASS": "pass", "MYSQL_HOST": "127.0.0.1", "MYSQL_PORT": "3306", },]
def start_server(config: Config) -> None: ...
start_server(config)

Pour que le Code semble plus confortable .

Paramètres variables

Python Un aspect très flexible de la fonction est le support pour les paramètres variables ,Type Hints Les dimensions de type pour les paramètres variables sont également prises en charge .

def foo(*args: str, **kwargs: int) -> None: ...
foo("a", "b", 1, x=2, y="c")

IDE Peut encore être vérifié .

Photos

Généralités

L'utilisation d'un langage dynamique nécessite un support générique ,Type Hints Plusieurs solutions sont également disponibles pour les génériques .

TypeVar

Utiliser TypeVar Peut recevoir n'importe quel type.

from typing import TypeVar
T = TypeVar("T")
def foo(*args: T, **kwargs: T) -> None: ...
foo("a", "b", 1, x=2, y="c")

Union

Si vous ne voulez pas utiliser les génériques , Vous ne voulez utiliser que quelques types spécifiés ,Alors on peut utiliser Union Fais - le..Comme la définition concat La fonction veut juste recevoir str Ou bytes Type.

from typing import Union
T = Union[str, bytes]
def concat(s1: T, s2: T) -> T: return s1 + s2
concat("hello", "world")concat(b"hello", b"world")concat("hello", b"world")concat(b"hello", "world")

IDE Voir la figure ci - dessous pour les conseils d'inspection :

Photos

TypeVar Et Union La différence

TypeVar Non seulement vous pouvez recevoir des génériques , Ça pourrait aussi ressembler à Union Utilisez la même chose, Il suffit de passer la plage de type que vous voulez spécifier en tant que paramètre à tour de rôle lors de l'Instanciation .Suivez - moi. Union La différence est,Utiliser TypeVar Fonctions déclarées, Le type Multi - Paramètres doit être le même ,Et Union Pas de restrictions.

from typing import TypeVar
T = TypeVar("T", str, bytes)
def concat(s1: T, s2: T) -> T: return s1 + s2
concat("hello", "world")concat(b"hello", b"world")concat("hello", b"world")

Voici comment TypeVar Lors de la qualification du type IDE Conseils:

Photos

Optional

Type Hints Offre Optional Pour agir comme Union[X, None] La forme abrégée de, Indique que le paramètre marqué est X Type,Ou None,Optional[X] Équivalent à Union[X, None].

from typing import Optional, Union
# None => type(None)def foo(arg: Union[int, None] = None) -> None: ...

def foo(arg: Optional[int] = None) -> None: ...

Any

Any Est un type particulier, Peut représenter tous les types .Aucune fonction spécifiée pour la valeur de retour et le type de paramètre,Est implicitement utilisé par défaut Any, Donc les deux suivants greeting L'écriture de la fonction est équivalente :

from typing import Any
def greeting(name): return "Hello " + name

def greeting(name: Any) -> Any: return "Hello " + name

Quand on veut utiliser Type Hints Pour implémenter l'écriture de type statique , Et je ne veux pas perdre la flexibilité qui caractérise le langage dynamique ,Prêt à l'emploi Any.

Any Lorsque la valeur de type est attribuée à un type plus précis ,Ne pas effectuer de vérification de type,Le code suivant IDE Il n'y a pas d'indice d'erreur :

from typing import Any
a: Any = Nonea = [] # Caractéristiques linguistiques dynamiques a = 2
s: str = ''s = a # Any Les valeurs de type sont attribuées à des types plus précis

Objet appelable(Fonctions、Classe, etc.)

Python .N'importe quel type appelable dans peut être utilisé Callable Dimensionnement. Dans l'annotation de code suivante Callable[[int], str],[int] Liste des paramètres représentant les types appelables ,str Représente la valeur de retour.

from typing import Callable
def int_to_str(i: int) -> str: return str(i)
def f(fn: Callable[[int], str], i: int) -> str: return fn(i)
f(int_to_str, 2)

Autoref

Quand nous devons définir la structure de l'arbre , L'auto - référence est souvent nécessaire .Lors de l'exécution __init__ La méthode Tree Type non généré , Donc ça ne peut pas être comme utiliser str Ce type intégré est également directement dimensionné , Doit être sous forme de chaîne “Tree” Pour faire référence à des objets non générés .

class Tree(object): def __init__(self, left: "Tree" = None, right: "Tree" = None): self.left = left self.right = right
tree1 = Tree(Tree(), Tree())

IDE Il est également possible de vérifier les types d'auto - références .

Photos

Ce formulaire peut être utilisé non seulement pour l'auto - référence , Les références antérieures s'appliquent également .

Type de canard

Python L'une des caractéristiques distinctives est son application massive aux types de canards ,Type Hints Offre Protocol Pour soutenir les types de canards . Pour définir une classe, il suffit d'hériter Protocol Vous pouvez déclarer un type d'interface , Lorsqu'une annotation d'un type d'interface est rencontrée , Tant que l'objet reçu implémente toutes les méthodes du type d'interface , Vous pouvez passer l'examen des annotations de type ,IDE Il n'y aurait pas d'erreur .Ici. Stream Pas besoin d'hériter explicitement Interface Catégorie, Il suffit de réaliser close La méthode est juste.

from typing import Protocol
class Interface(Protocol): def close(self) -> None: ...
# class Stream(Interface):class Stream: def close(self) -> None: ...
def close_resource(r: Interface) -> None: r.close()
f = open("a.txt")close_resource(f)
s: Stream = Stream()close_resource(s)

Grâce à l'intégration open Objet de fichier retourné par la fonction et Stream Les objets sont implémentés close Méthodes, Pour pouvoir passer à travers Type Hints Inspection,Et la chaîne“s”Non réalisé close Méthodes,Alors... IDE Une erreur de type est demandée .

Photos



Type Hints D'autres façons d'écrire


En fait, Type Hints Il n'y a pas qu'une seule écriture ,Python Deux autres types d'écriture ont été mis en œuvre pour tenir compte des préférences de différentes personnes et de la migration de l'ancien Code .

Écrivez avec des notes

Regarde - moi ça. tornado Exemple de cadre (tornado/web.py). S'applique aux modifications apportées à un projet existant , Le Code est écrit , Ajouter une dimension de type plus tard .

Photos

Écrit à l'aide d'un fichier séparé (.pyi)

Vous pouvez créer un nouveau répertoire dans le même répertoire que .py Homonyme .pyi Documentation,IDE Il est également possible de vérifier automatiquement le type . L'avantage est qu'il n'y a pas de changement au code original ,Découplage complet. L'inconvénient est qu'il faut maintenir deux codes en même temps .

Photos



Type Hints Pratique


En gros,, Couramment utilisé dans le codage quotidien Type Hints L'écriture a été présentée à tout le monde , Voyons comment nous pouvons l'appliquer dans le codage réel Type Hints.

dataclass——Classe de données

dataclass C'est un décorateur., Il peut décorer la classe , Utilisé pour ajouter des méthodes magiques à la classe ,Par exemple __init__() Et __repr__() Attendez.,Il est là. PEP 557[https://www.python.org/dev/peps/pep-0557/]Défini dans.

from dataclasses import dataclass, field

@dataclassclass User(object): id: int name: str friends: list[int] = field(default_factory=list)

data = { "id": 123, "name": "Tim",}
user = User(**data)print(user.id, user.name, user.friends)# > 123 Tim []

Utilisation ci - dessus dataclass Le code écrit est équivalent au code suivant :

class User(object): def __init__(self, id: int, name: str, friends=None): self.id = id self.name = name self.friends = friends or []

data = { "id": 123, "name": "Tim",}
user = User(**data)print(user.id, user.name, user.friends)# > 123 Tim []

Attention!:dataclass Le type de champ n'est pas vérifié .

On peut le découvrir.,Utiliser dataclass Pour écrire une classe, vous pouvez réduire beaucoup de code de modèle dupliqué , Plus de clarté grammaticale .

Pydantic

Pydantic Est basé sur Python Type Hints Bibliothèque de tiers pour, Il fournit la validation des données 、 Fonctions de sérialisation et de documentation , Est une bibliothèque très utile à apprendre . Voici un paragraphe à utiliser Pydantic Exemple de code pour:

from datetime import datetimefrom typing import Optional
from pydantic import BaseModel

class User(BaseModel): id: int name = 'John Doe' signup_ts: Optional[datetime] = None friends: list[int] = []

external_data = { 'id': '123', 'signup_ts': '2021-09-02 17:00', 'friends': [1, 2, '3'],}user = User(**external_data)
print(user.id)# > 123print(repr(user.signup_ts))# > datetime.datetime(2021, 9, 2, 17, 0)print(user.friends)# > [1, 2, 3]print(user.dict())"""{ 'id': 123, 'signup_ts': datetime.datetime(2021, 9, 2, 17, 0), 'friends': [1, 2, 3], 'name': 'John Doe',}"""

Attention!:Pydantic Contrôle obligatoire du type de champ .

Pydantic C'est écrit avec dataclass Très similaire, Mais il a fait plus de travail supplémentaire , Fournit également .dict() Cette méthode très pratique .

Encore un. Pydantic Exemple de validation des données ,Quand User Lorsque la classe a reçu un paramètre inattendu ,Va lancer ValidationError Anomalie, L'objet d'exception fournit .json() La méthode est pratique pour voir la cause de l'exception .

from pydantic import ValidationError
try: User(signup_ts='broken', friends=[1, 2, 'not number'])except ValidationError as e: print(e.json())"""[ { "loc": [ "id" ], "msg": "field required", "type": "value_error.missing" }, { "loc": [ "signup_ts" ], "msg": "invalid datetime format", "type": "value_error.datetime" }, { "loc": [ "friends", 2 ], "msg": "value is not a valid integer", "type": "type_error.integer" }]"""

Toutes les informations d'erreur sont stockées dans un list Moyenne, Le message d'erreur pour chaque champ est sauvegardé dans le nid dict Moyenne,Parmi eux loc Les champs d'exception et les emplacements d'erreur sont identifiés ,msg Pour signaler une erreur ,type Type d'erreur , De cette façon, toute la cause de l'erreur est claire .

MySQLHandler

MySQLHandler[https://github.com/jianghushinian/python-scripts/blob/main/scripts/mysql_handler_type_hints.py]C'est moi. pymysql Encapsulation de la bibliothèque, Pour qu'il supporte l'utilisation de with Appel syntaxique execute Méthodes, Et les résultats de la requête de tuple Remplacer par object, C'est aussi vrai Type Hints Application de.

class MySQLHandler(object): """MySQL handler"""
def __init__(self): self.conn = pymysql.connect( host=DB_HOST, port=DB_PORT, user=DB_USER, password=DB_PASS, database=DB_NAME, charset=DB_CHARSET, client_flag=CLIENT.MULTI_STATEMENTS, # execute multi sql statements ) self.cursor = self.conn.cursor()
def __del__(self): self.cursor.close() self.conn.close()
@contextmanager def execute(self): try: yield self.cursor.execute self.conn.commit() except Exception as e: self.conn.rollback() logging.exception(e)
@contextmanager def executemany(self): try: yield self.cursor.executemany self.conn.commit() except Exception as e: self.conn.rollback() logging.exception(e)
def _tuple_to_object(self, data: List[tuple]) -> List[FetchObject]: obj_list = [] attrs = [desc[0] for desc in self.cursor.description] for i in data: obj = FetchObject() for attr, value in zip(attrs, i): setattr(obj, attr, value) obj_list.append(obj) return obj_list
def fetchone(self) -> Optional[FetchObject]: result = self.cursor.fetchone() return self._tuple_to_object([result])[0] if result else None
def fetchmany(self, size: Optional[int] = None) -> Optional[List[FetchObject]]: result = self.cursor.fetchmany(size) return self._tuple_to_object(result) if result else None
def fetchall(self) -> Optional[List[FetchObject]]: result = self.cursor.fetchall() return self._tuple_to_object(result) if result else None

Vérification du type d'exécution

Type Hints Pourquoi? Hints Au lieu de Check, C'est parce que c'est juste un indice de type, pas un vrai contrôle . Ce qui est montré ci - dessus Type Hints Utilisation,En fait, c'est IDE Pour nous aider à remplir la fonction de vérification de type ,Mais en fait,,IDE La vérification de type pour ne pas déterminer si une erreur est signalée pendant l'exécution du Code , La fonction de vérification syntaxique n'est disponible qu'en période statique .

Pour implémenter une vérification de type forcée pendant la phase d'exécution du Code , Nous devons écrire notre propre code ou introduire des bibliothèques tierces ( Comme décrit ci - dessus Pydantic). Je passe par un type_check La fonction implémente le type de vérification dynamique en cours d'exécution , Pour votre information :

from inspect import getfullargspecfrom functools import wrapsfrom typing import get_type_hints

def type_check(fn): @wraps(fn) def wrapper(*args, **kwargs): fn_args = getfullargspec(fn)[0] kwargs.update(dict(zip(fn_args, args))) hints = get_type_hints(fn) hints.pop("return", None) for name, type_ in hints.items(): if not isinstance(kwargs[name], type_): raise TypeError(f"expected {type_.__name__}, got {type(kwargs[name]).__name__} instead") return fn(**kwargs)
return wrapper

# name: str = "world"name: int = 2
@type_checkdef greeting(name: str) -> str: return str(name)
print(greeting(name))# > TypeError: expected str, got int instead

Il suffit de donner greeting La fonction frappe type_check Décorateur, La vérification du type d'exécution peut être réalisée .


Annexe

Si vous souhaitez continuer à apprendre à utiliser Python Type Hints, Voici quelques - uns des projets open source que je vous recommande :

  • Pydantic [https://github.com/samuelcolvin/pydantic]

  • FastAPI [https://github.com/tiangolo/fastapi]

  • Tornado [https://github.com/tornadoweb/tornado]

  • Flask [https://github.com/pallets/flask]

  • Chia-pool [https://github.com/Chia-Network/pool-reference]

  • MySQLHandler [https://github.com/jianghushinian/python-scripts/blob/main/scripts/mysql_handler_type_hints.py]

Photos
PythonCAT Technology Exchange Group est ouvert!Il y a des employés en service dans les grandes usines nationales de première et de deuxième ligne,Il y a aussi des universités nationales et étrangères qui étudient des étudiants,Il y a plus d'une décennie de vieux oiseaux programmés,Il y a aussi de nouveaux élèves qui viennent d'entrer dans les écoles primaires et secondaires,Bonne atmosphère d'étude!Les étudiants qui veulent entrer dans le Groupe,S'il vous plaît, répondez à『 Groupe AC』,Obtenez Wechat Brother (Refuser le parti publicitaire,Si c'est vrai.!)~


Pas encore accro?Essayez - les




Python Artefact Celery Analyse du code source(2)

Django3 Utiliser WebSocket Réalisation WebShell

Un petit site pourri ,C'est plus que ça. Python Le site officiel n'est pas

Python Qu'est - ce qui se passe avec les soulignements dans les valeurs ?

PythonÀ gauche., Maths à droite : L'étude des nombres premiers d'uram

PythonUn langage fortement typé,Ou un langage de type faible?


Si vous trouvez cet article utile
S'il vous plaît, soyez généreuxPartagerEt - Oui. ,Merci beaucoup.
PythonCAT
PythonCAT
PartagerPythonNiveau avancé、PythonPhilosophie、Traduction d'articles、Outils de ressources, etc.
143Contenu original
Numéro public
版权声明
本文为[Chat Python]所创,转载请带上原文链接,感谢
https://pythonmana.com/2021/10/20211025204000292c.html

  1. Python + sélénium implémente le téléchargement automatique et la publication d'une démonstration d'instance vidéo courte et belle
  2. Python爬虫能当副业吗?到了哪个层次能接单?解析能挣钱的方式
  3. 大佬今天教你用python制作五款简单又好玩的小游戏
  4. Les reptiles Python peuvent - ils être une entreprise secondaire? À quel niveau les commandes peuvent - elles être reçues? Analyse des moyens de gagner de l'argent
  5. Python+微信小程序开发(五)for指令和上传图片
  6. Python+微信小程序开发(四)页面跳转和获取用户信息
  7. Python+微信小程序开发(三)开发小程序及页面布局
  8. If I had these resources when I first learned python, I wouldn't have been tortured for so long!
  9. If you want to learn Python well, [container / iteratable object / iterator / generator] must learn Python steadily!
  10. 用Python定义一个函数用于比较两个数并返回较大的数
  11. 用Python定義一個函數用於比較兩個數並返回較大的數
  12. Définir une fonction en python pour comparer deux nombres et renvoyer un nombre plus grand
  13. python自定义错误self.args是什么意思
  14. Que signifie Python Custom Error self.args
  15. 用python编写一个用n填充列表的程序
  16. 用python編寫一個用n填充列錶的程序
  17. Écrivez un programme qui remplit la liste avec n en python
  18. 你需要知道的 20 个 Python 技巧
  19. Python development learning how to quickly enter the programming industry
  20. 20 conseils Python que vous devez connaître
  21. python中关于数列删减问题
  22. Python frequently asked questions - PIP install specifies the requirements.txt exported by the poetry, and an error is reported: in -- require hashes mode, all req
  23. Sur le problème de la réduction des séries en python
  24. 关于Python安装的问题(不知道自己下的什么)
  25. What do Python's u, R, B, f mean?
  26. Actual combat! Why is Changjin lake so popular? I use Python to analyze cat eye reviews.
  27. Python用xpath定位正确返回的是返回空值
  28. Python error handling
  29. django_celery_beat的clocked定时任务不触发
  30. Python renvoie une valeur nulle si elle est correctement retournée en utilisant XPath
  31. 关于#python#的问题:sqlalchemy.exc.ProgrammingError: (pymysql.err.ProgrammingError)
  32. python + selenium 能定位出来算你厉害
  33. Python + sélénium peut vous localiser.
  34. Python code reading (Chapter 13): check whether the elements in the list are the same
  35. Python online retail data association rule mining Apriori algorithm data visualization
  36. python习题,要求用for循环和if语句。
  37. 用Python获得女友聊天记录,一招解决疑神疑鬼
  38. Obtenez le chat de votre petite amie en python pour résoudre les problèmes
  39. Les exercices Python nécessitent des boucles pour et des énoncés if.
  40. Python code reading (Chapter 13): check whether the elements in the list are the same
  41. 练手练到阅文集团作家中心了,python crawlspider 二维抓取学习
  42. python阶乘和数题,要求用for循环,if语句
  43. Python 求最大幂次,用while循环
  44. L'entraîneur s'est entraîné au centre d'écriture du Groupe Yuewen, Python crawlspider 2D grapping Learning
  45. 这六个Python程序的代码要怎么写
  46. Python calcule la puissance maximale et utilise la Boucle while
  47. python入门:请问怎么避免用户输入相同内容呢
  48. python用迭代法求平方根要求用while循环
  49. Comment écrire le Code de ces six programmes Python
  50. python用迭代法求平方根要求用while循環
  51. Python a besoin d'une Boucle while pour trouver la racine carrée par itération
  52. Démarrer avec Python: Comment puis - je empêcher les utilisateurs d'entrer le même contenu?
  53. 这么多的内置函数能记住吗?对python的68个内置函数分类总结!
  54. 這麼多的內置函數能記住嗎?對python的68個內置函數分類總結!
  55. Est - ce que tant de fonctions intégrées peuvent être mémorisées? Résumé de la classification des 68 fonctions intégrées de Python!
  56. 这么多的内置函数能记住吗?对python的68个内置函数分类总结!
  57. Est - ce que tant de fonctions intégrées peuvent être mémorisées? Résumé de la classification des 68 fonctions intégrées de Python!
  58. python 假设lst=[3,4,12,[6,9,12,24],[12,18,34]]统计list中包含元素12的个数
  59. python 假設lst=[3,4,12,[6,9,12,24],[12,18,34]]統計list中包含元素12的個數
  60. Python suppose que LST = [3,4,12, [6,9,12,24], [12,18,34]] compte le nombre d'éléments 12 dans la Liste