python基礎(chǔ)

一、數(shù)值類型與序列類型

知識點:

1.變量與定義  2.數(shù)值類型數(shù)據(jù)  3.序列類型數(shù)據(jù)  4.序列類型的通用操作

1.數(shù)值類型

變量與定義：

1茎截、什么是變量？
    變量就是用來儲存數(shù)據(jù)的
2监氢、變量怎么定義修壕？
    a = 123
    
3、變量的命名規(guī)則:    myVar   my_var

    變量命名咧最、：數(shù)字、字母御雕、下劃線矢沿，并且不能以數(shù)字開頭，不要用關(guān)鍵字命名

    查看關(guān)鍵字：import keyword
                keywrod.kwlist   （了解即可）

數(shù)值類型

1酸纲、什么是數(shù)值類型數(shù)據(jù)呢捣鲸？

2、Python中總共有多少數(shù)值類型闽坡？
    
    int ：整數(shù)         
    float：浮點數(shù)
    complex：復(fù)數(shù)       
    bool：布爾型  （特殊的數(shù)值類型栽惶，只有True和False兩個值）

3愁溜、怎么查看數(shù)據(jù)的類型呢？——> type( )
    a = 123
    print(type(a))

一外厂、數(shù)值的基本運算

二冕象、Python中其他運算方法

1、Python里面小數(shù)如何進行精確計算（了解即可）

# 如果進行精確計算酣衷？ 導(dǎo)入 decimal模塊

improt decimal
b = decimal.Decimal('2')
a = decimal.Decimal('2.3')
c = a - b
print( c )

2交惯、Python中 //運算 默認(rèn)運算向下取 整數(shù)

(1): 向下取 整數(shù)
    a = 5 // 2  
    print( a )  

(2):如果要向上取整的話，需要導(dǎo)入模塊math
    import math
    a = 8/3
    b = math.ceil( a )
    print(b)

如何應(yīng)用

1.數(shù)值計算: 常見的數(shù)值計算 
2.布爾型:   在后面要學(xué)習(xí)到的判斷中穿仪，是根據(jù)布爾值來判斷是否執(zhí)行
3.四則運算: 能夠靈活的使用四則運算往往可以很大程度上精簡我們的代碼

數(shù)值類型總結(jié):

整型席爽、浮點數(shù)和布爾型的定義和使用必須要掌握
復(fù)數(shù)和decimal(定點數(shù))了解即可
熟練使用常見的算術(shù)運算符
了解math模塊，需要的時候查看看文檔

2.序列類型

思考?

在Python中如果我想表示字母怎么辦呢啊片？
在Python中有東西既可以放字符串又可以放數(shù)值嗎只锻？

序列類型數(shù)據(jù)有哪些？

一紫谷、字符串:str (字符串定義：用引號包起來)

a = 'hackers123'

二齐饮、列表:list ( 列表的定義：中括號 [ ] )

a = [1,2,3]

三、元組 :tuple ( 元祖的定義：小括號（） )

b = ( 1,2,'abc' )

序列類型的通用操作笤昨？

一祖驱、索引取值和切片
二、序列類型之間相互轉(zhuǎn)換
三瞒窒、變量引用和拆包

一捺僻、下標(biāo)索引取值和切片

一、索引取值

a = (1,2,3,4,5,'abc')
b = a[0]
print( b )

二崇裁、序列類型的切片

a = (,1,2,3,4,5,6)
b = a[1:4]
print(b)

二匕坯、Python的序列類型的相互轉(zhuǎn)換

思考?

不同的序列類型可以相互轉(zhuǎn)化嗎？
列表和元組有什么區(qū)別呢拔稳？

擴展知識點

一葛峻、變量的重新賦值
二、變量的引用
三巴比、拆包

二术奖、序列類型的方法

本節(jié)知識點

1. 列表方法
2. 字符串方法
3. 元組的方法

1.列表方法

思考?

我們之前知道列表取值的方法，那怎么對數(shù)據(jù)做增刪改查呢轻绞？
列表除了增刪改查還有什么其他的方法呢腰耙？

列表方法

1、增：
    append()    （添加單個元素）
    insert()    （指定位置插入元素）
    extend()    （添加多個元素）

eg:
    li = [1,2,3,4,5,6]
    li.append(10)
    print(li)       # 1,2,3,4,5,6,10

2铲球、查：
    index()     （查找元素下標(biāo)） 
    count()     （查找元素出現(xiàn)的個數(shù)）
    
eg:
    li = [1,2,3,4,5,6]
    index = li.index(2)
    print( index )  # 3

3、刪：
    pop()       （刪除一個元素）
    remove()    （刪除指定元素）
    clear()     （情況列表）
    
eg:
    li = [1,2,3,4,5,6]
    index = li.remove(6)
    print( index )  # 返回已刪除的元素: 6

4晰赞、改:   通過下標(biāo)改值
   eg: 
        a = [1,5,6]
        a[0] = 4
        print(a) # 4,5,6

5稼病、其他方法：
    copy() ：    （復(fù)制 ）        
    reverse()：  （反向）
    sort()：     （排序）
    
eg:
    li = [1,2,3,4,5,6]
    num = li.reverse()
    print( num )    # [6,5,4,3,2,1]

列表的應(yīng)用

1.列表是python中最基本也是使用十分廣泛的數(shù)據(jù)類型
2.列表的使用在Python代碼幾乎無處不在
3.因此同學(xué)們對列表的增刪改查操作需要十分熟悉选侨，并且要知道同種類型
  不同方法之間的區(qū)別

2.字符串方法

思考?

字符串可以增刪改嗎？
如果可以的話那要怎樣做呢然走？

字符串方法

count()：查看元素出現(xiàn)的次數(shù)
eg:
    s = '123cdsff'
    num = s.count('f')
    print(num)      # 次數(shù)為2

find()：查找元素是否存在(存在返回下標(biāo)援制，不存在返回-1)

eg:
    s = '123cdsff'
    num = s.find('2')
    print(num)      # 下標(biāo)為:1

index()：跟find一樣，不存在報錯(存在返回下標(biāo),不存在報錯)

eg:
    s = '123cdsff'
    num = s.find('2')
    print(num)      # 下標(biāo)為:1

split()：分割(通過指定元素作為分割點芍瑞，將字符串分割晨仑，也可添加參數(shù)指定分割次數(shù))

eg:
    s = '123cdsff'
    ss = s.split('c')
    print(ss)       # ['123',,'',dsff']

replace()：替換(將指定元素全部替換)

eg:
    s = '123cdsff'
    ss = s.replace('c','a')
    print(ss)       # '123adsff'

字符串方法（了解即可）

 isdigit：查看字符串是否是純數(shù)字
isalpha：查看字符串是否是純字母
endswith：查看字符串是否已指定字段結(jié)束
startswith：查看字符串是否已指定字符開頭
islower：查看是否包含字母，并且字母都是小寫
isupper：查看是否包含字母拆檬，并且字母都是大寫
upper：把字符串中的小寫自怒轉(zhuǎn)化為大寫
lower：把字符串中的大小寫字母轉(zhuǎn)化為小寫
capitalize：把字符串第一個字母大寫
title：把每個單詞首字母大寫
strip ：刪除兩端空白字符 
lstrip：刪除左邊空白字符
rstrip：刪除右邊空白字符

語法格式(  字符串.方法名()  )：
         
         str1 = '12345'
         print( str1.isdigit()  ) # True

字符串拼接

1洪己、使用  +
    str1 + str2 + str3

2、格式化字符串

   ’%s %%s’%(str1,str2,str3)

3竟贯、使用join

    ’’.join([str1, str2, str3])

4答捕、使用 format

    ’{} {} {}’.format(obj1,obj2,obj3)

    ’{0} {1} {2}’.format(obj1,obj2,obj3)

    '{n0} {n1} {n2}'.format(n1=obj1,n0=obj2,n2=obj3)

字符串的應(yīng)用

1.字符串方法:
    字符串方法可以方便的對字符串作出處理，雖然字符串是不可變對象屑那，但是可以通過返回新對象的方法來實    現(xiàn)增刪改查拱镐，字符串方法很多，掌握常用的就好

2.字符串拼接和格式化
    實際中我們會將很多的字符串拼接起來持际，然后輸出或者是傳輸沃琅，這就需要我們能夠熟練的使用拼接和格式化    方法，在不同的場景中選擇方便和合適的方法

3.字符串的轉(zhuǎn)義
    字符串的轉(zhuǎn)義能表示很多不方便顯示的字符蜘欲，但同時也會帶來一些麻煩佛致，要學(xué)會正確的處理

3.元組的方法

思考?

元組有哪些方法呢？

元組方法:

查詢元素出現(xiàn)次數(shù):        count() 
查看元素第一個出現(xiàn)的位置: index()

元組的應(yīng)用

元組是不可變對象声滥，如果需要改變妓蛮，轉(zhuǎn)化成列表即可
元組中只有  count 和  index 方法，方便查找元組中的數(shù)據(jù)

三殿衰、使用 Vim 編輯 python

本節(jié)知識點

01. Linux常用命令
02. vim使用
03. vim編輯py文件
04. input朱庆、print

