python基礎學習筆記

伺服器

1.ftp伺服器

        FTP是FileTransferProtocol（檔案傳輸協定）的英文簡稱，中文名稱為“文傳協定”。用于Internet上的控制檔案的雙向傳輸。同時，它也是一個應用程式。基于不同的作業系統有不同的FTP應用程式，而所有這些應用程式都遵守同一種協定以傳輸檔案。

        在FTP的使用當中，常遇到兩個概念：“上傳”“下載下傳”。

2.samba伺服器

        Samba是在linux和UNIX系統上實作一個免費軟體，能夠完成在windows，mac作業系統下通路linux系統下的共享檔案。

3.ssh伺服器

        SSH為建立在應用層和傳輸層基礎上的安全協定。是目前較可靠，專為遠端登入會話和其他網絡服務提供安全性的協定，常用于遠端登入，以及使用者之間進行資料拷貝。可有效防止遠端管理過程中的資訊洩漏問題。

python２與３的差別

1.在python2版本中，一般在代碼中不能識别中文字元，但必須 在開頭處頂格寫上#coding=utf-8(編碼），不過python推薦#-*-coding:utf-8 -*-

2.在python2中，對象輸入時為raw_input()函數，而python3隻有input()函數

3.python2裡面，input時輸入3+4會自動轉為公式執行，而python3則傳回一個字元串"3+4"，如果python2要改成字元串輸出就要用raw_input

3.關鍵字                               if/else/for/break/inport/class/def/None/not/in/from/return/elif/continue/while/and/or/True/False/try/except/finally/as/global/lambda,pass,raise,del

python的文法

1. print：print(“age變量裡的值是%d”%age)　　（print(“%d”%i)#print(i)

    print(“name變量裡的值是%s”%name)

    print(“Love”*5)　（可以重複字元串）

    print(“姓名是：%xx，年齡是：%xx”%(name,age))　（同時列印多個變量）

    print(“*”,end “ ”) （print列印之後不換行）

    print(“ ”)　（列印之後換行）

    在print語句中，字元串後面會預設接一個\n符号，即換行，但是如果要在一個字元串後面跟着逗号，換行就被取消，例如：

            for i in [1,2,3,4,5]

                print i  #列印一個即換行

                print i, #列印一個不換行

2.\t:表示一個tab鍵，它不會換行

3.駝峰命名法（目的：增強目的的可讀性）

    englishScore= 100 （小駝峰法）

    EnglishScore= 100（大駝峰法）

    english_score= 100（推薦）

4.比較運算符

    ==,!=,<>（不等于）,>,<,>=,<=

5.算數運算符

    +,-,*,/,//（取整）,%（取餘），**（幂運算）

6.邏輯運算符

    and,or,not

7.程式的3大執行流程

• 順序執行
• 選擇執行
• 循環執行

8.if-else（判斷兩件）

    if條件:

        條件滿足的語句

    else:

        條件不滿足的語句

9.if-elif（判斷多件）

    if條件1：

    elif條件2：

    elif條件3：

10.while　循環

        while　條件：

            條件滿足的時候執行的事情　

11.for 循環

        for　變量名　in　name:

12.break，continue和return

         break的含義是要在這個地方中斷循環，并跳出循環體

         continue是從目前位置跳到最後一行的後面，不執行最後一行，對一個循環體而言，如同首尾銜接一樣

        return在函數中，使用單個的return，并不是傳回一個值，而是結束正在執行的函數，有點類似循環中的break作用

13.交換兩個變量的方式

        第一種：需要第三個變量

        a=3

        b=4

        c=0

        c=a

        a=b

        b=c

        第二種：不需要第三個變量

        a=a+b    

        b=a-b

        a=a-b

        第三種：不需要第三個變量

        a,b= b,a

14.檢視對象的記憶體的位址：id（對象）

15.檢視對象的類型：type（對象），對象有類型，變量無類型

16.整數溢出問題

        在某些程式設計語言中，整數溢出是必須正視的，但是在python裡面就無需憂愁，原因就是它支援“無限精度”的整數，即不用考慮整數溢出的問題，int類型與任意精度的long整數類可以無縫轉換，超過int範圍的情況都将轉換成long類型

17.内建函數

• divmod(5,2)  #傳回商和餘數
• round(1.12345,2) #第二個數表示四舍五入小數位數
• abs(-10) #求絕對值

18.常用數學函數（乘方，開方，對數運算，需導入math子產品）

• dir(math)能顯示math子產品的所有内置函數
• help(math.pow)能顯示該内建函數的用法
• dir()和help()對學習子產品很重要

19.格式

    #!/usr/bin/env python #引導程式找到python解析器

    #_*_ coding:utf-8 _*_  #編碼格式utf-8

20.cmp(str1,str2)比較

• 傳回的數值小于0,說明第一個str1小于str2
• 傳回的數值等于0,說明第一個str1等于str2
• 傳回的數值大于0,說明第一個str1大于str2

21.ASCII與字元的轉換

        ord():将單個字元轉換為ASCII,ord('a') = 97

        chr():将ASCII轉換為單個字元，chr(97) = 'a'

21.三元操作符

        A = Y if x else Z

        如果x為真，那麼執行A=Y

        如果x為假，那麼執行A=Z

字元串

1.cpu，記憶體，硬碟

        cpu讀寫快，但存儲小。而硬碟讀寫慢，但存儲大。是以誕生了記憶體這一概念位于二者之間

2.數字和字元串的存儲    

        如果是一個數字可以用一個位元組存儲，如果是字元串則不管雙引号内是什麼都要單獨占一個位元組

3.組成字元串的2種方式

        第一種：A= “lao” B=“wang” C=A+B

        第二種：C=“===%s===”%(A+B)

4.字元串中的下标

        name=“abcdef” name[0]=“a” name[-1]=“f” name[6]=xxx（越界導緻異常）

6.字元串切片和逆序

        切片：name=“abcdef” name[2:5]=“cde”

        跳取：name=“abcdef” name[2:-1:2]=“ce”

        逆序：name=“abcdef” name[-1::-1]=“fedcba”

