Python筆記-備忘

1、向列表添加元素

　　x.append(y) #末尾添加一個元素
　　x.extend([y,z]) #末尾添加多個元素
　　x.insert(index，y)

2、向列表獲取元素　　
　　x[index]

3、從列表刪除元素
　　x.remove("y")
　　del x(index) # 刪除整個列表 del x
　　x.pop() # 彈出列表最後一個元素 x.pop(index) 彈出index對應元素

4、列表分片 （建立副本）
　　x[x:y] #x爲開始位置 ，y爲結束位置 結束位置不包含
　　x[x：y：z] #z爲步長 默認爲1 z爲-1，反轉數列

5、列表
　　x.count(y) #計算x中出現多少次y
　　x.index(y) #返回y在x中的位置
　　x.reverse() #列表反轉
　　x.sort（）#從小到大排序 sort(fun,key=None,reverse=False)

6、元組(1,)
　　x = (a,b,c,d,e,f,g,...)　　
　　訪問元組： x[index]　　
　　分片複製元組 x2=x1[:]
　　間接刪除第3個元素 x=x[:2]+x[3:]
　　刪除元組 del x

7、fotmat格式化（012format參數爲位置參數，abc爲標籤，format中將等值的參數替換進去，即爲關鍵字參數，位置參數必須在關鍵字參數前）
　　"{0} love {1}.{2}".format("I","baidu","com")#即' I love baidu.com'
　　"{a} love {b}.{c}".format(a="I",b="baidu",c="com")#即 'I love baidu.com'
　　"{0}:{1:.2f}".format("圓周率",3.14159) #即爲'圓周率：3.14' 位置參數1後加了:替換域中，冒號表示格式化的開始，.2表示四捨五入保留2位小數

8、導入計時
　　import datetime
　　start = datetime.datetime.now()
　　...
　　...
　　delta = (datetime.datetime.now - start).total_seconds( )
　　print(delta)

9、數字處理
　　import math 　　
　　math.floor() #地板 向下取整 int 　　
　　math.ceil() #天花板 向上取整 4.5 =5
　　math.trunc()# 向0的方向取
　　round()#元整 四捨六入 5 取最近的偶數　　

　　math.sqrt()#開方
　　pow(x,y) == x**y
　　bin()#二進制
　　oct()#八進制
　　hex()#十六進制
　　math.pi#  π
　　math.e

10、類型判斷
　　type（） #返回type型
　　isinstance（int，str）# is int 是 str的實例？？

11、列表 [list]
　　能夠是任意對象（數字，字符串。對象，列表）
　　若干個元素 有序排列、可變
　　【】
　　查詢、a[index]
　　　　時間複雜度 O(x) 遍歷 x個元素
　　賦值：list[x] = value
　　刪除：a.clear() #清除，剩下空列表
　　　　a.remove(value)# 移除一個值
　　　　a.pop([index]) #默認彈出最後一個值
　　其餘操做：
　　　　a.reverse()->None# 就地更改 反轉序列
　　　　a.sort(key=None,reverse=False)->None#   就地排序 默認升序 key 一個函數 指定key如何排序
　　列表複製：
　　　　== 比較值 （內容） ； is 比較內存地址
　　　　lst1 = lst0 沒有賦值過程

　　　　A = [1,2,3]
　　　　B = A[:]

　　　　copy->list (shadow copy) x.copy() 依次從新建立
　　　　影子拷貝 及 淺拷貝 只是複製一個引用
　　　　深拷貝 deepcopy -> import copy

　　enumerate(iteralbe) #生成由二元組(元素數量爲二的元組)構成的迭代對象
　　　　　　　　　　　　每一個二元組由可迭代對象的索引及對應元素組成
　　　　普通的 for 循環
　　　　　　>>>i = 0
　　　　　　>>> seq = ['one', 'two', 'three']
　　　　　　>>> for element in seq:
　　　　　　... print i, seq[i]
　　　　　　... i +=1
　　　　　　...
　　　　　　0 one
　　　　　　1 two
　　　　　　2 three

　　　　　　for 循環使用 enumerate
　　　　　　>>>seq = ['one', 'two', 'three']
　　　　　　>>> for i, element in enumerate(seq):
　　　　　　... print i, element
　　　　　　...
　　　　　　0 one
　　　　　　1 two
　　　　　　2 three

　　zip() 函數用於將可迭代的對象做爲參數，將對象中對應的元素打包成一個個元組，而後返回由這些元組組成的列表。
　　　　若是各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操做符，能夠將元組解壓爲列表。

