一層內置函數 >>>>二層基礎數據類型>>>>三層和數字相關14個
四層數據類型4個
1 布爾值 ***bool
只有True 和False，並且首字母必須是大寫。
True:  1 int（非0），    2 str(非‘‘)      非空： True

False: 1 int（0）,        2  str(‘‘)       空： 0，“”，{}，[],（），set（）

2  數字 ***int
    int 應用於 ：+ ，- ，* ，/ ，** ，% ，

    例：int1 = 2  int2 = 12
        int3 = int1 + int2
        int3 = int1 - int2
        int3 = int1 * int2
        int3 = int1 / int2

3 浮點數（小數）***float
    特點： 在取值中 會取值一定的位數

    print(float (1.343))
    a= 3.141592653123456789
    print(a)
    3.141592653123457
    保留15，16位小數 且最後一位是四舍五入 不太理解

4  復數 complex
    復數由     a + bj : 實部和虛部組成
    實數 ：1
    虛部：j -1的平方
    3+ 4j <  5 +2j  錯誤  復數不能比較

四層 進制轉換3個
print(bin(20))
print(oct(20))
print(hex(20))
0b10100
0o24
0x14

1 二進制 bin()
0b10100

2 八進制 oct()
0o24

3 十六進制 hex()
0x14

四層 數學運算 7個

1 計算絕對值  **abs()
l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l1)
print(l2)

2 返回取（商，余）  **divmod()
ret = divmod(8,3)
ret1 =divmod (8,2)
print(ret)
print(ret1)
(2,2)
(4,0)

3 小數精確  **round(x,n)n為保留小數 具有四舍五入的應用
print(round(2.12133112,2))
2.12
print(round(2.12733112,2))
2.13

4 冪運算  **pow()
(x,n)  x**n
(x,n,y)  x**n\y 取商余數 和divmod 比較直接輸出余數
  >>> 分2種情況
    print(pow(2,3))
    print(pow(2,3,4))
    print(pow(2,3,3))
    8
    0
    2

    1 pow(x,y)    x**y
    2pow(x,y,z)   x**y%z

5 求和  sum(iterable,start) ***
    iterable參數必須是一個可叠代數字集
    start指出求和的初始值。start+iterable中的值為最終的和
    print(sum([1,2,3]))
    print(sum([1,2,3],2))         2 為初始值
    # print(sum([1,2,3],[3,4]))  打印報錯 因為([1,2,3],[3,4])不是可叠代對象
    print(sum(range(100)))
    6
    8
    4950
6 計算最小值min（）
    >>>>分2種情況
    字母比較也是一樣的 a<b<c
    1 min(iterable,key,default)

    a min({1,2,3,4,-5})
    print(min({1,2,3,4,-5}))
    1-5

    b min({},1)    不理解

    c min({1,2,3,4,5},key=lambda n:abs(n))
        print( min({1,2,3,4,5},key=lambda n:abs(n)))
        1
        print(min({1, 2, 3, 4, -5}, key=abs))
        1
插入小知識  lambda  是匿名函數的關鍵字相當於def
固定格式  函數名 = lambda 參數（n）：返回值n**n(n的條件)
                print(函數名（參數的值n）)
    a和b 是一樣的
  a def add(x,y):
        return x +y
    print(add(1,2))
  b add=lambda x,y: x+y
    print(add(1,2))

    2 min(*args,key,defult)


6 計算最大值max（）
    字母比較也是一樣的 a<b<c
>>>>分2種情況
    1 max(iterable,key,defult)
    dic = {‘k1‘:10,‘k2‘:100,‘k3‘:30}
    print(max(dic))
    k3  因為此時比較的是ascii 碼的大小
    lis = [1,3,6,-22]
    print(max(lis ,key=lambda k :k))
    print(max(lis ,key=abs))
    6
    -22
    2max(*args,key,defult)

    dic = {‘k1‘: 10, ‘k2‘: 100, ‘k3‘: 30}
    print(max(dic, key=lambda k: dic[k]))
    k2
    條件是dic[k]
    值最大的鍵
