1. 前言

??系列課程第一節：如何掌握編程的基本概念講解了為什么要學習基本概念以及如何學習，這節課是傾心打造的原創內容，對初學者學會自學很有幫助，

??除此之外，還詳細介紹了Jupyter Notebook的使用、如何掌握編程規范、如何查閱API檔案，之所以要花很多篇幅講解上述內容，主要是想給大家傳授學習編程的通用方法，不僅可以用在Pytho學習上，也可以用來學習其他編程語言中，

??課程的主要內容是通過講解學習編程最權威的資料(第一手資料)，也就是官方檔案，為了幫助大家更好的進行理解，會在課程中遇到的基本概念進行重點講解，這節課是正式學習Python語法的第一節，正餐即將開始，敬請期待：

??之前課程已經講過了Jupyter Notebook的使用方法，按理來說，直接使用Jupyter Notebook學習基礎語法更方便快捷，但是考慮再三，為了讓大家學的更加扎實，更推薦先使用Python解釋器的互動模式進行練習，有余力的同學，建議在Jupyter Notebook中再練習一遍，

2. 核心概念之變數

??在正餐開始之前呢，我們先講一個核心概念變數，首先變數在不同領域內是含義是不同的，

• 在數學中，變數是指數學運算式中的代表數量的符號，例如咱們常用的x、y、z，
• 在研究中，變數是指一系列的屬性，
• 在計算機科學(Computer Science，簡稱CS)，變數是指存盤在計算機中的數值相應的符號，通過運算式往往能夠改變該值，

??可以看出，在數學中和在計算機科學中，變數都是用來表示數值的，那區別是在哪里呢？區別主要體現在以下兩點：

1. 在計算機中，變數指的是存盤在計算機中的數值，所以它只能存盤一定范圍的值，而且由于計算機的本質使用的是二進制，所以要對原始數值進行編碼，最終存盤到計算機中，
2. 在計算機中，變數對應的值往往是能夠改變的，

3. Python的正式介紹

??本節課對應的官網鏈接為https://docs.python.org/3.6/tutorial/introduction.html，由于主要使用的是Python解釋器的互動模式，所以再復習一下Python解釋器的主要內容，

??在Python解釋器中，代碼輸入和結果輸出的區別之處在于，代碼輸入對應的行最前面有提示符(>>>或者…)，反之則為結果輸出，如下圖所示：

??上圖中，出現了行首提示符(…)，則表示需要輸入多行代碼，而且最后一行必須為空行，即最后一行直接按回車即可，

??除此之外，在手冊或者代碼中，往往會看到另外一個符號的身影，也就是#，#表示注釋的開頭，那什么是注釋呢？簡單來說，注釋就是對代碼的說明，打個比方來說，注釋相當于書評，并不會影響正文內容，也不會影響代碼的實際運行，舉個栗子：

# 這是第一句注釋
spam = 1  # 第二句注釋
          # ...第三句注釋
text = "# This is not a comment because it's inside quotes."

??需要注意的是text = “# This is not a comment because it’s inside quotes.”，由于#是包含在雙引號之內的，它是text字串的一部分，所以就不是注釋了，

3.1 使用Python作為計算器

3.1.1 數值運算

??Python解釋器最簡單的用法就是把它當成計算器進行使用，可以輕松的進行各種四則運算，如下所示：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating point number
1.6

??需要注意的是，數值型別包括兩大類，一個是整型(整數型別)，一個是浮點型(小數型別)，在計算機中，3和3.0雖然值是相等的，但是它們在計算機中對應的二進制卻并不相同，有同學可能在想，是不是在3對應的二進制的基礎上將.對應的二進制進行拼接就能得到3.0對應的二進制呢？這個題作為一個思考題，請大家自行進行思考，

??除了除法運算/以外，還有除法后取整//、除法取余操作，分別如下所示：

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # result * divisor + remainder
17

??如果整型和浮點型資料之間進行四則運算的話，會自動將整型轉換成浮點型進行運算：

