一篇文章掌握Python基础知识
这是在国外的一个网站上看到的一篇技术文章，浅显易懂，足以掌握Python基础语法等基本知识。大概翻译如下，欢迎点赞。
首先，Python是什么？ 根据其创建者Guido van Rossum的说法，Python是一个：
“高级编程语言，其核心设计理念是关于代码可读性以及允许程序员用几行代码表达概念的语法。”
对我而言，学习Python的第一个理由是它实际上是一种漂亮的编程语言。 编码并表达我的想法真的很自然。
另一个原因是我们可以用多种方式在Python中使用编码：数据科学，Web开发和机器学习都在这里发光。 Quora，Pinterest和Spotify都使用Python进行后端Web开发。 所以我们来了解一下。
基础
1.变量
您可以将变量看作存储值的单词。 就那么简单。
在Python中，定义一个变量并为其设置一个值非常简单。 想象一下，你想在一个名为“one”的变量中存储数字1.让我们这样做：
one =1
那有多简单？ 您只将值1分配给变量“one”。
two = 2
some_number = 10000
您可以将任何其他值分配给您想要的任何其他变量。 如您在上面看到的，变量“two”存储整数2，“some_number”存储10,000。
除了整数之外，我们还可以使用布尔值（真/假），字符串，浮点数以及其他很多数据类型。
# booleans
true_boolean = True
false_boolean = False
# string
my_name = "Leandro Tk"
# float
book_price = 15.80
2.控制流程：有条件的陈述
“If”使用表达式来评估语句是True还是False。 如果它是True，它将执行“if”语句中的内容。 例如：
if True:
print("Hello Python If")
if 2 > 1:
print("2 is greater than 1")
2大于1，所以执行“打印”代码。如果“if”表达式为false，则会执行“else”语句。
if 1 > 2:
print("1 is greater than 2")
else:
print("1 is not greater than 2")
1不大于2，所以“else”语句中的代码将被执行。您也可以使用“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.循环/迭代器
在Python中，我们可以以不同的形式进行迭代。 我会讲两个：while和for。
While循环：当语句为True时，块内的代码将被执行。 所以，这段代码将打印从1到10的数字。
num = 1
while num <= 10:
print(num)
num += 1
while循环需要一个“循环条件”。如果它保持为真，它将继续迭代。 在这个例子中，当num是11时，循环条件等于False。
另一个基本的代码来更好地理解它：
loop_condition = True
while loop_condition:
print("Loop Condition keeps: %s" %(loop_condition))
loop_condition = False
循环条件为True，因此它会一直迭代 - 直到我们将其设置为False。
对于循环：将变量“num”应用于块，“for”语句将为您迭代它。 此代码将打印与代码相同的内容：从1到10。
for i in range(1, 11):
print(i)
看到？ 它非常简单。 范围从1开始，直到第11个元素（10是第10个元素）。
列表：收藏| 数组| | 数据结构
想象一下你想要将整数1存储在一个变量中。 但也许现在你想要存储2.和3,4,5 ...
我是否有另一种方法来存储所需的所有整数，但不是以百万计的变量存储？ 你猜对了 - 确实有另一种方法来存储它们。
List是一个可以用来存储值列表的集合（比如你想要的这些整数）。 所以让我们使用它：
my_integers = [1, 2, 3, 4, 5]
这非常简单。 我们创建了一个数组并将其存储在my_integer上。
但是也许你会问：“我怎么才能从这个阵列中获得价值？”
很好的问题。 列表有一个叫做索引的概念。 第一个元素获取索引0（零）。 第二个获取1，依此类推。 你明白了。
为了使它更清晰，我们可以用它的索引来表示数组和每个元素。 我可以画出来：
请点击此处输入图片描述
使用Python语法，它也很容易理解：
my_integers = [5, 7, 1, 3, 4]
print(my_integers[0]) # 5
print(my_integers[1]) # 7
print(my_integers[4]) # 4
如果你不想存储整数。 你只是想存储字符串，就像亲戚名字的列表一样。 我的看起来像这样：
relatives_names = [
"Zhangsan",
"LiSi",
"WangWu",
"LiLei",
"Hanmei"
]
print(relatives_names[4]) # Hanmei
它的工作方式与整数相同。
我们刚刚了解了列表索引如何工作。 但我仍然需要向您展示如何将元素添加到List数据结构（将项目添加到列表中）。
将一个新值添加到List的最常见方法是追加。 让我们看看它是如何工作的：
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
添加元素是非常简单的。 您只需将元素（例如“The Effective Engineer”）作为附加参数应用即可。
那么，关于列表就够了。 我们来谈谈另一个数据结构。
字典：键值（Key-Value ）数据结构
现在我们知道列表是用整数索引的。 但是如果我们不想使用整数作为索引呢？ 我们可以使用的一些数据结构是数字，字符串或其他类型的索引。
让我们来了解一下字典数据结构。 Dictionary是键值对的集合。 这是它的样子：
dictionary_example = {
"key1": "value1",
"key2": "value2",
"key3": "value3"
}
关键是指向该值的索引。 我们如何访问字典值？
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
我创建了一个关于我的字典。 我的名字，昵称和国籍。 这些属性是Dictionary键。
在我们学习如何使用索引访问列表时，我们还使用索引（词典上下文中的键）来访问存储在词典中的值。
在这个例子中，我使用Dictionary中存储的所有值打印了一个关于我的短语。 很简单，对吧？
关于Dictionary的另一件很酷的事情是我们可以使用任何东西作为价值。 在我创建的字典中，我想添加关键字“年龄”和我的实际整数年龄：
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
在这里，我们有一个键（年龄）值（24）对使用字符串作为键和整数作为值。正如我们对列表所做的那样，让我们学习如何将元素添加到字典中。 指向某个值的键是Dictionary的重要组成部分。 当我们正在讨论添加元素时，也是如此：
dictionary_tk = {
"name": "Leandro",
"nickname": "Tk",
"nationality": "Brazilian"
}
dictionary_tk['age'] = 24
print(dictionary_tk) # {'nationality': 'Brazilian', 'age': 24, 'nickname': 'Tk', 'name': 'Leandro'}
我们只需要为Dictionary键分配一个值。 没有什么复杂的，对吧？
迭代：循环访问数据结构
正如我们在Python Basics中学到的，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循环，但是我们应用了键值：
dictionary = { "some_key": "some_value" }
for key in dictionary:
print("%s --> %s" %(key, dictionary[key]))
# some_key --> some_value
这是一个如何使用它的例子。 对于字典中的每个键，我们都会打印键和相应的值。
另一种方法是使用iteritems方法。
dictionary = { "some_key": "some_value" }
for key, value in dictionary.items():
print("%s --> %s" %(key, value))
# some_key --> some_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
我们可以看到我们使用属性作为Dictionary键的参数，并且它可以正常工作。
课程与对象 ----Classes & Objects
一点理论：
对象是真实世界物体的表示，如汽车，狗或自行车。 这些对象共享两个主要特征：数据和行为。
汽车有数据，如车轮数量，车门数量和座位容量他们还表现出行为：他们可以加速，停止，显示剩余多少燃料，以及其他许多东西。
我们将数据识别为属性和行为作为面向对象编程中的方法。 再次：
数据→属性和行为→方法
一个类是创建单个对象的蓝图。 在现实世界中，我们经常会发现许多具有相同类型的对象。 像汽车。 所有相同的品牌和型号（都有发动机，车轮，车门等）。 每辆车都是由同一套蓝图构成的，并且具有相同的组件。
Python面向对象编程模式：ON
作为一种面向对象的编程语言，Python具有以下概念：类和对象。
类是蓝图，是对象的模型。
所以再次，一个类只是一个模型，或者一种定义属性和行为的方式（正如我们在理论部分讨论过的）。 例如，车辆类别具有自己的属性，用于定义车辆是什么物体。 车轮数量，坦克类型，座位容量和最大速度都是车辆的属性。
考虑到这一点，我们来看看类的Python语法：
class Vehicle:
pass
我们用class声明来定义类 - 就是这样。 很简单！
对象是一个类的实例。 我们通过命名类创建一个实例。
car = Vehicle()
print(car) # <__main__.Vehicle instance at 0x7fb1de6c2638>
这里汽车是汽车类的一个对象（或实例）。
请记住，我们的车辆类别具有四个属性：车轮数量，坦克类型，座位容量和最大速度。 我们在创建车辆对象时设置了所有这些属性。 所以在这里，我们定义我们的类在接收数据时接收数据：
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方法。 我们称之为构造函数方法。 所以当我们创建车辆对象时，我们可以定义这些属性。 想象一下，我们喜欢特斯拉模型S，并且我们想要创建这种类型的对象。 它有四个轮子，以电能运行，有五个座位的空间，最大速度为250km /小时（155英里/小时）。 我们来创建这个对象：
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（装饰器）来定义getter和setter。 让我们看看代码：
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
这与定义方法略有不同。 这些方法用作属性。 例如，当我们设置新的车轮数量时，我们不会将两个作为参数，而是将值2设置为number_of_wheels。 这是编写Pythonic 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')
当我们调用这个方法时，它只是返回一个字符串“VRRRUUUUM”。
tesla_model_s = Vehicle(4, 'electric', 5, 250)
tesla_model_s.make_noise() # VRUUUUUUUM
封装：隐藏信息
封装是一种限制直接访问对象数据和方法的机制。 但与此同时，它便于对这些数据（对象的方法）进行操作。
“封装可以用来隐藏数据成员和成员的功能。 在这个定义下，封装意味着对象的内部表示通常在对象定义之外隐藏而不被看到。“ - Wikipedia
对象的所有内部表示都是从外部隐藏的。 只有对象可以与其内部数据进行交互。
首先，我们需要了解公共和非公共实例变量和方法是如何工作的。
公共实例变量
对于Python类，我们可以在我们的构造函数方法中初始化一个公共实例变量。 让我们看看这个：
在构造方法中：
class Person:
def __init__(self, first_name):
self.first_name = first_name
在这里，我们将first_name值作为参数应用于公共实例变量。
tk = Person('TK')
print(tk.first_name) # => TK
引用这个类
class Person:
first_name = 'TK'
在这里，我们不需要将first_name作为参数，所有实例对象都将具有用TK初始化的类属性。
tk = Person()
print(tk.first_name) # => TK
我们现在已经了解到，我们可以使用公共实例变量和类属性。 关于公共部分的另一个有趣的事情是我们可以管理变量值。 我的意思是什么？ 我们的对象可以管理它的变量值：Get和Set变量值。
牢记Person类，我们想为它的first_name变量设置另一个值：
tk = Person('TK')
tk.first_name = 'Kaio'
print(tk.first_name) # => Kaio
我们只为first_name实例变量设置另一个值（kaio），并更新了值。 就那么简单。 由于它是一个公共变量，我们可以做到这一点。
非公开实例变量
这里我们不使用术语“private”，因为在Python中没有任何属性是真正的私有的（没有通常不必要的工作量）。 - PEP 8
作为公共实例变量，我们可以在构造函数方法内或类内定义非公共实例变量。 语法不同之处在于：对于非公共实例变量，请在变量名称之前使用下划线（_）。
“Python中不存在”私有“实例变量，这些变量除了在对象内部以外不能被访问。 但是，大多数Python代码都遵循一个约定：以下划线（例如_spam）作为前缀的名称应被视为API的非公开部分（无论它是函数，方法还是数据成员） “ - Python软件基金会
这是一个例子：
class Person:
def __init__(self, first_name, email):
self.first_name = first_name
self._email = email
你看到电子邮件变量了吗？ 这就是我们如何定义一个非公共变量：
tk = Person('TK', '[email protected]')
print(tk._email) # [email protected]
我们可以访问并更新它。 非公共变量只是一个约定，应该被视为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
现在我们可以使用这些方法更新和访问非公共变量。 让我们来看看：
tk = Person('TK', '[email protected]')
print(tk.email()) # => [email protected]
tk._email = '[email protected]'
print(tk.email()) # => [email protected]
tk.update_email('[email protected]')
print(tk.email()) # => [email protected]
我们用first_name TK和电子邮件[email protected]发起了一个新对象
通过使用方法访问非公共变量来打印电子邮件
试图设置一个新的电子邮件出我们班
我们需要将非公共变量视为API的非公开部分
使用我们的实例方法更新了非公共变量
成功！ 我们可以使用助手方法在我们的课堂内更新它
公共方法
使用公共方法，我们也可以在课堂中使用它们：
class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def show_age(self):
return self._age
我们测试一下
tk = Person('TK', 25)
print(tk.show_age()) # => 25
太好了 - 我们可以毫无问题地使用它。
非公开方法
但用非公开的方法，我们无法做到。 让我们实现相同的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
现在，我们将尝试用我们的对象来调用这个非公共方法：
tk = Person('TK', 25)
print(tk._show_age()) # => 25
我们可以访问并更新它。 非公开方法仅仅是一种约定，应该被视为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
tk = Person('TK', 25)
print(tk.show_age()) # => 25
这里我们有一个_get_age非公共方法和一个show_age公共方法。 show_age可以被我们的对象（不在我们的类中）使用，并且_get_age仅用于我们的类定义（在show_age方法中）。 但是，再次：作为惯例。
封装摘要
通过封装，我们可以确保对象的内部表示从外部隐藏。
继承：行为和特征
某些物体有一些共同之处：它们的行为和特征。
例如，我继承了父亲的一些特征和行为。 我继承了他的眼睛和头发作为特征，以及他的不耐烦和内向作为行为。
在面向对象编程中，类可以继承另一个类的共同特征（数据）和行为（方法）。
我们来看另一个例子，并在Python中实现它。
想象一辆汽车。 车轮数量，座位容量和最大速度都是汽车的属性。 我们可以说ElectricCar类从普通的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中，我们将父类作为参数应用于子类。 ElectricCar类可以继承我们的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）如何工作
如何使用列表：Collection |排列
字典键值集合
我们如何遍历这些数据结构
对象和类
属性作为对象的数据
方法作为对象的行为
使用Python获取器和设置器和属性装饰器
封装：隐藏信息
继承：行为和特征
恭喜！ 您完成了关于Python的这一密集内容。
请点击此处输入图片描述