Vollständige Beherrschung von Python

Python ist eine High-Level-Programmiersprache, deren zentrale Designphilosophie die Lesbarkeit und Syntax des Codes ist, sodass Programmierer ihre Ideen mit sehr wenig Code ausdrücken können. Python ist eine Sprache, die eine elegante Programmierung ermöglicht. Es macht das Schreiben von Code und die Umsetzung meiner Ideen einfach und natürlich. Wir können Python an vielen Orten verwenden: Datenwissenschaft, Webentwicklung, maschinelles Lernen usw. können alle mit Python entwickelt werden. Quora, Pinterest und Spotify verwenden alle Python für ihre Backend-Webentwicklung. Also lasst uns Python lernen.

Python-Grundlagen

1. Variablen

Sie können sich eine Variable als ein Wort vorstellen, das zum Speichern eines Werts verwendet wird. Schauen wir uns ein Beispiel an.

Es ist sehr einfach, in Python eine Variable zu definieren und ihr einen Wert zuzuweisen. Probieren wir es mal aus, wenn Sie die Zahl 1 in der Variablen „eins“ speichern möchten:

one = 1

Super einfach, oder? Sie müssen lediglich der Variablen „eins“ den Wert 1 zuweisen.

two = 2
some_number = 10000

Sie können jeder anderen Variablen einen beliebigen Wert zuweisen, solange Sie möchten. Wie Sie oben sehen können, speichert die Variable „two“ die Ganzzahlvariable 2 und die Variable „some_number“ speichert 10000.

Neben Ganzzahlen können wir auch Boolesche Werte (True/Flase), Strings, Gleitkommazahlen und andere Datentypen verwenden.

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

2. Kontrollfluss: bedingte Anweisung

„If“ verwendet einen Ausdruck, um zu bestimmen, ob eine Anweisung wahr oder falsch ist, dann führen Sie den Code in if aus. Beispiel Wie folgt:

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

2 ist größer als 1, daher wird der Druckcode ausgeführt.

Wenn der Ausdruck in „if“ falsch ist, wird die „else“-Anweisung ausgeführt.

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

1 ist kleiner als 2 , daher wird der Code in „else“ ausgeführt.

Sie können auch die „elif“-Anweisung verwenden:

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. Schleifen und Iteration

In Python können wir in verschiedenen Formen iterieren. Ich werde darüber reden, während und für.

While-Schleife: Wenn die Anweisung True ist, wird der Codeblock innerhalb der While-Schleife ausgeführt. Der folgende Code gibt also 1 bis 10 aus.

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

Die while-Schleife erfordert eine Schleifenbedingung. Wenn die Bedingung immer wahr ist, wird sie immer wiederholt. Wenn der Wert von num 11 ist, ist die Schleifenbedingung falsch.

Ein weiterer Codeteil kann Ihnen helfen, die Verwendung der while-Anweisung besser zu verstehen:

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

Die Schleifenbedingung ist „True“, also wird sie so lange iterieren, bis sie „False“ ist.

For-Schleife: Sie können die Variable „num“ auf einen Codeblock anwenden und die „for“-Anweisung wird für Sie darüber iterieren. Dieser Code gibt den gleichen Code wie in while aus: von 1 bis 10 .

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

Hast du es gesehen? Es ist zu einfach. Der Bereich von i beginnt bei 1 und geht bis zum 11. Element (10 ist das zehnte Element)

Liste: Sammlung |.

Wenn Sie eine Ganzzahl in einer Variablen speichern möchten 1, aber Sie müssen auch 2 und 3, 4, 5 speichern...

Gibt es für mich eine andere Möglichkeit, diese ganzen Zahlen, die ich speichern möchte, zu speichern, anstatt Hunderte oder Tausende von Variablen zu verwenden? Wie Sie vermutet haben, gibt es andere Möglichkeiten, sie aufzubewahren.

Eine Liste ist eine Sammlung, die eine Spalte mit Werten speichern kann (genau wie die, die Sie speichern möchten), also verwenden wir sie:

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

Es ist wirklich einfach. Wir erstellen ein Array namens my_integer und speichern die Daten darin.

Vielleicht werden Sie fragen: „Wie bekomme ich die Werte im Array?“

Gute Frage. Listen haben ein Konzept namens Indizierung. Das erste Element der unteren Tabelle ist Index 0 (0). Der Index des zweiten ist 1 und so weiter, das sollten Sie verstehen.

Um es prägnanter zu machen, können wir das Array-Element durch seinen Index darstellen. Ich habe es gezeichnet:

Mit der Python-Syntax ist es auch leicht zu verstehen:

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

Wenn Sie keine Ganzzahlen speichern möchten. Sie möchten lediglich einige Zeichenfolgen speichern, beispielsweise eine Liste der Namen Ihrer Verwandten. Meins sieht so aus:

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

Das Prinzip ist dasselbe wie das Speichern von Ganzzahlen, was sehr benutzerfreundlich ist.

Wir haben nur gelernt, wie die Indizierung einer Liste funktioniert. Ich muss Ihnen auch erklären, wie Sie ein Element zur Datenstruktur der Liste hinzufügen (ein Element zur Liste hinzufügen).

Die gebräuchlichste Methode zum Hinzufügen neuer Daten zu einer Liste ist das Spleißen. Werfen wir einen Blick auf die Verwendung:

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

Spleißen ist super einfach, Sie müssen nur ein Element (z. B. „effektive Maschine“) als Spleißparameter übergeben.

Okay, das ist genug Wissen über Listen, schauen wir uns andere Datenstrukturen an.

Wörterbuch: Schlüsselwert-Datenstruktur

Jetzt wissen wir, dass die Liste eine indizierte Sammlung ganzer Zahlen ist. Was aber, wenn wir keine ganzen Zahlen als Indizes verwenden möchten? Wir können andere Datenstrukturen wie Zahlen, Zeichenfolgen oder andere Arten von Indizes verwenden.

Lassen Sie uns etwas über die Datenstruktur des Wörterbuchs lernen. Ein Wörterbuch ist eine Sammlung von Schlüssel-Wert-Paaren. Das Wörterbuch sieht fast so aus:

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的具体介绍，希望能帮助到大家。

Verwandte Empfehlungen:

Tutorial zum Konfigurieren von MySQL mit Python (muss gelesen werden)

Ein Fall, in dem Python Excel-Dateien bedient

Einführung in die Methode zum Herstellen einer Verbindung zur Datenbank in Python

Das obige ist der detaillierte Inhalt vonVollständige Beherrschung von Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!