大數據技術之_24_電影推薦系統項目_02_Python 基礎語法複習
第六章 Python 基礎語法6.1 Python 綜述6.1.1 Python 是什麼6.1.2 Python 的發展6.1.3 Python 的特色6.2 Python3 安裝6.2.1 Python3 和 Python2 的區別6.2.2 Python3 環境的安裝（以 windows 爲例）6.2.3 Anaconda(巨蟒) 安裝教程（可選）6.3 Python 基本語法6.3.1 編碼6.3.2 標識符6.3.3 註釋6.3.4 關鍵字和保留字6.3.5 行和縮進6.3.6 多行語句6.3.7 Python 的引號6.3.8 Python 空行6.3.9 等待用戶輸入6.3.10 同一行顯示多條語句6.3.11 多個語句構成代碼組6.3.12 print 輸出6.3.13 import 與 from … import6.3.14 命令行參數6.4. 基本數據類型6.4.1 變量賦值6.4.2 多變量賦值6.4.3 標準數據類型6.4.4 Number6.4.5 String6.4.6 List6.4.7 Tuple6.4.8 Set6.4.9 Dictionary（字典）6.4.10 python類型轉換6.5 Python 解釋器6.5.1 環境變量設置6.5.2 交互式編程6.5.3 腳本式編程6.6 運算符6.6.1 算術運算符6.6.2 比較運算符6.6.3 賦值運算符6.6.4 位運算符6.6.5 邏輯運算符(bool)6.6.6 成員運算符6.6.7 身份運算符6.6.8 Python 運算符優先級6.7 字符串（String）6.7.1 字符串建立6.7.2 字符串訪問6.7.3 字符串運算6.7.4 Python 字符串格式化6.7.5 內建函數6.8 列表（List）6.8.1 列表建立6.8.2 列表值獲取6.8.3 列表更新6.8.4 刪除列表元素6.8.5 其它列表操做6.8.6 列表嵌套6.8.7 Python 列表函數和方法6.9 元組6.9.1 元組建立6.9.2 元組值獲取6.9.3 元組更新6.9.4 刪除元組元素6.9.5 元組運算符6.9.6 元組內置函數6.10 字典6.10.1 字典建立6.10.2 字典值獲取6.10.3 更新字典6.10.4 刪除字典元素6.10.5 字典內置函數&方法6.11 Set 集合6.11.1 Set 集合建立6.11.2 Set 集合添加元素6.11.3 移除元素6.11.4 集合操做方法6.12 條件判斷6.12.1 基本語法6.12.2 注意要點6.13 循環語句6.13.1 while 循環6.13.2 for 循環6.13.3 range() 函數6.13.4 break 和 continue 語句及循環中的 else 子句6.13.5 pass 語句6.14 迭代器和生成器6.14.1 迭代器生成6.14.2 迭代器遍歷6.14.3 建立一個迭代器6.14.4 生成器6.15 函數6.15.1 基本語法6.15.2 函數分類6.15.3 匿名函數6.15.4 變量做用域6.15.5 全局變量和局部變量html
第六章 Python 基礎語法
6.1 Python 綜述
6.1.1 Python 是什麼
Python 是一個高層次的結合瞭解釋性、編譯性、互動性和麪向對象的腳本語言。
Python 的設計具備很強的可讀性，相比其餘語言常用英文關鍵字，其餘語言的一些標點符號，它具備比其餘語言更有特點語法結構。
ython 是一種解釋型語言：這意味着開發過程當中沒有了編譯這個環節。相似於 PHP 和 Perl 語言。
Python 是交互式語言：這意味着，咱們能夠在一個 Python 提示符後面直接互動執行寫本身的程序。
Python 是面嚮對象語言：這意味着 Python 支持面向對象的風格或代碼封裝在對象的編程技術。
Python 是初學者的語言：Python 簡單易學，對初級程序員而言，是一種偉大的語言，它支持普遍的應用程序開發，從簡單的文字處理到 Web 瀏覽器再到遊戲。
C 語言是讓計算機感到舒服的語言（內存、指針）；Python 是讓程序員感到舒服的語言。python
6.1.2 Python 的發展
Python 是由 Guido van Rossum（龜叔）在八十年代末和九十年代初，在荷蘭國家數學和計算機科學研究所設計出來的。
Python 自己也是由諸多其餘語言發展而來的，這包括 ABC、Modula-三、C、C++、Algol-6八、SmallTalk、Unix shell 和其餘的腳本語言等等。像 Perl 語言同樣，Python 源代碼一樣遵循 GPL(GNU General Public License)協議。
如今 Python 是由一個核心開發團隊在維護，Guido van Rossum 仍然佔據着相當重要的做用，指導其進展，「仁慈的獨裁者」。linux
6.1.3 Python 的特色
• 易於學習：Python 有相對較少的關鍵字，結構簡單，和一個明肯定義的語法，學習起來更加簡單。
• 易於閱讀：Python 代碼定義的更清晰。
• 易於維護：Python 的成功在於它的源代碼是至關容易維護的。
• 一個普遍的標準庫：Python 的最大的優點之一是豐富的庫、跨平臺的，在 UNIX、Windows 和 Macintosh 兼容很好。
• 互動模式：互動模式的支持，您能夠從終端輸入執行代碼並得到結果的語言，互動的測試和調試代碼片段。
• 可移植：基於其開放源代碼的特性，Python 已經被移植（也就是使其工做）到許多平臺。
• 可擴展：若是你須要一段運行很快的關鍵代碼，或者是想要編寫一些不肯開放的算法，你可使用 C 或 C++ 完成那部分程序，而後從你的 Python 程序中調用。
• 數據庫：Python 提供全部主要的商業數據庫的接口。
• GUI 編程：Python 支持 GUI 能夠建立和移植到許多系統調用。
• 可嵌入：你能夠將 Python 嵌入到 C/C++ 程序，讓你的程序的用戶得到"腳本化"的能力。git
6.2 Python3 安裝
6.2.1 Python3 和 Python2 的區別
Python 的 3.0 版本，常被稱爲 Python 3000，或簡稱 Py3k。相對於 Python 的早期版本，這是一個較大的升級。
爲了避免帶入過多的累贅，Python 3.0 在設計的時候沒有考慮向下相容。
許多針對早期 Python 版本設計的程式都沒法在 Python 3.0 上正常執行。
爲了照顧現有程式，Python 2.6 做爲一個過渡版本，基本使用了 Python 2.x 的語法和庫，同時考慮了向 Python 3.0 的遷移，容許使用部分 Python 3.0 的語法與函數。
新的 Python 程式建議使用 Python 3.0 版本的語法。
除非執行環境沒法安裝 Python 3.0 或者程式自己使用了不支援 Python 3.0 的第三方庫。目前不支援 Python 3.0 的第三方庫有 Twisted、py2exe,、PIL 等。
Python 3.0 在 print 函數、Unicode 編碼、除法運算、數據類型和異常等方面都與 2.X 版本有所變化。程序員
6.2.2 Python3 環境的安裝（以 windows 爲例）
第一步：下載 python 環境安裝包
官方地址：https://www.python.org/
第二步：安裝 python 環境
參考連接：windows下如何下載並安裝Python 3.6.4 ?算法
6.2.3 Anaconda(巨蟒) 安裝教程（可選）
若是是在 windows 系統中安裝，爲了更簡單地使用 python 中豐富的庫資源，能夠直接安裝一個 python 「全家桶」--Anaconda。
Anaconda 是一個 python 的發行版，包括了 python 和不少常見的軟件庫，和一個包管理器 conda。常見的科學計算類的庫都包含在裏面，使得安裝比常規 python 安裝要容易。注意：裝了 Anaconda 就不須要再裝 python 了。
Anaconda 不只能夠方便地安裝、更新、卸載工具包，並且安裝時能自動安裝相應的依賴包，同時還能使用不一樣的虛擬環境隔離不一樣要求的項目；從而大大簡化了工做流程。
下載地址：https://www.anaconda.com/distribution/
下載須要的對應版本，安裝很是簡單，只要跟着引導一步步作就能夠了！shell
Windows安裝 Anaconda3 詳細教程：
一、雙擊安裝程序，選擇 Next數據庫
二、點擊 I Agree
三、選擇 All Users
四、選擇安裝目錄
五、點擊 Install
六、正在安裝過程當中
七、安裝成功，點擊 Next
八、點擊 Skip，不建議 Install Microsoft VSCode，之後須要的時候再獨自安裝
九、取消默認的2個勾選，點擊 Finish
十、安裝好 Anaconda3 軟件後，會有一個 Anaconda Prompt，相似於 Windows 的 cmd 操做
Anaconda Prompt 終端 -- 它可以讓你使用命令行界面來管理環境和包
Spyder -- 它是面向科學開發的 IDE
Anaconda Navigator -- 它是用於管理環境和包的 GUI
打開 Anaconda Prompt，測試下是否安裝成功，分別輸入 python、ipython、conda、jupyter notebook等命令，會看到相應的結果，說明安裝成功。
python 是進入 python 交互命令行
ipython 是進入 ipython 交互命令行，很強大
conda 是 Anaconda 的配置命令
jupyter notebook 則會啓動 Web 端的 ipython notebook
十一、咱們能夠打開 Anaconda Navigator -> Launch jupyterlab ，也能夠直接在瀏覽器輸入 http://localhost:8888/lab （能夠保存爲書籤）。
若是是佈置在雲端，能夠輸入服務器域名（IP地址），是否是很爽！！！下面介紹如何將 Jupyter Notebook 安裝在雲端。
Linux 上安裝 Jupyter Notebook 的詳細過程：express
1.安裝 python3（略）
2.安裝 python 虛擬環境
> pip install virtualenv -i https://pypi.tuna.tsinghua.edu.cn/simple/
這裏用 -i 參數指定了國內源，方便快速下載
3.建立虛擬環境
> virtualenv -p python3 py3
這裏建立的是 python3 的虛擬環境，目錄名叫 py3，目錄名能夠任意起！
4.啓動 python 虛擬環境
> source py3/bin/activate
5.在虛擬環境中安裝 jupyter
(py3)> pip install jupyter -i https://pypi.tuna.tsinghua.edu.cn/simple/
6.安裝所需的 python 庫
(py3)> pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple/ # 數值計算、矩陣運算、向量運算
(py3)> pip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple/ # 畫表格和圖像
(py3)> pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/ # 數值分析、科學計算
(py3)> pip install sklearn -i https://pypi.tuna.tsinghua.edu.cn/simple/ # 機器學習
7.建立目標目錄並進入
(py3)> mkdir algorithm
(py3)> cd algorithm
8.啓動 jupyter notebook
(py3)> jupyter notebook
http://192.168.25.102:8888/lab
默認啓動端口爲 8888，複製連接後能夠經過瀏覽器訪問
6.3 Python 基本語法
6.3.1 編碼
默認狀況下，python3 源文件以 UTF-8 編碼，全部字符串都是 unicode 字符串。同時能夠指定源文件的不一樣編碼文件開頭加上：
# -*- coding: UTF-8 -*-
# coding=utf-8(等號兩邊不能有空格)
容許在源文件中使用 utf-8 字符集中的字符編碼，對應的適合語言爲中文等。
6.3.2 標識符
• 第一個字符必須是字母表中的字母或下劃線_
• 標識符中的其餘部分由字母、數字和下劃線組成
• 標識符對大小寫敏感
• 在 python3 中，非 ASCII 標識符 (如中文字符) 也是容許的
6.3.3 註釋
• 單行註釋：井號 #
• 多行註釋：三個單引號'''xxx'''，或者三個雙引號"""xxx"""
6.3.4 關鍵字和保留字
import keyword
print(len(keyword.kwlist)) # 33
print(keyword.kwlist) # 打印關鍵字
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
簡介：
1.and：表示邏輯‘與’
2.del：用於 list 列表操做，刪除一個或者連續幾個元素
3.from：導入相應的模塊，用 import 或者 from...import
4.not：表示邏輯‘非’
5.while：while 循環，容許重複執行一塊語句，通常無限循環的狀況下用它
6.as：as 單獨沒有意思，是這樣使用：with....as 用來代替傳統的 try...finally 語法的
7.elif：和 if 配合使用的，if 語句中的一個分支用 elif 表示
8.global：定義全局變量
例如：
name = 10
age = 20
def test():
global name
age = 30
name = 'aa'
# print(name)
test()
print(name) # 'aa'
print(age) # 20
9.or：表示邏輯「或」
10.with：和 as 一塊兒用，使用的方法請看 as，見 with
11.assert：表示斷言（斷言一個條件就是真的，若是斷言出錯則拋出異常）用於聲明某個條件爲真，若是該條件不是真的，則拋出異常：AssertionError
例如：
v1 = 10
v2 = 20
assert(v1 > v2)
12.else：參考下面 if 的解釋
13.if：if 語句用於選擇分支，依據條件選擇執行那個語句塊(if語句中最好不要嵌套 if 語句，建議把嵌套的 if 語句寫在另外一個函數中)
14.pass：pass 的意思就是什麼都不作，做用相似於佔位符
15.yield：用起來和 return 很像，但它返回的是一個生成器
16.break：做用是終止循環，程序走到 break 的地方就是循環結束的時候
17.except：和 try 一塊兒使用，用來捕獲異常
18.import：用來導入模塊，有時這樣用 from....import
19.class：定義類
20.in：查找列表中是否包含某個元素，或者字符串 a 是否包含字符串 b
21.raise：raise 能夠顯示地拋出異常。一旦執行 raise 語句，後面的代碼就不執行了
22.continue：跳過 continue 後面循環塊中的語句，繼續進行下一輪循環
23.finally：看到 finally 語句，必然執行 finally 語句的代碼塊
24.is：Python 中的對象包含三要素：id、type、value，用來判斷對象是否相等
25.return：用於跳出函數，也能夠在跳出的同時返回一個值
26.def：用於定義方法
27.for：for ... in 一塊兒使用：它在一序列的對象上遞歸，就是遍歷隊列中的每一個項目
28.lambda：即匿名函數
29.try：出如今異常處理中，使用格式爲：try ... except，try 中放想要執行的語句，except 捕獲異常
30.nonlocal：nonlocal 關鍵字用來在函數或其餘做用域中使用外層(非全局)變量
例如：
def make_counter():
count = 0
def counter():
nonlocal count
count += 1
return count
return counter
def make_counter_test():
mc = make_counter()
print(mc())
print(mc())
print(mc())
make_counter_test()
6.3.5 行和縮進
學習 Python 與其餘語言最大的區別就是，Python 的代碼塊不使用大括號 {} 來控制類，函數以及其餘邏輯判斷。python 最具特點的就是用縮進來寫模塊。
縮進的空白數量是可變的，可是全部代碼塊語句必須包含相同的縮進空白數量，這個必須嚴格執行。
例如：
if True:
print "True"
else:
print "False"
6.3.6 多行語句
Python 語句中通常以新行做爲語句的結束符。可是咱們可使用斜槓（ \）將一行的語句分爲多行顯示，以下所示：
total = item_one + \
item_two + \
item_three
print('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaa')
語句中包含 [], {} 或 () 括號就不須要使用多行鏈接符。以下實例：
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
6.3.7 Python 的引號
Python 可使用引號( ' )、雙引號( " )、三引號( ''' 或 """ ) 表示字符串，引號的開始與結束必須的相同類型的。
其中三引號能夠由多行組成，編寫多行文本的快捷語法，經常使用於文檔字符串，在文件的特定地點，被當作註釋。
word = 'word'
sentence = "這是一個句子。"
paragraph = """這是一個段落。
包含了多個語句"""
6.3.8 Python 空行
函數之間或類的方法之間用空行分隔，表示一段新的代碼的開始。類和函數入口之間也用一行空行分隔，以突出函數入口的開始。空行與代碼縮進不一樣，空行並非 Python 語法的一部分。書寫時不插入空行，Python 解釋器運行也不會出錯。可是空行的做用在於分隔兩段不一樣功能或含義的代碼，便於往後代碼的維護或重構。
記住：空行也是程序代碼的一部分。
6.3.9 等待用戶輸入
執行下面的程序在按回車鍵後就會等待用戶輸入：
input("\n\n按下 enter 鍵後退出。")
6.3.10 同一行顯示多條語句
Python 能夠在同一行中使用多條語句，語句之間使用分號(;)分割，如下是一個簡單的實例：
x = 'runoob';print(x + '\n')
6.3.11 多個語句構成代碼組
縮進相同的一組語句構成一個代碼塊，咱們稱之代碼組。像 if、while、def 和 class 這樣的複合語句，首行以關鍵字開始，以冒號( : )結束，該行以後的一行或多行代碼構成代碼組。
咱們將首行及後面的代碼組稱爲一個子句(clause)。
例如：
if expression :
suite
elif expression :
suite
else :
suite
6.3.12 print 輸出
同類型才能夠相加
print 默認輸出是換行的，若是要實現不換行須要在變量末尾加上 end="" 或者 end=''
x="a"
y="b"
# 換行輸出
print(x)
print(y)
print('---------')
# 不換行輸出
print(x, end="")
print(y, end="")
print()
6.3.13 import 與 from … import
在 python 用 import 或者 from...import 來導入相應的模塊。
a、將整個模塊(somemodule)導入，格式爲： import somemodule
b、從某個模塊中導入某個函數，格式爲： from somemodule import somefunction
c、從某個模塊中導入多個函數，格式爲： from somemodule import firstfunc,secondfunc,thirdfunc
d、將某個模塊中的所有函數導入，格式爲： from somemodule import *
(1)導入 sys 模塊
import sys
print('================Python import mode==================');
print ('命令行參數爲:')
for i in sys.argv :
print (i)
print('\n python 路徑爲', sys.path)
(2)導入 sys 模塊的 argv,path 成員
from sys import argv,path # 導入特定的成員
print('================python from import=====================')
print('path:', path) # 由於已經導入 path 成員，因此引用不須要加 sys.path
6.3.14 命令行參數
不少程序能夠執行一些操做來查看一些基本信息，Python 可使用 -h 參數查看各參數幫助信息：
$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d : debug output from parser (also PYTHONDEBUG=x)
-E : ignore environment variables (such as PYTHONPATH)
-h : print this help message and exit
6.4. 基本數據類型
6.4.1 變量賦值
counter = 100 # 整型變量
miles = 1000.0 # 浮點型變量
name = "runoob" # 字符串
print(counter)
print(miles)
print(name)
6.4.2 多變量賦值
Python 容許你同時爲多個變量賦值。例如：
a = b = c = 1
以上實例，建立一個整型對象，值爲 1，從後向前賦值，三個變量被賦予相同的數值。
能夠爲多個對象指定多個變量。例如：
a, b, c = 1, 2, "runoob"
a, b = b, a # 變量的交換
以上實例，兩個整型對象 1 和 2 的分配給變量 a 和 b，字符串對象 "runoob" 分配給變量 c。
注意：
a = 10
b = 20
a, b = b, a + 5
print(a, b)
結果：a=20, b=15
6.4.3 標準數據類型
Number（數字）、String（字符串）、Tuple（元組）、List（列表）、Dictionary（字典）、Set（集合）
a、不可變數據（3 個）：Number（數字）、String（字符串）、Tuple（元組）
b、可變數據（3 個）：List（列表）、Dictionary（字典）、Set（集合）
6.4.4 Number
int、float、bool、complex(複數)
例如：
a, b, c, d = 20, 5.5, True, 5 + 4j
print(type(a), type(b), type(c), type(d))
函數編程
type(a) # 判斷數據類型
isinstance(a, int) # 判斷數據是否屬於某類型
del var1, var2 # 手動 GC
區別:
(1) type() 不會認爲子類是一種父類類型
(2) isinstance() 會認爲子類是一種父類類型
例如：
class A:
pass
class B(A):
pass
print(type(A()) == A) # True
print(type(B()) == A) # False
print(isinstance(A(), A)) # True
print(isinstance(B(), A)) # True
進制
二進制：使用 0b 開頭 例如：0b1010
八進制：使用 0o 開頭 例如：0o555
十六進制：使用 0x 開頭 例如：0x52A74（大小寫都 OK）
bin()
oct()
hex()
python 中沒有數字的大小限制，可使用任意大的數字；python 能夠保證整數運算的精確，可是浮點數運算時可能會獲得一個不精確的結果。
數學函數
import math
(1) 基本數學函數
函數 返回值 ( 描述 )
abs(x) 返回數字的絕對值，如 abs(-10) 返回 10
ceil(x) 返回數字的上入整數，如 math.ceil(4.1) 返回 5
(x>y)-(x<y) 若是 x < y 返回 -1
若是 x == y 返回 0
若是 x > y 返回 1
exp(x) 返回 e 的 x 次冪 (ex)
如 math.exp(1) 返回 2.718281828459045
fabs(x) 返回數字的絕對值，如 math.fabs(-10) 返回 10.0
floor(x) 返回數字的下舍整數，如 math.floor(4.9)返回 4
log(x) 如 math.log(math.e) 返回 1.0，
如 math.log(100,10) 返回 2.0
log10(x) 返回以 10 爲基數的 x 的對數，
如 math.log10(100) 返回 2.0
max(x1, x2,...) 返回給定參數的最大值，參數能夠爲序列
min(x1, x2,...) 返回給定參數的最小值，參數能夠爲序列
modf(x) 返回 x 的整數部分與小數部分，
兩部分的數值符號與 x 相同，
整數部分以浮點型表示
pow(x, y) x**y 運算後的值
round(x [,n]) 返回浮點數 x 的四捨五入值，如給出 n 值，
則表明舍入到小數點後的位數
sqrt(x) 返回數字 x 的平方根
(2) 隨機數函數
隨機數能夠用於數學，遊戲，安全等領域中，還常常被嵌入到算法中，用以提升算法效率，並提升程序的安全性。
函數 描述
choice(seq) 從序列的元素中隨機挑選一個元素，
好比 random.choice(range(10))，表示從0到9中隨機挑選一個整數。
randrange ([start,] stop [,step]) 從指定範圍內，按指定基數遞增的集合
中獲取一個隨機數，基數缺省值爲 1
random() 隨機生成下一個實數，它在 [0,1) 範圍內
seed([x]) 改變隨機數生成器的種子 seed，
若是你不瞭解其原理，你沒必要特別去設定 seed，Python 會幫你選擇 seed。
shuffle(lst) 將序列的全部元素隨機排序
uniform(x, y) 隨機生成下一個實數，它在 [x,y] 範圍內
(3) 三角函數
函數 描述
acos(x) 返回 x 的反餘弦弧度值。
asin(x) 返回 x 的反正弦弧度值。
atan(x) 返回 x 的反正切弧度值。
atan2(y, x) 返回給定的 X 及 Y 座標值的反正切值。
cos(x) 返回 x 的弧度的餘弦值。
hypot(x, y) 返回歐幾里德範數 sqrt(x*x + y*y)。
sin(x) 返回 x 弧度的正弦值。
tan(x) 返回 x 弧度的正切值。
degrees(x) 將弧度轉換爲角度，如 degrees(math.pi/2) 返回 90.0
radians(x) 將角度轉換爲弧度
(4) 數學常量
常量 描述
pi 數學常量 pi（圓周率，通常以 π 來表示）
e 數學常量 e，e 即天然常數（天然常數）
6.4.5 String
Python 中的字符串用 單引號 或 雙引號 括起來，同時使用反斜槓 \ 轉義特殊字符。下標從 0 開始。
加號 + 是字符串的鏈接符， 星號 * 表示複製當前字符串，緊跟的數字爲複製的次數。
(1) 字符串截取
變量[頭下標:尾下標:步長)
-6 -5 -4 -3 -2 -1
0 1 2 3 4 5
+---+---+---+---+---+---+
| a | b | c | d | e | f |
+---+---+---+---+---+---+
例如：
str = 'hello world'
l = str[0:1:1] # 包頭不包尾
print(l) # h
(2) 字符串打印
Python 使用反斜槓(\)轉義特殊字符，若是你不想讓反斜槓發生轉義，能夠在字符串前面添加一個 r，表示原始字符串：
print('Ru\noob')
Ru
oob
print(r'Ru\noob')
Ru\noob
(3) 字符串獲取
print(str[0])
注意：
1、反斜槓能夠用來轉義，使用 r 可讓反斜槓不發生轉義。
2、字符串能夠用 + 運算符鏈接在一塊兒，用 * 運算符重複。
3、Python 中的字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始。
4、Python 中的字符串不能改變。
str = 'abcdef'
str[0] = 's' # 報錯
5、Python 沒有單獨的字符類型，一個字符就是長度爲1的字符串。
6.4.6 List
List（列表）是 Python 中使用最頻繁的數據類型。列表能夠完成大多數集合類的數據結構實現。
列表中元素的類型能夠不相同，它支持數字，字符串甚至能夠包含列表(所謂列表的嵌套)。
列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。
和字符串同樣，列表一樣能夠被索引和截取，列表被截取後返回一個包含所需元素的新列表。
定義：
list = [0, 1, 2, 3, 'c']
list[0] # 0
len(list) # 長度5
list[0:3] # [0, 1, 2]
注意：
1、List 寫在方括號之間，元素用逗號隔開。
2、和字符串同樣，list 能夠被索引和切片。
3、List 可使用+操做符進行拼接。
4、List 中的元素是能夠改變的。
5、不支持與或非運算。
6.4.7 Tuple
元組（tuple）與列表相似，不一樣之處在於：元組的元素不能修改。
元組寫在小括號 () 裏，元素之間用逗號隔開。
定義：
t = (0, 1, 2, 3, 'c')
t[0] # 0
len(list) # 長度 5
t[0:3] # (0, 1, 2)
t[0] = 2 # 報錯
注意：
1、與字符串同樣，元組的元素不能修改。雖然 tuple 的元素不可改變，但它能夠包含可變的對象，好比 list 列表。
注意：元組裏面存的是可變對象的地址，由於可變對象的地址是不能夠改變的。
list = [0, 2, 1, 3]
t = (0, 1, 2, 3, list)
t[0] = 1 # 報錯
t[4][0] = 1
print(t[4]) # ok
2、元組也能夠被索引和切片，方法同樣。
3、注意：構造包含 0 或 1 個元素的元組的特殊語法規則。
tup1 = () # 空元組
tup2 = (20,) # 一個元素，須要在元素後添加逗號
4、元組也可使用 + 或 * 操做符進行拼接。
6.4.8 Set
集合（set）的事物或對象稱做元素或是成員。基本功能是進行成員關係測試和刪除重複元素。
可使用大括號 {} 或者 set() 函數建立集合，注意：建立一個空集合必須用 set() 而不是 {}，由於 {} 是用來建立一個空字典。
建立格式：
parame = {value01, value02, ...} 或者 set(value)
s = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(s) # {'Mary', 'Jack', 'Rose', 'Tom', 'Jim'}
s = set('1b1b2b3b2b') # {'2', '3', '1', 'b'} 元素不能重複
set 操做：
# set 能夠進行集合運算
a = set('abracadabra')
b = set('alacazam')
print(a)
>>> {'b', 'a', 'c', 'r', 'd'}
print(a - b) # a 和 b 的差集
>>> {'b', 'd', 'r'}
print(a | b) # a 和 b 的並集
>>> {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
print(a & b) # a 和 b 的交集
>>> {'a', 'c'}
print(a ^ b) # a 和 b 中不一樣時存在的元素，注意：(a ^ b) = (a - b)|(b - a)
>>> {'l', 'r', 'z', 'm', 'b', 'd'}
6.4.9 Dictionary（字典）
字典（dictionary）是 Python 中另外一個很是有用的內置數據類型。
列表是有序的對象集合，字典是無序的對象集合。
二者之間的區別在於：字典當中的元素是經過鍵來存取的，而不是經過偏移存取。
字典是一種映射類型，字典用"{}"標識，它是一個無序的 鍵(key):值(value)對 集合。
鍵(key) 必須使用不可變類型。
在同一個字典中，鍵(key) 必須是惟一的。
字典建立：
(1) d = {"a":1, "b":2, "c":3}
(2) d = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
(3) d = {x : x**2 for x in (2, 4, 6)} # 其中 x : x**2 表示鍵，生成的字典是 {2: 4, 4: 16, 6: 36}
(4) d = dict(Runoob=1, Google=2, Taobao=3)
字典操做：
tinydict = {'name': 'guigu', 'code': 1, 'site': 'www.atguigu.com'}
print (dict['name']) # 輸出鍵爲 'name' 的值
print (dict['code']) # 輸出鍵爲 'code' 的值
print (tinydict) # 輸出完整的字典
print (tinydict.keys()) # 輸出全部鍵 dict_keys(['name', 'code', 'site'])
print (tinydict.values()) # 輸出全部值 dict_values(['guigu', 1, 'www.atguigu.com'])
6.4.10 Python 類型轉換
函數 描述
int(x [,base]) 將 x 轉換爲一個整數
float(x) 將 x 轉換到一個浮點數
complex(real [,imag]) 建立一個複數
str(x) 將對象 x 轉換爲字符串
repr(x) 將對象 x 轉換爲表達式字符串
eval(str) 用來計算在字符串中的有效 Python 表達式，並返回一個對象
tuple(s) 將序列 s 轉換爲一個元組
list(s) 將序列 s 轉換爲一個列表
set(s) 轉換爲可變集合
dict(d) 建立一個字典，d 必須是一個序列 (key, value)元組
frozenset(s) 轉換爲不可變集合
chr(x) 將一個整數轉換爲一個字符（ASCII 碼）
ord(x) 將一個字符轉換爲它的 ASCII 碼值
hex(x) 將一個整數轉換爲一個十六進制字符串
oct(x) 將一個整數轉換爲一個八進制字符串
6.5 Python 解釋器
Linux/Unix 的系統上，通常默認的 python 版本爲 2.x，咱們能夠將 python3.x 安裝在 /usr/local/python3 目錄中。
安裝完成後，咱們能夠將路徑 /usr/local/python3/bin 添加到您的 Linux/Unix 操做系統的環境變量中，這樣您就能夠經過 shell 終端輸入下面的命令來啓動 Python3 。
$ PATH=$PATH:/usr/local/python3/bin/python3 # 設置環境變量
$ python3 --version
Python 3.4.0
6.5.1 環境變量設置
在 Window 系統下你能夠經過如下命令來設置 Python 的環境變量，假設你的 Python 安裝在 C:\Python34 下:
set path=%path%;C:\python34
6.5.2 交互式編程
咱們能夠在命令提示符中輸入"python"（或者"python3"，具體視安裝時的命令名稱而定）命令來啓動 Python 解釋器：
$ python3
(1)執行以上命令後，出現以下窗口信息：
$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11)
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
(2)在 python 提示符中輸入如下語句，而後按回車鍵查看運行效果：
print("Hello, Python!")
(3)以上命令執行結果以下：
Hello, Python!
(4)當鍵入一個多行結構時，續行是必須的。咱們能夠看下以下 if 語句：
>>> flag = True
>>> if flag :
... print("flag 條件爲 True!")
...
flag 條件爲 True!
6.5.3 腳本式編程
(1) 將以下代碼拷貝至 hello.py 文件中：
print("Hello, Python!")
(2)經過如下命令執行該腳本：
python3 hello.py
(3)輸出結果爲：
Hello, Python!
(4)在 Linux/Unix 系統中，你能夠在腳本頂部添加如下命令讓 Python 腳本能夠像 SHELL 腳本同樣可直接執行：
#!/usr/bin/env python3
(5)而後修改腳本權限，使其有執行權限，命令以下：
$ chmod +x hello.py
(6)執行如下命令：
./hello.py
(7)輸出結果爲：
Hello, Python!
6.6 運算符
6.6.1 算術運算符
a = 10 b = 21
運算符 描述 實例
+ 加 兩個對象相加；a + b 輸出結果 31
- 減 獲得負數或是一個數減去另外一個數；a - b 輸出結果 -11
* 乘 兩個數相乘或是返回一個被重複若干次的字符串；a * b 輸出結果 210
/ 除 x 除以 y；b / a 輸出結果 2.1
% 取模 返回除法的餘數；b % a 輸出結果 1
** 冪 返回 x 的 y 次冪；a**b 爲 10 的 21 次方
// 取整除 向下取接近除數的整數；9//2 # 4 -9//2 #-5
6.6.2 比較運算符
a = 10, b = 20
運算符 描述 實例
== 等於 比較對象是否相等，(a == b) 返回 False
!= 不等於 比較兩個對象是否不相等，(a != b) 返回 True
> 大於 返回 x 是否大於 y，(a > b) 返回 False
< 小於 返回 x 是否小於 y，(a < b) 返回 True
>= 大於等於 返回 x 是否大於等於 y，(a >= b) 返回 False
<= 小於等於 返回 x 是否小於等於 y，(a <= b) 返回 True
注意：全部比較運算符返回 1 表示真，返回 0 表示假。這分別與特殊的變量 True 和 False 等價。
注意：這些變量名的大寫。
6.6.3 賦值運算符
運算符 描述 實例
= 簡單的賦值運算符 c = a + b 將a + b 的運算結果賦值爲 c
+= 加法賦值運算符 c += a 等效於 c = c + a
-= 減法賦值運算符 c -= a 等效於 c = c - a
*= 乘法賦值運算符 c *= a 等效於 c = c * a
/= 除法賦值運算符 c /= a 等效於 c = c / a
%= 取模賦值運算符 c %= a 等效於 c = c % a
**= 冪賦值運算符 c **= a 等效於 c = c ** a
//= 取整除賦值運算符 c //= a 等效於 c = c // a
6.6.4 位運算符
a = 60, b = 13
二進制形式：a = 0011 1100, b = 0000 1101
運算符 描述 實例
& 按位與運算符 (a & b) 輸出結果 12 ，二進制解釋： 0000 1100
| 按位或運算符 (a | b) 輸出結果 61 ，二進制解釋： 0011 1101
^ 按位異或運算符 (a ^ b) 輸出結果 49 ，二進制解釋： 0011 0001
~ 按位取反運算符 (~a ) 輸出結果 -61 ，二進制解釋： 1100 0011
<< 左移動運算符 a << 2 輸出結果 240 ，二進制解釋： 1111 0000
>> 右移動運算符 a >> 2 輸出結果 15 ，二進制解釋：0000 1111
6.6.5 邏輯運算符(bool)
a = 10, b = 20
運算符 描述 實例
and x and y 布爾"與" 若是 x 爲 False，x and y 返回 False，不然它返回 y 的計算值，(a and b) 返回 20
or x or y 布爾"或" 若是 x 是 True，它返回 x 的值，不然它返回 y 的計算值，(a or b) 返回 10
not not x 布爾"非" 若是 x 爲 True，返回 False。若是 x 爲 False，它返回 True，not(a and b) 返回 False
6.6.6 成員運算符
除了以上的一些運算符以外，Python 還支持成員運算符，測試實例中包含了一系列的成員，包括字符串，列表或元組。
運算符 描述
in 若是在指定的序列中找到值返回 True，不然返回 False，
即 x 在 y 序列中，若是 x 在 y 序列中返回 True
not in 若是在指定的序列中沒有找到值返回 True，不然返回 False，
即 x 不在 y 序列中，若是 x 不在 y 序列中返回 True
6.6.7 身份運算符
身份運算符用於比較兩個對象的存儲單元。
運算符 描述
is is 是判斷兩個標識符是否是引用自一個對象
x is y, 相似 id(x) == id(y) , 若是引用的是同一個對象則返回 True，不然返回 False。
is not is not 是判斷兩個標識符是否是引用自不一樣對象
x is not y ，相似 id(a) != id(b)。若是引用的不是同一個對象則返回結果 True，不然返回 False。
6.6.8 Python 運算符優先級
如下表格列出了從最高到最低優先級的全部運算符：
運算符 描述
** 指數 (最高優先級)
~ + - 按位翻轉, 一元加號和減號 (最後兩個的方法名爲 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法減法
>> << 右移，左移運算符
& 位 'AND'
^ | 位運算符
<= < > >= 比較運算符
<> == != 等於運算符
= %= /= //= -= += *= **= 賦值運算符
is is not 身份運算符
in not in 成員運算符
and or not 邏輯運算符
6.7 字符串（String）
6.7.1 字符串建立
s = 'abcd'
s = "abcd"
s = '''
abcd
efg
'''
s = """
abcd
efg
"""
6.7.2 字符串訪問
a = s[0] # 訪問第0個元素
l = len(s) # 字符串的長度
6.7.3 字符串運算
a = 「Hello」, b = 「Python」
操做符 描述 實例
+ 字符串鏈接 a + b 輸出結果：HelloPython
* 重複輸出字符串 a*2 輸出結果：HelloHello
[] 經過索引獲取字符串中字符 a[1] 輸出結果：e
[ : ] 截取字符串中的一部分，遵循左閉右開原則 str[0,2] 是不包含第 3 個字符的
in 成員運算符 'H' in a 輸出結果：True
not in 成員運算符 'M' not in a 輸出結果：True
r/R 原始字符串 print(r'a\nb') # a\nb
% 格式字符串 a=10;print("今年我%s歲" %a) # 今年我10歲
6.7.4 Python 字符串格式化
Python 支持格式化字符串的輸出。儘管這樣可能會用到很是複雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。
print ("我叫%s今年%d歲!" %('小明', 10)) # 我叫小明今年10歲!
符號 描述
%c 格式化字符及 其ASCII 碼
%s 格式化字符串
%d 格式化整數
%u 格式化無符號整型
%o 格式化無符號八進制數
%x 格式化無符號十六進制數
%X 格式化無符號十六進制數（大寫）
%f 格式化浮點數字，可指定小數點後的精度
%e 用科學計數法格式化浮點數
%E 做用同 %e，用科學計數法格式化浮點數
%g %f 和 %e 的簡寫
%G %f 和 %E 的簡寫
%p 用十六進制數格式化變量的地址
6.7.5 內建函數
方法 描述
capitalize() 將字符串的第一個字符轉換爲大寫
endswith(suffix,beg=0,end=len(string)) 檢查字符串是否以 obj 結束
expandtabs(tabsize=8) 把字符串 string 中的 tab 符號轉爲空格，tab 符號默認的空格數是 8
find(str, beg=0 end=len(string)) 檢測 str 是否包含在字符串中，若是包含返回開始的索引值，不然返回-1
index(str, beg=0, end=len(string)) 跟 find() 方法同樣，只不過若是 str 不在字符串中會報一個異常
isalnum() 若是字符串至少有一個字符而且全部字符都是字母或數字則返回 True，不然返回 False
isdigit() 若是字符串只包含數字則返回 True，不然返回 False
isnumeric() 若是字符串中只包含數字字符，則返回 True，不然返回 False
isspace() 若是字符串中只包含空白，則返回 True，不然返回 False
join(seq) 以指定字符串做爲分隔符，將 seq 中全部的元素(的字符串表示)合併爲一個新的字符串
len(string) 返回字符串長度
lower() 轉換字符串中全部大寫字符爲小寫
lstrip() 截掉字符串左邊的空格或指定字符
max(str) 返回字符串 str 中最大的字母
min(str) 返回字符串 str 中最小的字母
replace(old, new [, max]) 將字符串中的 str1 替換成 str2，若是 max 指定，則替換不超過 max 次
rfind(str, beg=0,end=len(string)) 相似於 find()函數，不過是從右邊開始查找
rindex( str, beg=0, end=len(string)) 相似於 index()，不過是從右邊開始
rstrip() 刪除字符串字符串末尾的空格
split(str="",num=string.count(str)) num=string.count(str)) 以 str 爲分隔符截取字符串，若是 num 有指定值，則僅截取 num 個子字符串
splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔
startswith(str,beg=0,end=len(string)) 檢查字符串是不是以 obj 開頭
strip([chars]) 在字符串上執行 lstrip()和 rstrip()
upper() 轉換字符串中的小寫字母爲大寫
6.8 列表（List）
6.8.1 列表建立
list = [1, 2, 3, 4, 5, 'atguigu']
[x+1 for x in range(10)] # range(10) = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 輸出結果是：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[x+1 for x in (1, 1, 2, 3)] # 輸出結果是：(2, 2, 3, 4)
6.8.2 列表值獲取
l = list[0]
l1 = list2[1:5]
len(list) #長度查看
6.8.3 列表更新
list[0] = 'agg'
6.8.4 刪除列表元素
del list[0]
6.8.5 其它列表操做
表達式 結果 描述
len([1, 2, 3]) 3 長度
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 組合
['Hi!']*4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重複
3 in [1, 2, 3] True 元素是否存在於列表中
for x in [1, 2, 3]: print(x, end=" ") 1 2 3 迭代
6.8.6 列表嵌套
使用嵌套列表即在列表裏建立其它列表，例如：
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'
6.8.7 Python 列表函數和方法
函數 描述
len(list) 列表元素個數
max(list) 返回列表元素最大值
min(list) 返回列表元素最小值
list(seq) 將元組轉換爲列表
list.append(obj) 在列表末尾添加新的對象
list.count(obj) 統計某個元素在列表中出現的次數
list.extend(seq) 在列表末尾一次性追加另外一個序列中的多個值（用新列表擴展原來的列表）
list.index(obj) 從列表中找出某個值第一個匹配項的索引位置
list.insert(index, obj) 將對象插入列表
list.pop([index=-1]) 移除列表中的一個元素（默認最後一個元素），而且返回該元素的值
list.remove(obj) 移除列表中某個值的第一個匹配項
list.reverse() 反向列表中元素
list.sort(cmp=None, key=None, reverse=False) 對原列表進行排序
list.clear() 清空列表
list.copy() 複製列表
6.9 元組
6.9.1 元組建立
tup1 = ('Google', 'atguigu', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"; # 不須要括號也能夠
6.9.2 元組值獲取
tup1[1]
tup1[1:5]
6.9.3 元組更新
元組不容許更新！
6.9.4 刪除元組元素
del tup[0]
6.9.5 元組運算符
表達式 結果 描述
len((1, 2, 3)) 3 計算元素個數
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 鏈接
('Hi!',) * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') 複製
3 in (1, 2, 3) True 元素是否存在
for x in (1, 2, 3): print (x,) 1 2 3 迭代(生成器)
6.9.6 元組內置函數
方法 描述 實例
len(tuple) 計算元組元素個數 len(tuple1)
max(tuple) 返回元組中元素最大值 max(tuple2)
min(tuple) 返回元組中元素最小值 min(tuple2)
tuple(seq) 將列表轉換爲元組 示例以下
list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1=tuple(list1)
tuple1 = ('Google', 'Taobao', 'Runoob', 'Baidu')
6.10 字典
在字典中，鍵必須不可變，因此能夠用數字，字符串或元組充當，而用列表就不行。
6.10.1 字典建立
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict = {x: x+1 for x in range(10)} # 輸出結果是：{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}
6.10.2 字典值獲取
dict['Alice']
6.10.3 更新字典
dict['Alice'] = 10
6.10.4 刪除字典元素
del dict['Alice']
del dict
6.10.5 字典內置函數&方法
函數 描述
len(dict) 計算字典元素個數，即鍵的總數。
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
len(dict)
str(dict) 輸出字典，以打印的字符串表示。
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
str(dict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
type(variable) 返回輸入的變量類型。
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
type(dict)
<class 'dict'>
-----------------------------------------------------
函數 描述
radiansdict.clear() 刪除字典內全部元素
radiansdict.copy() 返回一個字典的淺複製
radiansdict.fromkeys() 建立一個新字典，以序列 seq 中元素作字典的鍵，val 爲字典全部鍵對應的初始值
radiansdict.get(key, default=None) 返回指定鍵的值，若是值不在字典中返回 default 值
key in dict 若是鍵在字典 dict 裏返回 True，不然返回 False
radiansdict.items() 以列表返回可遍歷的 (鍵, 值) 元組數組
radiansdict.keys() 返回一個迭代器，可使用 list() 來轉換爲列表
radiansdict.setdefault(key, default=None) 和 get() 相似, 但若是鍵不存在於字典中，將會添加鍵並將值設爲 default
radiansdict.update(dict2) 把字典 dict2 的鍵/值對更新到dict裏
radiansdict.values() 返回一個迭代器，可使用 list() 來轉換爲列表
pop(key[,default]) 刪除字典給定鍵 key 所對應的值，返回值爲被刪除的值。key 值必須給出，不然返回 default 值
popitem() 隨機返回並刪除字典中的一對鍵和值(通常刪除末尾對)
-----------------------------------------------------
擴展：
1. 淺拷貝：只拷貝引用地址，未拷貝內容：
a = [1, 2, 3, 4, 5]
b = a
2. 深拷貝：拷貝引用地址和內容：
a = [1, 2, 3, 4, 5]
import copy
b = copy.deepcopy(a)
能夠遞歸拷貝；一拷到底
注意：
一、對於不可變類型 Number String Tuple，淺複製僅僅是地址指向，不會開闢新空間。
二、對於可變類型 List、Dictionary、Set，淺複製會開闢新的空間地址(僅僅是最頂層開闢了新的空間，裏層的元素地址仍是同樣的)。
三、淺拷貝後，改變原始對象中爲可變類型的元素的值，會同時影響拷貝對象的；改變原始對象中爲不可變類型的元素的值，只有原始類型受影響。
6.11 Set 集合
集合不支持切片操做。
6.11.1 Set 集合建立
s = {'name', 'aa', 'bb'}
s = set(序列) # dict序列，值添加 key
s = {x for x in range(10) if x not in range(5,10)} # 結果是：{0, 1, 2, 3, 4}
6.11.2 Set 集合添加元素
s.add(x) # 添加單個元素
s.update(x) # 添加序列元素
6.11.3 移除元素
s.remove(x) # 移除單個元素
s.discard(x) # 移除集合(不存在不報錯)
s.pop() # 隨機刪除集合中的一個元素
6.11.4 集合操做方法
方法 描述
len(s) 查看集合的長度
s.clear() 清空集合
x in s 判斷元素是否在集合中
add() 爲集合添加元素
clear() 移除集合中的全部元素
copy() 拷貝一個集合
difference() 返回多個集合的差集
difference_update() 移除集合中的元素，該元素在指定的集合也存在。
discard() 刪除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 刪除集合中的元素，該元素在指定的集合中不存在。
isdisjoint() 判斷兩個集合是否包含相同的元素，若是沒有返回 True，不然返回 False。
issubset() 判斷指定集合是否爲該方法參數集合的子集。
issuperset() 判斷該方法的參數集合是否爲指定集合的子集
pop() 隨機移除元素
remove() 移除指定元素
symmetric_difference() 返回兩個集合中不重複的元素集合。
symmetric_difference_update() 移除當前集合中在另一個指定集合相同的元素，並將另一個指定集合中不一樣的元素插入到當前集合中。
union() 返回兩個集合的並集
update() 給集合添加元素
6.12 條件判斷
6.12.1 基本語法
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
6.12.2 注意要點
1、每一個條件後面要使用冒號 : 表示接下來是知足條件後要執行的語句塊。
2、使用縮進來劃分語句塊，相同縮進數的語句在一塊兒組成一個語句塊。
3、在 Python 中沒有 switch – case 語句。
6.13 循環語句
6.13.1 while 循環
while bool：
pass
else:
pass
練習1：1-100 求和
練習2：輸出 9*9 乘法表
6.13.2 for 循環
for <variable> in <sequence>:
<statements>
6.13.3 range() 函數
若是你須要遍歷數字序列，可使用內置 range() 函數。它會生成數列：
range(start, end, step)
6.13.4 break 和 continue 語句及循環中的 else 子句
(1) break 語句能夠跳出 for 和 while 的循環體。若是你從 for 或 while 循環中終止，任何對應的循環 else 塊將不執行。
(2) continue 語句被用來告訴 Python 跳過當前循環塊中的剩餘語句，而後繼續進行下一輪循環。
6.13.5 pass 語句
Python pass 是空語句，是爲了保持程序結構的完整性。pass 不作任何事情，通常用作佔位語句。
6.14 迭代器和生成器
迭代是 Python 最強大的功能之一，是訪問集合元素的一種方式。迭代器是一個能夠記住遍歷的位置的對象。迭代器對象從集合的第一個元素開始訪問，直到全部的元素被訪問完結束。迭代器只能往前不會後退。
迭代器有兩個基本的方法：iter() 和 next()。
6.14.1 迭代器生成
字符串，列表或元組對象均可用於建立迭代器。
list=[1, 2, 3, 4]
it = iter(list) # 建立迭代器對象
print(next(it)) # 輸出迭代器的下一個元素
print(next(it))
6.14.2 迭代器遍歷
list=[1, 2, 3, 4]
it = iter(list)
(1)for循環
for i in it:
print(i)
(2)while循環
import sys
while True:
try:
print(next(its))
except StopIteration:
sys.exit()
6.14.3 建立一個迭代器
把一個類做爲一個迭代器使用須要在類中實現兩個方法 __iter__() 與 __next__()
例如：
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a < 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
for x in myiter:
print(x)
6.14.4 生成器
在 Python 中，使用了 yield 的函數被稱爲生成器(generator)。跟普通函數不一樣的是，生成器是一個返回迭代器的函數，只能用於迭代操做，更簡單點理解生成器就是一個迭代器。
在調用生成器運行的過程當中，每次遇到 yield 時函數會暫停並保存當前全部的運行信息，返回 yield 的值，並在下一次執行 next() 方法時從當前位置繼續運行。
調用一個生成器函數，返回的是一個迭代器對象。
import sys
def fibonacci(n): # 生成器函數 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一個迭代器，由生成器返回生成
while True:
try:
print(next(f), end=" ")
except StopIteration:
sys.exit()
6.15 函數
6.15.1 基本語法
def 函數名(參數列表):
函數體
6.15.2 函數分類
1. 有參數
(1) 有幾個參數，就得傳入幾個參數
(2) 在函數調用中輸入參數時，參數名稱必須對應
def aa(x):
print(x)
aa(x=5)
(3) 當調用函數時，必須所有定義名稱,且名稱對應，順序能夠不一樣
def aa(x, y):
print(x)
aa(y=2, x=5)
(4) 函數中能夠定義默認值
def aa(x=30, y):
print(x)
aa(y=2, x=5)
(5) 不定長度參數
def aa(x, y, *args, **kwargs):
print(x)
print(args) # 元組
print(kwargs) # 字典
aa(1, 2, 3, 4, 5, 6, 7, a = 8, b=9)
2. 有返回值
(1) 單個返回值
def aa(x):
return x
a = aa(10)
(2) 多個返回值
def aa(x):
return x, 10
a = aa(10) # a是一個元組
a, b = aa(10) # 多個參數接收
6.15.3 匿名函數
基本語法：
lambda [arg1 [,arg2,.....argn]]:expression
sum = lambda arg1, arg2: arg1 + arg2
# 調用 sum 函數
print("相加後的值爲 : ", sum(10, 20))
print("相加後的值爲 : ", sum(20, 20))
6.15.4 變量做用域
L（Local） 局部做用域
E（Enclosing） 閉包函數外的函數中
G（Global） 全局做用域
B（Built-in） 內建做用域
L –> E –> G –>B (在局部找不到，便會去局部外的局部找（例如閉包），再找不到就會去全局找，再者去內建中找)
x = int(2.9) # 內建做用域
g_count = 0 # 全局做用域
def outer():
o_count = 1 # 閉包函數外的函數中
def inner():
i_count = 2 # 局部做用域
o_count += 1
inner()
outer()
6.15.5 全局變量和局部變量
定義在函數內部的變量擁有一個局部做用域，定義在函數外的擁有全局做用域。
局部變量只能在其被聲明的函數內部訪問，而全局變量能夠在整個程序範圍內訪問。
調用函數時，全部在函數內聲明的變量名稱都將被加入到做用域中。
total = 0 # 這是一個全局變量
# 可寫函數說明
def sum(arg1, arg2):
# 返回2個參數的和."
total = arg1 + arg2 # total 在這裏是局部變量
print("函數內是局部變量：", total)
return total
#調用 sum 函數
sum(10, 20)
print("函數外是全局變量：", total)
相關文章
- 1. 電商大數據項目-推薦系統實戰（一）
- 2. 大數據技術之機器學習和推薦系統
- 3. 【大數據技術與推薦系統(3)】推薦系統設計
- 4. 【大數據技術與推薦系統(9)】推薦系統與Lambda架構
- 5. 推薦系統之大數據技術(超全面)
- 6. 【大數據技術與推薦系統(4)】推薦系統設計
- 7. 大數據：推薦系統
- 8. 【大數據技術與推薦系統(7)】Mahout推薦算法實戰
- 9. 【大數據技術與推薦系統(1)】推薦系統與大數據的關係
- 10. 推薦系統之大數據應用
- 更多相關文章...
- • Rust 基礎語法 - RUST 教程
- • Kotlin 基礎語法 - Kotlin 教程
- • Kotlin學習（一）基本語法
- • Flink 數據傳輸及反壓詳解
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
