新手必看：手把手教你入門 Python

gexian 2019-04-05

展開全文

https://ai./page/TextTranslation/830

2018-10-15 15:24:33

發(fā)起：余杭校對：醬番梨 審核：醬番梨

參與翻譯（1人）：

CONFIDANT

英文原文：Learning Python: From Zero to Hero

標簽： Python

標題

Learning Python: From Zero to Hero

新手必看：手把手教你入門 Python

by 啦啦啦2

First of all, what is Python? According to its creator, Guido van Rossum, Python is a:

“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.”

For me, the first reason to learn Python was that it is, in fact, a beautifulprogramming language. It was really natural to code in it and express my thoughts.

Another reason was that we can use coding in Python in multiple ways: data science, web development, and machine learning all shine here. Quora, Pinterest and Spotify all use Python for their backend web development. So let’s learn a bit about it.

首先，Python是什么？據(jù)它的創(chuàng)始人Guido van Rossum而言，

“Python是一種高級編程語言，它的核心設計思想是代碼可讀性和允許程序員用幾行代碼來表達觀點的語法?！?/p>

就我而言，學習Python的首要理由是，它事實上是一種優(yōu)雅的編程語言，我可以很自然地進行編程和表達想法。

另一個原因就是在許多方面都可以用它來編程：數(shù)據(jù)科學、web開發(fā)以及機器學習都會通過它而大放光彩。Quora, Pinterest and Spotify都用它來做后臺web開發(fā)。那么讓我們一起來了解一下吧！

by CONFIDANT

The Basics

1. Variables

You can think about variables as words that store a value. Simple as that.

In Python, it is really easy to define a variable and set a value to it. Imagine you want to store number 1 in a variable called “one.” Let’s do it:

How simple was that? You just assigned the value 1 to the variable “one.”

And you can assign any other value to whatever other variables you want. As you see in the table above, the variable “two” stores the integer 2, and “some_number” stores 10,000.

Besides integers, we can also use booleans (True / False), strings, float, and so many other data types.

2. Control Flow: conditional statements

基礎

1.變量

你可以把變量當成存儲值的字符，就是這么簡單。
Python中可以很容易地定義變量并對其進行賦值。假如你想把數(shù)字1存入一個名為“one”的變量中。讓我們一起來做吧：

one = 1

這到底有多簡單呢？你只需要把值1賦給變量“one”。

two = 2some_number = 10000

而且你可以將其它任何值賦給其它任何變量。正如上表中你看到的那樣，變量“two”存儲整數(shù)2，“some_number”存儲10000。
除了整型，我們也可以使用布爾型（真/假）、字符串型、浮點型以及其它數(shù)據(jù)類型。

2.控制流：條件語句

by CONFIDANT

“If” uses an expression to evaluate whether a statement is True or False. If it is True, it executes what is inside the “if” statement. For example:

2 is greater than 1, so the “print” code is executed.

The “else” statement will be executed if the “if” expression is false.

1 is not greater than 2, so the code inside the “else” statement will be executed.

You can also use an “elif” statement:

3. Looping / Iterator

In Python, we can iterate in different forms. I’ll talk about two: while and for.

While Looping: while the statement is True, the code inside the block will be executed. So, this code will print the number from 1 to 10.

The while loop needs a “l(fā)oop condition.” If it stays True, it continues iterating. In this example, when num is 11 the loop condition equals False.

Another basic bit of code to better understand it:

The loop condition is True so it keeps iterating?—?until we set it to False.

For Looping: you apply the variable “num” to the block, and the “for” statement will iterate it for you. This code will print the same as while code: from 1 to 10.

See? It is so simple. The range starts with 1 and goes until the 11th element (10 is the 10th element).

“If”是一種判斷語句真假的表達。若為真，就執(zhí)行“if”內(nèi)部語句。比如：

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

2比1大，因此就執(zhí)行“print”代碼。

如果“if”語句為假就會執(zhí)行“else”語句。

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

1不大于2，因此就會執(zhí)行“else”內(nèi)部語句。

你也可以使用“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.循環(huán)/迭代