　　　　　　>>> a = [1,2,3]
　　　　　　>>> b = [4,5,6]
　　　　　　>>> c = [4,5,6,7,8]
　　　　　　>>> zipped = zip(a,b) # 打包爲元組的列表
　　　　　　[(1, 4), (2, 5), (3, 6)]
　　　　　　>>> zip(a,c) # 元素個數與最短的列表一致
　　　　　　[(1, 4), (2, 5), (3, 6)]
　　　　　　>>> zip(*zipped) # 與 zip 相反，*zipped 可理解爲解壓，返回二維矩陣式
　　　　　　[(1, 2, 3), (4, 5, 6)]

12、隨機數
　　import random
　　　　    random.randint(a,b) #返回【ab】間的整數
　　　　　random.choice(seq) #從非空列表中隨機挑選一個數
　　　　　random.randrange([start,] stop) [,step] ) #按指定基數遞增的集合中獲取一個隨機數， 基數缺省值爲1
　　　　　random.shuffle(list)# 就地打亂列表元素

十3、元組(tuple) 不可變對象
　　tuple() -> empty tuple
　　t = (1,)
　　訪問元組 經過index
　　查詢 index(value,[start,[stop]])
　　count(value)計數

　　命名元組 namedtuple(typename,field_name,verbose=False,rename=False)
　　　　命名元組，返回一個元組的子類，並定義了字段
　　　　field_name 能夠是空格或逗號分割的字段的字符串，能夠是字段的列表
　　導入 from collections import namedtuple
　　　　例： Point = namedtuple('P[名字]','x,y')
　　　　p1 = Point(4,5)

　　刪除：del tuple

十4、字典 {dict}
　　建立: {}
　　　　　　{keys:value}
　　　　　　dict(key=value)
　　　　　　dict([(key,value),(key,value),])
　　dict1 = dict((('F',70),('A，80')，('S',90))) // dict(F=70,A=90,S=90)
　　　　　　doct1 => {'F':70,'A':80,'S':90}

　　fromkeys()   #建立並返回一個新的字典 ： 兩個參數 第一個爲key [第二個爲value]
　　　　dict1 = {}
　　　　keys =['name','age','job']
　　　　employ = dict.fromkeys(keys)
　　　　employ =>{'name0':None,'age':None,'job':None }

　　　　dict1.fromkeys((1,2,3)) => {1:None,2:None,3:None}
　　　　dict2.fromkeys((1,2,3),"Number") = > {1:"Numbwe",2:"Number",3:"Number"}

　　訪問字典：keys()返回鍵,values()返回字典全部的值,items()返回全部的項
　　　　dict1 = {}
　　　　dict1 = dict1.fromkeys(range(3),'你好')
　　　　dict1.keys() => dict_keys([0,1,2])
　　　　dict1.values() => dict_values(['你好','你好','你好'])
　　　　dict1.items() => dict_items([(0,'你好'),(1,'你好'),(2,'你好')])

　　　　get() #當鍵不存在 。返回None
　　　　dict1.get(31) =>'你好' dict.get(32) =>
　　　　若找不到，可在第二個參數設置values
　　　　判斷是否存在 ： index in dict1

　　　　setdefault() #當鍵不存在，自動添加None

　　更新字典：
　　　　data[key] = value
　　　　pets = {'米奇','老鼠','湯姆','波比'}
　　　　pets.update(米奇='酷奇')
　　　　pets => {'酷奇','老鼠','湯姆','波比'}

　　清空字典 ：
　　　　dict.clear()
　　複製：
　　　　dict2 = dict1.copy() id 1 != 2
　　合併：
　　　　data1.update(data2)

　　pop() popitem()
　　　　dict1.pop(2) #彈出對應的鍵值
　　　　dict2.popitem() #彈出一個簡直想
　　刪除值：
　　　　del data[key]

　　函數賦爲值：行爲方法
　　　　def say_hello():
　　　　　　print('welcome')

　　　　person = {'name':'Jerry','hello':say_hello}
　　　　person['hello']() -> welcome

十5、字符串 不可變對象 有序 可迭代

