Maîtrise complète de Python

Python est un langage de programmation de haut niveau dont la philosophie de conception principale est la lisibilité et la syntaxe du code, permettant aux programmeurs d'exprimer leurs idées avec très peu de code. Python est un langage qui permet une programmation élégante. Cela rend l'écriture de code et la mise en œuvre de mes idées simples et naturelles. Nous pouvons utiliser Python dans de nombreux endroits : la science des données, le développement Web, l'apprentissage automatique, etc. peuvent tous être développés à l'aide de Python. Quora, Pinterest et Spotify utilisent tous Python pour leur développement Web backend. Alors apprenons Python.

Bases de Python

1. Variables

Vous pouvez considérer une variable comme un mot utilisé pour stocker une valeur. Regardons un exemple.

Il est très simple de définir une variable et de lui attribuer une valeur en Python. Essayons si vous souhaitez stocker le chiffre 1 dans la variable « un » :

one = 1

Super simple, non ? Il suffit d'attribuer la valeur 1 à la variable "one".

two = 2
some_number = 10000

Vous pouvez attribuer n'importe quelle valeur à n'importe quelle autre variable aussi longtemps que vous le souhaitez. Comme vous pouvez le voir ci-dessus, la variable « deux » stocke la variable entière 2 et la variable « some_number » stocke 10 000.

En plus des entiers, nous pouvons également utiliser des valeurs booléennes (True/Flase), des chaînes, des virgules flottantes et d'autres types de données.

# booleanstrue_boolean = Truefalse_boolean = False# stringmy_name = "Leandro Tk"# floatbook_price = 15.80

2. Flux de contrôle : instruction conditionnelle

« If » utilise une expression pour déterminer si une instruction est vraie ou fausse. Si elle est vraie, exécutez le code dans if,. exemple Comme suit :

if True:
  print("Hello Python If")if 2 > 1:
  print("2 is greater than 1")

2 est supérieur à 1 , donc le code d'impression est exécuté.

Lorsque l'expression à l'intérieur de "if" est fausse, l'instruction "else" sera exécutée.

if 1 > 2:
  print("1 is greater than 2")else:
  print("1 is not greater than 2")

1 est plus petit que 2 , donc le code à l'intérieur de « else » sera exécuté.

Vous pouvez également utiliser l'instruction "elif" :

if 1 > 2:
  print("1 is greater than 2")elif 2 > 1:
  print("1 is not greater than 2")else:
  print("1 is equal to 2")

3. Boucles et itération

En Python, nous pouvons itérer sous différentes formes. Je parlerai de quand et pour.

Boucle While : lorsque l'instruction est vraie, le bloc de code à l'intérieur du while sera exécuté. Le code suivant affichera donc 1 à 10 .

num = 1while num <= 10:
    print(num)
    num += 1

La boucle while nécessite une condition de boucle. Si la condition est toujours vraie, elle itérera toujours. Lorsque la valeur de num est 11, la condition de boucle est fausse.

Un autre morceau de code peut vous aider à mieux comprendre l'utilisation de l'instruction while :

loop_condition = Truewhile loop_condition:
    print("Loop Condition keeps: %s" %(loop_condition))
    loop_condition = False

La condition de la boucle est True, elle continuera donc à itérer jusqu'à ce qu'elle soit False.

For Loop : Vous pouvez appliquer la variable " num " sur un bloc de code et l'instruction "for" le parcourra pour vous. Ce code imprimera le même code que dans while : de 1 à 10 .

for i in range(1, 11):
  print(i)

L'avez-vous vu ? C'est trop simple. La plage de i commence à partir de 1 et va jusqu'au 11ème élément (10 est le dixième élément)

Liste : Collection | Tableau | Structure de données

Si vous souhaitez stocker un entier dans une variable 1, mais vous devez également stocker 2 et 3, 4, 5...

Au lieu d'utiliser des centaines ou des milliers de variables, existe-t-il un autre moyen pour moi de stocker ces entiers que je souhaite stocker ? Comme vous l’aurez deviné, il existe d’autres moyens de les stocker.

Une liste est une collection qui peut stocker une colonne de valeurs (tout comme celles que vous souhaitez stocker), alors utilisons-la :

