print()函數(shù)
print(520)
print('Hello world')
print('Hello world')
print(3 1)
#將數(shù)據(jù)輸出文件中
fp=open('d:/text.txt','a ') #a 如果文件不存在就創(chuàng)建,,存在就在文件內(nèi)容的后面繼續(xù)追加
print('Hello world',file=fp)
fp.close()
#逗號,,不進行換行輸出(輸出內(nèi)容在一行當中)
print('Hello','World','Python')
轉(zhuǎn)義字符
- 什么是轉(zhuǎn)移字符?
- 反斜杠 想要實現(xiàn)的轉(zhuǎn)移功能首字母,。
- 為什么需要轉(zhuǎn)移字符,?
- 當字符串中包含反斜杠、單引號和雙引號等有特殊用途的字符時,,必須使用反斜杠對這些字符進行轉(zhuǎn)義(轉(zhuǎn)換一個含義)
- 當字符串中包含換行,、回車,,水平制表符或退格等無法直接表示的特殊字符時,也可以使用轉(zhuǎn)義字符當字符串中包含換行,、回車,,水平制表符或退格等無法直接表示的特殊字符時,也可以使用轉(zhuǎn)義字符
- 換行:\n
- 回車:\r
- 水平制表符:\t
- 退格:\b
print('Hello\nworld')
print('Hello\tworld')
print('Hello\bworld')
print('http:\\\\www.baidu.com')
print('老實說:\'大家好\'')
#原字符,,讓字符串中的轉(zhuǎn)移字符不起作用
print(r'Hello\nworld')
二進制與字符編碼
print(chr(0b100111001011000)) #0b表示二進制
print(ord('乘'))
Python中的標識符和保留字
變量的定義和使用
name='馬麗亞'
print(name)
print('標識',id(name))
print('類型',type(name))
print('值',name)
數(shù)據(jù)類型
針對浮點類型(float)存儲不精確的問題,,解決方案是:導(dǎo)入模塊 decimal
from decimal import Decimal
print(Decimal('1.1') Decimal('2.2')) #不會出現(xiàn)小數(shù)位不精確的情況了
布爾型(bool)可以轉(zhuǎn)換成整數(shù)型
print(True 1)
字符串類型可以使用單引號、雙引號,、三引號定義,,其中:單引號、和雙引號定義的字符串必須在一行,,三引號的字符串可以分布在連續(xù)的多行
str4='''人生苦短
我用Python'''
數(shù)據(jù)類型轉(zhuǎn)換
name='張三'
age=20
print(type(name),type(age))
print('我叫' name ',,今年' str(age) '歲。') #將 int 類型通過 str() 轉(zhuǎn)換成字符串類型,。
Python中的注釋
input()輸入函數(shù)
作用:接收來自用戶的輸入
返回值類型:輸入值的類型為str
值的存儲:使用=對輸入的值進行存儲
present=input('大圣想要什么禮物呢,?')
a=input('請輸入一個加數(shù):') #輸入的數(shù)字為str類型的
a=int(a) #對輸入的數(shù)據(jù)轉(zhuǎn)換
b=input('請輸入另一個加數(shù):') #輸入的數(shù)字為str類型的
b=int(b) #對輸入的數(shù)據(jù)轉(zhuǎn)換
print(a b)
#第二種方式實現(xiàn)
a=int(input('請輸入一個加數(shù):'))
b=int(input('請輸入另一個加數(shù):'))
Python中的運算符
#取余運算符
print(11%2) #等于1,余數(shù)是1
#冪運算符
print(2**2) #表示 2 的 2 次方
print(2**3) #表示 2 的 3次方,,也就是 2*2*2 = 8
#賦值運算符舉例
a=20
a =30
print(a) #結(jié)果是50,,相當于 a 30
#解包賦值舉例
a,b,c=20,30,40 #左右個數(shù)需一致
#比較運算符的結(jié)果為bool類型,比較的是值
# is 標識比較符
print('a>b嗎,?',a>b) # False
print(a==b) # True 表示 a 與 b 的 value 相等
print(a is b) # True 表示 a 與 b 的 id標識相等
print(a is not b) # False id標識符不相等
# in 與 not in 比較符
s='helloworld'
print('w' in s) #True
print('k' in s) #False
print('w' not in s) #False
print('k' not in s) #True
print(4&8) #按位與&,,同為1時結(jié)果為1
print(4|8) #按位或|,同為0時結(jié)果為0
print(4<<1) #向左移動1位,,相當于 乘以 2
print(4>>2) #向右移動2位,,相當于 除以 4
程序的組織結(jié)構(gòu)
三種基本結(jié)構(gòu)組成:順序結(jié)構(gòu)、選擇結(jié)構(gòu),、循環(huán)結(jié)構(gòu)
Python一切皆對象,,所有對象都有一個布爾值
# 單分支結(jié)構(gòu)
money=1000
s=int(input('請輸入取款金額:'))
if money>=s:
money=money-s
print('取款成功,,余額為:',money)
# 雙分支結(jié)構(gòu)
if money>=s:
money=money-s
print('取款成功,,余額為:',money)
else:
print('余額不足')
# 多分支結(jié)構(gòu)
score=int(input('請輸入一個成績:'))
if score>=90 and score<=100:
print('A級')
elif score>=70 and score<=89:
print('B級')
elif score>=60 and score<=69:
print('C級')
elif score>=0 and score<=59:
print('D級')
else:
print('對不起,成績輸入有誤,。')
# 還可以用下面語法表達
if 90<=score<=100:
print('A級')
elif 70<=score<=89:
print('B級')
elif 60<=score<=69:
print('C級')
elif 0<=score<=59:
print('D級')
else:
print('對不起,,成績輸入有誤。')
# 使用條件表達式進行比較
a=10
b=20
print(str(a) '大于等于' str(b) if a>=b else str(a) '小于' str(b))
# pass語句,,什么都不做,,只是一個占位符,用到需要寫語句的地方,,用于前期搭建代碼結(jié)構(gòu)的地方
if answer=='y':
pass
else:
pass
# while 循環(huán)
a=1
while a<10:
print(a)
a =1
# for-in 循環(huán)
for item in 'python':
print(item)
# break 語句,,用于結(jié)束循環(huán)結(jié)構(gòu),,通常與分支結(jié)構(gòu) if 一起使用
# continue 語句,用于結(jié)束當前循環(huán),,進入下一個循環(huán),,通常與分支結(jié)構(gòu) if 一起使用
- else 與語句
- 與 else 語句配合使用的三種情況為:if-else \ while-else \ for-else
列表
lst=['hello','world',98]
- 創(chuàng)建列表第二種方式,,使用內(nèi)置函數(shù) list()
lst2=(['hello','world',98])
列表的特點
列表元素按順序有序排序
索引映射唯一個數(shù)據(jù)
列表可以存儲重復(fù)數(shù)據(jù)
任意數(shù)據(jù)類型混存
根據(jù)需要動態(tài)分配和回收內(nèi)存
列表的查詢操作
- 查詢列表中存在N個相同元素,,只返回相同元素中的第一個元素的索引
- 如果查詢的元素在列表中不存在,則會拋出ValueError
- 還可以在指定的 start 和 stop 之間進行查詢
lst=['hello','world',89,'hello']
print(lst.index('hello')) #如果存在相同元素,,只返回相同元素第一個元素的索引
print(lst.index('python')) #拋出 IndexError 錯誤
print(lst.index('hello',1,3)) #指定范圍內(nèi),,查找索引 1 和 2
- 正向索引從1到N-1 舉例:lst[0]
- 逆向索引從-N到-1 舉例:lst[-N]
- 指定索引不存在,拋出 IndexError
lst=['hello','world',98,'hello','world',234]
print(lst[2]) #獲取索引為2的元素
print(lst[-3]) #逆向獲取索引為-3的元素
- 獲取列表中的多個元素
語法格式
列表名 [ start : stop : step ]
#start stop step 為空時默認為 0,、最大索引,、1
print(lst[::1]) #正向step
print(lst[::-1]) #逆向step
- 判斷指定元素在列表中是否存在 in 、not in
語法格式
元素 in 列表名
元素 not in 列表名
print(10 in lst)
print(10 not in lst)
- 遍歷列表元素 for-in
語法格式
for 迭代變量 in 列表名:
for item in lst:
print(item)
列表元素的增加操作
lst.append(100) #在列表末尾添加一個元素
lst.extend(lst2) #在列表末尾至少添加一個元素
lst.insert(1,90) #在列表的任意位置添加一個元素
lst[1:]=lst3 #在列表的任務(wù)位置添加至少一個元素,,從索引1往后的元素切掉,,lst3替換進來
列表元素的刪除操作
lst.remove(30) #刪除一個元素,如果有重復(fù)元素,,只刪除第一個元素,,如果元素不存在則拋錯 ValueError
lst.pop(1) #刪除索引為1的元素
lst.pop(5) #刪除索引為5的元素,如果指定的索引位置不存在將拋錯,,如果不指定參數(shù)則刪除列表最后一個元素
lst[1:3]=[] #切片,,將當前列表的1到3索引的元素通過傳入空的方式刪除
lst2=lst[1:3] #切片,產(chǎn)生新的列表,,原列表不改變
lst.clear() #刪除列表中所有元素
del lst #刪除列表對象
列表元素的修改操作
lst[2]=100 #修改索引2的元素值為100
lst[1:3]=[300,400,500,600]
列表元素的排序操作
- 調(diào)用 sort() 方法,,列表中的所有元素默認按照從小到大的順序排序,可以指定 reverse=True,,進行降序排序
lst.sort()
lst.sort(reverse=True)
- 調(diào)用內(nèi)置函數(shù) sorted(),,可以指定 reverse=True,進行降序排序,,原列表不發(fā)生改變
lst2=sorted(lst) #函數(shù)產(chǎn)生新的列表對象
lst3=sorted(lst,reverse=True)
列表生成的公式
語法格式
# [ i*i for i in range(1,10) ]
#注意事項:“表示列表元素的表達式”中通常包含自定義變量
lst=[i for i in range(1,10)] #產(chǎn)生1到9的列表
lst=[i*2 for i in range(1,10)] #產(chǎn)生2,4,、6、8,、10的列表
字典
什么是字典
Python 內(nèi)置的數(shù)據(jù)結(jié)構(gòu)之一,,與列表一樣是一個可變序列
以鍵值對的方式存儲數(shù)據(jù),字典是一個無序的序列
字典的原理
字典以大括號表示
scores={ '張三':100,'李四':98,'王五':45 }
- 字典的實現(xiàn)原理與查字典類似,,查字典是先根據(jù)部首或拼音查找對應(yīng)的頁碼,,Python 中的字典是根據(jù) key 查找 value 所在的位置。
字典的創(chuàng)建與刪除
scores={ '張三':100,'李四':98,'王五':45 }
dict(name='jack',age=20)
字典的常用操作
- [] 舉例:scores['張三']
- get() 方法 舉例:scores.get('張三')
print(scores['張三']) #如果找不到,,則會拋錯
print(scores.get('張三')) #如果找不到,,則不會拋錯,,返回 None
print(scores.get('張三','默認值')) #如果找不到,提供默認值
- key 的判斷 in ,、not in
print('張三' in scores)
print('張三' not in scores)
- 元素刪除操作
del scores['張三'] #刪除指定的 key-value 對
5.清空字典的元素
scores.clear()
- 字典元素的新增
scores['Jack']=90
- 字典元素的修改
scores['Jack']=70
獲取字典視圖的三個方法
- keys() 獲取字典中所有 key
- values() 獲取字典中所有 value
- items() 獲取字典中所有 key,value 對
- 將字典轉(zhuǎn)換成列表
items=scores.items()
list(items)
字典元素的遍歷
for item in scores:
print(item,scores[item],scores.get(item)) #scores[item] 會拋錯,,scores.get(item) 不會
字典的特點
字典中的所有元素都是一個 key-value 對,key 不允許重復(fù),,value 可以重復(fù)
字典中的元素是無序的
字典中的 key 必須是不可變對象
字典也可以根據(jù)需要動態(tài)滴伸縮
字典會浪費較大的內(nèi)存,,是一種使用空間換時間的數(shù)據(jù)結(jié)構(gòu)
字典生成式
- 內(nèi)置函數(shù) zip()
用于將可迭代的對象作為參數(shù),將對象中對應(yīng)的元素打包成一個元組,,然后返回由這些元組組成的列表
items=['Fruits','Books','Others']
prices=[96,78,85]
lst=zip(items,prices)
print(list(lst))
d={item.upper():price for item,price in zip(items,prices)} #如果鍵值對數(shù)量不匹配,,以數(shù)量少的一方展示
元組
Python 內(nèi)置的數(shù)據(jù)結(jié)構(gòu)之一,是一個不可變序列
不可變序列和可變序列
不可變序列:字符串,、元組,,沒有增、刪,、改操作
可變序列:列表,、字典,可以對序列執(zhí)行增,、刪,、改操作,對象地址不發(fā)生更改
元組的創(chuàng)建方式
t=( 'Python','Hello', 90 )
t=tuple(( 'Python','Hello', 90 ))
t=(10, )
t='Python','Hello', 90
t=()
t=tuple()
為什么要將元組設(shè)計成不可變序列
- 在多任務(wù)環(huán)境下,,同時操作對象時不需要加鎖,,因此在程序中盡量使用不可變序列
- 注意事項:元組中存車處的是對象的引用
- 如果元組中對象本身不可對象,則不能再引用其他對象
- 如果元組中的對象是可變對象,,則可變對象的引用不允許改變,,但數(shù)據(jù)可以改變
元組的遍歷
- 元組是可迭代對象,使用可以使用 for-in 遍歷
t=tuple('Python','hello',90)
for item in t:
print(item)
集合
- Python 語言提供的內(nèi)置數(shù)據(jù)結(jié)構(gòu)
- 與列表,、字典一樣都屬于可變類型的序列
- 集合是沒有 value 的字典
集合的創(chuàng)建方式
s={ 'Python','hello',90 }
s={ 2,3,4,4,5,5,6,7,7 } #集合中的元素不允許重復(fù)(與字典相同)
s=set(range(6))
print(s)
print(set([3,4,53,56])) #將列表轉(zhuǎn)換成集合
print(set([3,4,43,435])) #將元組轉(zhuǎn)換成集合,,元素是無序的
print(set('Python')) #將字符串轉(zhuǎn)換為集合,按字母序列,,無序
print(set({124,3,4,4,5})) #集合
print(set()) #空集合
集合元素的判斷操作
s={10,20,30}
print(10 in s) #True
print(10 not in s) #False
集合元素的新增操作
- 調(diào)用 add() 方法,,一次添加一個元素
- 調(diào)用 update() 方法,至少添加一個元素
s.add(40) #添加一個元素
s.update({60,70,80}) #添加多個元素
# update() 里還可以放元組,、列表
集合元素的刪除操作
- 調(diào)用 remove() 方法,,一次刪除一個指定元素,如果指定元素不存在則拋出 KeyError
- 調(diào)用 discard() 方法,,一次刪除一個指定元素,如果指定元素不存在則不會拋出異常
- 調(diào)用 pop() 方法,,一次刪除一個任意元素
- 調(diào)用 clear() 方法,,清空集合
s.remove(10)
s.remove(500) #報錯
s.discard(500) #不會報錯
s.pop() #刪除任意元素,,隨機的刪除一個元素,該方法無參數(shù)
s.clear() #清空集合
集合間的關(guān)系
兩個集合是否相等
s1={1,2,3}
s2={3,2,1}
print(s1==s2) #True
print(s1!=s2) #False
一個集合是否是另一個集合的子集合
- 可以調(diào)用方法 issubset 判斷
- B 是 A 的子集
s1={1,2,3}
s2={3,2,1}
s3={1,2,5,6}
print(s2.issubset(s1)) #True
print(s3.issubset(s1)) #False
一個集合是否是另一個集合的超集
- 可以調(diào)用方法 issuperset 判斷
- A 是 B 的超集
print(s1.issuperset(s2)) #True
print(s3.issuperset(s2)) #False
兩個集合是否沒有交集
- 可以調(diào)用方法 isdisjoint 判斷
print(s2.isdisjoint(s3)) #False 有交集為 False
s4={100,200,300}
print(s2.isdisjoint(s4)) #True 沒有交集為 True
集合的數(shù)學(xué)操作
交集 intersection()
s1={1,2,3,4,5}
s2={3,4,5,6,7}
print( s1.intersection(s2) ) #執(zhí)行結(jié)果為 {3,4,5}
#簡寫為
print(s1 & s2)
并集 union()
print(s1.union(s2)) #執(zhí)行結(jié)果為 {1,2,3,4,5,6,7} ,,去掉了重復(fù)的元素
#簡寫為
print(s1 | s2)
差集 difference()
print(s1.difference(s2)) #執(zhí)行結(jié)果為 {1,2}
#簡寫為
print(s1-s2)
對稱差集 symmetric_difference()
print(s1.symmetric_difference(s2)) #執(zhí)行結(jié)果為 {1,2,6,7}
#簡寫為
print(s1^s2)
集合生成式
s={i*i for i in range(10)}
print(s)
總結(jié)列表,、字典、元組,、集合
字符串
字符串的駐留機制
-
字符串
-
在 Python 中字符串是基本數(shù)據(jù)類型,,是一個不可變的字符序列
-
什么叫字符串駐留機制呢?
-
僅保存一份相同且不可變字符串的方法,,不同的值被存放在字符串的主流池中,,Python 的主流機制對相同的字符串只保留一份拷貝,后續(xù)創(chuàng)建相同字符串時,,不會開辟新空間,,而是把該字符串的地址賦給新創(chuàng)建的變量
-
駐留機制的集中情況(交互模式)
- 字符串的長度為 0 或 1 時
- 符合標識符的字符串
- 例如%不符合標識符,,所以類似 abc% 的字符串創(chuàng)建兩個,,為兩個id地址的字符串,即內(nèi)容一樣地址不一樣
- 字符串只在編譯時進行主流,,而非運行時
a='abc'
b='ab' 'c'
c=''.join(['ab','c'])
print(a is b) #True a 和 b 是編譯時創(chuàng)建的,,地址相同
print(a is c) #False c 是運行時計算的,新開辟的內(nèi)存空間
- [-5,265] 之間的整數(shù)數(shù)字
a=-5
b=-5
print(a is b) #True 在整數(shù)數(shù)字區(qū)間內(nèi)
a=-6
b=-6
print(a is b) #False 不在整數(shù)數(shù)字區(qū)間內(nèi)
- sys 中的 intern 方法強制2個字符串指向同一個對象
import sys
a='abc%'
a='abc%'
print(a is b) #False 不符合標識符的不駐留
a=sys.intern(b)
print(a is b) #True 強制駐留
字符串駐留機制的優(yōu)缺點
- 當需要值相同的字符串時,,可以直接從字符串池中拿來使用,,避免頻繁創(chuàng)建和銷毀,提升效率和節(jié)約內(nèi)存,,因此拼接字符串和修改字符串是回比較影響性能的
- 在需要進行字符串拼接時建議使用 str 類型的 join 方法,,而非 ,因為 join() 方法是先計算出所有字符中的長度,,然后再拷貝,,只 new 一次對象,效率比 效率高
字符串的查詢操作方法
index()
rindex()
find()
rfind()
提示:日常操作中盡可能使用 find() 和 rfind()
字符串的大小寫轉(zhuǎn)換操作方法
upper()
lower()
swapcase()
- 把字符串中所有大寫字母轉(zhuǎn)成小寫字母,,把所有小姐字母轉(zhuǎn)成大寫字母
print('Hello,world'.swapcase()) # hELLO,WORLD
capitalize()
- 把第一個字符轉(zhuǎn)成大寫,把其余字符轉(zhuǎn)成小寫
print('Hello'.capitalize()) # Hello
title()
- 把每個單詞的第一個字符轉(zhuǎn)成大寫,,把每個單詞的剩余字符轉(zhuǎn)成小寫
print('Hello world'.swapcase()) # Hello World
字符串內(nèi)容對齊操作
center()
ljust()
rjust()
zfill()
字符串劈分操作
split()
- 從字符串左邊開始劈分,默認的劈分字符是空格字符串,,返回的值都是一個列表
- 以通過參數(shù) sep 指定劈分字符串是的劈分符
- 通過參數(shù) maxsplit 指定劈分字符串時的最大劈分次數(shù),在經(jīng)過最大次劈分后,,剩余的子串會單獨作為一部分
rsplit()
- 從字符串右邊開始劈分,默認的劈分字符是空格字符串,,返回的值都是一個列表
- 以通過參數(shù) sep 指定劈分字符串是的劈分符
- 通過參數(shù) maxsplit 指定劈分字符串時的最大劈分次數(shù),,在經(jīng)過最大次劈分后,剩余的子串會單獨作為一部分
字符串判斷操作
isidentifier()
isspace()
- 判斷指定的字符串是否全部由空白字符組成
isalpha()
- 判斷指定的字符串是否全部由字母組成
isdecimal()
- 判斷指定字符串是否全部由十進制的數(shù)字組成
isnumeric()
- 判斷指定的字符串是否全部由數(shù)字組成
isalnum()
- 判斷指定字符串是否全部由字母和數(shù)字組成
字符串其他的操作方法
replace()
- 字符串替換
join()
- 字符串合并
字符串的比較操作
字符串的切片操作
- 字符串切片后都將產(chǎn)生新的內(nèi)存對象
格式化字符串
name='張三'
age=20
print('我叫%s,,今年%d歲' % (name,age))
print('我叫{0},,今年{1}歲'.format(name,age))
print(f'我叫{name},今年{age}歲')
print('%10d' % 99) # 10表示寬度
print('%.3f' % 3.1415926) # 表示精度,,保留3位小數(shù)
print('{0:.3f}'.format(3.1415926)) #表示精度,,保留3位小數(shù)
print('{0:.3}'.format(3.1415926)) #表示一共是3位數(shù)
print('%10.3f' % 3.1415926) #同時表示寬度、精度
print('{0:10.3f}'.format(3.1415926)) #同時表示寬度,、精度
字符串的編碼轉(zhuǎn)換
函數(shù)
函數(shù)的創(chuàng)建和調(diào)用
- 函數(shù)就是執(zhí)行特定任何以完成特定功能的一段代碼
- 為什么需要函數(shù)
- 服用代碼
- 隱藏實現(xiàn)細節(jié)
- 提高可維護性
- 提高可讀性便于調(diào)試
#創(chuàng)建函數(shù)
def calc(a,b): # 形參,,形式參數(shù)
c=a b
return c
result=calc(10,20) #實參,實參的位置是函數(shù)的調(diào)用處
print(result)
函數(shù)的參數(shù)傳遞
- 兩種傳遞方式
- 位置實參:根據(jù)形參對應(yīng)的位置進行實參傳遞
- 關(guān)鍵字實參:根據(jù)形參名稱進行實參傳遞
#位置實參
def calc(a,b):
calc(10,20)
#關(guān)鍵字實參
def calc(b=20,a=10):
calc(10,20)
# 1.無返回值的函數(shù),,不用寫 return
def fun1():
print('hello')
# 2.有1個返回值的函數(shù),返回類型為原類型,,示例中返回的是 str
def fun2():
return 'hello'
res=fun2()
# 3.返回多個值,,返回類型為元組
def fun3():
return 'hello','world'
print(fun3())
# 函數(shù)在定義時,是否需要返回值,,視情況而定
函數(shù)的參數(shù)定義
- 函數(shù)定義默認值參數(shù)
- 給形參設(shè)置默認值,,只有與默認值不符的情況才需要傳遞實參
def fun(a,b=100):
print(a,b)
fun(100) # 當沒有給參數(shù) b 傳值時,b 默認值 100
fun(20,30)
- 個數(shù)可變的位置參數(shù)
- 定義函數(shù)時,,可能無法實現(xiàn)確定傳遞的位置實參的個數(shù)時,,使用可變的位置參數(shù)
- 使用 * 定義個數(shù)可變的位置形參
- 結(jié)果為一個元組
# 定義可變的位置參數(shù)
def fun(*args):
print(args)
# 調(diào)用函數(shù),傳入不同個數(shù)的參數(shù),,輸出的是元組
fun(10)
fun(10,30)
fun(10,30,50)
- 個數(shù)可變的關(guān)鍵字形參
- 定義函數(shù)時,,無法事先確定傳遞的關(guān)鍵字實參的個數(shù)時,使用可變的關(guān)鍵字形參
- 使用 ** 定義個數(shù)可變的關(guān)鍵字形參
- 結(jié)果為一個字典
def fun1(**args):
print(args)
fun1(a=10) # 結(jié)果為字典類型,,{'a':10}
fun1(a=20,b=30,c=40) # 結(jié)果為字典類型,,{'a:20,'b':30,'c':40}
- 在函數(shù)定義參數(shù)時,兩種類型的參數(shù)只能各自定義一個
- 但兩個類型的參數(shù)可以同時出現(xiàn)在一個函數(shù)參數(shù)內(nèi),,但順序是個數(shù)可變的位置參數(shù)定義在前,,個數(shù)可變的關(guān)鍵字形參定義在后
# 第一個參數(shù)為可變的位置參數(shù),第二個參數(shù)為可變的關(guān)鍵字參數(shù)
def fun3(*args1,**args2):
函數(shù)的參數(shù)總結(jié)
變量的作用域
定義函數(shù)
- 局部變量
- 在函數(shù)內(nèi)定義并使用的變量,,只在函數(shù)內(nèi)部游逍,,局部變量使用 global 聲明,,這個變量就會變成全局變量
- 全局變量
- 函數(shù)體外定義的變量,可作用于函數(shù)內(nèi)外
def fun(a,b): # a , b 為函數(shù)的形參
c=a b # c 局部變量
print(c)
name='楊老師' # name 全局變量
def fun2():
print(name)
def fun3():
global age # 在函數(shù)體內(nèi)定義的全局變量
age = 20
print(age)
fun3()
print(age) #在外部也可以訪問該變量
遞歸函數(shù)
- 如果在一個函數(shù)的函數(shù)體內(nèi)調(diào)用了該函數(shù)本身,,這個函數(shù)成為遞歸函數(shù)
- 遞歸調(diào)用與遞歸終止條件
- 每遞歸調(diào)用一次函數(shù),,都會在棧內(nèi)存分配一個棧幀
- 每執(zhí)行完一次函數(shù),,都會釋放響應(yīng)的空間
- 缺點:占用內(nèi)存多,,效率低下
- 有點:思路和代碼簡單
def fac(n):
if n==1:
return 1
else:
return n*fac(n-1)
print(fac(6))
異常處理
try-except 結(jié)構(gòu)
try:
a=int(input('請輸入第一個整數(shù):'))
b=int(input('請輸入第二個整數(shù):'))
result=a/b
print('結(jié)果為:',result)
except ZeroDivisionError: #捕獲為零的異常
print('除數(shù)不允許為0')
except ValueError: #捕獲值類型異常
print('請輸入數(shù)字')
except BaseException as e: # 最后寫上這個可以捕獲遺漏的、其他的異常
print('捕獲其他異常錯誤',e)
print('程序結(jié)束')
try-except-else 結(jié)構(gòu)
try:
a=int(input('請輸入第一個整數(shù):'))
b=int(input('請輸入第二個整數(shù):'))
result=a/b
except ZeroDivisionError: #捕獲為零的異常
print('除數(shù)不允許為0')
except ValueError: #捕獲值類型異常
print('請輸入數(shù)字')
except BaseException as e: # 最后寫上這個可以捕獲遺漏的,、其他的異常
print('捕獲其他異常錯誤',e)
else:
print('結(jié)果為:',result)
print('程序結(jié)束')
try-except-else-finally 結(jié)構(gòu)
try:
a=int(input('請輸入第一個整數(shù):'))
b=int(input('請輸入第二個整數(shù):'))
result=a/b
except ZeroDivisionError: #捕獲為零的異常
print('除數(shù)不允許為0')
except ValueError: #捕獲值類型異常
print('請輸入數(shù)字')
except BaseException as e: # 最后寫上這個可以捕獲遺漏的,、其他的異常
print('捕獲其他異常錯誤',e)
else:
print('結(jié)果為:',result)
finally:
print('程序結(jié)束') #無論 except 還是 else 都會執(zhí)行到這里
Python 常見的異常類型
traceback 模塊打印異常信息
- 獲取異常信息,用于后續(xù)對異常的記錄log日志之類的操作
調(diào)試
- 斷點
- 程序運行到此處,,暫時掛起,,停止執(zhí)行。此事可以詳細觀察程序的運行情況,,方便做出進一步的判斷
- 進入調(diào)試視圖
- 三種方式:
- 單擊工具欄的按鈕
- 右鍵單擊編輯區(qū)
- 快捷鍵:shift F9
- 以上內(nèi)部根據(jù)不同的編譯器可能會不同
編程思想
- 編程屆的兩大陣營
類與對象
類
創(chuàng)建類
- 類的組成
- 屬性
- 實例方法 self
- 靜態(tài)方法
- 類方法 cls
class Student: #類
native_pace='廣州' #寫在類里的變量,,稱為類屬性
#初始化方法
def __init__(self,name,age):
self.name=name #self.name 稱為實體屬性,進行了一個復(fù)制的操作,,將局部變量的 name 的值賦給實體屬性
self.age=age
#實例方法
def eat(self): #實例方法的參數(shù)中,,必須寫上 self ,哪怕不寫它也會默認
print('學(xué)生在吃飯,。')
#靜態(tài)方法
@staticmethod
def method(): #靜態(tài)方法的參數(shù)不允許寫 self ,,這是規(guī)定
print('我使用了 staticmethod 進行了修飾,所以我是靜態(tài)方法')
#類方法
@classmethod
def cm(cls): #類方法括號中必須帶 cls ,,這是規(guī)定
print('我是類方法,,因為我使用了 classmethod 進行修飾')
- 在類外面定義的稱之為函數(shù),在類定義的稱為方法
類的實例化
- 意義:有了實例,,就可以調(diào)用類中的內(nèi)容
#創(chuàng)建 Student 類的實例對象 stul
stul=Student('張三',20)
stul.eat() #使用類的方法
print(stul.name,stul.age) #獲取類的屬性
#第二種調(diào)用方法:類名.方法名(類的實例對象),,實際上就是方法定義處的self
Student.eat(stul) #該代碼寫法的功能,與 stul.eat() 方法的功能一致
類屬性
- 類中方法外的變量稱為類屬性,,被該類的所有對象所共享
print(Student.native_pace)
stul=Student('張三',20)
stu2=Student('李四',30)
#修改類的屬性值
Student.native_pace='天津'
print(stul.native_pase) #返回 天津
print(stu2.native_pase) #返回 天津
#類屬性共享,,供多個實例化訪問相同的內(nèi)存地址
類方法
- 使用 @classmethod 修飾的方法,使用雷鳴直接訪問的方法
Student.cm()
靜態(tài)方法
- 使用 @staticmethod 修飾的方法,,使用類名直接訪問的方法
Student.method()
動態(tài)綁定屬性和方法
- Python 是動態(tài)語言,,在創(chuàng)建對象后,可以動態(tài)綁定屬性和方法
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def eat(self):
print(self.name '在吃飯,。')
stu1=Student('張三',20)
stu2=Student('李四',30)
#為實例對象 動態(tài)創(chuàng)建屬性
stu2.gender='女' #該屬性值隸屬于實例對象 stu2 的
print(stu1.name,stu1.age) #輸出 張三 20
print(stu2.name,stu2.age,stu2.gender) #輸出 李四 30 女
#類之外創(chuàng)建一個函數(shù)
def show():
print('定義在類之外的,,稱函數(shù)')
#綁定到實例對象 stu1 的 show 方法
stu1.show=show
stu1.show()
封裝
提高程序的安全性
- 將數(shù)據(jù)(屬性)和行為(方法)包裝到類對象中。在方法內(nèi)部對屬性進行操作,在類對象的外部調(diào)用方法,。這樣,,無序關(guān)心方法內(nèi)部的具體實現(xiàn)細節(jié),從而隔離了復(fù)雜度,。
- 在 Python 中沒有專門的修飾符用于屬性的私有,,如果該屬性不希望在類對象外被訪問,前面使用兩個“_”
#創(chuàng)建類
class Car:
def __init__(self,brand):
self.brand=brand
def start(self):
print('汽車已啟動,。,。。')
#實例化類
car=Car('寶馬X5')
#使用類的方法
car.start()
#使用類的屬性
print(car.brand)
class Student:
def __init__(self,name,age):
self.name=name
self.__age=age #年齡不希望在類的外部被使用,,使用加了兩個'_'
def show(self):
print(self.name,self.__age)
stu=Student('張三',20)
stu.show() #輸出 張三 20
print(stu.name) #輸出 張三
print(stu.__age) #程序拋錯,,提示屬性錯誤,該屬性為類的私有屬性,,外部不允許使用
print(stu._Student__age) #在類的外部可以通過 _Student__age 進行訪問
- 提示:作為程序員,,強烈建議不采取這種方式訪問 _Student__age
繼承
- 提高代碼的復(fù)用性
- 語法格式
- class 子類類名( 父類1 , 父類2... )
- pass
- 如果一個類沒有繼承任何基類,則默認繼承 object
- Python支持多繼承
- 定義子類時,,必須在其構(gòu)造函數(shù)中調(diào)用父類的構(gòu)造函數(shù)
#多繼承
class A(object):
pass
class B(object):
pass
#C類繼承了A,、B兩個類
class C(A,B):
pass
方法重寫
- 如果子類對繼承自父類的某個屬性或方法不滿意,可以在子類中對其(方法體)進行重新編寫
- 子類重寫后的方法中可以通過 super().xxx() 調(diào)用父類中被重寫的方法
object類
- object 類是所有類的父類,,所有類都有 object 類的屬性和方法
- 內(nèi)置函數(shù) dir() 可以查看指定對象所有屬性
- Object 有一個 str() 方法,,用于返回一個對于“對象的描述”,,對應(yīng)于內(nèi)置函數(shù) str() 經(jīng)常用于 print() 方法,幫我們查看對象的信息,,所有我們經(jīng)常會對 str() 進行重寫
多太
提高程序的可擴展性和可維護性
- 即便不知道一個變量所引用的對象到底是什么類型,,仍然可以通過這個變量調(diào)用方法,在運行過程中根據(jù)變量所引用對象的類型,動態(tài)決定調(diào)用哪個對象中的方法
特殊方法和特殊屬性
變量賦值操作
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self,cpu,disk):
self.cpu=cpu
self.disk=disk
#實例CPU的類實例
cpu1=CPU()
#將實例對象 cpu1 賦值給 cpu2
cpu2=cpu1
#輸出兩個對象的內(nèi)存地址是一樣的
print(cpu1,cpu2)
#總結(jié),變量賦值,,實際上還是指向同一個對象
淺拷貝
- Python 拷貝一版都是淺拷貝,,拷貝時,對象包含的子對象不拷貝,,因此,源對象與拷貝對象會引用同一個子對象
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self,cpu,disk):
self.cpu=cpu
self.disk=disk
cpu1=CPU()
disk1=Disk()
computer1=Computer(cup1,disk1) #創(chuàng)建計算機的實例對象
#淺拷貝
import copy
computer2=copy.copy(computer1)
#輸出類對象的內(nèi)存地址,,及子類對象的地址
print(computer1,computer1.cpu,computer1.disk)
print(computer2,computer2.cpu,computer2.disk)
# 結(jié)論:computer類的兩個實例化對象的內(nèi)存地址不同,,但兩個 cpu 和 disk 子類實例對象的內(nèi)存地址一樣
深拷貝
- 使用 copy 模塊的 deepcopy 函數(shù),遞歸拷貝對象中的子對象,源對象和拷貝對象所有的子對象也不相同
#深拷貝
computer3=copy.deepcopy(computre1)
print(computer1,computer1.cpu,computer1.disk)
print(computer2,computer2.cpu,computer2.disk)
# 結(jié)論:computer類與兩個 cpu 和 disk 子類實例對象的內(nèi)存地址都不一樣
模塊
什么是模塊
- 模塊的英文名稱:Modules
- 函數(shù)與模塊的關(guān)系:一個模塊中包含多個函數(shù)
- 在 Python 中一個模塊的文件擴展名為 .py
- 使用模塊的好處:
- 方便其他程序和腳本的導(dǎo)入并使用
- 避免函數(shù)名和變量名沖突
- 提高代碼的可維護性
- 提高代碼的可重用性
自定義模塊
- 新建一個 .py 文件,,名稱不要與 Python 自帶的標準模塊名稱相同
導(dǎo)入模塊
- import 模塊名稱 [as 別名]
- from 模塊名稱 import 函數(shù)/變量/類
#1.引入模塊名稱
import math #引入一個數(shù)學(xué)運算的模塊
print(math.pi) #調(diào)用 math 模塊中的 pi 函數(shù),輸出一個π的數(shù)值,顯示:3.1415926
print(dir(math)) #查詢 math 模塊中的所有可操作的函數(shù)或方法
#2.引入某個模塊中的函數(shù),、變量或類
from math import pi
from math import pow
print(pi)
print(pow(2,3))
以主程序形式運行
- 在每個模塊的定義中都包括一個記錄模塊名稱的變量 __name__,,程序可以檢查該變量,以確定他們在哪個模塊中執(zhí)行,。如果一個模塊不是被導(dǎo)入到其他模塊中執(zhí)行,那么它可能在解釋器的頂級模塊中執(zhí)行。頂級模塊的 __name__ 變量的值為 __main__
# 創(chuàng)建文件 calc.py 文件
def add(a,b):
return a b
if __name__ = '__main__':
print(add(10,20))
#1.當其他文件調(diào)用了 calc.py 文件,,print 不會被執(zhí)行
#2.當 calc.py 文件本身被執(zhí)行,,print 會執(zhí)行輸出,因為 calc.py 文件被主動執(zhí)行時,,__name__ 會被標記為當前程序 __main__
包
#導(dǎo)入包中的模塊 import 包名.模塊名 as 別名
import pageage1.mouduleA as ma
#調(diào)用該模塊里的函數(shù)
print(ma.a)
Python 中常用的內(nèi)置模塊
第三方模塊的安裝及使用
pip install 模塊名
-
在線安裝
-
使用第三方模塊
import 模塊名
知識總結(jié)
文件目錄
編碼格式
- Python 解釋器使用的是 Unicode(內(nèi)存)
- .py 文件在磁盤上使用 UTF-8 存儲(外存)
文件讀寫原理
- 文件讀寫俗稱“IO操作”
-內(nèi)置函數(shù) open() 創(chuàng)建文件對象
- 語法規(guī)則
#創(chuàng)建文件對象
file1=open('a.txt','r') #讀取一個文件,,模式為:只讀
#輸出文件內(nèi)容
print(file1.readlines()) # readlines() 讀取的是一個“列表”
#關(guān)閉系統(tǒng)資源
file1.close()
文件讀寫操作
- 文件的類型
- 按文件中的數(shù)據(jù)組織形式,,文件分為兩大類型:
- 文本文件:存儲普通“字符”文本,默認為 Unicode 字符集,,可以使用記事本程序打開
- 二進制文件:把數(shù)據(jù)內(nèi)容用“字節(jié)”存儲,,無法用記事本打開,必須使用專用軟件打開,,例:mp3音頻文件,、png圖片文件、doc文檔 等
#創(chuàng)建寫入的文件對象
# w 寫入,,覆蓋原文件
# a 寫入,,在原文件內(nèi)容后追加內(nèi)容
file2=open('b.txt','w') #模式為:寫
#寫入信息
file2.write('hello world') #如果文件存在,則寫入操作會覆蓋原文件
#關(guān)閉系統(tǒng)資源
file2.close()
#對二進制文件的讀寫操作
src_file=open('logo.png','rb') #創(chuàng)建只讀的圖像文件對象
target_file=open('copylogo.png','rb') #創(chuàng)建只寫的圖像文件對象
#讀取 src_file 文件對象,,并寫入到 target_file 文件對象中
target_file.write(src_file.read())
#關(guān)閉系統(tǒng)資源
target_file.close()
src_file.close()
#最后,, 號表示以讀寫的方式打開,需要與其他模式一起使用,,例:a
文件對象常用方法
with語句(上下文管理器)
- with 語句可以自動管理上下文資源,不論什么原因跳出 with 塊,,都能確保文件正確關(guān)閉,,以此來達到釋放資源的目的
with open('a.txt','r') as file1:
print(file1.read())
#語句最后 with 會自動關(guān)閉釋放,而不需要人為寫關(guān)閉語句
#完整的賦值粘貼一張圖片的代碼就是三行
with open('logo.png','rb') as src_file:
with open('copy2logo.png','wb') as target_file:
target_file.write(src_file.read())
目錄操作
- OS 模塊是 Python 內(nèi)置的與操作系統(tǒng)功能和文件系統(tǒng)相關(guān)的模塊,,該模塊中的語句執(zhí)行結(jié)果通常與操作系統(tǒng)有關(guān),,在不同的操作系統(tǒng)上運行,得到的結(jié)果可能不一樣
- OS 模塊與 OS.path 模塊用于對目錄或文件進行操作
#打開操作系統(tǒng)的記事本
import os
os.system('notepad.exe')
#調(diào)用系統(tǒng)中的可執(zhí)行文件,,例如打開QQ
os.startfile('C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQ.exe')
# walk 方法可以獲取當前目錄下所有文件及子目錄里的所有文件
import os
path=os.getcwd()
lst_files=os.walk(path)
for dirpath,dirname,filename in lst_files:
print(dirpath)
print(dirname)
print(filename)
print('----------- 分割線 -----------')
知識總結(jié)
其他知識
項目打包
- 安裝第三方模塊
- 在線安裝方式
- 語法:pip install PyInstaller
- 執(zhí)行打包操作
C:\Users\Administrator>pyinstaller -F E:\Python\Studentsys\student.py