涵蓋Python基礎語法，掌握基礎的編程能力
Python是一種面向對象的解釋型計算機程序設計語言，由吉多.范羅蘇姆開發，第一個公開發行版發布於1991年，它常被成為膠水語言，能夠把其他語言制作的各種模塊（尤其是C/C++），恆輕松的聯結在一起。
Python優點
Python開源，開發者可以自由的下載，閱讀，甚至是修改Python源代碼
Python具有本身且豐富而且強大的庫，而且由於Python的開源性，第三方庫也非常多，例如：在web開發有django.flask,Tornado，爬蟲scrapy，科學計算numpy.pandas等等
由於Python是開源的，他已經被移植到了大多數平台下面，例如：Windows，MacOS，Linux，Andorid,iOS等等
Python既支持面向過程，又支持面向對象，這樣編程就更加靈活
Python缺點
C程序相比非常慢，因為Python是解釋型語言，代碼在執行時會一行一行的翻譯成CPU能夠理解的機器碼，這個翻譯過程非常的耗時，所以很慢，而C程序時運行前直接編譯成CPU能執行的機器碼，所以相對Python而言，C語言執行非常快
要發布你寫的程序，實際上時發布源代碼，而是解釋型的語言，則必須把源代碼發布出去
Python有非常嚴格的縮進語法，只要縮進錯誤程序立馬崩潰
在任意時刻，只有一個線程在解釋器中運行，對Python虛擬機的訪問由全局解釋器鎖（GIL）來控制，正式這個鎖能夠保證同一時刻只有一個線程在運行，遇到i/o阻塞的時候會釋放（GIL）所以Python的多線程並不是真正的多線程，而是CPU執行速度非常快，讓人感覺不到GIL的存在。（GIL）會在Python高級階段講解
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-2eiqPEK6-1657892353562)(1.png)]
學了Python能干什麼
注釋是編寫程序時，寫程序的人給人一句、程序段、函數等的解釋或提示
注釋的作用：
注釋可以起到一個備注的作用，這個方法函數，變量到底是干嘛的，如果沒有注釋時間長了即使是自己寫的代碼，可能都不知道這個代碼到底是干嘛的，所以注釋起到的作用就是方便自己查看寫過的代碼，別人來接收你的代碼能看懂，簡單來將就是提高程序代碼的可讀性，以便於以後的參看、修改
Python中單行注釋用#號，#號右邊就是注釋的內容，Python解析器遇到#號就會當作注釋，不會去解析#號後面的內容
多行注釋 ‘’‘代碼… ‘’’
#x就是變量，當x=2結果就是6 x=10結果就是30
x=2
y=x*3
print(y)
命名規則：
變量必須以字母（a-z A-Z）下劃線(_)開頭，其他字符可以是字母數字下劃線 ，變量區分大小寫，Python關鍵字不能作變量名
_Name='張三'
name='劉德華'
print(_Name,name)
命名規范：
定兩個變量a=7,y=3
返回布爾型 True False
a=1
b=2
c=3
d=5
print(a>b and d>c) #結果為假
print(a>b or d>c)#結果為真
print(not a>d) #結果為真
優先級：（）–>not–>and–>or
print(2>1 and 1<4 or 2<3 and 9>6 or 2<4 and 3<2) #True
a,b,c,d=23,10,18,3
a+=3
print(a)
輸出 %占位符
name ='張三'
classPro='北京大學'
age =22
print('我的名字是%s：來自%s 今年%d歲了'%(name,classPro,age))
me ='我的'
classP='清華附中一年級3班'
age1=7
print('%s名字是小明，來自%s,我今年%d歲了'%(me,classP,age1))
print('我可以\n換行嗎')
print('\n')
print('-------------test---------------')
print('\n')
ID='老夫子'
QQ=66666666
number=13467204515
address='廣州市白雲區'
print('========================================')
print('姓名：%s'%ID)
print('QQ: %d'%QQ)
print('手機號碼：%d'%number)
print('公司地址：%s'%address)
print('========================================')
print('\n')
格式化輸出另外一種方式
print('---------格式化輸出另外一種方式.format------------')
print('姓名：{}'.format(ID))
print('QQ：{}'.format(QQ))
print('手機號碼：{}'.format(number))
print('公司地址：{}'.format(address))
輸入 input
Python中提供input 方法來獲取鍵盤輸入
input接收的鍵盤輸入都是str類型，如果接收數字類型需要將str轉成int
name=input('請輸入姓名')
age2=int(input('請輸入年齡：'))
qq=input('請輸入QQNumber：')
phone=input('請輸入手機號：')
addr=input('請輸入地址：')
print('姓名：%s 年齡是%d'%(name,age2))
print('QQ：{}'.format(qq))
print('手機號碼：{}'.format(phone))
print('公司地址：{}'.format(addr))
score = 80
if score<=60: #滿足條件就會輸出打印提示
print('成績不太理想，繼續加油')
pass #空語句
print('語句運行結束')
if score>60:
print('成績不錯')
else:
print("成績不合格，繼續努力")
grade=int(input('請輸入成績：'))
if grade>90:
print('您的成績是A等')
pass
elif grade>=80:
print('您的成績是B等')
pass
elif grade >=70:
print('您的等級是C等')
pass
elif grade >=60:
print('您的等級是D等')
pass
else:
print('你個廢物蛋')
print('程序運行結束.........')
xuefen=int(input('請輸入你的學分'))
if xuefen >10:
grade = int(input('請輸入你的成績'))
if grade>=80:
print('你可以升班了。。。恭喜您')
pass
else:
print('很遺憾，您的成績不達標....')
pass
pass
else:
print('您的表現也太差了吧0')
語法特點
# 1.有初始值
# 2.條件表達式
# 3.變量【循環體內計數變量】的自增自減，否則會造成死循環
tage='我是一個中國人'#字符串類型本身就是一個字符類型的集合
for item in tage:
print(item)
pass
#range 此函數可以生成一個數據集合的列表
#range(起始值：結束值：步長）步長不能為0
sum=0
for data in range(1,101):#數據做包含，右邊不包含1-100
sum+=data
pass
#print(data,end=' ')
print(sum)
print('sum=%d'%sum)
# print('sum={}'.format(sum))
#
for message in range(50,201):
if message%2==0:
print('%d是偶數'%message)
pass
else:
print('{}是奇數'.format(message))
# break 代表中斷結束，滿足條件直接結束本層循環
# continue 結束本次循環，繼續進行下次循環， （當continue條件滿足的時候，本次循環剩下的語句將不在執行，後面的循環繼續）
#這兩個關鍵字只能用在循環中
while:適用於對未知的循環次數 【用於判斷】
for ：適應於已知的循環次數【可迭代對象遍歷】
99乘法表用for實現
#九九乘法表
for i in range(1,10):
for j in range(1,i+1):
print('%d*%d=%d'%(i,j,i*j),end=' ')
print()#控制換行
print('--------------------------------------------------------')
print('\n')
案例 輸入1-100之間的數據
#輸入1-100之間的數據
index =1#定義變量
while index<=100:
print(index)
index+=1
pass
案例猜拳游戲
#案例猜拳游戲
import random
count =1
while count<=10:
person =int(input('請出拳：【0 石頭 1 剪刀2布】\n'))
computer=random.randint(0,2)#隨機數范圍
if person==0 and computer==1:
print('你真厲害')
pass
elif person==1 and computer==2:
print('你可真棒')
pass
elif person==2 and computer==0:
print('你真厲害')
pass
elif person==computer:
print('不錯嘛，竟然平手')
pass
else:
print('你輸了')
pass
count+=1
九九乘法表
#打印九九乘法表
i=1
while i<=9:
j=1
while j<=i:
print('%d*%d=%2d'%(i,j,i*j),end=" ")
j+=1
pass
print()
i+=1
pass
直角三角形
#直角三角形
row=9
while row>=1:
j=1
while j<=row:
print('*',end=' ')
j+=1
pass
print()
row-=1
pass
等腰三角形
#等腰三角形
i=1
while i<=10:
j1=1
while j1<=10-i:#控制打印沒空格的數量
print(' ',end='')
j1+=1
pass
k=1
while k<=2*i-1:#控制打印*號
print('*',end='')
k+=1
print()
i+=1
pass
猜年齡小游戲
有三點要求：
1.允許用戶最多嘗試3次
2.每嘗試3次後，如果還沒有猜對，就問用戶是否還想繼續玩，如果回答Y或y,就讓繼續猜3次，以此往後，如果回答N或n，就退出程序
3.如果猜對了，直接退出
# # import random
#
# # for i in range(3):
# # computer = random.randint(20, 22)
# # person = int(input('請輸入年齡：'))
# # if person == computer:
# # print('恭喜您答對了')
# # break
# #
# # else:
# # print('猜錯了')
# # zimu=input('是否繼續：繼續請輸入Y或者y 結束請輸入N或n')
# # if zimu=='Y' or zimu =='y':
# # pass
# # elif zimu=='N' or zimu=='n':
# # exit()
time =0
count=3
while time<=3:
age =int(input('請輸入您要猜的年齡：'))
if age ==25:
print('您猜對了：')
break
elif age >25:
print('您猜大了')# else:
print('您猜小了')
time+=1
if time==3:
choose=input('還想繼續嗎？Y/N')
if choose == 'Y' or choose=='y':
time=0#重置為初始值
elif choose=='N' or choose=='n':
exit()
else:
print('請輸入正確的符號..謝謝配合')
小王身高1.75，體重80.5kg,請根據BMI公式，【體重除以身高的平方】，幫助小王計算他的BMI指數，並根據BMI指數
低於18.5 過輕
18.5-25 正常
25-28 過重
28-32 肥胖
高於32 嚴重肥胖
用if-elif 判斷並打印出來
high=1.75
weight=80.5
BMI=weight/(high*high)
print('BMI的數據是{}'.format(BMI))
if BMI<18.5:
print('過輕')
elif 18.5<=BMI<25:
print('正常')
elif 25<=BMI<28:
print('過重')
elif 28<=BMI<32:
print('肥胖')
else:
print('嚴重肥胖')
## Python數據類型
>掌握Python的基本數據類型
* 數字
* int(有符號整數)
* long（長整數）(Python3版本取消了)
* float（浮點型）
* complex（復數）
* bool（布爾值）
* 返回 True False
* 字符串
* 字典
* 元組
* 列表
```python
a=[]
print(type(a)) #type方法可以查看變量的類型
b=10
print(type(b))
序列:一組按順序排列的值，【數據集合】
Python 中存在3中內置的序列類型：
‘’’
字符串 列表 元組
‘’’
序列優點：支持索引和切片操作
特征:第一個正索引為0，指向的是左端， 第一個索引為負數，指向的是右端
切片是指截取字符串中的某一段內容，
切片使用語法：[起始下標：結束下標：步長] 切片截取的內容不包含結束下標對應的數據，步長指的是隔幾個下標獲取一個字符
下標會越界，切片不會：
Test='python'
print(type(Test))
print(Test[0])#獲取第一個字符
print('獲取第二個字符%s'%Test[1])
for i in Test:
print(i,end=' ')
name='peter'
print('首字母大寫：%s'%name.capitalize())
a=' python '
print(a.strip())#去除兩邊的空格
print(a.lstrip())#去除左邊空格
print(a.rstrip())#去除右邊空格
#賦值字符串
b=a
print(b)
print(id(a))#查看內存地址
print(id(b))
str="I Love Python"
print(str.find('P'))#返回對應的下標 查找目標對象在序列中對應的位置 沒找到返回-1
print(str.index('v'))#index()檢測字符串中是否包含子字符串，返回對應下標，沒找到就報錯
print(str.startswith('I'))#返回布爾型 判斷是否以什麼什麼開始
print(str.endswith('i'))#判斷是否以什麼什麼結尾
print(str.lower())#全部轉小寫
print(str.upper())#全部轉大寫
st='hello world'
print(st[0])
print(str[::-1])#逆序輸出
print(st[2:5])#從下標2開始不包含5【左閉右開】
print(st[2:])#從第三個字符到最後
print(st[0:3])#從0開始可以省略0
print(st[:3])
list=[]#空列表
print(list)
print(len(list))#獲取列表對象 中數據個數
str='lodsa'
print(len(str))
listA=['abcd',123,456,798,True,12.255]
print(listA)
print(listA[0])#找出第一個元素
print(listA[1:3])
print(listA[3:])
print(listA[::-1])#倒敘
print(listA*3)#輸出多次列表中數據【復制多次】
print('------------------增加---------------------')
listA.append('Jay')
listA.append([1,1,2,'dfgs',{
"al":12}])
print(listA)
listA.insert(1,'插入的元素')#插入操作，需要指定插入位置
# reData=list(range(10))#強制轉換list對象
listA.extend([12,45,484])#擴展，批量添加
print(listA)
print('-----------------修改--------------')
print('修改之前',listA)
listA[0]='Peter'
print('修改之後',listA)
print('----------------------刪除---------------')
del listA[0] #刪除列表中第一個元素
print(listA)
del listA[1:3]#批量刪除
print(listA)
listA.remove(798)#指出指定元素
print(listA)
listA.pop(0)#移除第一個元素 #根據下標來移除
print(listA)
元組是不可變序列，在創建後不能做任何修改
可變
用()來創建元組類型，數據項用逗號來分割
可以是任何類型
當元組中只有一個元素時，要加上逗號，不然解釋器會當作整形處理
同樣支持切片操作
查找
tupleA=()#空列表
tupleA=('abcd',123,12.55,[123,45,'45hf'])
print(tupleA)
print(tupleA[2])
print(tupleA[1:3])
print(tupleA[::-1])
print(tupleA[::-2])
print(tupleA[-2:-1:])#倒著取下標， -2到-1區間的數據
print(tupleA[-4:-1])
tupleA[3][0]=250#對元組中的列表類型的數據進行修改
tupleB=tuple(range(10))
print(tupleB.count(9))
字典不是序列類型，沒有下標的概念，是一個無序的鍵值集合，是內置的高級數據類型
字典可以存儲任意對象
字典以鍵值對的形式創建的{key:value}利用大括號包裹
字典中中某個元素時，時根據鍵 ，值 字典的每個元素由2部分組成：鍵：值
訪問值的安全方法get()方法，在我們不確定字典中是否存在某個鍵而又想獲取其值時，可以使用get()方法，還可以設置默認的值
添加字典數據
dictA={
"pro":"藝術專業","school":'上海戲劇學院'}
dictA['name']='李易峰'
dictA['age']=29
print(dictA)
print(len(dictA))
print(dictA['name'])#通過鍵獲取值
dictA['name']='成龍'#修改鍵對應的值
print(dictA)
print(dictA.keys())#獲取所有的鍵
print(dictA.values())#獲取所有的值
print(dictA.items())#獲取所有的鍵和值
for key,value in dictA.items():
# print(item)
print('%s值==%s'%(key,value))
dictA.update({
'age':32})#更新 存在就更新，不存在就添加
dictA.update({
"height":1.78})#添加
print(dictA)
del dictA['name']
dictA.pop('age')
print(dictA)
#+ 合並
strA='人生苦短'
strB='我用Python'
print(strA+strB)
List_A=list(range(10))
list_B=list(range(10,21))
print(List_A+list_B)
# * 復制
print(strA*3,end=' ')
print(List_A*3)
# in 判斷對象是否存在
print('我' in strA)
print(10 in list_B)
掌握Python函數基礎，為開發項目打下堅實的基礎
在編寫程序的過程中，有某一功能代碼塊出現多次，但是為了提高編寫的效率以及代碼的重用，所以把具有獨立功能的代碼塊組織為一個小模塊，這就是函數
就是一系列Python語句的組合，可以在程序中運行一次或者多次，
一般具有獨立的功能
代碼的復用最大化以及最小化冗余代碼，整體代碼結構清晰，問題局部化
函數定義
def 函數名():
函數體【一系列語句，表示獨立的功能】
函數調用
調用之前先定義
函數名加（）即可調用
函數說明文檔：
函數內容的第一行可以用字符串進行 函數說明
函數定義
def pritInfo():
'''
這個函數用來打印小張信息
'''
#函數代碼塊
print('小張的身高是%f'%1.73)
print('小張的體重是%f'%130)
print('小張的愛好是%s'%'周傑倫')
print('小張的專業是%s'%'信息安全')
pritInfo()
def pritInfo(name,height,weight,hobby,pro):
#函數代碼塊
print('%s的身高是%f'%(name,height))
print('%s的體重是%f'%(name,weight))
print('%s的愛好是%s'%(name,hobby))
print('%s的專業是%s'%(name,pro))
pritInfo('peter',175,130,'聽音樂','甜品師')
pritInfo('小李',189,140,'打游戲','軟件工程師')
必選參數，默認參數【缺省參數】，可選參數，關鍵字參數
參數：其實就是函數為了實現某項特定功能，進而為了得到實現功能所需要的數據
為了得到外部數據
def sum(a,b):#形式參數：只是意義上的一種參數，在定義的時候是不占內存地址的
sum=a+b
print(sum)
必選參數
函數調用的時候，必選參數是必須要賦值的
sum(20,15)#20,15就是實際參數 實參， 實實在在的參數，是實際占用內存地址的
sum()不能這樣寫，需要傳參
def sum(a=1,b=11):
print(a+b)
sum()
sum(10)#在調用的時候，如果未賦值，就用定義函數時給定的默認值
可變參數（當參數的個數不確定時，比較靈活）
def getComputer(*args):
''' 計算累加和 '''
# print(args)
result=0
for item in args:
result+=item
print(result)
getComputer(1)
getComputer(1,2,3,4)
# def Func(**kwargs):
# print(kwargs)
# Func(name='趙頌')
# def Infofunc(*args,**kwargs): #可選參數必須在關鍵字可選參數之前
# print(args)
# print(kwargs)
# Infofunc(1,2)
# Infofunc(12,13,46,age=18)
def num(*args):
''' #寫函數，接收N 個數字，求這些參數數字的和 '''
result=0
for i in args:
result+=i
return result
a=num(1,2,2,2,2)
print(a)
def Func1(con):
''' 找出傳入的列表或元組的奇數位對應的元素，並返回一個新的列表 '''
listA=[]
index=1
for i in con:
if index%2==1:#判斷奇數位
listA.append(i)
index+=1
return listA
# e=Func1([1,2,45,1,1,'as',{1,25,',hs'}])
e=Func1(list(range(1,11)))
print(e)
def Func2(dic):
''' 檢查傳入字典的每一個value的長度，如果大於2，那麼僅僅保留前兩個長度的內容， 並將新的內容返回給調用者，PS:字典中的數據只能是字符串或者是列表 '''
result={
}
for key,value in dic.items():
if len(value)>2:
result[key]=value[:2]#向字典添加新的數據
else:
result[key]=value
return result
#調用
dicObj={
'name':'張三','hobby':['唱歌','跳舞','編程'],'major':'信息安全'}
print(Func2(dicObj))
#返回值
def Sum(a,b):
sum=a+b
return sum #將計算結果返回
result=Sum(12,15)#將返回的值賦給其他變量
print(result)
def calComputer(num):
''' 累加和 '''
listA=[]
result=0
i=1
while i<=num:
result+=i
i+=1
# listA.append(result)
listA.append(result)
return listA
message=calComputer(10)
print(type(message))
print(message)
def returnType():
''' 返回元組類型數據 '''
return 1,2,3
a =returnType()
print(type(a))
print(a)
def returnType1():
''' 返回字典類型 '''
return {
"name":"成龍"}
b=returnType1()
print(type(b))
print(b)
def fun1():
print("------------------fun1start")
print("--------------------執行代碼省略")
print("-------------------fun1end")
def fun2():
print('------------------fun2start')
#調用第一個函數
fun1()
print("---------------------fun2end")
fun2()
#函數分類：根據函數返回值和函數參數決定
#有參數無返回值
#有參數有返回值
#無參數無返回值
#無參數有返回值
# pro='信息安全'#全局變量
# name='周潤發'
# def printInfo():
# name='劉德華'#局部變量
# print('{}'.format(name))
#
# def TestMethod():
# name='peter'#局部變量
# print(name)
# printInfo()
# TestMethod()
#
#
# def message():
# print(pro)
#
# message()
#
pro='123'
def changGlobal():
global pro
pro='456'
print(pro)
changGlobal()
在Python中，值是靠引用來傳遞來的，可以用id()查看一個對象的引用是否相同.
id是值保存在內存中那塊內存地址的標識.
不可變類型
a=1
def func(x):
print('x的地址{}'.format(id(x)))
x=12
print('修改之後的x 的地址:{}'.format(id(x)))
print('a的地址：{}'.format(id(a)))
func(a)
li=[]
def testRenc(parms):
print(id(parms))
li.append([1,2,3,54])
print(id(li))
testRenc(li)
print('外部變量對象{}'.format(li))
lambda 參數1、參數2、參數3：表達式
特點
缺點
#匿名函數
m=lambda x,y:x+y
#通過變量去調用匿名函數
print(m(23,19))
M=lambda a,b,c:a*b*c
print(M(1,2,3))
age =15
print('可以繼續參軍，'if age>18 else'繼續上學')
C=lambda x,y:x if x>y else y
print(C(1,5))
re=(lambda x,y:x if x<y else y)(16,12)
print(re)
Rs=lambda x:(x**2)+890
print(Rs(10))
如果一個函數在內部不調用其他函數，而是調用自己本身，這個函數就是遞歸函數
遞歸 自己調用自己
必須有一個明確的結束條件
#階乘/通過遞歸實現
def factorial(n):
''' 階乘 '''
if n==1:
return 1
return n*factorial(n-1)
result =factorial(5)
print(result)
#通過普通函數實現階乘
def jiecheng(n):
''' 階乘 '''
result=1
for item in range(1,n+1):
result*=item
return result
re=jiecheng(5)
print(re)
#模擬實現，樹形結構的遍歷
import os #引入文件操作模塊
def findFile(file_Path):
listRs=os.listdir(file_Path)#得到該路徑下面的文件夾
for fileItem in listRs:
full_Path=os.path.join(file_Path,fileItem)#獲取完整的文件路徑
if os.path.isdir(full_Path):#判斷是否是文件夾
findFile(full_Path)#如果是一個文件，再次去遍歷
else:
print(fileItem)
else:
return
#d調用搜索文件對象
findFile('D:\\Python')
#Python語言自帶的函數
print(abs(-23))#取絕對值
print(round(2.23))#近似值
print(round(12.56,1))#保留一位小數
print(pow(3,3))#次方
print(3**3)#次方
print(max(12,15,18))#返回最大值
print(min(12,15))#最小值
print(sum(range(50)))
#eval 執行表達式
a,b,c=1,2,3
print('動態生成的函數{}'.format(eval('a+b+c')))
#chr() 數字轉字符
#bin() 轉為二進制
#hex() 轉為十六進制
#oct() 轉八進制
#list()將元組轉列表
print(bin(10))
print(hex(16))
tupleA=(132,2,2,23,1)
print(list(tupleA))
listA=[1,123,15,',ghdj']
print(tuple(listA))
# bytes轉換
print(bytes('我喜歡Python',encoding='utf-8'))
#sorted()函數對所有可迭代的對象進行排序操作 生成一個新的進行排序
#sort() 在原有數據基礎上進行排序
#all()
#range()
list=[1,2,3,45,6]
# list.sort()#直接修改原始對象
print('-------------排序之前-----------{}'.format(list))
# varList=sorted(list)
varList=sorted(list,reverse=True)#降序排序
# varList=sorted(list,reverse=False)#升序排序
print('-------------排序之後-----------{}'.format(varList))
#set 不支持索引切片，是一個無序的且不重復的容器
#類似於字典，但是只有Key,沒有value
set1={
1,2,3}
set1.add(123)#添加操作
set1.clear() #清空
print(set1)
List1=['1','2','24']
set2=set(List1)
print(set2)
re=set1.difference(set2)# 差集， a中有的b中沒有的
print(re)
print(set1-set2)#差集
print(set1.intersection(set2))#交集
print(set1&set2)#交集
print(set1.union(set2)) #並集
print(set1 | set2)#並集
#pop 就是從集合中拿數據並且同時刪除
print(set1)
set1.pop()
print(set1)
set1.discard(3)#指定移除元素
print(set1)
#update兩個集合
set1.update((set2))
print(set1)
介紹Python面向對象開發，為開發項目打下堅實的基礎
面向對象編程 oop 【object oriented programming】是一種Python的編程思路
面向過程：
在思考問題的時候，怎麼按照步驟去實現，
然後將問題解決拆分成若干個步驟，並將這些步驟對應成方法一步一步的最終完成功能
面向過程：就是一開始學習的，按照解決問題步驟去編寫代碼【根據業務邏輯去寫代碼】
面向對象：關注的是設計思維【找洗車店， 給錢洗車】
從計算機角度看：面向過程不適合做大項目
面向過程關注的是：怎麼做
面向對象關注的是：誰來做
類：是一個模板，模板裡包含多個函數，函數裡實現一些功能
對象：則是根據模板創建的實例，通過實例對象可以執行類中的函數
類由3部分構成：
例如：創建一個人類
事物的名稱（類名）：人（Person）
屬性：身高，年齡
方法；吃 跑…
現實世界 計算機世界
行為------》方法
特征------》屬性
#定義類和對象
#類名：采用大駝峰方式命名
#創建對象
#對象名=類名()
''' class 類名: 屬性 方法 '''
#實例方法 ：
# 在類的內部，使用def關鍵字可以定義一個實例方法，與一般函數 定義不同，類方法必須包含參數self【self可以是其他的名字，但是這個位置必須被占用】，且為第一個參數
#屬性：在類的 內部定義的變量
#定義在類裡面，方法外面的屬性成為類屬性，定義在方法裡面使用self引用的屬性稱之為實例屬性
class Person:
''' 對應人的特征 '''
name='小勇' #類屬性
age=22 #類屬性
''' 對應人的行為 '''
def __int__(self):
self.name = '小趙'#實例屬性
def eat(self):#實例方法
print('狼吞虎咽的吃')
def run(self):#實例方法
print('飛快地的跑')
#創建對象【類的實例化】
xm=Person()
xm.eat()#調用函數
xm.run()
print('{}的年齡是{}'.format(xm.name,xm.age))
# 如果有n個這樣對象 被實例化，那麼就需要添加很多次實例屬性，顯然比較麻煩
class Person1:
def __init__(self):#魔術方法
''' 實例屬性的聲明 '''
self.name='小勇'
self.age=22
self.sex='男生'
def run(self):
print('跑太快了吧')
xy=Person1()
# xy.run()
print(xy.age)
class Person:
def __init__(self,pro):
self.pro=pro
def geteat(s,name,food):
# print(self)
print('self在內存中的地址%s'%(id(s)))
print('%s喜歡吃%s,專業是：%s'%(name,food,s.pro))
zs=Person('心理學')
print('zs的內存地址%s'%(id(zs)))
zs.geteat('小王','榴蓮')
魔術方法： __ xxx __
''' __init__ 方法：初始化一個類，在創建實例對象為其賦值時使用 __str__方法 ： 在將對象轉換成字符串str(對象)測試的時候，打印對象的信息 __new__方法 ： 創建並返回一個實例對象，調用了一次，就會得到一個對象 __class__方法 ： 獲得已知對象的類（對象__class__) __del__方法： 對象在程序運行結束後進行對象銷毀的時候調用這個方法，來釋放資源 '''
class Animal:
def __init__(self,name,color):
self.name=name
self.color=color
print('--------init-------')
def __str__(self):
return '我的名字是%s,我的顏色為%s'%(self.name,self.color)
def __new__(cls, *args, **kwargs):
print('--------new-------')
return object.__new__(cls)
dog =Animal('旺財','黑色')
print(dog)
''' __new__和__init__函數區別 __new__類的實例化方法：必須返回該實例 否則對象就創建不成功 __init__用來做數據屬性的初始化工作，也可以認為是實例的構造方法，接收類的實例 self 並對其進行構造 __new__至少有一個參數是cls是代表要實例化的類，此參數在實例化時由Python解釋器自動操作 __new__函數執行要早於__init__函數 '''
''' 當一個對象被刪除或者被銷毀是，python解釋器會默認調用一個方法，這個方法為__del__()方法，也被成為析構方法 '''
class Animals:
def __init__(self,name):
self.name=name
print('這是構造初始化方法')
def __del__(self):
print('當在某個作用域下面，沒有被引用的情況下，解釋器會自動調用此函數，來釋放內存空間')
print('這是析構方法')
print('%s 這個對象被徹底清理了，內存空間被釋放了'%self.name)
cat=Animals('貓貓')
# del cat #手動的清理刪除對象
input('程序等待中......')
#當整個程序腳本執行完畢後會自動的調用_del_方法
# 當對象被手動摧毀時也會自動調用_del_方法
# 析構方法一般用於資源回收，利用_del_方法銷毀對象回收內存資源
Python中展現面向對象的三大類型： 封裝，繼承，多
態
封裝：值得是把內容封裝到某個地方，便於後面的使用
他需要：
把內容封裝到某個地方，從另外一個地方去到調用被封裝的內容
對於封裝來說，其實就是使用初始化構造方法將內容封裝到對象中，然後通過對象直接或者self來獲取被封裝的內容
繼承：和現實生活當中的繼承是一樣的，也就是子可以繼承父的內容【屬性和行為】（爸爸有的兒子有， 相反， 兒子有的爸爸不一定有），
所謂多態，定義時的類型和運行時的類型是不一樣，此時就成為多態
class Animal:
def eat(self):
''' 吃 '''
print('吃')
def drink(self):
''' 喝 '''
print('喝')
class Dog(Animal):#繼承Animal父類， 此時Dog就是子類
def wwj(self):
print('汪汪叫')
class Cat(Animal):
def mmj(self):
print('喵喵叫')
d1=Dog()
d1.eat()#繼承了父類的行為
d1.wwj()
c1=Cat()
c1.drink()
c1.eat()
''' 對於面向對象的繼承來說，其實就是將多個子類共有的方法提取到父類中， 子類僅僅需要繼承父類而不必一一去實現 這樣就可以極大提高效率，減少代碼的重復編寫，精簡代碼的層級結構 便於擴展 class 類名(父類): pass '''
class shenxian:
def fly(self):
print('神仙會飛')
class Monkey:
def chitao(self):
print('猴子喜歡吃桃子')
class SunWuKong(shenxian,Monkey):
pass
swk=SunWuKong()
swk.fly()
swk.chitao()
#當多個父類當中存在相同方法時候，
class D:
def eat(self):
print('D.eat')
class C(D):
def eat(self):
print('C.eat')
class B(D):
pass
class A(B,C):
pass
a=A()
# b=B()
a.eat()
print(A.__mro__)#可以現實類的依次繼承關系 查找執行順序
#在執行eaet方法時，順序應該是
#首先到A裡面去找，如果A中沒有，則就繼續去B類中去查找，如果B中沒有，則去C中查找，
#如果C類中沒有，則去D類中查找，如果還沒有找到，就會報錯
#A-B-C-D 也是繼承的順序
class Father:
def smoke(self):
print('抽芙蓉王')
def drink(self):
print('喝二鍋頭')
class Son(Father):
#與父類的（抽煙）方法同名,這就是重寫父類方法
def smoke(self):
print('抽中華')
#重寫父類方法後，子類調用父類方法時，將調用的是子類的方法
son=Son()
son.smoke()
#要想實現多態，必須有兩個前提需要遵守：
''' 1.繼承：多態必須放生在父類和子類之間 2.重寫：子類重寫父類的方法 '''
class Animal:
''' 基類[父類] '''
def say(self):
print('我是一個動物'*10)
class Dark(Animal):
''' 子類【派生類】 '''
def say(self):
''' 重寫父類方法 '''
print('我是一個鴨子'*10)
class Dog(Animal):
def say(self):
print('我是一只'*10)
# dark=Dark()
# dark.say()
#統一的去調用
def commonInvoke(obj):
obj.say()
list=[Dark(),Dog()]
for item in list:
''' 循環調用函數 '''
commonInvoke(item)
類屬性：就是類對象擁有的屬性，它被所有類對象的實例對象所共有，類對象和實例對象可以訪問
實例屬性：實例對象所擁有的屬性，只能通過實例對象訪問
class Student:
name ='黎明'#屬於類屬性，就是Student類對象所擁有
def __init__(self,age):
self.age=age #實例屬性
lm=Student(18)
print(lm.name)
print(lm.age)
print(Student.name)#通過Student類對象訪問name屬性
# print(Student.age)#類對象不能訪問實例屬性
#類對象可以被類對象和實例對象共同訪問使用的
#實例對象只能實例對象訪問
class People:
country='china'
@classmethod #類方法 用classmethod進行修飾
def get_country(cls):
return cls.country#訪問類屬性
@classmethod
def change_country(cls,data):
cls.country=data#修改列屬性的值，在類方法中
@staticmethod
def gatData():
return People.country
@staticmethod
def add(x,y):
return x+y
print(People.gatData())
p=People()
print(p.gatData())#注意：一般情況下，我們不會通過實例對象去訪問靜態方法
print(People.add(1,2))
# print(People.get_country())#通過類對象去引用
# p=People()
# print('通過實例對象訪問',p.get_country())
# People.change_country('英國')
# print(People.get_country())
#由於靜態方法主要來存放邏輯性的代碼，本身和類以及實例對象沒有交互
#也就是說，在靜態方法中，不會涉及到類中方法和屬性的操作
#數據資源能夠得到有效的充分利用
import time
class TimeTest:
def __init__(self,hour,minute,second):
self.hour=hour
self.minute=minute
self.second=second
@staticmethod
def showTime():
return time.strftime('%H:%M:%S',time.localtime())
print(TimeTest.showTime())
# t=TimeTest(2,10,11)
# print(t.showTime())#沒必要通過實例對象訪問靜態方法
語法：
使用私有化屬性的場景
要想訪問私有變量一般是寫兩個方法，一個訪問，一個修改，由方法去控制訪問
class Person:
__age =18 #實例一個私有化屬性，屬性名字前面加兩個下劃線
‘’’
class Person:
__hobby = 'dance'
def __init__(self):
self.__name = '李四' # 加兩個下劃線將此屬性私有化,不能再外部直接訪問，在類的內部可以訪問
self.age = 30
def __str__(self):
return '{}的年齡是{}，喜歡{}'.format(self.__name, self.age, Person.__hobby) # 調用私有化屬性
def change(self, hobby):
Person.__hobby = hobby
class Studeng(Person):
def printInfo(self):
# print(self.__name)#訪問不了父類中的私有屬性
print(self.age)
pass
xl = Person()
# print(xl.name)#通過類對象，在外部訪問的
print(xl)
xl.change('唱歌') # 修改私有屬性的值
print(xl)
stu = Studeng()
stu.printInfo()
stu.change('Rap')
print(stu)
# print(xl.hobby) # 通過實例對象訪問類屬性
# print(stu.hobby) # 通過實例對象訪問類屬性
# print(Person.hobby) # 通過類對象訪問類屬性
‘’’
_xxx前面加下劃線，以單下劃線開頭表示的是protected類型的變量，即保護類型只能允許其本身與子類進行訪問，不能使用from xxx import *的方式導入
__xxx__前後兩個下劃線，魔術方法，一般是python自帶的，開發者不要創建這類型的方法
xxx_後面單下劃線，避免屬性名與Python關鍵字沖突
class A:
def __myname(self): #在方法名前面加兩個下劃線
print(‘小明’)
class Animal:
def __eat(self):
print('吃東西')
def run(self):
self.__eat() # 在此調用私有化方法
print('飛快地跑')
class Bird(Animal):
pass
bird = Bird()
bird.run()
# 屬性函數 (property)
class Perons:
def __init__(self):
self.__age = 18
def ger_age(self):#訪問私有實例屬性
return self.__age
def set_age(self, age):#修改私有實例屬性
if age < 0:
print('年齡太小')
else:
self.__age = age
#定義一個類屬性，實現通過直接訪問屬性的形式去訪問私有屬性
age=property(ger_age,set_age)
p=Perons()
print(p.age)
p.age=-1
print(p.age)
學習使用Python操作文件，了解Python的垃圾回收機制
以二進制的形式寫數據
''' fobj=open("./Test1.text","wb")# str--->bytes fobj.write("在烏雲和大海之間".encode("utf-8")) fobj.close() '''
二進制形式追加
''' #追加不需要encode() #fobj=open("Test.text","a")# 追加數據 #fobj.write("在烏雲和大海之間\r\n") #fobj.write("海燕像黑色的閃電\r\n") fobj=open("./Test1.text","ab")# str--->bytes fobj.write("今天詩興大發\n".encode("utf-8")) fobj.close() '''
讀文件數據
#fobj=open('./Test.text','r')
fobj=open('./Test.text','rb')
data=fobj.read()
print(data)
print(data.decode("utf-8"))#讀取所有數據
#print(fobj.read(12))#讀取兩個數據
#print(fobj.readline())#讀取一行數據
#print(fobj.readlines())#讀取所有行，返回列表
fobj.close()#文件對象關閉掉
with open("withfile.text",'r') as f:
#f.write("123木頭人")
print(f.read())
學習正則表達式操作字符串
re模塊是用C語言寫的沒匹配速度非常快
其中compile函數根據一個模式字符串和可選的標志參數生成一個正則表達式對象，該對象擁有一系列方法用於正則表大會匹配和替換，re模塊也提供了與這下方法功能完全一致的函數，這些函數適用一個模式字符串做為他們的第一個參數
re.macth方法
import re
str='Python is the best language in the world'
result= re.match('P',str)
print(type(result))#<class 're.Match'>
print(result.group())
標志位
import re
strData='Python is the best language in the world\
gslfjgldsjgls'
#result= re.match('p',strData,re.I|re.M)#第三個參數 忽略大小寫
#print(type(result))#<class 're.Match'>
#print(result.group())
res=re.match('(.*?)is(.*?)',strData,re.I)
print(res.group(1))
print(res.group(2))
常用匹配規則
匹配字符數量
import re
# * 匹配前一個字符出現0次或者無限次
res=re.match('[a-z][a-z]*','MyPython',re.I)
print(res.group())
# + 匹配前一個字符1次或者無限次 至少一次
res=re.match('[a-zA-Z]+[\w]*','mynAMEDCeisz848s_')
print(res.group())
# ? 匹配前一個字符0次或者1次
res=re.match('[a-zA-Z]+[\d]?','mkohjhjgu8jg8')
print(res.group())
# {min,max} 匹配前一個從min到max次 min max必須是非負整數
#{count}精確匹配次數 {count,}沒有限制
res=re.match('\d{4,}','46145')
if res:
print('匹配成功{}'.format(res.group()))
#匹配郵箱 格式：[email protected]
res=re.match('[a-zA-Z0-9]{6,11}@163.com','[email protected]')
print(res.group())
# path="D:\\1_zhao_File\\1_MarkDown\MarkDown學習使用篇"
# print(path )
import re
#原生字符串 r
print(re.match(r'c:\\a.text','c:\\a.text').group())
#匹配開頭結尾
#^ 匹配字符串開頭
#$ 匹配字符串結尾
# res=re.match('^p.*','python is language')
res=re.match('^p[\w]{5}','python is language')
print(res.group())
res=re.match('[\w]{5,15}@[\w]{2,5}.com$','[email protected]')
print(res.group())
# | 匹配左右任意一個表達式 從左往右
import re
res=re.match('[\w]*|100','100')
print(res.group())
# (ab)分組匹配 將括號中字符作為一個分組
res=re.match('([0-9]*)-(\d*)','123456-464651561')
print(res.group())
print(res.group(1))
print(res.group(2))
# \num 的使用
# htmlTag='<html><h1>Python核心編程</h1></html>'
# res1=re.match(r'<(.+)>(.+)>(.+)</\2></\1>',htmlTag)
# print(res1.group(1))
# 分組 別名的使用 (?P<名字>)
data='<div><h1>www.baidu.com</h1></div>'
res=re.match(r'<(?P<div>\w*)><(?P<h1>\w*)>(?P<data>.*)</\w*></\w*>',data)
print(res.group())
# re.compile 方法
''' compile將正則表達式模式編譯成一個正則表達式對象 reg=re.compile(pattern) result=reg.match(string) 等效於result=re.match(pattern,string) 使用re.compile和保持所產生的正則表達式對象重用效率更高 '''
import re
#compile 可以把字符串編譯成字節碼
#優點：在使用正則表達式進行match時，python會將字符串轉為正則表達式對象
# 而如果使用compile，只需要轉換一次即可，以後在使用模式對象的話無需重復轉換
data='1364'
pattern=re.compile('.*')
#使用pattern對象
res=pattern.match(data)
print(res.group())
#re.search方法
#search在全文中匹配一次，匹配到就返回
data='我愛我偉大的祖國，I love China,China is a great country'
rees=re.search('China',data)
print(rees)
print(rees.span())
print(rees.group())
# print(data[21])
#re.findall方法 匹配所有，返回一個列表，
data='華為牛逼是華人的驕傲'
# res =re.findall('華.',data)
# print(res)
pattern=re.compile('華.')
res=pattern.findall(data)
print(res)
# re.sub方法 實現目標搜索和替換
data1='Pythons是很受歡迎的編程語言'
pattern='[a-zA-Z]+' #字符集范圍 +代表 前導字符模式出現1從以上
res=re.sub(pattern,'C#',data1)
resn=re.subn(pattern,'C#',data1)
print(res)
print(resn)
#re.subn 完成目標的的搜索和替換 還返回被替換的數量，以元組的形式返回
#re.split 是新分割字符串
data='百度，騰訊，阿裡，華為，360，字節跳動'
print(re.split(',',data))
''' python 中默認是貪婪的，總是貪婪的匹配盡可能多的字符，非貪婪相反，總是嘗試匹配盡可能少的字符 在 ” * ？ + {m,n}"後面加上 ? 使貪婪變成非貪婪 '''
#貪婪
import re
res=re.match('[\d]{6,9}','111222333')
print(res.group())
#非貪婪
res=re.match('[\d]{6,9}?','111222333')
print(res.group())
content='asdfbsdbdsabsd'
# pattern=re.compile('a.*b')# 貪婪
pattern=re.compile('a.*?b')#非貪婪
res=pattern.search(content)
print(res.group())
#0710-49