7.字元串的常見操作

        myStr= “hello world itcast and itcastxxxcpp”

        輸入：myStr.find(“world”) 輸出：6（6表示從左邊算起w的下标）

        輸入：myStr.find(“feige”) 輸出：-1（-1表示沒有該字元串）

        輸入：myStr.rfind(“itcast”) 輸出：23（23表示從右邊開始查找，但是下标仍是 左邊開始計算）

        輸入：myStr.index(“feige”) 輸出：程式異常（index與find相似，差別隻是當搜 索字元串不存在時，index會異 常，而find會輸出-1）

        輸入：myStr.count(“itcast”) 輸出：2（2表示count計數到itcast有兩次）

        輸入：myStr.count(“feige”) 輸出：0（要是發現不到該字元串就輸出計數為0）

        輸入：myStr.replace(“world”,“World”) 輸出：“helloWorld itcast and itcast...”（此處隻會改變輸出結果，但不會對原字元串myStr改變）

        輸入：myStr.replace(“itcast”,“xxx”,1)輸出：“helloworld xxx and itcastxxxcpp”(1表示替換一個itcast，如果沒有1則表示itcast全部替換xxx）

        輸入：myStr.split(“”) 輸出：[“hello”,“world”,“itcast”,“and”,“itcastxxxcpp”]（字元串分隔切片）

        輸入：myStr.split(“”,2) 輸出：[“hello”,“world”,“itcastand itcastxxxcpp”]

        輸入：myStr.capitalize() 輸出：“Helloworld itcast and itcastxxxcpp”（把字元串的第一個字元大寫）

        輸入：myStr.title() 輸出：“HelloWorld Itcast And Itcastxxxcpp”（把字元串的每個單詞首字母大寫)

        輸入：myStr.center(50) 輸出：“ helloworld itcast and itcastxxxcpp ”（返 回一個原字元串居中）

        輸入：myStr.partition(“itcast”) 輸出：（“helloworld”,“itcast”,“anditcastxxxcpp”）（将字元串分隔成三部分，itcast前和itcast和itcast後）

        輸入：myStr.rpartition(“itcast”) 輸出：（“helloworld itcast and ”,“itcast”,“xxxcpp”）（從右邊開始算，将字元串分成三部分）

        file_name =“xxx.txt”

        輸入：file_name.endswith= “.txt” 輸出：True （判斷字尾是不是obj結束）

        name =“wang xxx”

        輸入：name.startswith= “wang” 輸出：True （判斷字首是不是obj開頭）

         myStr =“HELLO world itcast and itcastcpp”

        輸入：myStr.lower() 輸出：“helloworld itcast and itcastcpp”（轉換字元串中所 有大寫字元為小寫）

        輸入：myStr.upper() 輸出：“HELLOWORLD ITCAST AND ITCASTCPP”（轉換字元串中所有小寫字元為大寫）

        輸入：myStr.strip()輸出：“HELLOworlditcastanditcastcpp”（删除所有空格，lstrip删除左邊所有空格，rstrip删除右邊所有空格）

         myStr =“hello”

        輸入：myStr.rjust(10) 輸出：“ hello”（傳回一個原字元串右對齊，ljust為 左對齊）　

        myStr =“hello\nworld”

        輸入：myStr.splitlines() 輸出：[“hello”,“world”]（傳回一個包含各行作為元素的 清單）

        myStr =“abc”

        輸入：myStr.isalpha() 輸出：True（用于判斷字元串是否為純字母）

        輸入：myStr.isdigit() 輸出：false（用于判斷字元串是否為純數字）

        輸入：myStr.isalnum() 輸出：True（用于判斷字元串是否為純數字或純字母）

        輸入：myStr.isspace() 輸出：False（用于判斷字元串是否為純空格）

        a =[“aaa”,“bbb”,“ccc”]          b=“=”

        輸入：b.join(a) 輸出：“aaa=bbb=ccc”（a中的每個字元用b來連接配接）

8.替換某些字元串為其他字元的解決思路：

        答：我們知道字元串是不可變類型，是不能直接就改的，那麼就先要将其轉化為清單，然後在循環中找到該元素，通過清單進行更改

                如：for i,string in enumerate(list):

                           if string == "love":

                               list[i]="automn"

清單

1.定義一個清單

        names= [“老王”，“老蔣”，“老李”]（與c語言數組不同的是它可以存儲不同的資料類型）

2.增删改查

        增：names.append(“老趙”)　names=[“老王”，“老蔣”，“老李”，“老趙”] （末尾）

               names.insert(0,“八戒”)　names=[“八戒”，“老王”，“老蔣”，“老李”]（插隊）

               names.extend(names1) 将names1的清單元素加到names中（合并）

               append和extend:

               a.append(b)相當于把b作為一個整體扔到a

               a.extend(b)相當于把b合并到a中

        删：names.pop() 　删除清單最後一個元素

                names.remove(“老王”)　删除清單中的老王，且隻能從左邊開始删除一次

                del names[0] 根據清單序号删除

               坑！在删除元素的時候：

                num = [11,22,33,44,55,66]

                for i in num:

                        if i == 33 or i == 44:

                            num.remove(i)

       此時的結果是num = [11,22,44,55,66]，即出現了漏删的情況，因為删完33時，44往前挪一位，即跳過了它，要想避免漏删就要在這個外面加上一個while True死循環

         也可以把要删的全部組合成另一個清單b，然後一個for循環，for i in b:     num.remove(b)

        改：names[0]=“老劉”根據清單序号改動元素

        查：if“老王”in names:

                    print(“找到了……”)

                     if “老王”not in names:

                     print（“可以添加老王……”）

            list.count("laowang")   #統計出某個元素在該list中出現的次數

            list.index("laowang")   #傳回元素的下标序号，如果沒有就報錯

            list.insert(i,x)  #傳遞兩個參數，i表示序号，x表示參數

            list.sort(cmp=None,key=None,reverse=False)  #預設從大到小，key=len就是長度

            同時得到元素索引和元素的解決思路：

                seasons = ["spring","summer","automn","winter"]

                list(enumerate(seasons))

