python知識點

#ipython的使用
## 幫助功能
？：Ipython的概述和簡介
help(name)：查詢指定名稱的幫助
obj？：列出obj對象的詳細信息
obj？？：列出更加詳細信息

## 特殊變量
_ ：表示前一次的輸出
__：倒數第二次輸出
___：倒數第三次輸出
_dh：目錄歷史
_oh：輸出歷史

## shell命令
!command 執行shell命令
!ls -l
!touch test.txt
files = !ls -l | grep py

## 魔術方法
使用%百分號開頭,ipython內置的特殊方法
%alias定義一個系統的別名
alias ll ls -l
%timeit statement
-n 一個循環loop執行語句多少次
-r 循環執行多少次loop，取最好的結果
%%timeit setup_code
%cd 改變當前工作路徑
%pwd顯示當前工作目錄
%ls 返回文件列表

# 封裝與解構
## 封裝：
將多個值使用逗號分割，組合在一起。本質上是返回一個元組，只是省掉了括號。
如：t1 = 1,2 #實際上將1和2封裝成了元組
temp = a ,a = b,b = temp;等價于 ==>> a,b = b,a

## 解構：
把線性結構的元素解開，順序賦給其他變量；左邊接納變量數要和右邊解開的元素數要一致

*：變量名*收集后組成一個列表
_:丟棄變量

## 例題
取出lst中的數字4：
lst = [1,(2,3,4),5]
_,(*_,a),_ = lst
print(a)
環境變量JAVA_HOME = /usr/bin,返回變量名和路徑：
1. name,path = “JAVA_HOME = /usr/bin”.split(‘=’)
print(name,path)
2. name,_,path = “JAVA_HOME = /usr/bin”.partition(“=”)
print(name,path)
3. 封裝解構來設計冒泡排序：
lst = [1,9,8,5,6,7,4,3,2]
for i in range(len(lst)):
flag = False
for j in range(len(lst)-i-1):
if lst[j]>lst[j+1]:
lst[j],lst[j+1] = lst[j+1],lst[j]
flag = True
if not flag:
break
print(lst)

# 字典（dict）
## 字典的性質
key-value鍵值對的數據的集合?？勺兊?、無序的、key不重復

## 字典定義及初始化
1. d = dict() 或者 d = {}
2. dict(**kwargs) 使用name = value 初始化一個字典
例如：dict(name = “www”) >>> {‘name’:’wkj’}
3. dict(iterable,**kwarg)使用可迭代對象name=value對構造字典，但是可迭代對象的元素必須是一個二元結構
例如：d = dict(((1,’a’),(2,’b’))) 或者 d = dict(([1,’a’],[2,’b’]))
4. dict(mapping,**kwarg) 使用一個字典構建另一個字典
5. d={‘a’:10,’b’:20,’c’:None,’d’:[123]}
6. 類方法dict.fromkeys(iterable,value)
例如：d = dict.fromkeys(range(5))
>>> {0:None,1:None,2:None,3:None,4:None}
d = dict.fromkeys(range(3),10)
>>> {0:10,1:10,2:10}

## 字典元素的訪問
(1) d[key]:返回key對應的值value,若key不存在拋出KeyError異常
(2) get(key[,default])：返回key對應的值value，key不存在返回default，如果沒有default返回None
(3) setdefault(key[,default]):返回key對應的值value；key不存在，添加kv對，value為default，并返回default，如果default沒有，即為None
例如：d = {0:10,1:10,2:8}
>>> d.setfault(0) —> 10
>>> d.setfault(3,8) —> 8

## 字典增加和修改
d[key] = value 將key的對應的值修改為value，若不存在，即添加kv對
update([other]) ：
(1) 使用另一個字典對kv對更新本字典：d.update(d1)
(2) key不存在就添加，如果存在就覆蓋
(3) 就地修改
d.update(red = 1) d.update(((‘red’,1),)) d.update({‘red’:1})

## 字典刪除
(1) pop(key[,default])
key存在，移除它，返回value
key不存在，返回給定的default
default未設置，key不存在則拋出keyError異常
(2) popitem()
移除并返回一個任意的鍵值對
字典為empty，拋出KeyError異常
(3) clear()
清空字典
(4) del語句
del d1[“age”] del d1[1]