　　'[]'.join(str)
　　處理： ~ split 系列(切割) 將字符串o按分割符切成若干字符串 並返回列表
　　　　~ s.partition(sep) -> (head,sep,tail)系列 將字符串按分隔符割成2段，返回2段和分隔符的元組
　　　　　　從左至右，遇到分隔符就把字符串分割成兩部分，返回頭、分隔符、尾三部分
　　　　　　若是沒有找到分隔符，就返回頭、2個空元素的三元組
　　　　　　sep分割字符串。必須指定
　　　　s.rpartition(sep) -> (head,sep,tail)
　　　　　　從右至左，遇到分隔符就把字符串分割成兩部分，返回頭、分隔符、尾三部分
　　　　　　若是沒有找到分隔符，就返2個空元素和尾的三元組
　　　　split(sep=None,maxsplit=-1) ->list of strings
　　　　　　從左至右 sep 指定分割字符串。缺省的狀況下空白字符串做爲分隔符
　　　　masxsplit 指定分割的次數，-1表示遍歷整個字符串
　　　　　　分割* splitliness([keepends]) -> list of strings
　　　　　　　按照行來切字符串 keepends 指是否保留行分隔符(\n \t \r)

　　字符串大小寫
　　　　s.upper()# 全大寫
　　　　s.lower() #全小寫
　　　　大小寫，作判斷的時候用 swapcase() 交互大小寫

　　字符串排版
　　　　title() -> str 標題的每一個單詞都大寫
　　　　s.capitalize() -> str 首個單詞大寫
　　　　s.center(width[,fillchar]) -> str width 打印寬度 fillchar 填充的字符
　　　　s.zfill(width) -> str width 打印寬度，居右，左邊用 0 補充
　　　　s.ljust(width[,fillchar]) -> str 左對齊
　　　　s.rjust(width[,fillchar]) -> str 右對齊

　　字符串修改
　　　　s.replace(old,new[,count]) -> str 字符串找到匹配替換爲新字串，返回新字符串 count 表示替代幾回，默認所有替換
　　　　s.strip([chars]) ->str 從字符串兩端去除指定的字符集chars中的全部字符 默認爲去除空白

　　　　s.lstrip([chars]) ->從左開始
　　　　s.rstrip([chars]) ->從右開始

　　字符串查找 *
　　　　s.find(sub[,start,end]]) ->int 從左至右 查找sub(子串) 有返回索引 無，返回-1
　　　　s.rfind(sub[,start,end]]) ->int 從右至左 查找sub(子串) 有返回索引 無，返回-1

　　　　s.index(sub[,start[,end]]) -> int 從左至右 查找sub(子串) 有返回索引 無，拋異常
　　　　s.rindex(sub[,start[,end]]) -> int 從右至左 查找sub(子串) 有返回索引 無，拋異常

　　　　時間複雜度 O(n)
　　　　s.count(sub[,start[,end]]) ->int 在指定區間【)從左至右 統計sub出現的次數

　　字符串判斷 *
　　　　endswith(suffix[,start[,end]]) -> bool 在指定區間，字符串是否suffix結尾
　　　　startwith(prefix[,start[,end]]) -> bool 在指定區間，字符串是否prefix開頭

　　字符串判斷 is 系列
　　　　isalnum() ->bool 是不是字母和數字組合
　　　　isalpha() ->bool 是不是字母
　　　　isdecimal() 是否只包含十進制數字
　　　　isdigit() 是否所有數字(0~9)
　　　　isidentifier() 是否是字母和下劃線開頭，其餘都是字母、數字、下劃線
　　　　islower() 是否都是小寫
　　　　isupper() 是否所有大寫
　　　　isspace() 是否只包含空白字符

　　字符串格式化 ***
　　　　+ 拼接字符串 非字符串先進行轉化
　　　　join 拼接 只能使用分隔符 且被拼接的爲可迭代對象
　　　　格式要求： 佔位符 format % (values)(只能是一個對象，或數目相等的元組)

　　*** format
　　　　"{} {xxx}".format(*args,**kwargs) ->str args 位置參數，一個元組 kwargs 關鍵字參數，一個字典
　　　　花括號即佔位符 {} 按位置匹配 {n} 表示位置參數索引爲n的值
　　　　{{}} 打印{}

　　　　訪問元素
　　　　　　"{0[0]}.{0[1]}".format(('magedu','com')) magedu','com==0 'magedu'=0[0]
　　　　對象屬性訪問
　　　　　　from collections import namedtuple
　　　　　　Point = namedtuple('Point','x,y')
　　　　　　p = Point(4,5)
　　　　　　"{{{0.x}.{0.y}}}".format(p)

　　　　對齊
　　　　　　'{:^30}'.format('centered') 居中
　　　　　　'{:*^30}'.format('centered') 居中 並用*填充

