Python初識——基礎篇

1、Python介紹

1.一、什麼是編程語言

其實，程序指的就是一系列指令，用來告訴計算機作什麼，而編寫程序的關鍵在於，咱們須要用計算機能夠理解的語言來提供這些指令。

爲了有效避開全部影響給計算機傳遞指令的因素，計算機科學家設計了一些符號，這些符號各有其含義，且之間無二義性，一般稱它們爲編程語言。編程語言中的每一個結構，都有固定的使用格式（稱爲語法）以及精確的含義（稱爲語義）。換句話說，編程語言指定了成套的規則，用來編寫計算機能夠理解的指令。習慣上，咱們將這一條條指令稱爲計算機代碼，而用編程語言來編寫算法的過程稱爲編碼。

本教程要講解的 Python] 就是一種編程語言，除此以外，你確定也據說過其餘一些編程語言，如 C、C++,Java、Ruby 等。至今，計算機科學家已經開發了成百上千種編程語言，且隨着時間演變，這些編程語言又產生了多個不一樣的版本。但不管是哪一個編程語言，也不管有多少個版本，雖然它們在細節上可能有所不一樣，無疑它們都有着固定的、無二義性的語法和語義。

以上提到的編程語言，都是高級計算機語言，設計它們的目的是爲了方便程序員理解和使用。但嚴格來講，計算機硬件只能理解一種很是低級的編程語言，稱爲機器語言。

1.二、編譯型語言和解釋型語言的區別

咱們編寫的源代碼是人類語言，咱們本身可以輕鬆理解；可是對於計算機硬件（CPU），源代碼就是天書，根本沒法執行，計算機只能識別某些特定的二進制指令，在程序真正運行以前必須將源代碼轉換成二進制指令。所謂的二進制指令，也就是機器碼，是 CPU 可以識別的硬件層面的「代碼」。

然而，究竟在何時將源代碼轉換成二進制指令呢？不一樣的編程語言有不一樣的規定：

• 有的編程語言要求必須提早將全部源代碼一次性轉換成二進制指令，也就是生成一個可執行程序（Windows 下的 .exe），好比C語言、C++、Go、Pascal（Delphi）、彙編等，這種編程語言稱爲編譯型語言，使用的轉換工具稱爲編譯器。

• 有的編程語言能夠一邊執行一邊轉換，須要哪些源代碼就轉換哪些源代碼，不會生成可執行程序，好比 Python、JavaScript、PHP、Shell、MATLAB等，這種編程語言稱爲解釋型語言，使用的轉換工具稱爲解釋器。

一、簡單理解，編譯器就是一個「翻譯工具」，相似於將中文翻譯成英文、將英文翻譯成俄文。可是，翻譯源代碼是一個複雜的過程，大體包括詞法分析、語法分析、語義分析、性能優化、生成可執行文件等幾個步驟

二、Java和 C#是一種比較奇葩的存在，它們是半編譯半解釋型的語言，源代碼須要先轉換成一種中間文件（字節碼文件），而後再將中間文件拿到虛擬機中執行。Java 引領了這種風潮，它的初衷是在跨平臺的同時兼顧執行效率；C# 是後來的跟隨者，可是 C# 一直止步於 Windows 平臺，在其它平臺鮮有做爲。

 

圖 1 編譯型語言和解釋型語言的執行流程

那麼，編譯型語言和解釋型語言各有什麼特色呢？它們之間有什麼區別？

對於編譯型語言，開發完成之後須要將全部的源代碼都轉換成可執行程序，好比 Windows 下的.exe文件，可執行程序裏面包含的就是機器碼。只要咱們擁有可執行程序，就能夠隨時運行，不用再從新編譯了，也就是「一次編譯，無限次運行」。在運行的時候，咱們只須要編譯生成的可執行程序，再也不須要源代碼和編譯器了，因此說編譯型語言能夠脫離開發環境運行。編譯型語言通常是不能跨平臺的，也就是不能在不一樣的操做系統之間隨意切換。

對於解釋型語言，每次執行程序都須要一邊轉換一邊執行，用到哪些源代碼就將哪些源代碼轉換成機器碼，用不到的不進行任何處理。每次執行程序時可能使用不一樣的功能，這個時候須要轉換的源代碼也不同。由於每次執行程序都須要從新轉換源代碼，因此解釋型語言的執行效率天生就低於編譯型語言，甚至存在數量級的差距。計算機的一些底層功能，或者關鍵算法，通常都使用 C/C++ 實現，只有在應用層面（好比網站開發、批處理、小工具等）纔會使用解釋型語言。

在運行解釋型語言的時候，咱們始終都須要源代碼和解釋器，因此說它沒法脫離開發環境。

當咱們說「下載一個程序（軟件）」時，不一樣類型的語言有不一樣的含義：

• 對於編譯型語言，咱們下載到的是可執行文件，源代碼被做者保留，因此編譯型語言的程序通常是閉源的。

• 對於解釋型語言，咱們下載到的是全部的源代碼，由於做者不給源代碼就無法運行，因此解釋型語言的程序通常是開源的。

相比於編譯型語言，解釋型語言幾乎都能跨平臺，「一次編寫，處處運行」是真是存在的，並且比比皆是。那麼，爲何解釋型語言就能跨平臺呢？這一切都要歸功於解釋器！