Linux常用命令

1. 查看文件信息：ls
2. 顯示當(dāng)前路徑：pwd
3. 創(chuàng)建目錄：mkdir
4.創(chuàng)建文件：touch
5.切換工作路徑：cd

Linux命令

刪除目錄：rmdir   (必須是空目錄)
刪除文件：rm
    參數(shù)               含義
    -i          以進入交互方式執(zhí)行
    -f          強制刪除,忽略不存在的文件,無需提示
    -r          遞歸地刪除目錄下的內(nèi)容,刪除文件夾時必須加此參數(shù)
    
輸出重定向命令：>
查看文件內(nèi)容及合并文件：cat
復(fù)制文件：cp
移動文件：mv
清屏：clear

查看當(dāng)前用戶：whoami
查看日歷：cal
查看當(dāng)前時間:date
查看進程信息：ps
動態(tài)顯示進程：top
遠程測試主機連通性  : ping    
查看網(wǎng)卡信息 : ifconfig  
重啟:   reboot 
關(guān)機:（poweroff  shutdown  init）
獲取root權(quán)限 : sudo 

Vim介紹

編輯器:
    Vim是Linux上常用編輯器，在Windows上可以使用記事本來編輯文件內(nèi)容闷祥，Vim也類似于記事本娱颊，但是    Vim有更加強大的功能，這樣Vim長久不衰

三種模式:
    在Vim中凯砍，有命令模式箱硕，輸入模式 和 末行模式三種模式。
    按 Esc 進入命令模式
    輸入 Shift + 悟衩； 進入末行模式
    輸入插入命令剧罩，如(i,a,o) 進入shu ru模式

Vim插件:
    Vim豐富的插件，可以把Vim打造成一個功能完備的IDE座泳，我們提供給大家的Vim已經(jīng)配置成一個適用于      Python開發(fā)的IDE

Vim使用

一惠昔、進入
     vim   文件名
     退出
        :wq    末行模式幕与，wq 保存退出
        :q       末行模式，q 直接退出
        :q!      末行模式镇防，q! 強制退出啦鸣，不保存


二、輸入模式
        i   從光標(biāo)所在位置前面開始插入
        I   在當(dāng)前行首插入
        a   從光標(biāo)所在位置后面開始輸入
        A   在當(dāng)前行尾插入
        o   在光標(biāo)所在行下方新增一行并進入輸入模式
        O   在當(dāng)前上面一行插入

# 進入輸入模式后来氧，在最后一行會出現(xiàn)--INSERT—的字樣


三诫给、移動光標(biāo)
        gg    到文件第一行
        G      到文件最后一行   (Shift + g)
        ^      非空格行首
        0       行首(數(shù)字0)
        $       行尾


四、復(fù)制和粘貼
        yy    復(fù)制整行內(nèi)容
        3yy  復(fù)制3行內(nèi)容
        yw   復(fù)制當(dāng)前光標(biāo)到單詞尾內(nèi)容
        p      粘貼


五啦扬、塊操作：
        v    塊選擇
        ctrl + v   列塊選擇
        
        
六中狂、刪除
        dd  刪除光標(biāo)所在行
        dw  刪除一個單詞

        x     刪除光標(biāo)所在字符
        u    撤銷上一次操作
        s     替換
        ctrl + r    撤銷   u


七、查找
       /    命令模式下輸入：/   向前搜索
       ?    命令模式下輸入：?   向后搜索
       n    向下查找
       N   向上查找

Vim編輯py文件

在Linux中考传，文件后綴只是一個標(biāo)示吃型，  任何文件都
可以用vim打開，py文件也是僚楞，也可以用vim文件
打開編輯

思考?

如果是寫在py文件中的python代碼要怎么運行呢勤晚？

py文件的的運行

一、
退出Vim,再執(zhí)行
python   file.py

二泉褐、
如果是使用的我們提供給大家的Vim赐写，可以按 F5 運行
注意：F5運行只是方便大家在學(xué)習(xí)過程中，方便大家調(diào)
試代碼而配置的膜赃，在實際項目中挺邀，還是使用第一種方法
運行python程序

python虛擬環(huán)境的使用

查看已經(jīng)安裝的虛擬環(huán)境
    workon   

進入虛擬環(huán)境：
    workon   虛擬環(huán)境名        

退出虛擬環(huán)境，家目錄下執(zhí)行：
    deactivate

輸入 | 輸出

輸入：input()

輸出：print()

四跳座、格式化輸出 和 深淺復(fù)制

本節(jié)知識點

01. 格式化輸出和字符串轉(zhuǎn)義
02. 字符串編碼
03. bytes和bytearray
04. 深淺復(fù)制

1.格式化輸出和字符串轉(zhuǎn)義

思考?

什么是格式化輸出端铛，之前講了字符串的拼接就已經(jīng)用到過了，其中用到的%s就是格式化輸出的一種疲眷，除了%s還有哪些格式化禾蚕？

format還有其他的用法嗎？

格式化輸出—>傳統(tǒng)方法

%s：通過str() 字符串轉(zhuǎn)換來格式化

了解：

    %d    %數(shù)字
    %f     %浮點數(shù)
    %c    %ASCII字符
    %o    %8進制
    %x    %16進制
    %e    %科學(xué)計數(shù)法
    ‘%-6.3f’%10.3    左對齊
    ‘%+-6.3f’%10.3   顯示正負(fù)
    ‘%5s’%’ab’    格式化長度

掌握：
    print(‘%s’%’123’)
    print(‘%r’%’123’)

Python方法

format

了解：
'{:.2f}'.format(12.333)         保留小數(shù)點后兩位
'{a:.2f}'.format(a=12.333)
'{:.2%}'.format(0.333)         百分比格式
'{0:x}'.format(20)                轉(zhuǎn)換成十六進制
'{0:o}'.format(20)                轉(zhuǎn)換成八進制    
 
 進制轉(zhuǎn)換的時候用{0:進制}

'{:0<10}'.format(12.3)          右對齊狂丝，長度為10
'{:x<10}'.format(13.44)        數(shù)字補x 
'{:0>10}'.format(13.44)        左對齊...
'{:0^10}'.format(13.44)        兩邊對齊...


'{{  hello {0}  }}'.format('python’)         轉(zhuǎn)義{和}符號

f = ' hello {0} '.format
f('python’)         這里可以把format當(dāng)作一個函數(shù)來看

字符串的轉(zhuǎn)義

字符前面加上   \   换淆，字符就不再表示字符本身的意思，表示ASCII碼中不能顯示字符几颜，
常見有下：

    \n  換行
    \t  水平制表符   
    \b  退格  
    \r  回車倍试，當(dāng)前位置移到本行開頭
    \\  代表反斜杠  \
    \’  代表一個單引號，同樣的 “  蛋哭？ 等符號也可以這么輸出
    \0  代表一個空字符
    \a  系統(tǒng)提示音

在python中如果要去掉字符串的轉(zhuǎn)義县习，只需要在字符串前面加上 r
    
    r'abc\tabc'

格式化和轉(zhuǎn)義應(yīng)用

格式化得到的結(jié)果都是字符串，通過把位置預(yù)先留出來，
后期再往其中填入內(nèi)容可以讓輸出內(nèi)容更加整潔美觀躁愿，而又具有良好的可讀性哈蝇，同時讓代碼更簡潔精練

字符串的轉(zhuǎn)義可以方便我們表示我們不太方便表示的字符，同時轉(zhuǎn)義有些情況下又會帶來麻煩攘已，特別是在表示路徑的時候，這種情況下可以在字符串前面加上  r  來去掉字符串的轉(zhuǎn)義

2.字符串編碼

思考

剛才我們講到了我們在python內(nèi)部要對字符串進行拼接和格式化是為了輸出和傳輸怜跑，那python中字符串的可以直接在網(wǎng)絡(luò)上傳輸嗎样勃？

如果不可以的話，python內(nèi)部是怎么做的呢性芬？

編 碼

'編碼數(shù)據(jù)'.encode(encoding='utf8')
'編碼數(shù)據(jù)'.encode(encoding='gbk')

上面的輸出結(jié)果分別是：
    b'\xe6\xbd\xad\xe5\xb7\x9e'
    b'\xcc\xb6\xd6\xdd'

字符串編碼的作用

Python統(tǒng)一了編碼峡眶，這樣Python在內(nèi)部處理的時候不會因編碼不同而出現(xiàn)程序不能正常執(zhí)行的問題

Python會自動根據(jù)系統(tǒng)環(huán)境選擇編碼，但是經(jīng)常在文件傳輸?shù)倪^程中植锉，會遇到各種不同的編碼辫樱，這個時候就需要我們?nèi)ヌ幚砭幋a問題

3.bytes和bytearray

思考

Python中的序列類型還有嗎？

bytes二進制序列類型

指定長度的零填充字節(jié)對象:
    方法:bytes()
    eg: 
        a = bytes(3)
        print(a) # b'\x00\x00\x00

二進制字符串對象：
    方法:bytes()
    eg: 
        a = bytes(a'abc')
        print(a) # b'abc'

bytearray二進制數(shù)組

