首先，什么是Python？根据它的创建者Guido van Rossum，Python是：
“高级编程语言，其核心设计理念是代码可读性和语法，它允许程序员用几行代码表达概念。”
对我来说，学习Python的第一个原因是它实际上是一种简单的编程语言。用它来编码和表达我的想法真的很自然。
另一个原因是我们可以通过多种方式使用Python编写代码：数据科学，Web开发和机器学习都在这里发挥作用。Quora，Pinterest和Spotify都使用Python进行后端Web开发。
基础
1.变量
您可以将变量视为存储值的单词。就这么简单。在Python中，定义变量并为其设置值非常容易。想象一下，你想将数字1存储在一个名为“one”的变量中。让我们这样做：
one = 1
这有多简单？您只是将值1赋给变量“one”。
two =2
some_number = 10000
您可以给任何其他变量赋值。如上表所示，变量“ two”存储数字2，“ some_number ”存储10,000。
除了数字之外，我们还可以使用booleans （True / False），strings，float和许多其他数据类型。
# booleans
true_boolean = True
false_boolean = False
# string
my_name = "Python"
# float
book_price = 15.80
2.控制流程：条件语句
“ If ”使用表达式来评估语句是True还是False。如果为True，则执行“if”语句中的内容。例如：
if True:
print("Hello Python If")
if 2 > 1:
print("2大于1")
2大于1，因此执行“ print ”（输出）代码。如果“ if ”表达式为false，则将执行“ else ”语句。
if 1 > 2:
print("1大于2")
else:
print("1小于2")
1小于2，因此将执行“ else ”语句中的代码。您还可以使用“ elif ”语句：
if 1 > 2:
print("1大于2")
elif 2 > 1:
print("1小于2")
else:
print("1等于 2")
3.循环/迭代器
在Python中，我们可以以不同的形式进行迭代。我将谈论两个：while 和for。
while循环：当语句为正确的时候，该块中的代码会被执行。因此，此代码将输出从1到10的数字。
num = 1
while num <= 10:
print(num)
num += 1
while循环需要一个“ 循环条件“。如果它保持为True，它将会继续迭代。在这个例子中，当num是11的时，循环条件为False。循环停止。
用另一个基础的代码来更好地理解它：
loop_condition = True
while loop_condition:
print("Loop Condition keeps: %s" %(loop_condition))
loop_condition = False
该循环条件是True如此它保持迭代-直到我们将其设置为False。
对于循环：将变量“ num ”应用于块，“ for ”语句将为您迭代它。此代码将输出与while代码相同的代码：从1到10。
for i in range(1, 11):
print(i)
这很简单。范围从第一个元素开始，直到第11个元素（1是第一个元素，10是第10个元素）。
4.列表：集合| 数组| 数据结构
假设您想将整数1存储在变量中，或者你现在要存储2,3,4,5 ......
我是否有另一种方法可以存储我想要的所有整数，但不是数百万个变量？答案是肯定有- 确实存在另一种存储它们的方法。
List是一个集合，可用于存储值列表（如您想要的这些整数）。所以我们使用：
my_integers = [ 1，2，3，4，5 ]
这很简单。我们创建了一个数组并将其存储在my_integer上。但也许你在问：“我如何从这个阵列中获取一个值？”好问题。List有一个叫做索引的概念。第一个元素获得索引0（0）。第二个得到1，依此类推。为了更清楚，我们可以用它的索引表示数组和每个元素。我可以画它：
使用Python语法，它也很容易理解：
my_integers = [9, 3, 7, 5, 0]
print(my_integers[0]) # 9
print(my_integers[1]) # 3
print(my_integers[4]) # 0
想象一下，你不想存储整数。您只想存储字符串，例如姓名列表。看起来像这样：
relatives_names = ["Aries","Leo","Virgo","Aquarius","Pisces"]
print(relatives_names[4]) # Pisces
它的工作方式与整数相同。我们刚学会了List目录如何运作。但我仍然需要向您展示如何向List数据结构添加元素（向列表添加项）。向列表添加新值的最常见方法是append。让我们看看它是如何工作的：
bookshelf = []
bookshelf.append("The Effective Engineer")
bookshelf.append("The 4 Hour Work Week")
print(bookshelf[0]) # The Effective Engineer
print(bookshelf[1]) # The 4 Hour Work Week
append非常简单。您只需要应用元素（例如“ The Effective Engineer ”）作为append参数。
关于列表已经说得够多了。我们来谈谈另一种数据结构。
5.Dictionary（字典）：键值数据结构
现在我们知道列表是用整数编号索引的。但是，如果我们不想使用整数作为索引呢？我们可以使用的一些数据结构是数字，字符串或其他类型的索引。
让我们了解字典数据结构。字典是键值对的集合。如下所示：
dictionary_example = {"key1": "value1","key2": "value2","key3": "value3"}
key键值是指向该值的索引。我们如何访问字典的值？你猜对了 - 用key。如下：
dictionary_Py = {"name": "Python","nickname": "Py","nationality": "China"}
print("My name is %s" %(dictionary_Py["name"])) # My name is Python
print("But you can call me %s" %(dictionary_Py["nickname"])) # But you can call me Py
print("And by the way I'm %s" %(dictionary_Py["nationality"])) # And by the way I'm China
我编写了一关于我的字典。我的名字，昵称和国籍。这些属性是字典键。
在学习如何使用索引访问列表时，我们还使用索引(字典上下文中的键)访问字典中存储的值。在本例中，我使用字典中存储的所有值输出了一个关于我的短语。字典的另一个很酷的地方是，我们可以使用任何值。在我创建的字典中，我想添加关键字“年龄”和我的实际整数年龄：
dictionary_Py = {"name": "Python","nickname": "Py","nationality": "China","age": 28}
print("My name is %s" %(dictionary_Py["name"])) # My name is Python
print("But you can call me %s" %(dictionary_Py["nickname"])) # But you can call me Py
print("And by the way I'm %i and %s" %(dictionary_Py["age"], dictionary_Py["nationality"])) # And by the way I'm China
这里我们有一个键值对（年龄：28），使用string作为键，integer作为值。
正如我们对列表所做的那样，让我们学习如何向字典中添加元素。指向值的键是字典的重要组成部分。当我们在谈论添加元素的时候也是如此：
dictionary_Py = {"name": "Python","nickname": "Py","nationality": "China"}
dictionary_Py['age'] = 28
print(dictionary_Py) # {'nationality': 'China', 'age': 28, 'nickname': 'Py', 'name': 'Python'}
我们只需要给字典键赋一个值。很简单，对吧？
6.迭代：循环数据结构
正如我们在Python基础中所学到的，列表迭代非常简单。我们的Python开发人员通常使用For循环。例如：
bookshelf = ["The Effective Engineer","The 4 hours work week","Zero to One","Lean Startup","Hooked"]
for book in bookshelf:
print(book)
因此对于书架上的每一本书，我们都可以输出出来。非常简单直观。这就是Python。
对于hash（哈希）数据结构，我们也可以使用for循环，我们应用key ：
dictionary = { "some_key": "some_value" }
for key in dictionary:
print("%s --> %s" %(key, dictionary[key]))
# some_key --> some_value
这是一个如何使用它的示例。对于字典中的每个键，我们输出键及其相应的值。
另一种方法是使用items的方法。
dictionary = { "some_key": "some_value" }
for key, value in dictionary.items():
print("%s --> %s" %(key, value))
# some_key --> some_value
我们将这两个参数命名为key和value，但是没有必要这样做，我们可以给他们取任何名字。如下所示：
dictionary_Py = {"name": "Python","nickname": "Py","nationality": "China","age": 28}
for attribute, value in dictionary_Py.items():
print("My %s is %s" %(attribute, value))
# My name is Python
# My nickname is Py
# My nationality is China
# My age is 28
我们可以看到我们使用属性作为字典键值的参数，并且它可以正常工作。
7.Classes（类）和Objects（对象）
很简单的理论：
对象是真实世界对象的一种表示，如汽车、狗或自行车。这些对象共享两个主要特征：数据和行为。
汽车有数据，如车轮数量，车门数量和座位数量。它们还表现出行为：它们可以加速，停止，显示剩余多少燃料，以及许多其他东西。
在面向对象编程中，我们将数据定义为属性，将行为定义为方法。
数据→属性和行为→方法
类是创建单个对象的蓝图。在现实世界中，我们经常发现许多具有相同类型的对象。例如汽车：所有相同的品牌和型号（都有发动机，车轮，车门等）。每辆车都是使用相同的蓝图构建的，并且具有相同的组件。
Python面向对象编程
Python作为面向对象的编程语言，具有以下概念：类和对象。
类是蓝图，是对象的模型。
因此，类只是一个模型，或者定义属性和行为的一种方法（正如我们在理论部分所讨论的那样）。例如，vehicle（车辆）类具有其自己的属性，来定义对象是什么。车轮的数量，油箱的类型，座位数量和最大速度都是车辆的属性。
考虑到这一点，让我们看一下类的 Python语法：
class Vehicle:
pass
对象是类的实例。我们通过命名类来创建实例。
car = Vehicle()
print(car)
# <__main__.vehicle instance="" at="">
这里car是Vehicle类的一个对象（或实例）。
请记住，我们的vehicle类有四个属性:车轮数、油箱类型、座位数量和最大速度。我们在创建一个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方法。我们称之为构造函数方法。创建vehicle对象时，我们可以定义这些属性。想象一下，我们喜欢特斯拉S型车，我们想要创造出这种东西。它有四个轮子，使用电能，有五个座位的空间，最大速度为250公里/小时。让我们创建这个对象：
tesla_model_s = Vehicle(4, 'electric', 5, 250)
四轮+电动“油箱类型”+五个座位+ 250km /小时最高速度。
所有属性都设置好了。但是我们如何访问这些属性的值呢?我们向对象发送一条消息询问它们。我们称之为方法。它是对象的行为。我们来实现它：
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
def number_of_wheels(self):
return self.number_of_wheels
def set_number_of_wheels(self, number):
self.number_of_wheels = number
这是两种方法的实现：number_of_wheels和set_number_of_wheels。我们称之为getter和setter。因为第一个获取属性值，第二个为属性设置一个新值。
在Python中，我们可以使用@property（decorators）来定义getters和setters。代码如下：
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
@property
def number_of_wheels(self):
return self.__number_of_wheels
@number_of_wheels.setter
def number_of_wheels(self, number):
self.__number_of_wheels = number
我们可以使用这些方法作为属性：
tesla_model_s = Vehicle(4, 'electric', 5, 250)
print(tesla_model_s.number_of_wheels) # 4
tesla_model_s.number_of_wheels = 2 # setting number of wheels to 2
print(tesla_model_s.number_of_wheels) # 2
这与定义方法略有不同。这些方法作为属性。例如，当我们设置新的轮数时，我们不会将two作为参数应用，而是将值2设置为number_of_wheels。这是编写python getter和setter编码的一种方法。
但我们也可以使用其他方法，比如“ make_noise ”方法。如下所示：
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
def make_noise(self):
print('VRUUUUUUUM')
当我们调用此方法时，它只返回一个字符串“ VRRRRUUUUM。”
tesla_model_s = Vehicle(4, 'electric', 5, 250)
tesla_model_s.make_noise() # VRUUUUUUUM
8.封装：隐藏信息
封装是一种限制直接访问对象的数据和方法的机制。但同时，它也简化了对数据（对象的方法）的操作。
“封装可用于隐藏数据成员和成员函数。在这个定义下，封装意味着对象的内部表示通常隐藏在对象定义之外的视图中。”
对象的所有内部表示都是从外部隐藏的。只有对象可以与其内部数据进行交互。首先，我们需要了解public和non-public实例变量和方法是如何工作的。
8.1.Public Instance Variables（公共实例变量）
对于Python类，我们可以在构造函数方法中初始化一个公共实例变量。例如：
在构造函数方法中：
class Person:
def __init__(self, first_name):
self.first_name = first_name
这里我们将first_name值作为参数应用于public instance variable。
Py = Person('PY')
print(Py.first_name) # PY
内部类：
class Person:
first_name = 'PY'
在这里，我们不需要将first_name参数作为参数应用，并且所有实例对象都有一个用Py初始化的类属性。
Py = Person()
print(Py.first_name) # PY
现在我们已经了解了可以使用公共实例变量和类属性。关于公共部分的另一个有趣的事情是，我们可以管理变量值。我们的对象可以管理它的变量值：获取和设置变量值。
记住Person类，我们想将另一个值设置为它的first_name变量：
class Person:
def __init__(self, first_name):
self.first_name = first_name
Py = Person('PY')
Py.first_name = 'Aries'
print(Py.first_name) # Aries
我们只是将另一个值（Aries）设置为first_name实例变量并更新了该值。由于它是一个公共变量，我们可以做到这一点。
8.2.Non-public Instance Variable（非公共实例变量）
我们在这里不使用术语“私有”，因为在Python中没有真正私有的属性（没有通常不必要的工作）。
作为公共实例变量，我们可以在构造函数方法或类中定义非公共实例变量。语法上的区别是：对于非公共实例变量，在变量名之前使用下划线（_）。
“除非从对象内部访问，否则不能访问的‘私有’实例变量在Python中不存在。然而，有一个惯例是大多数Python代码都遵循：以下划线（例如_spam）前缀的名称应被视为API的非公共部分（无论是函数，方法还是数据成员）“
如下所示：
class Person:
def __init__(self, first_name, email):
self.first_name = first_name
self._email = email
你看到email变量了吗？这就是我们定义的方式non-public variable ：
Py = Person('PY', '[email protected]')
print(Py._email) # [email protected]
我们可以访问和更新它。Non-public variables只是一个惯例，应该作为API的非公共部分。
所以我们使用一种允许我们在类定义中完成它的方法。让我们实现两种方法（email和update_email）来理解它：
class Person:
def __init__(self, first_name, email):
self.first_name = first_name
self._email = email
def update_email(self, new_email):
self._email = new_email
def email(self):
return self._email
现在我们可以使用这些方法更新和访问非公共变量。如下所示：
Py = Person('PY', '[email protected]')
print(Py.email()) # [email protected]
# Py._email = '[email protected]' -- treat as a non-public part of the class API
print(Py.email()) # [email protected]
Py.update_email('[email protected]')
print(Py.email()) # [email protected]
- 我们用first_name PY和email [email protected] 启动了一个新对象
- 通过使用方法访问非公共变量来输出电子邮件
- 试图在我们的类上设置一个新的email
- 我们需要将非公共变量视为API的非公共部分
- 使用实例方法更新非公共变量
- 成功！我们可以使用helper方法在我们的类中更新它
8.3.public methods（公共方法）
有了public methods，我们也可以在类之外使用它们：
class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def show_age(self):
return self._age
我们来测试一下：
Py = Person('Py', 28)
print(Py.show_age()) # 28
我们可以毫无问题地使用它。
8.4.Non-public Method（非公共方法）
但是non-public methods我们无法做到。让我们实现相同的Person类，但是现在使用show_age非公共方法使用下划线（_）。
class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def _show_age(self):
return self._age
现在，我们试着用我们的对象调用这个非公共方法：
Py = Person('PY', 28)
print(Py._show_age()) # 28
我们可以访问和更新它。Non-public methods只是一个惯例，应该被视为API的非公共部分。
以下是我们如何使用它的示例：
class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def show_age(self):
return self._get_age()
def _get_age(self):
return self._age
Py = Person('PY', 28)
print(Py.show_age()) # 28
在这里，我们有一个_get_age非公共方法和一个show_age 公共方法。show_age可以通过我们的对象使用（在类之外），而_get_age只能在类定义中使用（在show_age方法中）。但同样：这是一种惯例。
8.5.封装总结
通过封装，我们可以确保对象的内部表示从外部隐藏。
9.继承：行为和特征
某些对象有一些共同点：它们的行为和特征。
例如，我从父亲那里继承了一些特征和行为。我继承了他的眼睛和头发作为特征，以及他作为行为的烦躁和内向。
在面向对象的编程中，类可以从另一个类继承公共特征（数据）和行为（方法）。
让我们看看另一个例子，并在Python中实现它。
想象一辆车。车轮数量，座位数量和最大速度都是汽车的属性。我们可以说电动Car类从常规Car类继承了这些相同的属性。
class Car:
def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):
self.number_of_wheels = number_of_wheels
self.seating_capacity = seating_capacity
self.maximum_velocity = maximum_velocity
我们的Car类实现了：
my_car = Car(4, 5, 250)
print(my_car.number_of_wheels)
print(my_car.seating_capacity)
print(my_car.maximum_velocity)
这样子我们就可以使用创建的所有实例变量。
在Python中，我们将父类作为参数应用于子类。电动Car类可以继承我们的常规Car类。
class ElectricCar(Car):
def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):
Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity)
很简单。我们不需要实现任何其他方法，因为这个类已经有了它（继承自Car类）。让我们证明一下：
my_electric_car = ElectricCar(4, 5, 250)
print(my_electric_car.number_of_wheels) # 4
print(my_electric_car.seating_capacity) # 5
print(my_electric_car.maximum_velocity) # 250
最后
我们学到了很多关于Python的基础知识：
- Python变量的工作原理
- Python条件语句如何工作
- Python循环语句（while＆for）如何工作
- 如何使用列表：集合| 数组
- 字典键值集合
- 我们如何迭代这些数据结构
- 对象和类
- 属性作为对象的数据
- 方法作为对象的行为
- 使用Python getter和setter以及property decorator
- 封装：隐藏信息
- 继承：行为和特征
您已经完成了这篇关于Python的基础内容讲解！希望这些可以对您起到一定的帮助作用！
閱讀更多 湃紳Python 的文章
