python_基礎知識回顧總結

時間 2019-12-10

原文原文鏈接

1、流程控制：if，while ，for

一、if……else  條件判斷

語法：

if  條件1：

　　代碼塊

elif 條件2：

　　代碼塊

……

else：

　　代碼塊

注：單純的if語句裏，從上到下，只要符合其中一個條件，就不會再執行下面的條件了。python

二、while 無限循環git

語法格式：（代碼塊能夠是for循環或if條件判斷循環，break，continu）面試

while  條件：

　　代碼塊

---------------------------

while  條件成立時執行下面的代碼塊，不成立時執行else代碼塊，但一遇到break就直接退出循環，循環裏的或else都不會執行：

　　代碼塊

else：

　　代碼塊

----------------------------

 1 1、第一種狀況
 2 n = 1
 3 while n < 5：
 4     n +=1
 5     print(n)    -----> 2,3,4,5
 6 
 7 2、第二種狀況
 8 n = 1
 9 while n < 5:
10      print(n)  ------->1,2,3,4
11      n +=1
12 
13 3、第三種狀況
14 while  n < 5:
15     if  n == 3:
16         break
17         print(n)
18     n +=1  
19 ------->什麼都沒有，由於n =1或2時都不符合if條件，故不會執行裏面的代碼
20 
21 四、第四種狀況 （print（）縮進很重要，縮進很重要，縮進很重要！！！）
22 while  n < 5:
23     if  n == 3:
24         break
25     print(n)   --------->1,2
26     n +=1
27 等效果下面if---else
28 while  n < 5:
29     if  n == 3:
30         break
31     else：
32         print(n)
33     n +=1
34 注：if條件判斷，一旦符合條件，就不會再去看其餘條件了，故else也不會去執行了，只有在while或for循環中才會去執行。
35 
36 
37 
38 5、第五種狀況
39 while  n < 5:
40      print(n)
41      n +=1
42 else:
43       print("沒有break直接退出程序的話，當前麪條件不符合時，會打印else後的信息") 
44 
45 >>> 1,2,3,4
46 >>> 沒有break直接退出程序的話，當前麪條件不符合時，會打印else後的信息
47  
48 6、第六種狀況
49 while  n < 5:
50      print(n)
51      n +=1
52 else:
53       print("沒有break直接退出程序的話，當前麪條件不符合時，會打印else後的信息") 
54 print("只要不出現死循環，無論前面程序執行如何，在while循環外的代碼都會執行")   
55 
56 >>> 1,2,3,4
57 >>> 沒有break直接退出程序的話，當前麪條件不符合時，會打印else後的信息
58 >>>只要不出現死循環，無論前面程序執行如何，在while循環外的代碼都會執行

while 各類狀況運行結果

break 退出當前循環，若是外面還有循環，不會退出！！！api

三、for ……elseapp

語法格式：（同while循環，for循環是可控的循環，通常不做爲無限循環）

s = "321"
counts = 0
if counts < len(s):
    for i in s:
        print("倒數第%s秒"%(i))
        counts += 1
    else:
        print("出發")
else：
   print("這個打印是不會顯示的，由於if裏執行了上面的條件，下面就不會去執行的")

注意：當for循環結束後，會從上往下執行後面的代碼即else，能夠看做和for沒有關係的另外一個平行代碼塊

2、數據類型之間的轉換

不可哈希的數據類型便可變數據類型：list、dict、setide

可哈希的數據類型即不可變數據類型：int、str、tuple、bool函數

str 變成 list ：split(分割符) 或 list(str) 只是把每一個元素放入列表中ui

list 變成 str ：list_str = "拼接符或空格"join(list) 或str(list) 只是外層加雙引號，意義不大編碼

 1 # str 與 list的轉換
 2 # str ->list的轉換1：經過 split() 方法將str改成list
 3 str01 = "china_is_my_country"
 4 str01 = str01.title()  # China_Is_My_Country
 5 str_list = str01.split("_")  # ['China', 'Is', 'My', 'Country']
 6 
 7 # str ->list的轉換2：經過list()方法轉換的str是將一個列表會將每個元素都切開，有時可能沒法達到本身的預想，就用split(分割符)
 8 str_list0 = list(str01)
 9 # ['C', 'h', 'i', 'n', 'a', '_', 'I', 's', '_', 'M', 'y', '_', 'C', 'o', 'u', 'n', 't', 'r', 'y']
10 
11 # list ->str 的轉換1：經過str()方法將list轉成一個總體的str包括[]及雙引號等如"[1,2,3]",這種轉換沒有太大意義
12 # list ->str 的轉換2：經過join()方法將list裏每一個元素拼接起來
13 lis = ["我","愛","中","國"]
14 lis_str = "_".join(lis)  # 我_愛_中_國