指定長度的零填充字節(jié)對象:
    方法:bytearray()

二進制字符串對象：
    方法:bytearray()

二進制序列類型的應(yīng)用

二進制序列類型的用法比較少見俊庇，是python中少用的一種序列類型

對于二進制序列類型狮暑，大家基本了解即可

4.深淺復(fù)制

思考

列表里面可以放列表嗎？

定義如下列表：

li = [1, 2, 3]

li2 = [‘a(chǎn)’,  li]

淺復(fù)制：

li3  =  li2.copy()

深復(fù)制：

import   copy

l4  =  copy.deepcopy(li2)

深淺復(fù)制的應(yīng)用

深淺復(fù)制只有在列表嵌套列表的情況下討論

如果想保留修改之前的數(shù)據(jù)辉饱，就可以使用列表的復(fù)制搬男，但要注意列表嵌套情況下的問題

五、散列類型與 運算符優(yōu)先級, 邏輯運算

本節(jié)知識點

01. 集合
02. 字典
03. 運算符優(yōu)先級
04. 邏輯運算

1.集合

思考

回想下彭沼，列表中可以插入重復(fù)的元素嗎缔逛？

集 合

兩種定義方法：
    set1 = set(1,2,3) 

    {1,2,3,4}

三種運算:

s1 & s2          交集

s1  |  s2       并集

s1  -  s2       差集

集合的增刪改查方法

增：
    add()：增加一個元素
    update()：將一個集合的所有元素添加到原來集合中

刪：
    pop(): 刪除任意一個元素
    remove():  刪除指定元素

查：
    isdisjoint()    有交集返回False
    issubset()      判斷是否包含于
    issuperset()   判斷是否包含

集合特性

唯一性:集合中的元素具有唯一性，不存在兩個相同的元素
無序性:集合中的元素是無序的姓惑，所以沒有存在索引
可變性:集合是可變對象

2.字典

思考

那么接下來我們開始學(xué)習(xí)字典褐奴，在學(xué)習(xí)字典之前我們來思考一個問題，如果說我用列表儲存了咱們班一個的學(xué)員信息于毙，姓名敦冬，年齡，電話號碼望众，儲存完之后發(fā)現(xiàn)電話號碼寫錯了匪补，這個時候要修改電話號碼，怎么修改呢烂翰？

如果不能確定下標(biāo)呢夯缺？我們怎么改？是不是要先找到下標(biāo)甘耿，然后再修改踊兜。那么有沒有一種數(shù)據(jù)類型，可以快速找到我們儲存的某個數(shù)據(jù)呢

字典

兩種定義方法
    dict1 = {‘name’: '凱華',  'age'：18}        鍵值對形式 
    dict2 = dict(name='小明', age=18)           使用dict函數(shù)

修改和添加：
    dict1[‘name’] = '鍵值'
    dict2[‘a(chǎn)ge’] = 20

字典的增刪改查

刪：
    pop():      通過keyj鍵刪除對應(yīng)value鍵值佳恬，并返回
    popitem():  刪除一個鍵值對捏境，并返回  
    clear():    清空列表

查：
    get():      通過key查找對應(yīng)的value志
    keys():     查找出列表內(nèi)所有的key  
    values():   查詢所有的value
    items():    顯示所有的鍵值對

增 ： 
    update():       把一個字典里的鍵值對添加的原來的字典里
    setdefault():   有則查于游，無則增

其他方法：
    copy():     復(fù)制
    fromkeys(): 返回一個新的字典

字典特性

鍵(key)唯一性:字典中的鍵(key)具有唯一性，不存在兩個相同的鍵(key)
無序性:字典中的鍵也是無序的垫言，所以不能通過索引取值
可變性:字典是可變對象贰剥，但是字典的鍵(key)必須是不可變對象

3.運算符優(yōu)先級

思考

Python中有哪些運算符？

Python中的運算符

運算符                         描述


**                           冪運算
+筷频、-                         一元運算(正負(fù)號)

*蚌成、/、%                      算術(shù)運算符
+凛捏、-

<担忧、>、<=坯癣、>=                  比較運算符
==瓶盛、!=

=、%=示罗、/=惩猫、-=、+=鹉勒、*=帆锋、**=     賦值運算符
is、is not                   身份運算符
in禽额、not in                   成員運算符
not > and > or               邏輯運算符

4.邏輯運算

思考?

如何判斷兩個對象相同呢锯厢？
如何表示多個相同的條件呢？

邏輯運算符

1脯倒、查看對象類型：
    type
    isinstance
    
2实辑、比較運算符：
    ==
    !=

3、如果有多個條件：
    判斷語句1    and        判斷語句2
    判斷語句1    or         判斷語句2
    not                    判斷語句1

六藻丢、控制流程

本節(jié)知識點

01. 條件判斷
02. 三目運算
03. 條件循環(huán)
04. 迭代循環(huán)

1.條件判斷

思考

py文件中的代碼是按照怎樣的順序執(zhí)行的呢剪撬？怎么去驗證呢？
代碼的執(zhí)行順序可以改變嗎悠反？如果可以要怎么改變呢残黑？

代碼運行順序

從 上 往 下 依 次 執(zhí) 行

條件語句

語法結(jié)構(gòu)：

    if  判斷語句1:
        執(zhí)行語句1

    elif 判斷語句2:
        執(zhí)行語句2
    ...

    else:
        執(zhí)行語句

2.三目運算

思考:

有這樣一個判斷，如果值大于5返回True斋否，否則返回False梨水，代碼該么寫？
有更加簡單點的方式嗎茵臭？

三目運算

一般判斷運算:
    a  =   3
    if  a > 5:
        print(True)

    else:
        print(False)

三目運算:
    a  =   3
    True  if   a>5  else False


三目運算格式：
    條件滿足的結(jié)果 if  條件  else  條件不滿足的結(jié)果

3.條件循環(huán)

思考

如果在程序中疫诽，在特定的條件下，需要重復(fù)做一件事  應(yīng)該怎么做呢，比如說我們要在屏幕上打印100遍 hello python

我們前面的程序運行一遍接就結(jié)束了奇徒，有什么辦法讓前面的程序一直運行

條件循環(huán)：while

語法規(guī)則：
    while 判斷語句：
          循環(huán)體

??  注意縮進

循環(huán)里的 break 和continue 和else

1雏亚、break的用法：直接終止循環(huán)
2、continue的用法:中止當(dāng)前這一輪循環(huán)摩钙，進入下一輪循環(huán)
3罢低、else：是在while的條件不成立是執(zhí)行，循環(huán)被break終止的情況下胖笛，不會執(zhí)行else中的內(nèi)容

條件循環(huán)：while

while True:（表示條件始終成立）

while的應(yīng)用

控制程序流程: 對于不同的條件奕短，執(zhí)行不同的代碼
break:      可以在沒有終止條件的情況下結(jié)束循環(huán)
else:       只有在循環(huán)被終止條件終止的情況下才會執(zhí)行

4.迭代循環(huán)

思考

有一個列表li = [1，5,6,8,9,3,2]
如果要把里面的元素匀钧，一個一個全部拿出來應(yīng)該怎么做？

要求打印出1-20內(nèi)的整數(shù)

for 迭代循環(huán)

語法規(guī)則：
    for  i  in  obj：
         循環(huán)體

案例:
    li = [1,  5,  6,  9,  3,  2]
    for  i  in  li:
            print(i)
            
注意的要點：            
    1谬返、for 后面需要接上可迭代對象
    2之斯、for會依次取出可迭代對象中的元素
    3. 注意縮進

range的用法

range的用法：
    for  i  in  range(21):
            print(i)
           
注意的要點： 
    for循環(huán)中也可以用 break  continue   和else

print

end = ''   表示下一次打印不換行

print('xxxx',end='')

for的應(yīng)用

控制程序流程: 對于不同的條件，執(zhí)行不同的代碼
continue:   可以跳過本次循環(huán)遣铝，進入下次循環(huán)
else:       只有在正常迭代結(jié)束佑刷，即不是被break終止的情況

七、函數(shù) 與 參數(shù)

本節(jié)知識點

01. 函數(shù)的定義和調(diào)用
02. 函數(shù)參數(shù)和返回值
03.常見內(nèi)置函數(shù)

1.函數(shù)的定義和調(diào)用

思考

問題：有多個地方需要打印怎么做呢
問題：是不是需要打印的地方寫重復(fù)的代碼

函數(shù)的定義及調(diào)用

1酿炸、函數(shù)的定義
def  函數(shù)名(參數(shù))：
        pass

函數(shù)名命名規(guī)則：
    字母瘫絮、數(shù)字和下劃線組成，和變量命名規(guī)則一致

2填硕、函數(shù)的調(diào)用：    
        函數(shù)名（）

2.函數(shù)參數(shù)和返回值

思考

剛才講到了函數(shù)的定義麦萤，那函數(shù)里面可以傳入哪些對象呢？

函數(shù)參數(shù)的定義

1扁眯、必備參數(shù)：
    def  func(x):
        pass

2壮莹、默認(rèn)參數(shù)：
    def  func(x, y=None):
        pass