Python中有多重循環(huán)方法，我會提及兩種：while和for。
while循環(huán)：當語句為真時，將會執(zhí)行內(nèi)部的代碼塊。因此代碼將會輸出1到10.

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

while循環(huán)需要“循環(huán)條件”，若它為真就會執(zhí)行循環(huán)。在本例中，當
數(shù)字為11時，循環(huán)條件為假。

另一種基本代碼更容易理解：

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

循環(huán)條件為真就執(zhí)行循環(huán)直到循環(huán)條件置為假為止。

for循環(huán)：在塊內(nèi)你可以使用“num”，而且“for”語句也會執(zhí)行循環(huán)。這段代碼與while代碼（從1到10）的輸出是一樣的。

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

理解？很簡單。從1開始進行直到11，10是第十個元素。

by CONFIDANT

List: Collection | Array | Data Structure

Imagine you want to store the integer 1 in a variable. But maybe now you want to store 2. And 3, 4, 5 …

Do I have another way to store all the integers that I want, but not in millions of variables? You guessed it?—?there is indeed another way to store them.

List is a collection that can be used to store a list of values (like these integers that you want). So let’s use it:

It is really simple. We created an array and stored it on my_integer.

But maybe you are asking: “How can I get a value from this array?”

Great question. List has a concept called index. The first element gets the index 0 (zero). The second gets 1, and so on. You get the idea.

To make it clearer, we can represent the array and each element with its index. I can draw it:

Using the Python syntax, it’s also simple to understand:

Imagine that you don’t want to store integers. You just want to store strings, like a list of your relatives’ names. Mine would look something like this:

It works the same way as integers. Nice.

We just learned how Lists indices work. But I still need to show you how we can add an element to the List data structure (an item to a list).

The most common method to add a new value to a List is append. Let’s see how it works:

append is super simple. You just need to apply the element (eg. “The Effective Engineer”) as the append parameter.

Well, enough about Lists. Let’s talk about another data structure.

列表：包|數(shù)組|數(shù)據(jù)結構
假如你想將整數(shù)1用一個變量存儲，但是現(xiàn)在你或許還想存2、3、4、5以及更多。
我有其它方法來存儲我想存的所有整數(shù)而不是百萬個變量嗎？你猜到了——事實上有另一種存儲方法。

列表
是可以用來存儲一系列值（就像你想存的這些整數(shù)）的集合。那么一起來用一下吧：

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

真的很簡單。我們構造一個數(shù)組，并將它存在my_integer。
但是或許你會問：“我怎樣得到這個數(shù)組中的值？”問的好！
列表中有一個索引的概念。第一個元素的索引為0.第二個為1，以此類推，你就明白了。
為了更清楚地表示，我們可以用索引來表示數(shù)組和每個元素。我可以畫一下：

對于Python語言的使用也很容易理解：

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

假如你不想存儲整數(shù)，你想存儲字符串，像你的親人名字的集合。我的看起來是這樣的：

relatives_names = [  "Toshiaki",  "Juliana",  "Yuji",  "Bruno",  "Kaio"]

print(relatives_names[4]) # Kaio

它和整型的操作方式一樣。真棒！

我們只是學習索引如何有效使用，但是我仍然需要告訴你我們?nèi)绾螌⒁粋€元素加入數(shù)據(jù)結構（向列表中加入一項）。
向列表中增加一個新值最常見的方法就是append，讓我們一起來看看它是如何進行的：

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 Week

append超級簡單。你只需要將這個元素當作參數(shù)使用就行（有效的工程師）。這部分足夠了。讓我們談論下一種數(shù)據(jù)結構吧。

by CONFIDANT

Dictionary: Key-Value Data Structure

Now we know that Lists are indexed with integer numbers. But what if we don’t want to use integer numbers as indices? Some data structures that we can use are numeric, string, or other types of indices.

Let’s learn about the Dictionary data structure. Dictionary is a collection of key-value pairs. Here’s what it looks like:

The key is the index pointing to the value. How do we access the Dictionaryvalue? You guessed it?—?using the key. Let’s try it:

