一裳凸、快捷鍵

1. ctr+b 執(zhí)行
2. ctr+/ 單行注釋
3. ctr+c 拷貝
4. ctr+v 粘貼
5. ctr+z 撤銷
6. ctr+shift+z 反撤銷
7. ctr+a 全選
8. ctr+x 剪切

二岖免、注釋

注釋：注釋是穿插在代碼中的說明文字长赞，對于代碼實現(xiàn)功能無任何作用，注釋也不會參與執(zhí)行犁钟。

1公般、單行注釋

• 在注釋的內(nèi)容前加#

2忍啸、多行注釋

• a、 在每一行前面加 #
• b蘸嘶、使用'''和"""括起來
  '''
  這是多行注釋1
  這是多行注釋2
  '''
  """
  這是多行注釋1
  這是多行注釋2
  """

三良瞧、標識符

標識符：在開發(fā)中使用的所有名字都是標識符（包括變量名、函數(shù)名训唱、類名褥蚯、對象名等）

• 標識符的硬性要求：

  1. 由字母、數(shù)字况增、下劃線（_）組成赞庶。
  2. 數(shù)字不能開頭。
  3. 不能是保留字（關鍵字）澳骤。
     a2_=1
     abc=1
     ac2=2
     a+b=3 # 報語法錯誤
     2s=3 # 報語法錯誤
     for=2 # 報語法錯誤

• 規(guī)范：

  1. 見名知意歧强。
  2. PEP 8規(guī)范（變量名）:全部小寫，如果名字是由多個單詞組成为肮，單詞之間以_分開摊册。

    cat_name=1
  

• 駝峰式命名：如果是由多個單詞組成，第一個單詞首字母小寫颊艳。后面的每個單詞第一個字母大寫茅特。

    catName=1
  

• python中大小寫敏感：Key和key是不一樣的

四、關鍵字（保留字）

• 在python中有自己獨特功能的一些單詞棋枕，程序員在使用標識符的時候不能使用關鍵字白修。

  import keyword  #導入內(nèi)置keyword模塊
   print(keyword.kwlist)
   ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for','from', 'global', 'if', 'import', 'in', 'is', 'lambda','nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
  

五、行與縮進

• 在python中重斑，語法對縮進有嚴格的規(guī)范兵睛。同一級的代碼要寫在一個縮進下（縮進->空格和制表符tab）。

• 行：可以通過換行將代碼分塊窥浪。要求函數(shù)定義和其他代碼之間要有一個換行卤恳。類的聲明和其他代碼之間要有兩個換行。（不按要求來不會報錯）

     abc=1  #abc前多了一個空格寒矿，報IndentationError（縮進錯誤）
     if 10>20:
     abc=1
  

• 注意:語法相關的所有的符號突琳，都必須是英文輸入法下的符號

六、多行語句

• 一行代碼很長符相，需要多行顯示拆融。

• python中蠢琳，如果一行只有一個語句，那么語句后面可以不寫分號镜豹。（寫了也不會報錯）

• 如果一行中有多條語句傲须，那么語句中需要用（;）分開。

    aaa=1  ; abc=2
    bbb=2
    ccc=3
    sum1=aaa+bbb+ccc
  

• 將一行代碼寫成多行

    sum2=aaa+\
    bbb+\
    ccc
  

• 列表趟脂、字典泰讽、元祖、集合的元素在多行顯示的時候昔期，可以不用\連接

    dict1={
    'name':'yuting',
    'age':18,
    'gender':'女'
    }
  

七已卸、數(shù)據(jù)類型

• python中標準的數(shù)據(jù)類型有6種：Number(數(shù)字)、Str(字符串)硼一、List（列表）累澡、Tuples（元祖）、Setes（集合）般贼、Dict（字典）

• 可以通過type（）函數(shù)查看值得類型愧哟，例如：

    print(type(10))
    print(type(12.5))
    print(type(True))
    print(type(10+2j))
  

1、數(shù)字

python中的數(shù)字分為：整型（整數(shù)）哼蛆、浮點型(小數(shù))蕊梧、布爾、復數(shù)（實部+虛部）

a腮介、整型（int）:python3中只有長整型int,python2中有l(wèi)ong望几。

    例如：23、100萤厅、-25

b、浮點型(float):python3中只有float類型靴迫。

    例如：12.9惕味、1.0、0.0玉锌、-10.5名挥、2e2

c、布爾(bool):表示真假（是否）的值主守，值只有True（真）和False（假）兩個值禀倔，True是1，F(xiàn)alse是0参淫。
d救湖、復數(shù)(complex):由實部和虛部組成。

    例如：10+1j涎才，11.5+2j

2鞋既、字符串

• 由單引號或者雙引號括起來的數(shù)據(jù)就是字符串（推薦使用單引號）（python中沒有字符類型力九，所說的字符就是用引號括起來的長度是1的字符串）

    'hello world'    # 字符串中單獨的一個符號就是一個字符串
    '123'
    '!2dfs'
    ' '  #這些都是字符串，空格字符是有意義的字符串
    ''   #空串邑闺，長度是0
  

• python需要轉(zhuǎn)義字符來表示一些特殊的字符串：包括一些有特殊意義和特殊功能的字符串

    '\''
    print('\'')  #'
    print('\\')  #\
    str1='\t床前明月光,\n疑是地上霜'  # \n -->換行  \t -->制表符tab
    print(str1)
  

• 在字符串前面加r/R,阻止轉(zhuǎn)義字符轉(zhuǎn)義

    print('a\\nb')
    print(r'a\nb')
    print(R'a\nb')
  

八跌前、進制轉(zhuǎn)換

• 進制：十進制、二進制陡舅、八進制抵乓、十六進制（要求：會認識和轉(zhuǎn)換）

• 其他進制轉(zhuǎn)換成十進制：相乘求和

• 十進制轉(zhuǎn)換成其他進制：整除取余法

    100(2)->1100100  100(8)->144  100(16)->64
  

• 二進制和八進制（每三位二進制轉(zhuǎn)換成一位八進制）、十六進制（每四位二進制轉(zhuǎn)換成以為16進制）的轉(zhuǎn)換靶衍。

    (2)1100100->(8)144   001 100 100->1 4 4
    (8)571->(2)101111001  (2)a1b->(2)101000011011
  

1灾炭、十進制

• 基數(shù)：0、1摊灭、2咆贬、3、4帚呼、5掏缎、6、7煤杀、8眷蜈、9

• 逢十進一

    123:100+20+3  1*10^2+2*10^1+3*10^0
    12 #直接寫數(shù)字，就是十進制
    print(12)
    print(0o654)
  

2沈自、二進制

• 計算機存儲數(shù)據(jù)的時候酌儒，存的都是二進制數(shù)

• 基數(shù)：0、1

• 逢二進一（10-->2）

• 二進制轉(zhuǎn)十進制（相乘求和）：每一位上的數(shù)乘以當前位上的2的冪次數(shù)（從低位到高位枯途，冪次數(shù)從0開始一次加1）

    1101：1*2^0+0*2^1+1*2^2+1*2^3=13
    0b1101 #在二進制數(shù)前加“0b”
    print(0b1101)
    bin(10)  #將括號中的數(shù)字轉(zhuǎn)換成二進制數(shù)忌怎，返回的是字符串形式的數(shù)據(jù)
  
    print(bin(10))
    print(bin(0o64))
    print(bin(0xa3))      
  

3、八進制

• 基數(shù)：0 1 2 3 4 5 6 7

    26:6*8^0+2*8^1=22
    0o10  #在八進制數(shù)前加“0o”
    print(0o10)
    oct(10) #將括號中的數(shù)據(jù)轉(zhuǎn)換成8進制
    print(oct(10))
    print(oct(0b11100110))
    print(oct(0xab3))
  

4酪夷、十六進制

• 基數(shù)：0 1 2 3 4 5 6 7 8 9 a(10) b(11) c(12) d(13) e(14) f(15) (A B C D E F)

    1f: 15*16^0+1*16^1=31
    ab: 11*16^0+10*16^1=171
    0xa1 #在十六進制數(shù)前加"0x"
    print(0xa1)
    hex(100) #將括號里面的數(shù)據(jù)轉(zhuǎn)換成十六進制
    print(hex(100))
    print(hex(0o654))
  

九榴啸、變量

• 變量是用來存儲數(shù)據(jù)的。
• 在python中聲明變量不用指定類型晚岭，一個變量可以存儲任何類型的數(shù)據(jù)鸥印。

1.聲明變量

• 變量名=初值

  a、變量名：a坦报、標識符 b库说、PEP 8的命名方式 c、見名知意
  b片择、=：賦值符號潜的，要求賦值符號的左邊必須是變量，右邊是有值的表達式;

    a=10+20
    10=20  #語法錯誤（SyntaxError）
  

  c字管、初值：python中聲明變量必須賦值
  name='liuzhilong' #聲明一個變量夏块，并且賦了初值為'liuzhilong'
  a=b=c=10 #同時聲明三個變量a b c 疏咐，他們的初值都是10
  a1,b1,c1=10,12.4,'aaa' #同時聲明了三個變量a1,b1,c1;他們分別對應的初值分別是10,12.4，'aaa'
  name=100 #一個變量可以存儲多種類型的值（python是動態(tài)語言）

十脐供、運算符

• python中的運算符：算數(shù)運算符浑塞、比較運算符、賦值運算符政己、邏輯運算符

1酌壕、算數(shù)運算符

• 算數(shù)運算符： +(加) —(減) *(乘) /(除) %(取余) //(整除) **(冪運算)

• +-*/%和數(shù)學里面的運算一模一樣

    print(12+10.0)    #22.0
    print(12+10)   #22
    print(50-33)   #17
    print(10*3)   #30
    print(7/2)   #3.5
    print(10%3)   #1
  

• //(整除)：可以對浮點數(shù)做整除的操作，只是結(jié)果只保留整數(shù)的部分(直接去掉小數(shù)部分)

    print(10.0//3)   #3.0
    print(16/10)   #1.6
    print(16//10.0)  #1.0
  

• **（冪運算）

    print(2**3)   #計算2的3次方
  

• 對任意數(shù)取各個位數(shù)的值

    n=7896
    print('百位數(shù)：',n%1000//100)
    print('百位數(shù)：',n//100%10)
    print('十位數(shù)：',n%100//10)
    print('十位數(shù)：',n//10%10)
    print('個位數(shù)：',n%10)
  

• 通過import關鍵字可以導入python中內(nèi)置的模塊歇由。

• math是python內(nèi)置的一個提供數(shù)學運算的模塊卵牍。

    import math
    1、fabs(n):求n的絕對值
    num=math.fabs(-20)
    print(num)   # 20.0
    2沦泌、pi:圓周率
    print(math.pi)  # 3.141592653589793
    3糊昙、log：返回x的自然對數(shù)，默認以e為基數(shù)谢谦。
    print(math.log(30))  # 3.4011973816621555
    4释牺、log10:返回x的以10為底的對數(shù)
    print(math,log10(60))  #1.7781512503836436
    5、log2:返回x的基2對數(shù)
    print(math.log2(8))  # 3.0
    6回挽、tan:返回x(x為弧度)的正切值
    print(math.tan(10))   # 0.6483608274590866
    7没咙、floor:取小于等于x的最大的整數(shù)值寒瓦，如果x是一個整數(shù)间唉，則返回自身
    print(math.floor(34.6))  # 34
    8硬霍、gcd:返回x和y的最大公約數(shù)
    print(math.gcd(24,80))  # 8
    9寒屯、trunc:返回x的整數(shù)部分
    print(math.trunc(31.34))  # 31
    10、sqrt:求x的平方根
    print(math.sqrt(16))  # 4.0
  

2.比較運算符：>洛心、<儿奶、>=宝与、<=喜滨、==捉捅、!=

• 所有比較運算符的結(jié)果都是布爾值

• x>y:比較x是否大于y.如果是,結(jié)果就是True,否則就是False.

    print(10>5)     # True
    print(6<19)     # False
  

• 比較字符串大小的時候，不是比較兩個字符串的長度鸿市；而是從兩個字符串的第一個字符開始比較。如果第一個字符串的第一個字符大于第二個字符串的第一個字符即碗，結(jié)果就是True焰情，否則就是False。如果兩個字符串的第一個字符相等采取比較第二個字符剥懒，依次類推内舟。

    print('abcdef'>'bcd')  # False 
    print('abc'>'abcd')    # False
  

• x>=y:比較x是否大于或者等于y.x大于y或者等于y，結(jié)果都是True;否則就是False.

    print(10>=5)          # True
    print(10>=10)         # True
    print('abc'>='abc')   # True
  

• x<=y:比較x是否小于或者等于y.x小于y或者等于y初橘，結(jié)果都是True;否則就是False.

    print(10<=5)    # False
    print(10<=10)   # True
  

• x==y:比較x是否等于y.如果是验游，結(jié)果就是True,否則就是False.

    print(6==3)  # False
    print(5==5)  # True
    a=8
    b=3
    print(a==8)  # True
    print(a==3)  # False
    print(a==b)  # False
  

• x!=y:比較x是否不等于y.如果是充岛，結(jié)果就是True,否則就是False.

    print(a!=8)   # False
    print(a!=b)   # True
  

3、賦值運算符：=耕蝉、+=崔梗、-=、=垒在、/=蒜魄、%=、//=场躯、*=

• 所有的賦值運算符左邊都必須是變量谈为，右邊是表達式。

• 表達式(本身有值的語句)： 10踢关，a伞鲫，10+a，10>20,10+20/4*3等

    a=10
    b=a  # 如果a的值是基本數(shù)據(jù)類型（數(shù)字签舞、字符串）秕脓，直接將a里面存的值賦給b;如果值是對象，傳遞的是變量中存儲的地址瘪菌。
    a+10=10  # 語法錯誤（SyntaxError）
  

  a撒会、=

    num=a+30
  

  b、+=师妙、-=诵肛、=、//=默穴、*=

    a+10
    print(a)   # a=10
    a+=10      # a=a+10
    print(a)   # a=20
    a-=10      # a=a-10
    print(a)   # a=10
    a*=2       # a=a*2
    print(a)   # a=20
    a/=4       # a=a/4
    print(a)   # a=5.0
    a//=2      #a=a//2
    print(a)   # a=2.0
    a**=5      # a=a**5
    print(a)   # a=32.0
    a%=10      # a=a%10
    print(a)   # a=2.0
  

4怔檩、邏輯運算符：and（與）,or（或）,not（非）

• 邏輯運算符中表達的值都是布爾值

• 給變量賦值的時候，后面賦的值會覆蓋前面的蓄诽。

• 運算表達式中薛训，加（）可以改變運算的順序

  a、表達式1 and 表達式2：兩個表達式的值都是True仑氛，結(jié)果才是True;否則是False.

    print(True and True)     # True
    print(False and True)    # False
    print(True and False)    # False
    print(False and False)   # False
    例：
    age=40
    face=90
    進網(wǎng)吧要求:年齡大于18并且小于50乙埃，顏值還不能低于80.
    result=age>18 and age<50 and face>90
    print(result)           # True
  

  b、表達式1 or 表達式2：兩個表達式的值都為False時锯岖，結(jié)果為False介袜，否則都是True。

    print(True or True)     # True
    print(False or True)    # True
    print(True or False)    # True
    print(False or False)   # False
    例：
    grade=8.0
    score=80
    獎學金要求：績點大于8.0出吹，或者操評大于90
    result=grade>8.0 or score>90
    print(result)           # False
    獎學金要求：1遇伞、績點大于9.7  2、績點8.5-9.7捶牢，操評分大于85
    result=grade>9.7 or (8.5<=grade<=9.7 and score>85)
    print(result)           # False
  

  c鸠珠、not 表達式：如果表達式的值為True巍耗，結(jié)果為False;表達式的值為False，結(jié)果為True渐排。

    print(not True)                             # False
    print(not False)                            # True
    成績及格要求：績點不小于6炬太。
  
    grade=8.0
    result=not grade<6
    print(result)                                  # True
    進入游樂場的年齡要求：不大于12歲并且不小于2歲
  
    age=10
    result=(not age>12) and (not age<2)
    print(result)                                  #True
  

十一、運算優(yōu)先級

• 賦值運算符<邏輯運算符<比較運算符<加飞盆、減<乘娄琉、除、取余吓歇、整除孽水、冪運算<+（正號）、-（負號）
• 可以加括號改變運算的運算順序（遇到括號先算括號里的）

十二城看、字符串

• 字符串：有單引號或者雙引號括起來的文本

    'acds'
    '234'
    '---=334ff'
    '我是@ss'
  

1女气、Python中的字符串都是Unicode字符串

• Unicode編碼：是一種對字符的編碼方式（將字符編碼成對應的數(shù)字，方便計算機存儲）

• Unicode編碼又叫萬國碼测柠，支持目前幾乎所有的語言文字編碼

• Unicode包含ASCII碼

• 字符串比較大小的時候炼鞠，實質(zhì)就是比較字符的Unicode編碼的大小

• 數(shù)據(jù)存儲到計算機中是以2進制的形式存的

    將Unicode碼轉(zhuǎn)換成字符
    print(chr(0x4E00))   # 一
    將字符轉(zhuǎn)換成Unicode碼（結(jié)果是十進制的形式）
    print(ord('劉'))     #21016
    print(chr(21016))    #劉
  

2、字符串的長度

• 字符串的長度：指字符串中字符的個數(shù)（空格也算）

    'abc'  #長度為3
    ' yu'  #長度為3
  

• len（字符串）：獲取字符串的長度

    str1='你好轰胁，Python'
    length=len（str1）
    print(length)     #長度為9
    print('str')      #長度為3
  

3谒主、獲取字符/子串

a、獲取某一個字符

• 格式：字符串變量[下標]

• 下標：從0開始的數(shù)字赃阀，代表的是某一個字符在字符串中的偏移量（位置）(范圍：0~字符串長度-1)

• 注意：下標不要越界霎肯，否則會報錯（IndexError: string index out of range）

    str1='Hello,Python!'
    print(str1[0])    # H 獲取第0個字符 
    print(str1[5])    # , 獲取第5個字符 
    print(str1[20])   # 報錯（IndexError: string index out of range）
  

• 下標也可以是負數(shù)（負數(shù)也不可以越界）

    print(str1[-1])   # ！ 獲取倒數(shù)第一個字符（最后一個） 
    print(str1[-2])   # o 獲取倒數(shù)第二個字符  
    print(str1[len(str1)-1])   # n 獲取最后一個字符
  

b榛斯、獲取字符串中某一部分的字母（獲取子串）

• 格式：字符串變量[開始下標:結(jié)束下標] -->獲取從開始下標到結(jié)束下標前的所有字符

• 注意：開始下標對應的字符可以取到观游，結(jié)束下標對應的字符取不到

    str1='Hello,Python!'
    print(str1[1:4])   # ell  獲取從下標是1對應的字符開始，到下標是（4-1）對應的所有字符 
  
    print(str1[6:10])  # Pyth  獲取從下標是6對應的字符開始驮俗，到下標是9對應的所有字符
  

• 開始下標不寫懂缕，默認就是0

    print(str1[:5])    # Hello 獲取從開始到下標是4為止的所有的字符
  

• 結(jié)束下標不寫，就會取到最后一個字符

    print(str1[-4:])   # hon王凑！
    print(str1[:])     # Hello,Python! 取所有的字符
  

• 如果結(jié)束下標在開始下標的前面搪柑，就會取不到字符（不能倒著取）

    print(str1[5:1])  # 取不到字符
  

4索烹、字符串的運算符

• 字符串的運算符：+ , * , in , not in

  a工碾、+:字符串中的+操作，就是字符串連接

    str2='aaa'+'bcd'
    print(str2)  # aaabcd
    str1='hello'
    str2='world'
    str3=str1+' '+str2
    print(str3)   # hello world
    str2+='!'
    print(str2)  # world!
  

  b术荤、 * : 字符串中的 * 操作倚喂，就是字符串重復多少次

    str1='abc'*3
    print(str1)  #abcabcabc
  

  c每篷、字符串1 in 字符串2：判斷字符串2中是否包含字符串1

    str1='Hello'
    print('he' in str1)  # False  判斷he是否在str1中（判斷str1中是否包含'he'）
    print('He' in str1)  # True
  

  d瓣戚、字符串1 not in 字符串2：判斷字符串1是否不在字符串2中

    print('He' not in str1)  # False
  

十三端圈、print函數(shù)

• print()函數(shù)可以打印括號中的任何內(nèi)容

• 調(diào)用print函數(shù)打印完后會換行

    print(10)   # 10
    str1='aaa'
    print(str1)   # aaa
  

• 同時打印多個內(nèi)容（多個內(nèi)容間用逗號隔開）;打印的時候，多個內(nèi)容之間是用一個空格隔開子库。

    print('aa',100,str1)  # aa 100 aaa
  

  1舱权、格式化輸出

• print('%s %d'% (變量1，變量2))：輸出字符串的時候仑嗅，在字符串中使用字符串格式符表示變化的內(nèi)容宴倍。在%后面的括號里面，一次使用表達式給前面的字符串格式符賦值仓技。

• %s:字符串 %d:整數(shù) %f:浮點數(shù) %c:字符 %o:八進制數(shù)

     name='張三'
     age=18
     我是xxx鸵贬，今年xx歲
     print('我是%s,今年%d歲'%(name,age))  # 我是張三，今年18歲
  

  a脖捻、%f：浮點數(shù)占位符

     print('余額：%f萬元'%(10.25))  # 余額：10.250000萬元
  

  b阔逼、%.2f:保留小數(shù)點后兩位 %.3f:保留小數(shù)點后三位

     print('余額：%.2f萬元'%(10.25)) # 余額：10.25萬元
  

  c、%c：字符占位符（python中的字符地沮，指得是長度為1的字符串）

     print('%c'%('a'))     # a
     print('%c'%('abc'))   # 報錯
     print('%c'%(97))      # a（a對應的Unicode碼是97）
     print('%c'%(0x4e00))  # 一（一對應的Unicode碼是0x4e00）
  

  d嗜浮、%o：八進制數(shù)占位符

     print('%o'%(10))      # 12
  

  e、%x/%X:十六進制數(shù)占位符（x的大小寫決定打印出的十六進制數(shù)是大寫還是小寫）

     print('%x,%X'%(15,15))  # f  F
  

  2.設置print函數(shù)的sep參數(shù)摩疑，可以改變print函數(shù)在同時打印多個內(nèi)容時的分隔符（默認是空格）

• 注意：加號兩邊只能都是數(shù)字或者都是字符串危融，不能一個數(shù)字一個字符串

     name='張三'
     age=18
     我是xxx，今年xx歲
     print('我是',name,',今年',age,'歲')  # 我是 張三 ,今年 18 歲（打印多個數(shù)據(jù)時雷袋，數(shù)據(jù)之間默認以空格隔開）
     print('我是',name,',今年',age,'歲',sep='')  # 我是張三，今年18歲(打印多個數(shù)據(jù)時片排，數(shù)據(jù)之間沒有間隙)
     print('aa',100,str1,sep=',')  # aa,100,aaa（打印多個數(shù)據(jù)時寨腔，數(shù)據(jù)之間以','隔開）
  

  3.設置print的結(jié)束字符串，默認是'\n'（換行）率寡。

• 注意：設置sep和end參數(shù)迫卢，只是當次有效

     print('hello',end=' ')
     print('world')  # hello world(設置以空格結(jié)束，而不是換行)
     
     print('hello',end=' ')
     print('world')      
     print('aaa')    # hello world
                       aaa
  

十四冶共、字符串的內(nèi)置函數(shù)

• 單詞的區(qū)分乾蛤，和英語區(qū)分單詞的方式是一樣的（以空格）

  1、capitalize():將字符串中的第一個字符轉(zhuǎn)化為大寫（不會改變原來的字符串捅僵，而是返回一個新的字符串）

    str1='hello student'
    print(str1,str1.capitalize())  # python student Python student 
  

  2家卖、title():將字符串中每個單詞的首字母變成大寫（不會改變原來的字符串，而是返回一個新的字符串）

    newstr=str1.title()
    print(str1,newstr) # python student Python Student
  

  3庙楚、center(width,fillchar):將字符串變成指定的長度上荡，并且原字符串內(nèi)容居中，剩余的位置使用指定的字符fillchar填充。

    str1='abc'
    newstr=str1.center(5,'*')
    print(str1,newstr)   # abc *abc*
  

  4酪捡、upper()：全部大寫

    name='liuzhilong'
    print(name.upper())  #LIUZHILONG
  

  5叁征、lower():全部小寫

    name1='LIUZHILONG'
    print(name1.lower())  # liuzhilong
  

  6、swapcase():大小寫互換

    name2='LiuZhilong'
    print(name2.swapcase()) # lIUzHILONG
  

  7逛薇、ljust(width捺疼，fillchar):獲取固定長度，右邊不夠用指定的fillchar填充

    name='liuzhilong'
    print(name.ljust(16,'*'))  # liuzhilong******
  

  8永罚、find('t'):搜索指定字符串中特定字符的個數(shù)

    zifu='adfggtg'
    print(zifu.find('g'))  # 3
  

  9啤呼、strip（）：去掉字符串兩邊的空白字符，但是不會去除中間的

    name='\tliu'+'zhilong  \n'
    name3=name.strip()
    print(name3)
  

  10呢袱、lstrip（）：去掉字符串左邊的空白字符

    name='\tliu'+'zhilong  \n'
    name1=name.lstrip()
    print(name1)
  

  11官扣、rstrip（）：去掉字符串右邊的空白字符

    name='\tliu'+'zhilong  \n'
    name2=name.rstrip()
    print(name2)
  

十五、條件語句

• if elif else都是關鍵字羞福，需要能讀和寫（背）

• 基本格式：

    if 條件語句1：
      執(zhí)行語句塊1
    elif 條件語句2：
      執(zhí)行語句塊2
    else：
      執(zhí)行語句塊3
  

• 執(zhí)行過程：

  a.先判斷條件語句1是否為True醇锚，如果為True就執(zhí)行冒號后邊的執(zhí)行語句塊1，整個條件結(jié)構(gòu)就執(zhí)行完了;如果是False坯临，就去判斷條件語句2是否為True焊唬。
  b.如果是True就執(zhí)行執(zhí)行語句塊2，再執(zhí)行其他語句;如果是False,就直接執(zhí)行語句塊3看靠，再執(zhí)行其他語句赶促。

• 注意：冒號后邊語句塊和冒號所在得語句要保持一個縮進。

1.if

• 判斷條件語句的值是否為True挟炬，如果為True鸥滨，就只執(zhí)行執(zhí)行語句塊。否則就直接執(zhí)行if語句后面的其他語句谤祖。

    if 條件語句：
        執(zhí)行語句塊
    
    age=20
    要求判斷年齡是否大于18婿滓，如果大于18就輸出'成年人'
    if age>18:
        print('成年人')
    
    練習：判斷一個數(shù)是否是偶數(shù)，如果是就打印'xxx是偶數(shù)'
    n=18
    if n%2==0:
        print('%d是偶數(shù)'%(n))
  

2.if-else

• 判斷條件語句是否為True粥喜，如果為True凸主，就執(zhí)行語句塊1;否則就執(zhí)行語句塊2.

    if 條件語句：
        執(zhí)行語句塊1
    else：
        執(zhí)行語句塊2
    n=17
    if n%2==0:
        print('%d是偶數(shù)'%(n))
    else:
        print('%d是奇數(shù)'%(n))
    練習：輸入一個數(shù)，如果這個數(shù)大于10额湘，就輸出他的2倍值卿吐。否  則輸出這個數(shù)的2次冪。
    input():從控制臺獲取鍵盤輸入的一個字符串锋华，以回車結(jié)束嗡官。
    
    inputvalue=input('請輸入一個數(shù)：')
    print(inputvalue)
    n=int(inputvalue)
    比較運算符和+以及*，在運算的時候毯焕，兩邊可以都是字符串衍腥，也可以都是數(shù)字，但是不可以一樣一個。
    if n>10:
    num=n*2
        print(num)
    else:
    num=n**2
        print(num)
  

3.if-elif-elif-else

• 總結(jié):

  a.如果要求中需要多個判斷婆咸，可以使用多個elif的if語句坊罢。
  b.一個if/elif/else語句中可以嵌套其他的if語句。

  （1）給一個成績擅耽，判斷成績是優(yōu)秀(90-100)、良好(80-89)物遇、        中等(60-79)乖仇、不及格(60以下)
  方法一：
  grade=96
  if grade>=90:
      if grade>100:
          print('成績有誤')
      else:
          print('優(yōu)秀')
  elif grade>=80:
      print('良好')
  elif grade>=60:
        print('中等')
  elif grade>=0:
        print('不及格')
  else:
        print('成績有誤')
  方法二：
  grade=67
  if 100>=grade>=90:
    print('優(yōu)秀')
  elif 90>grade>=80:
    print('良好')
  elif 80>grade>=60:
    print('中等')
  elif 60>grade>=0:
    print('不及格')
  else:
    print('成績有誤')
    
  （2）給個年齡，判斷年齡處于：嬰兒（0-1歲）询兴、兒童（2-4         歲）乃沙、少年（5-12歲）、青年（13-18歲）诗舰、成年（19-40）警儒、       中年（41-60）、老年（60以上）
  age=1
  if age<2:
    if age<=0:
        print('年齡輸入錯誤')
    else:
        print('嬰兒')
  elif age<5:
    print('兒童')
  elif age<13:
    print('少年')
  elif age<19:
    print('青年')
  elif age<41:
    print('成年')
  elif age<61:
    print('中年')
  else:
    print('老年')
  

• 說明：Python中沒有switch語法眶根。

• pass：占位蜀铲，防止因為沒有寫塊結(jié)構(gòu)而出現(xiàn)語法錯誤。

  if n==10:
      pass
  

十六属百、轉(zhuǎn)換函數(shù)

1.int()

• int():將其他的數(shù)據(jù)轉(zhuǎn)換成int類型的數(shù)據(jù)

  num=12.56
  print(int(num))    # 12 將浮點數(shù)轉(zhuǎn)換成整數(shù)（直接去掉小數(shù)部分）
  bool1=True
  print(int(bool1))  # 1 將布爾值轉(zhuǎn)換成整數(shù)记劝，True->1  False->0
  str1='123'
  print(int(str1))   # 123 只有純數(shù)字字符串或者純數(shù)字字符串前有正負號的字符串才能轉(zhuǎn)換成相應的整數(shù)。
  

2.flot()

• flot():將其他數(shù)據(jù)轉(zhuǎn)換成浮點型

3.bool()

• bool()：將其他的數(shù)據(jù)轉(zhuǎn)換成布爾值

• 數(shù)字轉(zhuǎn)換成布爾族扰，非0是True厌丑，0是False。

  print(bool(12))     # True
  print(bool(-12.3))  # True
  print(bool(0))      # False
  

• 字符串轉(zhuǎn)換成布爾猜绣，除了空串是False荧库，其他的都是True轩拨。

  print(bool('abc'))  # True
  print(bool(''))     # False
  

• 注意：在if或者while循環(huán)后的條件語句，可以不是結(jié)果為True/False的表達式耕驰，也可以是值是其他類型的表達式.判斷的是時候就看這個值轉(zhuǎn)換成bool后的結(jié)果是True還是False。

  if 10:
    print('aaa')   # aaa （10轉(zhuǎn)換成bool后是True) 
  if 0:
    print('aaa')   #  （0轉(zhuǎn)換成bool后是False）
  練習：判斷一個字符串是否是空串录豺，如果不是就直接打印這個字符       串耍属，否則打印“空串”
  
  方法1：
  str1=''
  if str1:
    print(str1)
  else:
    print('空串')
  方法2：
  str1='abc'
  if str1!='':
    print(str1)
  else:
    print('空串')
  

4.str()

• str()：將其他的數(shù)據(jù)轉(zhuǎn)換成字符串。所有的數(shù)據(jù)類型都可以轉(zhuǎn)換成字符串巩检。

十七厚骗、循環(huán)

• python中循環(huán)：for循環(huán)、while循環(huán)（一個操作需要重復執(zhí)行多次兢哭，這個時候就要考慮使用循環(huán)）

1领舰、for循環(huán)

• python中的for循環(huán)只有for-in循環(huán)：

  格式：
  for 變量名 in 列表：
    循環(huán)體
  

• 執(zhí)行過程：使用變量去依次獲取列表中的數(shù)據(jù)直到獲取完為止;沒獲取一個數(shù)據(jù)，執(zhí)行一次循環(huán)體。

• 循環(huán)次數(shù)：由列表中的數(shù)據(jù)的個數(shù)決定冲秽。

  去獲取字符串中的每一個字符
  str1='abcdef'
  for char in str1:
    print(char)
  
  去統(tǒng)計字符串中'a'出現(xiàn)的次數(shù)
  str1='avaadafvaavafaaa'
  n=0
  for char in str1:
    if char=='a':
        n=n+1       
  print(n)
  

• range（）函數(shù)：可以生成一個數(shù)值范圍

  打印1-100
  for n in range(1,101):
    print(n)
  用法1：range(n),生成0~n-1的值
  for x in range(9):
    print(x)
  
  用法2：range(m,n),生成m~n-1的數(shù)
  for n in range(5,9):
    print(n)
  打印0-100之間所有的偶數(shù)
  for x in range(101):
    if x%2==0:
        print(x)
  
  用法3：range(m,n,step):從m開始每step取一個數(shù)舍咖，取到n前       一個數(shù)為止。
  
  for x in range(1,8,2):
    print(x)   # 1,3,5,7 
  
  不通過字符串相乘锉桑，打印10次“=”,并且打印在同一行排霉。
  for _ in range(10):
    print('=',end=' ')
  求1+2+3...+100
  n=0
  for x in range(1,101):
    n=n+x
  print(n)
  

• 注意：如果循環(huán)中的變量取到的值沒有意義，循環(huán)只是單純的控制次數(shù)民轴，這個時候for后面的變量名一般用“_”代替攻柠。

2.while循環(huán)

 格式：
 while 條件語句：
    循環(huán)體

• 執(zhí)行過程：判斷條件語句結(jié)果是否為True，如果為True就執(zhí)行一次循環(huán)體后裸。執(zhí)行完循環(huán)體后再判斷條件語句是否為True瑰钮，如果為True繼續(xù)執(zhí)行循環(huán)體。重復這個過程微驶，直到條件語句結(jié)果為False

• for循環(huán)可以實現(xiàn)的操作浪谴，while循環(huán)都可以

  打印1-100
  方法1：
  x=0
  while x<100:
    x+=1
    print(x) 
  方法2：
  x=1
  while x<=100:
    print(x)
    x+=1
  
  計算1+2+3+...+100
  x=0
  n=0
  while n<100:
    n+=1
    x+=n
    print(x)
  
  求1-100中所有偶數(shù)的和
  方法1：
  n=0
  x=0
  while n<=100:
    if n%2==0:
        x=x+n
        n=n+1
    print(x)
  方法2：
  n=0
  x=0
  while n<100:
    n+=2
    x=x+n
  print(x)
  

十七、break和continue

1因苹、break

• break是一個讓循環(huán)提前結(jié)束的關鍵字

• 如果在for循環(huán)或者while循環(huán)中遇到了break苟耻，那么循環(huán)就在break的位置直接結(jié)束。結(jié)束后程序執(zhí)行循環(huán)后邊的代碼扶檐。

  練習:找到1000~9999中第一個能夠被13整除的數(shù)梁呈，打印出來
  for x in range(1000,10000):
    if x%13==0:
        print(x)
        break    
    
  for x in range(1,100):
    if x==50:
        break
        print(x)     # 1 2 3 ...  49
  

• 用while循環(huán)實現(xiàn)：不斷的讓用戶去輸入數(shù)字，直到用戶輸入的數(shù)字是0為止蘸秘。最后在打印之前輸入的數(shù)的和官卡。

• input()函數(shù)：程序執(zhí)行到input()函數(shù)的時候，程序就會停下來醋虏，等待用戶從鍵盤輸入并且以回車結(jié)束寻咒，然后才會往下執(zhí)行。

• 注意：break只能寫在循環(huán)中

    sum1=0
    while True:
    num=int(input(">>>"))   # 獲取鍵盤輸入的內(nèi)容颈嚼，并且轉(zhuǎn)換成int類型
        sum1+=num   # 將當次輸入的數(shù)字加起來
        if num==0:   #  判斷輸入的數(shù)字是否是0毛秘，如果是就讓循環(huán)結(jié)束
            break   
        print(num)
    print(sum1)
  

• for循環(huán)的特點：次數(shù)確定，可以在序列中取數(shù)據(jù)

• while循環(huán)：循環(huán)次數(shù)不確定的（while True + break）

• randint(m,n):產(chǎn)生一個m到n的隨機整數(shù)

• 產(chǎn)生隨機數(shù)：random模塊是python內(nèi)置用來產(chǎn)生隨機數(shù)的模塊阻课，里面提供了很多產(chǎn)生隨機數(shù)的函數(shù)叫挟。

    猜數(shù)字：隨機生成一個整數(shù)。用戶輸入數(shù)字限煞。如果用戶輸入的數(shù)字大于這個隨機數(shù)就提示：“大了”;如果用戶輸入的數(shù)小于隨機數(shù)就提示：“小了”抹恳。直到用戶輸入的數(shù)和這個隨機數(shù)大小一樣游戲結(jié)束。
    import random
    num=random.randint(0,100)   # 產(chǎn)生一個0到100的隨機數(shù)
    n=0
    while True:
    num1=int(input("請輸入你猜的數(shù)字："))
    n=n+1
    if num1>num:
        print('大了')
    elif num1<num:
        print('小了')
    else:
        print('恭喜你署驻，猜對了奋献！')       
        print('一共猜了：%d次'%(n),end='  ')
        if n<=5:
            print('你太棒了健霹，只猜了%d次就猜對了'%(n))
        else:
            print('下次加油！')
        break
  

2瓶蚂、continue

• continue:結(jié)束當次循環(huán)糖埋，進入下次循環(huán)

    for x in range(1,10):
        print('=')
        continue   # 遇到continue就不再執(zhí)行循環(huán)體后面的內(nèi)容，直接進入下一次循環(huán)的判斷
        print(x)
    
    求1~100中所有奇數(shù)的和
    sum=0
    for x in range(1,100):
        if x%2==0:
            continue
        sum=sum+x
    print(sum)
    
    打印100~999中十位數(shù)上不是3的所有數(shù)：
    for x in range(100,1000):
        if x//10%10==3:
            continue
        print(x)   
    
    統(tǒng)計輸入的數(shù)字中窃这，偶數(shù)的個數(shù)瞳别。如果輸入0，就結(jié)束杭攻。（必須使用continue）
    flag=True
    n=0
    while True:
        num=int(input('請輸入一個數(shù)：'))  # 輸入數(shù)據(jù)
        if num%2==1:  # 判斷是否是奇數(shù)
            continue
        if num==0:
            flag=False
        n=n+1
    print(n)
  

十八祟敛、else

• python中循環(huán)語句后面可以加else語句。這個else語句會在循環(huán)結(jié)束后執(zhí)行朴上。

   for 變量 in 序列：
    循環(huán)體
   else：
    循環(huán)結(jié)束后會執(zhí)行的語句塊
   
   1*2*3...*10
   sum1=1
   for x in range(1,11):
    sum1*=x
   else:
    print(sum1)
  

• 注意：如果再循環(huán)語句中使用break，那么else語句不會執(zhí)行卒煞。（continue不存在這個問題）

    1*2*3...*10痪宰，當乘積大于10000就不在執(zhí)行
    sum1=1
    for x in range(1,11):
        if sum1*x>10000:    
            break
        sum1*=x
    print(sum1)
    else:
        print(sum1)  # 如果在循環(huán)中執(zhí)行了break，那么else中的語句不會執(zhí)行
  

十九畔裕、多重循環(huán)

• 在循環(huán)體里面可以有其他的循環(huán)語句衣撬，結(jié)構(gòu)為：

   for 變量 in 序列：
       for 變量1 in 序列2：
        循環(huán)體2
    其它的循環(huán)語句
   
   for 變量 in 序列：
    其他的循環(huán)語句1
    while 條件語句：
        循環(huán)體2
    其他的循環(huán)語句2
   
   while 條件語句1：
    while 條件語句2：
        循環(huán)體2
    其他的循環(huán)語句2
  

• 例如：

    如果n=5 打印
    1
    12
    123
    1234
    12345
    
    n=5
    for x in range(1,n+1):   # 控制行數(shù)
        for b in range(1,x+1):  # 控制當前行的數(shù)值
            print(b,end='')
        print()   # 一行結(jié)束換行
    
    *****
    ****
    ***
    **
    *
    n=5
    for x in range(1,n+1):
        for b in range(x,n+1):
            print('*',end='')
        print()
    
    n=10
    for x in range(1,n+1):
        for b in range(x,n+1):
            print('*',end='')
        print()
  

二十、列表

• python 中的數(shù)據(jù)類型：數(shù)字（不可變）扮饶、字符串（不可變）具练、列表（可變）、元祖（不可變）甜无、字典（可變）扛点、集合（可變）
• 容器類型的數(shù)據(jù)：列表、元祖岂丘、字典陵究、集合（序列）
• 列表（數(shù)組）：一個列表中可以存儲多個不同類型的數(shù)據(jù)
• 列表存儲數(shù)據(jù)的方式：將多個數(shù)據(jù)放到一個[]中，多個數(shù)據(jù)之間用逗號隔開奥帘。
• 列表特點：列表是可變的（值得是里面的元素的個數(shù)和值可變）
• []是列表的標志
• 列表是有序的（可以通過下標去獲取元素）

1铜邮、聲明一個列表

聲明了一個列表list1,有5個元素，分別是：1,2,3,10.2寨蹋，'abc'松蒜。
list1=[1, 2, 3, 10.2, 'abc']
print(list1)
聲明一個空的列表：
list[]

2、獲取列表元素

a已旧、獲取某單個元素（通過元素對應的下標）

• 下標的范圍：0~元素的個數(shù)-1秸苗；

• 注意：列表通過下標獲取列表元素的時候，下表不能越界运褪。

    list1=[1, 2, 3, 10.2, 'abc']
    print(list1[0])   # 1 獲取下標是0的元素
    print(list1[3])   # 10.2 獲取下標是10.2的元素
    print(list1[-1])  # abc 獲取最后一個元素
    # print(list1[5]) # IndexError: list index out of range
  

b.獲取列表中的部分元素（切片）

• 列表名[開始下標：結(jié)束下標]:獲取到的是從開始下標到結(jié)束下標前的所有的元素組成的列表难述。

    list3=[2, 1, 4, 56, 'cv', 3, 2.2]
    print(list3[1:4])  # [1, 4, 56] 獲取下標為1開始到下標為3的所有的元素
    print(list3[:3])   # [2,1,4] 獲取從第一個元素開始到下標為2的所有的元素
    print(list3[3:])   # [56, 'cv', 3, 2.2] 獲取從第3個下標開始到最后的所有的元素
    print(list3[:])    # [2, 1, 4, 56, 'cv', 3, 2.2] 獲取列表從開始到結(jié)束的所有元素
  

• 列表名[開始下標：結(jié)束下標：步長]

    print(list3[:4:2]) # [2, 4] 從第一個元素開始到下標為3萤晴，每兩個元素取一個
    獲取列表中所有下標是偶數(shù)的元素
    print(list3[::2])  # [2, 4, 'cv', 2.2]
  

c.遍歷列表

    list4=[1, 22, 31, 2, 42, 24, 12]
    打印列表中所有的偶數(shù)
    for item in list4:
        if item%2==0:
            print(item)
    計算列表中所有元素的和：
    方法一：
    s=0
    for item in list4:
        s+=item
    print(s)
    方法二：
    n=0
    s=0
    while n<len(list4):
        s=s+list4[n]
        n+=1
    print(s)
    獲取下標為奇數(shù)的元素
    方法一：
    n=1
    for item in list4:
        while n%2!=0:
            print(item)
            break
        n+=1
    方法二：
    n=0
    while n<len(list4):
        if n%2!=0:
            print(list4[n])
        n+=1
    方法三：
    n=1
    while n <len(list4):
        print(list4[n])
        n+=2

3、在列表中添加元素

a胁后、append()方法：列表名.append(元素)

• append()是將元素添加到列表的最后

    list1=[1]
    list1.append('abc')
    print(list1) # [1, 'abc']
    練習：找出列表中[2,3,23,13,45,24,21,26]所有的偶數(shù),并且保存起來
    list2=[2,3,23,13,45,24,21,26]
    list3=[]
    for item in list2:
        if item%2==0:
            list3.append(item)
    print(list3)  # [2, 24, 26]
  

b店读、insert:列表名.insert(下標,元素)

• 在指定的下標前插入指定的元素

• 注意：這兒的下標可以越界

    list4=[1,2,3,4,5,6,7,8]
    list4.insert(3,9)
    print(list4)  # [1, 2, 3, 9, 4, 5, 6, 7, 8]
    通過insert在4和5之間插入元素'b',在8的后面插入元素'c'。
    list4.insert(5,'b')  # [1, 2, 3, 9, 4, 'b', 5, 6, 7, 8]
    list4.insert(10,'c') # [1, 2, 3, 9, 4, 'b', 5, 6, 7, 8, 'c']當下標大于等于列表的長度攀芯，會插入到列表的最后
    list4.insert(0,'d')  # ['d', 1, 2, 3, 9, 4, 'b', 5, 6, 7, 8, 'c']在列表的最前面插入一個元素
  

4屯断、修改列表中的元素

• 修改元素：通過下標拿到對應的元素，然后重新賦值

    list1=[1,2,3,4,5,6]
    list1[1]=20  # [1, 20, 3, 4, 5, 6] 將下標是1的元素變成20
    讓列表中的所有元素變?yōu)樵瓉淼?倍：
    方法一：
    for b in range(0,len(list1)):
        list1[b]*=2
    print(list1)
    方法二：
    n=0
    for item in list1:
        list1[n]=item*2
        n+=1
    print(list1)
    讓列表中偶數(shù)位上的元素變?yōu)樵瓉淼?倍:
    for n in range(0,len(list1):
        if n%3==0:
            list1[n]*=2
    print(list1)
  

5侣诺、刪除列表中的元素

a殖演、del語句：在python中，del可以刪除任何內(nèi)容

• del語句刪除列表元素：del列表名[下標]

    list1=['a', 'b', 1, 2, 'c', 10+20, True]
    del list1[3]  # 刪除下標為3的元素
  

• 注意：刪除的時候下標不能越界

    del list1[20]  # 報錯
  

• 通過下標刪除要注意下標的重新分配的問題

    刪除列表中所有的偶數(shù)元素:
    list1=[1,2,3,4,12,6]
    n=0
    while n<len(list1):
        if list1[n]%2==0:
            del list1[n]
        else:
            n+=1
    print(list1)
  

• isinstance(變量年鸳，類型)：判斷指定的變量/值是否是指定的類型

    re=isinstance('aa',str)  # 判斷'aa'是否是字符串
    print(re)    # True
  

• str(字符串)趴久、int（整型）、float（浮點型）搔确、bool（布爾）

    刪除列表中所有的字符串元素:
    list2=['a',3,'c','d',55,23]
    n=0
    while n<len(list2):
        if isinstance(list2[n],str):
            del list2[n]
        else:
            n+=1
    print(list2)
  

b彼棍、通過remove方法刪除指定元素

• 格式：列表名.remove(元素)

    list3 = [1, 'c', 23, 'c', 'aa', 424, 'ewd']
    list3.remove('aa') # 刪除列表中的'aa'
  

• 使用remove刪除元素的時候，如果指定的元素在列表中有多個膳算，只刪除第一個

    list3.remove('c') 
    print(list3)  # [1, 23, 'c', 424, 'ewd']
    刪除列表[1,3,4,7,8,2,3,4,1]中所有的奇數(shù):
    list4=[1,3,4,7,8,2,3,4,1]
    n=0
    while n<len(list4):
        if list4[n]%2!=0:
            list4.remove(list4[n])
        else:
            n+=1
    print(list4)
  

c座硕、使用pop()方法刪除指定下標的元素

• 格式1：列表名.pop(下標) 。從列表中取出指定下標對應的元素

• 格式2：列表名.pop() 從列表中取出最后一個元素

    list5=[1,2,24,5,5,6,'w','f']
    delitem=list5.pop(5) # 將下標是5的元素從list5中取出涕蜂，并且存到變量delitem中
    print(delitem,list5) # 6 [1, 2, 24, 5, 5, 'w', 'f']
    del_item =list5.pop()
    print(del_item,list5)  # f [1, 2, 24, 5, 5, 'w']
    將一個列表[1,2,3,4,5,6]中的元素全部取出放到另外一個列表里面變成[6,5,4,3,2,1]：
    list6=[1,2,3,4,5,6]
    list7=[]
    while len(list6)>0:
        x=list6.pop()
        list7.append(x)  # 從后往前取
        # list7.insert(0,list6.pop(0))  # 從前往后取
    print(list7)
  

6华匾、列表的操作

a、求列表的長度

    list1=[1,2,34,1,4,51]
    print(len(list1))  # 6

b机隙、列表的+操作

• 列表1 + 列表2：將列表1和列表2中的元素組合成一個新的列表

    list2=[1,2,3]+['a','b','c']
    print(list2)  # [1, 2, 3, 'a', 'b', 'c']
  

c蜘拉、列表的 * 操作

• 列表 * 整數(shù):將列表中的元素重復指定的次數(shù)，然后組合成一個新的列表

    list3=[10,4]*3
    print(list3)  # [10, 4, 10, 4, 10, 4]
  

d有鹿、元素 in 列表：判斷指定的元素是否在指定的列表中

    list4=['abc',33,'a',2,1]
    print('abc' in list4)  # True

e诸尽、元素 not in 列表：判斷指定的元素是否不在指定的列表中

    list5=['abc',33,'a',2,1,'asa']
    print('asa' not in list5)   # False

f、獲取列表中的最大的元素

• 格式：max（列表）

    list6=[2,5,6,3,8,242,34]
    print(max(list6))
    list7=['abc', 'b', 'c', 'd']
    print(max(list7))  # d
  

• 注意：獲取最大值或者最小值的時候印颤，列表中的元素類型要么都是數(shù)字您机，要么都是字符串

    list8=['abc',33,'a',2,1,'asa']
    print(max(list8))     # 報錯 TypeError: '>' not supported between instances of 'int' and 'str'
  

g、獲取列表中的最小元素

• 格式：min(列表)

• sum(列表)：計算列表中所有元素的和

    list6=[2,5,6,3,8,242,34]
    print(min(list6))   # 2
    練習：求表演的平均分數(shù)（5個裁判年局，給表演打分际看。去掉一個最高分和一個最低分，再求平均分）
    import random
    list1=[]
    for i in range(1,6):
        fenshu=random.randint(1,11)
        list1.appdend(fenshu)
    list1.remove(max(list1))
    list1.remove(min(list1))
    print(sum(list1)/len(list1)
  

h矢否、list將其他的數(shù)據(jù)轉(zhuǎn)換成列表

• 個數(shù)：list(數(shù)據(jù))

    list8=list('abdnvfmg')
    print(list8) # ['a', 'b', 'd', 'n', 'v', 'f', 'm', 'g']
  

• 將range()轉(zhuǎn)換成列表

    list2=list(range(10))
    print(list2)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  

• 將列表轉(zhuǎn)換成字符串（不僅僅是將列表中的元素拼接成字符串仲闽，而是將整個列表的所有結(jié)構(gòu)都作為字符串的字符）

    print(str(list2),len(str(list2)),str(list2)[2])   # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 30 ,
  

• 列表的值[a、c]僵朗，類型是對象

    person = [True,False,True]
    for index, person in enumerate(persons):
        print(f'{index}:{"基"if person else "非"}')  # 0：基  1:非   2：基
  

• 對象類型：列表赖欣、字典屑彻、集合、元素顶吮、通過類創(chuàng)建的對象

• 變量在存儲對象數(shù)據(jù)的時候社牲，存的對象保存在內(nèi)存中的地址。如果用存對象的變量給另外一個對象賦值悴了，賦的是地址搏恤。

• 如果變量里存的是對象，要注意賦值的時候湃交，如果不想要兩個變量互相影響熟空，就不要直接賦值，而是拷貝對象產(chǎn)生新的對象然后賦值搞莺。

    list1 = [1, 2, 3, 4]
    list2 = list1
    list2[0] = 10
    print(list2)   # [10, 2, 3, 4]
    print(list1)   # [10, 2, 3, 4]
    
    list1 = [1, 2, 3, 4]
    list2 = list1[:]
    list2[3]=10
    print(list1)  # [1, 2, 3, 4]
    print(list2)  # [1, 2, 3, 10]
  

二十一息罗、元組（tuple）

• 元組就是不可變的列表
• 列表中除了增加、修改和刪除相關的操作才沧，其他都適用于元組迈喉。
• 什么時候用？ 就是存儲到容器中的數(shù)據(jù)不能被修改的時候使用糜工。
• 例如：星期幾對應的值

1弊添、聲明元組

tuple1=(1, 2, 3, 4, 'aa', True)
print(tuple1)

2录淡、查

print(tuple1[0])
print(tuple1[-1])

print(tuple1[:3])

for item in tuple1:
    print(item)

for index in range(len(tuple1)):
    print(tuple1[index])

3捌木、 + ，*

print((1, 3, 5, 6)+('q', 'b', 'c'))
print((1, 2, 3)*3)

4嫉戚、in , not in

a=10
print(a in (1, 4, 10, 5))
print(a not in (2, 3, 10, 5))

tuple2 = (1, 3, 5, 2, 7)
tuple2[2] = 10   # 報錯（TypeError: 'tuple' object does not support item assignment）
del tuple2[1]    # 報錯（TypeError: 'tuple' object does not support item assignment）

練習刨裆，輸入1-7的數(shù)字，然后對應輸出是星期幾彬檀。例如：輸入1帆啃，就輸出“星期一”。
tuple3=('一', '二', '三', '四', '五', '六', '日')
while True:
num=int(input('請輸入數(shù)字:'))
print('星期%s' % (tuple3[num-1]))

二十二窍帝、字典(dict)

• 字典是一個容器類的數(shù)據(jù)類型,以鍵值對（key:value）的形式來存儲數(shù)據(jù)
• 鍵值對： 鍵：值的形式存在努潘。 值：可以是任何類型的數(shù)據(jù)； 鍵：理論上只能是不可變的數(shù)據(jù)類型坤学，實際開發(fā)中一般將字符串作為key疯坤。
• 字典是可變的（說明可以增、刪深浮、改压怠、查），但是是無序的（不能使用下標來訪問元素）

1飞苇、聲明/定義 字典(dict)

聲明了一個字典對象菌瘫，有兩個鍵值對
dict1 = {'name': '駱昊', 'age': 18}
dict2 = {'score': 100, 10: 'aaa', (1, 2): [1, 2]}
print(dict2)

• 注意：可變的數(shù)據(jù)不能作為字典的key

    dict3={[10,12]:'abc'}  #  報錯 （TypeError: unhashable type: 'list'）
    聲明一個字典蜗顽，存儲小明的姓名、年齡雨让、成績雇盖、顏值：
    dict4={'name': '小明', 'age': 18, 'score': 80, 'face': 80}
  

2、查

a.獲取單個元素的值

• 通過key去獲取值：字典名[key值]

    print(dict4['age'])
    print(dict4['face'])
  

• 注意：使用字典名[key]的形式去獲取字典中元素的值的時候宫患，key值必須是字典中存在的刊懈，否則會報錯

    print(dict4['abc'])   # 報錯（KeyError: 'abc'）
  

• 通過get方法獲取值：字典名.get(key值)

• 獲取字典中不確定key對應的鍵值對是否存在時使用。

• None：python中一個特殊的值娃闲，表示沒有虚汛，類似C語言中的NULL

    print(dict4.get('face'))
    print(dict4.get('abc'))   # None
    
    獲取字典中'grade'對應的值，如果grade不存在就打印'不存在'皇帮，否則直接打印grade對應的值卷哩。
    if dict4.get('grade')==None:
        print('不存在')
    else:
        print(dict4.get('grade'))
  

b、遍歷字典

• 直接遍歷字典拿到的是字典中所有的key值

• 在開發(fā)中使用這種方法去遍歷字典

    dict5 = {'a': 12, 'b': 33, 'c': 66}
    for key in dict5:
        print(key, dict5[key])
  

• 這個在開發(fā)中不建議使用属拾，因為在獲取鍵值對前需要一些轉(zhuǎn)換的操作将谊，消耗CPU。

    for (key, value) in dict5.items():
        print(key, value)
  

3.修改

• 通過key去拿到對應的元素渐白，重新賦值

    dict5 = {'a': 12, 'b': 33, 'c': 66}
    dict5['a']=22
    print(dict5)
    
    練習：將上面的字典中所有的值變?yōu)樵瓉淼?倍尊浓。
    for key in dict5:
        dict5[key] *= 3
    print(dict5)
  

4.增加

• 通過key取值，然后賦值（如果這個key不存在纯衍，就是添加鍵值對栋齿。如果key存在，就是修改這個key）

• 注意：字典里的key是唯一的襟诸。

    dict6={'a': 1, 'b': 2, 'a': 3}
    print(dict6)  # {'a': 3, 'b': 2}
  

5.刪除(刪除的是鍵值對)

a瓦堵、del語句

• 格式：del 字典[key]

    dict5 = {'a': 12, 'b': 33.4, 'c': [1, 2, 3]}
    del dict5['b']   # 刪除'b'對應的鍵值對
    print(dict5)  # {'a': 12, 'c': [1, 2, 3]}
  

b、pop（）方法

• 格式: 字典.pop(key)

    dict5 = {'a': 12, 'b': 33.4, 'c': [1, 2, 3]}
    result = dict5.pop('a')  # 結(jié)果是被刪除的鍵值對的值
    print(result, dict5)  # 12 {'b': 33.4, 'c': [1, 2, 3]}
  

• dict5.popitem()方法：隨機刪除（取出）一個元素

    dict5 = {'a': 12, 'b': 33.4, 'c': [1, 2, 3], 'e': 22}
    dict5.popitem()
    
    練習：將字典中歌亲，值為字符串的全部刪除
    dict5 = {'a': 12, 'b': True, 'c': [1, 2, 3], 'e': 'string'}
    n=0
    for key in dict5.copy():
        if isinstance(dict5[key], str):    # 判斷是否是字符串
            del dict5[key]      # 移除key對應的鍵值對
    print(dict5)
  

6菇用、keys和values方法

dict1 = {'a': 1, 'b': 2, 'c': 3}

a、字典.keys():獲取字典中所有的key,結(jié)果是一個列表

print(dict1.keys())  # dict_keys(['a', 'b', 'c'])

b陷揪、字典.values():獲取字典中所有的值惋鸥，結(jié)果是一個列表

print(dict1.values())   # dict_values([1, 2, 3])

7、update

• 字典1.update(字典2)：用字典2中的元素去跟新字典1中的元素（如果字典2中的鍵值對在字典1中不存在悍缠，直接添加卦绣；如過存在則直接修改）

    dict1.update({'d': 12, 'e': 123, 'a': 10})
    print(dict1)  # {'a': 10, 'b': 2, 'c': 3, 'd': 12, 'e': 123}
  

8、in 和 not in

• 判斷字典中是否有指定的key

    print('a' in dict1)  # True
    print(12 in dict1)   # False
  

二十三扮休、集合（set）

• 集合是一種容器類型迎卤，并且是無序，元素的值是唯一的（不能重復）,是可變的玷坠。
• 是通過{}去存儲元素蜗搔，多個元素之間用逗號隔開劲藐。

1、聲明一個集合

set1 = {1, 2, 3, 4, 1}
print(set1)   # {1, 2, 3, 4}
將字符串轉(zhuǎn)換成集合：
set2 = set('abcdfreea')
print(set2)  # {'e', 'f', 'r', 'b', 'c', 'a', 'd'}
將列表轉(zhuǎn)換成集合：
set3 = set([1, 2, 3, 4, 5, 6, 5, 3])
print(set3)  # {1, 2, 3, 4, 5, 6}
將字典轉(zhuǎn)換成集合（是將字典的key取出來作為集合的元素）：
set4 = set({'a': 1, 'b': 2, 'c': 3})
print(set4)  # {'b', 'a', 'c'}

練習：將字符串str1='abcdffaaaaaffs'去重
str1='abcdffaaaaaffs'
set5 = set(str1)
str2=''
for x in set5:
    str2=str2+x
print(str2)

2樟凄、查

• 不能單獨的獲取某一個元素聘芜，只能通過遍歷的方式去獲取每一個元素

    set1 = {1, 2, 3, 4, 5}
    for item in set1:
        print(item)
  

3、增加

a缝龄、update（）

• 集合1.update(集合2)：將集合2中的內(nèi)容添加到集合1中

    set1 = set('1223')
    set2 = set('abcd')
    set2.update(set1)
    print(set2)  # {'a', '2', '1', 'd', 'c', '3', 'b'}
  

b复罐、add

• 集合.add(元素)：將指定的元素添加到集合中

    set2.add('aaa')
    print(set2)  # {'b', 'd', '3', '1', 'aaa', '2', 'c', 'a'}
  

4啼染、刪除

• 集合.remove(元素)：將指定的元素從集合中刪除

    set2.remove('1')
    print(set2)  # {'3', 'aaa', 'c', '2', 'a', 'd', 'b'}
  

5.判斷包含關系： >= 酝惧、 <=

• python中的集合除了擁有作為容器相關的操作以外沈善，還擁有數(shù)學中集合的相關操作

• 集合1>=集合2：判斷集合1中是否包含集合2，結(jié)果是布爾值

• 集合1<=集合2：判斷集合2中是否包含集合1.

    set1 = set('abcdef')
    set2 = set('abc')
    print(set1 >= set2)   # True
    
    set1 = set('abcdef')
    set2 = set('abcg')
    print(set1 >= set2)   # False
  

6. | 炼绘， & 嗅战， - ， ^

    set1 = set('12345')
    set2 = set('456789')

a俺亮、 |:求并集驮捍，求set1和set2中所有的元素

print(set1 | set2)  # {'2', '8', '9', '5', '7', '4', '6', '3', '1'}

b、 &:求交集脚曾，求在set1和set2的公共部分

print(set1 & set2)  # {'4', '5'}

c东且、 -:求差集,求在set1中，但是不在set2中的元素

print(set1 - set2)  # {'1', '3', '2'}

d本讥、 ^：獲取set1和set2中除了公共部分以外的所有元素

print(set1 ^ set2)  # {'6', '2', '9', '7', '8', '1', '3'}

7.copy

• 將set1中所有的元素取出來創(chuàng)建一個新的集合

    print(set1.copy())
  

• 什么時候用集合珊泳？ 功能涉及到數(shù)學集合相關的操作的時候，就要想到用集合

二十四囤踩、函數(shù)

1旨椒、認識函數(shù)

• 函數(shù)：函數(shù)就是實現(xiàn)某一特定功能的代碼塊晓褪，在類中堵漱，函數(shù)又叫方法（對某一個功能的封裝）
• 函數(shù)的作用：

a.讓界面更簡潔（同樣的功能對應的代碼只寫一遍）
b.如果功能發(fā)生改變，使用函數(shù)只需要修改一個地方的代碼
c.讓代碼模塊化

2涣仿、函數(shù)的聲明（定義）

a勤庐、格式
def 函數(shù)名（參數(shù)列表）：
說明文字
函數(shù)體

• def:是python中聲明函數(shù)的關鍵字
• 函數(shù)名：標識符，PEP8好港，見名知義（根據(jù)函數(shù)名大概知道函數(shù)的功能）
• ():固定格式愉镰，不能省略
• 參數(shù)列表（形參）：參數(shù)的作用就是從外面往函數(shù)中傳值。一個函數(shù)可以沒有參數(shù)钧汹，也可以有多個參數(shù)丈探。如果有多個參數(shù)，參數(shù)間用逗號隔開拔莱。
• 形參：獲取從外面?zhèn)鬟f給函數(shù)內(nèi)部的值（形參就是變量名）
• 冒號：固定的格式
• 說明文字：對函數(shù)功能進行說明
• 函數(shù)體：實現(xiàn)函數(shù)功能的代碼段

b碗降、對于初學者來說隘竭，聲明函數(shù)的步驟：

1.確定函數(shù)的功能（確定函數(shù)是做什么的）
2.確定函數(shù)名（根據(jù)功能確定函數(shù)名）
3.確定參數(shù)（確定是否有參數(shù)，確定參數(shù)有幾個讼渊，看實現(xiàn)這個功能需不需要從外面?zhèn)髦颠M去）
4.確定是否需要返回值（返回值：就是函數(shù)返回給調(diào)用者的數(shù)據(jù)动看。python中所有的函數(shù)都有返回值，默認是None）
5.實現(xiàn)函數(shù)的功能

• 注意：函數(shù)只有在調(diào)用的時候才會執(zhí)行

    寫一個函數(shù)爪幻，打印'hello python'
    def da_yin():
        """ 打印'hello python' """
        print('hello python')
    調(diào)用函數(shù)da_yin:
    da_yin()
  

• 注意：1.一個函數(shù)聲明后菱皆，可以調(diào)用多次 2.python中所有的函數(shù)調(diào)用表達式都有值

    寫一個函數(shù)，去打印10的階層
    def jie_ceng():
        """ 打印10的階層 """
        s = 1
        for i in range(1, 11):
            s = s*i
        print(s)
    jie_ceng()
  

3挨稿、函數(shù)的調(diào)用

• 格式：
  函數(shù)名（參數(shù)列表）

• 函數(shù)名：你聲明的需要調(diào)用的函數(shù)（已經(jīng)聲明過的函數(shù)才可以調(diào)用）

• 參數(shù)列表：實參（調(diào)用函數(shù)的時候給函數(shù)傳的值）

• 函數(shù)的調(diào)用過程：就是用實參給形參賦值仇轻，并且執(zhí)行函數(shù)體獲取返回值

    寫一個函數(shù)，打印兩個數(shù)的和：
    def my_sum(num1,num2):
        """ 打印num1+num2的和"""
        print(num1+num2)
  

• 帶參的函數(shù)的調(diào)用

• 注意：函數(shù)調(diào)用的時候一定要保證每個形參都有值

a.位置參數(shù)（用實參依次給形參賦值）

my_sum(2,3)  # 5 執(zhí)行這句代碼：先將num1=2奶甘，在將num2=3.在執(zhí)行my_sum的函數(shù)

b.關鍵字參數(shù)

my_sum(num2=5, num1=10)   # 15
練習：寫一個函數(shù)拯田，打印一個數(shù)的立方
def lifang(num):
    """ 打印num的立方"""
        print(num**3)
lifang(5)   # 125

c.參數(shù)的默認值

• 在python中，函數(shù)的參數(shù)可以設置默認值甩十。(函數(shù)聲明的時候給參數(shù)賦值)

• 如果參數(shù)設置了默認值船庇，那么調(diào)用函數(shù)的時候，這個參數(shù)可以傳參侣监，也可以不傳鸭轮。

    寫一個函數(shù)，問候某人（打娱厦埂：XXX窃爷，how are you!）
    def wen_hou(name='xxx'):
        """ 問候 """
        print('%s,how are you!'%(name))
  

• 函數(shù)調(diào)用的要求：保證每個參數(shù)有值

    wen_hou()   # xxx,how are you!
    wen_hou('Liu Zhilong')  # Liu Zhilong,how are you!
  

• 注意：聲明函數(shù)的時候，如果函數(shù)中有多個參數(shù)姓蜂，有默認值的參數(shù)必須放到?jīng)]有默認值的參數(shù)的后面

    def wen_hou(message, name='xxx'):
        """ 問候 """
        print('%s,how are you! %s'%(name,message))
    wen_hou('lalala')  # xxx,how are you! lalala
  

d.參數(shù)個數(shù)不定

• 參數(shù)個數(shù)不確定的時候按厘，就在參數(shù)列表中聲明一個變量，前面加一個“ * ”钱慢；這個時候這個變量就變成了元組逮京。

• 命名關鍵字參數(shù):寫在 * ,后面的參數(shù)；在調(diào)用時必須要給出參數(shù)名和參數(shù)值

    def roll_dice(*, num = 1):
        函數(shù)體
    roll_dice(num = 3)  # num =必須寫上束莫，不能直接寫數(shù)字懒棉，否則會報錯
  

• 函數(shù)調(diào)用的時候，所有的實參都會添加到這個元組中览绿。

    寫一個函數(shù)策严，求多個數(shù)的和
    def my_sum(*nums):
        """求多個數(shù)的和"""
        s=0
        for i in nums:
            s += i
        print(s)
    my_sum(2, 3, 5, 6, 7)  # 23
    my_sum(34, 21)  # 55
  

4、函數(shù)的返回值

• 函數(shù)的返回值：

a.就是函數(shù)調(diào)用表達式的值饿敲；
b.就是return關鍵字后的表達式的值妻导；
c.就是函數(shù)返回給調(diào)用者的值。

• 如何看一個函數(shù)的返回值是多少：就看return后面的結(jié)果，如果沒有return就是None

5倔韭、函數(shù)調(diào)用

• 函數(shù)調(diào)用表達式：就是調(diào)用函數(shù)的那個表達式（這個表達式是有值的暑脆，默認是None）

    func1()就是一個函數(shù)
    def func1():
        print('hello world!')
  

• func1()就是函數(shù)調(diào)用表達式，它是一個值狐肢。

• 普通的值能做的事情添吗，函數(shù)調(diào)用表達式都能做；例如：給變量賦值份名，打拥（可以作為實參傳給函數(shù)），運算等

    result = func1()
    print(result, func1())  #  hello world!   hello world!   None None
  

6僵腺、return

• return：

a.將值傳給函數(shù)調(diào)用者（函數(shù)調(diào)用表達式）
b.結(jié)束函數(shù)

• 如果函數(shù)中沒有return,就相當于在函數(shù)結(jié)束的時候后面加了一個return None

    def func2():
        print('hello world!')
        return None   
    
        return 100
        result = func2()
    print(result, func2())  # hello world!  hello world!  100 100
    練習：寫一個函數(shù)鲤孵，獲取兩個數(shù)的乘積
    def cheng_ji(num1, num2):
        return num1 * num2
    print(cheng_ji(5, 4))  # 20
  

7、函數(shù)的結(jié)束

• 函數(shù)的結(jié)束：

a.沒有return辰如，函數(shù)體執(zhí)行完畢普监，函數(shù)結(jié)束；
b.如果函數(shù)中有return琉兜，遇到return函數(shù)就結(jié)束凯正，程序直接回到函數(shù)調(diào)用的位置，接著往下執(zhí)行豌蟋。

練習：寫一個函數(shù)廊散，找出100-200之間第一個能被13整除的數(shù)
def zhao_shu():
for i in range(100, 201):
    if i % 13 == 0:
        return i
print(zhao_shu())   # 104

8、將列表作為參數(shù)

• 注意：將列表的變量作為實參傳遞給函數(shù)梧疲。如果在函數(shù)中改變了列表的元素允睹，那么原來的列表元素也會變。

    def shan_chu(list1):
    n=0
    while n < len(list1):
        if list1[n] % 2 ==0:
            del list1[n]
        else:
            n+=1
    print(list1)
    list2 = [2,1,5,6,2,44,5,6]
    shan_chu(list2)  # [1, 5, 5]
    print(list2)  # [1, 5, 5]
  

9幌氮、函數(shù)變量

• 我們在聲明函數(shù)的時候缭受，其實就是在聲明一個類型是函數(shù)類型（function）的變量。
• 普通變量能做的事情该互，函數(shù)變量都可以做米者。

a.函數(shù)名就是函數(shù)類型的變量（類型名：function），存的是函數(shù)入口的地址

def func1():
    print('aaa')

b.可以用一個變量給另外一個變量賦值

a = func1()    # 這樣賦值慢洋。是將函數(shù)func1的返回值賦給a
a = func1      # 將函數(shù)變量func1賦給啊塘雳，a就會變成一個函數(shù)
a()  # 心在就可以用函數(shù)變量a陆盘，去調(diào)用函數(shù)func1
def func2(num):
    return num * 2
b = func2
print(func2(10))  # 20
print(b(10))      # 20

c.函數(shù)變量作為函數(shù)的參數(shù)

def calculate(num1,num2,fn):
    if not(isinstance(num1,int) or              isinstance(num1,float)):
        print('num1不是數(shù)字')
        return  None
    if not(isinstance(num2,int) or isinstance(num2,float)):
        print('num2不是數(shù)字')
        return None
    return fn(num1, num2)
def func_add(n,m):
    return n + m
def func_sub(n, m):
    return n - m
print(calculate(20,10,func_sub))  # 10

d.函數(shù)作為返回值

• 寫一個函數(shù)普筹，func3('+')-> 返回求和的功能；finc3(' * ')-> 返回求乘積的功能

    def func3(char):
        if char == '+':
        # python中隘马，是可以在函數(shù)中聲明函數(shù)
            def fn(*n):
                sum=0
                for x in n:
                    sum += x
                return sum
            return fn
        if char == '*':
            def fn(*nums):
                sum1 = 1
                for i in nums:
                    sum1 *= i
                return sum1
            return fn
     result = func3('+')  # result是一個求個功能的函數(shù)的函數(shù)變量
     print(result(1,2,4,5))  # 10
     print(func3('*')(10, 20))   # 200
     
     def func4():
        list1=[1,2,3]
        return list1
     print(func4()[0])  # 1
  

10.匿名函數(shù)

• python中使用lambda關鍵字來聲明一個匿名函數(shù)

     格式：lambda 參數(shù)列表：返回值
     參數(shù)列表：多個參數(shù)之間用逗號隔開
     
     使用函數(shù)實現(xiàn)求兩個數(shù)的和：
     def func1(num1, num2):
        return num1 + num2
     print(func1(10,20))   # 30
     使用匿名函數(shù)實現(xiàn)求兩個數(shù)的和：
     func2= lambda num1, num2: num1 + num2
     print(func2(10, 20))  # 30
     
     練習：使用匿名函數(shù)求指定列表中太防，指定的兩個下標對應的元素的和
     func3= lambda list1, num1, num2: list1[num1]+list1[num2]
     print(func3([1, 2, 3, 4, 5], 2, 3))  # 7
     
     使用指定的功能去計算num1和num2（例如求和）
     def calulate(num1,num2,fn):
        return fn(num1, num2)
     print(calulate(10,20,lambda a,b: a+b))  # 30
  

11、遞歸函數(shù)

a.遞歸函數(shù)：在函數(shù)的聲明中調(diào)用函數(shù)本身

這兒的func1就是一個遞歸函數(shù)
def func1():
    print('aaa')
    func1
func1()

b.遞歸作用：理論上循環(huán)能夠做到的事情，遞歸都可以做蜒车。（但實際除非是非用不可的情況讳嘱，一般不用遞歸）
c.步驟：

• <1>確定臨界值（結(jié)束函數(shù)的時刻）

• <2>假設函數(shù)的功能已經(jīng)實現(xiàn)，然后找到f(n)和f(n-1)的關系

• <3>使用f(n-1)和f(n)的關系去實現(xiàn)f(n)的功能

    計算1+2+3+....+n(使用遞歸)
    def func1(n):
        # 1.確定臨界值
        if n ==1:
            return 1
    # 2.假設func1的功能實現(xiàn)了酿愧，找func1(n-1)和func1(n)的關系
    # func1(n-1)=1+2+3...+n-1
    # func1(n)=1+2+3...+n-1+n
    # 3.通過func1(n-1)去實現(xiàn)func1(n)的功能
        return func1(n-1)+n
    print(func1(10))
    
    用遞歸實現(xiàn)：2*4*6...*n(要求n是偶數(shù))
    def func2(n):
        if n == 2:
            return 2
        return func2(n-2) * n
    print(func2(6))
    
    打印圖形:n=5
    *****
    ****
    ***
    **
    *
    不用遞歸:
    def func3(n):
        for x in range(1,n+1):
            print('*'*(n+1-x))
    print(func3(5))
    用遞歸:
    def func4(n):
        if n == 1:
            print('*')
            return
        print(n*'*')
        func4(n-1)
    func4(5)
    
    打印圖形：n=5
    *
    **
    ***
    ****
    *****
    def func5(n):
        if n == 1:
            print('*')
                return
        func5(n-1)
        print(n*'*')
    func5(5)
  

12.函數(shù)的調(diào)用

• 函數(shù)調(diào)用的過程是一個壓棧的過程：

a.調(diào)用函數(shù)的時候沥潭，首先會在棧中開辟一塊內(nèi)存空間，用來保存函數(shù)調(diào)用過程中產(chǎn)生的數(shù)據(jù)（包括函數(shù)的參數(shù)和在函數(shù)中聲明的變量）
當函數(shù)執(zhí)行完成后嬉挡，被調(diào)用函數(shù)對應的內(nèi)存空間會被回收（釋放）

• 棧：是內(nèi)存中的一塊特殊的區(qū)域钝鸽。數(shù)字和字符串的值是存在棧里面的。
• 堆：對象是存在堆里面的
• 總結(jié)：遞歸要慎用Ｅ痈帧（能用循環(huán)做的拔恰，就不要用遞歸。遞歸消耗內(nèi)存也消耗CPU資源）

13基括、使用模塊管理函數(shù)

• 模塊：指一個.py文件（一個.py文件就是一個模塊）
• 可以在一個模塊中使用其它模塊的函數(shù)和類
• 怎么使用其他模塊中的函數(shù)颜懊？

a.通過import關鍵字導入模塊，然后通過模塊名.函數(shù)的方法去使用模塊中的函數(shù)

    通過 import 模塊名
    import random
    s=random.randint(1,10)
    print(s)

b.通過from-import直接導入指定的函數(shù)或者類风皿。導入后就可以直接調(diào)用函數(shù)

• 格式：from 模塊名 import 函數(shù)名1河爹，函數(shù)名2
  from 模塊名 import 函數(shù)名
  from random import randint
  s=randint(1,9)
  print(s)

c.通過 as關鍵字:通過as給導入的模塊或者函數(shù)重命名

    1.通過as改變模塊名
    import  random as my_random
    s=my_random.randint(1,10)
    print(s)
    2.通過as改變模塊中的函數(shù)名
    from random import randint as my_randint
    s=my_randint(1,9)
    print(s)

• 注意：當我們導入其它模塊的時候，會將其它模塊中的所有內(nèi)容都會導入到當前文件中

• 判斷模塊的內(nèi)置屬性 _ _ name _ _ 的值是否是' _ _ main _ _',將不需要被其它模塊導入的代碼寫到這個if語句中

    if __name__=='__main__':
        print('aaa')
  

• 關于_ _ name _ _ 屬性：_ _ name _ _ 是每個模塊都有的屬性桐款，作用是用來存儲模塊的名字昌抠。

• 當模塊不是正在執(zhí)行的模塊，_ _ name _ _ 屬性的值是模塊對應的文件的文件名鲁僚；當模塊正在執(zhí)行的時候炊苫，_ _ name _ _ 的值就是一個固定值'_ _ main _ _'

二十五、作用域

• python中只有模塊冰沙、函數(shù)和類會產(chǎn)生作用域侨艾。在作用域中聲明的變量我們叫局部變量
• 在產(chǎn)生作用域外的位置聲明的變量叫全局變量
• 不管是局部變量還是全局變量，都是從聲明開始起作用的拓挥。

1唠梨、全局變量

• 全局變量：聲明在產(chǎn)生作用域外。

• 使用范圍：從聲明開始到整個文件結(jié)束的任何位置都可以使用

• if語句侥啤、for/while循環(huán)體当叭，是不會產(chǎn)生作用域的；相當于寫在if盖灸、循環(huán)體中的變量不改變其變量屬性

    a=10  # 全局變量
    print(a)
    if True:
        print(a)
    for x in range(3):
        print(a)
  

2蚁鳖、局部變量

• 局部變量：在python中聲明在函數(shù)和類中的變量都是局部變量。

• 注意：在函數(shù)中不能修改全局變量的值赁炎，只能使用醉箕。

    def func3():
        d = 'a'   # d就是一個局部變量，使用范圍就是從聲明開始到函數(shù)結(jié)束
    print(d)
    func3()      # 'a'
  

a、global關鍵字的使用
b=100
def func5():
#想在這個地方去修改全局變量b的值為200
global b
b = 200
func5()
print(b) # 200

二十六讥裤、文件操作

• 文件都有后綴放棒，不同的后綴表示不同的存儲方式
• 文本文件（存文字信息）---- .txt , .word, .md 等...
• 二進制文件：視頻文件、音頻文件己英、圖片---- .mp4, .mov, .avi, .jpg, .mp3 等...
• 可執(zhí)行文件等--- .exe , . api, .dmg 等...
• 文件操作（對文件進行讀寫）步驟（對所有文件都有效）：

1.打開文件
2.對文件進行讀/寫操作（讀：獲取文件內(nèi)容 寫：修改文件內(nèi)容）
關閉文件

1间螟、文本文件

a.打開文件

• open(文件路徑，打開的模式='r'损肛，編碼方式)
• open函數(shù)有一個返回值：返回的就是被打開的文件句柄對象
• 文件句柄：就是文件的代言人寒亥，對文件句柄對象進行的操作就相當于對文件進行操作
• 文件路徑：文件在電腦中對應的地址

(1)直接寫全路徑（不推薦使用）： 'E:/Python資料/python作業(yè)/上課筆記/6.24/code/aaa.txt'
(2)一般將涉及到的文件放到工程中:'lalala.txt'

a.文件和代碼對應的.py文件在一個目錄下面：路徑直接寫文件名
在工程文件夾下，但是不直接和代碼文件在一個目錄里面： ./文件對應的文件夾名/文件名

• 打開的模式：

'r'(文本讀荧关，以讀的形式打開溉奕，只能獲取文件內(nèi)容，不能修改文件內(nèi)容)
'w'(文本寫忍啤，以寫的形式打開加勤，只能修改文件內(nèi)容，不能獲取文件內(nèi)容)
'a'(文本寫)
'rb'(二進制讀)
'wb'(二進制寫)
'ab'(二進制寫)

• 編碼方式(encoding)：'utf-8'(pythond的文本編碼方式)
• utf-8：一種文本編碼方式同波，就是使用1-6個字節(jié)對Unicode進行編碼鳄梅；utf-8就可以編碼所有國家的語言對應的字符。
• gbk：只支持中文文本編碼
• 注意：'r'打開文件未檩，如果文件的路徑錯了會報錯
  f=open('./fils/lalala.txt', 'r', encoding='utf-8')
• f：就是被打開的文件對應的文件句柄

b.讀操作

• 注意：對同一個句柄對象進行讀操作戴尸，每讀一次內(nèi)容，下次在讀的時候冤狡，從上次讀的結(jié)束的位置往下讀

• f.read():獲取文件中所有的內(nèi)容并且返回

• 文本文件讀取的結(jié)果是字符串

• read(n):指定讀取的文本長度（默認-1：讀全部內(nèi)容孙蒙，n大于長度讀所有）

    result=f.read()
    print(result)
    f.close()
  

• f.readline()：每次讀一行內(nèi)容

    f= open('aaa.txt','r',encoding='utf-8')
    result1 = f.readline()
    print(result1)
  

• 關閉文件:f.close()

    練習：1.讀取指定文件的所有內(nèi)容 2.讀取指定文件的所有內(nèi)容（一行一行的讀）
    f=open('./fils/lalala.txt', 'r', encoding='utf-8')
    print(f.read())
    while True:
        result1 = f.readline()
        if result1=='':
        # if not result1:
        # if len(result1)==0:
            break
        else:
            print(result1)
    f.close()
  

• readlines():讓文件中所有的內(nèi)容讀出來（將每一行的內(nèi)容作為列表的元素返回）

c.修改讀取的位置

• 讀寫文件，每次讀完悲雳，下次再讀的時候挎峦，是接著上次讀完的位置往下進行讀操作。

• 避免這個問題的方法：1.從新打開文件合瓢，然后再讀 2.設置讀寫位置

     f = open('aaa.txt', 'r', encoding='utf-8')
  

• 讀取文件中所有的內(nèi)容,下次再讀就是從文件結(jié)束的位置往后讀

• seek(偏移量)：偏移量是字節(jié)數(shù)（一個字母是一個字節(jié)坦胶，“utf-8”中一個漢字是3個字節(jié)，“gbk”中一個中文漢字是兩個字節(jié)）

• 注意：偏移量一般設置為0

• 設置讀寫位置為文件的開始：后面進行讀操作的時候晴楔，就是從文件開始的位置往后讀

     f.seek(0)
     print('====', f.read())
     f.close()
  

d.寫操作

f = open('aaa.txt', 'w', encoding='utf-8')

• 注意：'w'或者'a'打開文件顿苇，如果這個文件不存在，會創(chuàng)建一個新的文件

• write(寫的內(nèi)容)：文本文件中税弃，寫的內(nèi)容是字符串

• 注意：'w'->寫的時候會覆蓋原文件的內(nèi)容. 'a'->在原來的內(nèi)容后面追加內(nèi)容

     f.write('我的哥纪岁！')
     f.seek(0)  # 后面寫的時候，會以覆蓋前面寫的內(nèi)容的形式去寫
     f.writelines(['aaa', 'bbb', 'ccc'])
     f.close()
  

• python中可以使用以下結(jié)構(gòu)來進行文件操作過程：

     with open() as 文件變量:
        在文件打開后關閉前執(zhí)行的代碼段
     例如：
     with open('aaa.txt', 'r', encoding='utf-8') as f:
     print(f.read())
  

2钙皮、二進制文件

a.二進制文件的讀

• bytes類:python中的二進制數(shù)據(jù)對應的類型bytes

    with open('./fils/懶洋洋小黃貓.mov', 'rb') as f:
        data=f.read()
        print(data)
  

b.二進制文件的寫

• 'ab':無追加效果

    with open('./fils/new.mov', 'wb') as f:
        # data需要是bytes類型的數(shù)據(jù)
        f.write(data)
  

3蜂科、json文件

• json文件：就是后綴是.json的文件顽决，用來存儲文本數(shù)據(jù)（以特殊的語法結(jié)構(gòu)來存儲文本信息）

最外層：要么是字典結(jié)構(gòu)短条，要么是數(shù)組（列表）結(jié)構(gòu),要么是字符串
里面的數(shù)據(jù)：字符串导匣、二進制、數(shù)字茸时、字典贡定、數(shù)組(列表)

{}->字典結(jié)構(gòu)
{
    "name":"aa",
    "age":18,
    "score":[100,22,44]
}

[]->數(shù)組結(jié)構(gòu)
[
    100,
    "name"
]

->字符串
“
    name，awdf可都，[1,2,3]
”

• json文件的讀寫：python中使用python內(nèi)置模塊json來對json數(shù)據(jù)進行操作

    import json
  

a.讀取json文件中的內(nèi)容

• json.load(f):讀取的結(jié)果只有兩種情況（要么是字典缓待，要么是列表）

• json.loads(json字符串，編碼方式)：將字符串轉(zhuǎn)換成字典或者列表

    with open('./fils/json文件.json', 'r', encoding='utf-8') as f:
    # print(f.read())
    result = json.load(f)
    # print(type(result))  # dict
    print(result)
    resolt=json.loads('{"name":"lala","age":17}' encoding='utf-8')
    print(resolt)  # {'name':'lala','age':17}
  

b.json文件的寫操作

• json.dump(寫的內(nèi)容渠牲，寫到那個文件):寫的內(nèi)容只能是一個字典/一個數(shù)組（列表）/一個字符串/一個元組（寫進去是列表）

• json.dumps(對象)：將字典或者列表轉(zhuǎn)換成字符串

    with open('./fils/myjson.json', 'w', encoding='utf-8') as f:
    # dict1 = {'aaa': 100, 'abc': 'aaw', 'person': {'name': 'lalala', 'age': 50}}
    # list1 = [1, 22, 'www', [1, 3, 'e']]
    # str1 = 'avffad'
    tuple1 = (1, 2, 3)  # 寫進去還是列表
    json.dump(tuple1, f)
    
    寫一個添加學生的功能旋炒，將添加的學生信息持久化:
    1.添加學生
    2.查看學生
    import json
    # 1.
    name1= input('請輸入添加的學生姓名：')
    age1= int(input('請輸入學生的年齡：'))
    tel1= int(input('請輸入學生的電話號碼：'))
    try:
        with open('./fils/學生信息.json', 'r', encoding='utf-8') as f:
            dict2 = json.load(f)
    except:
        dict2 = {}
    dict1 = {"name": name1, "age": age1, "tel": tel1}
    dict2[name1] = dict1
    with open('./fils/學生信息.json', 'w', encoding='utf-8') as f:
        json.dump(dict2, f)
    # 2.
    name2 = input('請輸入要查找的學生姓名')
    with open('./fils/學生信息.json','r',encoding='utf-8') as f:
        result = json.load(f)[name2]
        print(result)
  

二十七、異常的捕獲

• 格式：

    格式1：
    try:
        代碼塊1（需要捕獲異常的代碼塊）
    except:
        代碼塊2（出現(xiàn)異常后執(zhí)行的代碼塊）
    # finally:
        # 代碼塊3（不管有沒有異常都要執(zhí)行的代碼塊）
    
    格式2：
    try:
        代碼塊1
    except 錯誤類型列表：
        代碼塊2
    # except:
        # 代碼塊3（出現(xiàn)異常后執(zhí)行的代碼塊）
    # finally:
        # 代碼塊4（不管有沒有異常都要執(zhí)行的代碼塊）
    出現(xiàn)指定錯誤類型的異常才捕獲
  

• 執(zhí)行過程：先執(zhí)行代碼塊1签杈，如果執(zhí)行代碼塊1的時候出現(xiàn)異常瘫镇，就執(zhí)行代碼塊2；如果代碼塊1不出現(xiàn)異常答姥，就執(zhí)行try結(jié)構(gòu)外的其它語句

    try:
        print(int('12fef'))
    except:
        print('出現(xiàn)異常了铣除！')
    
    try:
        with open('./fils/la.json', 'r', encoding='utf-8') as f:
            pass
    except FileNotFoundError:
        print('出現(xiàn)文件找不到異常！')
  

二十八鹦付、面向?qū)ο缶幊?/h1>

1尚粘、編程思想：

面向過程編程：c（只有邏輯和過程）
a=1
b=2
print(a+b)

面向?qū)ο缶幊蘪ava 、c++敲长、oc郎嫁、python（有類語法）-->(以對象為工具實現(xiàn)功能)
對象.sum(1,2)

函數(shù)式編程：c、java祈噪、python （以函數(shù)為工具實現(xiàn)功能）
def sum(num1,num2):
    return num1+num2
sum(1,2)

2行剂、類和對象

• 類：具有相同屬性和相同功能的對象的集合，是抽象的钳降。

• 對象：就是類的實例厚宰，是具體的。

    如果說電腦是一個類遂填，我桌上這臺電腦就是一個對象铲觉。
  

• 聲明類的格式：

    class 類名：
        類的內(nèi)容
  

a.class：python中聲明類的關鍵字
b.類名：標識符(1.首字母大寫！吓坚！ 2.見名知義)
c.冒號：固定格式撵幽，冒號后一個縮進的內(nèi)容就是類的內(nèi)容
d.類的內(nèi)容：

1.類變量:聲明在類中，方法外的變量礁击；要通過類去獲妊卧印（通過類能夠讓其具體的屬性）
2.對象屬性
3.方法（構(gòu)造方法逗载、對象方法、類方法链烈、靜態(tài)方法）：聲明在類中的函數(shù)就叫方法

聲明一個人對應的類：
class Person:
    count = 61  
    def __init__(self):
        # 我們一般在這個地方去聲明對象的屬性
        self.name = '啦啦啦'
        self.age = 18
        self.gender = '男'
    def run(self):
        print('跑起來')

• count：就是類變量(通過類去使用)厉斟，是局部變量，作用域是整個類

• _ _ init _ _ ：構(gòu)造方法 _ _ init _ _ 强衡，名字固定擦秽；通過類創(chuàng)建對象的時候，系統(tǒng)會自動的調(diào)用這個方法去初始化對象的屬性漩勤。

• self：

  1.類中所有的對象方法都會默認有一個self參數(shù)感挥，用來指向調(diào)用方法的對象（誰調(diào)用當前這個方法就指向誰）
  2.調(diào)用帶有self的方法不需要給self傳參，系統(tǒng)會自動將方法調(diào)用者傳給它

• name越败、age筋帖、gender就是人這個類的對象的屬性

• 對象方法：

  1.所有的對象方法都有一個默認的參數(shù)self
  2.直接聲明在類中的函數(shù)理张，都是對象方法
  3.對象方法必須使用對象去調(diào)用

• a.使用類變量:通過 類名.類變量 的形式在類外去使用類變量

    print(Person.count)  # 61
  

• b.name、age、gender都是對象屬性乙帮，對象屬性的使用：對象.屬性名

    # print(Person.name)  # 報錯（AttributeError: type object 'Person' has no attribute 'name'）
  

• c.對象方法run：對象方法只能通過對象去調(diào)用-->對象.方法名（）

    # run()  # 報錯（NameError: name 'run' is not defined）
    # Person.run()  # 報錯（TypeError: run() missing 1 required positional argument: 'self'）
  

• d.怎么聲明對象：類名（參數(shù)）

• 通過類創(chuàng)建對象：會自動調(diào)用類的 _ _ init _ _ 方法去初始化對象的屬性

• 類名（參數(shù)）势决，這個參數(shù)有沒有熔恢，有幾個就看 _ _ init _ _ 方法

     p1 = Person()  # 通過Person類轻姿，創(chuàng)建了一個對象p1
  

• 創(chuàng)建完對象后，就可以通過對象獲取對象屬性：對象.屬性名

     print(p1.name) # 啦啦啦
  

• 通過對象給屬性賦值

     p1.age = 18
     print(p1.age)  # 18
  

• 通過對象去調(diào)用對象方法（也叫給對象發(fā)送消息）

     p1.run()
  

• e.一個類可以擁有多個對象

     p2 = Person()
     p2.name = 'hehe'
     p2.age = 20
     print(p2.age)   # 20
     print(p2.name)  # hehe
  

二十九袱蜡、類的定義

• 類：具有相同屬性和功能的對象的集合丝蹭；抽象的

• 對象：類的實例；具體的

• 類的聲明

    class 類名（父類）：
        屬性
        方法
    class 類名：
        屬性
        方法
  

a.class：python中聲明類的關鍵字
b.類名：標識符坪蚁。 首字母大寫奔穿、見名知義。
c.屬性：分類的字段和對象的字段敏晤。---->屬性
d.方法：對象方法（構(gòu)造方法）贱田、類方法、靜態(tài)方法嘴脾。---->功能

• 方法：就是聲明在類中的函數(shù)（都有一個默認參數(shù)男摧，不需要調(diào)用的時候給他傳值）
• 對象方法：在類中直接聲明的函數(shù)，帶一個參數(shù)self译打；要使用對象來調(diào)用耗拓。

# 聲明類
class Person:
    """人類"""    # 說明文檔
    # 在類中聲明了eat方法，默認有一個參數(shù)self奏司，調(diào)用eat方法的時候乔询，不需要給self傳參
    # 在類中直接聲明的函數(shù)都是對象方法，對象方法必須使用對象來調(diào)用
    # 直接寫在類中的函數(shù)韵洋，必須帶參數(shù)self
    def eat(self):
        print('吃飯~')
    # 注意：如果要在類中聲明帶參的對象方法竿刁，那么其它的參數(shù)必須寫在self后面
    def run(self,num):
        print('跑了%d米'%(num))
# 創(chuàng)建對象

p1 = Person()
# p1就是Person類的一個實例（對象）
# 可以通過對象去調(diào)用類中的對象方法黄锤、和使用類中聲明的對象屬性（字段）

• 調(diào)用對象方法:

    p1.eat()  # 吃飯~
    p1.run(100)  # 跑了100米
  

• 一個類可以創(chuàng)建多個對象:

    p2 = Person()
    p2.eat()  # 吃飯~
    p2.run(80)  # 跑了80米
  

三十、對象屬性和init方法

1. 示例一：init方法會自動調(diào)用
   class Person:

• _ _ init _ _ 方法又叫構(gòu)造方法食拜。是在通過類創(chuàng)建對象的時候自動調(diào)用的方法

• _ _ init _ _ 方法的作用就是在創(chuàng)建對象的時候初始化對象的屬性

• _ _ init _ _ ：對象的屬性就是聲明在這個方法中

    def _ _ init _ _ (self):
        # 在這個地方聲明對象的屬性
        print('這個是init')
  

• 在聲明對象的時候會自動調(diào)用init方法

     p1 = Person()
     p2 = Person()
  

2.示例二：帶參的init方法

class Dog:
    """狗"""

• init方法的方法名固定： _ _ init _ _ 鸵熟。 但是參數(shù)是可以隨意改變的（但是self不變）

   def __init__(self, name):
       print('名字是：%s'%(name))
  

• 通過類創(chuàng)建對象的時候，要保證init方法里面的每一個參數(shù)都有值监婶。通過給類名后面的括號里傳參來保證旅赢。

    dog1 = Dog('xiaohui')
    dog2 = Dog(name='xiaobai')
  

3.示例三：對象屬性

• 屬性：聲明在類中的變量

• 對象屬性：要通過對象去使用齿桃；不同的對象可能會有不同的值惑惶；聲明在init方法中的變量。

    class Person2:
        """人類"""
        # 在init中聲明對象屬性：self.屬性名 = 初值
        def __init__(self):
        # 聲明一個對象屬性name短纵，初始值為空串
        self.name = ''
  

• 通過Person2類創(chuàng)建對象P3

    P3 = Person2()
  

• 通過P3對象去修改P3的name屬性

    P3.name = 'XIAOBAI'
  

• 通過P3對象去使用P3的name屬性

    print(P3.name)   # XIAOBAI
  

• 通過Person2類創(chuàng)建對象P4

    P4 = Person2()
  
    # 練習：聲明一個學生類带污，擁有屬性：名字、年齡和電話香到。擁有方法：學習
    class Student:
        def __init__(self):
            self.name = ''
            self.age = ''
            self.tel = ''
        def study(self):
            print('%s在學習'%(self.name))
    student1 = Student()
    student1.name = 'dage'
    student1.age = 20
    student1.tel = 123456789
    print(student1.age,student1.name,student1.tel)   # 20 dage 123456789
    # 調(diào)用對象方法（給對象發(fā)送消息）
    student1.study()      # dage在學習
  

4.示例四：

class Student1:
    def __init__(self, name1='', age1='', tel1=''):
        self.name = name1
        self.age = age1
        self.tel = tel1

• 在創(chuàng)建對象的時候給對象屬性賦初值

    student2 = Student1('xiaoming','20','1234556781')
    print(student2.name, student2.age, student2.tel) # xiaoming 20 1234556781
  

三十一鱼冀、self

• 類中的對象方法都有一個默認參數(shù)self

  a.調(diào)用帶有默認參數(shù)self的方法，不需要給self傳參悠就。系統(tǒng)會自動將調(diào)用當前方法的對象傳給self
  b.在方法中使用self就相當于使用調(diào)用方法的對象（只能使用self千绪，不能重新給self賦值）

  class Person:
    """人類"""
    def __init__(self, name='', age=0):
        # 聲明對象屬性
        self.name = name
        self.age = age
    def eat(self):
        print('吃飯')
    # 聲明一個對象方法run
    def run(self):
        # 在對象方法中使用對象的屬性，直接用self去獲取屬性
        print('%s跑起來'%(self.name))
        self.eat()
  # 創(chuàng)建一個Person對象
  p1 = Person('小明',10)
  

• 通過對象p1去調(diào)用run方法梗脾，系統(tǒng)會將self=p1

• 這個時候在run方法中荸型，p1和self是一個東西

  p1.run() # 小明跑起來
            # 吃飯
  
  練習：聲明一個圓類，擁有屬性：半徑 炸茧，擁有方法：計算圓的面積瑞妇、計算圓的周長
  from math import pi
  class Circle:
    def __init__(self, radius=0):
        self.radius = radius
    def area(self):
        return (self.radius)**2 * pi
    def perimeter(self):
        return 2*pi*self.radius
  circle1 = Circle(3)
  print('%.2f' % circle1.area()) # 28.27
  print('%.2f' % circle1.perimeter()) # 18.85
  

三十二、屬性的增刪改查

class Dog:
    """狗"""
    # Dog類有name和age兩個屬性
    def __init__(self,name='',age=0):
        self.name = name
        self.age = age
dog1 = Dog('恭喜發(fā)財',20)

1.查

a.方式一：對象.屬性

特點：如果屬性存在就獲取屬性的值梭冠。如果屬性不存在就會報AttributeError錯誤

print(dog1.name)  # 恭喜發(fā)財
# print(dog1.score)  # 報錯（AttributeError: 'Dog' object has no attribute 'score'）

b.方式二：getattr(對象辕狰，屬性名，默認值)--->獲取指定對象的指定屬性

如果不設置默認值：屬性如果存在就獲取屬性值控漠，如果屬性不存在就報錯
如果設置默認值：屬性如果存在就獲取屬性值蔓倍，如果屬性不存在，不報錯盐捷，并且將默認值作為結(jié)果

print(getattr(dog1, 'name'))  # 恭喜發(fā)財
# print(getattr(dog1, 'score'))  # 報錯（AttributeError: 'Dog' object has no attribute 'score'）
print(getattr(dog1, 'score', 100)) # 100

c.方式三：對象. _ _ getattribute _ _ (屬性名)

獲取指定對象的指定屬性偶翅。如果屬性不存在就會報錯。

print(dog1.__getattribute__('name'))  # 恭喜發(fā)財

2.改（修改）

a.方式一：對象.存在的屬性=新值

dog1.name = '小黃'
print(dog1.name)  # 小黃

b.方式二：setattr(對象毙驯，存在的屬性名倒堕，新值)

setattr(dog1, 'name', '小白')
print(dog1.name)  # 小白

c.方式三：對象. _ _ setattr _ _ (存在的屬性名，新值)

dog1.__setattr__('name', '小黑')
print(dog1.name) # 小黑

3.增（對象添加屬性）

• python中可以動態(tài)的給對象添加屬性爆价。

a.方式一：對象.不存在的屬性=值

dog1.sex = '公'
print(dog1.sex)  # 公

b.方式二:setattr(對象垦巴，不存在的屬性名媳搪，值)

setattr(dog1, 'he', 'dagoou')
print(dog1.he)  # dagoou

c.方式三：對象. _ _ setattr _ _ (不存在的屬性名，值)

dog1.__setattr__('hehe', '無語')
print(dog1.hehe)  # 無語

4.刪除屬性

a.方式一：del 對象.屬性

# 將dog1的age屬性刪除
del dog1.age

b.方式二：delattr(對象骤宣，屬性名)

delattr(dog1, 'hehe')

c.方式三：對象._ _ delattr _ _ (屬性名)

dog1.__delattr__('he')

5.判斷對象是否擁有某個屬性

• 方式：hasattr(對象秦爆，屬性名)--->判斷指定的對象是否擁有指定的屬性

    print(hasattr(dog1, 'age'))   # False
    print(hasattr(dog1, 'name'))  # True
  

• 示例1：對象屬性的操作只對當前那一個對象有效

    class Person:
        def __init__(self,name ='',age=0,id_num='',sex=''):
            self.name = name
            self.age = age
            self.id_num = id_num
            self.sex = sex
    p1 = Person('小明', 10)
    # 給不存在的屬性賦值，就是添加屬性
    p1.score = 100
    print(p1.score+100)   # 200
    p2 = Person('小黃', 20)

• 注意：

  1.對對象屬性的增憔披、刪等限、改、查是針對指定的那一個對象芬膝，不會影響其它的對象望门。
  2.實際開發(fā)用的時候，一般只用獲取對象屬性的值和修改對象屬性的值锰霜。想要添加和刪除屬性一般都是在init方法中去操作筹误。

• 通過給 _ _ slots _ _ 賦值，可以限制類中對象的屬性有哪些癣缅，防止一些不必要的屬性被添加

    class Dog:
        __slots__ = ('name', 'age', 'color')
        def __init__(self, name='',age=0,color=''):
            self.name = name
            self.age = age
            self.color = color
            # self.sex = '公'  #報錯厨剪，因為__slots__中沒有'sex'
    dog1 = Dog('小白',3,'yellow')
    
    練習題看6.27課堂筆記
  

三十三、內(nèi)置類屬性

class Dog:
    """狗"""
    def __init__(self,name='',age=0,color=''):
        self.name = name
        self.age = age
        self.color = color
    def run(self):
        print('%s跑起來了'%(self.name))
    def shout(self):
        print('%s在叫喚'%(self.name))
dog1 = Dog()

• 內(nèi)置類屬性是屬于類的友存，需要通過類去使用

a. 類. _ _ name _ _ :獲取類的名字(只有類有這個屬性)

print(Dog.__name__)   # Dog

b. 類. _ _ doc _ _ :獲取類的說明文檔

print(Dog.__doc__)   # 狗

c. _ _ dict _ _

類. _ _ dict _ _ :獲取類中所有的類屬性（類字段）和對應的值的鍵值對--->結(jié)果是字典
對象. _ _ dict _ _ :以鍵值對的形式獲取指定對象的所有的屬性和值

print(Dog.__dict__)
print(dog1.__dict__)  # {'name': '', 'age': 0, 'color': ''}

e. 類. _ _ module _ _ :獲取類所在的模塊的名字

print(Dog.__module__)  # __main__

f. 類. _ _ bases _ _ :獲取指定類的基類

print(Dog.__bases__)   # (<class 'object'>,)

三十四祷膳、類和對象

1、屬性私有化

• 屬性的訪問權(quán)限：公開屡立、保護(python中沒有)直晨、私有

• 公開: 指的是在類的外部可以直接使用（默認）

• 公開屬性：屬性名是普通單詞(就是不以兩個下劃線開頭的屬性)

• 私有：只能在類的內(nèi)部直接使用

• 私有屬性：屬性名以兩個下劃線開頭（不以兩個下滑線結(jié)束）

• 私有屬性不能在類的外部去使用

    class Person:
        """人"""
        def __init__(self, name='', age=0):
            # name屬性是公開的屬性
            self.name = name
            # __age屬性是私有的屬性
            self.__age = age
        def show(self):
            print(self.name)
            # 私有屬性可以類的內(nèi)部使用
            print(self.__age)
    p1 = Person('小明')
    print(p1.name)
    # print(p1.__age)  # AttributeError: 'Person' object has no attribute '__age'
    p1.show()
  

2、假的私有屬性

• 實際開發(fā)中侠驯，聲明類的屬性抡秆，很少會使用真正的私有屬性和公開屬性(前面加兩個下滑線的)。

• 實際對屬性的要求：

  a.可以通過點語法方便的來給屬性賦值或者拿到它的值（不能是私有的）
  b.給屬性賦值的時候吟策，需要對賦過來的值進行規(guī)范儒士，不能直接就讓值賦給屬性(不能是直接的公開屬性)

• 滿足要求: 就使用假的私有屬性 + getter和setter

  a.聲明屬性，屬性名前加一個下劃線（這個是規(guī)范檩坚，不是語法：帶一個下劃線的屬性着撩，不要直接通過一個下劃線對應的屬性名去訪問這個屬性）
  b.通過給屬性添加getter和setter來限制賦值和獲取值的過程

  添加getter: --> 限制獲取屬性值的操作

• getter的作用：返回屬性的值

    @property
    def 屬性名去掉下劃線(self):
        其他任何操作
        return self.帶下劃線的屬性名
        
    @屬性名去掉下劃線.setter
    def 屬性名去掉下劃線(self, 參數(shù)):
        其他任何操作
        self.帶下劃線的屬性名 = 參數(shù)
  

  c.在類的外部通過不帶下劃線的屬性去獲取屬性的值，或者給屬性賦值

    class Person:
  

• getter一般要添加匾委， setter可以不用寫

• 如果要添加setter必須添加getter

    示例二：getter和setter的使用以及關系
    class Cat:
        """貓"""
        def __init__(self, name='', color=''):
            self._name = name
            self._color = color
        @property
        def name(self):
            if isinstance(self._name, str):
                return self._name
            else:
                return ''
        @name.setter
        def name(self, name):
            self._name = name
     cat1 = Cat('小花', 'yeloow')
     cat1._name = '喵喵'  # 推薦
     print(cat1._name)  # 不推薦
  

3拖叙、類字段和類方法

• 類字段就是類屬性：通過類去獲取

  類字段是聲明在類里面，函數(shù)外面的變量

• 類方法：通過類去調(diào)用

  開發(fā)中怎么確定聲明稱方法是對象方法還是類方法：看實現(xiàn)的功能是否需要對象屬性來支持赂乐，如果需要就必須聲明稱對象方法

• @classmethod來說明下面的函數(shù)是一個類方法 --> 函數(shù)修飾符

• 所有的類方法都有一個默認參數(shù)cls,這個參數(shù)不需要傳參薯鳍，系統(tǒng)會自動將調(diào)用方法的類傳給它(誰調(diào)用指向誰)

    class Person:
        """人類"""
        # 這個person_num就是一個類字段
        person_num = 0
        @classmethod
        def hurt_earth(cls):
            print(cls)
            print('人類傷害破壞環(huán)境，傷害地球',  Person.person_num, cls.person_num)
  

• 類字段要用類去使用

     print(Person.person_num)
     Person.hurt_earth()
     print(Person)
     練習：寫一個數(shù)學類挨措，提供數(shù)據(jù)的加挖滤、減崩溪、乘、除的功能
     class Math:
        @classmethod
        def add(cls, *num):
            sum1 = 0
            for x in num:
                sum1 += x
            return sum1
     sum1 = Math.add(10, 2, 3)
     print(sum1)
  

4斩松、靜態(tài)方法

• 靜態(tài)函數(shù)：在類中聲明伶唯，由類來調(diào)用的方法

    示例一： 靜態(tài)方法
    class Math:
        """數(shù)學類"""
        # multiply就是一個靜態(tài)方法
        @staticmethod
        def multiply(num1, num2):
            return num1 * num2
  

• 靜態(tài)方法需要使用類來調(diào)用

     print(Math.multiply(10, 4))
  

• 靜態(tài)方法和類方法的區(qū)別：

  a.類方法都有一個默認參數(shù)cls指向調(diào)用方法的類，但是靜態(tài)方法沒有
  類型不一樣惧盹，靜態(tài)方法的類型是function乳幸，類方法的類型是method

5、類的繼承

• 繼承：繼承就是讓子類去擁有父類的屬性和方法

  子類：繼承者
  父類(超類)：被繼承者

• 什么時候用繼承：在寫一個類的時候钧椰，發(fā)現(xiàn)這個類中的部分屬性和方法另一個類都擁有粹断，這個時候就不用去聲明這些屬性和方法，直接從另外一個類中繼承下來就可以

    實例一：怎么繼承
    class 子類(父類):
        子類的內(nèi)容
    class Person:
        """人"""
        def __init__(self, name='aaa', age=0):
            self.name = name
            self.age = age
    class Student(Person):
        pass
    stu1 = Student()
    print(stu1.name)
  

• 可以繼承哪些東西演侯？

  a.公開屬性可以繼承
  b.私有的屬性不可以繼承
  c.公開的對象方法可以繼承（私有的不行）
  d.類字段可以繼承
  e.類的方法和靜態(tài)方法可以

• 總結(jié)：屬性和方法除了私有的都可以繼承; _ slots _不能繼承的

    class Animal:
        #1.對象的屬性
        __slots__ = ('name', '__age')
        def __init__(self, name='bb'):
            self.name = name
            self.__age = 18
        def run(self):
            print(self.__age)
        #2.對象方法
        def eat(self):
            print('吃東西')
        # 私有的對象方法姿染，只能類的內(nèi)部調(diào)用
        def __shout(self):
            print('叫')
        #3.類字段
            count = 100
        #4.類方法
        @classmethod
        def class_func(cls):
            print('class_func')
        #5.靜態(tài)方法
        @staticmethod
        def static_func():
            print('static_func')
     class Dog(Animal):
        pass
        # def eat_bone(self):
        # print('吃骨頭',self.__age)
     dog1 = Dog()
     print(dog1.name)
     dog1.eat()
     print(Dog.count)
     Dog.class_func()
     Dog.static_func()
     dog1.color = 'red'
     print(dog1.color)
  

6背亥、類的繼承重寫

• 聲明一個類秒际，如果不聲明其父類，那么這個類默認繼承自object這個類狡汉。

• object類是python中所有類直接或者間接的父類

• 示例一：什么是重寫

  重新實現(xiàn)從父類繼承下來的方法 ---> 重寫

    class Aniaml(object):
        def __init__(self, name):
            self.name = name
        def shout(self):
            print('%s:嗷嗷叫' % (self.name))
        def be_beat(self):
            print(self.name,'在跑')
            print('跑的時候嗷嗷叫')
    class Dog(Aniaml):
        # 重寫父類的shout方法娄徊。然后通過Dog對象調(diào)用shout執(zhí)行的是子類的方法
        def shout(self):
            print('%s:汪汪汪！'% (self.name))
        # 重寫父類的be_beat盾戴，保留了父類實現(xiàn)的功能寄锐，并且添加了新的功能
        def be_beat(self):
            # super()指的就是父類對象
            super().be_beat()
            print('奮起反抗')
  

• 示例2：init方法的繼承和重寫

  重寫init方法要注意：如果需要繼承父類的對象屬性，就需要通過super(). _ _ init _ _ ()去保留父類的對象屬性尖啡。然后再添加新的屬

    class Person:
        """人"""
        def __init__(self, name='', age=0):
            self.name = name
            self.age = age
     class Student(Person):
        """學生類"""
        def __init__(self, name='', age=0, study_id=''):
            super().__init__(name, age)
            self.study_id = study_id
     練習：設計兩個類：
     一個正方形類橄仆，擁有方法：求面積、求周長  擁有的屬性是邊長
     一個長方形類衅斩，擁有方法：求面積盆顾、求周長  擁有的屬性是長和寬
  
    class Rect:
        def __init__(self, length=0, width=0):
            self.length = length
            self.width = width
        def area(self):
            return self.width * self.length
        def perimeter(self):
            return (self.width + self.length)*2
    class Square(Rect):
        def __init__(self, length=0, width=0):
            super().__init__(length, width)
            self._side = 0
        @property
        def side(self):
            return self._side
        @side.setter
        def side(self, side):
            self.width = side
            self.length = side
            self._side = side
  

三十五、類和對象

1畏梆、類的多態(tài)

• 多態(tài)：就是一個事物有多種形態(tài),繼承就會產(chǎn)生多態(tài)

• 類的多態(tài):通過繼承您宪，同一個方法可以有多種實現(xiàn)

    class Animal:
        def shout(self):
            print('嗷嗷叫')
    class Cat(Animal):
        def shout(self):
            print('喵喵叫')
    class Dog(Animal):
        def shout(self):
            print('汪汪叫')
    animal1 = Animal()
    animal1.shout()   # 嗷嗷叫
    cat1 = Cat()
    cat1.shout()   # 喵喵叫
    dog1 = Dog()
    dog1.shout()   # 汪汪叫
  

2、運算符的重載

• 類中可以通過實現(xiàn)相應的魔法方法奠涌，來實現(xiàn)對象的比較運算（<宪巨、>）和加減運算（+、-）

• 實現(xiàn)后就可以通過運算符'>'和'<'來判斷對象的大小溜畅。通過'+'和'-'來求兩個對象的和和差

• 怎么重載：

    > --> __gt__
    < --> __lt__
    + --> __add__
    - --> __sub__
    
    class Student:
        def __init__(self, name='', age=0, score=0):
            self.name = name
            self.age = age
            self.score = score
            # 重載'>'符號
            # 對象1 > 對象2
            # self ->對象1捏卓；other -> 對象2
        def __gt__(self, other):
            # 怎么實現(xiàn)就看怎么判斷大于的
            return self.age > other.age
        # 重載'<'符號
        def __lt__(self, other):
            return self.score < other.score
            # 說明：如果大于比較和小于比較的內(nèi)容是一樣的，只需要重載其中的一個符號就可以了
            # 重載'+'
        def __add__(self, other):
            return self.score + other.score
            # 重載'-'
        def __sub__(self, other):
            return self.score - other.score
    stu1 = Student('小明', 18, 90)
    stu2 = Student('小花', 20, 80)
    stu3 = Student('aa',23,67)
    print(stu1 > stu2)  # False
    print(stu1 - stu2)  # 10
    print(stu1 + stu2)  # 170
  

3慈格、多繼承

• python支持多繼承

    class Animal:
        def __init__(self,age=0,name=''):
            self.age = age
            self.name = name
    
    class Fly:
        def fly(self):
            print('飛起來')
            # Bird類同時繼承Animal類和Fly類
    class Bird(Animal,Fly):
            pass
    bird1 = Bird()
    print(bird1.age)
    bird1.fly()
  

• 注意：實際開發(fā)中怠晴，不到萬不得已不建議使用多繼承

4贿肩、對象的內(nèi)存管理

• 對象值是存在堆中的，python自動去回收的

• 掌握：對象到底什么時候才會被銷毀（回收）

• 棧中的內(nèi)存是系統(tǒng)自動創(chuàng)建自動銷毀的龄寞，不需要管理汰规。平時說的內(nèi)存管理指的是對堆中的內(nèi)存的管理。

• python中能夠存到堆里面的數(shù)據(jù)物邑，全是對象

• python中管理內(nèi)存的機制：

  python是通過引用計數(shù)來管理內(nèi)存的：就看一個對象的引用計數(shù)的值是否為0溜哮，為0就銷毀
  讓一個變量存儲對象的地址，那么這個變量就是對象的一個引用色解；如果變量存別的值或者刪除這個變量茂嗓，都會讓這個引用消失。

• 應用：如果想要對象提前被銷毀科阎，就刪除其所有的引用

    class Person:
        def __init__(self,name='', age=0, scores=[]):
            self.name = name
            self.age = age
            self.scores = scores
    p1 = Person()
  

• p1是一個變量述吸，變量存的是對象的地址；變量p1本身是在棧里面的

• Person()返回值才是對象

6锣笨、包的應用

• 函數(shù) --->對實現(xiàn)功能的代碼的封裝
• 類 --->對屬性和方法進行封裝
• 模塊 --->對多個函數(shù)或者多個類進行封裝
• 包 --->對多個模塊進行封裝
• 舉例：對時間操作的相關功能

  1.日期對應的時間（年月日 -> 獲取當天的時間/獲取指定哪一天對應的星期/計算哪一年是閏年）
  2.時分秒（秒鐘/計算小時數(shù)/分數(shù)/時間相加）
  3.時間戳（時間轉(zhuǎn)換蝌矛、時間加密）

• 通過 from - import - 或 import - 導入包的內(nèi)容

三十六、pygame

import pygame

1.初始化

pygame.init()

2.創(chuàng)建窗口

• set_mode((寬错英，高)) --->單位是像素

    screen = pygame.display.set_mode((600, 400))
  

3.設置填充顏色

• 顏色值（是由計算機的三原色組成-->紅入撒、綠、藍）椭岩，簡稱RGB茅逮。我們能使用的所有的顏色都可以通過RGB值來表示。
• RGB值的表示方式：

  a.（red值判哥，green值献雅，blue值）值都是數(shù)字：0-255 (255,0,0)->紅色 （255,255,255）->白色
  b.十六進制的RGB值 #ff0000->紅色 #000000->黑色 #00ff00->綠色
  screen.fill((233, 233, 233))

4.顯示圖片/文字/圖形

1、顯示圖片

a.創(chuàng)建一個圖片對象

image = pygame.image.load('./files/1.jpg')

b.獲取圖片的大小

• (width,height) = 圖片對象.get_size()

    print(image.get_size())
  

c.對圖片進行縮放

• 將指定的圖片塌计，變成指定的大小挺身，返回一個新的圖片對象

• pygame.transform.scale(圖片對象, (寬度, 高度)

    image1 = pygame.transform.scale(image, (300, 200))
  

d.對圖片進行旋轉(zhuǎn)

• pygame.transform.rotate(圖片對象,旋轉(zhuǎn)角度)

• 角度：0-360的度數(shù)值

    image2 = pygame.transform.rotate(image1, 90)
  

e.對圖片進行旋轉(zhuǎn)縮放

• pygame.transform.rotozoom(圖片對象, 縮放角度, 縮放倍數(shù))

    image3 = pygame.transform.rotozoom(image2, 270, 0.8)
  

d.將對象添加到窗口對象中

• blit(需要添加到窗口的對象,坐標)

    screen.blit(image3, (150, 100))
  

2、顯示文字

a.創(chuàng)建字體對象

• SysFont(系統(tǒng)字體大小夺荒，字體大小)

• pygame.font.Font(字體文件地址瞒渠，字體大小)

    # font = pygame.font.SysFont('Times', 50)
    font = pygame.font.Font('./files/aa.ttf', 50)
  

b.根據(jù)字體創(chuàng)建文字對象

• font.render(文字，是否平滑技扼，顏色)

    text = font.render('hello python, 你好 世界伍玖！', True, (255, 0, 0))
  

c.將文字對象添加到窗口上

screen.blit(text, (80, 170))

3、畫圖形

a.畫線

• line(外觀對象剿吻，線的顏色窍箍，起始點，終點,線的寬度)

    pygame.draw.line(screen, (0, 0, 255), (100, 100), (300, 100), 5)
    pygame.draw.line(screen, (0, 0, 255), (100, 200), (300, 200), 5)
  

• lines(外觀對象，線顏色椰棘，是否閉合纺棺，點的列表)

• 第三個參數(shù)：False-->不閉合 ； True-->閉合

    pygame.draw.lines(screen, (255, 0, 0), True, [(10,40),(60,40),(30,80)],3)
  

b.畫矩形

• pygame.draw.rect(外觀對象, 顏色, 范圍, 線寬 )
• 范圍：告訴位置和大小-->(x,y,width,height)
• 線寬：線寬為0時就會填充矩形
  pygame.draw.rect(screen, (0, 255, 0),(300,200,100,80) ,0 )

c.畫弧線

• pygame.draw.arc(外觀對象邪狞，顏色祷蝌，范圍，起始角度帆卓，終止角度巨朦，線寬)

    from math import pi
    pygame.draw.arc(screen, (255, 255, 0), (150, 100, 200, 200), pi/2, pi, 3)
  

4.顯示在屏幕上

pygame.display.flip()
# pygame.display.update()

5.讓窗口停留

while True:
    for event in pygame.event.get():
        # 關閉事件
        if event.type == pygame.QUIT:
            exit()
        # 鼠標按下事件
        if event.type == pygame.MOUSEBUTTONDOWN:
            # 獲取鼠標按下的位置
            print(event.pos)
            print('鼠標按下')
        # 鼠標彈起事件
        if event.type == pygame.MOUSEBUTTONUP:
            # 獲取鼠標彈起的位置
            print(event.pos)
            print('鼠標彈起')
        # 鼠標移動事件
        if event.type == pygame.MOUSEMTTON:
            print('鼠標移動')

三十七、正則表達式

• 正則表達式主要用于字符串查找剑令、匹配和分割

1糊啡、正則符號

不帶任何正則符號的正則表達式
.--> 匹配任意的字符
\w-->匹配字母、數(shù)字吁津、下劃線
\s-->匹配空白字符（包括空格(\r)棚蓄、制表符(\t)和回車(\n)等）
\d-->匹配數(shù)字
\b-->匹配單詞邊界（字符串的開始和結(jié)束、空白碍脏、標點符號梭依、括號、~等）

• 注意：\b是不能匹配出結(jié)果的潮酒，只是對需要出現(xiàn)的邊界的要求(遇到\b的時候一定要注意\b后面的字符必須是單詞的邊界才會成功)

^ -->匹配開頭
$ -->匹配字符串結(jié)束
\相應的大寫字母-->\相應的小寫字母的功能取反
[]-->匹配[]中任意的一個字符

• []中可以是任意的字符睛挚，也可以是正則符號.一個[]只能匹配出一位字符

[^]-->匹配不在[]中的任意的一個字符
' * '' -->匹配0次或者多次
'+'' --> 匹配1次或者多次
'?'' -->匹配0次或者1次
{N}-->匹配N次
{M,}-->匹配至少M次
{M,N}-->匹配至少M次，最多N次
| -->分之（相當于邏輯運算符中的or）
'?'' -->重復任意次急黎，盡可能少的匹配
print(re.match(r'a?', 'aaabcd')) # match=''
+? --->重復一次或者多次，盡可能少的匹配

• 總結(jié)侧到？:就是在重復多次的匹配總?cè)绻竺婕硬蹋浚ヅ涞臅r候以能匹配的最少次數(shù)去匹配

• 注意：正則表達式中如果需要使用有特殊功能的字符匠抗，需要使用''進行特殊說明

    . --> \.    * --> \*    + --> \+   [ --> \[   ] --> \]
  

• []字符集中的特殊字符不需要加''來說明其為一個普通字符功能

2故源、正則函數(shù)

a. compile:將正則表達式字符串編譯成正則對象（就可以去調(diào)用相關的正則表達式對象方法）

import re
result = re.compile(r'\d\d[a-zA-Z]{2}')
print(type(result))  # <class '_sre.SRE_Pattern'>

b. match

1. re.match(正則表達式字符串/對象，要匹配的字符串)
2. 正則表達式對象.match(要匹配的字符串)

• 用指定的正則表達式和指定的字符串進行匹配汞贸，如果匹配成功就返回匹配對象绳军，否則返回None

    result = re.match(r'a\dd.', 'a2dlhuhh')
  

• 獲取匹配結(jié)果在原字符串中的范圍

    print(result.span())   # (0, 4)
  

• 獲取匹配開始的位置和結(jié)束的位置

    print(result.start(), result.end())   # 0 4
  

• 獲取匹配的結(jié)果

    print(result.group())   # a2dl
  

• 獲取原字符串

    print(result.string)  # a2dlhuhh
  

c. search

1. re.search(正則表達式/對象，指定的字符串)
2. 對象.search(指定的字符串)

• 在指定的字符串中矢腻，去查找第一個指定正則表達式匹配的字符串.如果找到了就返回匹配對象门驾，否則返回None

    result = re.search(r'a\dc', 'wfwfa3cdef')
    print(result)  # <_sre.SRE_Match object; span=(4, 7), match='a3c'>
  

d. findall

re.findall(正則表達式/對象,指定的字符串)

• 獲取指定字符串中，所有滿足正則表達式的子串多柑。返回值是一個列表奶是。

    result = re.findall(r'a\dc', 'dwa3cfffwa7cdw')
    print(result)   # ['a3c', 'a7c']
    練習：獲取一個字符串中所有以'ing'結(jié)束的單詞
    result = re.findall(r'[a-zA-Z]*ing\b', 'I love singing and dangcing')
    print(result)
  

e. split

1. re.split(正則表達式/對象,指定的字符串,最大拆分數(shù))

最大拆分數(shù)：拆分數(shù)量，默認是0. 0-->代表全部拆分

2. 正則對象.split(指定的字符串)

result = re.compile(r'[,\s]').split('abc,bcd,amm,ssff affefe erefef')
print(result)
result = re.compile(r'[，聂沙。]').split('床前明月光秆麸，疑是地上霜。舉頭望明月及汉，低頭思故鄉(xiāng)沮趣。')
del result[-1]
print(result)  # ['床前明月光', '疑是地上霜', '舉頭望明月', '低頭思故鄉(xiāng)']

f. sub

re.sub(正則表達式，替換字符串坷随，原字符串)-->替換后原字符串不變兔毒，返回一個新的字符串

• 將指定字符串中的指定的子串替換成其它的字符串

    刪除字符串'abdf nbdafwfwffwaalmlafkle'中的'a'和'b'
    result = re.sub(r'[ab]', '', 'abdf nbdafwfwffwaalmlafkle')
    print(result)
  

• 注意：正則表達式中有分組，findall的時候甸箱，只獲取匹配結(jié)果中和分組內(nèi)容相匹配的內(nèi)容育叁。

三十八、獲取網(wǎng)絡數(shù)據(jù)

• python中使用第三方庫requests來獲取網(wǎng)絡數(shù)據(jù)

    import requests
  

1. 確定請求的地址(url)

• GET傳參的兩種方式：

  a.直接拼接在url后面（?參數(shù)1=值&參數(shù)2=值2....）
  b.給get函數(shù)中的第二個參數(shù)傳參（{參數(shù):值, 參數(shù)2:值2...}）

  # url = 'https://www.apiopen.top/satinApi?type=1&page=1'
  url = 'https://www.apiopen.top/satinApi'
  

2.通過GET方式請求數(shù)據(jù),請求結(jié)束后會返回響應

response = requests.get(url,{'type': 1, 'page': 1})

3.獲取數(shù)據(jù)內(nèi)容

a.獲取字符串形式的數(shù)據(jù)

print(type(response.text), response.text)

b.獲取json格式的數(shù)據(jù)

reslut = response.json()
print(type(reslut), reslut)

c.獲取二進制形式的數(shù)據(jù)

data = response.content
print(type(data), data)

三十九芍殖、socket _ sever

• socket又叫套接字豪嗽，我們把進行網(wǎng)絡通信的一段就叫一個套接字

• socket編程，就是通過程序?qū)崿F(xiàn)通信的兩端（服務器和客戶端）

• python中支持socket有三種豌骏，分別是基于TCP龟梦、UDP和IP的，叫做TCP套接字窃躲、UDP套接字和原始套接字

    import socket
  

• 基于TCP的服務器端

1.創(chuàng)建套接字對象计贰，并且指定服務類型

• family:

    AF_INET-->ipv4
    AF_INET6-->ipv6
  

• type:

    SOCK_STREAM-->TCP
    server = socket.socket(family=socket.AF_INET,type=socket.SOCK_STREAM)
  

2.綁定IP地址和端口

• 地址：(IP地址，端口)

• IP地址：服務器所在的硬件的IP地址

• 端口：不同的端口綁定不同的服務蒂窒，同一個時間同一個端口只能綁定一個服務

• 端口的范圍0-65535躁倒，但是小于等于1024的端口叫“著名端口”，用于綁定著名服務（比如http服務洒琢，郵件服務等）秧秉，最好不要用

    server.bind(('10.7.154.101', 16345))
  

3.監(jiān)聽訪問

server.listen()
print('開始監(jiān)聽....')
# 讓服務器一直運行，等待訪問
while True:
    # 當有客戶端訪問當前服務器后就建立連接
    connet, addr = server.accept()  # 當有一個客戶端來連接當前服務器的時候才會執(zhí)行
    print('=========')
    while True:
        # 通過會話給客戶端發(fā)送消息
        # 發(fā)送的內(nèi)容必須是二級制數(shù)
        #字符串轉(zhuǎn)二進制：字符串.encode('utf-8')
        #二進制轉(zhuǎn)字符串：二進制數(shù)據(jù).decode('utf-8')
        message = input('>>>')
        connet.send(message.encode('utf-8'))
        # 接收客戶端發(fā)送給服務器的消息
        data = connet.recv(1024)
        print(data.decode('utf-8'))
    # 關閉連接
    # connet.close()

四十衰抑、socket _ 客戶端

import socket

1.創(chuàng)建套接字對象

client = socket.socket(family=socket.AF_INET,type=socket.SOCK_STREAM)

2.連接服務器

client.connect(('10.7.154.62', 12346))
while True:

3.接收服務器返回的數(shù)據(jù)

• 1024是接收數(shù)據(jù)的大小

    data = client.recv(1024)
    print(data.decode('utf-8'))
  

4.給服務器發(fā)送數(shù)據(jù)

message = input('>>>')
client.send(message.encode('utf-8'))