## 字典遍歷
(1) 遍歷key
for k in d:
print(k)
for k in d.keys():
print(k)
(2) 遍歷value
for k in d:
print(d[k])
for k in d.keys():
print(d.get[k])
(3) 遍歷item,即KV對
for item in d.items():
print(item) #返回元組
for k,v in d.items():
print(k,v) #返回kv對
for _,v in d.items():
print(v) #返回value

## 字典的key
字典里面的key和set中的key要求一致
可哈希才可以作為key
d = {1:0,2.0:3,”abc”:None,(‘hello’,’world’,’python’):”string”,b’abc’:’135′}

## defaultdict用法
from collections import defaultdict
d1 = {}
d2 = defaultdict(list)
for k in “abcde”:
for v in range(5):
if k not in d1.keys():
d1[k] = []
d1[k].append(v)
print(d1)
for k in ‘mnopq’:
for v in range(3):
d2[k].append(v)
print(d2)

## OrderedDict用法
有序字典可以記錄元素插入的順序，打印的時候也是按照這個順序輸出打印
from collections import OrderedDict
import random
d = {‘banana’: 3, ‘apple’: 4, ‘pear’: 1, ‘orange’: 2}
print(d)
keys = list(d.keys())
random.shuffle(keys)
print(keys)
od = OrderedDict()
for key in keys:
od[key] = d[key]
print(od)
print(od.keys())

# set集合
## set性質、定義、初始化
性質:可變的、無序的、不重復的元素的集合
定義：set() set(iterable)
s1 = set() s2 = set(range(5)) s5 = {3,4,5}

## set的元素
set的元素要求必須是可哈希的
目前不可hash的類list、set
元素不可以索引
set可迭代

## set增加與刪除、成員運算符
s1.add()：增加一個元素，如果元素存在，則什么都不做
s1.update(*other)：合并其他元素到set集合，參數other必須是可迭代對象，就地修改
s1.remove() :從set中移除一個元素，元素不存在則拋出keyError
s1.discard() :set中移除一個元素，不存在，則不操作
s1.pop()：移除一個任意元素，空集返回KeyError異常
s1.clear()：移除所有
in和not in 可以判斷元素是否在set中

## set和線性結構
線性結構的查詢時間復雜度是O(n),而set、dict使用hash值做為key，時間復雜度為0(1)

# 集合
## 集合基本概念
全集，子集，超集，真子集，真超集
并集：多個集合合并部分
交集：多集合公共部分
差集：多集合出去公共部分

## 集合運算
并集： a | b a.union(b) a |= b （就地修改）
交集： a & b a.intersection(b) a &= b（就地修改）
差集： a – b a -= b
對稱差集： a ^ b a ^= b 記作(A-B)U(B-A)

issubset(other) <= 判斷是否是另一集合的子集
set1 < set2 判斷是否真子集
issuperset(other) >= 判斷是否是other超集
set1 > set2 判斷set1是否是set2的真超集
isdisjoint(other) 判斷當前集合與other有沒有交集，沒有交集返回True

# 簡單選擇排序
基礎版：
list1 = [1,9,4,6,2,3,7,8,5]
length = len(list1)

for i in range(length):
maxindex = i
for j in range(i+1,length):
if list1[maxindex] < list1[j]:
maxindex = j
if i != maxindex:
list1[maxindex],list1[i] = list1[i],list1[maxindex]
print(list1)
優化版：
lst1 = [5,4,9,7,1,2,6,3,8]
length = len(lst1)