咱們所說的跨平臺，是指源代碼跨平臺，而不是解釋器跨平臺。解釋器用來將源代碼轉換成機器碼，它就是一個可執行程序，是絕對不能跨平臺的。解釋型語言之因此可以跨平臺，是由於有了解釋器這個中間層。在不一樣的平臺下，解釋器會將相同的源代碼轉換成不一樣的機器碼，解釋器幫助咱們屏蔽了不一樣平臺之間的差別。

Python 屬於典型的解釋型語言，因此運行 Python 程序須要解釋器的支持，只要你在不一樣的平臺安裝了不一樣的解釋器，你的代碼就能夠隨時運行，不用擔憂任何兼容性問題，真正的「一次編寫，處處運行」。Python 幾乎支持全部常見的平臺，好比 Linux、Windows、Mac OS、Android、FreeBSD、Solaris、PocketPC 等，你所寫的 Python 代碼無需修改就能在這些平臺上正確運行。也就是說，Python 的可移植性是很強的。

1.三、Python介紹

Python 英文原意爲「蟒蛇」，直到 1989 年荷蘭人 Guido van Rossum （簡稱 Guido）發明了一種面向對象的解釋型編程語言，並將其命名爲 Python，才賦予了它表示一門編程語言的含義。

 

Python 語言是在 ABC 教學語言的基礎上發展來的；遺憾的是，ABC 語言雖然很是強大，但卻沒有普及應用，Guido 認爲是它不開放致使的。基於這個考慮，Guido 在開發 Python 時，不只爲其添加了不少 ABC 沒有的功能，還爲其設計了各類豐富而強大的庫，利用這些 Python 庫，程序員能夠把使用其它語言製做的各類模塊（尤爲是C語言和 C++）很輕鬆地聯結在一塊兒，所以 Python 又常被稱爲「膠水」語言。

Python的語言優點有如下幾個點:

• 簡單易學

• 跨平臺

• 豐富強大的庫

• 極高的開發效率

• 應用領域普遍

• 擴展性強

1.四、Python環境安裝

1.4.一、解釋器的類型

'''
(1)Cpython(官方推薦)
    把python轉化成c語言能識別的二進制碼
(2)Jpython
       把python轉化成java語言能識別的二進制碼
(3)其餘語言解釋器
       把python轉化成其餘語言能識別的二進制碼
(4)PyPy
       將全部代碼一次性編譯成二進制碼,加快執行效率(模仿編譯型語言的一款python解釋器)
'''        

1.4.二、Cpython解釋器的版本

   '''
   python 2.x 版本，官方在 2020 年中止支持,原碼不規範,重複較多
   python 3.x 版本，功能更增強大且修復了不少bug,原碼清晰,簡單
   '''   

1.4.三、下載安裝Python解釋器

Python 安裝包下載地址：https://www.python.org/downloads/

 

 

 

 

 

安裝完成之後，打開 Windows 的命令行程序（命令提示符），在窗口中輸入python命令（注意字母p是小寫的），若是出現 Python 的版本信息，並看到命令提示符>>>，就說明安裝成功了，以下圖所示。

 

請儘可能勾選Add Python 3.8 to PATH，這樣能夠將 Python 命令工具所在目錄添加到系統 Path 環境變量中，之後開發程序或者運行 Python 命令會很是方便。

1.五、Python的第一個程序

python python文件名

 

2、基礎語法

2.一、變量

2.1.一、python的標識符規範

簡單地理解，標識符就是一個名字，就好像咱們每一個人都有屬於本身的名字，它的主要做用就是做爲變量、函數、類、模塊以及其餘對象的名稱。Python中標識符的命名不是隨意的，而是要遵照必定的命令規則

'''
一、標識符是由字符（A~Z 和 a~z）、下劃線和數字組成，但第一個字符不能是數字。
二、標識符不能和 Python 中的保留字相同。有關保留字，後續章節會詳細介紹。
三、Python中的標識符中，不能包含空格、@、% 以及 $ 等特殊字符。
四、在 Python 中，標識符中的字母是嚴格區分大小寫
五、Python 語言中，如下劃線開頭的標識符有特殊含義
六、Python 容許使用漢字做爲標識符（不推薦）
'''

標識符的命名，除了要遵照以上這幾條規則外，不一樣場景中的標識符，其名稱也有必定的規範可循，例如：

'''
- 當標識符用做模塊名時，應儘可能短小，而且所有使用小寫字母，可使用下劃線分割多個字母，例如 game_mian、game_register 等。
- 當標識符用做包的名稱時，應儘可能短小，也所有使用小寫字母，不推薦使用下劃線，例如 com.mr、com.mr.book 等。
- 當標識符用做類名時，應採用單詞首字母大寫的形式。例如，定義一個圖書類，能夠命名爲 Book。
- 模塊內部的類名，能夠採用 "下劃線+首字母大寫" 的形式，如 _Book;
- 函數名、類中的屬性名和方法名，應所有使用小寫字母，多個單詞之間能夠用下劃線分割；
- 常量命名應所有使用大寫字母，單詞之間能夠用下劃線分割；
'''

2.1.二、python的關鍵字

and	as	assert	break	class	continue
def	del	elif	else	except	finally
for	from	False	global	if	import
in	is	lambda	nonlocal	not	None
or	pass	raise	return	try	True
while	with	yield

2.1.三、變量

變量是一段有名字的連續存儲空間。咱們經過定義變量來申請並命名這樣的存儲空間，並經過變量的名字來使用這段存儲空間。在編程語言中，將數據放入變量的過程叫作賦值（Assignment）。Python 使用等號=做爲賦值運算符，具體格式爲：