3.while-for循環周遊清單

            while:

                whilei<5:

                    print(nums[i])

                    i+=1

      可以使用len(nums)來測清單元素

            for:（推薦）　

                for temp in nums:

                    print(temp)

4.13.for-else（for循環裡的東西全部周遊完之後，才會執行else裡的代碼）

            for temp in nums:

                print(temp)

            else:

                print(“＝＝＝＝＝＝＝＝”)

5.sort的用法

    list.sort(cmp = None,key = None,reverse = False)

    reverse=True就是從大到小，key=len就是長度劃分，reverse=True就是清單倒序

6.清單和字元串的相同點：索引，切片，合并

7.清單和字元串的不同點：在字元串中，每個元素隻能是字元，在清單中，元素可以任意類型

8.清單和字元串最大的差別：清單可以改變，字元串不能改變

9.清單和字元串的轉化：

     line.split("  ")可以使字元串以空格方式隔開并以清單存放，".".join(name)清單可以用"."來連接配接清單的元素

10.清單與元組可以用list()和tuple()互相轉化

字典

1.定義一個字典

        infor= {“name”:“班長”，“addr”：“山東”，“age”:“18”}

        print(“%s%s %d”%(infor[“name”],infor[“addr”],infor[“age”]))

        增：增加一個新的鍵值對

                infor[“name”]= banzhang（隻要鍵值不存在，賦予一個值就是增加）

               d1.update(d2) ：把字典2更新納入字典1，但字典2依然存在

                還可以d2.update(["(name","qiwsir")]),注意是兩個小括号和一個大括号

        删：删除一個鍵值對

                del infor[“name”]（重複删除會導緻程式異常）

               infor.pop("key")，删除指定鍵和整個鍵值對，沒有則異常

               infor.popitem()，不用參數，但一定随機删除一個鍵值對

        改：修改一個鍵值對

                隻要這個鍵值存在，然後賦予新的值就是修改

        查：查詢一個鍵值對

               infor[“name”]（查詢不存在的鍵值會導緻程式異常）

                 推薦：infor .get(“name”)（存在則傳回值，不存在時則無傳回）

3.在清單中搜尋字典

        for  temp in users:

            if  find_name == temp["name"]:

                print("%s\t%d\t\t%s\t\t%d\t"%(temp["name"],temp["qq"],temp["weixin"],temp["number"]))

                find_flag= 1

                break

        if find_flag == 0:

                print("抱歉，沒有找到您需要的名片…")

4.字典的周遊

        infor= {“name”:“laowang”,“age”,“18”}

        len(infor) = 2

        infor.keys()    [“age”,“name”]

        if“qq” in infor.keys():

            print(“有qq”)

        infor.values()          [18,“laowang”]

        infor.items()         （元組，既有key又有value）

        for temp in infor.items:

            print(“key= %s,value = %s”％(temp[0],temp[1]))

        c,d= a = (11,22)

        forA,B in infor.items():

            print(“key= %s,value = %s”%(A,B))

5.将字典清空

          infor.clear()  或者  infor = {} , 不過第二種并不是真正意義的清空，它隻是指向了另一個對象

6.get和setdefault

        infor.get("key")就是要得到某個鍵的值，也可以用infor["key"]來擷取值但如果鍵不存在，就會異常，而infor.get()隻傳回一個空    

            infor.setdefault("key"),如果有這個鍵就會傳回它的值，沒有的話就建立這個鍵值對，而值變成None

7.items/iteritems,key/iterkeys,values/itervalues

            infor.items()能夠得到字典的清單，元素是鍵和值的元組

            infor.iteritems()是一個"dictionary-itemiterator"類型，這種疊代器類型，必須用list轉換一下，才能看到裡面的真面目

元組

1.清單和元組基本沒什麼差別，都能存多個值，唯一的差別就是元組不讓增删改（隻讀）

2.建立一個元組：

        tup1= ('physics', 'chemistry', 1997, 2000)

        tup1= (50,)（如果是隻有一個元素，可以添加逗号來消除歧義）

3.删除一個元組：

        元組中的元素值是不允許删除的，但我們可以使用del語句來删除整個元組del　tup

4.修改一個元組：

        元組中的元素值是不允許修改的，但我們可以對元組進行連接配接組合tup3= tup1 + tup2

5.通路一個元組：

        元組可以使用下标索引來通路元組中的值print(tup1[0])

6.元組的内置函數

cmp(tuple1,tuple2)：比較兩個元組元素。

len(tuple)：計算元組元素個數。

max(tuple)：傳回元組中元素最大值。

min(tuple)：傳回元組中元素最小值。

tuple(seq)：将清單轉換為元組

3.代碼調試:可以在代碼與代碼中間加入print(“--------x--------”)來檢測代碼是否運作

集合

1.去重：可以用set()來去重複，也可以set = {}，但并不推薦，因為容易與字典相混淆

2.增删：

        增：set.add("jack") 　#新添加元素

               set.update("kim")   #從另一個集合合并到一起

        删：pop,remove,discard,clear

                set.pop()不能有參數，且是随機删除，當删除到集合為空如果還要繼續删除則發生異常

                set.remove("obj") 删除指定的元素，沒有則發生異常

                set.discard("obj") obj是set裡的元素就删除，不是就不做，不發生異常

                set.clear()清空整個集合

3.元素和集合的關系

           "obj" in set ，元素在集合内就傳回True，沒有就傳回False

4. 集合與集合關系

            相等與不等：a==b，a!=b ，正确就傳回Ｔrue，錯誤就傳回False

            子集：c<a  ,True，c是a的子集

                   　c.issubset(a)判斷c是否是a的子集

            并集：a.union(b) ，把a集合和b集合并起來

            交集：a.intersection(b) ，把a集合和b集合交起來

5.名詞