3、不定長參數(shù)：
    def  func(*args, **kwargs):
        pass

參數(shù)的調(diào)用：
    1姻檀、通過位置傳遞參數(shù)（未命名參數(shù)）
    2命满、通過關(guān)鍵字傳遞參數(shù)（命名參數(shù)）
    3.在python中參數(shù)無類型，參數(shù)可以接受任意對象绣版，只有函數(shù)中代碼才會對參數(shù)類型有限制

函數(shù)參數(shù)調(diào)用演示

1胶台、必備參數(shù)：
    def  func(x):
        print(x)

    func(1)

2、默認(rèn)參數(shù)：
    def  func(x, y=None):
         print(x)
         print(y)

    func(1)
    func(1, 2)

3杂抽、不定長參數(shù)：
    def  func(*args, **kwargs):
        print(args)
        print(kwargs)

    func(1, 2, 3, a=4, b=5, c=6)
    func(*(1, 2, 3), **{'a': 4, 'b': 5, 'c': 6})

函數(shù)的參數(shù)

必備參數(shù):在函數(shù)調(diào)用的時候诈唬，必備參數(shù)必須要傳入
默認(rèn)參數(shù):在函數(shù)調(diào)用的時候，默認(rèn)參數(shù)可以不傳入值默怨，不傳入值時讯榕，會使用默認(rèn)參數(shù)
不定長參數(shù):在函數(shù)調(diào)用的時候，不定長參數(shù)可以不傳入，也可以傳入任意長度愚屁。
其中定義時济竹，元組形式可以放到參數(shù)最前面，字典形式只能放到最后面

3.常見內(nèi)置函數(shù)

思考

Python中有哪些內(nèi)置函數(shù)呢霎槐？

Python中簡單內(nèi)置函數(shù)

1送浊、內(nèi)置對象查看：dir(__builtins__)
常見函數(shù)：
    len()       求長度
    min()       求最小值
    max()       求最大值
    sorted()    排序
    reversed()  反向
    sum()       求和
    
    
進制轉(zhuǎn)換函數(shù)：
    bin()   轉(zhuǎn)換為二進制
    oct()   轉(zhuǎn)換為八進制
    hex()   轉(zhuǎn)換為十六進制
    ord()   字符轉(zhuǎn)ASCII碼
    chr()   ASCII碼轉(zhuǎn)字符

Python中高級內(nèi)置函數(shù)

1、enumerate()  ： 同時列出數(shù)據(jù)和數(shù)據(jù)下標(biāo)丘跌，一般用在 for 循環(huán)當(dāng)中
2袭景、eval()： 
    一、取出字符串中的內(nèi)容
    二闭树、將字符串str當(dāng)成有效的表達式來求指并返回計算結(jié)果

3耸棒、exec():       執(zhí)行字符串或complie方法編譯過的字符串
4、filter() ：    過濾器
5报辱、zip() ：       將對象逐一配對
6与殃、map()：        對于參數(shù)iterable中的每個元素都應(yīng)用fuction函數(shù)，并將結(jié)果作為列表返回

常見內(nèi)置函數(shù)

常見內(nèi)置函數(shù)提供了一些處理的數(shù)據(jù)的方法碍现，可以幫助我們提高開發(fā)速度

我們介紹了一些python比較常見的內(nèi)置函數(shù)幅疼，大家了解即可，知道能做什么昼接，能夠得到什么結(jié)果就行

八爽篷、函數(shù)作用域與匿名函數(shù)

本節(jié)知識點

01. 高級內(nèi)置函數(shù)
02. 匿名函數(shù)
03. 函數(shù)作用域
04. 遞歸函數(shù)
05. 閉包

1.高級內(nèi)置函數(shù)

Python中高級內(nèi)置函數(shù)

1、enumerate()  ： 同時列出數(shù)據(jù)和數(shù)據(jù)下標(biāo)慢睡，一般用在 for 循環(huán)當(dāng)中
2逐工、eval()： 
    一、取出字符串中的內(nèi)容
    二漂辐、將字符串str當(dāng)成有效的表達式來求指并返回計算結(jié)果
            
3钻弄、exec():     執(zhí)行字符串或complie()方法編譯過的字符串
4、filter() ：過濾器
5者吁、zip() ： 將對象逐一配對
6窘俺、map()：  對于參數(shù)iterable中的每個元素都應(yīng)用fuction函數(shù)，并將結(jié)果作為列表返回

2.匿名函數(shù)

思考

上節(jié)課的filter函數(shù)复凳，可以過濾出列表中大于10的數(shù)據(jù)瘤泪，但是使用都需要提前定義一個函數(shù)，有沒有更加簡便的方式呢育八？

匿名函數(shù) lambda

filter(lambda x: x>10, li)

語法規(guī)則：
    lambda   參數(shù) : 表達式 

匿名函數(shù)應(yīng)用場景

簡單函數(shù):簡單的函數(shù)对途，可以不用使用def定義一個函數(shù)，使用匿名函數(shù)即可
函數(shù)調(diào)用:類似于filter髓棋、map等函數(shù)里面实檀，可以使用匿名函數(shù)來處理
提高開發(fā)效率:匿名函數(shù)的合理利用能夠讓那個代碼更加簡潔

3.函數(shù)作用域

思考

在函數(shù)里面也有可以定義變量惶洲，那函數(shù)里面的變量名如果和函數(shù)外面的變量名重名，會相互影響嗎膳犹？

示 例：

外部不能訪問函數(shù)內(nèi)部變量：
    def   fun1():
        x = 1
        return x
    
函數(shù)內(nèi)部能夠訪問函數(shù)外部變量:
    x = 123
    def  fun2():
        print(x)
        return x + 1
    
函數(shù)里面不能修改函數(shù)外部變量:
    x = 123
    def  fun3():
        x = x + 1
        return x
    
函數(shù)里面和函數(shù)外部變量名相同：
    x = 123
    print(x, id(x))
    def  fun4():
        x = 456
        print(x, id(x))
        x += 1
        return x

global 和 nonlocal

global：
    x = 123
    def   fun1():
        global x
        x += 1
        return x

nonlocal:
    def  fun2():
        x = 123
        def fun3():
            nonlocal x
            x += 1
            return  x
        return fun3()

函數(shù)作用域

函數(shù)內(nèi)部:函數(shù)內(nèi)部的變量恬吕，作用域只在函數(shù)內(nèi)部,函數(shù)內(nèi)部不可以直接更改函數(shù)外部的變量
global:函數(shù)內(nèi)部如果需要改變?nèi)肿兞浚托枰褂胓lobal修飾變量
nonlocal:在函數(shù)嵌套函數(shù)的情況下须床，同樣也有函數(shù)作用域的問題铐料，但是python3中提供了方便，只需要使用nonlocal就可以在里層函數(shù)內(nèi)部修改外部函數(shù)變量

4.遞歸函數(shù)

思考

函數(shù)里面可以自身調(diào)用自身嗎豺旬？

遞 歸

遞歸演示(階乘)：
    def factorial(n):    
        if n == 1:        
            return 1    
        return factorial(n-1)*n
        
遞歸中可以函數(shù)自身調(diào)用自身钠惩，但是使用時類似于條
件循環(huán)一樣，要有遞歸的終止條件

遞歸應(yīng)用

使用遞歸時族阅，常陈耍可以讓代碼更加簡潔

遞歸會占用比較多的內(nèi)存，當(dāng)遞歸次數(shù)比較多時坦刀，性能就會降低举塔，
因此不建議多使用遞歸

5.閉包

思考

函數(shù)里面可以再定義函數(shù)，那函數(shù)里面定義的函數(shù)可以在外面調(diào)用嗎求泰？
如果可以的話，要怎么做呢计盒？

閉 包

內(nèi)嵌函數(shù)：
    def fun1():    
        print('fun1()在被調(diào)用')    
        def fun2():        
            print('fun2()在被調(diào)用')
        fun2()

閉包：
    def fx(x):    
        x += 1    
        def fy(y):        
            return x*y    
        return fy

閉包是函數(shù)里面嵌套函數(shù)渴频，外層函數(shù)返回里層函數(shù)，這種情況稱之為閉包
閉包是概念北启，不是某種函數(shù)類型卜朗，和遞歸的概念類似，就是種特殊的函數(shù)調(diào)用
閉包可以得到外層函數(shù)的局部變量咕村，是函數(shù)內(nèi)部和函數(shù)外部溝通的橋梁

九场钉、類定義、屬性懈涛、初始化逛万、析構(gòu)

本節(jié)知識點

01. 類定義
02. 方法
03. 初始化和析構(gòu)

1.類定義

思考

之前我們在數(shù)據(jù)類型里面學(xué)習(xí)到了列表的方法，那是怎么做的可以讓列表里面放下這么多方法呢批钠？

類 是一個獨立存放變量(屬性/方法)的空間

運算符“.”
    — 用于進行變量空間的運算

類的定義：
     class 類名：
     pass  
     
Person類
    var 變量

查找變量var -> 實例 p ->轉(zhuǎn)到類中查找-> 實例中找不到-> 

1.類的定義

類的定義：
     class 類名：
     pass       