I created a Dictionary about me. My name, nickname, and nationality. Those attributes are the Dictionary keys.

As we learned how to access the List using index, we also use indices (keysin the Dictionary context) to access the value stored in the Dictionary.

In the example, I printed a phrase about me using all the values stored in the Dictionary. Pretty simple, right?

Another cool thing about Dictionary is that we can use anything as the value. In the Dictionary I created, I want to add the key “age” and my real integer age in it:

Here we have a key (age) value (24) pair using string as the key and integer as the value.

As we did with Lists, let’s learn how to add elements to a Dictionary. The key pointing to a value is a big part of what Dictionary is. This is also true when we are talking about adding elements to it:

We just need to assign a value to a Dictionary key. Nothing complicated here, right?

字典：鍵值數(shù)據(jù)結構

現(xiàn)在我們都知道，列表以整數(shù)作為索引，但是我們不想用整數(shù)作為索引怎么辦？我們可以使用的數(shù)據(jù)結構有數(shù)值型、字符串型或者是其它索引類型。
讓我們一起來了解一下字典這種數(shù)據(jù)結構吧。

dictionary_example = {  "key1": "value1",  "key2": "value2",  "key3": "value3"}

字典是鍵值對的集合，值的索引指向鍵。我們?nèi)绾潍@取字典中的值呢？你猜對了——使用鍵。讓我們一起來試一下：

dictionary_tk = {  "name": "Leandro",  "nickname": "Tk",  "nationality": "Brazilian"}print("My name is %s" %(dictionary_tk["name"])) # My name is Leandroprint("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tkprint("And by the way I'm %s" %(dictionary_tk["nationality"])) # And by the way I'm Brazilian

我構造了一個有關于我的字典，包括我的姓名、昵稱和國籍。這些屬性都是字典的鍵。正如我們學過的如何使用索引來獲取列表一樣，我們也使用索引來得到存儲在字典中的值。比如，我輸出一句有關我的語句，而它會用到所有存儲在字典中的屬性。非常簡單，對嗎？還有一件很贊的事，我們可以把任何東西當作值來使用。在我所構造的字典中，我想增加一個鍵“年齡”，而且我的真正的整數(shù)年齡也在里面：

dictionary_tk = {  "name": "Leandro",  "nickname": "Tk",  "nationality": "Brazilian",  "age": 24}print("My name is %s" %(dictionary_tk["name"])) # My name is Leandroprint("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tkprint("And by the way I'm %i and %s" %(dictionary_tk["age"], dictionary_tk["nationality"])) # And by the way I'm Brazilian

這里，我們有一組鍵（年齡）值（24）對，其中鍵為字符串型，值為整型。和我們用列表做的一樣，讓我們學一下如何向字典中增加元素吧。字典中很大一部分都是鍵指向值。當我們談論向字典中增加元素的時候，

dictionary_tk = {  "name": "Leandro",  "nickname": "Tk",  "nationality": "Brazilian"}

dictionary_tk['age'] = 24print(dictionary_tk) # {'nationality': 'Brazilian', 'age': 24, 'nickname': 'Tk', 'name': 'Leandro'}

我們只需要給字典中的鍵賦一個值。這里沒有什么是復雜的，對嗎？

by CONFIDANT

Iteration: Looping Through Data Structures

As we learned in the Python Basics, the List iteration is very simple. We Python developers commonly use For looping. Let’s do it:

So for each book in the bookshelf, we (can do everything with it) print it. Pretty simple and intuitive. That’s Python.

For a hash data structure, we can also use the for loop, but we apply the key :

This is an example how to use it. For each key in the dictionary , we printthe key and its corresponding value.

Another way to do it is to use the iteritems method.

We did name the two parameters as key and value, but it is not necessary. We can name them anything. Let’s see it:

We can see we used attribute as a parameter for the Dictionary key, and it works properly. Great!

循環(huán)：通過數(shù)據(jù)結構進行循環(huán)

正如我們在Python基礎部分學習的那樣，列表循環(huán)很簡單。Python開發(fā)者一般都是用for循環(huán)。讓我們做一下吧：