• 循環（loop)，指的是在滿足條件的情況下，重複執行同一段代碼，比如while語句
• 疊代（iterable)，指的是按照某種順序逐個通路對象中的每一項，比如for語句
• 遞歸（recursion)，指的是一個函數不斷調用自身的行為，如以程式設計方式輸出著名的菲波納契數列（典型）
• 周遊（traversal)，指的是按照一定的規則通路樹形結構中的每個節點，而且每個節點隻通路一項

函數

1.函數：把具有一個獨立功能的代碼塊當作一個整體，這個整體就是函數

2.目地：使程式變的更加子產品化

3.函數的定義（代碼封裝）：

        def print_fozu():

            print(“oo00oo”)

            ………..

4.注意：定義函數僅僅是定義，不能執行，需要調用

5.函數的調用

        print_fozu()

6.帶有參數的函數

        defsum_2_nums(a,b):

        ………….

        sum_2_nums(num1,num2)

7.函數的傳回值

        在不同函數之間，不能直接使用另一個函數裡的變量，要用到return來傳回這個變 量的值，再指派給另一個變量

8.函數中的多個return

        在函數中，隻要執行到一個return，就傳回結束，是以可以通過清單或元組來封裝變 量的值

9.函數的四種類型

        第一種：沒有參數，沒有傳回值

        第二種：有參數，沒有傳回值

        第三種：沒有參數，有傳回值

        第四種：有參數，有傳回值

        實參：當調用一個函數的時候，傳遞的值叫實參（實實在在傳遞的）

        形參：用來接收的叫形參

10.函數的嵌套調用

        def sum_3_nums(a, b, c):

            result = a+b+c

            #print("%d+%d+%d=%d"%(a,b,c,result))

            return result

      def average_3_nums(a1, a2, a3):

            result = sum_3_nums(a1, a2, a3)

            result = result/3 #result/=3

            print("平均值是:%d"%result)

        #1.擷取3個數值

        num1= int(input("第1個值:"))

        num2= int(input("第2個值:"))

        num3= int(input("第3個值:"))

        #sum_3_nums(num1,num2, num3)

        average_3_nums(num1,num2, num3)

11.局部變量：在一個函數裡能用，出了這個函數哪都用不了，這樣的變量稱為局部變量

12.全局變量：定義在函數外面的變量，在整個代碼中都可使用

13.如果一個變量已經在全局變量的位置定義了，此時還想在函數中對這個全局變量進行修改的話，僅用一個變量名＝一個值還不夠，它隻是一個局部變量，隻是和全局變量名字相同罷了，那麼就需要在修改語句前加上global　變量名，這是對一個全局變量的聲明，但是清單和字典可加可不加

14.隻要在函數調用之前有這個全局變量，那麼在調用函數的時候就可以使用這個全局變量

15.全局變量和局部變量名字相同，在函數裡會使用局部變量，預設是定義

16.為了規避全局變量和局部變量名字相同，定義全局變量的時候g_a=100

17.函數幫助文檔是help(test)，在函數的開頭處用一對雙引号或者三對雙引号來括起幫助　

18.函數的預設參數：調用函數時，預設參數的值如果沒有傳入，則被認為是預設值，如print預設是換行，有了end就是就不換行

19.不定長參數：

        如sum_2_nums(a,b,*args)形參用來傳遞一個不定長的參數，args列印出來的格式為元 組，元組如果隻有一個元素，必須在元素後面加上逗号，否則不是元組

如test(a,b,c=33,*args,**kwargs)形參，如果實參在傳遞的時候有變量名的指派就是字 典的形式存儲在kwargs中，沒有變量名的就是args裡

拆包：在傳遞參數的時候，如test(11,22,33,*A,**B)就可以将Ａ的内容傳遞到元組，Ｂ的内容傳遞到字典

20.引用：id(變量名)擷取變量名的位址

        在python中不是變量存儲了一個數值，而是這個字元指向了一個資料而已，它可以說是一個資料的位址，在Ａ＝Ｂ指派語句中也就是把Ｂ存儲的位址給了Ａ一份，使得Ｂ也指向了這個資料

21.可變類型和不可變類型

• 數字（不可變）
• 字元串（不可變，因為所有的東西都是引用）
• 元組（不可變）
• 清單（可變）
• 字典 （可變）

注意：可變類型在清單中不能當作鍵值（原因是它可變，故位址不确定）

22.遞歸

一個函數裡邊調用了函數本身，這樣的函數叫遞歸（一定要想清楚什麼時候結束調 用，否則會一直進行調用本身死循環，等記憶體使用完了之後就會當機，就像手機打開 app閃退）

        def getNums(num):

        if num>1:

        #此處注意要有傳回值到下一個調用的函數中

            return num*getNums(num-1)

        else:

            return num

        result= getNums(4)

        print(result)

23.函數中的文檔

        在函數開頭處的第一行，用三個引号的方式包裹着對函數的說明print test.__doc__就是顯示文檔内容，其為内建函數

24.形參和實參

        形參：形參表示一個值，過程希望調用時，傳遞該值

        實參：實參表示在調用過程中傳遞給過程形參的值，在調用代碼過程中需提供參數

25.命名空間　

        命名空間：表示辨別符的可見範圍，它是對作用域的特殊抽象，它包含處于該作用域的辨別符

匿名函數

1.用lambda關鍵詞能建立小型匿名函數。這種函數得名于省略了用def聲明函數的标準步驟

2.lambda函數的文法隻包含一個語句，如下：

        lambda[arg1[,arg2,arg3…]]:expression

        lam = lambda x:x+3            ret = lam(3)

3.lambda函數能接收任何數量的參數但隻能傳回一個表達式的值

4.匿名函數的應用

        def test(a,b,func)

            result= func(a,b)

            num= test(11,22,lambda x,y:x+y)

            print(num)

4.清單裡如果全是數字：

        排序：nums.sort()（小到大）

　        nums.sort(reverse=True)（大到小）

        倒序：nums.reverse()

5.如果清單裡是字典：

        infors.sort(key=lambdax:x[‘name’])（按name的首字母來排序）

6.靜态語言：先确定功能，再執行

　    動态語言：寫完代碼，運作的一霎那，功能才被确定

