从小白到大神,一文把握 Python 麋集知识点

灬兔子精

点击上方“CSDN”，选择“置顶公众号”

关键时候，第一时间送达！

第一个题目，什么是 Python ？根据 Python 之父 Guido van Rossum 的话，Python 是：

一种高级步伐语言，其焦点计划哲学是代码可读性和语法，可以或许让步伐员用很少的代码来表达本身的想法。

对于我来说，学习 Python 的主要缘故原由是，Python 是一种可以优雅编程的语言。它可以或许简朴天然地写出代码和实现我的想法。

另一个缘故原由是我们可以将 Python 用在许多地方：数据科学、Web 开辟和呆板学习等都可以利用 Python 来开辟。Quora、Pinterest 和 Spotify 都利用 Python 来举行他们的后端 Web 开辟。那么让我们来学习一下 Python 吧。

Python 底子

1. 变量

你可以把变量想象成一个用来存储值的单词。我们看个例子。

Python 中界说一个变量并为它赋值是很轻易的。如果你想存储数字 1 到变量 “one” ，让我们试试看：

one = 1

超等简朴吧？你只必要把值 1 分配给变量 “one” 。

two = 2

some_number = 10000

只要你想，你可以把恣意的值赋给任何其他的变量。正如你从上面看到的那样，变量 “two” 存储整型变量 2 ，变量 “some_number” 存储 10000 。

除了整型，我们还可以利用布尔值（True/Flase）、字符串、浮点型和其他数据范例。

# booleanstrue_boolean = Truefalse_boolean = False# stringmy_name = "Leandro Tk"# floatbook_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 大，以是 print 代码被实行。

当“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 时，while 内部的代码块会实行。以是下面这段代码会打印出 1 到 10 。

num = 1while num  %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) #

在这里，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千米。

全部的属性已经设置了。但我们该怎样访问这些属性值呢？我们给对象发送消息以向其哀求该值。我们称之为方法。它是对象的举动。让我们实现它：

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 (修饰符)来界说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) # 4tesla_model_s.number_of_wheels = 2 # setting number of wheels to 2print(tesla_model_s.number_of_wheels) # 2

这和方法界说有稍微的差别。这里的方法是按照属性实行的。比方当我们设置新的轮胎数量时，我们并不将这两个看做参数，而是将数值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

封装: 隐蔽信息

封装是一种限定直接访问对象数据和方法的机制。但与此同时，它使得在数据上操纵更简朴（对象的方法）。

“封装可被用于隐蔽数据成员和成员函数。按照这个界说，封装意味着 对象的内部表现一样平常在对象界说的外部视图中隐蔽。” — 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），并更新了值。就这么简朴。由于这是一个公共变量，我们是可以这么做的。

Non-public 实例变量

这里我们并没有利用术语“private”，由于在Python中全部属性都不是真的私有的（没有通常不须要的工作量）。 —  PEP 8

作为 public instance variable（公共实例变量），我们可以在构造方法或类内部界说 non-public instance variable （非公共实例变量）。语法上的区别是：对于 non-public instance variables （非公共实例变量），在变量名前利用下划线(_)。

“除了从对象内部外无法被访问的‘Private’实例变量在Python中并不存在。然而，这里有一个多数Python代码都会服从的惯例：利用下划线作为前缀的定名(比方 _spam)应该被以为是API的非公开部门（不管是函数、方法照旧数据成员）” —  Python软件底子

这里是示例代码:

class Person:

    def __init__(self, first_name, email):

        self.first_name = first_name

        self._email = 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]._email = '[email protected]'print(tk.email()) # => [email protected]_email('[email protected]')

print(tk.email()) # => [email protected]

• 我们利用first_name TK和email [email protected]初始化了一个新对象
  
  
• 利用方法访问非公开变量email并输出它
  
  
• 实验在类外部设置一个新的email
  
  
• 我们必要将非公开变量视为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 |Array
  
  
• 字典式键值聚集
  
  
• 我们怎样遍历这些数据布局
  
  
• 对象和类
  
  
• 作为对象数据的属性
  
  
• 作为对象举动的方法
  
  
• 利用 Python getter/setter 以及属性修饰器
  
  
• 封装：隐蔽信息
  
  
• 继续：举动和特性
  
  

恭喜！ 你完成了这个关于 Python 的麋集的知识点。

原文：Learning Python: From Zero to Hero

链接：http://medium.freecodecamp.org/learning-python-from-zero-to-hero-120ea540b567

译者：rever4433, Tocy, Tony, 南宫冰郁, 透过树叶的光

————— END —————

步伐员穿衣是怎么变得越来越丑的

苹果为 macOS 庞大毛病致歉；迅雷内耗股价暴跌；小米百度在一起 | 一周业界事

为什么总说步伐员是吃芳华饭的？真的是 35 岁混不到管理就即是赋闲？