bookshelf = [  "The Effective Engineer",  "The 4 hours work week",  "Zero to One",  "Lean Startup",  "Hooked"]for book in bookshelf:    print(book)

對于書架上的每本書，我們（可以用它做任何事）將它打印出來。非常簡單直觀，這就是Python。
對于一個哈希數(shù)據(jù)結構，我們同樣可以使用for循環(huán)，但是我們要運用鍵。

dictionary = { "some_key": "some_value" }for key in dictionary:    print("%s --> %s" %(key, dictionary[key]))    
# some_key --> some_value

這是一個如何使用的例子。對于字典中的每個鍵，我們都會輸出鍵和與之對應的值。另一種方法是用iteritems方法。我們的確命名兩個參數(shù)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

我們可以把我們使用的屬性看作是字典key的一個參數(shù)，而且它可以正常運行。好極了！

by CONFIDANT

Classes & Objects

A little bit of theory:

Objects are a representation of real world objects like cars, dogs, or bikes. The objects share two main characteristics: data and behavior.

Cars have data, like number of wheels, number of doors, and seating capacity They also exhibit behavior: they can accelerate, stop, show how much fuel is left, and so many other things.

We identify data as attributes and behavior as methods in object-oriented programming. Again:

Data → Attributes and Behavior → Methods

And a Class is the blueprint from which individual objects are created. In the real world, we often find many objects with the same type. Like cars. All the same make and model (and all have an engine, wheels, doors, and so on). Each car was built from the same set of blueprints and has the same components.

類和對象
一點點理論
對象表示真實世界中的實體，像汽車、小狗或自行車。對象共享兩個主要特性：數(shù)據(jù)和行為。
汽車有數(shù)據(jù)，比如車輪數(shù)、車門數(shù)以及座位容量。它們也有可顯示的行為：加速、停車、顯示剩余燃料以及其它事情。
在面向對象過程中，我們把數(shù)據(jù)當作屬性，把行為當作方法。再來一次，數(shù)據(jù)——>屬性，行為——>方法。而且從所構造的個體對象來看，類是模型。在現(xiàn)實生活中，我們經(jīng)常會發(fā)現(xiàn)許多相同類型的實體，比如汽車。模型和形狀都是一樣的（而且都有發(fā)動機、車輪、車門等等）每輛車都用相同的模型和組件。

by CONFIDANT

Python Object-Oriented Programming mode: ON

Python, as an Object-Oriented programming language, has these concepts: class and object.

A class is a blueprint, a model for its objects.

So again, a class it is just a model, or a way to define attributes and behavior(as we talked about in the theory section). As an example, a vehicle class has its own attributes that define what objects are vehicles. The number of wheels, type of tank, seating capacity, and maximum velocity are all attributes of a vehicle.

With this in mind, let’s look at Python syntax for classes:

We define classes with a class statement?—?and that’s it. Easy, isn’t it?

Objects are instances of a class. We create an instance by naming the class.

Here car is an object (or instance) of the class Vehicle.

Remember that our vehicle class has four attributes: number of wheels, type of tank, seating capacity, and maximum velocity. We set all these attributeswhen creating a vehicle object. So here, we define our class to receive data when it initiates it:

Python的面向對象的編程模式：
Python作為一種面向對象的編程語言，有類和對象的概念。類是對象的模型。類只是一個模型，或者說是一種定義屬性和行為的方法（正如我們在理論部分所談到的那樣）。舉個例子，一個車輛類有自己的屬性，用于定義那些對象是車輛。車輪數(shù)、油箱類型、座位數(shù)和最快速度都是一輛車的屬性。帶著這些，讓我們一起來看看Python中類的語法：

class Vehicle:
    pass

我們通過類聲明來定義類——就是這樣，很簡單吧！對象是類的一個實例。我們通過命名類來構造一個實例。

car = Vehicle()
print(car) # <__main__.Vehicle instance at 0x7fb1de6c2638>

這里的car就是一個類Vehicle的一個對象（或實例）。記得我們的車輛類有四個屬性：車輪數(shù)、油箱類型、座位數(shù)和最快速度。當我們構造一個車輛對象時就需要設置這些屬性。因此這里，我們需要定義我們的類，當它初始化的時候能夠接收數(shù)據(jù)。

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