創(chuàng)建實例:
    實例名 = 類名（）      

“類”與“實例”之間的關(guān)系

是一類事物的抽象宇植，不是真是存在的。
描繪了該類事物的共性埋心，
例如：“人類”指郁、“貓類”、“狗類”

某類事物的具體個體拷呆，是該類事物的具體表現(xiàn)闲坎，它是真實存在的疫粥。
例如：“炎志”是具體的某個“人”
            ''小明''是某個具體的’人’ 

           “加菲貓”是具體的某個“貓”
            ''湯姆貓'' 是某個具體的’貓‘

一個“實例”的“特征”，就是“屬性”

class Persion(object):
    pass

p1 = Persion()
p2 = Persion()

p1.name = '小明'
p1.age = 20

p2.name = '大華'
p2.age = 23

類屬性和實例屬性

類屬性：在類里面定義的屬性腰懂，可以通過類和實例訪問
    class Persion(object):
        attr = '人'
    
實例屬性：通過實例定義的屬性梗逮，只能通過實例訪問
    P1 = Persion()
    P1.name = '名字'

類的私有屬性

在python中有兩私有屬性，分別是在屬性前加  一個下?lián)Q線(_) 和 兩個下劃線(__)
    _x: 意義在于喚起用戶的注意悯恍，看成私有屬性,類對象和子類可以訪問
    __xx：雙前置下劃線,避免與子類中的屬性命名沖突库糠，無法在外部直接訪問(名字重整所以訪問不到)

私有屬性：
       在 Python 中， _  和  __  的使用 更多的是一種規(guī)范/約定涮毫，沒有真正限制的目的

類

定義:類的定義使用關(guān)鍵字 class 
封裝:類可以把各種對象組織在一起瞬欧，作為類的屬性，通過 .  (點)運算符來調(diào)用類中封裝好的對象
屬性:變量在類中稱為屬性罢防，但是類中的屬性不僅僅只包含變量艘虎，函數(shù)等其他的對象也可以作為類的屬性

2.方法

思考

類里面除了放屬性之后，還可以放些什么呢咒吐？
可以不可以在類里面定義函數(shù)呢野建？

“方法”就是封裝在類里的一種特殊的函數(shù)

class Hero(object):
    def move(self):
        print('ok!')

“實例方法” 的調(diào)用過程與 self

通常，將默認(rèn)會傳入的那個參數(shù)命名為self恬叹，用來表示調(diào)用這個方法的實例對象本身候生。
方法總是定義在類中的，但是卻叫“實例方法”绽昼，因為它表示該類所有實例所共有的行為

方法

類方法:類中的方法唯鸭，就是函數(shù)
self:  代表的是實例本身
調(diào)用:方法的調(diào)用和屬性調(diào)用一樣，通過點操作符調(diào)用硅确，傳參和函數(shù)傳參一樣

3.初始化和析構(gòu)

思 考

在剛才目溉，實例化之后才添加 實例屬性，那有沒有辦法在實例化的時候就添加實例屬性呢菱农？

“初始化”特殊方法

在Python中有很多以雙下劃線開頭且以雙下劃線結(jié)尾的固定方法缭付。
他們會在特定的時機被觸發(fā)執(zhí)行。
__init__ 就是其中之一循未，它會在實例化之后自動被調(diào)用陷猫。以完成實例的初始化。

init 的參數(shù)傳遞過程

實例化
    產(chǎn)生一個類的實例
    
Python自動調(diào)用
    實例.__init__(參數(shù))
    
轉(zhuǎn)換為
    類.__init__(實例,參數(shù))

“析構(gòu)”問題引入

剛才討論了在實例化的時候的妖，可以做一些操作烙丛，那么當(dāng)實例被銷毀的時候，是否也可以做些什么呢羔味？

通常在實例被銷毀的時候河咽，會執(zhí)行怎樣的任務(wù) ？
    __del__”就是一個析構(gòu)函數(shù)了赋元，當(dāng)使用del 刪除對象時忘蟹，會調(diào)用他本身的析構(gòu)函數(shù)飒房。
    提示開發(fā)者，對象被銷毀了媚值，方便調(diào)試狠毯。
    進行以寫必要的清理工作。

基于變量計數(shù)的對象銷毀機制

當(dāng)沒有一個變量指向某個對象的時候褥芒，Python會自動銷毀這個對象嚼松，以便回收內(nèi)存空間。

del 關(guān)鍵字锰扶，可以刪除一個變量的指向献酗。

十、繼承坷牛、多繼承罕偎、魔術(shù)方法

本節(jié)知識點

01.繼承   02. 多繼承     03. 魔術(shù)方法

1.繼承

思 考

剛剛的作業(yè)我們定義一個矩形類，有長京闰、寬的屬性颜及，和計算面積的方法，那么現(xiàn)在我要定義一個正方形的類蹂楣，也有長 寬兩個屬性（正方形的長寬是不是一樣的）俏站，和計算面積的方法，那么這個類我們應(yīng)該怎么定義呢痊土？

class Rectangle:  # 矩形類

    def __init__(self,length,width):
        self.length = length            
        self.width  = width  

    def area(self):        
        areas = self.length * self.width        
        return areas

class Square:  # 正方形類

    def __init__(self,length,width):
        self.length = length            
        self.width  = width  

    def area(self):        
        areas = self.length * self.width        
        return areas

繼承 問題引入

問題一: 兩個中有大量重復(fù)的代碼肄扎，是否能夠只寫一次?   抽象出一個更抽象的類，放公共代碼
問題二： 繼承的意義是什么?                       重用代碼施戴，方便代碼的管理和修改
問題三： 繼承是復(fù)制變量空間嗎?                    只是引用，不會復(fù)制

從矩形類中派生正方形類(派生和繼承是一個意思)

class Rectangle:  # 矩形類

    def __init__(self,length,width):
        self.length = length            
        self.width  = width  

    def area(self):        
        areas = self.length * self.width        
        return areas

class Square(Rectangle):  # 正方形類

    pass

繼承搜索

如果找不到,轉(zhuǎn)到其父類中查找
如果再找不到,轉(zhuǎn)到其父類的父類中查找
訪問類的屬性或方法,不是變量空間的復(fù)制 萌丈！

思 考

正方形類繼承矩形類之后赞哗，要求正方類在實例化的時候就判斷是否滿足正方形鄰邊相等的要求呢？

重用父類的 init

class Square(Rectangle):  # 正方形類

    def __init__(self, length, width):
        if length == width：
            super().__init__(length, width)
            Rectangle.__init__(self, length, width)

這個 self 是正方形類的實例,不是矩形類的實例

調(diào)用父類 重寫方法

當(dāng)子類重寫父類方法之后辆雾，子類如果想再次調(diào)用父類的方法肪笋，可以使用這兩種方法
方式一：
    父類名.方法名（self）

方式二：
    super().方法名()
    
注意：用類名調(diào)用的時候，( )里面要寫self

頂級基類 object

Python 2.x中默認(rèn)都是經(jīng)典類度迂，只有顯式繼承了object才是新式類
Python 3.x中默認(rèn)都是新式類藤乙，寫不寫object都一樣，都繼承object

bases 特殊屬性

__base__  ：查看繼承的父類
__bases__：查看繼承的全部父類

思考：為什么返回的是一個元祖 惭墓？

2.多繼承

思考

剛才講到了繼承坛梁，一個類可以繼承一個類，繼承之后可以使用父類的方法和屬性腊凶，那一個類可以繼承多個類嗎触菜？
如果可以繼承多個類的話，那如果兩個父類中有一樣的方法的情況下您没，子類繼承哪一個呢寝姿？

多繼承

通過C類實例的方法調(diào)用來看

當(dāng)繼承多個父類時，如果父類中有相同的方法扒吁，
那么子類會優(yōu)先使用最先被繼承的方法

在上面的例子中，如果不想繼承父類的方法怎么辦呢？
重寫父類方法之后公般，如果又需要使用父類的方法呢？

多繼承 調(diào)用父類重寫方法

當(dāng)子類重寫父類方法之后胡桨，子類如果想再次調(diào)用父類的方法官帘，可以使用這兩種方法

使用 super調(diào)用父類重名方法，可以通過類的__mro__屬性來查看多繼承的情況下登失，子類調(diào)用父類方法時遏佣，在父類中的搜索順序

多繼承

在python3中，類被創(chuàng)建時會自動創(chuàng)建屬性 __mro__   解析順序

object是所有類的父類

基于多繼承的 Mix-in 設(shè)計模式

最好揽浙，多繼承就一層状婶，且是最后一層
注意：一般，“Mix-in類”是繼承的終點 馅巷！

多繼承

mro():類在生成時會自動生成方法解析順序膛虫，可以通過  類名.mro()來查看
super():可以來調(diào)用父類的方法，使用super的好處在于即使父類改變了钓猬，那么也不需要更改類中的代碼
Mixin:是一種開發(fā)模式稍刀，給大家在今后的開發(fā)中提供一種思路

3.魔術(shù)方法

思考

在講字符串拼接的時候，字符串可以直接相加敞曹，那我們自定義的類可以實現(xiàn)嗎账月？

魔術(shù)方法

