Cette fois, je vais expliquer les listes, les taples et les dictionnaires parmi les types de données Python. C'est l'explication de Python après une longue période. Comparez avec la méthode et la méthode de déclaration Java.
Un type de données qui maintient l'ordre de plusieurs éléments et représente un ensemble de chaque élément. Déclarez en insérant []. Si vous souhaitez définir les éléments au moment de la déclaration, déclarez les éléments entre [] séparés par des virgules.
Chaque élément est accessible par index, et l'indice de la liste a de longueur n est 0..n-1. L'élément mth (1 <= m <= n) peut être obtenu avec un [m -1].
Python
a = ["1-1", "1-2", "1-3", "1-4", "1-5"]
print(a[1]) # ⇒ 1-2
De même en Java, l'élément mth (1 <= m <= n) peut être obtenu avec a.get (m -1).
Java
List<String> a = new ArrayList<String>(Arrays.asList(new String[]{"1-1", "1-2", "1-3", "1-4", "1-5"}));
System.out.println(a.get(1)); // ⇒ 1-2;
Pour obtenir la taille de la liste, utilisez la fonction len.
Python
a = ["1-1", "1-2", "1-3", "1-4", "1-5"]
print(len(a)) # ⇒ 5
Java utilise la méthode de la taille.
Java
List<String> a = new ArrayList<String>(Arrays.asList(new String[]{"1-1", "1-2", "1-3", "1-4", "1-5"}));
System.out.println(a.size()); // ⇒ 5
Joindre des listes en python utilise l'opérateur +. Cette fonction joint les listes ensemble pour créer une nouvelle liste. Par conséquent, cela n'affecte pas la liste d'origine.
Python
a = ["1-1", "1-2", "1-3", "1-4", "1-5"]
b = ["2-1", "2-2", "2-3", "2-4", "2-5"]
print(a + b) # ⇒ ['1-1', '1-2', '1-3', '1-4', '1-5', '2-1', '2-2', '2-3', '2-4', '2-5']
print(a) # ⇒ ['1-1', '1-2', '1-3', '1-4', '1-5']
print(b) # ⇒ ['2-1', '2-2', '2-3', '2-4', '2-5']
Il ne semble pas y avoir de très bon moyen en Java. Il semble que je n'ai pas d'autre choix que d'ajouter tous les éléments a et b à la nouvelle liste.
Java
List<String> a = new ArrayList<String>(Arrays.asList(new String[]{"1-1", "1-2", "1-3", "1-4", "1-5"}));
List<String> b = new ArrayList<String>(Arrays.asList(new String[]{"2-1", "2-2", "2-3", "2-4", "2-5"}));
List<String> c = new ArrayList<String>();
c.addAll(a);
c.addAll(b);
System.out.println(c); // ⇒ [1-1, 1-2, 1-3, 1-4, 1-5, 2-1, 2-2, 2-3, 2-4, 2-5]
Il existe deux façons d'ajouter un élément à une liste: ajouter un élément et ajouter une liste à la liste entière. Tout d'abord, utilisez les méthodes append et insert pour ajouter un élément. append ajoute un élément à la fin de la liste. insert ajoute l'élément à la position d'index spécifiée.
Python
a = ["1-1", "1-2", "1-3", "1-4", "1-5"]
#Ajoutez-le à la fin de la liste.
a.append("1-7")
print(a) # ⇒ ['1-1', '1-2', '1-3', '1-4', '1-5', '1-7']
#S'ajoute à l'emplacement d'index spécifié.
a.insert(5, "1-6")
print(a) # ⇒ ['1-1', '1-2', '1-3', '1-4', '1-5', '1-6', '1-7']
En Java, les deux utilisent la méthode add.
Java
List<String> a = new ArrayList<String>(Arrays.asList(new String[]{"1-1", "1-2", "1-3", "1-4", "1-5"}));
a.add("1-7");
System.out.println(a); // ⇒ [1-1, 1-2, 1-3, 1-4, 1-5, 1-7]
a.add(5, "1-6");
System.out.println(a); // ⇒ [1-1, 1-2, 1-3, 1-4, 1-5, 1-6, 1-7]
Ajoutez ensuite une liste à la liste complète. Utilisez la méthode extend. Vous pouvez ajouter tous les éléments de la liste en spécifiant la liste comme argument.
Python
a = ["1-1", "1-2", "1-3", "1-4", "1-5"]
b = ["2-1", "2-2", "2-3", "2-4", "2-5"]
a.extend(b)
print(a) # ⇒ ['1-1', '1-2', '1-3', '1-4', '1-5', '2-1', '2-2', '2-3', '2-4', '2-5']
Je l'ai déjà écrit en Java, mais vous pouvez l'ajouter en utilisant la méthode addAll.
Java
List<String> a = new ArrayList<String>(Arrays.asList(new String[]{"1-1", "1-2", "1-3", "1-4", "1-5"}));
List<String> b = new ArrayList<String>(Arrays.asList(new String[]{"2-1", "2-2", "2-3", "2-4", "2-5"}));
a.addAll(b);
System.out.println(a); // ⇒ [1-1, 1-2, 1-3, 1-4, 1-5, 2-1, 2-2, 2-3, 2-4, 2-5]
Utilisez "in" pour voir si un élément est dans la liste. True est retourné s'il existe, False s'il n'existe pas.
Python
a = ["1-1", "1-2", "1-3", "1-4", "1-5", ["1-2", "1-3"]]
print("1-2" in a) # ⇒ True
print("1-6" in a) # ⇒ False
#Vous pouvez également vérifier si la liste existe dans la liste comme suit.
print(["1-2", "1-3"] in a) # ⇒ True
Java utilise la méthode contains.
Java
a = new ArrayList<String>(Arrays.asList(new String[]{"1-1", "1-2", "1-3", "1-4", "1-5"}));
System.out.println(a.contains("1-2")); // ⇒ true
System.out.println(a.contains("1-6")); // ⇒ false
Pour découper un élément, spécifiez-le au format [n: m] comme une chaîne de caractères.
Python
a = ["1-1", "1-2", "1-3", "1-4", "1-5"]
#Index 2 à index 4 (4 non inclus)
print(a[2:4]) # ⇒ ['1-3', '1-4']
#De l'index 2 à la fin
print(a[2:]) # ⇒ ['1-3', '1-4', '1-5']
#Jusqu'à l'index 4 (4 non inclus)
print(a[:4]) # ⇒ ['1-1', '1-2', '1-3', '1-4']
#Obtenez tous les deux
print(a[::2]) # ⇒ ['1-1', '1-3', '1-5']
Java utilise la méthode subList. Les arguments sont l'index de début de coupe et l'index de fin (non inclus).
Java
List<String> a = new ArrayList<String>(Arrays.asList(new String[]{"1-1", "1-2", "1-3", "1-4", "1-5"}));
//Index 2 à index 4 (4 non inclus)
System.out.println(a.subList(2, 4)); // ⇒ [1-3, 1-4]
//De l'index 2 à la fin
System.out.println(a.subList(2, a.size())); // ⇒ [1-3, 1-4, 1-5]
//Jusqu'à l'index 4 (4 non inclus)
System.out.println(a.subList(0, 4)); // ⇒ [1-1, 1-2, 1-3, 1-4]
//Est-il impossible d'obtenir tous les deux si le filtre n'est pas appliqué avec Stream?
Ensuite, j'expliquerai le tapple. Un tuple est une liste dont le contenu ne peut pas être modifié. Par conséquent, l'utilisation d'une méthode qui modifie un élément qui n'est pas un taple entraînera une erreur. Sauf si vous le modifiez, aucune erreur ne se produira. Il est également possible d'ajouter le taple lui-même à la liste.
Python
a = ("1-1", "1-2", "1-3", "1-4", "1-5")
a.append("1-6") # ⇒ AttributeError: 'tuple' object has no attribute 'append'
c = ["1-1"];
c.extend(a)
print(c) # ⇒ ['1-1', '1-1', '1-2', '1-3', '1-4', '1-5']
Les listes qui ne peuvent pas être modifiées en Java peuvent être créées à l'aide de Collections.unmodifiableList. Bien sûr, vous pouvez créer votre propre classe. Vous pouvez également créer une carte immuable dans la classe Collections, donc si vous avez le temps, vous pouvez y jeter un œil.
Java
List<String> a = new ArrayList<String>(Arrays.asList(new String[]{"1-1", "1-2", "1-3", "1-4", "1-5"}));
List<String> unmodifList = Collections.unmodifiableList(a);
unmodifList.add("1-1"); // ⇒ UnsupportedOperationException
Comme une liste, c'est un type de collection, mais contrairement à une liste, il n'a pas d'ordre. Au lieu de cela, la valeur est gérée par la clé et la valeur correspondante. La méthode de déclaration consiste à le mettre entre crochets ({}) et à déclarer la clé et la valeur séparées par deux points (:). Séparez-les par une virgule (,) pour déclarer les valeurs suivantes.
Python
a = {"key" : "value", "A" : "13 ans", "B" : "15 ans"}
print(a) # ⇒ {'key': 'value', 'A': '13 ans', 'B': '15 ans'}
C'est une carte à Java. Il n'existe aucun moyen de définir la valeur initiale dans Java Map.
Java
Map<String, String> map = new HashMap<String, String>();
System.out.println(map); // ⇒{}
Il n'existe aucune méthode pour ajouter un élément au type de dictionnaire. Ajoutez en spécifiant directement la clé et la valeur de la variable de type dictionnaire.
Python
a = {"key" : "value", "A" : "13 ans", "B" : "15 ans"}
a["C"] = "16 ans"
print(a) # ⇒ {'key': 'value', 'A': '13 ans', 'B': '15 ans', 'C': '16 ans'}
Utilisez la méthode put en java.
Java
Map<String, String> map = new HashMap<String, String>();
map.put("A", "13 ans");
map.put("B", "15 ans");
map.put("C", "16 ans");
System.out.println(map); // ⇒{A=13 ans, B=15 ans, C=16 ans}
Utilisez "in" pour vérifier si une clé existe dans une variable de type dictionnaire.
Python
a = {"key" : "value", "A" : "13 ans", "B" : "15 ans"}
print("A" in a) # ⇒ True
print("C" in a) # ⇒ False
Java utilise la méthode containsKey. Il existe également une méthode containsValue qui vous permet de vérifier si elle est incluse dans Value autre que la clé. Il ne semble y avoir aucune méthode correspondant à containsValue en python.
Java
Map<String, String> map = new HashMap<String, String>();
map.put("A", "13 ans");
map.put("B", "15 ans");
System.out.println(map.containsKey("A")); // ⇒ true
System.out.println(map.containsKey("C")); // ⇒ false
System.out.println(map.containsValue("15 ans")); // ⇒ true
System.out.println(map.containsValue("16 ans")); // ⇒ false
Utilisez la méthode get pour obtenir la valeur. La méthode get spécifie la clé pour obtenir la valeur Value. Si la clé n'existe pas, None sera retourné. Si la clé n'existe pas, vous aurez peut-être du mal à renvoyer None. Dans ce cas, définissez la valeur par défaut dans le deuxième argument de get. Ensuite, si la valeur de clé existe, la valeur par défaut spécifiée est renvoyée.
Python
a = {"key" : "value", "A" : "13 ans", "B" : "15 ans"}
print(a.get("A")) #⇒ 13 ans
print(a.get("C")) # ⇒ None
print(a.get("A", "10 ans")) #⇒ 13 ans
print(a.get("C", "10 ans")) # ⇒ 10 ans
Java utilise également la méthode get pour obtenir la valeur correspondant à la clé. Si vous souhaitez définir une valeur par défaut et l'obtenir, utilisez la méthode getOrDefault. L'utilisation est la même que la spécification de la valeur par défaut de python. Cette méthode a été ajoutée à partir de Java 8. Merci d'être sobre.
Java
Map<String, String> map = new HashMap<String, String>();
map.put("A", "13 ans");
map.put("B", "15 ans");
System.out.println(map.get("A")); //⇒ 13 ans
System.out.println(map.get("C")); // ⇒ null
System.out.println(map.getOrDefault("A", "10 ans")); //⇒ 13 ans
System.out.println(map.getOrDefault("C", "10 ans")); // ⇒ null
Si vous souhaitez enregistrer toutes les clés dans le dictionnaire, utilisez la méthode keys. La clé enregistrée sera renvoyée dans un format de liste. Cependant, la commande n'est pas garantie. J'ai pensé, mais une classe appelée dict_keys a été renvoyée. Pour en profiter, vous devez utiliser l'instruction for.
Python
a = {"A" : "13 ans", "B" : "15 ans"}
print(a.keys()) # ⇒ dict_keys(['A', 'B'])
for key in a.keys():
print(key)# ⇒ 'A'Quand'B'
En java, utilisez la méthode keySet. Cette méthode retourne un jeu de clés dans la classe Set.
Java
Map<String, String> map = new HashMap<String, String>();
map.put("A", "13 ans");
map.put("B", "15 ans");
System.out.println(map.keySet()); // ⇒ [A, B]
for (String s : map.keySet()) {
System.out.println(s); // ⇒ A, B
}
Si vous souhaitez enregistrer les valeurs dans le dictionnaire, utilisez la méthode values. Une classe appelée dict_values sera renvoyée. Pour en profiter, vous devez utiliser l'instruction for.
Python
a = {"A" : "13 ans", "B" : "15 ans"}
print(a.values()) # ⇒ dict_values(['13 ans', '15 ans'])
for value in a.values():
print(value) # ⇒ '13 ans'Quand'15 ans'
En java, utilisez la méthode keySet. Cette méthode retourne un jeu de clés dans la classe Set.
Java
Map<String, String> map = new HashMap<String, String>();
map.put("A", "13 ans");
map.put("B", "15 ans");
System.out.println(map.values()); // ⇒ [13 ans,15 ans]
for (String s : map.values()) {
System.out.println(s); //⇒ 13 ans,15 ans
}
Si vous souhaitez enregistrer la clé et la valeur dans le dictionnaire, utilisez la méthode items. Une classe appelée dict_items sera renvoyée. Pour en profiter, vous devez utiliser l'instruction for.
Python
a = {"A" : "13 ans", "B" : "15 ans"}
print(a.items()) # ⇒ dict_items([('A', '13 ans'), ('B', '15 ans')])
for key, value in a.items():
print(key, value) #⇒ A 13 ans,B 15 ans
En java, utilisez la méthode entrySet. Cette méthode retourne une clé et une valeur Entry dans la classe Set.
Java
Map<String, String> map = new HashMap<String, String>();
map.put("A", "13 ans");
map.put("B", "15 ans");
System.out.println(map.entrySet()); // ⇒ [A=13 ans, B=15 ans]
for (Entry<String, String> e : map.entrySet()) {
System.out.println(e.getKey()); // ⇒ A, B
System.out.println(e.getValue()); //⇒ 13 ans,15 ans
}
Il semble que les objets renvoyés par values (), keys (), items () soient des objets de vue. L'objet de vue fournit une vue dynamique des éléments du dictionnaire, mais il semble que la valeur de la vue change à mesure que la valeur du dictionnaire d'origine change.
Python
a = {"A" : "13 ans", "B" : "15 ans"}
items = a.items()
print(items) # ⇒ dict_items([('A', '13 ans'), ('B', '15 ans')])
#L'ajout d'éléments augmentera les éléments de l'objet de vue
a["C"] = "16 ans"
print(items) # ⇒ dict_items([('A', '13 ans'), ('B', '15 ans'), ('C', '16 ans')])
#Si vous supprimez l'élément, l'élément de l'objet de vue disparaît également
a.pop("A")
print(items) # ⇒ dict_items([('B', '15 ans'), ('C', '16 ans')])
#Si vous modifiez l'élément, l'élément de l'objet de vue change également
a["B"] = "14 ans"
print(items) # ⇒ dict_items([('B', '14 ans'), ('C', '16 ans')])
c'est tout. Dans l'ensemble, je pense que Python est plus facile à écrire.
Recommended Posts