学习 Python ：从 0 到 1

首先，什么是 Python ？它的创造者「吉多-范罗苏姆」这样定义，一门高级语言，它的核心设计理念包括代码可读性、允许程序员用几行代码就可以实现自己的想法。

“high-level programming language, and its core design philosophy is all about code readability and a syntax which allows programmers to express concepts in a few lines of code.”

对我来说，学习 Python 的第一个原因，它实际上是一门很美好的语言，真的可以很自然的通过编码来表达我的想法。

另一方面，我们可以在很多方面都可以使用 Python ：数据科学、web开发、机器学习。这些方面 Python 都做的挺好的。Quora、Pinterest、Spotify 都使用 Python 作为他们的 web 后端开发语言。废话不多说，我们来了解一下它吧。

以下都是基础内容。主要对象应该是使用过其他语言但是没用过 Python 的同学，还有就是对编程感兴趣的小白同学。

1、变量

你可以简单认为所有的变量都是一个单词，然后保存着一个值，就是这样。

在 Python 中，定义一个变量并赋值是很简单的事情。举例说明，你想象着让 one 这个单词保存 1 这个数值。对应的代码：

one = 1

是不是很简单，刚刚给变量 one 赋值 1

你可以给任何变量分配任何值。把 2 赋值给变量 two ，把 10000 赋值给 some_number。

two = 2
some_number = 10000

除了 Integers ，我们也可以使用 booleans（ True/False ），strings ，float 等其他数据类型。

#booleans
true_boolean = True
false_boolean = False

#string
my_name = 'LeoBing'

#float
book_price = 15.80

2、控制流：条件语句

「if」使用表达式来判断一个语句是否为真或假。如果为真，则执行「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")
elfi 2 > 1:
    print(" 1 is not greater than 2")
else:
    print(" 1 is equal to 2 ")

3、循环和迭代

在 Python 中，我们可以用多种方式使用迭代。下面将介绍两种： while 和 for

**while 循环：**当 while 条件是 True ，里面的代码将会执行。下面是打印 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

**For 循环：**废话不多说，下面的代码同样打印 1-10

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

是不是很简单，嘻嘻

4、集合、数组、数据结构

之前我们是把 1 存储到一个变量 one 中。现在我们想把 2，3，4，5… 存到一个变量中？肿么办

List 是一个集合，可以存储我们想存储的各种类型的数据。那我们先看一个例子：

my_integers = [1,2,3,4,5]  # 我们可以创建一个数组存储它

那如何从数组中取到我想要的数据呢 ？List 有索引这个概念，第一个元素的索引是 0 ，第二元素的索引是 1 等… 现在你应该知道怎么办了。

为了更清楚的说明，我们可以通过索引展示数组中的每一个元素，如图所示：

数组和索引

Python 代码也是很容易明白的，如下：

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

如果你不想存储 Integer 类型，只想存储 strings 类型的，类似联系人列表：

relatives_name = [ "Toshiaki" , "Juliana" , "Yuji" ,  "Bruno" , "Kaio"]
print(relatives_name[4]) # Kaio 跟 Integer 类型一样。

上面我们仅仅说明了 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 方法很简单，只要把要添加的元素作为 append 方法的参数即可。以上就是 List 的基本操作，让我们看下其他数据结构。

5、字典：键值对数据结构

现在我们知道 Lists 用 integer 数字当作索引，但是如果我们不想用 integer 数字当作索引呢 ？ 有一些数据结构，我们可以用数字、字符串等其他类型当作索引。

字典，键值对集合，如下：

dictionary_example = { "key1":"values1" ,"key2":"values2" ,"key3":"values3" }

键是值的索引，所以我们可以通过键[key]来访问字典中的值，如下：

dictionary_lb = { "name":"Leo","nickname":"Bing","nationlity":"Chinese"}
print("My name is %s"%(dictionary_lb["name"]))
print("But you can call me %s"%(dictionary_lb["nickname"]))
print("And by the way I'm  %s"%(dictionary_lb["nationlity"]))