一層內置函數 >>>>二層基礎數據類型>>>>三層和數據結構相關24個
四層序列13個>>>列表和元祖2個
1 列表 ***list

    增加

    1append
    增加到最後一個列表
    li = [1, 3, 4, ‘wang‘, ]
    li.append(‘wangyan‘)
    print(li)
    [1, 3, 4, ‘wang‘, ‘wangyan‘]

    2insert
    插入，   xx.insert(3)表示列表裏第2位插入，此處是內容)

    li = [1, 3, 4, ‘wang‘, ]
    li.insert(3, ‘wangyan‘)
    print(li)
    [1, 3, 4, ‘wang‘,‘wangyan’]
    li = [1, 3, 4, ‘wang‘, ]

    3  # extend 叠代的添加 添加的元素分開了疊加，也就是extend後如果是字符串（‘ABC’）後邊則是‘A‘, ‘B‘, ‘C‘,如果後邊是[]
    li = [1, 3, 4, ‘wang‘, ]
    li.extend([1, 2, 3, ‘www‘])
    print(li)
    [1, 3, 4, ‘wang‘, 1, 2, 3, ‘www‘]

    li.extend([1, 2, 3, ‘www‘])
    則變成[1, 2, 3, ‘www‘]
    li = [1, 3, 4, ‘wang‘, ]
    li.extend(‘luodan‘)
    print(li)
    [1, 3, 4, ‘wang‘, ‘l‘, ‘u‘, ‘o‘, ‘d‘, ‘a‘, ‘n‘]

    二刪除  #
    1pop
    按照索引去刪除，有返回值，
    此時註意壓棧思想
    和insert用法類似
    。pop(索引對應的值，數字是多少就是列表的數字的N - 1)刪除那個

    li = [1, 3, 4, ‘wang‘, ]
    li.pop(3)
    print(li)[1, 3, 4]

    2remove
    按照元素去刪除說白了就是刪除名字就行
    例如1‘wang‘

    li = [1, 3, 4, ‘wang‘, ]
    li.remove(‘wang‘)
    print(li)[1, 3, 4]

    3clear
    列空列表結果[]
    li = [1, 3, 4, ‘wang‘, ]
    li.clear()
    print(li)

    4del 用法和正常的鍵盤刪除基本幾樣
    區別.pop.remove.clear
    直接del[]   刪除列裏面切片  取值在刪除

    li = [1, 3, 4, ‘wang‘, ‘True‘, 33, ‘yy‘]
    del li[3:6:2]
    print(li)
    [1, 3, 4, ‘True‘, ‘yy‘]

    三改
    先切片 在刪除 在改正

    1
    字符串的
    li = [1, 3, 4, ‘wang‘, ‘True‘, 33, ‘yy‘]
    li[1:4] = ‘寶寶‘
    print(li)
    [1, ‘寶‘, ‘寶‘, ‘True‘, 33, ‘yy‘]
    切片後先刪除
    4 ‘wang’  變為2位 ‘寶’寶 ‘寶’ 並且叠加

    2，後邊的是列表[]
    取片刪除後進行在刪除的位置合並
    li = [1, 3, 4, ‘wang‘, ‘True‘, 33, ‘yy‘]
    li[1:3] = [‘ad‘, ‘efe‘, ‘eded‘, ‘wian‘]
    print(li)
    [1, ‘ad‘, ‘efe‘, ‘eded‘, ‘wian‘, ‘wang‘, ‘True‘, 33, ‘yy‘]

    四查 切片 查看
    li = [1, 3, 4, ‘wang‘, ‘True‘, 33, ‘yy‘]
    print(li[3:6])
    [‘wang‘, ‘True‘, 33]

    li = [1, 3, 4, ‘wang‘, ‘True‘, 33, ‘yy‘]
    del li
    print(li)
    結果為空的

    打印長度
    li = [1, ‘dfs‘, 23, 87]
    print(len(li))