>>> 4 * 3.75 - 1
14.0

??想把浮點型變數轉換成整型也很容易，使用int函式即可，反之使用float函式即可

>>>price = 15.0
>>>int(price)
15
>>>price = 15
>>>float(price)
15.0

??在Python中，冪運算用**進行表示，如下所示：

>>>
>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

??等號是用來對變數進行賦值的， 需要注意的是，賦值運算并不會產生任何輸出，如下所示：

>>>
>>> width = 20
>>> height = 5 * 9
>>> width * height
900

??如果變數沒有被定義(沒有進行賦值操作)，使用未賦值的變數就會報錯：

>>>
>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

??在Python解釋器互動模式中，最后一個運算式的值會賦值給變數_，有時就會用起來很便利，如下所示：

>>>
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

??但需要注意的是，在進行變數命名時，請勿使用內置變數或者內置函式的名稱，例如上述的_和int、float等，

??在數值型別中，除了int和float型別以外，還有Decimal和Fraction型別可以用來處理分數運算，另外，Python還支持復數運算，可使用j來表示虛部，如下所示：

3.1.2 字串型別

??Python字串的三種表示方法如下所示：

# 不同個數的引號在表示字串時沒有區別，但字串開頭結尾必須使用同一種引號，否則報錯
url = 'http://www.python.org'  # 單引號
url = "http://www.python.org"  # 雙引號
url_new = '''http://www.python.org'''  # 三引號
print(url)

??思考題：為什么Python設計了三種表達字串的方法？而其他語言往往只有一種，如C語言只有雙引號來表示字串，

??在字串中，可使用反斜杠\來表示轉義字符，有關轉義字符的概念請參考鏈接：https://blog.csdn.net/herosunly/article/details/114961274中第二節：如何學習官網教程中的內容，

??在Python中，可使用print函式來列印字串變數的值，但輸出時會忽略字串中最開始和最末尾的引號，以及轉義字符和其他特殊字符，

'"Isn\'t," they said.'
>>> print('"Isn\'t," they said.')
"Isn't," they said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s)  # with print(), \n produces a new line
First line.
Second line.

??如果不想讓反斜杠\來表示轉義字符，可以在字串最起始的位置(起始引號)之前加上r，如下所示：

>>>
>>> print('C:\some\name')  # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name')  # note the r before the quote
C:\some\name

??三引號除了在字串內能同時使用單引號和雙引號以外，它的另一個主要作用是用來表示多行字串，可在第一行的三引號后緊跟一個反斜杠(大家可以試試不加的效果，看看有什么差異)，代碼如下所示：

print('''\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
''')

??顯示結果如下所示：

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

??字串之間可使用+來進行拼接，也可以使用*表示相同字串重復拼接在一起，如下所示：

>>>
>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

??相鄰的兩個字串常量會自動進行拼接：

>>>
>>> 'Py' 'thon'
'Python'

??過長的字串可以通過上述分段表示：

>>>
>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

??但只能用在兩個字串常量，而不能使用在變數和常量之間：

>>>
>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax

??連接字串變數和常量之間，請使用+：

>>>
>>> prefix + 'thon'
'Python'

??除了拼接以外，字串可以進行索引訪問，例如通過索引0來訪問字串中最起始的字符，需要注意的是，在Python中并沒有單獨的字符型別（C語言有）

>>>
>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

??索引也可以是負值，負號后面的值表示從最右端開始計算的索引，需要注意的是最右邊的字符索引為-1(思考一下，為什么是從-1開始呢)：

>>>
>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

??除了索引操作以外，字串也支持切片操作，切片是索引的升級操作，索引是取出單個字符，而切片是取出字串的子串：

>>>
>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

??需要注意的是，切片取的是位于左閉右開區間的子串，所以，s[:i] + s[i:] 和s是等價的，

>>>
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

??為了簡單起見，如果在使用切片時省略起始引數，則表示起始位置為0：