my_integers = [1, 2, 3, 4, 5]

C'est vraiment simple. Nous créons un tableau appelé my_integer et y stockons les données.

Peut-être vous demanderez-vous : "Comment puis-je obtenir les valeurs dans le tableau ?"

Bonne question. Les listes ont un concept appelé indexation. Le premier élément du tableau inférieur est l'index 0 (0). L'indice du second est 1, et ainsi de suite, vous devez comprendre.

Pour que ce soit plus concis, nous pouvons représenter l'élément du tableau par son index. Je l'ai dessiné :

En utilisant la syntaxe Python, il est également facile à comprendre :

my_integers = [5, 7, 1, 3, 4]
print(my_integers[0]) # 5print(my_integers[1]) # 7print(my_integers[4]) # 4

Si vous ne souhaitez pas stocker d'entiers. Vous souhaitez simplement stocker quelques chaînes, comme une liste des noms de vos proches. Le mien ressemble à ceci :

relatives_names = [  "Toshiaki",  "Juliana",  "Yuji",  "Bruno",  "Kaio"]
print(relatives_names[4]) # Kaio

Son principe est le même que celui du stockage d'entiers, ce qui est très convivial.

Nous avons seulement appris comment fonctionne l'indexation d'une liste, je dois aussi vous expliquer comment ajouter un élément à la structure de données de la liste (ajouter un élément à la liste).

La méthode la plus courante pour ajouter de nouvelles données à une liste est l'épissage. Voyons comment il est utilisé :

bookshelf = []
bookshelf.append("The Effective Engineer")
bookshelf.append("The 4 Hour Work Week")
print(bookshelf[0]) # The Effective Engineerprint(bookshelf[1]) # The 4 Hour Work W

L'épissage est super simple, il vous suffit de passer un élément (comme "machine efficace") comme paramètre d'épissage.

D'accord, c'est assez de connaissances sur les listes, regardons d'autres structures de données.

Dictionnaire : structure de données clé-valeur

Nous savons maintenant que List est une collection indexée de nombres entiers. Mais que se passe-t-il si nous ne voulons pas utiliser d’entiers comme index ? Nous pouvons utiliser d'autres structures de données, telles que des nombres, des chaînes ou d'autres types d'index.

Apprenons-en davantage sur la structure des données du dictionnaire. Un dictionnaire est une collection de paires clé-valeur. Le dictionnaire ressemble presque à ceci :

dictionary_example = {
  "key1": "value1",
  "key2": "value2",
  "key3": "value3"
}

Key 是指向  value  的索引。我们如何访问字典中的  value  呢？你应该猜到了，那就是使用  key 。 我们试一下：