7.輸入強制轉換為公式：

        如在轉換輸入類型的時候使用func_new= eval(func_new)就可轉換成公式，即所有的 輸入都将轉換為輸入，與int是一個道理

檔案操作

1.在linux系統中：一切裝置皆檔案

2.檔案的打開與關閉

        打開：f= open(“test.py”,“r”) (需要用f指派)

        #r隻能讀（必須存在）,w隻能寫（存在則覆寫，不存在就建立）,a打開檔案用于 追加（存在則追加，不存在就建立）

         ＃rb以二進制格式打開一個檔案隻讀，wb以二進制格式打開一個檔案用于寫入，ab以二進制格式打開檔案追加内容

        ＃r+打開一個檔案用于讀寫，w+打開一個檔案用于讀寫，a+打開一個檔案用于讀寫

        #rb+,wb+,ab＋與上述類似，二進制檔案可讀可寫

        關閉：f.close()

3.檔案的讀和寫

        讀：f.read(x) #x表示read讀第幾個，注意需要用一個變量接收，然後列印，程式才會出結果

        寫：f.write(“haha”) #它會傳回目前輸入的個數

4.python的檔案複制代碼

            # _*_ coding:utf-8 _*_

            f = open("19-交換變量的值.py","r")

            content = f.read()

            f.close()

            f = open("xxx.txt.py","w")

            f.write(content)

5.得到例如jack[複件].txt的複制檔案

             先在jack.txt中使用old_file_name.rfind(“.”)找出“.”的下标，然後new_file_name=old_file_name[:position]+"[複件]"+old_file_name[position:]，position就是“.”的下标

6.f.read(),f.readline和f.readlines

        read是讀字元串，readline是讀一行（字元串），readlines是全部讀出的列

7.大檔案的處理方法

        讀到大檔案的時候切記不能用read

        為避免程式挂掉，是以在這時，不能一次性全部讀取，需要加入一個循環，每次讀 取1024個位元組，等讀取不到位元組了，這時再break

        whileTrue:

            content = old_file.read(1024)

            if len(content)==0:

            new_file.write(content)

8.檔案的定位讀寫

            f.seek(2,0)：seek可以了解為一個指針，第二個數字表示大方向，0是檔案的開頭，1是檔案的目前未知，2表示檔案末尾，類似于粗調，第二個數字是偏移量，類似于細調

            f.tell()：擷取目前的讀寫位置

9.檔案，檔案夾的相關操作

import os（引入os包）

修改檔案名：os.rename(“xxx.py”,“x.py”)

删除檔案：os.remove(“x.py”)

建立檔案夾：os.mkdir(“test”)

删除檔案夾：os.rmdir(“test”)

擷取目前路徑：os.getcwd()

改變預設目錄：os.chdir(“../”)

擷取目錄清單：os.listdir(“./”)

10.批量重命名代碼

        import os

        #1.擷取要重命名的檔案夾　名字

        folder_name = input("請輸入要重命名的檔案夾:")

        #2.擷取指定的檔案夾中的所有　檔案名字        

        file_names= os.listdir(folder_name)

        os.chdir(floder_name)

        #3.重命名

        for name in file_names:

        print(name)

        old_file_name= folder_name+"/"+name

        new_file_name= folder_name+"/"+"[京東出品]-"+name

        os.rename(old_file_name,new_file_name)

面向對象

1. 面向對象和面向過程的差別

        面向過程：根據業務邏輯從上到下寫代碼

        面向對象：将資料與函數綁定到一起，進行封裝，這樣能夠更快速的開發程式，減少了重複代碼的重寫過程（能讓程式更加簡單，更加緊湊 面向對象和面向過程都是解決問題的一種思路而已

       面向對象(object-oriented;簡稱:OO) 至今還沒有統一的概念我這裡把它定義為:按人們認識客觀世界的系統思維方式,采用基于對象(實體)的概念建立模型,模拟客觀世界分析、設計、實作軟體的辦法。面向對象程式設計(ObjectOriented Programming-OOP) 是一種 解決軟體複用的設計和程式設計方法。這種方法把軟體系統中相近相似的操作邏輯和操作應用資料、狀态,以類的型式描述出來,以對象執行個體的形式在軟體系統中複用,以達到提高 軟體開發效率的作用。

2.類和對象的關系

            面向對象程式設計的2個非常重要的概念：類和對象

• 對象是面向對象程式設計的核心，在使用對象的過程中，為了将具有共同特征和行為的一組對象抽象定義，提出了另外一個新的概念——類
• 類就相當于制造飛機時的圖紙，用它來進行建立的飛機就相當于對象
• 類是抽象的,在使用的時候通常會找到這個類的一個具體的存在,使用這個具體的存在，一個類可以找到多個對象。某一個具體事物的存在,在現實世界中可以是看得見摸得着的，可以是直接使用的

簡單的說，類可以看成是一個模型，是建立對象的一個模型，而對象就是一個實物，類的範圍比對象大

3.類的構成

類的名稱：類名

類的屬性：一組資料

類的方法：允許對進行操作的方法（行為）

    新式類：廣度優先，從最接近的上一個類開始，依次往上尋找相應的繼承屬性

    舊式類：深度優先，從最開始的類開始，依次往下尋找相應的繼承屬性    

4.類的抽象

        擁有相同(或者類似)屬性和行為的對象都可以抽像出一個類

5.定義類

        class類名（推薦大駝峰命名法）：

        #屬性

        #方法

        defxxx(self): #注意在定義行為的時候要用self

            pass

6.建立一個對象    

        在上述的代碼之後，加上tom= 類名，傳回對象的引用

        tom.drink()引用drink的行為

        添加變量：tom.color= “黑色”

7.self:

        如在lanmao.introduce()中,print(“self.name”),誰調用就指向誰，它就會介紹自己 lanmao

8.類裡面的方法和函數的差別

        類裡的方法和函數外觀很相似，都采用def hanshu()，但是類的方法裡必須要有一個 形參，它可以是self，可以是a,b,c,d等等，但是在調用的時候，實參裡不能傳遞任何值