我创建了一个关于我个人信息的字典，其中，name、nickname、nationlity，这些属性值都是字典中的 key。我们可以用索引去访问 List ，同样可以用索引（就是字典中的 key 值）访问字典中的值。

关于字典另一个比较厉害的地方，任何东西都可以作为它的值。比如我在字典中加入 age:24 ,在这里 key 是字符串类型和 value 是 integer类型。

dictionary_lb = { "name":"Leo","nickname":"Bing","nationlity":"Chinese","age":24}

就像 Lists 一样，那么字典是如何添加元素的呢？key 是字典中的重要组成部分，dictionary 如何添加元素也印证了这一点。

dictionary_lb = { "name":"Leo","nickname":"Bing","nationlity":"Chinese"}
dictionary_lb['age'] = 24
print( dictionary_lb['age']) # 24

6、迭代：通过数据结构来循环

上面说了迭代和循环，Lists 迭代非常简单， Python 开发人员通常会用 For 循环.

bookshelf = ["The Effective Engineer","The 4 hours work week","Zero to One","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

上面的例子说明了我们如何使用的。For 循环遍历字典中的每一个 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_lb = { "name":"Leo","nickname":"Bing","nationlity":"Chinese","age":24}
for attribute,value in dictionary_lb.items():
    print(" My %s is %s "%(attribute,value))  # 参数变量定义为 attribute
#My name is Leo
#My nickname is Bing
#My nationlity is  Chinese
#My age is 24

一样可以正常输出，Great ！

7、类和对象

一点点原理：对象就是展现在真实世界上的东西，比如：车、狗。这些对象都有两个主要的特征：外部数据和行为。

车有轮子、门、座椅这些外部数据，它们也有加速、停等行为。

在面向对象语言中，我们把外部数据定义为属性，把行为定义为方法。

类是单一对象创建的一个蓝图。在真实世界中，我们经常发现很多对象有同样的特征，比如车，同样的外表和模型，每辆车都是从同样的蓝图造出来的，都有同样组件。

Python 作为一门面向对象语言，也有这些概念：类和对象。

对于对象来说，类就是一个蓝图、一个模型。

再说一次，类是一个模型，或者说是一个定义属性和行为的方法。下面的例子，vehicle 这个类有它自己的属性，定义了 vehicle 是一个什么样的对象。轮子的个数、油箱类型、座椅个数、最大速度等所有关于车的属性。

class vehicle:
    pass

car = vehicle() # 这里的 car 就是 vehicle 对象
print(car)  # <__main__.vehicle instance at 0x7fd4be605290>

汽车对象有四个属性：轮子的个数、油箱类型、座椅个数、最大速度。我们可以在汽车对象初始化的过程中，对这些属性赋值。那么应该如何定义呢，下面的代码：

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 对象，定义这些属性值。想象一下，马一龙的特斯拉，四个轮子，电动汽车，五个座椅，最大速度 250km/hour ，我们该如何定义：

tesla_model_s = vehicle(4 , 'electric', 5 , 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 来定义 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)
print(tesla_model_s.number_of_wheels) # 2

对于一些固定的属性值，可以直接在对象中直接定义方法：

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_nosie(self):
        print("VRUUUUUUM")

试一下：
tesla_model_s = vehicle(4 , 'electric', 5 , 250)
tesla_model_s.make_noise() # VRUUUUUUM

8、封装：隐藏信息

封装是一种限制直接访问数据和方法的机制，但同时，它也方便了对数据的操作。

“Encapsulation can be used to hide data members and members function. Under this definition, encapsulation means that the internal representation of an object is generally hidden from view outside of the object’s definition.” — Wikipedia

一个对象的所有内部状态对于外部来说都是隐藏的，只有实例对象可以跟内部数据进行交互。

首先，我们来看一下 pubic 和 non-public 修饰的实例参数和方法是怎么工作的：

Public Instance Variable:

对于 Python 类来说，我们可以用构造方法初始化 public instance variable。

class Person：
    def __init__(self , first_name ):
       self.first_name = first_name #这里的 first_name 是 public 实例的参数。

lb = Person('LB')
print(lb.first_name) # ==> LB

这里，我们不用定义 first_name 属性值，所有的对象实例都会初始化 first_name 为 LB：

class Person1：
    def __init__(self , first_name ):
        first_name = 'LB'
 
lb = Person1()
print(lb.first_name) # ==> LB

上面例子说明，我们可以使用 public 实例变量和类的属性。另一方面，public 还允许我们去定义参数值，如下：

lb = Person('LB')
lb.first_name='Messi' # 将 first_name 实例变量更新为另一个值 Messi
print(lb.first_name) # ==>Messi

Non-Public Instance Variable:

这里并没有用 private 来修饰，因为在 Python 中没有真正的私有属性。

同 Public 一样，我们可以在构造函数和类里定义 Non-Public 。语法稍微有点不同，Non-Public , 变量定义前使用下划线（__）

“‘Private’ instance variables that cannot be accessed except from inside an object don’t exist in Python. However, there is a convention that is followed by most Python code: a name prefixed with an underscore (e.g. _spam) should be treated as a non-public part of the API (whether it is a function, a method or a data member)” ——Python Software Foundation

例子：

class Person：
    def __init__(self , first_name ，email）：
     self.first_name = first_name
     self.__email = email # 变量 email 被定义为 Non-Public

lb = Person('LB','LB@mail.com')
print(tk.__email) # LB@mail.com ，访问 email 变量。

Non-Public 变量定义只是一种约定形式，我们只要用 Non-Public 的方式就可以访问。下面定义两个方法，感受一下：

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

lb = Person('LB','LB@mail.com')
print(lb.email())  #LB@mail.com
lb._email = 'new_lb@mail.com'  # 私有变量必须通过方法修改
print(lb.email()) #LB@mail.com
lb.update_mail('new_lb@mail.com')
print(lb.email()) #new_lb@mail.com

Public Method

class Person：
    def __init__(self , first_name ，age）：
       self.first_name = first_name
       self._age= age
    def show_age(self):
       return self._age

lb = Person('LB',25)
print(lb.show_age) # ==> 25

公有方法和公有属性的操作方式一致, 就酱~

Non-Public Method

class Person：
    def __init__(self , first_name ，age）：
       self.first_name = first_name
       self._age= age
    def _show_age(self):
       return self._age
lb = Person('LB',25)
print(lb._show_age) # ==> 25

私有方法和私有属性的操作方式也一致，同样遵守 Python 私有的特殊形式即可

另一个形式，在类中定义公有方法调用私有方法：

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

lb = Person('LB',25)
print(lb.show_age) # ==> 25

公有和私有：公有的变量可以随意访问，可以直接通过属性名称进行修改，也可以定义类方法进行修改。私有的变量，变量访问只需按照约定好的形式进行方法即可（形式可以把它当作 Python API 的一部分），在进行修改时，需要通过类内部的方法进行修改，不能直接修改。

9、继承：行为和特征

对象都有公有信息：行为和特征。例如，我继承爸爸一些特征和行为，眼睛和头发的特征，耐心和内向的行为方式。

在面向对象语言中，类也可以从其他类中继承公有的特征和行为。

比如定义汽车，轮子个数、座椅个数、最大速度等属性值，当定义电动汽车的时候就可以直接继承汽车这个类。

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
 
my_car = Car(4,5,250)
print(my_car.number_of_wheels)
print(my_car.seating_capacity)
print(my_car.maximum_velocity)

一旦初始化完成，我们就可以用实列来访问变量。

在 Python 中，我们把父类作为子类的参数，电动汽车可以直接继承汽车这个类。

class ElectricCar(Car):
    def __init__(self,number_of_wheels,seating_capacity,maximum_velocity)
      Car.__init__(self,number_of_wheels,seating_capacity,maximum_velocity)

就这么简单，不需要实现任何其他方法，因为它已经从汽车类继承了，验证一下：

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 ：从 0 到 1”的全部内容，希望对你有所帮助。
​
​关于Python技术储备

学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、Python必备开发工具

三、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、Python练习题

检查学习结果。

六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

最后祝大家天天进步！！

上面这份完整版的Python全套学习资料已经上传至CSDN官方，朋友如果需要可以直接微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】。