by CONFIDANT

We use the init method. We call it a constructor method. So when we create the vehicle object, we can define these attributes. Imagine that we love the Tesla Model S, and we want to create this kind of object. It has four wheels, runs on electric energy, has space for five seats, and the maximum velocity is 250km/hour (155 mph). Let’s create this object:

Four wheels + electric “tank type” + five seats + 250km/hour maximum speed.

All attributes are set. But how can we access these attributes’ values? We send a message to the object asking about them. We call it a method. It’s the object’s behavior. Let’s implement it:

This is an implementation of two methods: number_of_wheels and set_number_of_wheels. We call it getter & setter. Because the first gets the attribute value, and the second sets a new value for the attribute.

In Python, we can do that using @property (decorators) to define gettersand setters. Let’s see it with code:

And we can use these methods as attributes:

This is slightly different than defining methods. The methods work as attributes. For example, when we set the new number of wheels, we don’t apply two as a parameter, but set the value 2 to number_of_wheels. This is one way to write pythonic getter and setter code.

But we can also use methods for other things, like the “make_noise” method. Let’s see it:

When we call this method, it just returns a string “VRRRRUUUUM.”

我們會用到init方法。我們稱它為構造方法。因此當我們構造一個車輛實體時，我們可以定義這些屬性。假設我們都喜歡特斯拉模型S，我們想要構造一個這種類型的對象。它是電動的，有四個車輪和五個座位，而且最快速度為250千米/小時（155英里/小時）。讓我們創(chuàng)建一個這種對象：

tesla_model_s = Vehicle(4, 'electric', 5, 250)

對所有屬性進行設置：四個輪子+電動“油箱類型”+五個座位+最快速度為250千米/小時。但是我們?nèi)绾潍@取這些屬性的值呢？我們向該對象發(fā)送了一條查詢屬性值的信息，我們稱之為方法，它是對象的行為。讓我們一起來實現(xiàn)吧：

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

包括兩種方法的實現(xiàn)：車輪數(shù)和車輪數(shù)的設置。我們稱為getter和setter，因為前者獲得屬性值，而后者獲得該屬性的一個新值。
在Python中，我們可以這樣做：用@property(decorators)來定義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) # 4tesla_model_s.number_of_wheels = 2 # setting number of wheels to 2print(tesla_model_s.number_of_wheels) # 2

這里有點不同于定義方法，方法和屬性的作用一樣。比如，當我們設置新的車輪數(shù)時，我們不會把2作為參數(shù)，而是把number_of_wheels的值設為2。這是一種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    def make_noise(self):
        print('VRUUUUUUUM')

當我們調用這種方法時，它就會返回一串“VRRRRUUUUM”。

tesla_model_s = Vehicle(4, 'electric', 5, 250)
tesla_model_s.make_noise() # VRUUUUUUUM

by CONFIDANT

Encapsulation: Hiding Information

Encapsulation is a mechanism that restricts direct access to objects’ data and methods. But at the same time, it facilitates operation on that data (objects’ methods).

“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

All internal representation of an object is hidden from the outside. Only the object can interact with its internal data.

First, we need to understand how public and non-public instance variables and methods work.

Public Instance Variables

For a Python class, we can initialize a public instance variable within our constructor method. Let’s see this:

Within the constructor method:

Here we apply the first_name value as an argument to the public instance variable.

Within the class:

Here, we do not need to apply the first_name as an argument, and all instance objects will have a class attribute initialized with TK.

Cool. We have now learned that we can use public instance variables and class attributes. Another interesting thing about the public part is that we can manage the variable value. What do I mean by that? Our object can manage its variable value: Get and Set variable values.

Keeping the Person class in mind, we want to set another value to its first_name variable:

There we go. We just set another value (kaio) to the first_name instance variable and it updated the value. Simple as that. Since it’s a public variable, we can do that.