變量名 = 任意類型的值(存儲數據) 

例如:

x = 10
y = "hi,yuan"
z = True
# 變量的值能夠隨時被修改，只要從新賦值便可 並且,你也不用關心數據的類型
​
x = "hello world"

思考:

x = 10
x = 20
y = x
y = 30
print(x)
print(y)

2.二、語句分隔符和縮進規則

在C、Java等語言的語法中規定，必須以分號做爲語句結束的標識。Python也支持分號，一樣用於一條語句的結束標識。但在Python中分號的做用已經不像C、Java中那麼重要了，Python中的分號能夠省略，主要經過換行來識別語句的結束。

和其它程序設計語言（如 Java、C 語言）採用大括號「{}」分隔代碼塊不一樣，Python 採用代碼縮進和冒號（ : ）來區分代碼塊之間的層次。在 Python 中，對於類定義、函數定義、流程控制語句、異常處理語句等，行尾的冒號和下一行的縮進，表示下一個代碼塊的開始，而縮進的結束則表示此代碼塊的結束。

注意，Python 中實現對代碼的縮進，可使用空格或者 Tab 鍵實現。但不管是手動敲空格，仍是使用 Tab 鍵，一般狀況下都是採用 4 個空格長度做爲一個縮進量（默認狀況下，一個 Tab 鍵就表示 4 個空格）。

Python 的設計哲學是優雅、明確、簡單

2.三、註釋

註釋（Comments）用來向用戶提示或解釋某些代碼的做用和功能，它能夠出如今代碼中的任何位置。Python 解釋器在執行代碼時會忽略註釋，不作任何處理，就好像它不存在同樣。在調試（Debug）程序的過程當中，註釋還能夠用來臨時移除無用的代碼。

通常狀況下，合理的代碼註釋應該佔源代碼的 1/3 左右。Python 支持兩種類型的註釋，分別是單行註釋和多行註釋。

# Python的單行註釋
'''
Python的多行註釋
這是註釋代碼,不被解釋器執行的內容
'''

注意事項:

(1) Python 多行註釋不支持嵌套

(2) 無論是多行註釋仍是單行註釋，當註釋符做爲字符串的一部分出現時，就不能再將它們視爲註釋標記，而應該看作正常代碼的一部分，例如：

print('''Hello,World!''')
print("""http://c.biancheng.net/cplus/""")
print("#是單行註釋的開始")

2.四、輸入輸出函數

print("hi,yuan") # 輸入函數
input(">>>")  # 輸入函數

2.五、Python編碼規範（PEP 8）

Python 採用 PEP 8 做爲編碼規範，其中 PEP 是 Python Enhancement Proposal（Python 加強建議書）的縮寫，8 表明的是 Python 代碼的樣式指南。下面僅給你們列出 PEP 8 中初學者應嚴格遵照的一些編碼規則：

一、每一個 import 語句只導入一個模塊，儘可能避免一次導入多個模塊，例如：

#推薦
import os
import sys
#不推薦
import os,sys

關於 import 的含義和用法會在後續介紹，這裏沒必要深究。

二、不要在行尾添加分號，也不要用分號將兩條命令放在同一行

三、建議每行不超過 80 個字符，若是超過，建議使用小括號將多行內容隱式的鏈接起來，而不推薦使用反斜槓 \ 進行鏈接。例如，若是一個字符串文本沒法實現一行徹底顯示，則可使用小括號將其分開顯示，代碼以下：

#推薦
s=("C語言中文網是中國領先的C語言程序設計專業網站，"
"提供C語言入門經典教程、C語言編譯器、C語言函數手冊等。")
#不推薦
s="C語言中文網是中國領先的C語言程序設計專業網站，\
提供C語言入門經典教程、C語言編譯器、C語言函數手冊等。"

四、使用必要的空行能夠增長代碼的可讀性，一般在頂級定義（如函數或類的定義）之間空兩行，而方法定義之間空一行，另外在用於分隔某些功能的位置也能夠空一行。

五、一般狀況下，在運算符兩側、函數參數之間以及逗號兩側，都建議使用空格進行分隔。

3、基本數據類型

3.一、整型

整數就是沒有小數部分的數字，Python 中的整數包括正整數、0 和負整數。有些強類型的編程語言會提供多種整數類型，每種類型的長度都不一樣，能容納的整數的大小也不一樣，開發者要根據實際數字的大小選用不一樣的類型。例如C語言提供了 short、int、long、long long 四種類型的整數，它們的長度依次遞增，初學者在選擇整數類型時每每比較迷惑，有時候還會致使數值溢出。而 Python 則不一樣，它的整數不分類型，或者說它只有一種類型的整數。Python 整數的取值範圍是無限的，無論多大或者多小的數字，Python 都能輕鬆處理。

x = 10
print(type(x))  # <class 'int'>
x = 100000000000000000000000000000000000000000000000000
print(type(x))
print(x)

進制

# 十六進制
print(0x11)
print(0x111)
​
# 二進制
print(0b101)
print(0B101)
​
# 八進制
print(0o12)
print(0o23)
​
# 十進制轉換爲二進制
print(bin(3))
​
# 十進制轉換爲十六進制
print(hex(19))
​
# 十進制轉換爲八進制
print(oct(10))
​

3.二、浮點類型