__add__   :當(dāng)類的實例之間使用+號時，會自動調(diào)用__add__這個魔法方法

運算符方法(解一下即可澳迫，在實際中應(yīng)用并不多):
    __add__(self,other) # x+y
    __sub__(self,other) # x-y
    __mul__(self,other) # x*y
    __mod__(self,other) # x%y
    __iadd__(self,other)    # x+=y
    __isub__(self,other)    # x-=y
    __radd__(self,other)    # y+x
    __rsub__(self,other)    # y-x
    __imul__(self,other)    # x*=y
    __imod__(self,other)    # x%=y

字符串表示 問題引入

 在交互模式下輸出的交互信息與直接print的信息有些不同局齿，背后的原理是 ？
 我們該如何使用這種機制  橄登？

str 和 repr

__str__ 和 __repr__

調(diào)用str函數(shù)來處理實例對象抓歼，如果對象沒有定義__str__方法，則調(diào)用__repr__方法
調(diào)用repr函數(shù)來處理實例對象拢锹，則調(diào)用__repr__處理谣妻，

str和repr原理

在python中，__repr__和__str__這兩個方法都是用于顯示的卒稳，__str__是面向用戶的蹋半，而__repr__面向程序員。
使用內(nèi)置函數(shù)str和repr方法在處理對象的時候充坑，分別調(diào)用的是對象的__str__ 和__repr__方法
調(diào)用str函數(shù)來處理輸出的對象湃窍，如果對象沒有定義__str__方法闻蛀，則調(diào)用__repr__方法
調(diào)用repr函數(shù)來處理輸出的對象，則調(diào)用__repr__處理您市，
使用print操作  會首先嘗試 調(diào)用__str__方法 ,如果__str__方法沒有定義觉痛，則調(diào)用__repr__方法
在交互模式下，輸入對象  顯示對象 __repr__ 方法的返回值

類的實例可以向函數(shù)一樣被調(diào)用嗎茵休？

__call__方法:
    正常情況下薪棒，實例是不能像函數(shù)一樣被調(diào)用的，要想實例能夠被調(diào)用榕莺，就需要定義 __call__  方法

類中的一些查詢相關(guān)信息的方法 (了解既可)

1俐芯、__class__ 查看類名        
    格式：  實例.__class__
   
2、__dict__  查看全部屬性钉鸯，返回屬性和屬性值鍵值對形式
    格式：實例.__dict__

3吧史、__doc__   查看對象文檔，即類中(用三個引號引起來的部分)
    格式：類名.__dict__

4唠雕、__bases__       查看父類
    格式：類名.__base__

5.__mro__        查看多繼承的情況下贸营，子類調(diào)用父類方法時，搜索順序
    格式：子類名.__mro__
    實例.__class__.__mro__

魔術(shù)方法應(yīng)用場景

__str__和__repr__:str和repr都是分別調(diào)用這兩個魔術(shù)方法來實現(xiàn)的
原理:在類中岩睁，很多事情其實調(diào)用的魔術(shù)方法來實現(xiàn)的
作用:通過合理的利用魔術(shù)方法钞脂，可以讓我們更加方便的展示我們的數(shù)據(jù)

十一、描述器 與 裝飾器

本節(jié)知識點

01. __new__方法和單例模式
02. 定制屬性訪問
03. 描述符
04. 裝飾器

1.new__方法和單例模式

問題思考：

__new__方法什么時候會被調(diào)用捕儒，它能做什么冰啃？
類每次實例化的時候都會創(chuàng)建一個新的對象，如果要求類只能被實例化一次該怎么做呢刘莹？
什么是單例模式阎毅？

new方法

四個點理解__new__方法

1、__new__方法是在 類 創(chuàng)建實例 的時候自動調(diào)用的点弯。
2扇调、實例是通過類里面的__new__方法是在 類 創(chuàng)建出來的。
3蒲拉、先調(diào)用__new__方法創(chuàng)建實例肃拜，再調(diào)用 __init__方法初始化實例痴腌。
4雌团、__new__方法，,后面括號里的cls代表的是類本身

創(chuàng)建實例的時候士聪，自動調(diào)用了__new__,方法和__init__方法锦援，并且是先調(diào)用的__new__再調(diào)用的__init__方法，打印 cls 的時候顯示的這個 類

單列模式

定義一個私有屬性__instance等于None

然后我們判斷它是不是等于None剥悟，如果等于None灵寺，我們調(diào)用父類的方法創(chuàng)建一個實例對象曼库，并把返回的對象賦值給 __instance，并且返回__instance
 
如果__instance不等于None略板，那就說明已經(jīng)創(chuàng)建了對象我們直接把__instance返回出去毁枯。

單例模式實現(xiàn)的原理：
通過重寫__new__方法，讓__new__只能進行一次實例創(chuàng)建叮称。

兩個實例的ID是相同的,意味著第二次創(chuàng)建的時候种玛，并沒有真正的去創(chuàng)建，而是引用的第一次創(chuàng)的實例瓤檐，同一個實例的不同名字

new方法

初始化函數(shù)之前:__new__方法會在初始化函數(shù) __init__  之前執(zhí)行
單例模式:利用這個 __new__ 可以很方便的實現(xiàn)類的單例模式
合理利用:__new__  方法合理利用可以帶來方便赂韵，常應(yīng)用在類的單例模式

2.定制屬性訪問

思 考

如何判斷一個實例里面有某個屬性呢？
怎樣刪除實例屬性呢挠蛉？
同樣的怎樣刪除變量呢祭示？

定制屬性訪問

1、查：
    hasattr(re, 'length')   # 返回bool值
    getattr(re,  'length')  # 返回屬性值
    b. __getattribute__('length') # 返回屬性值
    
2谴古、增：
    b.aaa = 1
    setattr(b, 'bbb', 2)
    b.__setattr__('ccc', 3)
    
3质涛、改：
    setattr(b, 'length', 6)
    b.__setattr__('length', 5)
    
3、刪：
    delattr(b, 'ccc')
    b.__delattr__('bbb')
    del b

getattr / hasattr / setattr / delattr

getattr(object, ’name’[, default])    ->    object.name

hasattr(object, ’name’)               ->
    def hasattr(object, name_string):
    try:
        getattr(object, name_string)
        return True
    except AttributeError:
        return False
        
setattr(object, ’name’, value)       ->    object.name = value
delattr(object, ’name’)              ->    del object.name

定制屬性訪問

re = Rectangle(3, 4)   # 矩形類實例

def __getattr__(self, item):
    print('no attribute')
    
當(dāng)屬性不存在時讥电，如果定義了此方法蹂窖，則調(diào)用方法

定制屬性訪問

b.length
b.__getattribute__('length')

屬性值存在:返回屬性值
屬性值不存在:調(diào)用__getattr__未定義時報錯

定制屬性訪問

hasattr:判斷是否存在屬性，如果屬性存在則進行下一步操作
getattr:得到屬性值
setattr:設(shè)置屬性

3.描述符

思 考

如果在一個類中實例化另一個類恩敌，對這個屬性進行訪問的時候怎么做的瞬测？

描述符

描述符協(xié)議：python描述符是一個“綁定行為”的對象屬性，在描述符協(xié)議中纠炮，它可以通過方法重寫屬性的訪問月趟。這些方法有:
    __get__(), __set__(), 和__delete__()。

如果這些方法中的任何一個被定義在一個對象中恢口，這個對象就是一個描述符

魔術(shù)方法

描述符大家了解即可
魔術(shù)方法的作用其實是讓開發(fā)人員能夠更加靈活的控制類的表現(xiàn)形式

4.裝飾器

思 考

之前我們講了閉包孝宗，閉包中可以傳入一個函數(shù)嗎？

裝飾器

能夠?qū)崿F(xiàn)在不修改原來的函數(shù)的基礎(chǔ)上添加功能耕肩。

def fun(func):
    def inner():
        print("== 裝飾器 ==")
        func()
    return inner

@fun # fun 的功能其實就是相當(dāng)于 fu = fun(fu()) 這一句代碼
def fu():
    print("基礎(chǔ)功能代碼")

func()

內(nèi)置裝飾器

python的類里面中還有三個內(nèi)置的裝飾器：

    @property：
    作用是將類里面的一個方法變成屬性

    @classmethod：標(biāo)識類方法的

    @staticmethod  ：靜態(tài)方法

類裝飾器

class Test_Class:  
    def __init__(self, func):      
        self.func = func
        
    def __call__(self): 
        print('類')      
        return self.func    
        
    @Test_Class?def fun_test(): 
        print('這是個測試函數(shù)')
    
類也可以做裝飾器因妇，但是需要定義 __call__ 方法

裝飾器參考

查看函數(shù)運行時間：

import time 

def run_time(func):   
    def new_fun(*args,**kwargs):  
        t0 = time.time()      
        print('star time: %s'%(time.strftime('%x',time.localtime())) )   
        back = func(*args,**kwargs)?       
        print('end time: %s'%(time.strftime('%x',time.localtime())) ) 
        print('run time: %s'%(time.time() - t0))
        return back  
    return new_fun

裝飾器