封裝：隱藏信息
封裝機制不允許直接獲取對象的數(shù)據(jù)和方法，但與此同時，它提供了對數(shù)據(jù)和方法的操作。
“封裝可以用來隱藏數(shù)據(jù)成員和功能成員，在此定義下，封裝意味著一個對象的內(nèi)部表示通常對該對象以外是隱藏的”?！S基百科

一個對象的內(nèi)部表示對外界是隱藏的，只有該對象可以聯(lián)系到其內(nèi)部數(shù)據(jù)。首先我們需要理解公有和非公有實例變量和方法如何運行。

公有實例變量
對于一個Python類，我們用結構化方法初始化一個公有實例變量，讓我們一起來看一下：

class Person:
    def __init__(self, first_name):        self.first_name = first_name

在結構體方法中，我們用first_name的值作為對公有實例變量的聲明。

tk = Person('TK')print(tk.first_name) # => TK

在類中，我們不需要將first_name作為聲明，而且實例對象會有一個類屬性，并用初始化為TK。

tk = Person()
print(tk.first_name) # => TK

很棒！現(xiàn)在我們知道我們可以使用公有實例變量和類屬性。另一件有關于公有部分的有趣的事情是我們可以管理變量的值。那意味著什么？對象可以管理和設置其變量的值。

要記得Person類，我們想給它的first_name設置另一個值：

tk = Person('TK')
tk.first_name = 'Kaio'print(tk.first_name) # => Kaio

開始了，我們只是把kaio賦給first_name這個實例變量，而且對其值進行了更新。很簡單，因為它是公有變量，所以我們可以這樣做。

by CONFIDANT

Non-public Instance Variable

We don’t use the term “private” here, since no attribute is really private in Python (without a generally unnecessary amount of work).?—?PEP 8

As the public instance variable , we can define the non-public instance variable both within the constructor method or within the class. The syntax difference is: for non-public instance variables , use an underscore (_) before the variable name.

“‘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

Here’s an example:

Did you see the email variable? This is how we define a non-public variable :

We can access and update it. Non-public variables are just a convention and should be treated as a non-public part of the API.

So we use a method that allows us to do it inside our class definition. Let’s implement two methods (email and update_email) to understand it:

Now we can update and access non-public variables using those methods. Let’s see:

We initiated a new object with first_name TK and email tk@mail.com
Printed the email by accessing the non-public variable with a method
Tried to set a new email out of our class
We need to treat non-public variable as non-public part of the API
Updated the non-public variable with our instance method
Success! We can update it inside our class with the helper method

非公有實例變量

這里我們不用“私有”這一術語，因為在Python中不存在真正的私有屬性（一般沒有不必要的工作量）?！狿EP 8
正如public instance variable一樣，我們可以用構造方法或在類內(nèi)定義non-public instance variable。語法上的不同有：non-public instance variables在變量名前使用下劃線。
“在Python中不存在這樣的情況：在對象內(nèi)部以外無法獲取‘private’實例變量，然而在Python代碼中一貫遵循的一個習慣是：變量名前要加下劃線前綴（比如：_spam），名字一般作為API的非公有部分（無論它是函數(shù)、方法還是數(shù)據(jù)成員）”——Python Software Foundation
有這樣一個例子：

class Person:
    def __init__(self, first_name, email):        self.first_name = first_name        self._email = email

你看到email變量了嗎？它顯示了我們?nèi)绾味xnon-public variable：

tk = Person('TK', 'tk@mail.com')
print(tk._email) # tk@mail.com

我們可以獲得并更新它。Non-public variables僅僅是種習慣，而且應該被當作API的非公有部分。因此我們用一種方法，它允許我們在類內(nèi)對其進行定義。一起來實現(xiàn)以下兩個方法：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

現(xiàn)在我們使用方法可以更新和獲取non-public variables。讓我們一起來看一下：

tk = Person('TK', 'tk@mail.com')
print(tk.email()) # => tk@mail.comtk._email = 'new_tk@mail.com'print(tk.email()) # => tk@mail.comtk.update_email('new_tk@mail.com')
print(tk.email()) # => new_tk@mail.com