在編程語言中，小數一般以浮點數的形式存儲。

Python中的小數有兩種書寫形式：

（1) 十進制形式

這種就是咱們平時看到的小數形式，例如 34.六、346.0、0.346。書寫小數時必須包含一個小數點，不然會被 Python 看成整數處理。

（2）指數形式

Python 小數的指數形式的寫法爲：aEn 或 aen

指數形式的小數舉例：
2.1E5 = 2.1×105，其中 2.1 是尾數，5 是指數。
3.7E-2 = 3.7×10-2，其中 3.7 是尾數，-2 是指數。
0.5E7 = 0.5×107，其中 0.5 是尾數，7 是指數。

注意，只要寫成指數形式就是小數，即便它的最終值看起來像一個整數。例如 14E3 等價於 14000，但 14E3 是一個小數。Python 只有一種小數類型，就是 float。

f1 =  3.14
print(f1)
print(type(f1))  # <class 'float'>
​
f2 =0.000000000000000000000000000000003
print(f2)
print(type(f2))
​
f3 = 3.141592612345678987654321
print(f3)
print(type(f3))
​
f4 = 12e4
print(f4)
print(type(f4))

3.三、布爾類型

Python提供了 bool 類型來表示真（對）或假（錯），好比常見的5 > 3比較算式，這個是正確的，在程序世界裏稱之爲真（對），Python 使用 True 來表明；再好比4 > 20比較算式，這個是錯誤的，在程序世界裏稱之爲假（錯），Python 使用 False 來表明。

print(4 == 2) # False
print(5 > 1)  # True
​
name = "yuan"
print(name == "alex") # False
print(1=="1") # False

True 至關於整數值 1，False 至關於整數值 0。

3.四、字符串類型

字符串是由零個或多個字符組成的有限序列。字符串的內容能夠包含字母、標點、特殊符號、中文、日文等全世界的全部字符。

s1 = "hi yuan"
print(s1)
​
s2 = ""
print(s2)
​
s3 = "苑是最好的老師!"
print(s3)

Python 字符串中的雙引號和單引號沒有任何區別

3.4.一、轉義符

轉義字符	說明
\n	換行符，將光標位置移到下一行開頭。
\r	回車符，將光標位置移到本行開頭。
\t	水平製表符，也即 Tab 鍵，通常至關於四個空格。
\a	蜂鳴器響鈴。注意不是喇叭發聲，如今的計算機不少都不帶蜂鳴器了，因此響鈴不必定有效。
\b	退格（Backspace），將光標位置移到前一列。
\	反斜線
'	單引號
"	雙引號
\	在字符串行尾的續行符，即一行未完，轉到下一行繼續寫。

s1 = "hi yuan\noldboyedu"
print(s1)
​
s2 = 'I\'m yuan'
print(s2)
​
s3 = "D:\\nythonProject\\nenv\\Scripts\\python.exe"
print(s3)

3.4.二、長字符串