str與list的互轉

str 經過list(str)、tuple(str)、set(str) 對象方法轉換成str ，只是在外加了一層雙引號，對元素操做很不方便，故這種轉換沒有意義 spa

注：str 、list、tuple、set、int 沒法經過dict(）轉換成字典，因字典是鍵值對成對存在的 (ValueError: dictionary update sequence element #0 has length 1; 2 is required)

注：想把str轉換成int，str必須全是數字才行，否則報錯

str經過對應對象方法變成 list 、tuple、set 、int 都是將str每一個字符拆分迭代的放入對應數據類型中

---------------

非空字符串、列表、元組、字典、集合及非零數字轉換成bool型都爲True

0，None，[]，（），{}，set（），False ，bytes" 轉換成bool型都爲 False

3、數據類型：

不可變數據類型：int、str、bool、tuple、frozenset
可變數據類型：list、dict、set
公共方法：count()、len()、del、copy()
len(全部都有)
count（數字、字典、集合沒有此方法）
index（數字、字典、集合沒有此方法）
可變數據類型都有copy（）

整數、字符串、列表、元組、布爾能夠相加（字典、集合不可相加）

整數： int

# 不可變數據類型，無序

    數學運算：+ - * /  //(整除) % **（冪）
    比較運算： >,<,>=,<=,==,!=
    賦值運算：=,+=,*=,/=,-=,%=,,//=,**=

    邏輯運算：not or and
            從左到右
            優先級：（） not  and  or
            1(非零整數)：true   0：false
            1 or 2  左邊非零取左邊，0 取右邊，and相反

    身份運算：is  is not  判斷兩個對象是否是爲同一個內存地址

    成員運算：in not in   判斷字符/元素是否在目標中，str，list，dict，set，tuple

    位運算：
        &  與運算   1 1 得1 ， 1 0 得0  ，0 0 得 0
        |  或運算   1 1 得1，1 0 得1 ，0 0 得0

    方法：
        int.bit_length()   查看數字在內存中佔的字節數
布爾值：True  False
    #不可變數據類型、True爲1，False爲0   （0，None，False，[],(),{},set(),都爲False）
補充：
1、int 轉 float  是取整，不是四捨五入
1.一、  int(12.34)  --->12
　　　　int("12.34")  ---> 報錯

二、  i = 1， # 注意後面的點     print（type（i））==》(1,) <class 'tuple'>

字符串： str

# 不可變數據類型、有序、可切片，可迭代循環，交互默認輸入爲字符串
    # 以單或雙引號表示 ：'元素'
    # 不可增刪改
    切片：從左到右字符串中的索引從0開始
    [start:end:step]  顧頭不顧尾
    [1:3] 字符串中索引1到2的字符
    [1:-1] -1 表示最後一個字符
    操做方法：
            del str          刪除字符串
            len(str)         統計字符串長度，內置方法
            str.count(元素）  統計字符串中的元素出現的個數
            str.center(寬度，"填充物可不寫")  指定長度居中顯示，默認填充物爲空格
            str.title()      非字母隔開的單詞首字母大寫，其他都變小寫
                  china coUntry --> China Country
        *   str.capitalize()  首字母大寫，其餘單詞所有小寫
                china_Country  --> China_country
            str.swapcase()    --->字符串大小寫互轉
        **  str.upper()    ----> 所有變成大寫
            str.isupper()           是否所有爲大寫
        **  str.lower()    -----> 所有變成小寫
            str.islower()           是否所有爲小寫
            str.encoding("將字符串以何種編碼集進行編碼")
        **  str.startswith("元素") 判斷字符串是否以什麼開頭，返回bool值
            str.endswith("元素")
        *** str.find("元素"，star，end)  找元素的索引，若是元素不存在，返回-1
        *** str.index("元素",star,end)   找元素的索引，若是元素不存在，報錯
        *** str.strip("元素可空")     去掉兩端的\n,\t,\s等空白字符，也可指定字符從兩端刪
            str.lstrip()
            str.rstrip()
     ***** str.split("分割符可空，默認空格，多個空格當作一個")   分割字符串，返回列表
            str.lsplit()
            str.rsplit()
        *** str.replace(old,new,替換幾回）
        *** str.format()  字符串格式化
                "{}my name is {}".format(11,"秀*")
                "{1}my name is {2}，next year is {1}".format(11,"秀*")
                {id}is old boy ,my name {name}".format(id =11,name="sun")  
　　　　　　dic = {‘id’：11，‘name’:'sun'}　　　　　
              {id}is old boy ,my name {name}".format(**dic)  　也能夠放字典
            % 百分號的方式格式化
                "my name is %s ,i am %d" %("sun",30)"
                "my name is %(name)s ,i am %(age)d" %(dic)"  能夠放字典
                %s 字符串
                %d 整數
                %f 小數   %.2f 保留2爲小數
            3.6以上版本格式話能夠：f"{name}已經登陸了"

            str.isalnum()  是否爲字母或數字，返回bool值
            str.isalpha()  是否全爲字母
            str.isdigit()  是否全爲數字
            str.isspace()  是否有空白字符
     ***** str.join(iterable可迭代)   字符串拼接,括號裏必定得是可迭代得數據，且只能爲一個參數
                注：
                "sun".join([11,22])  報錯，join不能將帶有數字得list轉換成字符串，須要先將數字轉換成字符串
                "*".join("%s" %id for id in list)
            object  in  str    判斷元素是否在str中

列表：list

# 可變數據類型，有序，可切片，可迭代循環，元素可爲任意類型數據
    # 以[元素，]表示
    # 可增刪改查
    切片：
    同字符串同樣，經過索引切
    增：
      list.append(元素）       向列表末尾添加元素
      list.insert(index,元素） 指定索引位置向列表添加元素
      list.extend(iterable)    迭代的向列表末尾添加多個元素
    刪：
       list.pop(index)     根據索引刪除，不添加索引時，默認刪除最後一個
       list.remove(元素/object） 根據元素刪除
       del list   刪除列表
       del list[:3]  根據索引切片刪除
       list.clear()  清空列表
    改：
        lis[index] = new_data    索引切片修改
            lis = [11,22,33,44,55]
            lis[:2] = [66,77,88]    # lis = [66, 77, 88, 33, 44, 55]  步長爲1時，不考慮個數對應，切的時一片空間
            lis[:3:2] = [66,77]     # 報錯，步長不爲1時，左右元素個數需一致
                                    #ValueError: attempt to assign sequence of size 3 to extended slice of size 2
    查：
        lis[index]      經過索引查
        for i in list:   經過迭代循環查，i爲列表中的每一個元素
    方法：
        del list               刪除列表
        len(list)             統計列表的長度
        list.count(object)   統計列表中指定元素出現的個數
        list.index(object,start,end)   查找元素的索引
        list.sort(reverse=False)     排序，默認爲升序，當reverse值設爲True時，降序排列
        list.reverse()      列表中元素順序反轉過來
        list.copy()         列表淺拷貝
        object in list      判斷對象是否在列表中

元組：tuple

# 不可變數據類型，有序，可切片，可迭代循環，元素能夠是任意數據類型
    # 不可增刪改
    # 以括號表示（）
    查：
       tuple[2]   經過切片查
       for i in tuple：   經過迭代循環查
    方法：
       tuple.count(object)
       tuple.index(object,start,end)
       len(tuple)
        object in tuple
元組單個元素，須要在後面加上一個逗號，否則python就不會認爲其是一個元組類型
還有 i= 1， python也認爲其爲一個元組

字典：dict

# 可變數據類型，鍵值對存在，鍵不可變,可哈希的（int，str,bool,frozenset)，值能夠是任意數據類型，無序，不可切片，可迭代循環查詢
    # 以大括號表示{key：value}
    # 可整刪查
    增：
        dic = {}
        dic[new_key] = new_data    直接增長，若是key存在則更新value
        dic.setdefault(key,value)  本方法一旦key，value都建立，且value指定的不是[]、{}、set(),值都不能更改
        new_dic = dict.fromkeys(iterable,values)
            new_dic = dict.fromkeys([11,22],[33,44]) -->{11: [33, 44], 22: [33, 44]}
            前面的key對應相同的value,且當後面的value爲可變數據類型時如列表，改變任意一個value，
            另外一個也會改變，淺拷貝，不然不改變
    刪：
        dic.pop(key)    指定key刪除，默認刪除最後一項,返回刪除key對應的value,若是key不存在報錯 KeyError:
        dic.popitem()   隨機刪除 ，返回刪除的鍵值對以tuple形式顯示
                        3.6以上字典內置爲有序，popitem（）默認刪除最後一個，但面試要說隨機刪除
        del dic[key]    指定key刪除，若是key不存在報錯 KeyError:
        del dic
        dic.clear()
    改：
        dic[key] = new_data
        dic.update(dic1)       dic將dic1更新到本身的字典中，key重複更新爲新value
    查：
        dic[key]     key不存在時，報錯
        dic.get[key,"不存在時自定義返回值"]   key不存在時默認返回None，也可自定義返回值
        dic.keys()   以仿列表形式存全部key，可迭代
        dic.values()
        dic.items()
        for i in dic   i 爲dic的key
    方法：
        len(dic)

集合：set

# 可變數據類型，無序，元素惟一不重複且可哈希即不可變數據類型，可迭代
    # 以{}形式表現,主要用於去重
    # 不可切片（無序），可增刪查
    增：
        set.add(元素)
        set.update(iterable)    迭代的更新到set中
    刪：
        set.pop()   隨機刪除
        set.remove(元素）  沒有報錯
        set.clear()
        del set
    改：
        因無序，只能經過先刪除後整加的方式
        set.remove(待改元素)
        set.add(新增元素)
    查：
        for i in set:
    方法：
        len(set)
        交集： &     相同的部分
        並集： |     合體
        差集  a-b    去掉在a中b有的元素，減法
        s = frozenset([11,22,33])  將可變數據類型改成不可變

4、深淺拷貝

淺拷貝：

一、針對的是可變數據類型：list、dict、set ，不可變數據類型int、str、tuple、bool 是沒有拷貝一說的，他們都沒copy() 方法

二、淺拷貝後是在內存地址中分配了一份新的地址，且淺拷貝只拷貝了第一層，第二層不會拷貝，故第二層若是改變，原數據及淺拷貝後的數據也將改變

三、= 賦值不是淺拷貝，[:] 切片是淺拷貝

a = [11,22,[11,22]]

b = a

注：以上稱爲賦值，只是將a,b都指向了同一個內存地址

c = a.copy() 用的是list中的方法copy是淺拷貝，id(a) 與 id(c) 的內存地址是不一樣的

淺拷貝的標準寫法爲：

import copy

c = copy.copy(a)

三、切片是淺拷貝

切片是淺拷貝的代碼演示

深拷貝：

就是將原文件內部元素徹底拷貝，不會將由於第二層元素改變，另外一個也會改變

深拷貝方法：

import copy

list_new = copy.deepcopy()

擴展：枚舉函數enumerate(itertable,start)

它返回2個參數，以元組形式返回，一個是能夠做爲索引，一個是元素

li = [11,22,33,44]

for i in enumerate(li):

　　print(i)

>>>(0, 11)
>>>(1, 22)
>>>(2, 33)
>>>(3, 44)

擴展:解構,能夠經過解構在循環中直接用兩個變量接收

for k,v from li:

     print(k,v)

基礎數據類型坑你沒商量：

一、range是可迭代對象，可迭代對象均可以進行切片，全部的可變數據類型都有copy方法，但此方法只是對應數據類型寫的和淺拷貝相似功能的方法，而真正的淺拷貝都須要導入copy模塊。

 1 # 二、L = range(100) （4分）
 2 L = range(100)
 3 # 1) 取第一到第三個元素_______
 4 '''list(L)[:3]'''  ===>list(L[:3])
 5 # 2) 取倒數第二個元素_______
 6 '''list(L)[-2]'''  ===>L[-2]
 7 # 3) 取後十個元素_______
 8 '''list(L)[-10:]'''===>list(L[-10:])
 9 # 4) 把L複製給L1用_______
10 '''L1 = L.copy()'''
11 error 我作錯了 ,結論：可迭代對象均可以切片取值，range類沒有copy()方法
12 L1 = L[:] or L1 = L or L1 = copy.copy(L) or L1 = copy.deepcopy()

range

二、當函數被定義時，Python的默認參數就被建立一次，而不是每次調用函數的時候建立。這意味着，若是您使用一個可變默認參數並改變了它，您將會在將來全部對此函數的調用中改變這個對象。

 1 # 二、如下的代碼的輸出將是什麼:___(3分)
 2 #
 3 # def extendList(val,list = []):
 4 #     list.append(val)
 5 #     return list
 6 
 7 # list1 = extendList(10)  = list
 8 # list2 = extendList(123, [])
 9 # list3 = extendList(‘a’)
10 
11 # print 「list1 = % s」 % list1
12 # print 「list2 = % s」 % list2
13 # print 「list3 = % s」 % list3
14 
15 answer:
16 list1 = [10,a]
17 
18 list2 = [123]
19 
20 list3 = [10,a]

默認參數只建立一次，後面都引用它

- 打印進度條

import time
for i in range(0,101,2):
     time.sleep(0.1)
     char_num = i//2      #打印多少個'*'
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)