修飾函數(shù):修飾函數(shù)
增加功能:給函數(shù)增加功能
內(nèi)置裝飾器:三個內(nèi)置裝飾器是需要掌握的，在項目中會經(jīng)常使用

十二猿诸、文件

本節(jié)知識點

01. 內(nèi)置裝飾器
02. 文件基本操作
03. 上下文管理
04. IO流
05. 使用工具

1.內(nèi)置裝飾器

python的類里面中還有三個內(nèi)置的裝飾器：

    @property：
    作用是將類里面的一個方法變成屬性

    @classmethod：標(biāo)識類方法的

    @staticmethod  ：靜態(tài)方法

2.文件基本操作

思考

我們的程序都是運行在內(nèi)存中的婚被，內(nèi)存是不可持久化存儲的，那怎樣才能持久存儲呢梳虽？

文件

1址芯、打開文件：
    path = 'test.txt'
    path = r'/home/pyvip/py_case/test.txt'
    file = open(path, 'w+')

2、寫入：
    file.write('Python')
    file.flush()
    file.writelines([1, 2, 3])

3、讀取與關(guān)閉：
    file.read()
    file.readline()
    file.readlines()
    file.close()

4谷炸、查看與移動文件指針：
    file.tell()
    file.seek(0)

文件打開的模式:

其他模式：rb   rb+     wb     wb+    ab    ab+ 

加個b的作用：以二進制的格式打開文件举瑰，進行上述操作 捣辆。

文件

持久存儲:保存內(nèi)存中數(shù)據(jù)都是易丟失的，只有保存在硬盤中才能持久的存儲此迅，保存在硬盤中的基本方法就是把數(shù)據(jù)寫入文件中
打開與關(guān)閉:在python中文件的打開與關(guān)閉變得十分簡單快捷汽畴，文件在關(guān)閉的時候就會自動保存
寫入與讀取:文件的寫入和讀取是必須要十分熟練的內(nèi)容

3.上下文管理

思考

文件能夠自動關(guān)閉嗎？

whith

with open(path, 'r') as f:
    print(f.read())
    
with能夠自動關(guān)閉文件耸序，不需要執(zhí)行close方法

上下文管理

with:使用with打開文件忍些，則文件不需要自己關(guān)閉，會自動的關(guān)閉
__enter__:進入時需要執(zhí)行的代碼坎怪，相當(dāng)于準(zhǔn)備工作
__exit__:退出時需要執(zhí)行的代碼罢坝，相當(dāng)于收尾工作

4.IO流

思考

文件可以持久存儲，但是現(xiàn)在類似于臨時的一些文件搅窿，不需要持久存儲嘁酿，如一些臨時的二維碼等，這個不需要持久存儲男应，但是卻需要短時間內(nèi)大量讀取闹司，這是時候還是只能保存在文件里面嗎？

StringIO

1殉了、創(chuàng)建IO操作：
import io
    sio = io.StringIO()
    
2开仰、寫入：
    sio.write(str(i))
    
3拟枚、讀刃酵：
    sio .getvalue()
    StringIO在內(nèi)存中如同打開文件一樣操作字符串众弓，因此也有文件的很多方法

當(dāng)創(chuàng)建的StringIO調(diào)用 close() 方法時，在內(nèi)存中的數(shù)據(jù)會被丟失 

BytesIO

創(chuàng)建BytesIO：
    import io
    bio = io.BytesIO()

寫入：
    bio.write(b'abcd')

讀雀艄俊：
    sio .getvalue()

BytesIO 和 StringIO 類似谓娃，但是BytesIO操作的是 Bytes數(shù)據(jù)

5.使用工具

思考

文件可以直接新建，但是現(xiàn)在如果需要創(chuàng)建文件夾和移動文件夾怎么辦呢蜒滩？

os 操作系統(tǒng)交互

os 模塊提供python和操作系統(tǒng)交互的接口

直接調(diào)用系統(tǒng)命令
    os.system('ls')
    
通用路徑操作：
    os.path
    os.path.join(r'/home/pyvip', r'pycase')
    
文件目錄操作：
    os.mkdir('test')
    os.rename('test', 'test1')
    ...
os 提供了Python和操作系統(tǒng)交互方式滨达，只要是和操作系統(tǒng)相關(guān)，就可以嘗試在os模塊中找方法

shutil 高級文件操作

shutil 模塊提供了許多關(guān)于文件和文件集合的高級操作

移動文件
    shutil.move()

復(fù)制文件夾
    shutil.copytree()

刪除文件夾
    shutil.rmtree()

十三俯艰、異常

本節(jié)知識點

01. 異常
02. 異常處理
03. 斷言

1.異常

思考

什么是異常捡遍？ python中有哪些異常？
如何通過程序的報錯來找到有問題的代碼竹握？

Python的異常結(jié)構(gòu)（基于繼承）

在 Python 中所有的異常都是繼承自 BaseException

直接分為四大類：
    SystemExit：Python退出異常
    KeyboardInterrupt： 鍵盤打斷（Ctrl+C）
    GeneratorExit： 生成器退出（下次課再講）
    Exception： 普通異常（只會使用這部分的異常）

做一個會提問的人

在今后的學(xué)習(xí)和工作過程中画株，會遇到大量的報錯，每個開發(fā)人員都必須掌握查找和解決報錯的能力

在自己無法解決需要尋求幫助時啦辐，也要掌握如何描述問題谓传，把問題描述清楚的能力，掌握如何提問的技巧芹关，這會大大節(jié)省雙方的時間和精力

2.異常處理

本節(jié)思考

問題一：異常通常會帶來怎樣的問題 续挟？程序停止了
問題二： 我們?nèi)绾文芊乐惯@個問題， 從而利用異常 侥衬？
問題三： 具體的該怎么做 诗祸？

異常處理 try … except …

try:
    print("== 可能出現(xiàn)錯誤的代碼區(qū) ==")
except:
    print("== 出現(xiàn)錯誤的代碼區(qū) ==")

注意:
    try 后面必須跟上 excep

捕獲具體的異常

except 后面可以寫上捕獲具體的異常類型  
還可以通過as 把捕獲的異常信息 儲存到后面的變量里面

關(guān)于 Exception 及其 子類 的解釋

代碼中會出現(xiàn)的異常都是 Exception 的子類， 因此在 except 中只需要在最后加上 Exception 即可
在捕獲異常的過程中轴总，會從上倒下依次對比異常贬媒，找到之后就不會再往后查找

更加豐富的結(jié)構(gòu)

注意事項：
    1. try       下面放可能出錯的代碼 
    2. except  try下面的代碼出錯后，會執(zhí)行except下面的代碼
    3. else      try下面代碼沒有錯誤,執(zhí)行else下面的代碼
    4. finally 不管try下面的代碼有沒有出錯肘习，始終都會執(zhí)行

擴展（自定義異常類型）

raise   主動拋出異常
格式：raise 異常類型

注意：raise  是主動拋出后面寫的異常類型

異常

try:將可能會發(fā)生異常的代碼放在try中际乘，就可以得到異常，并做相應(yīng)處理
except: 用來接受異常漂佩，并且可以拋出或者返回異常
else和finally: 
    else:在沒有異常的時候會執(zhí)行
    finally:不管是否有異常脖含，都會執(zhí)行

3.斷言

本節(jié)思考

問題一： 如何能在代碼中強制要求一個條件滿足 ？
問題二： 是否有專門的語法來完成 投蝉？

斷言 assert