for i in range(length//2):
maxindex = i
minindex = -i-1
minorigin = minindex
for j in range(i+1,length-i):
if lst1[maxindex] < lst1[j]:
maxindex = j
if lst1[minindex] > lst1[-j-1]:
minindex = -j-1

if lst1[minindex] == lst1[maxindex]:
break
if i != maxindex:
lst1[i],lst1[maxindex] = lst1[maxindex],lst1[i]
if i == minindex or i ==length + minindex:
minindex = maxindex
if minorigin != minindex and lst1[minorigin] != lst1[minindex]:
lst1[minorigin],lst1[minindex] = lst1[minindex],lst1[minorigin]
print(lst1)

# 標準庫datetime
datetime模塊：對日期、時間、時間戳的處理
datetime類：
類方法：
today() 返回本地時區的datetime對象
now() 返回當前時間的datetime對象
ntcnow() 沒有時區的當前時間
fromtimestamp(timestamp,tz = none),從一個時間戳返回一個datetime對象
datetime對象：
timestamp() 返回一個到微秒的時間戳
構造方法：datetime.datetime(2016,07,12,19,23,44,79066)
year month day hour minute second microsecond用對象取這些屬性
weekday() isoweekday() 返回星期的天，前者0開始，后者1開始
date() time() replace() isocalendar()
日期格式化：
類方法strptime(date_string,format),返回datetime對象
對象方法strftime(format),返回字符串
字符串format函數格式化：
import datetime
dt = datetime.datetime.strptime(“21/11/06 16:30”, “%d/%m/%y %H:%M”)
print(dt.strftime(“%Y-%m-%d %H:%M:%S”))
print(“{0:%Y}/{0:%m}/{0:%d} {0:%H}::{0:%M}::{0:%S}”.format(dt))
timedelta對象：
構造方法：datetime.timedelta(days = 0,seconds = 0…)
year = datetime.timedelta(days = 365)
total_seconds():返回時間差的秒數

# 標準庫time
time.sleep(seconds) 將調用線程掛起指定的秒數

# 列表解析 List Comprehension
語法：[返回值 for 元素 in 可迭代對象 if 條件] 它返回的是一個新的列表
優勢：是一種語法糖，編譯器會優化，提高了效率，簡化了代碼，增加了可讀性
練習1.返回 1-10 平方的列表
[x**2 for x in range(1,11)]
練習2.返回lst = [1,4,9,16,2] 的相鄰兩項之和
[lst[i]+lst[i+1] for i in range(len(lst)-1)]
練習3.打印九九乘法表
[print(‘{}*{}={:<3}{}’.format(j,i,i*j,’\n’ if i == j else ”),end=””) for i in range(1,10) for j in range(1,i+1)]
練習4.依次生成前100個ID的列表，左邊4位從1開始的整數，右邊是10位隨機小寫的英文字母。例‘0001.abadicddws’
方法1 import random
[‘{:04}.{}’.format(i,”.join([chr(random.randint(97,122)) for j in range(10)])) for i in range(1,101)]

方法2 import string
[‘{:>04}.{}’.format(i,”.join(random.choice(string.ascii_lowercase) for _ in range(0,10))) for i in range(1,101)]

# 生成器表達式
語法：
-(返回值 for 元素 in 可迭代對象 if 條件)
-列表解析式由中括號[] 換成 小括號
-返回一個生成器
和列表解析式的區別：
-生成器按需計算(惰性求值、延遲計算)，需要的時候才計算值
-列表解析式是立即返回值
生成器：
-可迭代的對象
-迭代器
例如：
-g = (“{:04}”.format(i) for i in range(1,11))
-next(g)
與列表解析式的對比：
-生成器表達式延遲計算，列表解析式立即計算
內存占用
-生成器占用內存較少，二列表解析式占用內存多
計算時間：
-生成器的耗時非常短，列表解析式耗時長
-但是生成器本身并沒有返回任何值，只返回了生成器對象
-列表解析式構造并返回了一個新的列表

# 集合解析式
語法：
– {返回值 for 元素 in 可迭代對象 if 條件}
– 列表解析式的中括號換成大括號{}
– 立即返回一個集合
用法：
– {(x,x+1) for x in range(10)}
– {[x] for x in range(10)} #錯誤，[x] 不可是不可hash的列表

# 字典解析式
語法：
– {返回值 for 元素 in 可迭代對象 if 條件}
– 使用key:value形式
– 立即返回一個字典
用法：
– {x:(x,x+1) for x in range(10)}
– {x:[x,x+1] for x in range(10)}
– {(x,):[x,x+1] for x in range(10)}
– {[x]:[x,x+1] for x in range(10)} # 錯誤 列表不可hash
– {chr(0x41+x):x**2 for x in range(10)}# 它只返回了3個元素，木桶原理，因為一直在向前覆蓋