　　　　進制
　　　　　　"int:{0:d}; hex:{0:x}; oct:{0:o}; bin:{0:b}".format(42)
　　　　　　輸出爲： 'int:42; hex:2a; oct:52;bin:101010'
　　　　　　"int:{0:d}; hex:{0:#x}; oct:{0:#o}; bin:{0:#b}".format(42)
　　　　　　輸出爲： 'int:42; hex:Ox2a; oct:Oo52;bin:Ob101010'

十6、集合{set} 無序 {}內無映射關係
　　　　　　num = {1,2,3,4,5,5,6,5,4,3,1,1}
　　　　　　num = {1,2,3,4,5,6}
　　建立集合 ：
　　　　set1 = {xxxxxxxx}
　　　　set2.set([xxxxxxxxxx])

　　訪問集合：
　　　　for each in set1：
　　　　print(each,end='')
　　操做：
　　　　set1.add(num) 增長num
　　　　set1.remove(num) 刪除num

　　不可變集合：
　　　　set1.frozenset({1,2,3,4})
　　　　刪除 del set1

十7、函數、參數即參數結構
　　分類：內建函數、庫函數、
　　　　可變參數： 一個形參能夠匹配任意個參數
　　　　可變位置參數：收集造成一個tuple
　　　　def add(*nums): nums這個形參能夠接受任意個實參
　　　　　　sum = 0
　　　　　　for x in nums:
　　　　　　　　sum += x
　　　　　　return sum
　　　　　add(1,3,5) add(2,4,6) 收集多個實參爲tuple

　　　　可變關鍵字參數：形參前用**符號，表示可接受多個關鍵字參數,收集的實參名和值組成dict
　　　　def showconfig(**kwargs):
　　　　　　for k,v in kwargs.items():
　　　　　　　　print('{} = {}'.format(k,v))

　　　　keywordonly-only 參數
　　　　　　def fun(*args,x,y,**kwargs);
　　　　　　　　print(x)
　　　　　　　　print(y)
　　　　　　　　print(args)
　　　　　　　　print(kwargs)
　　　　　　定義合法
　　　　　　fun(7,9,y=5,x=3,a=1,b='python')
　　　　　　=> 3
　　　　　　　　5
　　　　　　　　(7,9)
　　　　　　　　{'b':'python','a':1}

　　　　　　def fun(*args,x):
　　　　　　　　print(x)
　　　　　　　　print(args)
　　　　　　fun(3,5) 　　=>error
　　　　　　fun(3,5,7)　　 =>error
　　　　　　fun(3,5,x=7) 　　=> x=7, 3,5=args

　　　　　　def fn(*,x,y):
　　　　　　　　print(x,y)
　　　　　　fn(x=5,y=6) x y 必須keyword-only參數

　　　　可變參數和參數默認值：
　　　　　　def fn(*args,x=5):
　　　　　　　　print(x)
　　　　　　　　print(args)
　　　　　　fn() == fn(x=5) () 5
　　　　　　fn(5) == (5,) 5
　　　　　　fn(x=6) == () 6

　　　　　　def fn(y,*args,x=5):
　　　　　　　　print('x={},y={}.format(x,y)')
　　　　　　　　print(args)
　　　　　　n(5)、fn(1,2,3,x=10)、

　　　　　　def fn(x=5,**kwargs):
　　　　　　　　print('x={}'.format(x))
　　　　　　　　print(kwargs)
　　　　　　fn() => x = 5 {}
　　　　　　fn(6)=> x = 6 {}
　　　　　　fn(x=7,y=6) => x= 7 {'y':6}

　　函數參數：
　　　　參數規則通常順序：普通參數、缺省參數、可變位置參數、keyword-only參數、可變關鍵字參數
　　　　　　def fn(x,y,z=3,*args,m=4,n,**kwargs):
　　　　　　　　print(x,y,z,m,n)
　　　　　　　　print(args)
　　　　　　　　print(kwargs)
　　　　　　fn(1,2,n=3) => 1,2,3,4,3 () {}
　　　　　　fn(1,2,10,11,t=7,n=5) =>1 2 10 4 5 (11,) {'t':7}

　　參數解構：
　　　　　def add(x,y:)
　　　　　　　　return x+y
　　　　　add(4,5)
　　　　　t=(4,5)
　　　　   add(t[0],t[1])
　　　　   add(*t) 解構： 非字典型 * 字典型 **

　　　　　d = {'x':5,'y':6}
　　　　   add(**d)

　　內嵌函數和閉包：
　　　　函數內部能夠訪問到全局變量 不要去改變
　　　　　　count = 5
　　　　　　def myFun():
　　　　　　global count
　　　　　　count = 10
　　　　　　print(count)
　　　　　　nuFun() => 10
　　　　　　count => 10