>>>
>>> word[:2]   # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]   # characters from position 4 (included) to the end
'on'
>>> word[-2:]  # characters from the second-last (included) to the end
'on'

??為了幫助初學者理解，特意將一個特定字串每個位置對應的索引標出，請先用筆自己寫一下每個位置的正負索引，然后進行對照學習：

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

??思考題：如果給出了字串切片的起始引數和終止引數，是否能計算出字串的長度呢？

??但是索引超出了字串的范圍，就會報錯：

>>>
>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

??但是切片操作就會規避以上的錯誤，如下所示：

>>>
>>> word[4:42]
'on'
>>> word[42:]
''

??Python字串是不能改變的，即無法通過索引或者切片的方式修改字串的值，否則會報錯，

>>>
>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'

??如果需要一個新的字串，請重新創建字串:

>>>
>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

??那么就有同學對下列運算式有疑問，這是屬于改變字串的值嗎？

>>> a = '123'
>>> a = '456'

??其實不是的，它本質是創建了一個新的字串然后再傳給a，那不是把字串123修改成了字串456，如果大家有興趣，可以了解一下值傳遞和址傳遞，

??內置函式len()將會回傳字串的長度：

>>>
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

3.1.3 串列

??上述的資料型別為基本型別，那能否把相同型別或者不同的型別組合在一起，構成復合型別呢？

??在Python中最通用復合型別的是串列，在串列中，用方括號表示起始和終止符號，不同元素之間以逗號隔開，不同元素可以是不同型別的，但通常是相同型別的，另外，逗號后面往往會跟一個空格，這個屬于編程規范，編程規范的內容詳見鏈接：https://blog.csdn.net/herosunly/article/details/114313439，

>>>
>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

??字串和串列都屬于序列型別，所以也支持索引和切片操作：

>>>
>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

??切片和索引操作后會回傳一個新的串列，這是對原有串列進行淺拷貝：

>>>
>>> squares[:]
[1, 4, 9, 16, 25]

??串列也支持拼接操作：

>>>
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

??與字串型別不同的是，字串是不可變的，而串列是可變的，

>>>
>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

??也可以使用append方法在串列最后拼接新的元素：

>>>
>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

??通過切片進行重新賦值也是可行的，可能會改變原有串列的長度：

>>>
>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

??同樣可以使用內置函式len()來求得串列的長度：

>>>
>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

??串列也支持嵌套操作，即串列中的元素也可以為串列：

>>>
>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2 編程的第一步

??除了完成四則運算等簡單任務以外，可以用Python來完成更加復雜的任務，例如得到斐波那契數列，

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5
8

??a, b = 0, 1，在這行代碼中使用了多個變數的賦值，從而同時把0賦值給a、把1賦值給b，最后一行代碼a, b = b, a+b也是相同的，

??Python比較運算和C語言是類似的: < (小于), > (大于), == (等于), <= (小于等于), >= (大于等于) and != (不等于)，

??回圈包括回圈條件和回圈體，while回圈是在條件為真(b < 10)時多次執行，直至條件為假時退出，在Python中(與C類似)，非零為真，零為假，這里的零，不僅指的是數值0，而且如果當序列長度為0時，也為零，

??而回圈體需要添加縮進符號，在互動式模式中，縮進可通過一個TAB或者若干個空格進行表示，需要注意的是，縮進符號一旦指定之后，后續必須使用相同的縮進符號，但最好使用四個空格來表示縮進，可在代碼編輯器中進行設定，將TAB自動轉換成四個空格，

??print()函式可以將字串和變數的值放到一起進行列印，如下所示：

>>>
>>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536

??在print()函式中可重新指定引數end，從而替換默認的換行符：

>>>
>>> a, b = 0, 1
>>> while b < 1000:
...     print(b, end=',')
...     a, b = b, a+b
...
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

??對本系列課程感興趣的同學可以點擊鏈接：https://blog.csdn.net/herosunly/category_10831935.html，課程更新時間為每周至少一篇，希望能對大家學習Python有所幫助，