Python3.7從零開始學
—|進入Python3.7的精彩世界
—|---|Python起源
—|---|—|Python作者簡介
—|---|—|---|Guido von Rossum，荷蘭人。1982年，Guido從阿姆斯特丹大學獲得了數學和計算機碩士學位。1989年，他創立了Python語言。
—|---|—|Python發展簡介
—|---|—|---|1989年，為了打發圣誕節假期，Guido開始寫Python語言的編譯器。Python這個名字，來自Guido所摯愛的電視劇Monty Python’s Flying Circus。他希望這個新的叫做Python的語言，能符合他的理想：創造一種C和shell之間，功能全面，易學易用，可拓展的語言。
—|---|—|---|1991年，第一個Python編譯器誕生。它是用C語言實現的，并能夠調用C語言的庫文件。從一出生，Python已經具有了：類，函數，異常處理，包含表和詞典在內的核心數據類型，以及模塊為基礎的拓展系統。
—|---|—|---|1999年，Granddaddy of Python web frameworks, Zope 1 was released in 1999
—|---|—|---|1994年，Python 1.0 - January 1994 增加了 lambda, map, filter and reduce.
—|---|—|---|2000年，Python 2.0 - October 16, 2000，加入了內存回收機制，構成了現在Python語言框架的基礎
—|---|—|---|2004年，Python 2.4 - November 30, 2004, 同年目前最流行的WEB框架Django 誕生
—|---|—|---|2006年，Python 2.5 - September 19, 2006
—|---|—|---|2008年，Python 2.6 - October 1, 2008
—|---|—|---|2010年，Python 2.7 - July 3, 2010
—|---|—|---|2014年，In November 2014, it was announced that Python 2.7 would be supported until 2020, and reaffirmed that there would be no 2.8 release as users were expected to move to Python 3.4+ as soon as possible
—|---|—|---|2008年，Python 3.0 - December 3, 2008
—|---|—|---|2009年，Python 3.1 - June 27, 2009
—|---|—|---|2011年，Python 3.2 - February 20, 2011
—|---|—|---|2012年，Python 3.3 - September 29, 2012
—|---|—|---|2014年，Python 3.4 - March 16, 2014
—|---|—|---|2015年，Python 3.5 - September 13, 2015
—|---|—|---|2015年，Python 3.5.1, documentation released on 07 December 2015.
—|---|—|---|2016年，Python 3.5.2, documentation released on 27 June 2016.
—|---|—|---|2016年，Python 3.6.0, documentation released on 23 December 2016.
—|---|—|---|2017年，Python 3.6.1, documentation released on 21 March 2017.
—|---|目前Python主要應用領域
—|---|—|云計算:
—|---|—|---|云計算最火的語言， 典型應用OpenStack
—|---|—|WEB開發:
—|---|—|---|眾多優秀的WEB框架，眾多大型網站均為Python開發，Youtube, Dropbox, 豆瓣。。。， 典型WEB框架有Django
—|---|—|科學運算、人工智能:
—|---|—|---|典型庫NumPy, SciPy, Matplotlib, Enthought librarys,pandas
—|---|—|系統運維:
—|---|—|---|運維人員必備語言
—|---|—|金融分析：
—|---|—|---|量化交易，金融分析，在金融工程領域，Python不但在用，且用的最多，而且重要性逐年提高。
—|---|—|---|原因：作為動態語言的Python，語言結構清晰簡單，庫豐富，成熟穩定，科學計算和統計分析都很牛逼，生產效率遠遠高于c,c++,java,尤其擅長策略回測
—|---|—|圖形GUI:
—|---|—|---|PyQT, WxPython,TkInter
—|---|目前使用Python的公司
—|---|—|谷歌：Google App Engine 、code.google.com 、Google earth 、谷歌爬蟲、Google廣告等項目都在大量使用Python開發
—|---|—|CIA: 美國中情局網站就是用Python開發的
—|---|—|NASA: 美國航天局(NASA)大量使用Python進行數據分析和運算
—|---|—|YouTube:世界上最大的視頻網站YouTube就是用Python開發的
—|---|—|Dropbox:美國最大的在線云存儲網站，全部用Python實現，每天網站處理10億個文件的上傳和下載
—|---|—|Instagram:美國最大的圖片分享社交網站，每天超過3千萬張照片被分享，全部用python開發
—|---|—|Facebook:大量的基礎庫均通過Python實現的
—|---|—|Redhat: 世界上最流行的Linux發行版本中的yum包管理工具就是用python開發的
—|---|—|豆瓣: 公司幾乎所有的業務均是通過Python開發的
—|---|—|知乎: 國內最大的問答社區，通過Python開發(國外Quora)
—|---|—|春雨醫生：國內知名的在線醫療網站是用Python開發的
—|---|—|除上面之外，還有國內許多公司都在使用Python完成各種各樣的任務。
—|---|—|---|搜狐—|---|—|---|金山—|---|—|---|騰訊
—|---|—|---|盛大—|---|—|---|網易—|---|—|---|百度
—|---|—|---|阿里—|---|—|---|淘寶—|---|—|---|土豆
—|---|—|---|新浪—|---|—|---|果殼
—|---|從python2.7到python3.7的新特性
—|---|—|python2.x和3.x中的區別
—|---|—|---|使用__future__模塊
—|---|—|---|print函數
—|---|—|---|整數除法
—|---|—|---|Unicode
—|---|—|---|xrange
—|---|—|---|觸發異常
—|---|—|---|處理異常
—|---|—|---|next()函數和.next()方法
—|---|—|---|for循環變量與全局命名空間泄露
—|---|—|---|比較無序類型
—|---|—|---|使用input()解析輸入內容
—|---|—|---|返回可迭代對象,而不是列表
—|---|—|python3.7與3.5的區別
—|---|—|---|重新實現了字典(dict)類型,以便能想pypy的字典類型一樣使用更緊湊的表達方式.
—|---|—|---|為asynicio模塊增加了新功能
—|---|—|---|引入了一種新的字符串:f-strings
—|---|—|---|在python3.6后,可在同一個函數體中使用await和yield
—|---|—|---|添加了對async for 在list、set、dict解析式以及generator表達式中的使用支持
—|---|—|---|支持nanosecond的時間函數
—|---|—|---|在新版本中添加了@dataclass 裝飾器,減少數據類型定義的代碼行數
—|---|如何學習python
—|---|python環境構建
—|---|從HelloWorld開始
—|---|調試
—|---|問題解答
—|---|溫故知新,學以致用
—|開啟python之旅
—|---|認識程序
—|---|數據類型
—|---|—|Python中可以自定義數據類型,可以具有無限種數據類型。系統默認提供6個標準數據類型：
—|---|—|1.Number類型 數值類型
—|---|—|---|Number類型一共分為四個小類別：整型，浮點型，布爾型，復數
—|---|—|---|Int 整形
—|---|—|---|—|整形就是整數類型，聲明整形有四種方式：
—|---|—|---|—|1.十進制：0~9
—|---|—|---|—|---|變量 = 十進制數字
—|---|—|---|—|2.二進制：0~1
—|---|—|---|—|---|變量 = 0b二進制數字
—|---|—|---|—|---|0b是二進制的標志符號
—|---|—|---|—|3.八進制：0~7
—|---|—|---|—|---|變量 = 0o八進制數字
—|---|—|---|—|---|0o是八進制的標志符號
—|---|—|---|—|4.十六進制：0_9AF
—|---|—|---|—|---|變量 = 0x十六進制數字
—|---|—|---|—|---|0x是十六進制的標志符號
—|---|—|---|Float 浮點型
—|---|—|---|—|浮點型就是小數類型，聲明浮點型有兩種方式：
—|---|—|---|—|1.小數方式：
—|---|—|---|—|---|變量 = 3.1415926
—|---|—|---|—|2.科學計數法：
—|---|—|---|—|---|變量 = 314e2 #相當于314x10的平方—|---|
—|---|—|---|Bool 布爾類型
—|---|—|---|—|布爾類型是計算機專用的數據類型，只有2個值：True和False
—|---|—|---|—|True 表示肯定的答案
—|---|—|---|—|---|有，是，好的，沒錯，真的…
—|---|—|---|—|False 表示否定的答案
—|---|—|---|—|---|沒有，不是，孬，錯，假的…—|---|
—|---|—|---|Complex 復數類型
—|---|—|---|—|復數的完整結構(實數部分+虛數部分)
—|---|—|---|—|聲明復數的兩種方式：
—|---|—|---|—|---|表達式方式：
—|---|—|---|—|---|—|變量 = 實數 + 虛數 如：var = 3 + 2j
—|---|—|---|—|---|特定功能：
—|---|—|---|—|---|—|變量 = complex(實數，虛數值) 如：var = complex(5,3)
—|---|—|---|—|實數：現實存在的所有數值都是實數 虛數：不是真實存在的數字(i的平方為-1作為基本單位) 數學中：i的平方 = -1 i就是虛數的基本單位 1i 2i 5i… 計算機中：用j來表示i即可
—|---|—|2.String類型 字符類型
—|---|—|---|String 字符串類型
—|---|—|---|—|字符串類型就是文字類型，聲明一個字符串類型有三種方式：
—|---|—|---|—|單引號：
—|---|—|---|—|---|變量 = ‘內容’
—|---|—|---|—|雙引號：
—|---|—|---|—|---|變量 = “內容”
—|---|—|---|—|三引號：
—|---|—|---|—|---|變量 = ‘’‘內容’’’
—|---|—|---|—|---|變量 = “”“內容”""
—|---|—|---|—|如何選擇聲明字符串的方式：
—|---|—|---|—|---|單引號：內容中包含大量雙引號時，適合使用單引號聲明字符串
—|---|—|---|—|---|雙引號：內容中包含大量單引號時，適合使用雙引號聲明字符串
—|---|—|---|—|---|三引號：內容中同時包含單雙引號，適合使用三引號聲明字符串
—|---|—|---|—|---|轉義字符： 通過某種特定的格式使得字符的意義發生改變，這就是轉義字符，常見轉義字符如下：
—|---|—|---|—|---|—|轉義字符 作用描述 使用率
—|---|—|---|—|---|—|\ 續行符 *
—|---|—|---|—|---|—|\ 反斜杠符號() ***
—|---|—|---|—|---|—|’ 單引號 *****
—|---|—|---|—|---|—|" 雙引號 *****
—|---|—|---|—|---|—|\a 響鈴
—|---|—|---|—|---|—|\b 退格(backspace)
—|---|—|---|—|---|—|\e 轉義
—|---|—|---|—|---|—|\000 空
—|---|—|---|—|---|—|\n 換行 *****
—|---|—|---|—|---|—|\v 縱向制表符
—|---|—|---|—|---|—|\t 橫向制表符 *****
—|---|—|---|—|---|—|\r 回車 *****
—|---|—|---|—|---|—|\f 換頁
—|---|—|---|—|---|—|\oyy 八進制數，yy代表的字符，例如：\o12代表換行
—|---|—|---|—|---|—|\xyy 十六進制數，yy代表的字符，例如：\x0a代表換行
—|---|—|---|—|---|—|\other 其它的字符以普通格式輸出
—|---|—|---|元字符串：
—|---|—|---|—|在任意字符串之前添加字母r或者R，那么當前字符串中所有轉義字符在使用時都不會進行轉義操作，這就是元字符串，正則表達式中常見格式。
—|---|—|---|—|strval = R’鋤禾日當午，\n汗滴\禾下土，\n誰知\r盤中餐，\n麗麗\t皆辛苦\n’
—|---|—|3.List類型 列表類型
—|---|—|---|列表就是一些列數據的順序組合，并且組合之后可以修改。 列表的標志符號：[ ] 列表格式：
—|---|—|---|變量 = [值,值,值…]
—|---|—|4.Tuple類型 元組類型
—|---|—|---|元組就是一些列數據的順序組合，但是組合之后不可以修改。 元組的標志符號：, 元組格式：
—|---|—|---|變量 = (值,值,值…)
—|---|—|5.Dict類型 字典類型
—|---|—|---|字典就是具有鍵值映射關系的一組無序數據組合，可以修改 字典的標志符號：{} 字典格式：
—|---|—|---|變量 = {鍵:值,鍵:值,鍵:值…}
—|---|—|6.Set類型 集合類型
—|---|—|---|一組特定數據的無序組合，所有數據不會重復 集合的標志符號：無 集合格式：
—|---|—|---|變量 = {值,值,值…}
—|---|變量和關鍵字
—|---|—|變量相關
—|---|—|---|什么是變量
—|---|—|---|—|變量就是可以改變的量，如：
—|---|—|---|—|---|x + y = 10
—|---|—|---|—|---|x = 5 y = ?
—|---|—|---|—|---|x = 7 y = ?
—|---|—|---|—|上面示例中的 x 和 y 就是變量，它們是數學里的變量。
—|---|—|---|—|通俗的理解：
—|---|—|---|—|---|變量 = 生活中的容器(盒子)
—|---|—|---|—|---|變量賦值操作 = 我們把物品放入盒子
—|---|—|---|—|---|數據類型 = 放了不同物體的盒子(放了鞋子，那這個盒子的類型就是鞋盒；放了飯，就是飯盒…)
—|---|—|---|變量賦值
—|---|—|---|—|變量的命名規范：
—|---|—|---|—|---|1.變量名支持中文 但不推薦使用
—|---|—|---|—|---|2.可以使用數字 但不能以數字開頭
—|---|—|---|—|---|3.不可以使用特殊字符 除了下劃線_
—|---|—|---|—|---|4.變量嚴格區分大小寫
—|---|—|---|—|---|5.變量命名要有意義(規范)
—|---|—|---|—|---|6.變量命名要避免和系統使用的保留關鍵字沖突
—|---|—|---|—|變量賦值的基本格式
—|---|—|---|—|---|變量名 = 值 如：age = 18
—|---|—|---|—|---|變量的其他賦值方式
—|---|—|---|—|---|—|變量1 = 變量2 = 變量3 = 值 （給多個變量同時賦同一個值）
—|---|—|---|—|---|—|變量1，變量2，變量3 = 值1，值2，值3 （給多個變量同時分別賦不同的值）
—|---|—|---|—|---|變量交換
—|---|—|---|—|---|—|變量1,變量2 = 變量2，變量1
—|---|—|---|變量的三個常用操作
—|---|—|---|—|1.獲取值 可直接通過變量名獲取
—|---|—|---|—|---|用法：name
—|---|—|---|—|2.查看數據類型 使用type()函數
—|---|—|---|—|---|用法：type(name)
—|---|—|---|—|3.獲取變量在內存中的id標識 使用id()函數
—|---|—|---|—|---|用法：id(name)
—|---|—|---|Python中，一切都是對象，包括變量，每個變量都是一個對象，對象的概念詳見面向對象一文
—|---|—|關鍵字相關
—|---|—|---|概念
—|---|—|---|—|關鍵字就是一些具有特殊功能的標識符。在這里關鍵字指的是系統已經使用了的標識符，那么系統一般是不允許我們使用跟這些關鍵字同名的標識符的。
—|---|—|---|查看系統保留關鍵字的方法：
—|---|—|---|—|在命令行輸入 import keyword 回車后輸入 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’]
—|---|—|---|創建Python文件
—|---|—|---|—|文件名稱部分
—|---|—|---|—|---|1.可以使用英文，不要使用中文
—|---|—|---|—|---|2.可以使用數字，但是盡量不要全用數字
—|---|—|---|—|---|3.可以使用_或者-等部分字符分隔文件名
—|---|—|---|—|---|4.文件命名要有意義方便維護
—|---|—|---|—|---|5.變量命名要避免和系統使用的保留關鍵字沖突
—|---|—|---|—|文件后綴部分
—|---|—|---|—|---|Python不限制文件后綴名，但建議使用更標準的常用格式
—|---|—|---|—|---|常用文件后綴： .py .pyw
—|---|—|---|—|---|—|.pyw 格式是被設計來運行開發完成的純圖形界面程序的—|---|但在開發純圖形界面程序的時候，你也可以暫時把 .pyw 改成
—|---|—|---|—|---|—|.py，方便運行時調出控制臺的窗口，查看所有錯誤信息
—|---|—|---|—|查看文件后綴的方法
—|---|—|---|—|win7
—|---|—|---|—|---|打開任意文件夾->組織選項->文件夾和搜索選項->查看選項卡->高級設置->取消"隱藏已知文件類型的擴展名"選項
—|---|—|---|—|win10
—|---|—|---|—|---|打開任意文件夾->查看選項卡->倒數第三列中第二個選項(文件擴展名)勾上去—|
—|---|語句
—|---|—|Python語句分為兩類：單行語句 和 代碼塊/代碼組
—|---|—|* 單行語句指的是一行Python代碼。
—|---|—|* 代碼組指的是特定的語言結構。
—|---|表達式
—|---|運算和運算符
—|---|—|運算： 由一個以上的值經過變化得到新值得過程，就是運算。
—|---|—|運算符： 用于運算的符號，就是運算符
—|---|—|運算的分類：
—|---|—|---|1.算數運算
—|---|—|---|—|+ 加法運算
—|---|—|---|—|- 減法運算
—|---|—|---|—|* 乘法運算
—|---|—|---|—|/ 除法運算
—|---|—|---|—|% 取余運算
—|---|—|---|—|// 取商運算 地板除
—|---|—|---|—|** 冪運算
—|---|—|---|2.比較運算/關系運算
—|---|—|---|—|< 小于運算
—|---|—|---|—|> 大于運算
—|---|—|---|—|== 等于運算
—|---|—|---|—|<= 小于等于運算
—|---|—|---|—|>= 大于等于運算
—|---|—|---|—|!= 不等于運算
—|---|—|---|3.賦值運算
—|---|—|---|—|= 普通賦值運算
—|---|—|---|—|+= 加法賦值運算
—|---|—|---|—|-= 減法賦值運算
—|---|—|---|—|= 乘法賦值運算
—|---|—|---|—|/= 除法賦值運算
—|---|—|---|—|%= 取余賦值運算
—|---|—|---|—|//= 取商賦值運算
—|---|—|---|—|= 冪賦值運算
—|---|—|---|—|所有運算賦值操作的格式都可以轉換為[變量 = 變量 運算符 值]
—|---|—|---|—|---|如：var /= 5 相當于 var = var / 5
—|---|—|---|4.邏輯運算
—|---|—|---|—|邏輯運算就是布爾值之間的運算，Python只有三種運算方式
—|---|—|---|—|1.and 邏輯與運算(有假則假；兩邊為真才是真)
—|---|—|---|—|---|洗手：
—|---|—|---|—|---|—|左手洗了True，右手洗了True，洗完了 True
—|---|—|---|—|---|—|左手洗了True，右手沒洗False，沒洗完 False
—|---|—|---|—|---|—|左手沒洗False，右手洗了True，沒洗完 False
—|---|—|---|—|---|—|左手沒洗False，右手沒洗False，沒洗完 False
—|---|—|---|—|2.or 邏輯或運算(有真則真；兩邊為假才是假)
—|---|—|---|—|---|鑰匙丟了找鑰匙：
—|---|—|---|—|---|—|你沒找到鑰匙False，你媳婦也沒有找到鑰匙False，鑰匙沒找到 False
—|---|—|---|—|---|—|你找到了鑰匙True，你媳婦沒找到鑰匙False，鑰匙找到了 True
—|---|—|---|—|---|—|你沒有找到鑰匙False，你媳婦找到了鑰匙True，鑰匙找到了 True
—|---|—|---|—|---|—|你和你媳婦同時找到了鑰匙True和True，鑰匙找到了 True
—|---|—|---|—|3.not 邏輯非運算(真變假，假變真)
—|---|—|---|—|---|老爺們去了泰國
—|---|—|---|—|---|—|純爺們兒True，做了手術，不是純爺們兒了 False
—|---|—|---|5.位運算
—|---|—|---|—|在二進制基礎上進行的邏輯運算就是位運算。
—|---|—|---|—|& 按位與運算
—|---|—|---|—|| 按位或運算
—|---|—|---|—|～ 按位非運算
—|---|—|---|—|^ 按位抑或運算
—|---|—|---|—|<< 左移運算 相當于×2運算
—|---|—|---|—|>> 右移運算 相當于地板除2運算
—|---|—|---|6.成員運算
—|---|—|---|—|檢測一個數據是否在指定的容器(復合數據)當中
—|---|—|---|—|---|檢測數據1是否在數據2中
—|---|—|---|—|---|—|格式：數據1 in 數據2
—|---|—|---|—|---|檢測數據1是否不在數據2中
—|---|—|---|—|---|—|格式：數據1 not in 數據2
—|---|—|---|7.身份運算
—|---|—|---|—|檢測兩個變量在內存中是否是同一個值
—|---|—|---|—|---|檢測兩個變量在內存中是不是同一個值
—|---|—|---|—|---|—|格式：數據1 is 數據2
—|---|—|---|—|---|檢測兩個變量在內存中是否不是同一個值
—|---|—|---|—|---|—|格式：數據1 is not 數據2
—|---|—|運算優先級的問題
—|---|—|---|運算的優先級
—|---|—|---|—|例如：在數學中，1+5x2，乘法會優先運算。
—|---|—|---|—|我們的Python程序也是一樣的，一個運算中存在多個運算符時，系統也有它自己的一套優先級的規則。
—|---|—|---|—|Python的運算優先級規則如下，從上向下按照優先級的由高向低依次排序
—|---|—|---|—|但是我們并不推薦各位死記硬背，因為我們自己寫程序遇到優先級問題可以使用()解決，更方便，也更易讀。
—|---|—|---| 指數(最高優先級)
—|---|—|---|~ + - 按位翻轉， 一元加號和減號(最后兩個的方法名為 +@ 和 -@)
—|---|—|---| / % // 乘，除，取模和取整除
—|---|—|---|+ - 加法減法
—|---|—|---|>> << 右移，左移運算符
—|---|—|---|& 位 ‘AND’
—|---|—|---|^ | 位運算符
—|---|—|---|<= < > >= <> == != 比較運算符
—|---|—|---|= %= /= //= -= += *= = 賦值運算符
—|---|—|---|is is not 身份運算符
—|---|—|---|in not in 成員運算符
—|---|—|---|not or and 邏輯運算符
—|---|—|檢測數據歸屬類型
—|---|—|---|type()
—|---|—|---|—|測試時可是使用，開發盡量避免使用
—|---|—|---|—|格式：type(變量)
—|---|—|---|isinstance()
—|---|—|---|—|檢測一個數據是否由指定的類型創建
—|---|—|---|—|格式：isinstance(變量，檢測的類型)—|
—|---|注釋
—|---|—|注釋就是：注解，解釋。主要用于在代碼中給代碼標識出相關的文字提示(提高代碼的可讀性) 或 調試程序。
—|---|—|Python中注釋分為兩類：
—|---|—|---|1.單行注釋： 單行注釋以 # 號開頭，在當前行內，# 號后面的內容就是注釋內容
—|---|—|---|2.多行注釋： 多行注釋使用兩個 ‘’’ 或兩個 “”" 將需要注釋的內容包裹起來
—|---|字符串操作
—|---|—|+ 字符串連接操作
—|---|—| 字符串復制操作
—|---|—|[] 字符串索引操作，通過索引訪問指定位置的字符，索引從0開始
—|---|—|[::] 字符串取片操作
—|---|—|---|完整格式：[開始索引:結束索引:間隔值]
—|---|—|---|[:結束索引] 從開頭截取到結束索引之前
—|---|—|---|[開始索引:] 從開始索引截取到字符串的最后
—|---|—|---|[開始索引：結束索引] 從開始索引截取到結束索引之前
—|---|—|---|[:] 截取所有字符串
—|---|—|---|[開始索引:結束索引:間隔值] 從開始索引截取到結束索引之前按照指定的間隔截取字符
—|---|—|r’字符串’ 元字符串，所有字符串中的轉義字符不會轉義，當作普通字符—|
—|---|牛刀小試試-九九乘法表實現
—|---|調試
—|---|問題解答
—|---|溫故知新,學以致用
—|列表和元組
—|---|通用序列操作
—|---|列表
—|---|—|列表操作
—|---|—|---|一組有序數據的組合就是列表
—|---|—|創建列表
—|---|—|---|空列表
—|---|—|---|—|方式1：
—|---|—|---|—|---|變量 = []
—|---|—|---|—|方式2：
—|---|—|---|—|---|變量 = list()
—|---|—|---|具有一個數據的列表
—|---|—|---|—|變量 = [值] 備注：列表中保存的每個都稱之為元素
—|---|—|---|具有多個數據的列表
—|---|—|---|—|變量 = [值,值,值…]
—|---|—|普通操作
—|---|—|---|訪問列表中的元素
—|---|—|---|—|變量[索引]
—|---|—|---|修改列表中的元素
—|---|—|---|—|變量[索引] = 新值
—|---|—|---|添加列表元素
—|---|—|---|—|普通操作無法實現，需要借助函數操作
—|---|—|---|刪除列表中的元素
—|---|—|---|—|del 變量[索引]
—|---|—|---|刪除整個列表
—|---|—|---|—|del 列表變量
—|---|—|序列操作
—|---|—|---|通用的序列操作包括以下幾種： 序列相加、序列相乘、索引、取片/分片、成員檢測、最大值、最小值、長度計算
—|---|—|---|列表相加操作
—|---|—|---|—|格式：變量 = 列表1 + 列表2
—|---|—|---|—|結果：新的列表
—|---|—|---|—|注意：+兩側都要是列表類型
—|---|—|---|列表相乘操作
—|---|—|---|—|格式：變量 = 列表 * 整數
—|---|—|---|—|結果：新的列表
—|---|—|---|—|索引操作
—|---|—|---|—|變量[索引]
—|---|—|---|分片操作
—|---|—|---|—|格式：變量 = 列表[:]
—|---|—|---|—|---|獲取整個列表
—|---|—|---|—|格式：變量 = 列表[:結束索引]
—|---|—|---|—|---|獲取列表開頭到結束索引之前的數據組成的列表
—|---|—|---|—|格式：變量 = 列表[開始索引:]
—|---|—|---|—|---|獲取列表開始索引到列表末尾的數據組成的列表
—|---|—|---|—|格式：變量 = 列表[開始索引:結束索引]
—|---|—|---|—|---|獲取開始索引和結束索引之間的數據組成的列表（包含開始索引，不包含結束索引）
—|---|—|---|—|格式：變量 = 列表[開始索引:結束索引:間隔值]
—|---|—|---|—|---|獲取開始索引和結束索引之間的數據（按照間隔值來獲取）組成的列表（包含開始索引，不包含結束索引）
—|---|—|---|成員檢測
—|---|—|---|—|檢測一個數據是否在列表中
—|---|—|---|—|---|格式：值 in 列表
—|---|—|---|—|---|結果：布爾值
—|---|—|---|—|檢測一個數據是否不在列表中
—|---|—|---|—|---|格式：值 not in 列表
—|---|—|---|—|---|結果：布爾值
—|---|—|序列操作函數
—|---|—|---|len()計算列表中元素的個數
—|---|—|---|max()獲取列表中的最大值
—|---|—|---|min()獲取列表中的最小值
—|---|—|---|list()生成空列表或者將其他數據轉化為列表類型
—|---|—|列表的遍歷操作
—|---|—|---|for…in
—|---|—|---|—|for 變量 in 列表：
—|---|—|---|—|---|使用變量
—|---|—|---|while
—|---|—|---|—|i = 0
—|---|—|---|—|while i<len(列表):
—|---|—|---|—|---|使用列表中的元素(列表[i])
—|---|—|---|—|---|i += 1
—|---|—|---|遍歷同等長度的二級列表
—|---|—|---|—|列表 = [[值1,值2],[值1,值2],…]
—|---|—|---|—|for 變量1,變量2 in 列表:
—|---|—|---|—|---|使用變量1和變量2
—|---|—|---|—|#注意：變量1取二級列表中的第一個值，變量2取第二個值
—|---|—|---|遍歷非同等長度的二級列表
—|---|—|---|—|列表 = [[值1，值2]，[值1，值2,值3],[值]…]
—|---|—|---|—|for 變量1 in 列表:
—|---|—|---|—|---|for 變量2 in 變量1:
—|---|—|---|—|---|—|使用變量2(變量2是二級列表中的每個值)
—|---|—|列表內涵/列表推導式 list content
—|---|—|---|簡單的列表推導式
—|---|—|---|—|格式：[變量 for 變量 in 列表]
—|---|—|---|—|結果：遍歷列表中的每個值，將每個值獲取之后組成新的列表，可以對獲取的值進行修改
—|---|—|---|—|[變量可以其他操作 for 變量 in 列表]
—|---|—|---|帶有判斷條件的列表推導式
—|---|—|---|—|格式：[變量 for 變量 in 列表 if 條件表達式]
—|---|—|---|—|結果：遍歷列表中的每個值，根據判斷條件決定是否取出指定的值組成新的列表，可以對獲取的值進行修改
—|---|—|---|多個列表的同時循環的列表推導式
—|---|—|---|—|格式：[變量1+變量2 for 變量1 in 列表1 for 變量2 in 列表2]
—|---|—|---|—|結果：同時遍歷列表1和列表2中的每個值，將列表1中的每個值和列表2中的每個值進行運算得到新的列表,新的列表中元素個數=列表1中元素個數 * 列表2中的元素個數
—|---|—|---|—|變量1和變量2可以進行其他操作，不一定非要+ 這只是demo
—|---|—|---|帶有判斷條件的多個列表的同時循環列表推導式
—|---|—|---|—|格式：[變量1+變量2 for 變量1 in 列表1 for 變量2 in 列表2 if 條件表達式]
—|---|—|---|—|結果：同時遍歷列表1和列表2中的每個值，根據判斷條件將列表1中的值和列表2中的值進行運算，得到新的列表,新的列表數量由判斷條件決定
—|---|—|列表專用函數
—|---|—|---|append()
—|---|—|---|—|功能：向列表的末尾添加新的元素
—|---|—|---|—|格式：列表.append(值)
—|---|—|---|—|返回值：None
—|---|—|---|—|注意：新添加的值在列表的末尾，該函數直接操作原有列表
—|---|—|---|clear()
—|---|—|---|—|功能：清空列表中所有元素
—|---|—|---|—|格式：列表.clear()
—|---|—|---|—|返回值:None
—|---|—|---|copy()
—|---|—|---|—|功能：復制列表
—|---|—|---|—|格式：列表.copy()
—|---|—|---|—|返回值：新的列表
—|---|—|---|count()
—|---|—|---|—|功能：計算某個元素出現的次數
—|---|—|---|—|格式：列表.count(值)
—|---|—|---|—|返回值：整數
—|---|—|---|extend()
—|---|—|---|—|功能：將一個列列表繼承另一個列表
—|---|—|---|—|格式：列表.extend(序列)
—|---|—|---|—|返回值：None
—|---|—|---|—|注意：直接改變原有列表
—|---|—|---|index()
—|---|—|---|—|功能：獲取某個值在列表中的索引
—|---|—|---|—|格式：列表.index(值)
—|---|—|---|—|返回值：整數
—|---|—|---|—|注意：值不存在與列表時拋出異常錯誤！
—|---|—|---|insert()
—|---|—|---|—|功能：在指定位置之前插入元素
—|---|—|---|—|格式：列表.insert(索引,值)
—|---|—|---|—|返回值:None
—|---|—|---|—|注意：直接改變原有列表
—|---|—|---|pop()
—|---|—|---|—|功能：在列表中移除一個元素
—|---|—|---|—|格式：列表.pop([索引])
—|---|—|---|—|返回值：無
—|---|—|---|—|注意：沒有指定索引，默認移除最后一個元素
—|---|—|---|remove()
—|---|—|---|—|功能：移除指定的值
—|---|—|---|—|格式：列表.remove(值)
—|---|—|---|—|返回值：無
—|---|—|---|—|注意：如果有索引的清空下推薦使用POP移除，效率比remove高
—|---|—|---|reverse()
—|---|—|---|—|功能：列表反轉操作
—|---|—|---|—|格式：列表.reverse()
—|---|—|---|—|返回值：None
—|---|—|---|sort()
—|---|—|---|—|功能：列表排序
—|---|—|---|—|格式：列表.sort() 按照從小到大排序（數字）
—|---|—|---|—|格式：列表.sort(reverse=True) 按照從大到小排序（數字）
—|---|—|---|—|格式：列表.sort(key=函數) 對值進行指定的函數處理之后在從小到大排序
—|---|—|---|—|格式：列表.sort(key=函數，reverse=True) 對值進行指定的函數處理之后在從大到小排序
—|---|—|---|—|返回值：None
—|---|—|---|—|注意：直接改變原有列表
—|---|元組
—|---|—|元組操作
—|---|—|---|元組也是一組有序數據的組合，和列表唯一的不同是，元組不可修改
—|---|—|---|列表 = 用鉛筆寫的清單(能擦能改)
—|---|—|---|元組 = 用鋼筆寫的清單(不能擦改)
—|---|—|創建元組
—|---|—|---|創建空元組
—|---|—|---|—|方式1：
—|---|—|---|—|---|變量 = ()
—|---|—|---|—|方式2：
—|---|—|---|—|---|變量 = tuple()
—|---|—|---|創建單個元素的元組
—|---|—|---|—|方式1：
—|---|—|---|—|---|變量= (值,)
—|---|—|---|—|方式2：
—|---|—|---|—|---|變量 = 值,
—|---|—|---|創建多個元素的元組
—|---|—|---|—|方式1：
—|---|—|---|—|---|變量 = (值,值…)
—|---|—|---|—|方式2：
—|---|—|---|—|---|變量 = 值,值…
—|---|—|基本操作
—|---|—|---|訪問元素
—|---|—|---|—|變量[索引]
—|---|—|---|—|注意： 元組中的元素，只允許訪問，無法修改，刪除 及 添加。
—|---|—|序列操作
—|---|—|---|序列操作：索引，分片，最大值，最小值，長度，加法，乘法…
—|---|—|---|元組相加
—|---|—|---|—|變量 = 元組1 + 元組2
—|---|—|---|—|結果：新的元組
—|---|—|---|元組相乘
—|---|—|---|—|變量 = 元組 * 整數
—|---|—|---|—|結果：新的元組
—|---|—|---|索引操作
—|---|—|---|—|變量[索引] 只能訪問不能修改和刪除
—|---|—|---|分片
—|---|—|---|—|格式：變量[:] 獲取整個元組的元素
—|---|—|---|—|格式：變量[開始索引:] 從開始索引的元組截取末尾
—|---|—|---|—|格式：變量[:結束索引] 從開頭截取到結束索引之前
—|---|—|---|—|格式：變量[開始索引:結束索引] 從開始索引位置截取到結束索引之前
—|---|—|---|—|格式：變量[開始索引:結束索引:間隔值] 從開始索引位置按照間隔值截取到結束索引之前
—|---|—|---|成員檢測
—|---|—|---|—|格式：值 in 元組 作用：檢測一個值是否在元組當中
—|---|—|---|—|格式：值 not in 元組 作用：檢測一個值是否不再元組當中
—|---|—|序列函數
—|---|—|---|len()獲取元組的長度
—|---|—|---|max()獲取元組中的最大值
—|---|—|---|min()獲取元組中的最小值
—|---|—|---|tuple()創建空元組或者將其他序列轉化為元組類型
—|---|—|元組的遍歷
—|---|—|---|for … in
—|---|—|---|—|變量 = (值1,值2,值3…)
—|---|—|---|—|for 變量 in 元組:
—|---|—|---|—|---|使用變量獲取元組的每個值
—|---|—|---|while
—|---|—|---|—|i = 0
—|---|—|---|—|while i<len(元組):
—|---|—|---|—|---|使用元組變量[i]訪問每個值
—|---|—|---|—|---|i += 1
—|---|—|---|遍歷長度相同的多級元組
—|---|—|---|—|元組 = ((值1,值2…),(值1,值2…)…)
—|---|—|---|—|for 變量1，變量2… in 元組:
—|---|—|---|—|---|使用變量1和變量2
—|---|—|---|遍歷長度不同的多級元組
—|---|—|---|—|元組 = ((值1,值2…),(值1,值2…)…)
—|---|—|---|—|for 變量1 in 元組:
—|---|—|---|—|---|for 變量2 in 變量1：
—|---|—|---|—|---|—|使用變量2獲取每個值
—|---|—|---|直接獲取二級元組的值
—|---|—|---|—|tuple1[1][3]
—|---|—|元組內涵/元組推導式
—|---|—|---|基本格式：
—|---|—|---|—|格式： 變量 = (i for i in 元組)
—|---|—|---|—|結果：不是元組而是一個生成器
—|---|—|---|帶條件格式：
—|---|—|---|—|格式： 變量 = (i for i in 元組 if 條件表達式)
—|---|—|---|—|結果：不是元組而是一個生成器
—|---|—|---|多循環推導式：
—|---|—|---|—|格式： 變量 = (x+y for x in 元組1 for y in 元組2)
—|---|—|---|—|結果：不是元組而是一個生成器 x+y可以是其他操作
—|---|—|---|帶條件的多循環推導式：
—|---|—|---|—|格式： 變量 = (x+y for x in 元組1 for y in 元組2 if 條件表達式)
—|---|—|---|—|結果：不是元組而是一個生成器 x+y可以是其他操作
—|---|—|元組函數
—|---|—|---|index()
—|---|—|---|—|獲取指定值在元組中的索引值
—|---|—|---|—|格式：元組.index(值)
—|---|—|---|—|返回值：整數
—|---|—|---|count()
—|---|—|---|—|計算某個值在元組中出現的次數
—|---|—|---|—|格式：元組.count(值)
—|---|—|---|—|返回值：整數—|
—|---|列表與元組的區別
—|---|牛刀小試-列表與元組相互轉化
—|---|調試
—|---|問題解答
—|---|溫故知新,學以致用
—|字符串
—|---|字符串基本操作
—|---|—|+ 字符串連接操作
—|---|—| 字符串復制操作
—|---|—|[] 字符串索引操作，通過索引訪問指定位置的字符，索引從0開始
—|---|—|[::] 字符串取片操作
—|---|—|---|完整格式：[開始索引:結束索引:間隔值]
—|---|—|---|[:結束索引] 從開頭截取到結束索引之前
—|---|—|---|[開始索引:] 從開始索引截取到字符串的最后
—|---|—|---|[開始索引：結束索引] 從開始索引截取到結束索引之前
—|---|—|---|[:] 截取所有字符串
—|---|—|---|[開始索引:結束索引:間隔值] 從開始索引截取到結束索引之前按照指定的間隔截取字符
—|---|—|r’字符串’ 元字符串，所有字符串中的轉義字符不會轉義，當作普通字符
—|---|字符串格式化
—|---|字符串方法
—|---|—|capitalize()
—|---|—|---|功能：首字母大寫
—|---|—|---|格式：字符串.capitalize()
—|---|—|---|返回值：新字符串
—|---|—|title()
—|---|—|---|功能：將每個單詞首字母變為大寫
—|---|—|---|格式：字符串.title()
—|---|—|---|返回值：新字符串
—|---|—|upper()
—|---|—|---|功能：將所有字母變為大寫
—|---|—|---|格式：字符串.upper()
—|---|—|---|返回值：新字符串
—|---|—|lower()
—|---|—|---|功能：將所有字母變為小寫
—|---|—|---|格式：字符串.lower()
—|---|—|---|返回值：新字符串
—|---|—|swapcase()
—|---|—|---|功能：大小寫互換
—|---|—|---|格式：字符串.swapcase()
—|---|—|---|返回值:新字符串
—|---|—|len()
—|---|—|---|功能：計算字符串的長度
—|---|—|---|格式:len(字符串)
—|---|—|---|返回值：整型
—|---|—|count()
—|---|—|---|功能：計算指定字符串出現的次數
—|---|—|---|格式：字符串.count(查找字符串[,開始索引[,結束索引]])
—|---|—|---|返回值：整數
—|---|—|find()
—|---|—|---|功能：查找指定字符串第一次出現的位置
—|---|—|---|格式：字符串.find(查找字符串[,開始索引[,結束索引]])
—|---|—|---|返回值：整數 找不到返回-1
—|---|—|index()
—|---|—|---|功能：查找指定字符串第一次出現的位置
—|---|—|---|格式：字符串.index(查找字符串[,開始索引[,結束索引]])
—|---|—|---|返回值：整數 找不到拋出錯誤！
—|---|—|---|注意： find 和 index 的區別在于，當指定字符查找不到時，find返回-1，程序可以繼續執行，而index則報錯，程序無法繼續執行。
—|---|—|startswith()
—|---|—|---|功能：檢測字符串是否以指定的字符串開頭
—|---|—|---|格式：字符串.startswith(查找字符串)
—|---|—|---|返回值：布爾值
—|---|—|endswith()
—|---|—|---|功能：檢測字符串是否以指定的字符串結尾
—|---|—|---|格式：字符串.endswith(查找字符串)
—|---|—|---|返回值：布爾值
—|---|—|isupper()
—|---|—|---|功能：檢測一個字符串中的英文是否都是大寫字母，符號不算
—|---|—|---|格式：字符串.isupper()
—|---|—|---|返回值:布爾值
—|---|—|islower()
—|---|—|---|功能：檢測一個字符串中的英文是否都是小寫字母，符號不算
—|---|—|---|格式：字符串.islower()
—|---|—|---|返回值：布爾值
—|---|—|isalnum()
—|---|—|---|功能：檢測字符串是否由數字，字母和文字等組成
—|---|—|---|格式：字符串.isalnum()
—|---|—|---|返回值：布爾值 漢字當作普通字符處理，沒有標點和特殊字符就是真，空字符串為false
—|---|—|isalpha()
—|---|—|---|功能：檢測字符串是否有字母和文字組成
—|---|—|---|格式：字符串.isalpha()
—|---|—|---|返回值：布爾值，漢字當作普通字母處理。空字符串為false
—|---|—|isdigit()
—|---|—|---|功能：檢測字符串是否由純數字組成 十進制
—|---|—|---|格式：字符串.isdigit()
—|---|—|---|返回值：布爾值
—|---|—|isnumeric()
—|---|—|---|功能：檢測字符串是否是數值字符串 數字整數
—|---|—|---|格式:字符串.isnumeric()
—|---|—|---|返回值：布爾值
—|---|—|isdecimal()
—|---|—|---|功能：檢測字符串是否是純數值字符串組成
—|---|—|---|格式:字符串.isdecimal()
—|---|—|---|返回值：布爾值
—|---|—|isspace()
—|---|—|---|功能：檢測字符串是否由空白字符組成
—|---|—|---|格式:字符串.isspace()
—|---|—|---|返回值：布爾值
—|---|—|istitle()
—|---|—|---|功能：檢測字符串是否符合title()的結果
—|---|—|---|格式：字符串.istitle()
—|---|—|---|返回值:布爾值
—|---|—|split()
—|---|—|---|功能：將字符串按照指定字符進行切割操作
—|---|—|---|格式：字符串.split(切割指定字符串)
—|---|—|---|返回值：列表
—|---|—|splitlines()
—|---|—|---|功能：將字符串按照換行位置進行切割操作
—|---|—|---|格式：字符串.splitlines([結束符號])
—|---|—|---|返回值：列表
—|---|—|join()
—|---|—|---|功能：將列表中的內容按照指定字符連接成一個字符串
—|---|—|---|格式:連接字符串.join(列表)
—|---|—|---|返回值：字符串
—|---|—|zfill()
—|---|—|---|功能：在原有字符串長度不足指定長度時，用0填充
—|---|—|---|格式:字符串.zfill(指定長度)
—|---|—|---|返回值：字符串 不足的長度使用0填滿，原來的字符串內容靠右
—|---|—|center()
—|---|—|---|功能：指定字符串長度，并且使得元字符串內容居中，其余位置使用指定字符填充
—|---|—|---|格式: 字符串.center(指定長度[，填充字符])
—|---|—|---|返回值：字符串 填充字符默認空格，可以指定其他
—|---|—|ljust()
—|---|—|---|功能：指定字符串長度，并且使得元字符串內容靠左，其余位置使用指定字符填充
—|---|—|---|格式：字符串.ljust(指定長度[，填充字符])
—|---|—|---|返回值：字符串 填充字符默認空格，可以指定其他
—|---|—|rjust()
—|---|—|---|功能：指定字符串長度，并且使得元字符串內容靠右，其余位置使用指定字符填充
—|---|—|---|格式：字符串.rjust(指定長度[，填充字符])
—|---|—|---|返回值：字符串 填充字符默認空格，可以指定其他
—|---|—|strip()
—|---|—|---|功能：去掉左右2側的指定字符，默認空格
—|---|—|---|格式:字符串.strip([指定字符])
—|---|—|---|返回值：字符串
—|---|—|lstrip()
—|---|—|---|功能：去掉左側的指定字符，默認空格
—|---|—|---|格式:字符串.lstrip([指定字符])
—|---|—|---|返回值：字符串
—|---|—|rstrip()
—|---|—|---|功能：去掉右側的指定字符，默認空格
—|---|—|---|格式:字符串.rstrip([指定字符])
—|---|—|---|返回值：字符串
—|---|—|maketrans() 和 translate()
—|---|—|---|maketrans()
—|---|—|---|—|功能：制作用于字符串替換的映射表
—|---|—|---|—|格式: 字符串.maketrans(‘查找字符’,‘替換字符’) 兩個字符必須長度相等
—|---|—|---|—|返回值：字典
—|---|—|---|translate()
—|---|—|---|—|功能：進行字符串替換操作
—|---|—|---|—|格式：字符串.translate(映射表)
—|---|—|---|—|返回值：替換之后的字符串—|---|
—|---|牛刀小試-變形金剛
—|---|調試
—|---|問題解答
—|---|溫故知新,學以致用
—|字典
—|---|字典操作
—|---|—|以鍵值對方式存在的無序數據的組合就是字典
—|---|創建字典
—|---|—|創建空字典
—|---|—|---|方式1：
—|---|—|---|—|變量 = {}
—|---|—|---|方式2：
—|---|—|---|—|變量 = dict()
—|---|—|創建多個元素的字典
—|---|—|---|方式1：
—|---|—|---|—|變量 = {鍵:值,鍵:值…}
—|---|—|---|方式2：
—|---|—|---|—|變量 = dict({鍵:值,鍵:值…})
—|---|—|---|方式3：
—|---|—|---|—|變量 = dict(鍵=值,鍵=值…)
—|---|—|---|—|注意：該方式鍵作為形參名使用，不可以添加引號，必須符合變量規則
—|---|—|---|方式4：
—|---|—|---|—|變量 = dict([(鍵,值),(鍵,值)…])
—|---|—|---|—|變量 = dict([[鍵,值],[鍵,值]…])
—|---|—|---|—|變量 = dict(((鍵,值),(鍵,值)…))
—|---|—|---|方式5：
—|---|—|---|—|變量 = dict(zip((鍵，鍵…),(值,值…)))
—|---|字典的基本操作
—|---|—|訪問字典元素
—|---|—|---|變量[鍵]
—|---|—|添加字典元素
—|---|—|---|變量[新鍵] = 值
—|---|—|修改字典元素
—|---|—|---|變量[鍵] = 新值
—|---|—|刪除字典元素
—|---|—|---|del 變量[鍵]
—|---|字典的序列操作
—|---|—|成員檢測
—|---|—|---|格式：值 in 字典
—|---|—|---|—|檢測一個值是否在字典的鍵中
—|---|—|---|格式：值 not in 字典
—|---|—|---|—|檢測一個值是否不再字典的鍵中
—|---|序列函數
—|---|—|len()計算字典中元素的長度
—|---|—|max()獲取字典中最大的鍵
—|---|—|min()獲取字典中最大的值
—|---|—|dict()創建空字典或者將其他類型轉化字典
—|---|字典的遍歷
—|---|—|遍歷鍵
—|---|—|---|for 變量i in 字典:
—|---|—|---|—|#使用i遍歷所有的鍵，有鍵就可以通過變量訪問其值
—|---|—|遍歷鍵和值
—|---|—|---|for 變量i，變量j in 字典.items():
—|---|—|---|—|#使用變量i遍歷所有鍵，通過變量j遍歷所有值
—|---|字典內涵/字典推導式
—|---|—|普通的字典內涵
—|---|—|---|變量= {key:value for key,value in 字典.items()}
—|---|—|帶有判斷條件的字典內涵
—|---|—|---|變量= {key:value for key,value in 字典.items() if 條件表達式}
—|---|—|多個循環的字典內涵
—|---|—|---|變量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items()}
—|---|—|帶有判斷條件的多個循環的字典內涵
—|---|—|---|變量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items() if 條件表達式}
—|---|字典專用函數
—|---|—|clear()
—|---|—|---|功能：清空字典
—|---|—|---|格式：字典.clear()
—|---|—|---|返回值：None
—|---|—|---|注意：直接改變原有字典
—|---|—|copy()
—|---|—|---|功能：復制字典
—|---|—|---|格式：字典.copy()
—|---|—|---|返回值：新的字典
—|---|—|fromkeys()
—|---|—|---|功能：使用指定的序列作為鍵創建字典
—|---|—|---|格式：字典.fromkeys(序列,值)
—|---|—|---|返回值：字典
—|---|—|get()
—|---|—|---|功能：根據鍵獲取指定的值
—|---|—|---|格式：字典.get(鍵[，默認值])
—|---|—|---|返回值:值
—|---|—|---|注意:如果鍵不存在，則使用默認值,如果沒有默認值則返回None
—|---|—|items()
—|---|—|---|功能：將字典的鍵值轉化成類似元組的形式方便遍歷
—|---|—|---|格式：字典.items()
—|---|—|---|返回值：類似元組的類型
—|---|—|keys()
—|---|—|---|功能：將字典的所有鍵組成一個序列
—|---|—|---|格式：字典.keys()
—|---|—|---|返回值:序列
—|---|—|values()
—|---|—|---|功能：將字典的所有值組成一個序列
—|---|—|---|格式：字典.values()
—|---|—|---|返回值：序列
—|---|—|pop()
—|---|—|---|功能：移除字典中指定的元素
—|---|—|---|格式：字典.pop(鍵[,默認值])
—|---|—|---|返回值：被移除的鍵對應的值
—|---|—|---|注意：如果鍵不存在，則報錯，如果鍵不存在，默認值設置，則返回默認值
—|---|—|popitem()
—|---|—|---|功能：移除字典中的鍵值對
—|---|—|---|格式：字典.popitem()
—|---|—|---|返回值：鍵值對組成的元組
—|---|—|---|注意：彈一個原字典就少一個，字典為空就不可以彈出，會報錯
—|---|—|setdefault()
—|---|—|---|功能：添加一個元素
—|---|—|---|格式：字典.setdefault(鍵,值)
—|---|—|---|返回值:None
—|---|—|---|注意：添加是鍵存在則不進行任何操作，鍵不存在則添加，添加是不寫值，默認None值
—|---|—|update()
—|---|—|---|功能：修改字典中的值
—|---|—|---|方式1：
—|---|—|---|—|格式： 字典.update(鍵=值)
—|---|—|---|—|返回值：None
—|---|—|---|—|注意:此處的鍵作為關鍵字參數使用，不可以添加’’
—|---|—|---|方式2：
—|---|—|---|—|格式: 字典.update({鍵:值})
—|---|—|---|—|返回值：None
—|---|牛刀小試-字典合并與排序
—|---|調試
—|---|問題解答
—|---|溫故知新,學以致用
—|條件、循環和其他語句
—|---|使用文本編輯器
—|---|import使用
—|---|別樣的賦值
—|---|語句塊兒
—|---|順序結構和分支結構—|
—|---|—|流程控制
—|---|—|---|流程： 計算機執行代碼的順序，就是流程。
—|---|—|---|流程控制： 對計算機代碼執行順序的控制，就是流程控制。
—|---|—|---|流程分類： 流程控制一共分為三類，分別是 順序結構、分支(選擇)結構、循環結構。
—|---|—|順序結構
—|---|—|---|順序結構就是代碼一種自上而下執行的結構，這是Python默認的流程。
—|---|—|分支(選擇)結構
—|---|—|---|分支結構一共分為4類，分別是 單項分支、雙項分支、多項分支、巢狀分支
—|---|—|---|單項分支
—|---|—|---|—|格式：
—|---|—|---|—|---|if 1 < 5:
—|---|—|---|—|---|print(‘條件為真輸出我’)
—|---|—|---|—|特征：
—|---|—|---|—|---|1.if條件表達式結果為真，則執行if之后所控制的代碼組，如果為假，則不執行后面的代碼組
—|---|—|---|—|---|2.冒號:之后下一行的內容必須縮進，否則語法錯誤
—|---|—|---|—|---|3.if之后的代碼中如果縮進不一致，則可能縮進不一致的代碼不會受到if條件表達式的控制
—|---|—|---|—|---|4.冒號:后面的代碼是在條件表達式結果為真的情況下執行，所以稱之為真區間 或 if區間
—|---|—|---|雙項分支
—|---|—|---|—|格式：
—|---|—|---|—|---|if 1 < 5:
—|---|—|---|—|---|—|print(‘條件為真輸出我’)
—|---|—|---|—|---|else:
—|---|—|---|—|---|—|print(‘條件為假輸出我’)
—|---|—|---|—|特征：
—|---|—|---|—|---|1.雙項分支有兩個區間，分別是 True控制的if區間 和 False控制的else區間
—|---|—|---|—|---|2.if區間的內容在雙項分支中必須縮進，否則語法錯誤
—|---|—|---|多項分支
—|---|—|---|—|格式：
—|---|—|---|—|---|if 1 > 5:
—|---|—|---|—|---|—|print(‘如果1 > 5，我會被輸出’)
—|---|—|---|—|---|elif 9 < 8:
—|---|—|---|—|---|—|print(‘如果9 < 8，我會被輸出’)
—|---|—|---|—|---|else:
—|---|—|---|—|---|—|print(‘如果以上兩條都不成立，我會被輸出’)
—|---|—|---|—|特征：
—|---|—|---|—|---|1.多項分支可以添加無限個elif分支，無論如何，只會執行眾多分支的其中一個
—|---|—|---|—|---|2.執行完一個分支后，分支結構就會結束，后面的分支都不會判斷，也不會執行
—|---|—|---|—|---|3.多項分支的判斷順序是自上而下逐個分支進行判斷的。
—|---|—|---|巢狀分支
—|---|—|---|—|格式:
—|---|—|---|—|---|if 1 < 5:
—|---|—|---|—|---|—|print(‘1真的小于5哦’)
—|---|—|---|—|---|—|if 3 < 9:
—|---|—|---|—|---|—|---|print(‘如果3 < 9，我會被輸出’)
—|---|—|---|—|---|else:
—|---|—|---|—|---|—|print(‘如果上面條件不成立，我會被輸出’)
—|---|—|---|—|特征：
—|---|—|---|—|---|巢狀分支是其他他分支結構的嵌套結構，無論哪個分支都可以嵌套
—|---|循環
—|---|—|循環結構
—|---|—|---|循環結構可以減少源程序重復書寫的工作量(代碼量)，用來描述重復執行某段算法的問題，這是程序設計中最能發揮計算機特長的程序結構。
—|---|—|Python中循環結構分為兩類，分別是 while 和 for … in
—|---|—|while
—|---|—|---|格式1：
—|---|—|---|—|num1,num2 = 3,5
—|---|—|---|—|while num1 < num2:
—|---|—|---|—|---|print(‘如果條件成立，會進入循環體，我所處的這塊區域，就是循環體’)
—|---|—|---|—|---|num1 += 1 #控制循環條件中的變量，否則進入死循環
—|---|—|---|—|死循環： 死循環就是循環不會終止的循環類型，設置條件永遠為True來實現，但非常占用資源
—|---|—|---|格式2：
—|---|—|---|—|num1,num2 = 3,5
—|---|—|---|—|while num1 < num2:
—|---|—|---|—|---|print(‘如果條件成立，會進入循環體’)
—|---|—|---|—|---|num1 += 1
—|---|—|---|—|else:
—|---|—|---|—|---|print(‘條件不成立時，我會被輸出’)
—|---|—|---|—|注意： while循環中的else是在while條件表達式為假的情況下執行的代碼內容
—|---|—|for … in
—|---|—|---|for 變量 in 容器：用于遍歷容器類的數據(字符串，列表，元組，字典，集合)
—|---|—|---|格式1：
—|---|—|---|—|user_list = [‘小明’,‘小紅’,‘小強’,‘小軍’]
—|---|—|---|—|for val in user_list:
—|---|—|---|—|---|print(val)
—|---|—|---|格式2：
—|---|—|---|—|data = (‘a’,‘alibaba’),(‘b’,‘baidu’),(‘c’,‘changhong’)
—|---|—|---|—|for k,v in data:
—|---|—|---|—|---|print(k,’>’,v)
—|---|—|---|—|使用格式2請注意： 要求遍歷的容器必須是以下幾種格式
—|---|—|---|—|---|[(),(),()] 列表中有元組
—|---|—|---|—|---|[[],[],[]] 列表中有列表
—|---|—|---|—|---|((),(),()) 元組中有元組
—|---|—|---|—|---|{(),(),()} 集合中有元組
—|---|—|---|—|---|字典的特殊使用
—|---|—|---|格式3：
—|---|—|---|—|data = (‘a’,‘b’,‘c’,‘d’,‘e’)
—|---|—|---|—|for v in data:
—|---|—|---|—|---|print(v)
—|---|—|---|—|else:
—|---|—|---|—|---|print(‘我else區間又來啦！’)
—|---|—|---|—|循環結束時執行else區間的代碼
—|---|—|流程控制語句
—|---|—|---|break
—|---|—|---|—|翻譯：破壞，結束
—|---|—|---|—|作用：在循環中break的作用是終止當前循環結構的后續所有操作，一點程序運行了break，循環也就終止了。
—|---|—|---|continue
—|---|—|---|—|翻譯：繼續
—|---|—|---|—|作用：在循環中continue的作用是跳過本次循環，開始下一次循環。continue執行之后本次循環的后續代碼不再執行，直接進入下一次循環。
—|---|—|---|pass
—|---|—|---|—|翻譯：忽略
—|---|—|---|—|作用：pass是沒有任何意義的空語句，主要用來占位用，避免語法錯誤。—|
—|---|牛刀小試-猜字游戲編寫
—|---|調試
—|---|問題解答
—|---|溫故知新,學以致用
—|函數
—|---|調用函數
—|---|定義函數
—|---|函數的參數
—|---|執行流程
—|---|形參和實參
—|---|變量的作用域
—|---|有返回值和無返回值函數
—|---|為什么要有函數
—|---|返回函數
—|---|遞歸函數
—|---|匿名函數
—|---|偏函數
—|---|牛刀小試-經典排序之快速排序實現
—|---|調試
—|---|問題解答
—|---|溫故知新,學以致用
—|---|函數概念
—|---|—|在計算機中稱之為函數，在現實生活中稱之為功能。
—|---|—|函數是能夠實現特定功能的計算機代碼，它是一種特定的代碼組結構。
—|---|函數的作用
—|---|—|1.提高代碼的重復利用率，避免重復開發相同代碼
—|---|—|2.提高程序的開發效率
—|---|—|3.便于程序維護
—|---|函數名的命名規則，和變量基本一樣：
—|---|—|1.推薦使用英文，禁止使用中文
—|---|—|2.可以使用數字，但不能以數字開頭
—|---|—|3.不可以使用特殊字符，除了下劃線_
—|---|—|4.函數名嚴格區分大小寫
—|---|—|5.函數名必須要有意義
—|---|—|6.不能和系統保留關鍵字沖突
—|---|函數的定義
—|---|—|1.基本格式：
—|---|—|---|def 函數名():
—|---|—|---|—|pass
—|---|—|---|示例：
—|---|—|---|—|#定義函數
—|---|—|---|—|def funName():
—|---|—|---|—|---|pass #此處編寫功能代碼
—|---|—|---|—|funName() #調用
—|---|—|---|注釋：
—|---|—|---|—|函數的特征：函數定義之后，不會自動執行，只會在調用的時候執行。不調用，不執行。
—|---|—|2.帶有參數的格式：
—|---|—|---|def 函數名(參數1，參數2…):
—|---|—|---|—|pass
—|---|—|---|示例：
—|---|—|---|—|#定義帶有參數的函數
—|---|—|---|—|def funName(arg):
—|---|—|---|—|---|print(‘接收到的參數：’,arg)
—|---|—|---|—|funName(666) #調用
—|---|—|---|注釋：
—|---|—|---|—|形參：形式上的參數，聲明函數時，括號()中的參數，是形參。
—|---|—|---|—|實參：實際上的參數，調用函數是，括號()中的參數，是實參。
—|---|—|---|—|實參將值傳遞給形參的本質過程，本質上就是簡單的變量賦值。
—|---|—|3.帶有默認值的參數的格式：
—|---|—|---|def 函數名(參數1 = 值1,參數2 = 值2…):
—|---|—|---|—|pass
—|---|—|---|示例：
—|---|—|---|—|#定義帶有默認值參數的函數
—|---|—|---|—|def funName(arg = ‘jack’):
—|---|—|---|—|---|print(‘參數值：’,arg)
—|---|—|---|—|funName() #調用方式一
—|---|—|---|—|funName(‘mark’) #調用方式二 調用時傳的參數會覆蓋默認值
—|---|—|---|注釋：
—|---|—|---|—|如果形參有默認值，調用時可以不需要傳參，系統會直接使用參數的默認值。
—|---|—|---|—|調用時給有默認值的參數傳參，實參會覆蓋形參的默認值。本質上就是變量的重新賦值。
—|---|—|4.使用關鍵字參數格式：
—|---|—|---|函數名(形參1 = 實參1,形參2 = 實參2…)
—|---|—|---|示例：
—|---|—|---|—|#定義帶有默認值參數的函數
—|---|—|---|—|def funName(name = ‘jack’,age = 18,sex = ‘man’):
—|---|—|---|—|print(‘name:’,name)
—|---|—|---|—|print(‘age:’,age)
—|---|—|---|—|print(‘sex:’,sex)
—|---|—|---|—|funName(8,‘二狗’,‘Superman’) #參數較多時賦值順序顛倒，將會影響程序執行結果
—|---|—|---|—|funName(age = 8,name = ‘二狗’,sex = ‘Superman’) #關鍵字參數賦值完美解決上面的問題
—|---|—|---|注釋：
—|---|—|---|—|關鍵字參數就是調用函數時，在實參前面指定形參的做法，為了防止參數按照位置傳遞出現的錯誤。
—|---|—|5.收集參數使用方法：
—|---|—|---|收集參數可以收集的參數不受數量限制
—|---|—|---|1）非關鍵字收集參數
—|---|—|---|—|def 函數名(*參數名):
—|---|—|---|—|---|pass
—|---|—|---|—|示例：
—|---|—|---|—|---|#定義帶有非關鍵字收集參數的函數
—|---|—|---|—|---|def funName(arg):
—|---|—|---|—|---|—|for v in arg: #遍歷
—|---|—|---|—|---|—|---|print(v)
—|---|—|---|—|---|funName(1,2,3,‘a’,‘b’,‘c’) #調用
—|---|—|---|—|注釋：
—|---|—|---|—|---|1.非關鍵字收集參數，在形參前添加一個即可
—|---|—|---|—|---|2.非關鍵字收集參數，收集的實參會組成一個元組
—|---|—|---|—|---|3.非關鍵字收集參數，接受沒有任何形參接受的非關鍵字實參
—|---|—|---|—|---|4.非關鍵字收集參數，可以和普通的形參共存
—|---|—|---|2) 關鍵字收集參數
—|---|—|---|—|def 函數名(**參數名):
—|---|—|---|—|---|pass
—|---|—|---|—|示例：
—|---|—|---|—|---|#定義帶有關鍵字收集參數的函數
—|---|—|---|—|---|def funName(*car):
—|---|—|---|—|---|—|for v in car: #遍歷
—|---|—|---|—|---|—|---|print(v,'value : ',car[v])
—|---|—|---|—|---|funName(a = ‘卡車’,b = ‘火車’,c = ‘公交車’) #調用
—|---|—|---|—|注釋：
—|---|—|---|—|---|1.關鍵字收集參數，在形參前添加兩個
—|---|—|---|—|---|2.關鍵字收集參數，收集的實參會組成一個字典，形參名作為鍵，值作為值
—|---|—|---|—|---|3.關鍵字收集參數，僅接收沒有任何形參接收的關鍵字參數
—|---|—|---|—|---|4.關鍵字收集參數，可以和普通的形參共存
—|---|—|---|—|多種參數混合使用應當注意的 定義函數時盡量避免多種參數格式混合(普通參數，關鍵字參數，兩種收集參數)
—|---|—|---|—|---|1.普通參數和關鍵字參數必須在兩種收集參數之前
—|---|—|---|—|---|2.非關鍵字收集參數，必須在關鍵字收集參數之前
—|---|—|---|—|---|3.如果多種參數混合在一起用，必須注意禁止參數多次賦值操作(普通參數賦值在前，關鍵字參數賦值在后)
—|---|函數的返回值
—|---|—|根據執行函數完畢是否可以得到一個結果，我們可以將函數分為兩種類型。
—|---|—|---|執行過程函數：
—|---|—|---|—|函數執行完畢之后，接收不到任何返回結果的函數。如：print()
—|---|—|---|具有返回值得函數：
—|---|—|---|—|函數執行完畢之后，會產生一個結果，可以被接收和使用的函數。如：type()
—|---|—|格式：
—|---|—|---|def 函數名(參數…):
—|---|—|---|—|Python code…
—|---|—|---|—|return 返回值 #有return的函數，就是有返回值的函數
—|---|—|---|變量名 = 函數名(參數…) #我們可以通過一個變量去接收函數的返回值
—|---|—|注釋：
—|---|—|---|1.具有return語句的函數，我們稱之為具有返回值的函數
—|---|—|---|2.return可以為當前函數執行完畢的函數返回一個結果，這個返回值可以用變量接收
—|---|—|---|3.return執行之后，函數將會終止，所以return之后的語句是不會被執行的
—|---|—|---|4.一個函數可以使用多個return語句，但是只有一個會被執行，一般都是放入分支結構中
—|---|—|---|5.一個函數如果需要返回多個數據，使用復合數據類型(list,tuple,set,dict)來操作即可
—|---|遞歸函數
—|---|—|在函數內調用當前函數本身的函數就是遞歸函數
—|---|—|定義遞歸函數
—|---|—|---|#定義一個遞歸函數
—|---|—|---|def tubie(num):
—|---|—|---|—|#1.輸出num
—|---|—|---|—|print(num)
—|---|—|---|—|#2.判斷條件，不改變num
—|---|—|---|—|if num >0:
—|---|—|---|—|---|tubie(num-1)
—|---|—|---|—|else:
—|---|—|---|—|---|print(’==========’)
—|---|—|---|—|#3.輸出num
—|---|—|---|—|print(num)
—|---|—|#調用遞歸函數
—|---|—|---|tubie(3)—|
—|面向對象編程
—|---|理解面向對象
—|---|類的定義和使用
—|---|深入類
—|---|繼承
—|---|多態
—|---|封裝
—|---|多重繼承
—|---|獲取對象信息
—|---|類的專有方法
—|---|牛刀小試-出行建議
—|---|調試
—|---|問題解答
—|---|溫故知新,學以致用
—|---|面向對象 Object Oriented
—|---|—|面向對象的學習：
—|---|—|---|面向對象的語法（簡單，記憶就可以搞定）
—|---|—|---|面向對象的思想（稍難，需要一定的理解）
—|---|面向過程和面向對象的區別
—|---|—|面向過程開發，以函數作為基本結構使用：
—|---|—|---|吃飯 -> 吃飯的函數
—|---|—|---|喝水 -> 喝水函數
—|---|—|---|洗衣服 -> 洗衣服的函數
—|---|—|---|睡覺 -> 使用充氣娃娃的函數
—|---|—|---|看電影 -> 買票開電影函數
—|---|—|面向對象的開發，以對象作為基本結構使用： 女朋友{ 喂飯功能 喂水功能 洗衣服功能 陪你睡覺功能 陪你看電影功能 … }
—|---|—|---|吃飯->調用女盆友的喂飯功能
—|---|—|---|喝水->調用女朋友的喂水功能
—|---|—|---|洗衣服->調用女朋友的洗衣服功能
—|---|—|---|睡覺->調用女朋友的陪睡功能
—|---|—|面向對象的開發非常適合大型程序開發，開發速度和后期維護都比過程化開發要好很多。同時，也會降低一點效率。
—|---|—|語言中對象結構的特色：高內聚，低耦合。
—|---|面向對象相關的單詞：
—|---|—|OO 面向對象
—|---|—|OOP 面向對象的程序開發
—|---|—|OOA 面向對象的分析
—|---|—|OOD 面向對象的設計
—|---|—|OOI 面向對象的實現
—|---|—|OOA -> OOD -> OOI 面向對象的實現過程
—|---|類和對象
—|---|—|什么是類
—|---|—|---|人類就是一個類
—|---|—|---|動物類也是一個類
—|---|—|---|鳥類就是一個類
—|---|—|---|女朋友也是一個類
—|---|—|---|基友也是一個類
—|---|—|---|瓶子都是一個類
—|---|—|---|類是一個實物的特征的集合，是抽象的概念。
—|---|—|---|打蛋蛋是一個類
—|---|—|---|XXOO也是一個類
—|---|—|---|撩妹也是一個類
—|---|—|---|開車也是一個類
—|---|—|---|打人也是一個類
—|---|—|---|類也是行為和操作的概念的集合。也是不具體的操作，沒有真正操作過。
—|---|—|---|類是抽象的概念，僅此而已！
—|---|—|什么是對象
—|---|—|---|霍云瑞這個人他是一個對象
—|---|—|---|霍云瑞家的那個小雞雞是一個對象
—|---|—|---|霍云瑞的第一個女朋友就是一個對象
—|---|—|---|霍云瑞的當前的基友就是一個對象
—|---|—|---|這個瓶子就是一個對像。
—|---|—|---|教室后面那個空調就是一個對象。
—|---|—|---|對象就是具體存在的看得見摸得著的某個實物。
—|---|—|---|昨天霍云瑞打一次自己的蛋蛋，就是一個對象
—|---|—|---|今天中午霍云瑞吧馬浚龍XXOO了就是一個對象
—|---|—|---|今天上午霍云瑞吧馬俊龍撩了就是一個對象
—|---|—|---|馬俊龍今天晚上把霍云瑞打了，這就是一個對象
—|---|—|---|真實發生過得行為就是對象
—|---|—|---|對象一定是具體的或者發生過的事物！
—|---|類和對象的關系
—|---|—|類是多個對象歸納總結而來的，是一種概念，包含所有對象。
—|---|—|---|由對象總結出類的過程，叫做抽象化
—|---|—|對象是類的具體實現或者實施而來，他是真實的，特指某個事物
—|---|—|---|由類制作出對象的過程，叫做實例化
—|---|如何書寫類文件
—|---|—|推薦使用駝峰命名法來書寫文件：
—|---|—|駝峰命名法：
—|---|—|---|類名：每個單詞的首字母大寫
—|---|—|---|—|人類 Person
—|---|—|---|—|開車 DriveCar
—|---|—|---|—|撩妹 LiaoMei
—|---|—|---|函數名/變量：除了第一個單詞之外首字母大寫
—|---|—|---|—|瀧澤蘿拉 longZeLuoLa
—|---|—|---|—|約炮函數 yuePao 或者yue_pao（不是駝峰命名）
—|---|—|一個文件如果是一個單獨的類，那么直接使用類名來當作文件名即可
—|---|類的組成
—|---|—|類中只有2種內容：成員屬性和成員方法
—|---|—|成員屬性:
—|---|—|---|用于描述類的特征的變量就是成員屬性
—|---|—|成員方法：
—|---|—|---|用于描述類的功能的函數就是成員方法
—|---|類的書寫規則
—|---|—|1.必須使用class關鍵字來聲明一個類
—|---|—|2.類的名稱需要符合駝峰命名法（規范）
—|---|—|3.類中只能存在2種內容，成員屬性和成員方法，除此之外，所有的代碼都禁止出現！
—|---|—|4.聲明成員屬性時，所有成員屬性必須有值，如果沒值會報錯！，推薦使用None等值代替
—|---|—|5.成員方法只需要按照函數的規則聲明即可
—|---|實例化對象
—|---|—|實例化對象格式
—|---|—|---|對象變量 = 類()
—|---|—|類的類型為 type
—|---|—|---|<class ‘type’>
—|---|—|類的值就是類本身
—|---|—|---|<class ‘main.Person’>
—|---|—|對象的類型為類
—|---|—|---|<class ‘main.Person’>
—|---|—|對象的值，對象本身
—|---|—|---|<main.Person object at 0x020DC650>
—|---|檢測類和對象的成員
—|---|—|檢測類成員
—|---|—|---|類名.dict
—|---|—|檢測對象成員
—|---|—|---|對象.dict
—|---|類和對象成員的操作
—|---|—|類成員操作
—|---|—|---|訪問類中成員
—|---|—|---|—|類名.成員屬性名
—|---|—|---|—|類名.成員方法名() （沒有參數要求，所有方法都可以通過類訪問）
—|---|—|---|修改類中成員
—|---|—|---|—|類名.成員屬性名 = 值
—|---|—|---|—|類名.成員方法名 = 新值 （如果需要函數只能用lambda）
—|---|—|---|刪除類中成員
—|---|—|---|—|del 類名.成員屬性名
—|---|—|---|—|del 類名.成員方法名
—|---|—|---|添加類中成員
—|---|—|---|—|類名.新成員屬性名 = 值
—|---|—|---|—|類名.新成員方法名 = 值 （如果需要函數只能用lambda）
—|---|—|對象成員操作
—|---|—|---|訪問對象中成員
—|---|—|---|—|對象變量.成員屬性名
—|---|—|---|—|對象變量.成員方法名() （必須有一個用于接收對象本身的形參）
—|---|—|---|修改對象中成員
—|---|—|---|—|對象變量.成員屬性名 = 值
—|---|—|---|—|對象變量.成員方法名 = 新值 （如果需要函數只能用lambda）
—|---|—|---|刪除對象中成員
—|---|—|---|—|del 對象變量.成員屬性名
—|---|—|---|—|del 對象變量名.成員方法名
—|---|—|---|添加對象中成員
—|---|—|---|—|對象變量.新成員屬性名 = 值
—|---|—|---|—|對象變量.新成員方法名 = 值 （如果需要函數只能用lambda）
—|---|關于self
—|---|—|他不是關鍵字，是一個隨意書寫的字符串而已
—|---|—|1.英文單詞的意義 ：自己
—|---|—|2.綁定類的方法，只能通過類來訪問的方法，就是綁定類的方法
—|---|—|3.非綁定類的方法，就是可以通過對象訪問的方法就是非綁定的方法
—|---|—|4.綁定類與非綁定類的方法不取決于語法，而取決于設計者如何設計該方法
—|---|—|5.一般情況下非綁定類的方法第一個參數寫單詞self，但是這不是唯一的單詞，寫什么都行，self不是關鍵字，不是關鍵字，不是關鍵字！
—|---|面向對象的三大特性
—|---|—|面向對象都具有三大特性：封裝，繼承 和 多態
—|---|—|封裝特性
—|---|—|---|封裝就是對類和對象的成員訪問進行限制，設定可以訪問的方式和不可以訪問的方式。
—|---|—|---|封裝的三個級別：
—|---|—|---|—|私有化封裝 -> private 英文單詞而已不是關鍵字
—|---|—|---|—|受保護的封裝 -> protected 英文單詞而已不是關鍵字
—|---|—|---|—|公共的封裝 -> public 英文單詞而不是關鍵字
—|---|—|---|檢測封裝的三個位置：
—|---|—|---|—|類中/對象中
—|---|—|---|—|類外部/對象外部
—|---|—|---|—|子類中
—|---|—|---|私有化封裝 private
—|---|—|---|—|私有化封裝是最高級別的封裝。私有化封裝之后的成員,只能在類中/對象中訪問，類的外部，子類中都不可以訪問到。
—|---|—|---|—|私有化封裝：在成員名稱前添加2個_即可
—|---|—|---|—|例如：封裝heart -> __heart
—|---|—|---|—|python將heart 改名為 _類名__成員名
—|---|—|---|—|封裝后的訪問限制：
—|---|—|---|—|---|類中/對象中 可以訪問
—|---|—|---|—|---|類外/對象外 不可以訪問
—|---|—|---|—|---|子類/子類對象 不可以訪問
—|---|—|---|—|注意：在python中實現的封裝操作，不是通過權限限制而是通過改名(name mangling 改名策略)實現的，名字變了找不到而已。
—|---|—|---|—|可以通過 對象.類名 __方法或類名.類名 __方法名訪問到（但禁止這么干）
—|---|—|---|受保護的封裝 protected
—|---|—|---|—|受保護的封裝是一定級別的封裝，封裝之后，只有部分位置可以訪問（類和子類），部分位置（類外）不可以訪問。
—|---|—|---|—|受保護的封裝： 在成員名稱前添加1個_即可
—|---|—|---|—|例如:受保護 money -> _money
—|---|—|---|—|封裝后的訪問限制：
—|---|—|---|—|---|類中/對象中 可以訪問
—|---|—|---|—|---|類外/對象外 可以訪問（原則上類外不行，但是沒實現）
—|---|—|---|—|---|子類/子類對象 可以訪問
—|---|—|---|公共的封裝 public
—|---|—|---|—|所有的成員默認都是公共的封裝級別，可以在類中，類外，及子類中正常訪問
—|---|—|---|—|類中/對象中 可以訪問
—|---|—|---|—|類外/對象外 可以訪問
—|---|—|---|—|子類/子類對象 可以訪問
—|---|—|繼承
—|---|—|---|繼承就是可以獲取另外一個類中的成員屬性和成員方法。(并非所有成員)
—|---|—|---|作用：
—|---|—|---|—|繼承的作用是增加代碼的復用性，節省不必要的重復代碼，提高開發效率，同時可以設置類之間的關系。
—|---|—|繼承的兩個概念：
—|---|—|---|父類
—|---|—|---|—|用于被繼承的類，稱之為父類，也叫做基類，或者超類
—|---|—|---|子類
—|---|—|---|—|繼承其他類的類，稱之為子類，也叫做派生類
—|---|—|繼承的格式
—|---|—|---|class 父類：
—|---|—|---|—|pass
—|---|—|---|class 子類(父類)：#繼承操作的關鍵步驟
—|---|—|---|—|pass
—|---|—|繼承的特征
—|---|—|---|1.所有類都是繼承自object類（object類對應的對象就是object對象，也是萬物皆對象）
—|---|—|---|2.子類繼承父類則可以訪問父類的所有成員。（私有成員除外）
—|---|—|---|3.子類繼承父類并不會將父類的所有成員復制到子類當中去，訪問父類成員是間接通過父類來訪問的，
—|---|—|---|4.子類可以具有自己獨有的屬性和方法
—|---|—|---|5.子類可以重載父類中的方法，只需要設置和父類指定成員相同的名稱即可實現重載，重載之后的成員，子類只會訪問當前類中的成員，而不會調用父類中同名的成員
—|---|—|---|6.子類中如果重載父類的方法，并且還想將重載的父類方法借調過來使用，可以在重載的方法中使用如下方法
—|---|—|---|—|父類名.方法() 或者 super().方法()
—|---|—|單繼承和多繼承
—|---|—|---|單繼承：每個類只能繼承一個類的方式稱為單繼承。
—|---|—|---|多繼承：每個類可以同時繼承多個類的方式稱為多繼承。
—|---|—|---|python屬于多繼承語言！但是一般不用
—|---|—|多繼承格式：
—|---|—|---|class 父類1:
—|---|—|---|—|pass
—|---|—|---|class 父類2:
—|---|—|---|—|pass
—|---|—|---|class 子類(父類1,父類2)：
—|---|—|---|—|pass
—|---|—|---|多繼承之后，子類就具備了所有父類的成員（私有成員除外）
—|---|—|---|多個父類具有相同的成員時，子類繼承[繼承列表]中第一個類的方法
—|---|—|菱形繼承/鉆石繼承
—|---|—|---|菱形繼承格式
—|---|—|---|class A:
—|---|—|---|—|pass
—|---|—|---|class B(A):
—|---|—|---|—|pass
—|---|—|---|class C(A):
—|---|—|---|—|pass
—|---|—|---|class D(B,C):
—|---|—|---|—|pass
—|---|—|---|—|A
—|---|—|---| /
—|---|—|---| B C
—|---|—|---| \ /
—|---|—|---|—|D
—|---|—|---|菱形繼承存在的問題
—|---|—|---|—|如果BC類同時繼承了A類，D類又繼承了BC兩個類的情況下(菱形繼承)，
—|---|—|---|—|在調用BC中某個同名方法(該方法都繼承自A類)時會導致繼承自A類的該方法被多次調用。產生邏輯問題！
—|---|—|---|—|所以python使用 super() 類來解決了多繼承的菱形繼承問題
—|---|—|MRO列表
—|---|—|---|Method Realtion Order 用來制作一個繼承關系的列表
—|---|—|---|python3中使用C3算法來計算MRO列表（計算過程暫時忽略）
—|---|—|---|MRO列表的制作原則：
—|---|—|---|—|1.子類永遠在父類的前面
—|---|—|---|—|2.如果繼承了多個父類，那么按照()中的順序在列表中擺放
—|---|—|super()
—|---|—|---|super不是一個關鍵字,也是不是有函數,他是一個類
—|---|—|---|super()的作用不是查找父類，而是找MRO列表的上一個類
—|---|—|---|super()和父類沒有任何實質性的關系，只是有時候能調用到父類而已。
—|---|—|---|在單繼承的情況下，super()永遠調用的是父類/父對象
—|---|—|---|格式：
—|---|—|---|—|super().方法() #python3的格式
—|---|—|---|多繼承按需操作，在沒有必要的時候避免強行使用!
—|---|—|mixin 設計模式
—|---|—|---|該設計模式的主要作用是采用多繼承方式，進行類的擴展。
—|---|—|---|優點：
—|---|—|---|—|1.mixin可以在對類不做任何修改的情況下，擴展類的功能（添加父類）
—|---|—|---|—|2.可以方便的組織和維護各種不同組件的劃分。
—|---|—|---|—|3.可以根據需要任意調整
—|---|—|---|—|4.可以避免創建更多的類，也可以避免繼承導致的混亂
—|---|—|---|示例：
—|---|—|---|—|#水果類
—|---|—|---|—|class Fruit:
—|---|—|---|—|---|pass
—|---|—|---|—|#禮物類和非禮物類
—|---|—|---|—|class Gift:
—|---|—|---|—|---|pass
—|---|—|---|—|class NotGift:
—|---|—|---|—|---|pass
—|---|—|---|—|#南方北方類
—|---|—|---|—|class South:
—|---|—|---|—|---|pass
—|---|—|---|—|class North:
—|---|—|---|—|---|pass
—|---|—|---|—|#爽和不爽的蘋果
—|---|—|---|—|class Cool:
—|---|—|---|—|---|pass
—|---|—|---|—|class NotCool:
—|---|—|---|—|---|pass
—|---|—|---|—|#真實水果類
—|---|—|---|—|class Apple(Fruit,Gift,North,NotCool):
—|---|—|---|—|---|pass
—|---|—|---|—|class Pear(Fruit,NotGift,North,NotCool):
—|---|—|---|—|---|pass
—|---|—|---|—|class Banana(Fruit,NotGift,North,Cool):
—|---|—|---|—|---|pass
—|---|—|---|—|class Orange(Fruit,Gift,South,NotCool)—|
—|異常
—|---|什么是異常
—|---|異常處理
—|---|拋出異常
—|---|捕捉異常
—|---|捕捉多個異常
—|---|使用一個塊捕捉多個異常
—|---|捕捉對象
—|---|全捕捉
—|---|異常中的else
—|---|自定義異常
—|---|finally子句
—|---|異常和函數
—|---|牛刀小試-正常數和異常數
—|---|bug的由來
—|---|溫故知新,學以致用
—|日期和時間
—|---|日期和時間
—|---|time模塊
—|---|datetime模塊
—|---|日歷模塊
—|---|牛刀小試-時間大雜燴
—|---|調試
—|---|問題解答
—|---|溫故知新,學以致用
—|正則表達式
—|---|認識正則表達式
—|---|re模塊
—|---|貪婪模式和非貪婪模式
—|---|替換
—|---|編譯
—|---|牛刀小試-匹配比較
—|---|溫故之心,學藝之用
—|文件操作
—|---|打開文件
—|---|基本文件方法
—|---|對文件內容進行迭代
—|---|StringIO函數
—|---|序列化與反序列化
—|---|牛刀小試-批量更改文件名
—|---|調試
—|---|問題解答
—|---|溫故之心,學藝之用
—|多線程
—|發送和接收電子郵件
—|網絡編程
—|GUI編程
—|操作數據庫
—|項目實戰-爬蟲
—|自然語言分詞與詞頻統計
—|區塊鏈實戰
—|附錄

總結

以上是生活随笔為你收集整理的python3.7知识点汇总的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。