Python 長字符串由三個雙引號"""或者三個單引號'''包圍，語法格式以下：

'''
Python 長字符
'''
​
"""
Python 長字符
"""

在長字符串中放置單引號或者雙引號不會致使解析錯誤。若是長字符串沒有賦值給任何變量，那麼這個長字符串就不會起到任何做用，和一段普通的文本無異，至關於被註釋掉了。

注意，此時 Python 解釋器並不會忽略長字符串，也會按照語法解析，只是長字符串起不到實際做用而已。當程序中有大段文本內容須要定義成字符串時，優先推薦使用長字符串形式，由於這種形式很是強大，能夠在字符串中放置任何內容，包括單引號和雙引號。

3.4.三、格式化輸出

方式1:

以前講到過 print() 函數的用法，這只是最簡單最初級的形式，print() 還有不少高級的玩法，好比格式化輸出，這就是本節要講解的內容。print() 函數使用以%開頭的轉換說明符對各類類型的數據進行格式化輸出，具體請看下錶。

轉換說明符	解釋
%d、%i	轉換爲帶符號的十進制整數
%o	轉換爲帶符號的八進制整數
%x、%X	轉換爲帶符號的十六進制整數
%e	轉化爲科學計數法表示的浮點數（e 小寫）
%E	轉化爲科學計數法表示的浮點數（E 大寫）
%f、%F	轉化爲十進制浮點數
%g	智能選擇使用 %f 或 %e 格式
%G	智能選擇使用 %F 或 %E 格式
%c	格式化字符及其 ASCII 碼
%r	使用 repr() 函數將表達式轉換爲字符串
%s	使用 str() 函數將表達式轉換爲字符串

name = "yuan"
age = 23
print("My name is %s; My age is %d"%(name,age))

在 print() 函數中，由引號包圍的是格式化字符串，它至關於一個字符串模板，能夠放置一些轉換說明符（佔位符）。本例的格式化字符串中包含一個%s和%d說明符，它最終會被後面的name和age 變量的值所替代。中間的%是一個分隔符，它前面是格式化字符串，後面是要輸出的表達式。

方式2:

相對基本格式化輸出採用‘%’的方法，format()功能更強大，該函數把字符串當成一個模板，經過傳入的參數進行格式化，而且使用大括號‘{}’做爲特殊字符代替‘%’

（1）不帶編號，即「{}」
​
（2）帶數字編號，可調換順序，即「{1}」、「{2}」
​
（3）帶關鍵字，即「{name}」、「{age}」

name = "yuan"
age = 23
print("My name is {}; My age is {}".format(name,age))
print("My name is {1}; My age is {0}".format(name,age))
print("My name is {n}; My age is {a}".format(n=name,a=age))

3.4.四、字符串內置方法

大小寫處理

函數	做用	示例	輸出
capitalize	首字母大寫，其他小寫	‘lk with psr'.capitalize()	‘Lk with psr'
upper	所有大寫	‘lk with psr'.upper()	‘LK WITH PSR'
lower	所有小寫	‘lk with psr'.lower()	‘lk with psr'
swapcase()	大小寫互換	‘Lk with Psr'.swapcase()	‘lK WITH pSR'
.title()	首字母大寫	‘lk with psr'.title()	‘Lk With Psr'

判斷字符串中的字符類型

函數	做用	示例	輸出
startswith(‘a',[start,end])	是否以a開頭	‘a lk'.startswith(‘a')	True
endswith(‘a')	是否以a結尾	‘lk'.endswith(‘a')	False
isalnum()	是否全爲字母或數字	‘123asd'.isalnum()	True
isalpha()	是否全字母	‘lk12'.isalpha()	True
isdigit()	是否全數字	‘123'.isdigit()	True
islower()	是否全小寫	‘lk'.islower()	True
isupper()	是否全大寫	‘lk'.isupper()	False
istitle()	判斷首字母是否爲大寫	‘Lk'.istitle()	True
isspace()	判斷字符是否爲空格	' '.isspace()	True

字符串替換

函數	做用	示例	輸出
replace(‘old',‘new')	替換old爲new	'hello world'.replace(‘world',‘python')	hello python
replace(‘old',‘new',次數)	替換指定次數的old爲new	'hello world'.replace(‘l',‘p',2)	heppo world

去空格

函數	做用	示例	輸出
strip()	去兩邊空格	' h e-l lo '.strip()	能夠想象
lstrip()	去左邊空格	' h e-l lo '.lstrip()	能夠想象
rstrip()	去右邊空格	' h e-l lo '.rstrip()	能夠想象

用特定符鏈接單個字符

函數	做用	示例	輸出
.join()	-鏈接	‘-'.join([‘a', ‘b', ‘c'])	a-b-c

用字符串中的特定符分割字符串

函數	做用	示例	輸出
split()	默認按空格分隔	' h e-l lo ' .split()	[‘h', ‘e-l', ‘lo']
split(‘指定字符')	按指定字符分割字符串爲數組	' h e-l lo ' .split('-')	[' h e', 'l lo ']

搜索

函數	做用	示例	輸出
find()	搜索指定字符串，沒有返回-1	‘lk la'.find(‘lk')	0
index()	同上，可是找不到會報錯	‘lk la'.index(‘lk')	0
rfind()	從右邊開始查找	‘lk la'.rfind(‘lk')	0
count()	統計指定的字符串出現的次數	‘lklklk'.count(‘lk')	3

4、進階數據類型

4.一、序列介紹

所謂序列，指的是一塊可存放多個值的連續內存空間，這些值按必定順序排列，可經過每一個值所在位置的編號（稱爲索引）訪問它們。

爲了更形象的認識序列，能夠將它看作是一家旅店，那麼店中的每一個房間就如同序列存儲數據的一個個內存空間，每一個房間所特有的房間號就至關於索引值。也就是說，經過房間號（索引）咱們能夠找到這家旅店（序列）中的每一個房間（內存空間）。

4.1.1 、序列索引

序列中，每一個元素都有屬於本身的編號（索引）。從起始元素開始，索引值從 0 開始遞增，如圖 1 所示。

 

除此以外，Python 還支持索引值是負數，此類索引是從右向左計數，換句話說，從最後一個元素開始計數，從索引值 -1 開始，如圖 2 所示。

 

4.1.二、序列切片

切片操做是訪問序列中元素的另外一種方法，它能夠訪問必定範圍內的元素，經過切片操做，能夠生成一個新的序列。序列實現切片操做的語法格式以下：

序列類型對象[start : end : step]

其中，各個參數的含義分別是：

• start：表示切片的開始索引位置（包括該位置），此參數也能夠不指定，會默認爲 0，也就是從序列的開頭進行切片；

• end：表示切片的結束索引位置（不包括該位置），若是不指定，則默認爲序列的長度；

• step：表示在切片過程當中，隔幾個存儲位置（包含當前位置）取一次元素，也就是說，若是 step 的值大於 1，則在進行切片去序列元素時，會「跳躍式」的取元素。若是省略設置 step 的值，則最後一個冒號就能夠省略。

4.1.三、序列相加與相乘

Python 中，支持兩種類型相同的序列使用「+」運算符作相加操做，它會將兩個序列進行鏈接，但不會去除重複的元素。使用數字 n 乘以一個序列會生成新的序列，其內容爲原來序列被重複 n 次的結果

print("welcome"+" to"+" oldboyedu")
print("*"*10)
print("*"*30+"welcome to oldboyedu"+"*"*30)

4.1.四、檢查元素是否包含在序列中

Python 中，可使用 in 關鍵字檢查某元素是否爲序列的成員。

print("yuan" in "hi,yuan")

4.二、列表類型

在實際開發中，常常須要將一組（不僅一個）數據存儲起來，以便後邊的代碼使用。說到這裏，一些讀者可能據說過數組（Array），它就能夠把多個數據挨個存儲到一塊兒，經過數組下標能夠訪問數組中的每一個元素。

4.2.一、列表的建立

從形式上看，列表會將全部元素都放在一對中括號[ ]裏面，相鄰元素之間用逗號,分隔，以下所示：

[element1, element2, element3, ..., elementn]

列表中的元素個數沒有限制，只要是 Python 支持的數據類型就能夠。從內容上看，列表能夠存儲整數、小數、字符串、列表、元組等任何類型的數據，而且同一個列表中元素的類型也能夠不一樣。

4.2.二、訪問列表元素

列表是 Python 序列的一種，咱們可使用索引（Index）訪問列表中的某個元素（獲得的是一個元素的值），也可使用切片訪問列表中的一組元素（獲得的是一個新的子列表）。

使用索引訪問列表元素的格式爲：

listname[i]

其中，listname 表示列表名字，i 表示索引值。列表的索引能夠是正數，也能夠是負數。

使用切片訪問列表元素的格式爲：

listname[start : end : step]

其中，listname 表示列表名字，start 表示起始索引，end 表示結束索引，step 表示步長。

4.2.三、列表的增刪改查之增

添加方法： append、extend、insert

<1>append() 方法用於在列表的末尾追加元素，該方法的語法格式以下：

listname.append(obj)

其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的數據，它能夠是單個元素，也能夠是列表、元組等。

<2>extend() 和 append() 的不一樣之處在於：extend() 不會把列表或者元祖視爲一個總體，而是把它們包含的元素逐個添加到列表中。

extend() 方法的語法格式以下：

listname.extend(obj)

其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的數據，它能夠是單個元素，也能夠是列表、元組等，但不能是單個的數字。

<3> append() 和 extend() 方法只能在列表末尾插入元素，若是但願在列表中間某個位置插入元素，那麼可使用 insert() 方法。

insert() 的語法格式以下：

listname.insert(index , obj)

其中，index 表示指定位置的索引值。insert() 會將 obj 插入到 listname 列表第 index 個元素的位置。

當插入列表或者元祖時，insert() 也會將它們視爲一個總體，做爲一個元素插入到列表中，這一點和 append() 是同樣的。

4.2.四、列表的增刪改查之刪

在Python列表中刪除元素主要分爲如下 3 種場景：

• 根據目標元素所在位置的索引進行刪除，可使用 del 關鍵字或者 pop() 方法；

• 根據元素自己的值進行刪除，可以使用列表（list類型）提供的 remove() 方法；

• 將列表中全部元素所有刪除，可以使用列表（list類型）提供的 clear() 方法。

<1>del是 Python 中的關鍵字，專門用來執行刪除操做，它不只能夠刪除整個列表，還能夠刪除列表中的某些元素。咱們已經在《Python列表》中講解了如何刪除整個列表，因此本節只講解如何刪除列表元素。

del 能夠刪除列表中的單個元素，格式爲：

del listname[index]

其中，listname表示列表名稱，index 表示元素的索引值。

del也能夠刪除中間一段連續的元素，格式爲：

del listname[start : end]

其中，start 表示起始索引，end 表示結束索引。del會刪除從索引 start 到 end 之間的元素，不包括 end 位置的元素。

<2> Python pop() 方法用來刪除列表中指定索引處的元素，具體格式以下：

listname.pop(index)

其中，listname表示列表名稱，index 表示索引值。若是不寫 index 參數，默認會刪除列表中的最後一個元素.

<3>除了del 關鍵字，Python 還提供了 remove() 方法，該方法會根據元素自己的值來進行刪除操做。須要注意的是，remove() 方法只會刪除第一個和指定值相同的元素，並且必須保證該元素是存在的，不然會引起ValueError 錯誤。

4.2.四、列表的增刪改查之改

Python提供了兩種修改列表（list）元素的方法，你能夠每次修改單個元素，也能夠每次修改一組元素（多個）。修改單個元素很是簡單，直接對元素賦值便可.

修改一組元素，Python 支持經過切片語法給一組元素賦值。在進行這種操做時，若是不指定步長（step 參數），Python 就不要求新賦值的元素個數與原來的元素個數相同；這意味，該操做既能夠爲列表添加元素，也能夠爲列表刪除元素。

4.2.五、列表的增刪改查之查

Python 列表（list）提供了 index() 和 count() 方法，它們均可以用來查找元素。

4.三、元組類型

元組（tuple）是 Python中另外一個重要的序列結構，和列表相似，元組也是由一系列按特定順序排序的元素組成。

元組和列表（list）的不一樣之處在於：

• 列表的元素是能夠更改的，包括修改元素值，刪除和插入元素，因此列表是可變序列；

• 而元組一旦被建立，它的元素就不可更改了，因此元組是不可變序列。元組也能夠看作是不可變的列表，一般狀況下，元組用於保存無需修改的內容。

從形式上看，元組的全部元素都放在一對小括號( )中，相鄰元素之間用逗號,分隔，以下所示：

(element1, element2, ... , elementn)

其中 element1~elementn 表示元組中的各個元素，個數沒有限制，只要是 Python 支持的數據類型就能夠。

須要注意的一點是，當建立的元組中只有一個字符串類型的元素時，該元素後面必需要加一個逗號,，不然 Python 解釋器會將它視爲字符串。

4.四、字典類型

Python字典（dict）是一種無序的、可變的序列，它的元素以「鍵值對（key-value）」的形式存儲。相對地，列表（list）和元組（tuple）都是有序的序列，它們的元素在底層是挨着存放的。

字典類型是 Python 中惟一的映射類型。「映射」是數學中的術語，簡單理解，它指的是元素之間相互對應的關係，即經過一個元素，能夠惟一找到另外一個元素。如圖 1 所示。

 

字典中，習慣將各元素對應的索引稱爲鍵（key），各個鍵對應的元素稱爲值（value），鍵及其關聯的值稱爲「鍵值對」。

字典類型很像學生時代經常使用的新華字典。咱們知道，經過新華字典中的音節表，能夠快速找到想要查找的漢字。其中，字典裏的音節表就至關於字典類型中的鍵，而鍵對應的漢字則至關於值。

主要特徵	解釋
經過鍵而不是經過索引來讀取元素	字典類型有時也稱爲關聯數組或者散列表（hash）。它是經過鍵將一系列的值聯繫起來的，這樣就能夠經過鍵從字典中獲取指定項，但不能經過索引來獲取。
字典是任意數據類型的無序集合	和列表、元組不一樣，一般會將索引值 0 對應的元素稱爲第一個元素，而字典中的元素是無序的。
字典是可變的，而且能夠任意嵌套	字典能夠在原處增加或者縮短（無需生成一個副本），而且它支持任意深度的嵌套，即字典存儲的值也能夠是列表或其它的字典。
字典中的鍵必須惟一	字典中，不支持同一個鍵出現屢次，不然只會保留最後一個鍵值對。
字典中的鍵必須不可變	字典中每一個鍵值對的鍵是不可變的，只能使用數字、字符串或者元組，不能使用列表。

4.4.一、建立字典

使用 { } 建立字典，因爲字典中每一個元素都包含兩部分，分別是鍵（key）和值（value），所以在建立字典時，鍵和值之間使用冒號:分隔，相鄰元素之間使用逗號,分隔，全部元素放在大括號{ }中。

使用{ }建立字典的語法格式以下：

dictname = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}

其中 dictname表示字典變量名，keyn : valuen表示各個元素的鍵值對。須要注意的是，同一字典中的各個鍵必須惟一，不能重複。

4.4.二、訪問字典

列表和元組是經過下標來訪問元素的，而字典不一樣，它經過鍵來訪問對應的值。由於字典中的元素是無序的，每一個元素的位置都不固定，因此字典也不能像列表和元組那樣，採用切片的方式一次性訪問多個元素。

Python 訪問字典元素的具體格式爲：

dictname[key]

其中，dictname 表示字典變量的名字，key 表示鍵名。注意，鍵必須是存在的，不然會拋出異常。

除了上面這種方式外，Python 更推薦使用 dict 類型提供的 get() 方法來獲取指定鍵對應的值。當指定的鍵不存在時，get() 方法不會拋出異常。

get() 方法的語法格式爲：

dictname.get(key[,default])

其中，dictname 表示字典變量的名字；key 表示指定的鍵；default 用於指定要查詢的鍵不存在時，此方法返回的默認值，若是不手動指定，會返回 None。

4.4.三、字典的基本操做

因爲字典屬於可變序列，因此咱們能夠任意操做字典中的鍵值對（key-value）。Python 中，常見的字典操做有如下幾種：

• 向現有字典中添加新的鍵值對。

• 修改現有字典中的鍵值對。

• 從現有字典中刪除指定的鍵值對。

• 判斷現有字典中是否存在指定的鍵值對。

一、Python字典添加鍵值對

爲字典添加新的鍵值對很簡單，直接給不存在的 key 賦值便可，具體語法格式以下：

dictname[key] = value

對各個部分的說明：

• dictname 表示字典名稱。

• key 表示新的鍵。

• value 表示新的值，只要是 Python 支持的數據類型均可以。

二、Python字典修改鍵值對

Python 字典中鍵（key）的名字不能被修改，咱們只能修改值（value）。

字典中各元素的鍵必須是惟一的，所以，若是新添加元素的鍵與已存在元素的鍵相同，那麼鍵所對應的值就會被新的值替換掉，以此達到修改元素值的目的。

三、Python字典刪除鍵值對

若是要刪除字典中的鍵值對，仍是可使用 del 語句。

四、判斷字典中是否存在指定鍵值對

若是要判斷字典中是否存在指定鍵值對，首先應判斷字典中是否有對應的鍵。判斷字典是否包含指定鍵值對的鍵，可使用 in 或 not in 運算符。

4、運算符

4.一、算數運算符

運算符	說明	實例	結果
+	加	12.45 + 15	27.45
-	減	4.56 - 0.26	4.3
*	乘	5 * 3.6	18.0
/	除法（和數學中的規則同樣）	7 / 2	3.5
//	整除（只保留商的整數部分）	7 // 2	3
%	取餘，即返回除法的餘數	7 % 2	1
**	冪運算/次方運算，即返回 x 的 y 次方	2 ** 4	16，即 24

4.二、賦值運算符

運算符	說 明	用法舉例	等價形式
=	最基本的賦值運算	x = y	x = y
+=	加賦值	x += y	x = x + y
-=	減賦值	x -= y	x = x - y
*=	乘賦值	x *= y	x = x * y
/=	除賦值	x /= y	x = x / y
%=	取餘數賦值	x %= y	x = x % y
**=	冪賦值	x **= y	x = x ** y
//=	取整數賦值	x //= y	x = x // y
&=	按位與賦值	x &= y	x = x & y
|=	按位或賦值	x |= y	x = x | y
^=	按位異或賦值	x ^= y	x = x ^ y
<<=	左移賦值	x <<= y	x = x << y，這裏的 y 指的是左移的位數
>>=	右移賦值	x >>= y	x = x >> y，這裏的 y 指的是右移的位數

4.三、比較運算符

比較運算符	說明
>	大於，若是>前面的值大於後面的值，則返回 True，不然返回 False。
<	小於，若是<前面的值小於後面的值，則返回 True，不然返回 False。
==	等於，若是==兩邊的值相等，則返回 True，不然返回 False。
>=	大於等於（等價於數學中的 ≥），若是>=前面的值大於或者等於後面的值，則返回 True，不然返回 False。
<=	小於等於（等價於數學中的 ≤），若是<=前面的值小於或者等於後面的值，則返回 True，不然返回 False。
!=	不等於（等價於數學中的 ≠），若是!=兩邊的值不相等，則返回 True，不然返回 False。
is	判斷兩個變量所引用的對象是否相同，若是相同則返回 True，不然返回 False。
is not	判斷兩個變量所引用的對象是否不相同，若是不相同則返回 True，不然返回 False。

4.四、邏輯運算符

邏輯運算符	含義	基本格式	說明
and	邏輯與運算，等價於數學中的「且」	a and b	當 a 和 b 兩個表達式都爲真時，a and b 的結果才爲真，不然爲假。
or	邏輯或運算，等價於數學中的「或」	a or b	當 a 和 b 兩個表達式都爲假時，a or b 的結果纔是假，不然爲真。
not	邏輯非運算，等價於數學中的「非」	not a	若是 a 爲真，那麼 not a 的結果爲假；若是 a 爲假，那麼 not a 的結果爲真。至關於對 a 取反。

5、流程控制語句

和其它編程語言同樣，按照執行流程劃分，Python 程序也可分爲 3 大結構，即順序結構、選擇（分支）結構和循環結構：

• Python 順序結構就是讓程序按照從頭至尾的順序依次執行每一條 Python 代碼，不重複執行任何代碼，也不跳過任何代碼。

• Python 選擇結構也稱分支結構，就是讓程序「拐彎」，有選擇性的執行代碼；換句話說，能夠跳過沒用的代碼，只執行有用的代碼。

• Python 循環結構就是不斷地重複執行同一段代碼。

5.一、分支語句

Python 中的 if else 語句能夠細分爲三種形式，分別是 if語句、if else 語句和if elif else 語句

5.1.一、if語句

語法格式：

if 表達式：
    代碼塊

5.1.二、if-else語句

語法格式：

if 表達式：
    代碼塊 1
else：
    代碼塊 2

5.1.三、if-elif-else語句

語法格式：

if 表達式 1：
    代碼塊 1
elif 表達式 2：
    代碼塊 2
elif 表達式 3：
    代碼塊 3
...# 其它elif語句
else：
    代碼塊 n

對語法格式的說明：

一、「表達式」能夠是一個單一的值或者變量，也能夠是由運算符組成的複雜語句，形式不限，只要它能獲得一個值就行。無論「表達式」的結果是什麼類型，if else 都能判斷它是否成立（真或者假）。

二、「代碼塊」由：與具由相同縮進標識的若干條語句組成。

5.二、循環語句

5.2.一、while 循環

Python 中，while 循環和 if 條件分支語句相似，即在條件（表達式）爲真的狀況下，會執行相應的代碼塊。不一樣之處在於，只要條件爲真，while 就會一直重複執行那段代碼塊。

while 語句的語法格式以下：

while 條件表達式：
   代碼塊

這裏的代碼塊，指的是縮進格式相同的多行代碼，不過在循環結構中，它又稱爲循環體。

while 語句執行的具體流程爲：首先判斷條件表達式的值，其值爲真（True）時，則執行代碼塊中的語句，當執行完畢後，再回過頭來從新判斷條件表達式的值是否爲真，若仍爲真，則繼續從新執行代碼塊...如此循環，直到條件表達式的值爲假（False），才終止循環。

5.2.二、for循環

for 循環的語法格式以下：

for 迭代變量 in 字符串|列表|元組|字典|集合：
  代碼塊

格式中，迭代變量用於存放從序列類型變量中讀取出來的元素，因此通常不會在循環中對迭代變量手動賦值；代碼塊指的是具備相同縮進格式的多行代碼（和 while 同樣），因爲和循環結構聯用，所以代碼塊又稱爲循環體。

5.2.三、break和continue

咱們知道，在執行 while 循環或者 for 循環時，只要循環條件知足，程序將會一直執行循環體，不停地轉圈。但在某些場景，咱們可能但願在循環結束前就強制結束循環，Python 提供了 2 種強制離開當前循環體的辦法：

1. 使用 continue 語句，能夠跳過執行本次循環體中剩餘的代碼，轉而執行下一次的循環。

2. 只用 break 語句，能夠徹底終止當前循環。

break 語句能夠當即終止當前循環的執行，跳出當前所在的循環結構。不管是 while 循環仍是 for 循環，只要執行 break 語句，就會直接結束當前正在執行的循環體。和 break 語句相比，continue 語句的做用則沒有那麼強大，它只會終止執行本次循環中剩下的代碼，直接從下一次循環繼續執行。