2 元祖*** tuple
    元組被稱為只讀列表，即數據可以被查詢，但不能被修改，所以，字符串的切片操作同樣適用於元組。
    例：（1，2，3）（"a","b","c"）
一層內置函數 >>>>二層基礎數據類型>>>>三層和數據結構相關24個
四層序列13個>>>相關內置函數2個
    1 反轉 **reversed()   叠代器的
                recersed()  叠代器   1 新生成一個列表不改變原列表 2 有返回值還是一個叠代器
                                2還有個是就是強轉的list(ret)
                reserse()  反轉   1 不會生成一個列表改變原來的列表 2  返回值是Npne

    l = [1, 3, 5, 4, 2, 7]
    ret = reversed(l)
    print(ret)
    print(list(ret))
    <list_reverseiterator object at 0x02B6A370>  叠代器
    [7, 2, 4, 5, 3, 1]

    l = [1, 3, 5, 4, 2, 7]
    l.reverse()
    print(l)
    [7, 2, 4, 5, 3, 1]
    拓展 sort（） 是從小到大排序
    sort() reversed()

    li = [1,3,5,6,4,2]
    li.sort()
    print(li)

    li.reverse()
    print(li)
    [2, 4, 6, 5, 3, 1] 列表反轉

    li = [2, 4, 6, 5, 3, 1]
    li .sort(reverse = True)
    print(li)
    [6, 5, 4, 3, 2, 1]  列表倒序