1.我們用TK和tk@mail.com對一個新對象的first_name和email進行初始化。
2.使用方法獲得non-public variable，然后輸出email。
3.試著在我們的類外設置一個新的email。
4.我們需要將non-public variable作為API的non-public部分。
5.用我們的實例方法更新non-public variable。
6.成功了！我們借助幫助方法可以在類內(nèi)對其進行更新。

by CONFIDANT

Public Method

With public methods, we can also use them out of our class:

Let’s test it:

Great?—?we can use it without any problem.

Non-public Method

But with non-public methods we aren’t able to do it. Let’s implement the same Person class, but now with a show_age non-public method using an underscore (_).

And now, we’ll try to call this non-public method with our object:

We can access and update it. Non-public methods are just a convention and should be treated as a non-public part of the API.

Here’s an example for how we can use it:

Here we have a _get_age non-public method and a show_age public method. The show_age can be used by our object (out of our class) and the _get_age only used inside our class definition (inside show_age method). But again: as a matter of convention.

公有方法
我們可以在類外使用公有方法，

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

棒極了——沒有任何問題！

非公有方法

對于非公有方法，我們不能那樣做。一起來實現(xiàn)一個同樣的Person類，但是現(xiàn)在我們會用下劃線表示non-public method，即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

現(xiàn)在會通過對象來調用這個方法：

tk = Person('TK', 25)print(tk._show_age()) # => 25

我們可以獲得它并對其進行更新。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

tk = Person('TK', 25)
print(tk.show_age()) # => 25

這里我們有一個public method為show_age，我們的對象（在類外）可以使用它，而_get_age只能在類定義部分使用（在show_age方法中）。再次提醒：這只是習慣問題。

by CONFIDANT

Encapsulation Summary

With encapsulation we can ensure that the internal representation of the object is hidden from the outside.

Inheritance: behaviors and characteristics

Certain objects have some things in common: their behavior and characteristics.

For example, I inherited some characteristics and behaviors from my father. I inherited his eyes and hair as characteristics, and his impatience and introversion as behaviors.

In object-oriented programming, classes can inherit common characteristics (data) and behavior (methods) from another class.

Let’s see another example and implement it in Python.

Imagine a car. Number of wheels, seating capacity and maximum velocity are all attributes of a car. We can say that an ElectricCar class inherits these same attributes from the regular Car class.

Our Car class implemented:

Once initiated, we can use all instance variables created. Nice.

In Python, we apply a parent class to the child class as a parameter. An ElectricCar class can inherit from our Car class.

Simple as that. We don’t need to implement any other method, because this class already has it (inherited from Car class). Let’s prove it:

Beautiful.

封裝總結
有了封裝，我們可以確保對象的內(nèi)部表示對外是隱藏的。
繼承：行為和特性
某些對象有共同點：行為和特性
舉個例子,我繼承了我父親的一些行為和特性。我繼承了他的眼睛和頭發(fā)作為特性，他的不耐心和內(nèi)向作為行為。
在面向對象編程中，類可以繼承另一個類的共同特性（數(shù)據(jù)）和行為（方法）。
讓我們一起來看另一個例子，并用Python對其進行實現(xiàn)。
假定有一輛汽車，它的屬性有：車輪數(shù)、座位數(shù)和最快速度。我們可以說電動車類繼承普通車類的這些相同屬性。

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

已經(jīng)實現(xiàn)了我們的汽車類：

my_car = Car(4, 5, 250)print(my_car.number_of_wheels)print(my_car.seating_capacity)print(my_car.maximum_velocity)

一旦對其進行初始化，我們就可以使用所構造的所有instance variables。非常棒！在Python中，我們可以將parent class作為child class的一個參數(shù)。一個電動車類可以繼承我們的汽車類。

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

就是這么簡單。我們不需要實現(xiàn)其它任何方法，因為這個類已經(jīng)有了這些方法（繼承了汽車類）。讓我們來證明一下：

my_electric_car = ElectricCar(4, 5, 250)print(my_electric_car.number_of_wheels) # => 4print(my_electric_car.seating_capacity) # => 5print(my_electric_car.maximum_velocity) # => 250

非常漂亮！

by CONFIDANT