目錄
很多小伙伴可能都沒有看過凡哥的視頻，所以大家可能對凡哥不是很了解這里先和大家來個自我介紹
凡哥我已經有著十二年互聯網自動化測驗和測驗開發工程師，擁有豐富的自動化測驗平臺及測驗開發經驗，擅長介面測驗、Python自動化全堆疊，測驗開發平臺等，參與過億級用戶金融系統測驗開發平臺架構以及開發，曾主導過多家一線互聯網公司自動化測驗平臺或自動化測驗框架的搭建，參與專案涵蓋金融、電商、教育等多個行業，好就介紹這么多，接下來就開始正題廢話少說讓我們開始把
【第一小節：python pycharm 安裝】
一.python安裝
二.配置環境變數
三，驗證一下
四，安裝pycharm
五，更換下載源
六，更新pip
七，PyCharm配置
【第二小節：selenium +python環境搭建】
一、selenium簡介
二、python安裝
三、配置環境變數
1. 搜索環境變數
2. 在System Properties視窗中找到Environment Variables并點擊此按鈕，
3. 編輯System variables中的Path（可雙擊打開編輯視窗，也可選中Path后點擊Edit按鈕打開編輯視窗），
四、安裝selenium
五、瀏覽器
1. 安裝瀏覽器，并根據瀏覽器版本下載對應的瀏覽器驅動，將驅動檔案放到python根目錄，
六、最終驗證自動化環境是否配置成功
【第三小節：python環境變數】
1.變數是什么？
2.宣告變數
3.變數定義的規則
4.常量
5.注釋
6.Python的基礎資料型別
7.判斷變數是什么資料型別
【第四小節：python IDLE使用方法詳解】
1.簡介
在代碼編輯區中，撰寫多行代碼，例如，輸出由宋詞《江城子》改編而成的《程式員之歌》，代碼如下：
按下快捷鍵
運行程式后，將打開 Python Shell 視窗顯示運行結果，
【第五小節：Python集成開發環境Pycharm+Git+Gitee】
一、環境介紹
二、環境搭建
1）注冊碼云賬戶，創建代碼遠端倉庫
2）安裝Git，可以自己去官網下載 https://git-scm.com/ 或者百度云盤提取，直接下一步安裝至結束，滑鼠右擊桌面出現Git GUI Here和Git Bash Here則說明安裝成功！
3）Pycharm 配置Git
4）代碼托管到遠端倉庫碼云
【第六小節：Python基礎語法】
一，語法
二、編譯器
三、基礎知識
1、資料型別
2、條件判斷
if陳述句可以通過判斷條件是否成立來決定是否執行某個陳述句
3、回圈陳述句
for回圈
while回圈
4、運算子
邏輯運算子
比較運算子
算術運算子
布爾運算子
四、類和函式
函式
函式引數
特殊函式
匿名函式：用在那些只使用一次的場景中，程式中只需要呼叫一次某個簡單邏輯，
類
初始化變數
類的繼承
多繼承
高級面向物件
魔法方法
迭代器協議
生成器和裝飾器
內置裝飾器
五、常用操作
格式化操作
format方法
常用函式
例外資訊
六、檔案管理
檔案讀寫
OS模塊
sys模塊
七、模塊和包
模塊
導包
【第七小節：python（變數型別）】
序
變數賦值
多個變數賦值
標準資料型別
number
string（字串）
list（串列） （用【】）
tuple（元組）（不能二次賦值）（用（））
dictionary （字典）（用{}）
Python資料型別轉換
【第八小節：Python資料型別轉換】
一 自動型別轉換
二 強制型別轉換
2.1 把資料強制轉換成整型 int
2.2 float (整型 浮點型 布爾型別 純數字字串)
2.3 bool型別
三 容器型別資料的強制型別轉換
3.1 str 強轉成字串型別
3.2 list 串列
3.3 tuple 元組
3.4 set 集合
3.5 二級容器
3.6 字典的強制型別轉換
【第九小節：Python 內置函式]
分類
按引數和回傳值分類
按來源分類
內置函式
【第十小節：python運算子】
什么是運算子
1、算術運算子
2、比較運算子
3、賦值運算子
4、位運算子
5、邏輯運算子
6、成員運算子
7、身份運算子
運算子優先級
【第十一小節：python流程控制】
1、概念
2、執行流程的三種情況
3、必知必會
if語法
1、單分支（單if）
2、雙分支（if 和else一起使用）
3、多分支（if、elif以及else共同使用）
4、if嵌套
小練習
while回圈
1、語法
2、基本用法示例
3、while+break
4、全域標志位
5、while嵌套
案例
6、while+continue
7、while+else
8、死回圈
for回圈
1、語法
演示
2、range關鍵字
3、for+break
4、for+continue
5、for+else
6、for回圈嵌套
【第一小節：python pycharm 安裝】
凡哥有話bb：如果想要安裝包，學習資料，教學視頻，有關于不懂的技術類問題的小伙伴也可以找到我們的蓓蓓小姐姐微信：【mashang-qq】備注【csdn000】【必須備注不然不會通過哦】我們還有大佬在線答疑群
群號：【913569736】（備注“csdn000”）群里的免費資料都可以找蓓蓓小姐姐領取，還有同行大神一起交流技術哦，
一.python安裝
小伙子踏入python門，從此python人，加油打工人
?
?
?
?
二.配置環境變數
?
?
三，驗證一下
?
?
四，安裝pycharm
?
五，更換下載源
?
試一下安裝numpy
?
六，更新pip
說明pip可以更新
?
進行更新操作命令
?
七，PyCharm配置
?
?
?
?
更換一下字體大小
?
感謝每一個認真閱讀我文章的人，看著粉絲一路的上漲和關注，禮尚往來總是要有的，雖然不是什么很值錢的東西，如果你用得到的話可以直接拿走：
① 2000多本Python電子書（主流和經典的書籍應該都有了）
② Python標準庫資料（最全中文版）
③ 專案原始碼（四五十個有趣且經典的練手專案及原始碼）
④ Python基礎入門、爬蟲、web開發、大資料分析方面的視頻（適合小白學習）
⑤ Python學習路線圖（告別不入流的學習）
在我的QQ技術交流群里（技術交流和資源共享，廣告進來腿給你打斷）
可以自助拿走，群號913569736（備注“csdn000”）群里的免費資料都是筆者十多年測驗生涯的精華，還有同行大神一起交流技術哦，
作者有話bb：
這篇文章寫的是關于python的安裝，下一咱們正式開始說selenium+python的環境搭建以及環境變數的原理，從最基礎python環境搭建以及環境變數的原理來學習，慢慢的積累，從0開始，凡哥相信各位一定會有所識訓，
人生格言：學習不是記錄表象，而是掌握本質
【第二小節：selenium +python環境搭建】
一、selenium簡介
Selenium 是用于測驗 Web 應用程式用戶界面 (UI) 的常用框架，它是一款用于運行端到端功能測驗的超強工具，支持的瀏覽器包括IE（7, 8, 9, 10, 11），Mozilla Firefox，Safari，Google Chrome，Opera，Edge等，
Selenium的發展經歷了三個階段，第一個階段，也就是selenium1的時代，在運行selenium1.0程式之前，我們得先啟動selenium server端(selenium remote control)，我們簡稱RC，RC主要包括三個部分：launcher，http proxy，selenium core，其中selenium core是被selenium server嵌入到瀏覽器頁面中的，selenium core內部是一堆javascript函式構成，通過呼叫這些函式來實作對瀏覽器的各種操作，
很顯然比較繁瑣，這并不是最佳自動化解決方案，于是后來有了webdriver，
selenium2 的時代合并了webdriver，也就是我們通常說的selenium，selenium2是默認支持Firefox瀏覽器的，這點非常方便，當然也支持其他更多瀏覽器，Ie和chrome瀏覽器需要下載驅動包，并添加到環境變數下
selenium3 是2016年十月份左右出來的，并且現在默認安裝都是selenium3了，selenium3在selenium2的基礎上做了一些調整，最明顯的區別就是 selenium2對Firefox的支持最高只支持46及以下版本，selenium3可以支持47以上版本，但是需要下載geckodriver.exe驅動，并添加到環境變數path下，
二、python安裝
下載最開始說到了，詳情請看文章開頭
1. 下載完成后，直接安裝即可，安裝程序中可選擇自己的安裝路徑（注意安裝路徑要記得，后續配置環境變數用到），
三、配置環境變數
中文的環境變數配置路徑：搜索到環境變數 -> 雙擊環境變數中的Path -> 點擊新建按鈕，把python的安裝路徑復制上，點擊確定按鈕即可完成環境變數編輯，
1. 搜索環境變數
?
2. 在System Properties視窗中找到Environment Variables并點擊此按鈕，
?
3. 編輯System variables中的Path（可雙擊打開編輯視窗，也可選中Path后點擊Edit按鈕打開編輯視窗），
?
4. 點擊Edit environment variable的New按鈕添加ptyhon的安裝路徑（python的安裝路徑即python.exe所在路徑，對應python安裝中第3步驟的路徑），點擊OK保存環境變數配置，
5. 檢查環境python環境變數是否配置成功：
A、win + R 或在windows的搜索框搜索cmd，打開DOS視窗，
B、輸入python，回車，假如出現python版本等資訊即說明python安裝成功且環境變數配置成功，
?
四、安裝selenium
1.WIN+R打開DOS視窗輸入：pip(如果有內容顯示，說明正常)
2.cmd輸入指令安裝selenium：pip install selenium
注釋：如果想安裝指定版本的selenium 則可吧輸入的命令改為pip install selenium==3.141.0，其中“==”后面是對應的版本號，
3.驗證selenium是否正常作業
1）在DOS視窗輸入命令：python
2）在進入命令列后輸入命令：from selenium import webdirver
假如沒有出現報錯資訊，則證明selenium可正常作業，
?
五、瀏覽器
1. 安裝瀏覽器，并根據瀏覽器版本下載對應的瀏覽器驅動，將驅動檔案放到python根目錄，
如下圖，有Chrome和Edge的對應瀏覽器驅動，
?
六、最終驗證自動化環境是否配置成功
1.創建python檔案，運行如下代碼，確認是否能成功打開瀏覽器，
1 # coding: utf-8
2 from selenium import webdriver
3 driver = webdriver.Chrome()
4 driver.get("https://www.baidu.com")
【第三小節：python環境變數】
1.變數是什么？
變數是把程式運行的結果臨時存在記憶體里，一遍后續的代碼呼叫，
2.宣告變數
name = '小明'
上述代碼宣告了一個變臉，變數名為：name，變數name的值為："小明"
變數的作用：昵稱，其代指記憶體里某個地址中保存的內容
3.變數定義的規則
-
變數名只能是字母、數字或下劃線的任意組合
-
變數名的第一個字符不能是數字
-
變數名不能為以下關鍵字：['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
-
變數名要具有描述性
-
變數名不能使用中文，不能過長
4.常量
-
生活中一直不變的：身份證號碼，歷史發生的時間
-
常量一直不變的量，Python中沒有真正的常量，為了應和其他語言，全部大寫的變數稱之為常量，
-
將變數全部大寫，放在檔案最上邊
-
設定一些不變的量如：身份證號，性別和名字
5.注釋
-
便于理解對方的代碼和自己的代碼
-
單行注釋#，多行注釋 '''被注釋的內容'''
-
難以理解的代碼后面加注釋（函式，類，檔案都需要注釋來解釋說明）
6.Python的基礎資料型別
-
int（整型）：1，2，3，123，123123
在32位機器上，整數的位數為32位，取值范圍為-231～231-1，即-2147483648～2147483647
在64位系統上，整數的位數為64位，取值范圍為-263～263-1，即-9223372036854775808～9223372036854775807
-
str（字串）：在Python中,加了引號的字符都被認為是字串，
#單雙引號配合使用 countent = "i'm zfs ,18 years old" #三引號使用，換行的字串 msg = ''' 今天天氣真好， 我想寫首小詩， ''' print(msg) #字串拼接 s1 = 'zfs' s2 = 'shuai' s3 = s1 + s2 print(s3) #str * int s1 = '帥' print(s1 * 8
-
bool（布林值）：True或False，用于邏輯判斷
print(2<1) print(2>1)
7.判斷變數是什么資料型別
s1 = '100' s2 = 100 print(s1,type(s1)) print(s2,type(s2))
【第四小節：python IDLE使用方法詳解】
1.簡介
在安裝 Python(Windows安裝Python（圖解） 后，會自動安裝一個 IDLE，它是一個 Python Shell (可以在打開的 IDLE 視窗的標題欄上看到），程式開發人員可以利用 Python Shell 與 Python 互動，
本節將以 Windows7 系統中的 IDLE 為例，詳細介紹如何使用 IDLE 開發 Python 程式，
單擊系統的開始選單，然后依次選擇“所有程式 -> Python 3.6 -> IDLE (Python 3.6 64-bit)”選單項，即可打開 IDLE 視窗，如圖 1 所示，
?
圖 1 IDLE主視窗
前面我們己經應用 IDLE 輸出了簡單的陳述句，但在實際開發中，通常不能只包含一行代碼，當需要撰寫多行代碼時，可以單獨創建一個檔案保存這些代碼，在全部撰寫完成后一起執行，具體方法如下：
-
- 在 IDLE 主視窗的選單欄上，選擇“File -> New File”選單項，將打開一個新視窗，在該視窗中，可以直接撰寫 Python 代碼，
在輸入一行代碼后再按下 <Enter> 鍵，將自動換到下一行，等待繼續輸入，如圖 2 所示，
?
圖 2 新創建的 Python 檔案視窗 -
在代碼編輯區中，撰寫多行代碼，例如，輸出由宋詞《江城子》改編而成的《程式員之歌》，代碼如下：
- print(” “*5+“程式員之歌”)
- print(” “*15+“——《江城子》改編\n”)
- print(“十年生死兩茫茫，寫程式，到天亮，”)
- print(“千行代碼，Bug何處藏，”)
- print(“縱使上線又怎樣，朝令改，夕斷腸，”)
- print(“領導每天新想法，天天改，日日忙，”)
- print(“相顧無言，惟有淚千行”)
- print(“每晚燈火闌珊處，程式員，加班狂，”)
撰寫代碼后的 Python 檔案視窗如圖 3 所示，
?
圖 3 撰寫代碼后的 Python 檔案視窗 -
按下快捷鍵
- <Ctrl+S> 保存檔案，這里將檔案名稱設定為 demo.py，其中，.py 是 Python 檔案的擴展名，在選單欄中選擇“Run -> Run Module”選單項（也可以直接按下快捷鍵 <F5>），運行程式，如圖 4 所示，
?
圖 4 運行程式 -
運行程式后，將打開 Python Shell 視窗顯示運行結果，
- 如圖 5 所示，
?
圖 5 運行結果
- 在 IDLE 主視窗的選單欄上，選擇“File -> New File”選單項，將打開一個新視窗，在該視窗中，可以直接撰寫 Python 代碼，
【第五小節：Python集成開發環境Pycharm+Git+Gitee】
一、環境介紹
PyCharm是一種Python IDE，帶有一整套可以幫助用戶在使用Python語言開發時提高其效率的工具，比如除錯、語法高亮、Project管理、代碼跳轉、智能提示、自動完成、單元測驗、版本控制，此外，該IDE提供了一些高級功能，以用于支持Django框架下的專業Web開發，
Git(讀音為/g?t/，)是一個開源的分布式版本控制系統，可以有效、高速地處理從很小到非常大的專案版本管理， Git 是 Linus Torvalds 為了幫助管理 Linux 內核開發而開發的一個開放原始碼的版本控制軟體，
碼云(gitee.com)是 OSCHINA.NET 推出的代碼托管平臺,支持 Git 和 SVN,提供免費的私有倉庫托管，目前已有超過 350 萬的開發者選擇碼云，（國產）
二、環境搭建
1）注冊碼云賬戶，創建代碼遠端倉庫
- 碼云地址： https://gitee.com/ 建議使用郵箱注冊，筆者沒有使用所以又進行了郵箱系結
?
- 創建遠端代碼倉庫
?
- 紅框地址就是遠端庫地址，提交或者更新代碼都是這個地址
?
2）安裝Git，可以自己去官網下載 https://git-scm.com/ 或者百度云盤提取，直接下一步安裝至結束，滑鼠右擊桌面出現Git GUI Here和Git Bash Here則說明安裝成功！
鏈接：https://pan.baidu.com/s/1AMJgPTCANWrysQCqWCFU8w
提取碼：8o54
注意：在Git Bash Here 設定一下Git 用戶名和郵箱，提交代碼會用到
$ git config --global user.name “wirelessqa”
$ git config --global user.email wirelessqa.me@gmail.com
3）Pycharm 配置Git
- 安裝Pycharm見筆者另一篇博客：https://www.cnblogs.com/xjx767361314/p/10195661.html
- 設定git管理代碼
?
- 將開發的代碼托管到本地倉庫Git
- 初始化倉庫：git init
?
- 添加代碼到本地倉庫：git add .
- 查看本地倉庫代碼狀態：git status
?
4）代碼托管到遠端倉庫碼云
- 配置遠端倉庫地址
?
- 將碼云倉庫地址粘貼到這里，需要進行碼云賬戶驗證，注冊的賬戶資訊
?
- 點擊提交圖示或快捷鍵ctrl+k提交代碼到遠端碼云,可以commit或者commit&push
?
- 筆者是沒有commit&push 而是terminal視窗命令push的，但效果是一樣的！
?
- 登錄遠端倉庫碼云，查看代碼情況，至此環境搭建完成，代碼提交成功！
?
- 多人協同開發，配置倉庫成員，建議鏈接分享，直接利用Pycharm匯入即可
?
?
- Pycharm 匯入遠端庫碼云代碼,利用git命令或者Pycharm工具自帶方式創建分支，分支開發，最后合并到master
?
最后 Git常用命令列舉：
添加檔案到Git倉庫，分兩步：
使用命令git add .
使用命令git commit -m 描述提交內容
分支使用：
查看分支：git branch
創建分支：git branch
切換分支：git checkout
推送自己的修改到遠程分支 git push origin
創建+切換分支：git checkout -b
合并某分支到當前分支：git merge
提交到遠程倉庫 git push
洗掉分支：git branch -d
Git使用作業流 ： https://blog.csdn.net/phunxm/article/details/48575797
Git常用命令：https://blog.csdn.net/lxw198902165221/article/details/89228458
強烈推薦碼云這個平臺，國產開源、好用，Git相關知識收集的很全面，贊！
碼云提供的Git命令：Learn Git Branching
碼云提供的Git大全：Git 大全 - Gitee.com
【第六小節：Python基礎語法】
一，語法
?
二、編譯器
支持python的編譯器有很多，
我個人使用pycharm，其功能齊全，唯一的缺點的收費，
或者Visual Studio Code也是一個不錯的選擇.
三、基礎知識
1、資料型別
資料型別包括：字串（string）、整數型別（int）、浮點數（float）、布爾型別（boolean）[其中float('inf')代表正無窮，float('-inf')代表負無窮]，其關系如圖：
?
2、條件判斷
if陳述句可以通過判斷條件是否成立來決定是否執行某個陳述句
if···else···
if···elif······else···
"""用法如下""" | |
weather = '天晴' | |
if weather == '下雨': | |
print('在家學習') | |
elif weather == '陰天': | |
print('去釣魚') | |
elif weather == '暴風雨': | |
print('保命') | |
else: | |
print('去逛街') | |
# 特殊的三目運算 | |
a = 3 | |
print(True) if a>5 else print(False) |
3、回圈陳述句
for回圈
for 變數名 in 可遍歷物件:
宣告操作
else: # 回圈結束才會去執行，可以省略！
宣告操作
for i in range(10): | |
print(i) | |
else: | |
print("finished") |
while回圈
while 回圈條件:
? 宣告操作
else: # 回圈結束才會去執行，可以省略！
? 宣告操作
while i<= 5: | |
print(i) | |
i += 1 | |
else: | |
print('finished') | |
# 死回圈 | |
while True: | |
pass | |
# 99乘法表的制作 | |
num1 = 1 | |
while num1 <= 9: | |
num2 = 1 | |
while num2 <= num1: | |
print(f'{num1}*{num2}={num1 * num2:<2} ', end='') | |
num2 += 1 | |
print('') | |
num1 += 1 |
結束回圈
continue：跳出當前回圈
break：終止全部回圈
4、運算子
邏輯運算子
| 名稱 | 用法 |
|---|---|
| or | 有一個為真，則為真 |
| and | 有一個為假，則為假 |
| not | 否定作用 |
比較運算子
| 符號 | 用法 |
|---|---|
| < | 小于 |
| > | 大于 |
| = | 等于 |
| <= | 小于等于 |
| >= | 大于等于 |
| != | 不等于 |
算術運算子
| 符號 | 用法 |
|---|---|
| * | 乘法 |
| + | 加法 |
| - | 減法 |
| / | 除法 |
| // | 整除運算 |
| % | 取余運算 |
| ** | 冪運算 |
布爾運算子
| 型別 | 作用 | 范圍 |
|---|---|---|
| True | 真 | 除False外都為真 |
| False | 假 | 空串列、空元組、空字典，空集合，0，空字串等 |
四、類和函式
函式
def 函式名(): # 函式的命名用駝峰命名法
? 函式體
函式名() #函式的呼叫：直接函式名加括號就是在呼叫函式，函式在呼叫時會執行函式里面的函式體
def fun(): # 定義一個函式print("This a function")fun() # 呼叫函式
函式引數
形參：在函式體內用到的引數
必備引數：函式在呼叫是必須要傳入的引數,給了幾個引數就必須傳幾個引數值
關鍵字引數：指定引數名來傳引數值
不定長引數（默認引數，可以不寫）：接受的引數值不定，傳多少，這個不定長引數就接受多少
一個號是元組不定長引數*args，兩個**是字典不定長引數**kwargs
函式的注釋 -> 提示：在help函式查看時可以看到
def func(*args, **kwargs) -> "define function": | |
print(args, 'and ', kwargs) | |
func(1, 2, 3, a=1, d=2, c=3) # 其中，a=1是關鍵字引數， |
函式的作用域
函式內部的變數不能被函式外面使用，除非通過return回傳
num1 = 20 # 這是全域變數 | |
def func2(): | |
global num1 # global 關鍵字宣告全域變數 | |
num1 = num1+1 | |
print(num1) | |
print(num1) |
閉包里面的區域變數
def func(): | |
num2 = 30 # 這是區域變數 | |
def func1(): | |
nonlocal num2 # nonlocal 關鍵字宣告區域變數 | |
num2 = num2+1 | |
print(num2) | |
def func2(): | |
print(num2) | |
return func1,func2 # 外層函式回傳內層函式的函式體 | |
a,b = func() #a = func1 a() func1() |
特殊函式
遞回函式：函式自身呼叫自己
def recursion(n): | |
if n <= 1: # 遞回結束的條件 | |
return 1 # 結束回傳1 | |
else: | |
return n * recursion(n-1) # 一直呼叫自己 5*4*3*2*1 | |
print(recursion(5)) |
匿名函式：用在那些只使用一次的場景中，程式中只需要呼叫一次某個簡單邏輯，
def g(x): | |
x = str(x) | |
return x | |
print(g(2)) | |
# 轉換成匿名函式 | |
g = lambda x:x+1 # x就是函式g要傳入的引數值，冒號后面就是對傳入的引數做的操作 | |
g(4) # 匿名函式呼叫和函式一樣 |
匿名函式也可以用在串列中
list1 = [2,'3',1,'4',7,'9',5] | |
list1.sort() | |
list1.sort(key=lambda x:int(x),reverse=False) | |
print(list1) |
類
初級面向物件
面向物件的基本概念：類、屬性、方法
類：黑白黃三種人，人類
屬性：自身存在的，名字、性別、身高、體重、膚色，靜態屬性
方法：人會走路、吃飯、玩，動態屬性
name1 = '小' # 變數 | |
class Person: # class 帕斯卡命名法 PersonList | |
name = '子' # 定義在類里面的變數稱之為屬性 | |
age = 18 | |
def play(self,name): # 定義在類里面的函式稱之為方法,self指實體化物件本身 self=zilin | |
print(f'{name}正在玩游戲') | |
def search(self,name): | |
print(f'{name}正在查資料') | |
zilin = Person() # 實體化類，創建一個物件，實體化成一個具體的人 | |
bd = Person() # 創建第二個實體化物件bd | |
bd.name = '北斗' # 重新給bd這個人給予一個名字 |
初始化變數
初始化函式__init__ 對屬性重新賦值，讓每個人擁有自己獨有的屬性
class Student: | |
def __init__ (self, name, age): # self指實體化物件本身 ，實體化物件是自動呼叫一次 | |
self.name = name # 等號后面的是實體化的屬性 | |
self.age=age | |
def play(self): # 定義在類里面的函式稱之為方法,self指實體化物件本身 self=zilin | |
print(f'{self.name}正在玩游戲') #bd.name | |
def search(self): | |
print(f'{self.name}正在查資料') # bd.name | |
def __del__(self): # 解構式__del__：讓物件在洗掉時輸出一句話,洗掉物件自動呼叫 | |
print(f'{self.name}被洗掉了') | |
stu = Student(bd, 18) # 實體化物件時嗎，就應該相對應的給初始化函式傳參 | |
stu.play() | |
stu.search() | |
del stu # 洗掉stu這個實體化物件 |
類的繼承
class Student: | |
def __init__ (self, name, age): # self指實體化物件本身 ，實體化物件是自動呼叫一次 | |
self.name = name # 等號后面的是實體化的屬性 | |
self.age=age | |
def play(self): # 定義在類里面的函式稱之為方法,self指實體化物件本身 self=zilin | |
print(f'{self.name}正在玩游戲') #bd.name | |
def eat(self): | |
print(f'{self.name}正在吃飯') # bd.name | |
def __del__(self): # 解構式__del__：讓物件在洗掉時輸出一句話,洗掉物件自動呼叫 | |
print(f'{self.name}被洗掉了') | |
class StuYear(Student): # 繼承Student中的所有方法 | |
def __init__(self, name, age, year): | |
super().__init__(name, age) # 繼承Student類的實體化物件 | |
self.year = year | |
def study(self): | |
print("name:", self.name, "age:", self.age, "year:", self.year) | |
def eat(self): | |
Student.eat(self) # 指定類去使用里面的方法 | |
super().eat() # 讓重寫發的子類擁有父類的方法 | |
print(f'{self.name}愛吃辣') | |
stu = StuYear('li', 20, 20) | |
stu.study() | |
stu.play() | |
StuYear.eat(self=stu) |
多繼承
使用''類名.mro()"方法查看繼承順序
class A: | |
pass | |
class B: | |
pass | |
class C: | |
pass | |
class D(A, B, C): # 呼叫順序為A, B, C | |
pass | |
print(D.mro()) # 查看繼承順序 |
高級面向物件
魔法方法
class Person: | |
def __init__(self,name): | |
self.name = name | |
def eat(self): | |
print(f'{self.name}在吃飯') | |
kun = Person('kun') | |
hasattr(kun,'name') # 判斷屬性是否存在 | |
getattr(kun,'name') # 得到屬性值，沒有則報錯 | |
setattr(kun,'name','一') # 設定屬性值，有則改，無則加 | |
delattr(kun,'name') # 洗掉屬性 | |
issubclass(Person,object) # issubclass 判斷第一個類是不是后面類的子類 | |
isinstance(zilin,Person) # isinstance 判斷實體是否是后面類的實體物件 | |
isinstance(1,(str,int,float)) # 還可以用來判斷資料型別 | |
type(zilin) == Person # 只能判斷單個類實體化衍生 |
__new__方法：new魔法方法創建實體化物件，以及如何讓init初始化方法擁有引數去使用
class Person: | |
def __new__(obj,*args,**kwargs): #object祖宗類，new方法才是幫我們創建實體化物件的一個方法 | |
print('new實體方法') | |
return object.__new__(obj) # Person.eat(self) | |
def __init__(self,name): | |
print('init自動呼叫') | |
self.name = name | |
zilin = Person('kun') |
單例模式 ： 創建的所有的實體化物件都是同一個物件
class Person: | |
def __new__(obj,*args,**kwargs): #object祖宗類，new方法才是幫我們創建實體化物件的一個方法 | |
if not hasattr(obj,'_instance'): #not取反回傳True，判斷祖宗類object里面有沒有這個_instance | |
#通過屬性限制他去創建多個新的實體物件 | |
obj._instance = object.__new__(obj) #object.__new__(obj) 生成一個新的實體化物件 | |
return obj._instance #回傳實體化物件 | |
def __init__(self,name): | |
print('init自動呼叫') | |
self.name = name | |
z = Person('z') # 立第一個實體化物件會在object類去創建一個_instance屬性 | |
b = Person('b') # 建第二個實體化物件判斷屬性存在回傳第一個實體化物件 | |
y = Person('y') # 第三個實體化物件判斷屬性存在還是回傳第一個實體化物件 | |
z==b==y # 上創建的都是同一個實體物件 |
輸出魔法方法 __str__ __repr__
class Person: | |
def __init__(self,name,age): | |
self.name = name | |
self.age = age | |
def __str__(self): # 針對print輸出魔法方法 | |
return f'這個是{self.name}的str魔法方法' | |
def __repr__(self): # 直接輸出實體物件時會呼叫 | |
return f'這個是{self.name}的repr魔法方法' | |
z = Person('z',18) | |
z # repr方法呼叫 | |
print(z) # str方法呼叫 |
__call__方法：讓實體物件像函式一樣去呼叫
class Person: | |
def __init__(self,name,age): | |
self.name = name | |
self.age = age | |
def __call__(self,x,y): | |
return x+y | |
z = Person('z',18) | |
z(1, 2) |
協議
序列協議
li = (1,2,3,4) | |
class IndexTuple: | |
def __init__(self,*args): # args元組不定長引數拿到是一個元組 | |
self.values = args | |
self.index = tuple(enumerate(self.values)) # 通過列舉enumerate的方法將下標索引和自身的元素組成一個大大的元組 | |
print(self.index) | |
def __len__(self): | |
return len(self.values) | |
def __getitem__(self,key): # 通過下標索引key取值 | |
return self.index[key] | |
return self.values[key] | |
def __repr__(self): | |
return str(self.values) # 只能回傳字串 | |
my_t = IndexTuple(1,2,3,34) |
可迭代物件 --> 取值，像字串，元組，串列，集合，字典能夠被如回圈取值一個一個拿取到元素的資料型別
li = [1,2,3,4,5] # 可迭代物件 | |
li1 = iter(li) # 將可迭代物件轉成一個迭代器物件，迭代器物件就是能夠被next一個一個將值取出 | |
next(li1) |
迭代器協議
class Number: | |
def __init__(self,end): | |
self.start = 0 | |
self.end = end | |
def __iter__(self): #構建一個迭代器物件 | |
return self | |
def __next__(self): #對迭代器物件取值 | |
self.start += 1 | |
if self.start <= self.end: #當self.start值小于self.end | |
return self.start #回傳self.start | |
else: | |
raise StopIteration #拋出終止迭代例外 | |
nu = Number(6) | |
for i in nu: | |
print(i) | |
# 也可以用next(nu)函式去呼叫 |
背景關系協議： 計時器，所謂的秒表，檢測代碼運行時長
import time #時間模塊 | |
class RunTime: | |
def __enter__(self): #接收代碼開始時間 | |
self.star_time = time.time() #獲得當前開始時間 | |
return self.star_time | |
def __exit__(self,exc_type,exc_val,exc_tb): | |
self.end_time = time.time() #獲取當前結束時間 | |
self.run_time = self.end_time - self.star_time #代碼運行時間 | |
print('代碼運行時間為：',self.run_time) | |
with RunTime(): #使用方法 | |
# 要執行的代碼，運行時長 | |
pass |
生成器和裝飾器
生成器等同于迭代器 yield 關鍵字回傳值 next獲取值
def func(): | |
print(1) | |
yield 2 # 和return一樣有一個暫停函式的功能，并且遇到下一個next會繼續向下執行 | |
print(3) | |
yield 4 | |
print(5) | |
yield 6 | |
a = func() | |
for i in a: | |
print(i) | |
# 或者使用next(a)，通過next獲取值得到回傳值 |
裝飾器：閉包加回呼函式
def fun(x): | |
def fun1(aa, bb): | |
print(aa, 'and:', bb) | |
return x(1, 2) | |
print('外層函式') | |
return fun1 | |
@fun | |
def func(cc, dd): | |
print('這是func的值：', cc, dd) | |
func(3, 4) |
內置裝飾器
class Person: | |
def __init__(self,name,age): | |
self.name = name | |
self.age = age | |
@classmethod # 第一個引數自動傳入類 | |
def learn(cls): # cls=Person | |
print(f'{zl.name}在學習') | |
print(cls) | |
@staticmethod #不在自動傳入self | |
def sleep(): | |
print(zl.name) | |
print('在睡覺') | |
zl = Person('z',18) | |
Person.learn() | |
Person.sleep() |
五、常用操作
格式化操作
%方式
?
format方法
?
常用函式
print()：輸出函式
input()：輸入函式
type()：查看資料型別
id()：查看記憶體地址
eval()：去除雙引號
例外資訊
try:
? pass
except Exception as e: # 保錯后鍵例外資訊存盤在e中
? pass
finally: # 無論報不報錯都運行
? pass
| 例外名稱 | 描述 |
|---|---|
| BaseException | 所有例外的基類 |
| SystemExit | 解釋器請求退出 |
| KeyboardInterrupt | 用戶中斷執行(通常是輸入^C) |
| GeneratorExit | 生成器(generator)發生例外來通知退出 |
| Exception | 常規錯誤的基類 |
| StopIteration | 迭代器沒有更多的值 |
| StandardError | 所有的內建標準例外的基類 |
| ArithmeticError | 所有數值計算錯誤的基類 |
| FloatingPointError | 浮點計算錯誤 |
| OverflowError | 數值運算超出最大限制 |
| ZeroDivisionError | 除(或取模)零 (所有資料型別) |
| AssertionError | 斷言陳述句失敗 |
| AttributeError | 物件沒有這個屬性 |
| EOFError | 沒有內建輸入,到達EOF 標記 |
| EnvironmentError | 作業系統錯誤的基類 |
| IOError | 輸入/輸出操作失敗 |
| OSError | 作業系統錯誤 |
| WindowsError | 系統呼叫失敗 |
| ImportError | 匯入模塊/物件失敗 |
| LookupError | 無效資料查詢的基類 |
| IndexError | 序列中沒有此索引(index) |
| KeyError | 映射中沒有這個鍵 |
| MemoryError | 記憶體溢位錯誤(對于Python 解釋器不是致命的) |
| NameError | 未宣告/初始化物件 (沒有屬性) |
| UnboundLocalError | 訪問未初始化的本地變數 |
| ReferenceError | 弱參考(Weak reference)試圖訪問已經垃圾回收了的物件 |
| RuntimeError | 一般的運行時錯誤 |
| NotImplementedError | 尚未實作的方法 |
| SyntaxError | Python 語法錯誤 |
| IndentationError | 縮進錯誤 |
| TabError | Tab 和空格混用 |
| SystemError | 一般的解釋器系統錯誤 |
| TypeError | 對型別無效的操作 |
| ValueError | 傳入無效的引數 |
| UnicodeError | Unicode 相關的錯誤 |
| UnicodeDecodeError | Unicode 解碼時的錯誤 |
| UnicodeEncodeError | Unicode 編碼時錯誤 |
| UnicodeTranslateError | Unicode 轉換時錯誤 |
| Warning | 警告的基類 |
| DeprecationWarning | 關于被棄用的特征的警告 |
| FutureWarning | 關于構造將來語意會有改變的警告 |
| OverflowWarning | 舊的關于自動提升為長整型(long)的警告 |
| PendingDeprecationWarning | 關于特性將會被廢棄的警告 |
| RuntimeWarning | 可疑的運行時行為(runtime behavior)的警告 |
| SyntaxWarning | 可疑的語法的警告 |
| UserWarning | 用戶代碼生成的警告 |
六、檔案管理
檔案讀寫
檔案打開
相對路徑：在py腳本檔案同級目錄下的檔案 .\同級目錄 ..\上級目錄
絕對路徑：完整的路徑
檔案讀寫mode
a追加模式下，如果檔案不存在，也會自動幫我們創建一個檔案，之后在寫入內容
和w只寫的區別就是一個是清空再寫入，一個是繼續向后寫
?
檔案操作
打開
file = open("FilePath", mode="type"(, encoding="")) # 要記得關閉檔案
pass
file.close()
with open("FilePath", mode="type"(, encoding="")) # 背景關系管理器打開，可以不用關閉
寫入
file.writre("content") # write()方法：需要傳入一個字串做為引數,否則會報錯
file.writelines() # writelines()方法：既可以傳入字串又可以傳入一個字符序列,并將該字符序列寫入檔案
讀取
file.read() # read()方法：一次性讀如并回傳檔案的所有內容
file.readlines() # readlines()方法：每次讀取一行；回傳的是一個字串物件，保持當前行的記憶體，一次性讀取整個檔案；自動將檔案內容分析成一個行的串列
遍歷讀取
檔案物件本身可以迭代，并且以行的形式讀取
for i in file:print(i)指標
file.tell() # tell()方法：回傳檔案的當前位置，即檔案指標當前位置，
file.seek() # seek()方法：用于移動檔案讀取指標到指定位置，
- seek第一個引數：移動的長度（位元組）；如果該值為負數，表示從后往前移動n個位元組
- seek第二個引數：0從開頭（默認），1從當前，2從末尾
OS模塊
| 方法 | 含義 |
|---|---|
| os.sep | 符合當前系統的路徑分割符，Linux/windows\ |
| os.name | 回傳作業系統型別windows“nt”Linux“posix” |
| os.rename | 更改檔案名，傳遞兩個引數（舊檔案名，新檔案名） |
| os.getcwd | 回傳當前的作業目錄 |
| os.listdir | 列出指定目錄下的目錄和檔案 |
| os.chdir | 修改當前的作業路徑 |
| os.mkdir | 創建目錄 |
| os.makedirs | 遞回創建目錄 |
| os.remove | 洗掉檔案 |
| os.rmdir | 洗掉檔案夾（檔案夾下內容為空） |
| os.removedirs | 遞回洗掉檔案夾 |
| os.system | 執行系統命令 |
| os.popen | 執行系統命令，會將結果以檔案的形式回傳 |
| os.walk | 通過在目錄樹中游走輸出在目錄中的檔案名，向上或者向下 |
| os.path.join | 連接目錄和檔案名，os.path.join（path,name） |
| os.path. isfile | 判斷指定物件是否為檔案，是回傳True,否則False |
| os.path.isdir | 判斷指定物件是否為目錄，是True,否則False |
| os.path. split | 回傳路徑的目錄和檔案名 |
| os.path. exists | 檢驗指定的物件是否存在，是True,否則False |
| os.path.getsize | 獲取指定物件的檔案大小 |
| os.path.abspath | 獲得絕對路徑 |
| os.path.basename | 回傳檔案名 |
| os.path.dirname | 回傳檔案所在目錄 |
sys模塊
| 方法 | 含義 |
|---|---|
| sys.argv | 獲取命令列引數串列，第一個元素是程式本身 |
| sys.exit(n) | 退出Python程式，exit(0)表示正常退出，當引數非0時，會引發一個SystemExit例外，可以在程式中捕獲該例外 |
| sys.version | 獲取Python解釋程器的版本資訊 |
| sys.maxsize | 最大的Int值，64位平臺是2**63 - 1 |
| sys.path | 回傳模塊的搜索路徑，初始化時使用PYTHONPATH環境變數的值 |
| sys.platform | 回傳作業系統平臺名稱 |
| sys.stdin | 輸入相關 |
| sys.stdout | 輸出相關 |
| sys.stderr | 錯誤相關 |
| sys.exc_info() | 回傳例外資訊三元元組 |
| sys.getdefaultencoding() | 獲取系統當前編碼，默認為utf-8 |
| sys.setdefaultencoding() | 設定系統的默認編碼 |
| sys.getfilesystemencoding() | 獲取檔案系統使用編碼方式，默認是utf-8 |
| sys.modules | 以字典的形式回傳所有當前Python環境中已經匯入的模塊 |
| sys.builtin_module_names | 回傳一個串列，包含所有已經編譯到Python解釋器里的模塊的名字 |
| sys.copyright | 當前Python的著作權資訊 |
| sys.flags | 命令列標識狀態資訊串列，只讀， |
| sys.getrefcount(object) | 回傳物件的參考數量 |
| sys.getrecursionlimit() | 回傳Python最大遞回深度，默認1000 |
| sys.getsizeof(object[, default]) | 回傳物件的大小 |
| sys.getswitchinterval() | 回傳執行緒切換時間間隔，默認0.005秒 |
| sys.setswitchinterval(interval) | 設定執行緒切換的時間間隔，單位秒 |
| sys.getwindowsversion() | 回傳當前windwos系統的版本資訊 |
| sys.hash_info | 回傳Python默認的哈希方法的引數 |
| sys.implementation | 當前正在運行的Python解釋器的具體實作，比如CPython |
| sys.thread_info | 當前執行緒資訊 |
七、模塊和包
模塊
其是一個 Python 檔案，以 .py 結尾，包含了 Python 物件定義和Python陳述句，
導包
import 包名 # 匯入模塊
import 模塊名 as 別名
from 模塊名 import 成員名 as 別名
from 模塊名 import 成員名
from 模塊名 import * # 從模塊中匯入所有方法
【第七小節：python（變數型別）】
序
其實大一上就簡單學了下python，跟著書做了下飛機大戰和爬豆瓣的爬蟲，但現在好像連python基本語法都不記得了，剛好這個學期要有自學opencv和strcpy的需求，所以借此機會重溫下py，用的資料就是《python編程從入門到實踐》，我就慢慢從頭開始過下基礎知識，現在就當成云筆記了，希望也對和我一樣的小白有些許幫助，同時若有大佬能對我指點一二我就感激不盡啦，
變數賦值
python是一種解釋型語言，和我學的c完全不一樣，同時注意的地方也有許多，縮進，繼承，類，等等，
counter = 100 # 賦值整型變數
miles = 1000.0 # 浮點型
name = "John" # 字串
print(name)
?
多個變數賦值
a, b, c = 1, 2, "john"
a = b = c = 1
標準資料型別
number
var1 = 1
var2 = 10
洗掉的話：
del var1
Python支持四種不同的數字型別：
int（有符號整型）
long（長整型[也可以代表八進制和十六進制]）
float（浮點型）
complex（復數）（復數由實數部分和虛數部分構成，可以用 a + bj,或者 complex(a,b) 表示， 復數的實部 a 和虛部 b 都是浮點型，）
string（字串）
python的字串串列有2種取值順序:
從左到右索引默認0開始的，最大范圍是字串長度少1
從右到左索引默認-1開始的，最大范圍是字串開頭
eg：
a b c d e
0 1 2 3 4
-5 -4 -3 -2 -1
"切片“是python很強大的一個功能，用 [頭下標:尾下標] 來截取相應的字串，其中下標是從 0 開始算起，可以是正數或負數，下標可以為空表示取到頭或尾，左閉右開
s = 'abcdef'
print(s[1:5])
?
可以像C語言陣列一樣使用切片功能，
加號（+）是字串連接運算子，星號（*）是重復操作，如下實體：
str = 'Hello World!'
print (str) # 輸出完整字串
print (str[0]) # 輸出字串中的第一個字符
print (str[2:5]) # 輸出字串中第三個至第六個之間的字串
print (str[2:]) # 輸出從第三個字符開始的字串
print (str * 2) # 輸出字串兩次
print (str + "TEST") # 輸出連接的字串
?
Python 串列截取可以接收第三個引數，引數作用是截取的步長，在索引 1 到索引 4 的位置并設定為步長為 2（間隔一個位置）來截取字串
list（串列） （用【】）
串列可以完成大多數集合類的資料結構實作，它支持字符，數字，字串甚至可以包含串列（即嵌套），
串列用 [ ] 標識，是 python 最通用的復合資料型別，
串列中值的切割也可以用到變數 [頭下標:尾下標] ，就可以截取相應的串列，從左到右索引默認 0 開始，從右到左索引默認 -1 開始，下標可以為空表示取到頭或尾，
操作和string類似
tuple（元組）（不能二次賦值）（用（））
元組是另一個資料型別，類似于 List（串列），
元組用 () 標識，內部元素用逗號隔開，但是元組不能二次賦值，相當于只讀串列，
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
同切片操作
dictionary （字典）（用{}）
字典(dictionary)是除串列以外python之中最靈活的內置資料結構型別，串列是有序的物件集合，字典是無序的物件集合，
兩者之間的區別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取，
字典用"{ }"標識，字典由索引(key)和它對應的值value組成，
dict = {} # 創建空字典
dict['one'] = "This is one" # 為字典賦鍵值對
dict[2] = "This is two"
tinydict = {'name': 'runoob', 'code': 6734, 'dept': 'sales'}
print(dict['one']) # 輸出鍵為'one' 的值
print(dict[2]) # 輸出鍵為 2 的值
print(dict)
print(tinydict) # 輸出完整的字典
print(tinydict.keys()) # 輸出所有鍵
print(tinydict.values()) # 輸出所有值
?
注意編碼格式為UTF-8
Python資料型別轉換
int(x [,base])
將x轉換為一個整數
long(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)
將一個整數轉換為一個字符
unichr(x)
將一個整數轉換為Unicode字符
ord(x)
將一個字符轉換為它的整數值
hex(x)
將一個整數轉換為一個十六進制字串
oct(x)
將一個整數轉換為一個八進制字串
python內置函式好多啊
【第八小節：Python資料型別轉換】
?
一 自動型別轉換
(針對于Number型別) bool float int complex
當Number不同的資料型別進行運算的時候,默認向更高精度轉化
精度從低到高順序:bool -> int -> float ->complex
True 默認轉化是1
False 默認轉化是0
# (1) bool + int res = True + 89 print(res) # (2) bool + float res = True + 55.78 print(res) # (3) bool + complex res = False + 2-4j print(res) # (4) int + float res = 31 + 4.1 print(res) # (5) int + complex res = 17 + 4-7j print(res) # (6) float + complex res = 8.12 + 3+5j print(res)
[root@node10 python]# python3 test.p
90 56.78 (2-4j) 35.1 (21-7j) (11.12+5j)
二 強制型別轉換
Number => (int float bool complex)
2.1 把資料強制轉換成整型 int
(整型 浮點型 布爾型別 純數字字串)
var1 = 13 var2 = 99.99 var3 = True var3_1 = False var4 = 4+1j var5 = "123321" var6 = "你好123" res = int(var2) # True 強轉整型是1 False 強轉整型是0 res = int(var3) print(res,type(res)) res = int(var3_1) print(res) res = int(var5) print(res,type(res))
[root@node10 python]# python3 test.py
1 <class 'int'> 0 123321 <class 'int'>
字符型字串不能轉化
var1 = 13 var2 = 99.99 var3 = True var3_1 = False var4 = 4+1j var5 = "123321" var6 = "你好123" res = int(var6) print(res,type(res))
[root@node10 python]# python3 test.py
Traceback (most recent call last):
File "test.py", line 9, in <module>
res = int(var6)
ValueError: invalid literal for int() with base 10: '你好123'
2.2 float (整型 浮點型 布爾型別 純數字字串)
var1 = 13 var2 = 99.99 var3 = True var3_1 = False var4 = 4+1j var5 = "123321" var6 = "你好123" res = float(var1) print(res) res = float(var3) # 加上.0 成為小數 print(res) res = float(var3_1) # 0.0 print(res) res = float(var5) #123321.0 print(res)
[root@node10 python]# python3 test.py
13.0 1.0 0.0 123321.0
[root@node10 python]# python3 test.py
var1 = 13 var2 = 99.99 var3 = True var3_1 = False var4 = 4+1j var5 = "123321" var6 = "你好123" res = float(var4) #can't convert complex to float print(res)
[root@node10 python]# python3 test.py
Traceback (most recent call last):
File "test.py", line 9, in <module>
res = float(var4) #can't convert complex to float
TypeError: can't convert complex to float
complex (整型 浮點型 布爾型別 純數字字串 復數)
var1 = 13 var2 = 99.99 var3 = True var3_1 = False var4 = 4+1j var5 = "123321" var6 = "你好123" res = complex(var1) # 13 + 0j print(res) res = complex(var2) #(99.99+0j) print(res) res = complex(var3) #(1+0j) print(res) res = complex(var3_1) #0j print(res) res = complex(var5) #(123321+0j) print(res)
[root@node10 python]# python3 test.py
(13+0j) (99.99+0j) (1+0j) 0j (123321+0j)
2.3 bool型別
( 容器型別資料 / Number類型資料 都可以,要么True要么False)
布爾型別為假的十種情況: 0,0.0,False,0j,"",[],(),set(),{},None None 是系統的一個關鍵字 表示空的,什么也沒有,一般做初始值
var1 = 13
var2 = 99.99
var3 = True
var3_1 = False
var4 = 4+1j
var5 = "123321"
var6 = "你好123"
res = bool(var6)
print(res,type(res))
res = bool(var4)
print(res,type(res))
res = bool([1,2,3])
print("<!!!>")
print(res)
res = None
print(res,type(res))
[root@node10 python]# python3 test.py
True <class 'bool'> True <class 'bool'> <!!!> True None <class 'NoneType'>
三 容器型別資料的強制型別轉換
(str list tuple set dict)
3.1 str 強轉成字串型別
( 容器型別資料 / Number型別資料 都可以 )
字串強轉規律: 就是單純的在原資料的兩側加上引號
var1 = "快樂每一天"
var2 = [1,2,3]
var3 = (4,5,6)
var4 = {"美麗","店鋪名個人"}
var5 = {"a":1,"b":2,"c":3}
var6 = 123
res = str(var2)
print(repr(res),type(res))
res = str(var3)
print(repr(res),type(res))
res = str(var5)
print(repr(res),type(res))
res = str(var6)
# print(res,type(res))
# repr 以字串形式原型化輸出資料 (想看到引號用repr轉化)
print(repr(res),type(res))
[root@node10 python]# python3 test.py
'[1, 2, 3]' <class 'str'>
'(4, 5, 6)' <class 'str'>
"{'a': 1, 'b': 2, 'c': 3}" <class 'str'>
'123' <class 'str'>
3.2 list 串列
list 串列強轉規律:
如果是字串:把字串中的每一個字符當成新的元素放到串列中，如果是其他資料:就是單純的把原識別符號換成[]
var1 = "快樂每一天"
var2 = [1,2,3]
var3 = (4,5,6)
var4 = {"美麗","店鋪名個人"}
var5 = {"a":1,"b":2,"c":3}
var6 = 123
res = list(var1) #['快', '樂', '每', '一', '天']
print(res)
res = list(var3)
print(res)
res = list(var4)
print(res)
res = list(var5) #['a', 'b', 'c'] 強轉字典時,保留鍵,舍去值
# res = list(var6) # error
print(res)
[root@node10 python]# python3 test.py
['快', '樂', '每', '一', '天'] [4, 5, 6] ['店鋪名個人', '美麗'] ['a', 'b', 'c']
3.3 tuple 元組
tuple 元組強轉規律
如果是字串:把字串中的每一個字符當成新的元素放到元組中
如果是其他資料:就是單純的把原識別符號換成() 變成元組即可
var1 = "快樂每一天"
var2 = [1,2,3]
var3 = (4,5,6)
var4 = {"美麗","店鋪名個人"}
var5 = {"a":1,"b":2,"c":3}
var6 = 123
res = tuple(var1) #('快', '樂', '每', '一', '天')
print(res)
res = tuple(var2)
print(res)
res = tuple(var5) #('a', 'b', 'c') #強轉字典時,保留鍵,舍去值
print(res)
[root@node10 python]# python3 test.py
('快', '樂', '每', '一', '天')
(1, 2, 3)
('a', 'b', 'c')
3.4 set 集合
set 集合強轉規律
- 如果是字串:把字串中的每一個字符當成新的元素放到集合中
- 如果是其他資料:就是單純的把原識別符號換成{} 變成集合即可??
var1 = "快樂每一天"
var2 = [1,2,3]
var3 = (4,5,6)
var4 = {"美麗","店鋪名個人"}
var5 = {"a":1,"b":2,"c":3}
var6 = 123
res = set(var1) #因為無序,字串被打散
print(res)
res = set(var2) # {1,2,3}
print(res)
res = set(var5) #強轉字典時,保留鍵,舍去值,鍵值順序被打亂
print(res)????
[root@node10 python]# python3 test.py
{'快', '每', '一', '樂', '天'}
{1, 2, 3}
{'c', 'a', 'b'}
過濾串列重復資料
listvar = [1,2,3,4,5,5,6,7,6] container = set(listvar) print(container) container = list(container) print(container,type(container))
[root@node10 python]# python3 test.py
{1, 2, 3, 4, 5, 6, 7}
[1, 2, 3, 4, 5, 6, 7] <class 'list'>
3.5 二級容器
外面是一個容器型別的資料,里面的元素還是一個容器型別資料
listvar = [1,2,3,(4,5,6)] # 二級容器 print(listvar)
[root@node10 python]# python3 test.py
[1, 2, 3, (4, 5, 6)]
二級元祖
tup = (3,5,(7,8,9)) print(tup)
[root@node10 python]# python3 test.py
(3, 5, (7, 8, 9))
二級集合 (只能存放元組)
setvar = {1,2,3,(11,22,33)}
print(setvar)
[root@node10 python]# python3 test.py
{1, 2, 3, (11, 22, 33)}
二級字典
dictvar = {'a':{'c':333},'b':2}
# 取出333
print(dictvar['a']['c'])
[root@node10 python]# python3 test.py
333
# 四級容器
container = [1,2,3,(4,5,6,{"a":1,"b":[7,8,9]}),90]
# 取出9
res = container[-2][-1]["b"][-1]
print(res)
[root@node10 python]# python3 test.py
| 1 |
|
等長的二級容器
(1) 里面每個元素都是容器型別資料
(2) 每個容器型別資料的元素個數都相同
container = [(1,2,3),[4,5,6]]
3.6 字典的強制型別轉換
外面是串列,里面是串列或元組或字串
listvar = [["a",1],("b",2),"c123"] # 字串慎用 如果值是多個,有局限性
listvar = [["a",1],("b",2)] # 推薦 ***
res = dict(listvar)
print(res)
[root@node10 python]# python3 test.py
{'a': 1, 'b': 2}
外面是元組,里面是串列元組或字串
tuplevar = (["c",11],("d",23)) # 推薦 ***
res = dict(tuplevar)
print(res)
[root@node10 python]# python3 test.py
{'c': 11, 'd': 23}
例外:如果往串列或者元組容器放集合,語法上不報錯,但情況出乎意料,達不到想要效果
container = dict([{"a",1},{"b",2}]) # 不推薦使用
print(container)
[root@node10 python]# python3 test.py
{'a': 1, 'b': 2}
外面是集合,里面是元組或字串
setvar = {('a',1),('b',2),"c3"} # 必須放入不可變資料,即可哈希
res = dict(setvar)
print(res)
[root@node10 python]# python3 test.py
{'b': 2, 'a': 1, 'c': '3'}
int() float() bool() complex()
str() list() tuple() set() dict()
這些函式在進行強轉時,都默認轉化成當前的資料型別
用這樣的方式也可以初始化一個變數
res = int() res = list() print(res)
[root@node10 python]# python3 test.py
【第九小節：Python 內置函式]
分類
按引數和回傳值分類
無引數，無回傳值
無引數，有回傳值
有引數，無回傳值
有引數，有回傳值
按來源分類
內置函式
自定義函式
標準庫函式
第三方庫函式
內置函式
數學運算(7個)
型別轉換(24個)
序列操作(8個)
物件操作(7個)
反射操作(8個)
變數操作(2個)
互動操作(2個)
檔案操作(1個)
編譯執行(4個)
裝飾器(3個)
| 函式 | 分類 | 回傳值 |
|---|---|---|
| abs() | 數學運算 | 回傳數字的絕對值，如abs(-10) 回傳 10 |
| all() | 序列操作 | 接受一個迭代器，如果迭代器的所有元素都為真，那么回傳True，否則回傳False |
| any() | 序列操作 | 接受一個迭代器，如果迭代器里有一個元素為真，那么回傳True,否則回傳False |
| ascii() | 物件操作 | 呼叫物件的__repr__()方法，獲得該方法的回傳值 |
| bin() | 型別轉換 | 將十進制數分別轉換為2進制 |
| bool() | 型別轉換 | 測驗一個物件是True還是False |
| bytearray() | 型別轉換 | 將一個字串轉換成位元組型別 |
| bytes() | 型別轉換 | 將字符型別/數值型別等轉換為字串型別 |
| callable() | 反射操作 | 判斷物件是否可以被呼叫，能被呼叫的物件就是一個callables物件，比如函式和帶有__call__()的實體 |
| chr() | 型別轉換 | 查看十進制數對應的ASCII字符 |
| classmethod() | 裝飾器 | 用來指定一個方法為類的方法，由類直接呼叫執行，只有一個cls引數,執行雷的方法時，自動將呼叫該方法的類賦值給cls.沒有此引數指定的類的方法為實體方法 |
| compile() | 編譯執行 | 將一個字串編譯為位元組代碼 |
| complex() | 型別轉換 | 用于創建一個值為 real + imag * j 的復數或者轉化一個字串或數為復數，如果第一個引數為字串，則不需要指定第二個引數 |
| delattr() | 反射操作 | 洗掉物件的屬性 |
| dict() | 型別轉換 | 創建資料字典 |
| dir() | 物件操作 | 不帶引數時回傳當前范圍內的變數，方法和定義的型別串列，帶引數時回傳引數的屬性，方法串列 |
| divmod() | 數學運算 | 分別取商和余數 |
| enumerate() | 型別轉換 | 回傳一個可以列舉的物件，該物件的next()方法將回傳一個元組 |
| eval() | 編譯執行 | 將字串str當成有效的運算式來求值并回傳計算結果 |
| exec() | 編譯執行 | 執行字串或complie方法編譯過的字串，沒有回傳值 |
| filter() | 序列操作 | 過濾器，構造一個序列，等價于[ item for item in iterables if function(item)]，在函式中設定過濾條件，逐一回圈迭代器中的元素，將回傳值為True時的元素留下，形成一個filter型別資料 |
| float() | 型別轉換 | 講一個字串或整數轉換為浮點數 |
| format() | 物件操作 | 格式化輸出字串，format(value, format_spec)實質上是呼叫了value的__format__(format_spec)方法 |
| frozenset() | 型別轉換 | 創建一個不可修改的集合 |
| getattr() | 反射操作 | 獲取物件的屬性 |
| globals() | 變數操作 | 回傳一個描述當前全域變數的字典 |
| hasattr() | 反射操作 | 用于判斷物件是否包含對應的屬性 |
| hash() | 物件操作 | 用于獲取一個物件（字串或者數值等）的哈希值 |
| help() | 物件操作 | 回傳物件的幫助檔案 |
| hex() | 型別轉換 | 將十進制數分別轉換為16進制 |
| id() | 物件操作 | 回傳物件的記憶體地址 |
| input() | 互動操作 | 獲取用戶輸入內容 |
| int() | 型別轉換 | 將一個字串或數值轉換為一個普通整數 |
| isinstance() | 反射操作 | 檢查物件是否是類的物件，回傳True或False |
| issubclass() | 反射操作 | 檢查一個類是否是另一個類的子類，回傳True或False |
| iter() | 型別轉換 | 用來生成迭代器 |
| len() | 物件操作 | 回傳物件長度，引數可以是序列型別（字串，元組或串列）或映射型別（如字典） |
| list() | 型別轉換 | 串列建構式 |
| locals() | 變數操作 | 列印當前可用的區域變數的字典 |
| map() | 序列操作 | 根據提供的函式對指定序列做映射 |
| max() | 數學運算 | 回傳給定元素里最大值 |
| memoryview() | 型別轉換 | 回傳給定引數的記憶體查看物件 |
| min() | 數學運算 | 回傳給定元素里最小值 |
| next() | 序列操作 | 回傳一個可迭代資料結構（如串列）中的下一項 |
| object() | 型別轉換 | 不接受任何引數，回傳一個無特征物件，該物件是所有類的基礎 |
| oct() | 型別轉換 | 將十進制數分別轉換為8進制 |
| open() | 檔案操作 | 打開檔案 |
| ord() | 型別轉換 | 查看某個ASCII對應的十進制數 |
| pow() | 數學運算 | 冪函式 |
| print() | 互動操作 | 輸出函式 |
| property() | 裝飾器 | 在新式類中回傳屬性值 |
| range() | 型別轉換 | 根據需要生成一個指定范圍的數字，可以提供你需要的控制來迭代指定的次數 |
| repr() | 編譯執行 | 將任意值轉換為字串，供計時器讀取的形式 |
| reversed() | 序列操作 | 反轉，逆序物件 |
| round() | 數學運算 | 四舍五入 |
| set() | 型別轉換 | 創建一個無序不重復元素集，可進行關系測驗，洗掉重復資料，還可以計算交集、差集、并集等， |
| setattr() | 反射操作 | 函式對應函式 getattr()，用于設定屬性值，該屬性不一定是存在的， |
| slice() | 型別轉換 | 實作切片物件，主要用在切片操作函式里的引數傳遞 |
| sorted() | 序列操作 | 對所有可迭代的物件進行排序操作 |
| staticmethod() | 裝飾器 | 回傳函式的靜態方法 |
| str() | 型別轉換 | 回傳一個物件的string格式 |
| sum() | 數學運算 | 求和 |
| super() | 型別轉換 | 呼叫父類的方法 |
| tuple() | 型別轉換 | 元組建構式 |
| type() | 物件操作 | 顯示物件所屬的型別 |
| vars() | 物件操作 | 回傳物件object的屬性和屬性值的字典物件 |
| zip() | 序列操作 | 將物件逐一配對 |
| __import__() | 反射操作 | 用于動態加載類和函式 |
【第十小節：python運算子】
什么是運算子
舉個簡單的例子:
4 + 5 = 9
例子中，4 和 5 被稱為運算元，+ 稱為運算子，
Python 語言支持以下型別的運算子:???
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 |
以下實體演示了Python所有算術運算子的操作：
實體(Python 3.0+)
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值為：", c)
c = a - b
print ("2 - c 的值為：", c)
c = a * b
print ("3 - c 的值為：", c)
c = a / b
print ("4 - c 的值為：", c)
c = a % b
print ("5 - c 的值為：", c)
# 修改變數 a 、b 、c
a = 2
b = 3
c = a**b
print ("6 - c 的值為：", c)
a = 10
b = 5
c = a//b
print ("7 - c 的值為：", c)
以上實體輸出結果：
1 - c 的值為： 31
2 - c 的值為： 11
3 - c 的值為： 210
4 - c 的值為： 2.1
5 - c 的值為： 1
6 - c 的值為： 8
7 - c 的值為： 2
結果總是隱式轉換為復雜型別
# 正負
>>> +x
521
>>> -x
-521
# 加法,可結合賦值運算+=
>>> x + 0
521
# 減法,可結合賦值運算-=
>>> x - 21
500
# 乘法,可結合賦值運算*=
>>> z * 100
521.0
# 除法,可結合賦值運算/=或//=
"""
兼容特性: from __future__ import division
"""
# Python2中對于包含小數使用真除法(保留小數部分,最終為小數)
>>> x / 100.
5.21
# Python3中對于包含小數使用真除法(保留小數部分,最終為小數)
>>> x / 100.
5.21
# Python2中對于全整數使用傳統除法(保留整數部分,最終為整數)
>>> x / 100
5
# Python3中對于全整數使用真除法(保留小數部分,最終為小數)
>>> x / 100
5.21
# Python2中對于包含小數使用地板除(保留整數部分,最終為小數)
# Python3中對于包含小數使用地板除(保留整數部分,最終為小數)
>>> x // 100.
5.0
# Python2中對于全整數使用地板除(保留整數部分,最終為整數)
# Python3中對于全整數使用地板除(保留整數部分,最終為整數)
>>> x // 100
5
# 取模,可結合賦值運算%=
>>> x % 2
1
# 乘方,可結合賦值運算**=
>>> z * 10 ** 2
521.0
>>> 5 + 4 # 加法
9
>>> 4.3 - 2 # 減法
2.3
>>> 3 * 7 # 乘法
21
>>> 2 / 4 # 除法，得到一個浮點數
0.5
>>> 2 // 4 # 除法，得到一個整數
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32
>>> 2 & (2 - 1)
0
>>> 8 & (8 - 1)
0
>>> 16 & (16 - 1)
0
2、比較運算子
以下假設變數a為10，變數b為20：
| 運算子 | 描述 | 實體 |
|---|---|---|
| == | 等于 - 比較物件是否相等 | (a == b) 回傳 False， |
| != | 不等于 - 比較兩個物件是否不相等 | (a != b) 回傳 True， |
| > | 大于 - 回傳x是否大于y | (a > b) 回傳 False， |
| < | 小于 - 回傳x是否小于y，所有比較運算子回傳1表示真，回傳0表示假，這分別與特殊的變數True和False等價，注意，這些變數名的大寫， | (a < b) 回傳 True， |
| >= | 大于等于 - 回傳x是否大于等于y， | (a >= b) 回傳 False， |
| <= | 小于等于 - 回傳x是否小于等于y， | (a <= b) 回傳 True， |
以下實體演示了Python所有比較運算子的操作：
#!/usr/bin/python3
a = 21
b = 10
c = 0
if ( a == b ):
print ("1 - a 等于 b")
else:
print ("1 - a 不等于 b")
if ( a != b ):
print ("2 - a 不等于 b")
else:
print ("2 - a 等于 b")
if ( a < b ):
print ("3 - a 小于 b")
else:
print ("3 - a 大于等于 b")
if ( a > b ):
print ("4 - a 大于 b")
else:
print ("4 - a 小于等于 b")
# 修改變數 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
print ("5 - a 小于等于 b")
else:
print ("5 - a 大于 b")
if ( b >= a ):
print ("6 - b 大于等于 a")
else:
print ("6 - b 小于 a")
以上實體輸出結果：
1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a
# 值比較
# 小于
>>> y < x
True
# 小于等于
>>> x <= x
True
# 大于
>>> x > y
True
# 大于等于
>>> x >= y
True
# 等于
>>> x == x
True
# 不等于
# for Python2
>>> x != y
True
>>> x <> y
True
# for Python3
>>> x != y
True
# 地址比較
>>> id(x), id(521)
(140428868352096, 140428868352072)
>>> x is 521
False
3、賦值運算子
向記憶體申請一空閑記憶體單元存盤數字然后將變數名指向此記憶體單元,至此可通過變數名操作此記憶體單元資料
以下假設變數a為10，變數b為20：
| 運算子 | 描述 | 實體 |
|---|---|---|
| = | 簡單的賦值運算子 | 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 |
| := | 海象運算子，可在運算式內部為變數賦值，Python3.8 版本新增運算子， | 在這個示例中，賦值運算式可以避免呼叫 len() 兩次:if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)") |
以下實體演示了Python所有賦值運算子的操作：
實體(Python 3.0+)
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值為：", c)
c += a
print ("2 - c 的值為：", c)
c *= a
print ("3 - c 的值為：", c)
c /= a
print ("4 - c 的值為：", c)
c = 2
c %= a
print ("5 - c 的值為：", c)
c **= a
print ("6 - c 的值為：", c)
c //= a
print ("7 - c 的值為：", c)
以上實體輸出結果：
1 - c 的值為： 31
2 - c 的值為： 52
3 - c 的值為： 1092
4 - c 的值為： 52.0
5 - c 的值為： 2
6 - c 的值為： 2097152
7 - c 的值為： 99864
:point_right：混合運算子優先級問題可通過括號()提升優先級解決
:point_right：混合型別的轉換以復雜度為基準,會自動轉換至復雜度最高的型別
多個變數賦值
Python允許你同時為多個變數賦值，例如：
a = b = c = 1
以上實體，創建一個整型物件，值為 1，從后向前賦值，三個變數被賦予相同的數值，
您也可以為多個物件指定多個變數，例如：
a, b, c = 1, 2, "runoob"
以上實體，兩個整型物件 1 和 2 的分配給變數 a 和 b，字串物件 "runoob" 分配給變數 c，
4、位運算子
按位運算子是把數字看作二進制來進行計算的，Python中的按位運演算法則如下：
下表中變數 a 為 60，b 為 13二進制格式如下：
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
| 運算子 | 描述 | 實體 |
|---|---|---|
| & | 按位與運算子：參與運算的兩個值,如果兩個相應位都為1,則該位的結果為1,否則為0 | (a & b) 輸出結果 12 ，二進制解釋： 0000 1100 |
| | | 按位或運算子：只要對應的二個二進位有一個為1時，結果位就為1， | (a | b) 輸出結果 61 ，二進制解釋： 0011 1101 |
| ^ | 按位異或運算子：當兩對應的二進位相異時，結果為1 | (a ^ b) 輸出結果 49 ，二進制解釋： 0011 0001 |
| ~ | 按位取反運算子：對資料的每個二進制位取反,即把1變為0,把0變為1，~x 類似于 -x-1 | (~a ) 輸出結果 -61 ，二進制解釋： 1100 0011， 在一個有符號二進制數的補碼形式， |
| << | 左移動運算子：運算元的各二進位全部左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0， | a << 2 輸出結果 240 ，二進制解釋： 1111 0000 |
| >> | 右移動運算子：把">>"左邊的運算元的各二進位全部右移若干位，">>"右邊的數指定移動的位數 | a >> 2 輸出結果 15 ，二進制解釋： 0000 1111 |
以下實體演示了Python所有位運算子的操作：
實體(Python 3.0+)
按位運算子是把數字看作二進制來進行計算的，Python中的按位運演算法則如下：
下表中變數 a 為 60，b 為 13二進制格式如下：
#!/usr/bin/python3
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b; # 12 = 0000 1100
print ("1 - c 的值為：", c)
c = a | b; # 61 = 0011 1101
print ("2 - c 的值為：", c)
c = a ^ b; # 49 = 0011 0001
print ("3 - c 的值為：", c)
c = ~a; # -61 = 1100 0011
print ("4 - c 的值為：", c)
c = a << 2; # 240 = 1111 0000
print ("5 - c 的值為：", c)
c = a >> 2; # 15 = 0000 1111
print ("6 - c 的值為：", c)
>>> bin(x)
'0b1000001001'
# 左移,可結合賦值運算<<=
"""
規則: 左
"""
>>> bin(x << 2)
'0b100000100100'
# 右移,可結合賦值運算>>=
>>> bin(x >> 2)
'0b10000010'
# 位與,可結合賦值運算&=
"""
規則: 都為1為1,否則為0
100000100100
000010000010
------------
000000000000
"""
>>> 0b100000100100 & 0b10000010
0
# 位或,可結合賦值運算|=
"""
規則: 存在1為1,否則為0
100000100100
000010000010
------------
100010100110
"""
>>> 0b100000100100 | 0b10000010
2214
# 異或,可結合賦值運算^=
"""
規則: 不同為1,相同為0
100000100100
000010000010
----------
100010100110
"""
>>> 0b100000100100 ^ 0b10000010
2214
# 取反,可結合賦值運算～=
"""
規則: 1變為0,0變為1
0000001000001001
----------------
1111110111110110 取反,此時最高位為1表示負數,負數的存盤需要將其轉換為補碼
----------------
1000001000001001 反碼,保持符號位不變,其它位置取反
----------------
1000001000001010 補碼,在反碼的基礎上最低位+1
----------------
-522
"""
>>> ~0b1000001001
-522
👉 位或運算等同于十進制加法,基于此值之上與運算元位與等同于求運算元,反之與運算元取反位與等同于求被運算元,通常被用于權限模型
In [44]: x = 521
In [45]: bin(x)
Out[45]: '0b1000001001'
In [46]: x << 2
Out[46]: 2084
In [48]: bin(2084)
Out[48]: '0b100000100100'
In [52]: x << 5
Out[52]: 16672
In [53]: bin(16672)
Out[53]: '0b100000100100000'
//
In [49]: x >> 2
Out[49]: 130
In [50]: bin(130)
Out[50]: '0b10000010'
In [51]: 2084 & 130 # 與操作
Out[51]: 0
>>> bin(x)
'0b1000001001'
# 左移,可結合賦值運算<<=
"""
規則: 左
"""
>>> bin(x << 2)
'0b100000100100'
# 右移,可結合賦值運算>>=
>>> bin(x >> 2)
'0b10000010'
# 位與,可結合賦值運算&=
"""
規則: 都為1為1,否則為0
100000100100
000010000010
------------
000000000000
"""
>>> 0b100000100100 & 0b10000010
0
# 位或,可結合賦值運算|=
"""
規則: 存在1為1,否則為0
100000100100
000010000010
------------
100010100110
"""
>>> 0b100000100100 | 0b10000010
2214
# 異或,可結合賦值運算^=
"""
規則: 不同為1,相同為0
100000100100
000010000010
----------
100010100110
"""
>>> 0b100000100100 ^ 0b10000010
2214
# 取反,可結合賦值運算～=
"""
規則: 1變為0,0變為1
0000001000001001
----------------
1111110111110110 取反,此時最高位為1表示負數,負數的存盤需要將其轉換為補碼
----------------
1000001000001001 反碼,保持符號位不變,其它位置取反
----------------
1000001000001010 補碼,在反碼的基礎上最低位+1
----------------
-522
"""
>>> ~0b1000001001
-522
👉 位或運算等同于十進制加法,基于此值之上與運算元位與等同于求運算元,反之與運算元取反位與等同于求被運算元,通常被用于權限模型
5、邏輯運算子
Python語言支持邏輯運算子，以下假設變數 a 為 10, b為 20:
| 運算子 | 邏輯運算式 | 描述 | 實體 |
|---|---|---|---|
| and | x and y | 布爾"與" - 如果 x 為 False，x and y 回傳 x 的值，否則回傳 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 |
以上實體輸出結果：
實體(Python 3.0+)
# 與, 都為真為真
>>> x and y
52.1
# 或, 一個真即真
>>> x or y
521
# 非,總是隱式轉換為布爾物件
>>> not x
False
以上實體輸出結果：
1 - 變數 a 和 b 都為 true
2 - 變數 a 和 b 都為 true，或其中一個變數為 true
3 - 變數 a 和 b 有一個不為 true
4 - 變數 a 和 b 都為 true，或其中一個變數為 true
5 - 變數 a 和 b 都為 false，或其中一個變數為 false
# 與, 都為真為真
In [38]: x
Out[38]: 521
In [39]: y
Out[39]: 6
In [40]: x and y
Out[40]: 6
# 或, 一個真即真
In [41]: x or y
Out[41]: 521
# 非,總是隱式轉換為布爾物件
>>> not x
False
In [42]: x = 0
In [43]: not x
Out[43]: True
6、成員運算子
除了以上的一些運算子之外，Python還支持成員運算子，測驗實體中包含了一系列的成員，包括字串，串列或元組，
| 運算子 | 描述 | 實體 |
|---|---|---|
| in | 如果在指定的序列中找到值回傳 True，否則回傳 False， | x 在 y 序列中 , 如果 x 在 y 序列中回傳 True， |
| not in | 如果在指定的序列中沒有找到值回傳 True，否則回傳 False， | x 不在 y 序列中 , 如果 x 不在 y 序列中回傳 True， |
以下實體演示了Python所有成員運算子的操作：
實體(Python 3.0+)
以上實體輸出結果：
1 - 變數 a 不在給定的串列中 list 中
2 - 變數 b 不在給定的串列中 list 中
3 - 變數 a 在給定的串列中 list 中
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， |
注： id() 函式用于獲取物件記憶體地址，
# 為避免頻繁分配釋放記憶體,解釋器預先將-5~256的小整數作為索引將值存入small_ints串列對應的記憶體單元
# 至此宣告變數右側值為小整數時會首先在small_ints串列中索引是否存在,如果存在則直接將變數名指向此地址
>>> n1 = 1
>>> n2 = 1
>>> n1 is n2
True
>>> n1 = 521
>>> n2 = 521
>>> n1 is n2
False
# 對于單行多個賦值的特殊情況,如果值相同會將變數名指向同一塊兒記憶體單元
>>> n1 = 521; n2 = 521; n3 = 521
>>> n1 is n2 is n3
True
以下實體演示了Python所有身份運算子的操作：
實體(Python 3.0+)
以上實體輸出結果：
1 - a 和 b 有相同的標識
2 - a 和 b 有相同的標識
3 - a 和 b 沒有相同的標識
4 - a 和 b 沒有相同的標識
is 與 == 區別：
is 用于判斷兩個變數參考物件是否為同一個， == 用于判斷參考變數的值是否相等，
>>>a = [1, 2, 3] >>> b = a >>> b is a True >>> b == a True >>> b = a[:] >>> b is a False >>> b == a True
運算子優先級
以下表格列出了從最高到最低優先級的所有運算子：
| 運算子 | 描述 |
|---|---|
| ** | 指數 (最高優先級) |
| ~ + - | 按位翻轉, 一元加號和減號 (最后兩個的方法名為 +@ 和 -@) |
| * / % // | 乘，除，求余數和取整除 |
| + - | 加法減法 |
| >> << | 右移，左移運算子 |
| & | 位 'AND' |
| ^ | | 位運算子 |
| <= < > >= | 比較運算子 |
| == != | 等于運算子 |
| = %= /= //= -= += *= **= | 賦值運算子 |
| is is not | 身份運算子 |
| in not in | 成員運算子 |
| not and or | 邏輯運算子 |
以下實體演示了Python所有運算子優先級的操作：
實體(Python 3.0+)
以上實體輸出結果：
(a + b) * c / d 運算結果為： 90.0
((a + b) * c) / d 運算結果為： 90.0
(a + b) * (c / d) 運算結果為： 90.0
a + (b * c) / d 運算結果為： 50.0
and 擁有更高優先級:
實體
以上實體輸出結果：
yes
注意：
Pyhton3 已不支持 <> 運算子，可以使用 != 代替，如果你一定要使用這種比較運算子，可以使用以下的方式：
>>> from __future__ import barry_as_FLUFL >>> 1 <> 2 True
【第十一小節：python流程控制】
1、概念
控制事物的執行流程就是流程控制
2、執行流程的三種情況
順序結構：自上而下運行
分支結構：在運行程序中根據條件的不同可能會執行不同的流程
回圈結構：在運行程序中會有些代碼需要反復執行
3、必知必會
1、條件都會轉成布林值，從而決定子代碼是否執行
2、在python中，使用縮進來代表代碼的從屬關系（四個空格）
3、并不是所有的代碼都可以擁有子代碼
4、同屬于某個代碼的多行子代碼，必須保持相同的縮進量
小技巧：在上一行代碼的結尾如果是冒號，那么下一行代碼比縮進
if語法
??
1、單分支（單if）
#語法：
# if 條件：
# 條件成立之后執行的代碼塊
#示例：
age = 18
if age < 20:
print('你很漂亮')
2、雙分支（if 和else一起使用）
#語法：
# if 條件1：
# 條件1成立之后執行的代碼塊
# else ：
# 條件不成立后執行的代碼塊
#示例：
age = 29
if age < 20:
print('你很漂亮')
else:
print('認錯人了')
3、多分支（if、elif以及else共同使用）
#語法：
# if 條件1：
# 條件1成立之后執行的代碼塊
# elif 條件2：
# 條件1不成立條件，2成立之后執行的代碼塊
# else 條件3:
# 條件1和2都不成立，條件3成立之后執行的代碼塊
#示例：
age = 19
if age < 20:
print('你很漂亮')
elif age <29:
print('你好啊')
else:
print('不好意思認錯人了')
4、if嵌套
age_of_girl = 20
height = 171
weight = 99
is_pretty = True
success = False
if age_of_girl >= 20 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:
if success:
print('表白成功,在一起')
else:
print('下次再見')
else:
print('阿姨好')
小練習
# jason管理員 tony安保人員 kevin財務 jack銷售 其他普通員工
# 1.獲取用戶名
username = input('你的名字:')
# 2.判斷用戶名身份
if username == 'jason':
print('管理員')
elif username == 'tony':
print('安保')
elif username == 'kevin':
print('財務')
elif username == 'jack':
print('銷售')
else:
print('普通員工')
while回圈
??
1、語法
while 條件:
條件成立之后執行的子代碼塊
2、基本用法示例
i = 1
while i <= 5:
print(i)
i += 1
3、while+break
break：結束本層回圈
while True:
# 1.獲取用戶輸入的用戶名和密碼
username = input('username>>>:')
password = input('password>>>:')
# 2.判斷用戶名和密碼是否正確
if username == '小明' and password == '123':
print('輸入正確')
# 直接結束本層回圈
break
else:
print('輸入錯誤')
4、全域標志位
tag = True
while tag:
# 1.獲取用戶輸入的用戶名和密碼
username = input('username>>>:')
password = input('password>>>:')
# 2.判斷用戶名和密碼是否正確
if username == '小明' and password == '123':
print('輸入正確')
# 直接結束本層回圈
tag = False
else:
print('輸入錯誤')
5、while嵌套
# while嵌套
while True:
# 1.獲取用戶輸入的用戶名和密碼
username = input('username>>>:')
password = input('password>>>:')
# 2.判斷用戶名和密碼是否正確
if username == '小明' and password == '123':
print('輸入正確')
while True:
cmd = input('請輸入您的指令>>>:')
# 判斷用戶是否想退出
if cmd == 'q':
break
print('正在執行您的指令:%s' % cmd)
break
else:
print('輸入錯誤')
案例
猜年齡的游戲
普通要求
用戶可以有三次猜錯的機會 如果程序中猜對了直接退出
拔高要求
三次機會用完之后提示用戶是否繼續嘗試 如果是則再給三次機會 如果否則直接結束
普通要求
# 1.先撰寫猜年齡主體功能
# 定義一個真實的年齡
real_age = 18
# 3.定義一個計數器
count = 1
# 2.先加一個回圈功能
while count < 4:
# 1.1 獲取用戶猜測的年齡
guess_age = input('請輸入您猜測的年齡>>>:')
# 1.2 簡單粗略的將字串轉換成數字(可能會報錯 暫時不要考慮)
guess_age = int(guess_age)
# 1.3 猜測年齡
if guess_age > real_age:
print('猜大了')
# 4.1 每次猜錯都加一
count += 1
elif guess_age < real_age:
print('猜小了')
# 4.1 每次猜錯都加一
count += 1
else:
print('哎呀 你真棒 猜對了!!!')
# 4.猜對了直接結束本層回圈
break
# 優化
# count += 1
拔高要求
# 1.先撰寫猜年齡主體功能
# 定義一個真實的年齡
real_age = 18
# 3.定義一個計數器
count = 1
# 2.先加一個回圈功能
while True:
# 5.判斷當前用戶是第幾次嘗試
if count == 4:
choice = input('您已經嘗試了三次 是否繼續(y/n)>>>:')
# 5.1 判斷用戶輸入的是y還是n
if choice == 'y':
# 重置count的次數
count = 1
else:
print('再接再厲')
break
# 1.1 獲取用戶猜測的年齡
guess_age = input('請輸入您猜測的年齡>>>:')
# 1.2 簡單粗略的將字串轉換成數字(可能會報錯 暫時不要考慮)
guess_age = int(guess_age)
# 1.3 猜測年齡
if guess_age > real_age:
print('猜大了')
# 4.1 每次猜錯都加一
count += 1
elif guess_age < real_age:
print('猜小了')
# 4.1 每次猜錯都加一
count += 1
else:
print('哎呀 你真棒 猜對了!!!')
# 4.猜對了直接結束本層回圈
break
# 優化
# count += 1
6、while+continue
continue表示結束本次回圈，直接進入下一次回圈
# 使用while回圈列印出0-10但是不列印4
# 1.定義一個起始變數
count = 0
# 2.回圈
while count < 11:
# 5.判斷 如果count為4則不列印
if count == 4:
count += 1
# 跳過本次回圈 開始下一次回圈
continue
# 3.列印變數的值
print(count)
# 4.變數值自增1
count += 1
continue會讓回圈體代碼直接回到條件判斷處重新判斷
7、while+else
count = 0
while count < 5:
print(count)
count += 1
else:
print('呵呵') # 會執行else子代碼
count = 0
while count < 5:
if count == 3:
break
print(count)
count += 1
else:
print('呵呵') # 不會執行else子代碼
"""
當while回圈沒有被人為中斷(break)的情況下才會走else
"""
8、死回圈
while True:
print(1)
for回圈
for回圈可以做的事情while都可以做，之所以使用for回圈是在回圈取值時，for回圈比while回圈的使用更為簡潔
1、語法
for 變數名 in 可迭代物件：#（此時只需要知道可迭代物件是字串、串列、字典，后面會專門講解）
代碼一
代碼二
ps:變數名如果沒有合適的名稱 那么可以使用i,j,k,v,item等
演示
# 串列
for i in ['a','b','c']:
print(i)
# 字串
for i in 'hello world':
print(i)
# 字典
d = {'name': '小明', 'age': 18, }
for k in d:
print(k, d[k])
2、range關鍵字
# 第一種:一個引數 從0開始 顧頭不顧尾
for i in range(10): # 0,1,2,3,4,5,6,7,8,9
print(i)
# 第二種:兩個引數 自定義起始位置 顧頭不顧尾
for i in range(4, 10): #4,5,6,7,8,9
print(i)
# 第三種:三個引數 第三個數字用來控制等差值
for i in range(2, 100, 10): # 2,12,22,32,42,52,62,72,82,92
print(i)
range在不同版本的解釋器中 本質不同
在python2.X中range會直接生成一個串列
在python2.X中有一個xrange也是迭代器
在python3.X中range是一個迭代器 節省記憶體空間
'''python2.X中xrange就是python3.x里面的range'''
具體如下
python2
??
??
python3
??
3、for+break
# break功能也是用于結束本層回圈h和while回圈一樣的作用
for i in range(10):
if i == 4:
break
print(i)
4、for+continue
# continue功能也是用于結束本層回圈h和while回圈一樣的作用
for i in range(10):
if i == 4:
continue
print(i)
5、for+else
# else也是在for回圈正常結束的情況下才會執行和while回圈一樣的作用
for i in range(10):
if i == 4:
break
print(i)
else:
print('123')
6、for回圈嵌套
# *****
# *****
# *****
for i in range(3):
for j in range(5):
print("*", end='')
print() # print()表示換行
# 1*1=1
# 2*1=2 2*2=4
# 3*1=3 3*2=6 3*3=9
# 4*1=4 4*2=8 4*3=12 4*4=16
# 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
# 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
# 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
# 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
# 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
for i in range(1, 10):
for j in range(1, i + 1):
print('%s*%s=%s' % (i, j, i * j), end=' ')
print()
# *
# ***
# *****
# *******
# *********
max_level = 5
for current_level in range(1, max_level + 1):
for i in range(max_level - current_level):
print(' ', end='') # 在一行中連續列印多個空格
for j in range(2 * current_level - 1):
print('*', end='') # 在一行中連續列印多個空格
prin
感謝每一個認真閱讀我文章的人，看著粉絲一路的上漲和關注，禮尚往來總是要有的，雖然不是什么很值錢的東西，如果你用得到的話可以直接拿走：
① 2000多本Python電子書（主流和經典的書籍應該都有了）
② Python標準庫資料（最全中文版）
③ 專案原始碼（四五十個有趣且經典的練手專案及原始碼）
④ Python基礎入門、爬蟲、web開發、大資料分析方面的視頻（適合小白學習）
⑤ Python學習路線圖（告別不入流的學習）
在我的QQ技術交流群里（技術交流和資源共享，廣告進來腿給你打斷）
學習資料可以找到我們呢的蓓蓓小姐姐【mashang-qq】備注【csdn000】免費領取哦
【必須備注】不然不會通過哦
可以自助拿走，群號913569736（備注“csdn000”）群里的免費資料都是筆者十多年測驗生涯的精華，還有同行大神一起交流技術哦，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/395125.html
標籤：python