2 slice 切片  轉成元祖
    l = (1,2,23,213,5612,342,43)
    sli = slice(1,5,2)
    print(l[sli]）
    (2, 213)

一層內置函數 >>>>二層基礎數據類型>>>>三層和數據結構相關24個
四層序列13個>>>字符串9個
    1 字符串***str
    a 帶引號的都是字符串    三引號 可以跨行
    name = ‘郭鵬達‘name2 = "王巖"
    例：  msg = ‘‘‘

         字符串

    ‘‘
    b 字符串拼接。 字符串加法和乘法。 S1 = ‘abc’  s2 = ‘123’  print(s1 + s2)  ‘abc123’
    2 .format()  
         大括號內是改變輸出前的內容  大括號內空 和。format() 一一對應
    li = [‘alex‘,‘eric‘,‘rain‘]
    # # 利用下劃線將列表的每一個元素拼接成字符串"alex_eric_rain"
    
    info = "{}_{}_{}".format(li[0],li[1],li[2])
    print(info)
    
    #第一種： 大括號內是改變輸出前的內容  大括號內空 和。format() 一一對應
    ret18 = ‘name :{},sex:{},hig:{}‘.format("王巖","男",174)
    print(ret18)
    name :王巖,sex:男,hig:174
    
    3 字節 *** bytes 
        1 acsic碼   基本不用    不同編碼之間互用會產生亂碼，
        2 unicode  　　　  A 字母  4個字節   00000000 00000000 00100100 01000000
    　　　　　　　　           中 文    4個字節    00000000 00000000 00100100 00000000 
        3utf-8 中文        A 字母  1個字節      00000001  
    　　　　　　　　歐  洲  2個字節     00000000 00000000 00100100 00000000
    　　　　　　　  亞洲  中文 3個字節  00000000 00000000 00000000 00100100 0000000
        4 gbk              A  字母 2個字節        00000000 00001000
    
    　　　　　　                中文  亞洲  2個字節    00100100 00000000
    
    bytes ：表現形式：    s =  ‘Q’   b1 = s.encode (‘utf-8‘)   print (b1)   b1 = b‘Q‘  
    　　　 內部存儲是（utf-8 ，gbk ，gb232等）
    
    　　　  s1 = ‘曉梅‘      b11 = s1.encode(‘utf-8‘)
    表現形式： s = b‘\xe6\x99\x93\xe6\xa2\x85‘ （utf-8,gbk，gb2312.....）010101
    
         0000 1000 0000 0000 0000 0001 0000 1001 0000 0000 0000 0001
    註意：在utf-8 的情況下b 後邊有6個 （e6 99 等） 說名 曉梅 是中文 utf-8 是兩個字6個字節
    4 bytearray  
    5 memoryview
    6 ord   字符按照unicode轉數字
    7 chr   數字按照unicode轉字符
    8 ascii 只要是ascii碼中的內容，就打印出來，不是就轉換成\u
    9 **rep  用於%r格式化輸出     
    區別就是 輸出什麽就是什麽 註意引號
    print(‘name,%r‘%‘金老板‘)
    name,‘金老板‘
    print(‘name,%s‘%‘金老板‘)
    name ，金老板
    一層內置函數 >>>>二層基礎數據類型>>>>三層和數據結構相關24個
    四層序列13個>>>數據集合3個
    
    1 **字典   
    字典相關的代碼
    1、字典的特性：a 字典的無序性； b 數據關聯性強 C 鍵鍵值對   唯一一個映射數據類型
    字典的鍵必修二是可哈希的（不可變的數據類型：,字符串，數字的，布爾值，元祖）
    並且是唯一的
    不可哈希的（可變的數據：列表，字典，set 集合）
    例子 ,
    dic = {‘name‘:‘aima‘,‘age‘:43}
    2 增加
    a、 增加 dic [‘k‘] = v 直接可覆蓋  dic[‘name‘] = ‘wangyan‘
    b 、dic.sedefault (‘k‘)  有鍵值對不做任何改變，沒有鍵值對才添加
    dic = {‘name‘:‘aima‘,‘age‘:43,‘sex‘:‘men‘}
    dic[‘name‘] = ‘wangyan‘
    print(dic)
    dic.setdefault(‘goodmen‘,‘wangyan‘)
    print(dic)
    有鍵值 不做任何反應還是原來的字典 ，沒有的就添加新的
    
    3 、刪除
    a .pop()  刪除一個鍵 就刪除一個組
    dic.pop(‘name‘)
    print(dic)
    
    壓棧思想 .pop()  默認返回最後一個值 
    li=[]
    l = [1,2,3,4,5]
    l1 = l.pop()
    print(l1)
    5 
    
    b 、del 直接刪除k 鍵
    del dic[‘age‘]
    print(dic)
    dic = {‘name‘:‘aima‘,‘age‘:43,‘sex‘:‘men‘}
    4 改
    a 和第一種增加一樣 覆蓋
    
    dic[‘name‘] = ‘luodan‘
    print(dic)
    b   .update()
    dic1 = {‘boy‘:‘wangmutian‘}
    dic .update(dic1)
    print(dic)
    {‘name‘: ‘aima‘, ‘age‘: 43, ‘sex‘: ‘men‘, ‘boy‘: ‘wangmutian‘}
    5 查 直接打印k 就能得到V的值 但是如果沒有k鍵 就會報錯 提示None
     a 直接打印k
    
    for key in dic:
        print(key)
    
    name
    age
    sex
    
    b for i in dic.keys():
    for i in dic.keys():
        print(i)
    
    6重要的格式 一定要記住!!!!!!!!! 低級盡量不用
    dic = {‘name‘:‘aima‘,‘age‘:43,‘sex‘:‘men‘}
    for key,value in dic.items():
        print(key,value)
    name aima
    age 43
    sex men
    for key in dic:
        print(key,dic[key])
    
    dic = {‘name‘:‘aima‘,‘age‘:43,‘sex‘:‘men‘}
    7列表變成字典 如果後邊有1 ，就是值 否則[]裏面都是k 值
    分別給鍵對值
    
    
    dic = dict.fromkeys([‘22‘,(1,2),‘wangyan‘,‘zhang‘],‘kk‘)
    print(dic
    {‘22‘: ‘kk‘, (1, 2): ‘kk‘, ‘wangyan‘: ‘kk‘, ‘zhang‘: ‘kk‘}
    固定格式  一定的是
    dic =  dict.fromkeys()                                   ）
    
    2 **集合
    集合是無序的 元素是可哈希的（不可變的數據類型：int  str   tuple bool ）
    但是集合本身是不可哈希的（可變的數據類型） 所以做不了字典的鍵
    主要是用於去重
    
    a  每次打印都是無序的 都不一樣的
    set = {1,‘wag‘,4 ,‘Tru‘,3}
        print(set)
    set = {1,‘wag‘,4 ,‘Tru‘,3，3}
    print(set)
    直接打印去重 
    b  集合的增刪改查
     增加 。add()   .update
     刪  。pop
     改 
     查 for i in set1
    c 集合的交集 並集 反交集
    
    交集&（and） 取公共部分
    差集(-)  取set1  交集以外的set1
    並集  取所有的  但是重復部分取一次  用|表示
    set(lis)&set1(lis2)
    set(lis)-et1(lis2)
    
    set1 ={1,2,3,4}
    set2 ={2,3,4,5,6,7,8}
    交集
    print(set1&set2)
    {2, 3, 4}
    
    去重 並集  | 表示
    print(set1|set2)
    {1, 2, 3, 4, 5, 6, 7, 8}
    
    差集
    print(set1-set2)
    {1}
    
    3 **冷凍集合  暫無資料
    
一層內置函數 >>>>二層基礎數據類型>>>>三層和數據結構相關24個
四層序列13個>>>相關內置函數8個
    
    1 **len() 長度  字符串 列表  包含空
    lis = [1,4,3,2]
    print(len(lis))
    s = ‘wangyanluodanwangmutian  ‘
    s1 = ‘wangyanluodanwangmutian‘
    print(len(s))
    print(len(s1))
    4
    25
    23
    
    2 **枚舉，對於一個可叠代的（iterable）/可遍歷的對象（如列表、字符串），
      enumerate將其組成一個索引序列，利用它可以同時獲得索引和值。
    就是打印列表的索引和值
    li = [‘alex‘,‘銀角‘,‘女神‘,‘egon‘,‘太白‘]
    for i in enumerate(li):
        print(i)
        (0, ‘alex‘)
        (1, ‘銀角‘)
        (2, ‘女神‘)
        (3, ‘egon‘)
        (4, ‘太白‘)
    
    for index,name in enumerate(li,1):
        print(index,name)
        1 alex
        2 銀角
        3 女神
        4 egon
        5 太白
3 all 判斷是否有bool值為False 的值
4 any 判斷是否有bool值為True  的值
5 **zip 返回一個叠代器必須有個list 轉化   以最短的為基準 將兩個列表整合成兩個列表 分別取值
     print( list(zip([1,2,3,4,5],[2,3,4])))
     [(1, 2), (2, 3), (3, 4)]

    
6 filer 過濾 通過函數的定義過濾
    def small(x):
        if x < 10:
            return True
    ret = filter(small,[1,4,3,22,55,33])
    print(list(ret))
    [1,4,3]
    def small(x):
        return x % 2 == 1
    ret = filter(small,[1,4,3,22,55,33])
    print(list(ret))
7 map 返回一個新的列表
    L = [1,2,3,4,]
    def pow2(x):
        return x*x
    print(list(map(pow2,L)))
8sorted
l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l2)

一層內置函數 >>>>二層作用域相關
1 global  改變全局的
     n = 1
    def func():
        global n
        n = n +1
        print(n)
    print(n)
    func()
    print(n)
   1 ，2，2
2 local  的內容會根據執行位置來決定作用域中的內容 如果在全局執行 和globals() 一樣
3 nonlocl  修改最近擁有該變量的外層函數  不影響全局 
    n = 1
    def func1():
        n = 2
        def func2():
            nonlocal n
            n+=1
            print(n)
        func2()
    func1()
    print(n)
    答案 是 3 引用上級的, 1 全局的
一層內置函數>>>>二層叠代器/生成器相關(3)
    判斷是不是可叠代對象 print(‘__iter__‘in dir(對象))
            print(isinsstance(對象)，iterable  )
   叠代器的含義   含有 .__iter__() 的 且比可叠代對象多一個next 方法 
   方 法  next    iter 兩個個用法
   生成器的含義本質 生成器的本質就是叠代器
   方法
1 iter    可叠代對象的一個方法

2 next  叠代器的比可叠代對象多個方法

3 ***range  
    yield  py關鍵字   genertaor   生成器  
    含有yield的話就變成了生成器 
    條件有二
    1是有yield
    2函數的調用
    3 print(g) 是 F 或者T   是不是生成器？？？
    4 打印t(g._next_())
    打出來就是yield 後面 
    例子 
    打印出100件衣服 標上序號
        def  cloth():
        for i in range (100):
            yield (‘衣服%s‘%i)
    g = cloth()
    1 一件一件的打印
    print(g.__next__())
    2打印前50件
    for i in range(50):
        print(g.__next__())
    3全打出了來
    for i in g:
        print(i)
一層內置函數>>>>二層叠代器/生成器相關(3)>>>>其他>>>>字符串類型代碼的實行3個
        註意這個三個盡量不要用 或者請示領導再用
    1 **eval   執行 有返回值的  可以拿到結果的 
    2 **exec 用於流程性代碼的執行   
        print(exec(‘1+3-3-1‘))
        print(eval(‘1+3-3-1‘))
        None
        0
    3 compile  編譯
一層內置函數>>>>二層叠代器/生成器相關(3)>>>>其他>>>>輸入輸出2個
    1  ***input 用戶交互  name = input (‘請輸入內容‘) 必須是str
    2  ***print  打印出內容  默認是sep = ‘,‘
    print(1,2,3,4,5 ,sep = ‘*‘)
        1*2*3*4*5
一層內置函數>>>>二層叠代器/生成器相關(3)>>>>其他>>>>內存相關2個
    id  hashi函數是一個算法  結果是一個數字   每次數字不一樣的 
        存儲和查找    只要不可變就是
    1 ***hash 可哈希（不可變）  不可哈希（可變）
    2 id  內存地址
    print(id(‘wangyan‘))
    print(hash(‘wangyan‘))
    每次打印的數字都是u不一樣的
一層內置函數>>>>二層叠代器/生成器相關(3)>>>>其他>>>>文件操作相關(1)
 1 **open  
 f = open(‘文件名‘,encoding = ‘utf-8‘)
 打開模式 有 默認 r  讀模式
                 w 寫模式 清空
                 a  不可讀 追寫文件的最後 沒有則創建
                 b 以字節的形式打開
一層內置函數>>>>二層叠代器/生成器相關(3)>>>>其他>>>>模塊相關(1）
1 ***import  
    import os
    os.remove()
    os.rename(‘old‘,‘new‘)
    import  time
    start = time.time()
    end = time.time()
一層內置函數>>>>二層叠代器/生成器相關(3)>>>>其他>>>>查看(1）
    在pyxm   左鍵單擊
    help 包含所有的用法
    in dir 只包含方法名字
1 help
    a  直接help   退出 q
    b  help(數據類型)   制定查看某對象的幫助信息
一層內置函數>>>>二層叠代器/生成器相關(3)>>>>其他>>>>調用相關(1）
1 callable 是否可以調用  返回布爾值  
    a = [1,3,4,6]
    print(callable(a))
    print(callable(print()))
    print(callable(‘abc‘)) 
       全是False
2 **dir  1 查看內置屬性  dir(__builthin__)
       2 查看某對象的屬性及方法 dir()
 
           

內置函數大總結