9.__init__方法（給對象添加特定的屬性）

        def__init__(self):

        python會自動調用這一個方法，一旦建立即可預設調用，這種方法通常被稱為魔法 方法

        利用好這一點，就可以用它來傳遞一些特定的屬性，不用每個對象都去定義一遍

        例如：def__init__(self,new_name,new_age)

                        self.name= new_name

                        self.age = new_age

        最後在建立對象的時候注意把這個屬性參數傳遞進去,隻有在建立對象的時候可以扔 參數，對象發生行為時不可以扔參數：

        tom =Cat(“tom”,18)

10.__str__方法（傳回調用對象的資訊）

        def__str__(self):

        同__init__方法一樣，一旦建立即可調用，常被用來傳回對象的資訊

        例如：def__str__(self):

                        return “%s的年齡是：%s”%(self.name,self.age)

                  print(tom) #列印對象的資訊

11.應用-烤地瓜

　    如果當多次調用某個方法，要方法的下一次調用用到上一次的結果，不應該在這個方 法裡找一個變量存，因為這個方法一旦被調用完後，就會釋放記憶體，正确的方法是要找 到目前對象的一個屬性，把這個結果扔到屬性裡去

        如果一種屬性需要多個元素，可以引入清單來存儲多個數值，在__str__()方法中的return可以直接利用str(self.condiments))傳回這個清單的資訊

12.應用-存放家具

        如果一個對象與另外一個對象有一定的關系，那麼一個對象可用是另外一個對象的 屬性

        如果要是能用直接擷取屬性的地方，統統改成用方法來擷取，因為這樣可以避免直 接被通路的情況，遇到不想被通路的資訊時候做不到禁止，權限控制

13.邏輯屬性要用方法來指派

        在給對象設定屬性的時候，如果直接賦予的話，可能某種情況下會發生不合邏輯的情況，如dog.age = -10，這句話文法是沒有錯的，所有在運作的時候不會報錯，所有最好是在設定屬性的時候，用方法來指派，這樣可以引入判斷，如if new_age >0:  self.age = new_age,這樣就能使得屬性符合人們的邏輯了

14.公有方法和私有方法

        私有方法：如def __send_msg():這個方法一般表示是比較重要的方法，且一般需要獲得一定條件才可調用，稱為是私有方法，即需要滿足一一定條件，就好比是發短信一樣，需要有金額大于0的情況下，但在property裝飾的方法可以通路私有化的執行個體屬性，所有封裝的确不是讓人看不見

        公有方法：如def send_msg():這就是公有方法，即調用就可以執行，公有方法還可以去調用私有方法，當滿足一定的情況，可以調用私有方法，這就是私有方法的使用

        私有的屬性：不能通過對象直接通路，但能通過方法通路，私有的方法隻能通過方法通路

15.__del__方法

        如果對象在程式結束之前把所有引用都删了，del方法在最後一個删的時候結束，觸發調用del方法，但如果并沒有删除完所有的引用，也就是程式還有占用記憶體，那麼在程式結束之後再觸發這個del方法

16.測量對象的引用個數

        如果要測量一個對象的引用計數的方式，那麼就要導入sys子產品，采用sys子產品裡的sys.getrefcount(對象),就會傳回一個值，因為在使用這個子產品方法時會自動使用一個變量把這個對像引用值儲存起來，是以傳回值要比實際引用個數多1

17.單繼承

        繼承描述的是事物之間的所屬關系，例如貓和狗都屬于動物，程式中便可以描述為貓和狗繼承自動物，一般程式都稱為父類（基類）和子類（派生類），沒有母類

        子類在繼承的時候，在定義類時，小括号()中為父類的名字，如class Animal(object):   class Dog(Animal):這就是一個簡單的繼承，子類（派生類）可以使用所有父類（基類）的方法，但不能使用同一基類下其他派生類的方法

        注意：在繼承的過程中，父類的私有屬性，私有方法，也就是由雙下劃線__test():組成的不能繼承

        繼承的意義與好處：

• 可以實作代碼複用，但也不是全部複用，可能不用
• 實作屬性和方法繼承

18.多繼承

        子類可以有多個父類，就好像騾子既繼承類馬又繼承類驢。這裡的多繼承指的是子類可以繼承父類的父類，也可以繼承來自不同的父類，例如class C(A,B):

        上面的多繼承例子中，如果父類A和父類B中，有一個同名的方法，那麼通過子類去調用的時候，調用哪個？

        　調用的先後順序：先調用自己的方法，如果沒有就從上一個先定義的父類找，再下一個父類，如果還是還找不到就是父類的父類，再沒有就錯誤了

        如果調用的是繼承的父類中的公有方法，可以在這個公有方法中通路父類的私有屬性和私有方法，但是，如果在子類中實作了一個公有方法，那麼這個方法不能夠調用繼承的父類中的私有方法和私有屬性

19.重寫

         重寫就是把方法與父類同樣的定義一遍

        如果發現在繼承的時候，父類的方法的名字就是想要的名字，但不是想要的功能的時候，那麼這個時候就可以去重寫，如果子類中有這個方法的名字，那麼它就會執行這個類裡的方法，如果沒有這個方法的時候才會去父類裡找

20.調用被重寫的方法

        在重寫的方法裡去調用被重寫的部分

        第一種：Dog.bark(self)  

        第二種：super().bark()

        關于代碼#super().__init__()的說明

            這一行代碼，可以調用也可以不調用，建議調用，因為__init__方法往往是用來對建立完的對象進行初始化工作，如果在子類中重寫了父類的__init__方法，即意味着父類中的很多初始化工作沒有做，這樣就不保證程式的穩定了，是以在以後的開發中，如果重寫了父類的__init__方法，最好是先調用父類的這個方法，然後再添加自己的功能