dictionary_tk = {
  "name": "Leandro",
  "nickname": "Tk",
  "nationality": "Brazilian"
}
print("My name is %s" %(dictionary_tk["name"])) # My name is Leandro
print("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tk
print("And by the way I'm %s" %(dictionary_tk["nationality"])) # And by the way I'm Brazilian

我们有个 key (age) value (24），使用字符串作为  key  整型作为  value  。

我创建了一个关于我的字典，其中包含我的名字、昵称和国籍。这些属性是字典中的 key 。

就像我们学过的使用索引访问 list 一样，我们同样使用索引（在字典中 key 就是索引）来访问存储在字典中的 value  。

正如我们使用 list 那样，让我们学习下如何向字典中添加元素。字典中主要是指向 value 的 key 。当我们添加元素的时候同样如此：

dictionary_tk = {
  "name": "Leandro",
  "nickname": "Tk",
  "nationality": "Brazilian",
  "age": 24
}
print("My name is %s" %(dictionary_tk["name"])) # My name is Leandro
print("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tk
print("And by the way I'm %i and %s" %(dictionary_tk["age"], dictionary_tk["nationality"])) # And by the way I'm Brazilian

我们只需要将一个字典中的一个 key 指向一个  value  。没什么难的，对吧？

迭代：通过数据结构进行循环

跟我们在 Python 基础中学习的一样，List 迭代十分简单。我们 Python 开发者通常使用 For 循环。我们试试看：

bookshelf = [
  "The Effective Engineer",
  "The 4 hours work week",
  "Zero to One",
  "Lean Startup",
  "Hooked"
]
for book in bookshelf:
    print(book)

对于在书架上的每本书，我们打印（ 可以做任何操作 ）到控制台上。超级简单和直观吧。这就是 Python 的美妙之处。

对于哈希数据结构，我们同样可以使用 for 循环，不过我们需要使用 key 来进行：

dictionary = { "some_key": "some_value" }
for key in dictionary:
   print("%s --> %s" %(key, dictionary[key])) # some_key --> some_value

上面是如何在字典中使用 For 循环的例子。对于字典中的每个 key ，我们打印出 key 和 key 所对应的 value 。

另一种方式是使用 iteritems 方法。

dictionary = { "some_key": "some_value" }
for key, value in dictionary.items():
    print("%s --> %s" %(key, value))# some_key --> some_value

我们命名两个参数为 key 和 value ，但是这不是必要的。我们可以随意命名。我们看下：

dictionary_tk = {
  "name": "Leandro",
  "nickname": "Tk",
  "nationality": "Brazilian",
  "age": 24
}
for attribute, value in dictionary_tk.items():
    print("My %s is %s" %(attribute, value))
    
# My name is Leandro
# My nickname is Tk
# My nationality is Brazilian
# My age is 24

可以看到我们使用了 attribute 作为字典中 key 的参数，这与使用 key 命名具有同样的效果。真是太棒了！

类&对象

一些理论:

对象是对现实世界实体的表示，如汽车、狗或自行车。 这些对象有两个共同的主要特征： 数据 和 行为 。

汽车有 数据 ，如车轮的数量，车门的数量和座位的空间，并且它们可以表现出其行为：它们可以加速，停止，显示剩余多少燃料，以及许多其他的事情。

我们将 数据 看作是面向对象编程中的属性和行为。 又表示为：

数据→ 属性和行为 → 方法

而 类 是创建单个对象的蓝图。 在现实世界中，我们经常发现许多相同类型的对象。 比如说汽车。 所有的汽车都有相同的构造和模型（都有一个引擎，轮子，门等）。每辆车都是由同一套蓝图构造成的，并具有相同的组件。

Python 面向对象编程模式：ON

Python，作为一种面向对象编程语言，存在这样的概念： 类 和 对象 。

一个类是一个蓝图，是对象的模型。

那么，一个类是一个模型，或者是一种定义 属性 和 行为 的方法（正如我们在理论部分讨论的那样）。举例来说，一个车辆 类 有它自己的 属性 来定义这个 对象 是个什么样的车辆。一辆车的属性有轮子数量，能源类型，座位容量和最大时速这些。

考虑到这一点，让我们来看看 Python 的 类 的语法：

class Vehicle:
   pass

上边的代码，我们使用 class 语句 来定义一个类。是不是很容易？

对象是一个 类 的实例化，我们可以通过类名来进行实例化。

car = Vehicle()
print(car) # <__main__.Vehicle instance at 0x7fb1de6c2638>

在这里，car 是类 Vehicle 的对象（或者实例化）。

记得车辆 类 有四个 属性 ：轮子的数量，油箱类型，座位容量和最大时速。当我们新建一个车辆 对象 时要设置所有的 属性 。所以在这里，我们定义一个 类 在它初始化的时候接受参数：

class Vehicle:
    def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
        self.number_of_wheels = number_of_wheels
        self.type_of_tank = type_of_tank
        self.seating_capacity = seating_capacity
        self.maximum_velocity = maximum_velocity

这个 init 方法 。我们称之为构造函数。因此当我们在创建一个车辆 对象 时，可以定义这些 属性 。想象一下，我们喜欢 Tesla Model S ，所以我们想创建一个这种类型的 对象。 它有四个轮子，使用电能源，五座并且最大时时速是250千米（155英里）。我们开始创建这样一个 对象 ：

tesla_model_s = Vehicle(4, 'electric', 5, 250)

四轮+电能源+五座+最大时速250千米。

以上内容就是Python的具体介绍，希望能帮助到大家。

Recommandations associées :

Tutoriel sur la configuration de MySQL avec Python (à lire absolument)

Un cas de Python exploitant des fichiers Excel

Introduction à la méthode de connexion à la base de données en python

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!