Python基礎學習筆記(每日持續更新)
阿新 • • 發佈：2019-04-13
語音 message 進制轉化 無敵 del cde ref 隨機數 lib
第一章 計算機基礎
1.1 硬件
計算機基本的硬件由：CPU / 內存 / 主板 / 硬盤 / 網卡 / 顯卡 等組成，只有硬件但硬件之間無法進行交流和通信。需要操作系統進行協調工作
1.2 操作系統
操作系統用於協同或控制硬件之間進行工作，常見的操作系統有那些:
- windows,個人辦公系統,圖形窗口
- linux
- centos 【公司線上一般用】
- redhat 收費
- unbutu 圖形界面較好
- mac,個人開發使用,人機交互較好
1.3 解釋器或編譯器
編程語言的開發者寫的一個工具，將用戶寫的代碼轉換成010101交給操作系統去執行。
1.3.1 解釋和編譯型語言
解釋型語言就類似於： 實時翻譯，代表：Python / PHP / Ruby / Perl
編譯型語言類似於：說完之後，整體再進行翻譯，代表：C / C++ / Java / Go ...
1.4 軟件（應用程序）
軟件又稱為應用程序，就是我們在電腦上使用的工具，類似於：記事本 / 圖片查看 / 遊戲
1.5 進制
對於計算機而言無論是文件存儲 / 網絡傳輸輸入本質上都是：二進制（010101010101），如：電腦上存儲視頻/圖片/文件都是二進制； QQ/微信聊天發送的表情/文字/語言/視頻 也全部都是二進制。
進制：
- 2進制，計算機內部。
- 8進制
- 10進制，人來進行使用一般情況下計算機可以獲取10進制，然後再內部會自動轉換成二進制並操作。
- 16進制，一般用於表示二進制（用更短的內容表示更多的數據）。
第二章 Python入門
2.1 環境的安裝
- 解釋器：py2 / py3 （環境變量）
- 環境安裝參見https://blog.csdn.net/ling_mochen/article/details/79314118
- 開發工具：pycharm
2.2 編碼
2.2.1 編碼基礎
- ascii:只針對英語編碼,8位表示一個東西,共有2**8個,unicode 分為 ecs2 (2字節) 和 ecs4 (4字節).
- unicode:萬國碼,32位表示一個東西,共有2**32個;
- utf-8:給unicode壓縮優化,用盡量少的位數表示一個東西;(8意思是8的倍數),3個字節表示中文.
- gbk:兩個字節表示中文.
- gb2312
2.2.2 python編碼相關
輸入
- py2: num = raw_input("提示輸入內容")
- py3 : num= input("提示輸入內容")
輸出
- py2: print "小鉆風"
- py3: print("小鉆風")
對於Python默認解釋器編碼：
- py2： 默認解釋器編碼ascii
- py3： 默認解釋器編碼utf-8
如果想要修改默認編碼，則可以使用：
# -*- coding:utf-8 -*- 註意：對於操作文件時，要按照：以什麽編寫寫入，就要用什麽編碼去打開。
2.3 變量
問：為什麽要有變量？
為某個值創建一個“外號”，以後在使用時候通過此外號就可以直接調用。
- 變量要求
- 變量只能由數字,字母和下劃線組成
- 數字不能開頭,不能純數字
- 不能包含python關鍵字
- 見名知意
- 命名方法下劃線命名,例:big_ox
2.4 if條件判斷
基本結構
if 條件 :
結果
else:
結果2.5while循環
while循環基本結構;
while 條件: 結果 # 如果條件為真，那麽循環則執行 # 如果條件為假，那麽循環不執行debug模式顯示每一步運行結果;
關鍵字
- break #終止當前循環;
- continue (繼續) #如果碰到continue,則退出當前循環,立即回到while條件位置.
while else #while條件不再滿足時執行else.
2.6for循環
(公共功能)
for循環基本結構
for 新變量 in 原變量:
? 結果 ----------------循環取出原變量的字符賦值給新變量
name = 'bigox'
for new_name in name:
print(new_name)- for循環中break和continue用法一樣
- 在使用循環中,有窮盡的優先考慮for循環,無窮盡的考慮while循環
range界限
# range(1,5,1) #第一個參數是範圍的起始位置,第二個參數是範圍的結束位置,第三個為步長,默認為1,取值顧首不顧尾.
for num in range(1,9):
print(num) #=======>輸出為1-82.7運算符(特殊)
算數運算
- %取余
- **冪
- //整除
比較運算
- ==比較對象是否相等
- !=不等於
賦值運算
- += 加法賦值: c+=a <==> c =c+a
邏輯運算
- bool類型數字0和空字符串‘‘是False,其余是True.
and "與"
v = 1 and 9 =====> v = 9 #如果第一個值轉換為布爾值時如果為True,則v=第二個值; v1 = 0 and 1 =====> v = 0 #如果第一個值轉換為布爾值時如果為False,則v=第一個值; v1 = 0 and '' =====> v = 0 #如果有多個and,從左到右進行判斷.or "或"
v = 1 or 9 =====> v = 1 #如果第一個值轉換為布爾值時如果為True,則v=第一個值; v1 = 0 or 1 =====> v = 1 #如果第一個值轉換為布爾值時如果為False,則v=第二個值; v1 = 0 or '' =====> v = '' #如果有多個or,從左到右進行判斷.not "非"
- 在沒有()的情況下,not優先級大於and,and優先級大於or,即 () >not >and > or.同一優先級從左往右計算.
- 先進行數學運算,在進行邏輯運算
補充:
in / not in
#示例:(是否包含敏感字符) while True: text = input('請輸入你要說的話:') if '傻逼'in text: print('包涵敏感字符')
第三章 數據類型
3.1 整型（int）
3.1.1 整型的長度
py2中有：int/long
py3中有：int （int/long）
3.1.2 整除
py2和py3中整除是不一樣。
py2除法只能取整數,py3除法取全部值
py2除法取全部值,需要加代碼:
from future improt division
value = 3/2
print(value)
3.2 布爾（bool）
布爾值就是用於表示真假。True和False。
其他類型轉換成布爾值：
- str()
- ...
對於：None / "" / 0 .... -> false
3.3 字符串（str）
3.3.1字符串格式化:
字符串是寫代碼中最常見的，python內存中的字符串是按照：unicode 編碼存儲。對於字符串是不可變。
\n換行符
基本格式
name = input('請輸入姓名:') age = input('請輸入年齡:') job = input('請輸入工作:') hobby = input('請輸入愛好:') msg = ''' ---------- info of bigox ---------- Name :%s Age :%s Job :%s Hobby :%s ------------- end -------------''' print(msg%(小鉆風,500,it,girl,))- %s 表示字符串;
- %d 表示數字;
- %% 字符串格式化時表示百分數.
註意要點:
1.input 輸入內容全是字符串.
2.py版本輸入格式區別
- py2: name = raw_input(‘請輸入姓名‘)
- py3: name = input(‘請輸入姓名‘)
3.3.2字符操作方法
字符串 str:upper/lower/isdecimal/strip/replace/split/startswith/endswith/format/encode/join
大寫： upper
v = 'ALEX' v1 = v.upper() print(v1) v2 = v.isupper() # 判斷是否全部是大寫 print(v2)小寫：lower
v = 'alex' v1 = v.lower() print(v1) v2 = v.islower() # 判斷是否全部是小寫 print(v2) ############ 了解即可 v = '?' # 將字符串變小寫（更牛逼） v1 = v.casefold() print(v1) # ss v2 = v.lower() print(v2)判斷是否是數字： isdecimal
v = '1' # v = '二' # v = '②' v1 = v.isdigit() # '1'-> True; '二'-> False; '②' --> True v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False v3 = v.isnumeric() # '1'-> True; '二'-> True; '②' --> True print(v1,v2,v3) # 推薦用 isdecimal 判斷是否是 10進制的數。 # ############## 應用 ############## v = ['alex','eric','tony'] for i in v: print(i) num = input('請輸入序號：') if num.isdecimal(): num = int(num) print(v[num]) else: print('你輸入的不是數字')去空白+\t+\n + 指定字符串.strip()
v1 = "alex " print(v1.strip()) v2 = "alex\t" print(v2.strip()) v3 = "alex\n" print(v3.strip()) v1 = "alexa" print(v1.strip('al'))替換 replace
#.replace() message = input('請輸入"大傻逼"') new_mes = message.replace('傻逼','**') print(new_mes) #.replace('原字符','替換字符','替換個數').startswith() 判斷是否以()開頭,輸出值為bool類型
name = 'bigox' print(name.startswith('big')).endswith() 同.startswith()用法相同
.format()格式(同字符串格式化)
name = '我叫:{0},年齡:{1}'.format('bigox',24)
print(name)
- .encode() :編碼轉換
name = '劉' #解釋器讀取到內存後,按照unicode編碼存儲:8字節.
print(name.encode('utf-8')) #轉化為utf-8編碼
? 10 .join()循環每個元素,並在元素之間加入連接符.
name = 'bigox'
new_name = '_'.join(name)
print(new_name) #輸出結果為 b_i_g_o_x
分割:字符串切割後形成列表
#.split() name = 'abcdefg' new_name = name.split('d') print(new_name) #.split('分割點',分割次數)- 分割時引用字母或數字分割時該字母數字消失,如果是標點符號,則不消失.
3.4 列表list
列表獨有方法
** .append()列表最後追加元素**
lst = ["麻花藤", "林俊傑", "周潤發", "周芷若"] print(lst) lst.append("wusir") print(lst).insert在指定的索引位置插入元素
lst = ["麻花藤", "林俊傑", "周潤發", "周芷若"] print(lst) lst.insert(1,"wusir") print(lst).remove()指定元素刪除
.remove("指定元素")
.pop()刪除索引元素:()如果沒有索引值的話默認刪除出最後一個
.pop(索引)
.clear()清空
del[ ]切片刪除
.extend()添加
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"] s = 'qwert' li.extend(s) print(li) #--------------------------- lst = ["王誌文", "張一山", "苦海無涯"] lst.extend(["麻花藤", "麻花不疼"]) print(lst)reverse反轉
v = [1,2,3,4,5,6]
v.reverse()
print() #[6, 5, 4, 3, 2, 1]
- sort排序
v = [1,3,7,4,5,6]
v.sort()
print() #[1, 3, 4, 5, 6, 7]
#v.sort() 從小到大排序(默認)
#v.sort(reverse=True) 從大到小排序
列表轉字符串:
nums = [11,22,33,44] for a in range(0,len(nums)): nums[a] = str(nums[a]) result = ''.join(nums) print(result)3.5元組tuple
元組為不可變類型
元組子元素不可變,而子元素內部的子元素是可以變的,取決於元素是否為可變對象
元組中如果只有一個元素,一定要添加一個逗號,否者不是元組(1,)
可嵌套
3.5字典dict
字典:幫助用戶表示事物的信息(事物有多個屬性)
基本格式:字典鍵的數據類型不能為list和tuple,值可以為任何類型.
dictionary = {'鍵':'值','鍵':'值','鍵':'值'}
獨有功能:
info = {"name":'劉偉達','age':18,'gender':'男','hobby':'同桌'}獲取字典info所有鍵.keys()
for i in info.keys(): print(i)獲取字典info所有值.values()
for i in info.values(): print(i)獲取字典info所有的鍵值對.items()
for i in info.items(): print(i).get()取值
info = {'k1':'v1','k2':'v2'} a = info.get('k1') print(a) #v1 info2 = ['11111'] b = info.get('11111',22222) print(b) #22222.update()更新,存在就更改,不存在增加
info = {'k1':'v1','k2':'v2'} info.update({'k1':'v0','k3':'v3'}) print(info) #{'k1': 'v0', 'k2': 'v2', 'k3': 'v3'}
****判斷是否存在敏感字符
in/not in 是否包涵(輸出類型為bool類型)
str/list/tuple/dict都適用
# # 經典例題 # # # 讓用戶輸入任意字符串，然後判斷此字符串是否包含指定的敏感字符。 #char_list = ['利奇航','堂有光','炸展會'] #content = input('請輸入內容：') # 我叫利奇航 / 我是堂有光 / 我要炸展會 char_list = ['利奇航','堂有光','炸展會'] i = True content = input('請輸入內容:') for mes in char_list: if mes in content: i = False break if i: print(無敏感字符) else: print(包含敏感字符)
3.6集合set
- 在集合中True與數字1重復,False與數字0重復
- 列表, 字典和集合為可更改類型,不可哈希,不能存放在集合當中.
集合獨有功能,
.add() 添加
.discard()刪除
要修改,需要先刪除再添加
.clear()清空
.update()
info = {'k1','k2'} info.update({'k1','k3','v3'}) print(info) #{'k1','k2','k3','v3'}.intersection() 交集
? 命令後的 () 可以是集合,也可以是列表.
info = {1,2,3} print(info.intersection({1,3,4})) #{1,3}.union()並集
info = {1,2,3} print(info.union({1,3,4})) #{1,2,3,4}.difference()差集
info = {1,2,3} print(info.union({1,3,4})) #{2,4}
3.7 公共功能
- len
- 索引
- 切片
- 步長
- for循環
- 列表, 字典和集合為可更改類型,不可哈希,不能存放在集合當中.也不能作為字典的鍵.
3.8內存相關
id(查看內存地址)
賦值更改內存地址,內部變更改變量的值
內存地址
a = 1 b = 1 id(a) = id(b) #按理說a與b的id不該一樣,但是在python中,為了提高運算性能,對某些特殊情況進行了緩存.(小數據池)緩存對象: 1. 整型： -5 ~ 256 2. 字符串："alex",'asfasd asdf asdf d_asdf ' ----"f_*" * 3 - 重新開辟內存。== 與is 區別
- ==比較的是值是否一致
- is 比較內存地址是否一致
對str,int,bool,tuple不可變數據類型深淺拷貝都一樣,對於list,dict,set可變數據類型才有區別
############## 示例 ############ v1 = 'alex' import copy #固定格式 v2 = copy.copy(v1) print(id(v1),id(v2))淺拷貝 copy.copay()
- 拷貝第一層.
深拷貝 copy.deepcopy()
- 拷貝嵌套層次中的所有可變類型
3.9各數據類型常用操作總結
一.數字/整型int
- int()強行轉化數字
二.bool類型False&True
- bool()強行轉化布爾類型.
- 0,None,及各個空的字符類型為False.其余均為Ture.
三.字符串str
str()強行轉化字符串
#列表轉化字符換 nums = [11,22,33,44] for a in range(0,len(nums)): nums[a] = str(nums[a]) result = ''.join(nums) print(result).upper()轉化大寫
name = 'abc' new_name = name.upper() print(new_name).lower()轉化小寫
name = 'ABC' new_name = name.lower() print(new_name).replace()替換
message = input('請輸入"大傻逼"') new_mes = message.replace('傻逼','**') print(new_mes) #.replace('原字符','替換字符','替換個數').strip()去首尾空格
name = ' abc ' new_name = name.strip() print(new_name) #.rstrip()去除右側空格 .lstrip()去除左側空格.split()分割
name = 'abcdefg' new_name = name.split('d') print(new_name) #.split('分割點',分割次數).isdecimal()判斷是否可以轉化位數字
while True: num = input('請輸入內容:') num1= num.isdigit() #print(num1) 數字的話輸出True,非數字輸出FALSE if num1: print('你輸入正確') break else: print('請輸入數字').startswith() 判斷是否以()開頭,輸出值為bool類型
name = 'bigox' print(name.startswith('big'))endswith() 判斷是否以()結尾,輸出值為bool類型 同.startswith()用法相同
.format()格式(同字符串格式化)
name = '我叫:{0},年齡:{1}'.format('bigox',24) print(name).encode() :編碼轉換
name = '劉' #解釋器讀取到內存後,按照unicode編碼存儲:8字節. print(name.encode('utf-8')) #轉化為utf-8編碼.join()循環每個元素,並在元素之間加入連接符.
name = 'bigox' new_name = '_'.join(name) print(new_name) #輸出結果為 b_i_g_o_x
四.列表list
列表轉換list()
#列表轉化字符換 nums = [11,22,33,44] for a in range(0,len(nums)): nums[a] = str(nums[a]) result = ''.join(nums) print(result).pop(索引)
a = li.pop(2) #在列表中刪除,並將刪除的此數據賦值給a
name = ['bigox','xo','ox'] name.pop(1) print(name)del 列表 [索引]
name = ['bigox','xo','ox'] del name[0:2] print(name).append()列表最後追加元素
lst = ["麻花藤", "林俊傑", "周潤發", "周芷若"] print(lst) lst.append("wusir") print(lst).insert()在指定的索引位置插入元素
lst = ["麻花藤", "林俊傑", "周潤發", "周芷若"] print(lst) lst.insert(1,"wusir") print(lst)remove()**指定元素刪除
name = ['bigox','xo','ox'] name.remove(xo) print(name).clear()**清空
.extend**()添加
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"] s = 'qwert' li.extend(s) print(li) #--------------------------- lst = ["王誌文", "張一山", "苦海無涯"] lst.extend(["麻花藤", "麻花不疼"]) print(lst).reverse()反轉
v = [1,2,3,4,5,6] v.reverse() print() #[6, 5, 4, 3, 2, 1].sort排序
v = [1,3,7,4,5,6] v.sort() print() #[1, 3, 4, 5, 6, 7] #v.sort() 從小到大排序(默認) #v.sort(reverse=True) 從大到小排序
五.元組tuple
強制轉換：
tuple(‘adfadfasdfasdfasdfafd‘)
v1 = tuple('adfadfasdfasdfasdfafd') print(v1) # ('a', 'd', 'f', 'a', 'd', 'f', 'a', 's', 'd', 'f', 'a', 's', 'd', 'f', 'a', 's', 'd', 'f', 'a', 'f', 'd')tuple([11,22,33,44])
v1 = tuple([11,22,33,44]) print(v1) # (11, 22, 33, 44)
元組子元素不可變,而子元素內部的子元素是可以變的,取決於元素是否為可變對象
元組中如果只有一個元素,一定要添加一個逗號,否者不是元組
六.字典dict
字典鍵的數據類型不能為list和tuple,值可以為任何類型.
.keys()取鍵
for i in info.keys(): print(i).values()取值
for i in info.values(): print(i).items()取鍵值對
for i in info.items(): print(i).get()以鍵取值,如果鍵不存在返回原定結果
info = {'k1':'v1','k2':'v2'} a = info.get('k1') print(a) #v1 info2 = ['11111'] b = info.get('11111',22222) print(b) #22222.update()更新_存在覆蓋更新,不存在添加
info = {'k1':'v1','k2':'v2'} info.update({'k1':'v0','k3':'v3'}) print(info) #{'k1': 'v0', 'k2': 'v2', 'k3': 'v3'}
七.集合set
無序,不可重復
在集合中True與數字1重復,False與數字0重復
.add() 添加
info = {'k1','k2'} info.add('k3') print(info).discard()刪除
info = {'k1','k2','k3'} info.discard('k3') print(info)要修改,需要先刪除再添加
.clear()清空
.update()
info = {'k1','k2'} info.update({'k1','k3','v3'}) print(info) #{'k1','k2','k3','v3'}.intersection() 交集
? 命令後的 () 可以是集合,也可以是列表.
info = {1,2,3} print(info.intersection({1,3,4})) #{1,3}.union()並集
info = {1,2,3} print(info.union({1,3,4})) #{1,2,3,4}.difference()差集
info = {1,2,3} print(info.union({1,3,4})) #{2,4}
第四章 文件操作
4.1 文件基本操作
obj = open('路徑',mode='模式',encoding='編碼')
obj.write()
obj.read()
obj.close()
4.2 打開模式
基本模式
#打開文件
f=open('要打開文件路徑',mode='r/w/a/',encoding='文件原來編碼') #f為接收變量
#操作文件
data = f.() # 讀取文件內部全部內容,data為接收內容
f.write('要寫內容')
#關閉文件
f.close()
#文件打開新操作,自動關閉
with open('text.txt',mode= 'a',encoding='utf-8') as v:
data = a.read()
# 縮進中的代碼執行完畢之後自動關閉
r / w / a
r+ / w+ / a+
rb / wb / ab
r+b / w+b / a+b
w/wb
w 模式傳入的是字符串,寫入時計算機進行了兩步操作:
將寫入內容根據指定編碼encoding轉換為對應二進制語言
# 字符串轉化為二進制 mes = '示例' a = mes.encode('utf-8') #二進制文件轉化為字符串 mes = '01010101010100' a = mes.decode('utf-8')將二進制寫入到文件裏
- 一般用於文字寫入
wd 模式傳入的是二進制文件,想寫入字符串需要進行轉換操作
- 要把寫入內容先轉化為二進制語言(encode)
- wd再將二進制文件寫入文件
- 一般用於圖片/音頻/視頻/未知編碼寫入
r/rb
- r 讀取時計算機進行了兩步操作:
- 讀取硬盤上的二進制
- 按照指定編碼轉換成對應文件
- rb 讀取到的是二進制數據,不進行任何轉換.
a/ab
- 用法類比w/r
4.3 操作
read() , 全部讀到內存
read(1)
1表示一個字符
obj = open('a.txt',mode='r',encoding='utf-8') data = obj.read(1) # 1個字符 obj.close() print(data)1表示一個字節
obj = open('a.txt',mode='rb') data = obj.read(3) # 1個字節 obj.close()
write(字符串)
obj = open('a.txt',mode='w',encoding='utf-8') obj.write('中午你') obj.close()write(二進制)
obj = open('a.txt',mode='wb') # obj.write('中午你'.encode('utf-8')) v = '中午你'.encode('utf-8') obj.write(v) obj.close()seek(光標字節位置)，無論模式是否帶b，都是按照字節進行處理。
obj = open('a.txt',mode='r',encoding='utf-8') obj.seek(3) # 跳轉到指定字節位置 data = obj.read() obj.close() print(data) obj = open('a.txt',mode='rb') obj.seek(3) # 跳轉到指定字節位置 data = obj.read() obj.close() print(data)tell(), 獲取光標當前所在的字節位置
obj = open('a.txt',mode='rb') # obj.seek(3) # 跳轉到指定字節位置 obj.read() data = obj.tell() print(data) obj.close()flush，強制將內存中的數據寫入到硬盤
v = open('a.txt',mode='a',encoding='utf-8') while True: val = input('請輸入：') v.write(val) v.flush() v.close()
4.4 關閉文件
文藝
v = open('a.txt',mode='a',encoding='utf-8')
v.close()二逼
with open('a.txt',mode='a',encoding='utf-8') as v:
data = v.read()
# 縮進中的代碼執行完畢後，自動關閉文件
4.5 文件內容的修改
with open('a.txt',mode='r',encoding='utf-8') as f1:
data = f1.read()
new_data = data.replace('飛灑','666')
with open('a.txt',mode='w',encoding='utf-8') as f1:
data = f1.write(new_data)
- 大文件修改
- 在大文件讀取時,不能一次性讀取,需要按字節read(字節數)或for循環按行讀取
with open('a.txt',mode='r',encoding='utf-8') as f1,open('b.txt',mode='w',encoding='utf-8') as f2: #打開文件a,b
for line in f1: #按行取a的內容
new_line = line.replace('666','999') #修改內容
f2.write(new_line) #修改後的寫入b,完成修改
第五章 函數
5.1函數基礎
三元(目)運算:
v = 前面 if 條件 else 後面 #條件為真v=前面,條件為假v=後面 #等同於 if 條件： v = '前面' else: v = '後面' #示例: # 讓用戶輸入值，如果值是整數，則轉換成整數，否則賦值為None data = input('>>>') value = int(data) if data.isdecimal() else None函數定義:函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。函數能提高應用的模塊性，和代碼的重復利用率。
5.1.1.基本結構
def 函數名():
# 函數內容
pass #pass占位符,沒有任何操作
# 函數的執行
函數名()
函數如果不被調用,內部代碼將不被執行.
運行示例
def get_list_first_data(): v = [11,22,33,44] print(v[0]) get_list_first_data()
5.1.2參數
參數分為動態參數和靜態參數,又叫動參和形參.
def get_list_first_data(aaa): # aaa叫形式參數(形參) v = [11,22,33,44] print(v[aaa]) get_list_first_data(1) # 2/2/1調用函數時傳遞叫：實際參數（實參）小練習
# 1. 請寫一個函數，函數計算列表 info = [11,22,33,44,55] 中所有元素的和。 def get_sum(): info = [11,22,33,44,55] data = 0 for item in info: data += item print(data) get_sum() # 2. 請寫一個函數，函數計算列表中所有元素的和。 def get_list_sum(a1): data = 0 for item in a1: data += item print(data) get_list_sum([11,22,33]) get_list_sum([99,77,66]) v1 = [8712,123,123] get_list_sum(v1) # 3. 請寫一個函數，函數將兩個列表拼接起來。 def join_list(a1,a2): result = [] result.extend(a1) result.extend(a2) print(result) join_list([11,22,33],[55,66,77] # 4. 計算一個列表的長度 def my_len(arg): count = 0 for item in arg: count += 1 print(count) v = [11,22,33] my_len(v) len(v)
5.1.3 返回值return
return後續代碼不會被執行
只能返回一次
如果要返回多個數據，可先把多個數據包裝成一個整體。整體返回（列表、元組、字典.......）
def caculate(a, b): he = a + b cha = a - b return (he, cha)小練習
# 1. 讓用戶輸入一段字符串，計算字符串中有多少A字符的個數。有多少個就在文件a.txt中寫多少個“李邵奇”。 def get_char_count(data): sum_counter = 0 for i in data: if i == 'A': sum_counter += 1 return sum_counter def write_file(line): if len(line) == 0: return False # 函數執行過程中，一旦遇到return，則停止函數的執行。 with open('a.txt',mode='w',encoding='utf-8') as f: f.write(line) return True content = input('請輸入:') counter = get_char_count(content) write_data = "李邵奇" * counter status = write_file(write_data) if status: print('寫入成功') else: print('寫入失敗') # 2. 寫函數，計算一個列表中有多少個數字，打印： 列表中有%s個數字。 # 提示：type('x') == int 判斷是否是數字。 """ # 方式一： def get_list_counter1(data_list): count = 0 for item in data_list: if type(item) == int: count += 1 msg = "列表中有%s個數字" %(count,) print(msg) get_list_counter1([1,22,3,'alex',8]) # 方式二： def get_list_counter2(data_list): count = 0 for item in data_list: if type(item) == int: count += 1 return count v = get_list_counter1([1,22,3,'alex',8]) msg = "列表中有%s個數字" %(v,) print(msg) """ # 2. 寫函數，計算一個列表中偶數索引位置的數據構造成另外一個列表，並返回。 """ # 方式一： def get_data_list1(arg): v = arg[::2] return v data = get_data_list1([11,22,33,44,55,66]) # 方式二： def get_data_list2(arg): v = [] for i in range(0,len(arg)): if i % 2 == 0: v.append(arg[i]) return v data = get_data_list2([11,22,33,44,55,66]) """ # 3. 讀取文件，將文件的內容構造成指定格式的數據，並返回。 """ a.log文件 alex|123|18 eric|uiuf|19 ... 目標結構： a. ["alex|123|18","eric|uiuf|19"] 並返回。 b. [['alex','123','18'],['eric','uiuf','19']] c. [ {'name':'alex','pwd':'123','age':'18'}, {'name':'eric','pwd':'uiuf','age':'19'}, ] """ #c問答案: def read_log(txt):#定義函數 l=['name','age','job'] l1 = [] with open(txt, mode='r', encoding='utf-8') as f: for mes in f:#取f行,'alex|123|18','eric|uiuf|19' count=0 dic={} for v in mes.strip().split('|'):#mes.split()切割字符串['alex','123','18'] dic[l[count]]=v #取鍵賦值 count +=1 l1.append(dic) print(l1) read_log('a.log')
5.2參數祥解
實際參數可以是任何值
函數沒有返回值,默認返回None
函數內部執行時,遇到return就終止運行
return可以返回任何數據類型的值,多個值時返回元組
# enconding: utf-8 def test(): return 1,2,3 print(test()) #(1, 2, 3)
5.2.1傳參
傳參:調用函數並傳遞參數,實參與形參必須一一對應
位置傳參:嚴格按照位置先後順序傳參
關鍵字傳參:直接賦值傳參,無先後順序
混合傳參:位置參數與關鍵字參數混合使用,位置參數一定在關鍵字參數之前
def func(a1, a2): print(a1, a2) func(a2=99,a1=2) # 關鍵字傳參數和位置傳參可以混合使用（位置傳入的參數 > 關鍵字參數在後 = 總參數個數） def func1(a1, a2, a3): print(a1, a2, a3) # func(1, 2, a3=9) # func(1, a2=2, a3=9) # func(a1=1, a2=2, a3=9) # func(a1=1, 2,3) # 錯誤
5.2.2 默認參數
- 默認參數:在函數建立時定義好的參數.
- 默認參數可傳可不傳.不傳參使用默認值,傳遞參數相當於重新對默認參數賦值.
5.2.3 *參數 萬能參數(打散)
(*args)只接收位置參數
格式(*參數)可以接收多個參數,但是只支持位置傳參
實參傳遞到形參時是以元組形式傳遞
傳參時實參前加星(*實參),先把實參打散,再傳參到形參
def func(*args): print(args) func(1) func(1,2) # args=(1, 2) func((11,22,33,44,55)) # args=((11,22,33,44,55),) func(*(11,22,33,44,55)) # args=(11,22,33,44,55)
5.2.4 **參數 萬能參數
**(kwargs)
只接收關鍵
字參數
實參傳遞到形參時是以字典形式傳遞{‘k‘=v}
傳參時實參前加**,直接傳遞字典
def func(*args,**kwargs): print(args,kwargs) # func(1,2,3,4,5,k1=2,k5=9,k19=999) func(*[1,2,3],k1=2,k5=9,k19=999) func(*[1,2,3],**{'k1':1,'k2':3}) func(111,222,*[1,2,3],k11='alex',**{'k1':1,'k2':3})
註意:一般*args與**kwargs一起使用,這是超級無敵萬能參數
經典例題:
# def func(*args,**kwargs):
# print(args,kwargs)
# # a. 執行 func(12,3,*[11,22]) ，輸出什麽？
# # b. 執行 func(('alex','武沛齊',),name='eric')
'''a.(12,3,11,22) {}
b.(('alex','武沛齊'),) {'name':'eric'}'''
參數重點總結
- 調用（執行）函數時，傳參：位置參數 > 關鍵字參數
- 定義函數：
- def func(a)
- def func(a,b=None) # 對於默認值，如果是可變類型，----> 坑。
- def func(*args,**kwargs)
5.3作用域
作用域就是作用範圍，按照生效範圍可以分為全局作用域和局部作用域。
python
- 一個py文件是一個全局作用域
- 一個函數是一個作用域
作用域中查找數據規則:優先查找自己局域內數據,自己沒有再去父級作用域查找,以此類推,可以找到,可以修改,不能為父級作用域的變量重新賦值.
global ‘全局,全球‘強制更改全局作用作用域 ,先global+變量,再對變量賦值
nonlocal ‘外地‘ 強制更改父級作用域變量 ,先nonlocal+變量,再對變量賦值
# 示例一 name = ["老男孩",'alex'] def func(): global name name = '我' func() print(name) # ############################## nonlocal name = "老男孩" def func(): name = 'alex' def inner(): nonlocal name # 找到上一級的name name = 999 inner() print(name) func() print(name)全局作用域:全局作用域內的數據公用
- 全局變量全部大寫
局部作用域:局部作用域可以使用全局作用域內的數據,但是全局作用域使用不了局部作用域的數據即
- 局部變量正常變量定義
函數的作用域鏈：小範圍作用域可以使用大範圍的變量，但是反之不行，他是單向的。
函數內只可以調用全局作用域的函數
# x = 10 # def func(): # x = 9 # print(x) # def x1(): # x = 999 # print(x) # print(x) # x1() # # func() # x = 10 # def func(): # x = 8 # print(x) # def x1(): # x = 999 # print(x) # x1() # print(x) # # func() # x = 10 # def func(): # x = 8 # print(x) # def x1(): # print(x) # x1() # print(x) # # func() # x = 10 # def func(): # x = 8 # print(x) # def x1(): # print(x) # x = 9 # x1() # x = 10 # print(x) # # func()作用域小結
- 函數為作用域
- 自己 > 父級 > 父級 > 全局 【讀/修改（可變）】
- 重新賦值：
- global 全局
- nonlocal 外層
5.4高級函數
函數可以當做變量來使用:
def func(): print(123) func_list = [func, func, func] # func_list[0]() # func_list[1]() # func_list[2]() for item in func_list: v = item() print(v)函數可以當做參數進行傳遞,誰調用的函數返回值就給誰.
def func(arg): print(arg) func(1) func([1,2,3,4]) def show(): return 999 func(show)子作用域只能讀取或修改父級的值，不能重新賦值。
#經典例題 ---------------企業面試題-------- def func(): print('花費查詢') def bar(): print('語音溝通') def base(): print('xxx') def show(): print('xxx') def test(): print('xxx') info = { 'f1': func, 'f2': bar, 'f3':base, 'f4':show, 'f5':test } choice = input('請選擇要選擇功能：') function_name = info.get(choice) if function_name: function_name() else: print('輸入錯誤')函數當做返回值
高級一點的內置函數(了解,懂什麽意思)
map(函數,可叠代對象),映射函數,循環每個元素,然後讓每個元素執行函數,將每個函數執行的結果保存到新的列表,並返回.
v1 = [11,22,33,44] result = map(lambda x:x+100,v1) print(list(result)) # 特殊fifter(函數,可叠代對象),篩選過濾,循環每個元素然後執行函數,將每個函數執行的結果篩選保存到新的列表並返回.
result = filter(lambda x: True if type(x) == int else False ,v1) print(list(result)) result = filter(lambda x: type(x) == int ,v1) print(list(result))reduce(函數,可叠代對象),循環每個元素,然後執行函數,將每個函數執行的結果刪選保存到新的列表並返回.
import functools v1 = ['wo','hao','e'] def func(x,y): return x+y result = functools.reduce(func,v1) print(result) result = functools.reduce(lambda x,y:x+y,v1) print(result)
5.5 lambda表達式
# 三元運算，為了解決簡單的if else的情況，如：
if 1 == 1:
a = 123
else:
a = 456
a = 123 if 1 == 1 else 456 #經典格式
# lambda表達式，為了解決簡單函數的情況，如：
def func(a1,a2):
return a1 + 100
func = lambda a1,a2: a1+100 #經典格式列表所有方法返回值基本都是None,出了pop會返回要刪除的元素
字符串所有方法返回值基本都是新值
# 練習題 USER_LIST = [] func1 = lambda x: USER_LIST.append(x) v1 = func1('alex') print(v1) print(USER_LIST) # 練習題 func1 = lambda x: x.split('l') v1 = func1('alex') print(v1)
5.6內置函數
自定義函數:自我編寫函數.
內置函數:python系統內置函數.
lambda表達式也叫匿名函數.
函數與函數之間的數據互不影響,每次運行函數都會開一個辟新的內存.
item = 10 def func(): item = 2 def inner(): print(item) for item in range(10): pass inner() func()- 函數銷毀條件:
- 函數運行完畢
- 函數內部元素沒有被其他使用
- 可叠代數據類型:可被for循環的類型
內置函數 含義 len,open,range,id,type print,input,強制轉換命令 ... abs() 絕對值 float() 浮點型 max() 最大值 min() 最小值 sum() 求和 divmod() 兩數相除的商和余數(頁面選擇) pow() 指數運算pow(2,3)= 2**3=8 bin() 十進制轉化為二進制 oct() 十進制轉化為八進制 int() 其他進制轉化為十進制 hex() 十進制轉化為十六進制 chr() 十進制數字轉換成unicode編碼中的對應字符串 ord() 根據字符在unicode編碼中找到其對應的十進制 len,open,range,id,type
print,input
強制轉換
數學相關
abs，絕對值
v = abs(-1) print(v)float，轉換成浮點型（小數）
v = 55 v1 = float(55) print(v1)max，找到最大值
v = [1,2,311,21,3,] result = max(v) print(result)min，找最小值
v = [1,2,311,21,3,] result = min(v) print(result)sum，求和
v = [1,2,311,21,3,] result = sum(v) print(result)divmod，兩數相除的商和余數
a,b = divmod(1001,5) print(a,b)# 經典______________練習題 請通過分頁對數據進行展示 """ 要求： 每頁顯示10條數據 讓用戶輸入要查看的頁面：頁碼 """ USER_LIST = [] for i in range(1,836): temp = {'name':'你少妻-%s' %i,'email':'123%[email protected]' %i } USER_LIST.append(temp) # 數據總條數 total_count = len(USER_LIST) # 每頁顯示10條 per_page_count= 10 # 總頁碼數 max_page_num,a = divmod(total_count,per_page_count) if a>0: max_page_num += 1 while True: pager = int(input('要查看第幾頁：')) if pager < 1 or pager > max_page_num: print('頁碼不合法，必須是 1 ~ %s' %max_page_num ) else: """ # 第1頁：USER_LIST[0:10] -> 0123456789 # 第2頁：USER_LIST[10:20] # 第3頁：USER_LIST[20:30] ... """ start = (pager-1) * per_page_count end = pager * per_page_count data = USER_LIST[start:end] for item in data: print(item)
進制轉換:
十進制數轉化為其他進制時十進制數必須是整型.
其他進制轉化為十進制時其他進制數必須是字符串,並在字符串後註明多少進制.
bin，將十進制轉化成二進制
num = 13 v1 = bin(num) print(v1)oct，將十進制轉換成八進制,
num = 8 v1 = oct(num) print(v1)int，將其他進制轉化成十進制
# 二進制轉化成十進制 v1 = '0b1101' result = int(v1,base=2) print(result) # 八進制轉化成十進制 v1 = '0o1101' result = int(v1,base=8) print(result) # 十六進制轉化成十進制 v1 = '0x1101' result = int(v1,base=16) print(result)hex，將十進制轉換成十六進制
num = 16 v1 = hex(num) print(v1)
----企業面試題------
# 1字節等於8位 # IP: 192.168.12.79 -> 001010010 . 001010010 . 001010010 . 001010010 # 1. 請將 ip = "192.168.12.79" 中的每個十進制數轉換成二進制並通過,連接起來生成一個新的字符串。 ip = "192.168.12.79" ip_list = ip.split('.') # ['192','168','12','79'] result = [] for item in ip_list: result.append(bin(int(item))) print(','.join(result)) # 2. 請將 ip = "192.168.12.79" 中的每個十進制數轉換成二進制: # 0010100100001010010001010010001010010 -> 十進制的值。 # 3232238671
- 函數銷毀條件:
5.7閉包
應用場景:
- 裝飾器/SQLAIchemy源碼
函數可以作為變量
函數可以作為參數
函數可以作為返回值
def bar(): def inner(): print(123) return inner v = bar() v()閉包:為一個函數創建一塊區域(內部變量供自己使用),為他以後執行提供數據
# 基本格式 def func(name): def inner(): print(name) return inner v1 = func('alex') v1() v2 = func('eric') v2()#練習 # 第一題 name = 'alex' def base(): print(name) def func(): name = 'eric' base() func() # {name=eric, } # 第二題 name = 'alex' def func(): name = 'eric' def base(): print(name) base() func() # 第三題 name = 'alex' def func(): name = 'eric' def base(): print(name) return base base = func() base()閉包企業面試題
info = [] def func(i): def inner(): print(i) return inner for item in range(10): info.append(func(item)) info[0]() info[1]() info[4]()
5.8 內置模塊(.py文件)
1.將指定的字符串加密:
- 將指定的字符串加密md5加密
import hashlib
def get_md5(data):
obj = hashlib.md5()
obj.update(data.encode('utf-8'))
result = obj.hexdigest()
return result
val = get_md5('123')
print(val)加鹽
import hashlib def get_md5(data): obj = hashlib.md5("sxff123ad".encode('utf-8'))#md5(加入任意字符串增加密碼復雜度) obj.update(data.encode('utf-8')) result = obj.hexdigest() return result val = get_md5('123') print(val)
應用:
#賬戶密碼加密函數:
import hashlib
USER_LIST = []
def get_md5(data):
obj = hashlib.md5("gfdsjdxff123ad".encode('utf-8'))
obj.update(data.encode('utf-8'))
result = obj.hexdigest()
return result
#用戶註冊:
def register():
print('**************用戶註冊**************')
while True:
user = input('請輸入用戶名:')
if user == 'N':
return
pwd = input('請輸入密碼:')
temp = {'username':user,'password':get_md5(pwd)}
USER_LIST.append(temp)
#用戶登錄
def login():
print('**************用戶登陸**************')
user = input('請輸入用戶名:')
pwd = input('請輸入密碼:')
for item in USER_LIST:
#校驗新輸入密碼加密後與用戶註冊加密是否相同
if item['username'] == user and item['password'] == get_md5(pwd):
return True
register()
result = login()
if result:
print('登陸成功')
else:
print('登陸失敗')2.隨機驗證碼模塊應用:
- chr() 十進制數字轉換成unicode編碼中的對應字符串
- ord() 根據字符在unicode編碼中找到其對應的十進制
- random.randit(最小值,最大值) 生產隨機數
#生產隨機驗證碼
import random
def get_random_code(length=6):
data = []
for i in range(length):
v = random.randint(65,90) #random.randit(最小值,最大值) 生產隨機數
data.append(chr(v))
return ''.join(data)
code = get_random_code()
print(code)
import random # 導入一個模塊
v = random.randint(起始,終止) # 得到一個隨機數
3.密碼不顯示（只能在終端運行）
import getpass
pwd = getpass.getpass('請輸入密碼：')
if pwd == '123':
print('輸入正確')
認識苦短,我學Python.每日持續更新
Python基礎學習筆記(每日持續更新)