1养葵、 assert 1 == 1
`   assert 1 == 2

2、 斷言語句是將調(diào)試斷言插入程序的一種便捷方式

    assert 的語法規(guī)則是：
        表達式返回 True  不報錯
        表達式返回 False  報錯  報 AssertionError

十四瘩缆、迭代器 與 生成器关拒， 模塊與包

本節(jié)知識點

01. 推導(dǎo)表達式
02.生成器
03.迭代器
04. 模塊
05. 包和包管理

1.推導(dǎo)表達式

思考

得到一個元素為1到10的列表，可以怎么做？

列表推導(dǎo)

循環(huán)添加：
    li = []?for i in range(1,11): 
        li.append(i)
    
列表推導(dǎo)：
    li = [i for i in range(1, 11)]

列表推導(dǎo)+條件判斷：
    l2 = [i for i in range(1, 11) if i % 2 == 0]
    
列表推導(dǎo)+三目運算：
    l3 = [i if i % 2 == 0 else 0 for i in range(1, 11)]

集合和字典推導(dǎo)

集合推導(dǎo)：
    {i for i in range(1,10)}

字典推導(dǎo)：
    {i: j for i, j in enumerate(li)}

推導(dǎo)表達式

推導(dǎo)表達式相對于for循環(huán)來處理數(shù)據(jù)着绊，要更加的方便
列表推導(dǎo)表達式使用更加的廣泛

2.生成器

思考

把推導(dǎo)式放在小括號（）里面返回的谐算，是一個generator對象，這個是什么归露？

創(chuàng)建生成器的兩個方法

方法 一：列表推導(dǎo)式的 [ ] 改成  ( )
    b = ( x for x in rang(10) )
    next(b)
    
方法 二：在函數(shù)里面加上yield
    def fun(num):
        a = 0
        while a<num:
            yield a
            a += 1
    ge = fun(10)
    next(ge)
    
    
注意:
    生成器不會一下子把所以內(nèi)容生成出來洲脂，在我們需要的時候用next（）去生成

yield運行規(guī)則

yield 一個對象 
規(guī)則:
    1.返回這個對象 2.暫停這個函數(shù)  3.等待下次next()重新激活運行

注意：
    yield 表達式只能在函數(shù)中使用,在函數(shù)體中使用 yield 表達式可以使函數(shù)成為一個生成器
    yield 可以返回表達式結(jié)果，并且暫定函數(shù)執(zhí)行,直到next激活下一個yield

Python使用生成器對延遲操作提供了支持剧包。所謂延遲操作恐锦，是指在需要的時候才產(chǎn)生結(jié)果，而不是立即產(chǎn)生結(jié)果,從而節(jié)省大量的空間,這也是生成器的主要好處

3.迭代器

可迭代對象與迭代器

思考一： 迭代是一個怎樣的過程 疆液？
    就是一個依次從數(shù)據(jù)結(jié)構(gòu)中拿出東西的過程  =>  Iterator
思考二： 能否用更加低級的while來實現(xiàn) 一铅？
    可以的，但是堕油，需要自己控制下標(biāo)并獲取對應(yīng)的元素
思考三： 可迭代對象與迭代器的區(qū)別 馅闽？

區(qū)分 可迭代對象 和 迭代器

from collections import Iterable ,Iterator

可迭代對象: Iterable     
可迭代對象能用for循環(huán)進行遍歷
可以使用 isinstance() 判斷一個對象是否是 Iterable 對象：
迭代器： Iterator    

迭代器不僅可以通過for進一行遍歷，可以通過next取值
可以使用 isinstance() 判斷個對象是否是 Iterator ：

迭代

for 迭代變量 in 可迭代對象
每一次循環(huán)都會自動讓"迭代變量"指向"下一個元素"

the_list = [1,2,3,4,5]
for index in the_list:
    print(index)

for 實現(xiàn)原理

the_list = [1,2,3,4,5]
itr = iter(the_list)
try:
    while True:
        var = next(itr)
        print(var)
except StopIteration:
    pass

從可迭代對象生成一個迭代器

iter(可迭代對象)
next(迭代器)

迭代器

迭代器對象本身需要支持以下兩種方法馍迄，它們一起構(gòu)成迭代器協(xié)議：
    iterator.__iter__()
    iterator.__next__()

取值：
    next(iterator)
    iterator.__next__()
    注意：如果迭代器值取完之后福也，會返回 StopIteration 錯誤
    
擴展提示：通過定義__iter__和__next__方法，以自定義迭代器

4.模塊

本節(jié)思考

思考一：什么是模塊 攀圈？ 
    模塊就是一個python文件
思考二：為什么需要導(dǎo)入別的模塊 暴凑？
    在開發(fā)中，我們可以分配不同的程序員赘来，不同部分的工作现喳，最后通過導(dǎo)入，將所有人的成果結(jié)合在一起
思考三：導(dǎo)入的過程大致是怎樣的 犬辰？
    import  -->  執(zhí)行導(dǎo)入的文件 -->  在當(dāng)前這個文件里生成一個模塊對象

模塊

模塊：在python中嗦篱，模塊就是一個py文件，可以使用下面兩種方法導(dǎo)入

import datetime
from datetime import datetime  (as this_datetime)

注意：datetiame是一個常用的時間處理模塊


1.在同一目錄下幌缝，可直接使用上面兩種方法去導(dǎo)入
2.在不同目錄下灸促，需要使用  sys.path  添加路徑
    sys.path.append('path')

在python3中導(dǎo)入后，會在當(dāng)前路徑下生成一個 __pycache__  文件夾

導(dǎo)入語法 與 導(dǎo)入路徑

import 模塊名
直接導(dǎo)入,使用時模塊名.函數(shù)名()

import 模塊名 as 新名字
導(dǎo)入以后涵卵，重新命名使用 新名字.函數(shù)名（）

from 模塊名 import 函數(shù)名
部分導(dǎo)入浴栽，導(dǎo)入模塊內(nèi)部的東西，而不要模塊可以在模塊里用一個變量 __all__控制被導(dǎo)入函數(shù)

sys.path
用于存放導(dǎo)入路徑的列表,類似于環(huán)境變量中的 PATH

if name == 'main':

__name__:
    python會自動的給模塊加上這個屬性,如果模塊是被直接調(diào)用的轿偎，則 __name__ 的值是 __main__,否則就是該模塊的模塊名 

if __name__ == '__main__':
    該語句可以控制代碼在被其他模塊導(dǎo)入時不被執(zhí)行

5.包和包管理

本節(jié)思考

思考一：什么是包 典鸡？包，就是包含了很多模塊的文件夾
思考二：如何構(gòu)造一個包 坏晦？首先需要把py文件放入包中萝玷，并且加一個__init__.py文件
思考三：加入包的概念后嫁乘，導(dǎo)入規(guī)則是否有變化 ？

通過包球碉，我們加入了層級導(dǎo)入

包和包管理

包概念：
    把很多模塊放到一個文件夾里面蜓斧，就可以形成一個包

包管理：
    當(dāng)把很多模塊放在文件中時，為了方便引用包中的模塊汁尺，引入了包管理

__init__.py:
    在包管理中，加入此模塊多律，則包名可以直接通過屬性訪問的方式痴突，訪問此模塊內(nèi)的對象，文件內(nèi)容可以為空

相對路徑導(dǎo)入:
    在包管理中狼荞，可以通過 . (一個點) 和 .. (兩個點)分別來導(dǎo)入同層和上一層的模塊

相對路徑導(dǎo)入

引入作用:
    在包中辽装，如果包中模塊要導(dǎo)入同一包中的其他模塊，就必須使用此方法導(dǎo)入
使用方法：
    from  .module(..module)  import obj   (as  new_name)
引入之后的影響:
    當(dāng)一個模塊中出現(xiàn)此導(dǎo)入方式相味，則該模塊不能被直接運行拾积，只能被導(dǎo)入

十五、正則表達式

本節(jié)知識點

 一丰涉、正則表達式的概念
 二拓巧、re模塊
 三、元字符

一一死、正則表達式的概念

正則表達式概念問題引入

問題一： 什么是正則表達式 肛度？
問題二： 正則表達式主要解決什么問題 ？

正則表達式所面向的問題

1投慈、判斷一個字符串是否匹配給定的格式(判斷用戶注冊帳號是否滿足格式)
2.從一個字符串中按指定格式提取信息(抓取頁面中的鏈接)
3.判斷用戶提交的郵箱的格式是否正確

二承耿、re模塊

在Python中需要通過正則表達式對字符串進行匹配的時候，可以使用一個模塊來操作伪煤，名字為re

import re

1加袋、findall()方法：在字符串中找到正則表達式所匹配的所有子串，并返回一個列表抱既，如果沒有找到匹配的职烧，則返回空列表

import re
s = 'python123'
ss = re.findall('python',s)
print(ss)

2、match()方法
re.match() 嘗試從字符串的起始位置匹配一個模式防泵，匹配成功 返回的是一個匹配對象（這個對象包含了我們匹配的信息）阳堕，如果不是起始位置匹配成功的話，match()返回的是空择克，

import re
s = 'python123'
ss = re.match('python',s)
print(  ss.group() )

注意：
    match()只能匹配到一個
    1.可以通過group()提取匹配到的內(nèi)容
    2.可以通過span()提取匹配到的字符下標(biāo)

2恬总、search()方法
re.search() 掃描整個字符串,匹配成功 返回的是一個匹配對象（這個對象包含了我們匹配的信息）

import re
s = 'python123'
ss = re.search('python',s)
print(ss)

注意：
search()也只能匹配到一個，找到符合規(guī)則的就返回肚邢，不會一直往后找
re.match與re.search的區(qū)別：
    re.match只匹配字符串的開始壹堰，如果字符串開始不符合正則表達式拭卿，則匹配失敗，
    re.search：匹配整個字符串贱纠，如果一直找不到則報錯

三峻厚、元字符

問題引入

問題一： 什么是元字符 ？(本身具有特殊含義的字符)
問題二： 常用元字符有哪些 谆焊？
問題三： 怎樣才能匹配這些字符本身 惠桃？

單字符匹配

代表數(shù)量的元字符

表示邊界的元字符

分組匹配

貪婪與非貪婪

正則默認(rèn)都是用貪婪模式去匹配數(shù)據(jù)的莲兢，就是盡可能多的匹配符合要求的數(shù)據(jù)汹来，在非貪婪模式下，始終找最短匹配

s = '<html> 123<h2>abc</h2> </html>'
re.findall(r'<.*>',a) # 貪婪
#結(jié)果: [ '<html> 123<h2>abc</h2> </html>' ]

s = '<html> 123<h2>abc</h2> </html>'
re.findall(r'<.*?>',a)  # 加上 ? 非貪婪
#結(jié)果: [ '<html>',<h2>'','</h2>','</html>' ]