　　閉包：
　　　　def funX(x):
　　　　　　def funY(y):
　　　　　　　　return x+y
　　　　　　return funY
　　　　i = funX(8)
　　　　i(5) => 13 // funX(8)(5)

　　nonlocal :在內部函數中能夠移動外部函數中局部變量的值
　　　　def funX():
　　　　　　x = 5
　　　　　　def funY():
　　　　　　　　nonlocal x
　　　　　　　　x *= x
　　　　　　　　return x
　　　　　　return funY
　　　　funX()() => 25

　　lambda 建立匿名函數 ：
　　　　g = lambda x : 2 * x + 1
　　　　g (5) => 11

　　filter()、map()
　　　　filter有兩個參數，第一個參數能夠是函數或者None， 若是是函數，則將第二個可迭代數據裏的每個元素做爲函數參數進行計算，將返回爲True的值
　　　　　　若是是None，則直接將第二個參數中爲True的值篩選出來
　　　　例：奇數過濾器
　　　　def odd(x):
　　　　　　return x % 2

　　　　temp = filter(odd,range(10)) // list(filter(lambda x : x % 2 ,range(10)))
　　　　list(temp) => [1,3,5,7,9]

　　map() 映射 兩個參數，一個函數加一個可迭代序列，將系列裏的每個元素做爲函數的參數進行運算加工，知道可迭代序列每一個元素都加工完畢，返回新序列

　　　　list(map(lambda x: x * 2,range(10)) => [,2,4,6,8,10,12,14,16,18,20]

十8、高階函數 （函數做爲返回值，一個或多個函數做爲參數，每每造成閉包）
　　y=f(g(x))
　　def counter(base):
　　　　def inc(step=1):
　　　　　　nonlocal base
　　　　　　base += step
　　　　　　return base
　　　　return inc

　　柯里化：原來接受兩個參數的函數變成接受一個參數的函數的過程，新的函數返回一個以原有第二個參數的函數
　　　　z=f(x,y) => z=f(x)(y)
　　例子: 　　 def add(x,y):
　　　　　　　  　return x + y
　　　　　　　print(add(4,5))

　　　　=>   　def new_add(x):
　　　　　　　　   def inner(y):
　　　　　　　　　　  return x + y
　　　　　　　　　return inner

　　裝飾器 *：本質是高階函數，

十9、文件讀寫
　　聲明：open('路徑'，'模式'，encoding='編碼')
　　　　路徑： 'c:\\path\\data.txe'
　　　　　　　 r'c:\path\data.txt'
　　　　模式：文本：'r'讀 'w'寫 'rw' 讀寫 'a' 打開，追加
　　　　　　　　二進制：'*b'
　　　　f = open(r'E:\pythonfile\date.txt','r')
　　　　f.read() #讀取全部信息 指針移動至末尾
　　　　f.seek(0)# 指針移動開頭 ，可從新讀取
　　　　f.tell() #告訴指針位置
　　　　f.close() #關閉文件對象
　　讀寫：
　　　　f.read(n) #讀取n位字符的信息
　　　　f.readlines() #讀取全部行信息
　　　　f.readline() #讀取下一行

　　　　for line in f.readlines():// for line in f:
　　　　　　print(line)

　　查詢當前操做目錄 　   import os
　　　　　　　　　　　　os.getcwd()
　　　　　　　　　　　　os.chdir(r'xxxxxx') 切換目錄

　　文件寫入：
　　　　f = open('路徑'，'模式'，encoding='編碼')
　　　　f.write('xxxxxxxxx')
　　　　f.close()
　　　　f.writelines()# 一次寫入多行
　　　　f.flush() #直接將內存緩存操做顯示在文件上

　　自動釋放資源 　　　　with open('路徑'，'r'，encoding='編碼') as f: 　　　　　　for line in f: 　　　　　　　　print(line) 　　pickle模塊： 　　　　import pickle 　　　　my_list = [123,123.4,'你好'，[another list]] 　　　　pickle_file = open(r'E:\pythonfile\my_list.pkl','wb') 二進制寫入 　　　　pickle.dump(my_list,my_list.file) dump方法保存數據 　　　　pickle_file.close() 　　打開： 　　　　import pickle 　　　　pickle_file = open(r'E:\pythonfile\my_list.pkl','rb')二進制讀 　　　　my_list = pickle.load(pickle_file) load 加載數據 　　　　print(my_list)