21.多态

        簡單的說，一個人有多種表現形式就是多态

        是指面向對象程式執行時，相同的資訊可能會送給多個不同的類别對象，系統可根據對象所屬類别，引發對應類别方法而有不同的行為

        所謂多态：定義時的類型和運作時的類型不一樣，此時就稱為多态，簡單的說就是根據對象的不同來執行不一樣的功能，如：

        def introduce(temp):

              temp.print_self()

        這裡就根據temp的不同來執行各自的print_self，這就是多态，這個print_self就是不同類裡的一個方法

22.類屬性，執行個體屬性

        類屬性就是類對象所擁有的屬性，它被所有類對象的執行個體對象所共有，在記憶體中隻存在一個副本，這個和C++中類的靜态成類外可以通過類對象和執行個體對象通路，也就是說類對象好比是一張大的海報，人人都能看，執行個體屬性就是對象的基本屬性員變量有點類似。對于公有的類屬性，在，好比是人人都有一張海報，浪費資源，所有就有了類屬性，可以被所有類對象和執行個體對象通路，就好比是執行個體對象的共享屬性稱為類屬性，隻需要建立一次

         執行個體屬性不能左右類屬性，但類屬性能影響執行個體屬性，但如果是變量引起的是一個可變的對象-清單，則通過類屬性和執行個體屬性都能直接改變這個對象

        調用時用類名＋類屬性，例：Tool.num  +=1

         在給類添加屬性的時候，該屬性被放入類對象的__dict__魔法字典的鍵值對中

         在給執行個體添加屬性的時候，該屬性被放入執行個體對象的__dict__魔法字典的鍵值對中

23.類方法，靜态方法

        類方法：是類對象所擁有的方法，需要用修飾器@classmethod來辨別其為類方法，對于類方法，第一個參數必須是類對象，一般以cls作為第一個參數，類方法還有一個用途就是可以對類屬性進行修改，它不能通路執行個體屬性

        兩種調用方式：對類屬性操作用類方法

                第一種：通過類的名字調用類方法，如Game.add_num()

                第二種：通過類建立出來的對象去調用這個類方法,如game.add_num()

        靜态方法：需要通過修飾器@staticmethod來進行修飾，靜态方法不需要多定義參數，它無法通路執行個體變量，類，和執行個體屬性

        兩種調用方式：方法與類關系和執行個體方法沒有關系，就用靜态方法

                第一種：通過類的名字調用靜态方法，如Game.print_menu()

                第二種：通過類建立出來的執行個體對象去調用靜态方法，如game.print_menu()

        方法和執行個體方法以及靜态方法的定義形式就可以看出來，類方法的第一個參數是類對象cls，那麼通過cls引用的必定是類對象的屬性和方法；而執行個體方法的第一個參數是執行個體對象self，那麼通過self引用的可能是類屬性、也有可能是執行個體屬性（這個需要具體分析），不過在存在相同名稱的類屬性和執行個體屬性的情況下，執行個體屬性優先級更高。靜态方法中不需要額外定義參數，是以在靜态方法中引用類屬性的話，必須通過類對象來引用        

24.耦合性

        如果類與類之間的耦合性過強，也就是一個類改變，另一個類也需要改變，此時可以定義一個函數，把其中一個類的方法形參傳遞到這個函數中，再在這個函數裡傳回到類中，如設計4s店類例子，這種思維叫做解耦

        但是如果采用面向對象程式設計就最好全部采用對象程式設計，于是這個方法就要定義為一個類，分離其他兩個類的方法叫做簡單工廠模式

        基類隻是搭一個架構，不需要實作所有功能，功能在子類裡實作

25.工廠方法模式

         定義了一個建立對象的接口(可以了解為函數)，但由子類決定要執行個體化的類是哪一個，工廠方法模式讓類的執行個體化推遲到子類，抽象的CarStore提供了一個建立對象的方法createCar，也叫作工廠方法。

        子類真正實作這個createCar方法建立出具體産品。 建立者類不需要直到實際建立的産品是哪一個，選擇了使用了哪個子類，自然也就決定了實際建立的産品是什麼

26.__new__方法

        定義def __new__(cls):

                        return  object.__new__(cls)

             __new__必須要有傳回值，傳回執行個體化出來的執行個體，這點在自己實作__new__時要特别注意，可以return父類__new__出來的執行個體，或者直接是object的__new__出來的執行個體， __new__方法接受的參數雖然也是和__init__一樣，但__init__是在類執行個體建立之後調用，而 __new__方法正是建立這個類執行個體的方法       

            簡單的說__init__隻負責初始化，__new__隻負責建立，他們兩結合的方法就是構造方法     

27.單例對象

            就是不管怎麼建立，始終隻有一個對象，就是單例 ，就要在用一個類屬性來判斷是否已經建立了對象，如果建立了對象就把它儲存起來再傳回出去，if cls.__instance == None:如果沒有，就讓cls.__instance = object.__new__(cls)

28.隻初始化一次對象

            與上述類似，加一個類屬性判斷即可，__init_flag = false就初始化，然後__init_flag=True,就不會執行初始化

29.内置命名空間，全局命名空間，本地命名空間

 内置命名空間：python運作起來，它們就存在了。内置函數的命名空間都屬于内置命名空間，是以我們可以在任何程式中直接運作它們，比如前面的id()，不需要什麼操作，拿過來就能用

全局命名空間：每個子產品建立它自己所擁有的全部命名空間，不同子產品的全局命名空間彼此獨立，不同子產品中相同名稱的命名空間，也會因為子產品的不同步互相幹擾

本地命名空間：子產品中有函數或者類，每個函數或者類所定義的命名空間就是本地命名空間，如果函數傳回了結果或者抛出異常，則本地命名空間也結束了

異常

