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

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。