1.異常    

            當Python檢測到一個錯誤時，解釋器就無法繼續執行了，反而出現了一些錯誤的提示，這就是所謂"異常"

             try: （放置可能出現錯誤的代碼）（這是可以嵌套的）                                                   

                  print(num)

                  print("-----1-----")

           except NameError as ret:（如果産生錯誤，處理的方法，當捕獲多個異常時，可以把要捕獲的異常的名字，放到except 後，并使用元組的方式僅進行存儲）（也可以用except Exception）

                 print("處理異常")

                 print(ret)（擷取異常的資訊描述）

           else: （沒有異常才會執行的功能）

                 print("沒有異常")      

         finally:（在程式中，如果一個段代碼必須要執行，即無論異常是否産生都要執行，那麼此時就需要使用finally）

                  print("------"）

2.異常的傳遞

         如果一個異常是在一個函數中産生的，例如函數A---->函數B---->函數C,而異常是在函數C中産生的，那麼如果函數C中沒有對這個異常進行處理，那麼這個異常會傳遞到函數B中，如果函數B有異常處理那麼就會按照函數B的處理方式進行執行；如果函數B也沒有異常處理，那麼這個異常會繼續傳遞，以此類推。。。如果所有的函數都沒有處理，那麼此時就會進行異常的預設處理，即通常見到的那樣  

3.自定義異常

            用raise語句來引發一個異常。異常/錯誤對象必須有一個名字，且它們應是Error或Exception類的子類

4.異常進行中抛出異常

            直接預設raise

5.assert語句

            assert，翻譯過來是斷言，assret是語句等價于布爾真的判斷，發生異常就意味着表達式為假，如assert amount >0，amount必須大于零的情況下就用斷言，當條件不滿需就會報錯

              用于如下情況：

• 防禦性的程式設計
• 運作時對程式邏輯的檢測
• 合約性檢查（比如前置條件，後置條件）
• 程式中的常量
• 檢查文檔

6.面試：python是一種動态語言，既支援面向對象也支援面向過程

             python的面向對象的三個基本要素：封裝，繼承，多态

子產品

1.子產品的介紹

         Python中有一個概念叫做子產品（module），這個和C語言中的頭檔案以及Java中的包很類似，比如在Python中要調用sqrt函數，必須用import關鍵字引入math這個子產品

2.制作子產品

            比如現在test.py中，定義了函數add,然後建立一個sendmsg.py，在裡面導入import test,使用test.add()，也可以用from test import sendmsg，調用test()就是一個制作子產品的大體流程，為了讓我們自己寫的子產品被python解釋器知道，需要用sys,path.append("路徑")，但這種情況下，比如在互動模式下，如果關閉了，再開啟，還要重新告知

            常用方法：設定PYTHONPATH環境變量

                                vim /etc/profile

                                export PATH = /home/jack/python:$PAT

3.延時

            import time as tt（可以起個乳名，意在替代當子產品名過長的情況）

            time.sleep(5)  #延時5秒

4.__all__

            from test import *時，為了防止把不需要的子產品導入，在子產品裡邊建立一個變量__all__,是一個清單，放上将來要使用的函數，類，全局變量的名字，如果不放，别人就無法使用  __all__ =["Tset","test"] ,

5. __name__

            有時候在代碼的編寫過程中，肯定會在代碼裡面加入測試的代碼，那麼在引入這個子產品的時候就會發生每一次引入的時候這些測試代碼就會運作，但是在真正使用的過程中是不需要測試代碼的實作的，是以需要有一種方法可以既能實作代碼的測試，又不會在引入子產品的時候被執行，就需要在子產品裡加入if __name__ = "__main__()":，在這個條件下執行不會引入測試代碼，但是在子產品本身又能完成測試，如果隻是用于導入子產品，則不需要這個

6.python中的包

            包将有聯系的子產品組織在一起，即放到同一個檔案夾下，并且在這個檔案夾建立一個名字為__init__.py 檔案，那麼這個檔案夾就稱之為包，這個__init__.py控制着包的導入行為，在這個檔案中， 定義一個__all__變量，它控制着 from 包名 import *時導入的子產品，如__all__ = ["sendmsg"]           

7.子產品釋出

             1.編輯setup.py:

            from distutils.core import setup

setup(name="dongGe", version="1.0", description="dongGe's module", author="dongGe", py_modules=['test.sendmsg', 'test.recvmsg'])

               2.構模組化塊

                python/python3 setup.py build

                3.生成釋出壓縮包

                  python/python3  setup.py sdist

8.子產品安裝，使用

                    1.找到子產品的壓縮包

                    2.解圧

                     3.進入檔案夾

                     4.執行指令python setup.py install

                     5.子產品的引入

                            from    子產品名　import 子產品名或者*

9.給程式傳參數

                    import sys

                     print(sys.argv)

                     name = sys.argv[1] 

                     print("熱烈歡迎%s的到來"%name) 

9.清單推導式

                    range的風險是在python2裡，如果是[1,10000000]會占用很大的記憶體，而在python3中不會出現這個情況，需要的時候立刻生成一個值供使用

                    1.while 的清單推導                                                  

                        name = []

                         i=0

                         while i<=77:

                              name.append(i)

                              i+=1

                         print (name)

                    2.for的清單推導,range與切片很類似

                        for i in range(10,78):

                         print(i)

                    3.第一個i是元素的值，後面的for是代表循環的次數，如果第一個i=11，那麼所有的元素都是11

                        a=[i for i in range(1,18)]

                        print(a)

                    4. #for控制循環的次數，for和if的嵌套

                         c = [i for i in range(10) if i%2==0]

                         print(c)

                    5.  #每執行第一個for循環都要執行第二個循環的所有次數

                        d = [i for i in range(3) for j in range(2)]

                         print(d)

                     6.#每執行第一個for循環都要執行第二個循環的所有次數

                        d = [(i,j) for i in range(3) for j in range(2)]

                         print(d) 

                    例題：找出100以内能被3整除的正整數

                         aiquot = []                                       很簡潔：range(3,100,3)

                        for n in range(1,100)

                                if n%3 ==0:

                                       aiquot.append(n)

10.import math和from math import *的差別

            如：import math                                          from math import *

                   math.pow(3,2)                                       pow(3,2)

                   調用math子產品的math.pow函數　　　  這裡不需要加上math的字首

10.set,list,tuple

                      set的類型是集合，set,list,tuple之間可以互相轉換

                       d=list(c) d=tuple(c)  d=set(e)

                        使用set,可以快速的完成對list中的元素去重複功能