一、ipython的使用
1、ipython ??python的一個解釋器。
2、官網介紹，幫助文檔。
3、看out。。- ?– ?–
4、？Ipython的概述和間接
Help（name）
查詢指定名稱的幫助。
Obj？列出obj對象的詳細信息。
Obj？？列出更加詳細的信息。
5、特殊變量
_表示前一次輸出
—表示倒數第二次輸出。
——表示倒數第三次輸出。
-Oh顯示所有輸出歷史。
-dh 顯示目錄。
6、執行shell的命令。
調用shell能用的命令。
!command執行shell命令。
!ls-l
!touch test.txt
File=!ls -l |grep py
7、魔術方法。
使用%號開頭，ipython ????%timeit時間函數。
使用%%號的開頭。
%%js
使用%百分號開頭的，IPython內置的特殊方法
%magic 格式
% 開頭是line magic
%% 開頭是 cell magic，notebook的cell
%alias 定義一個系統命令的別名
alias ll ls -l
%timeit statement
-n 一個循環loop執行語句多少次
-r 循環執行多少次loop，取最好的結果
%%timeit setup_code
code…..
8、魔術方法
%cd 改變當前工作目錄，cd可以認為是%cd的鏈接。路徑歷史在_dh中查看
%pwd、pwd 顯示當前工作目錄
%ls 、ls 返回文件列表
注意：%pwd這種是魔術方法，是IPython的內部實現，和操作系統無關。而!pwd 就要依賴當前操
作系統的shell提供的命令執行，默認windows不支持pwd命令
%%js、%%javascript 在cell中運行js腳本
%%js
alert(‘a’ + 1)
二、封裝和解構。
1、轉變成為元組。
2、先算后面的，在算左邊的。
3、封裝，將多個值使用逗號分隔，組合在一起。。本質上，返回一個元組，只是省略了一個小括號。。t1=(1,2) ???t2=1,2封裝成tuple。
4、解構，把線性結構的元素解開，并順序的賦給其它變量。
lst=[3,5]
first,second=lst
print(first,second)
3 5
左邊接納的變量數要和右邊解開的元素個數一致。帶有*號的除外。 ????x,y=list((2,3))
list .tuple .string ,bytes ,bytearray.
x,y=”a”,”b”既有封裝又有解構的表達式。
舉例子：[a,b]=(1,2) ????a,*b=(1,2,3) ????a,b={1,2}
5、使用*變量名接受，但不能單獨使用。 ???lst=list(range(1,50,2)) ???head,*mid,tail=lst
6、被*變量名收集后組成一個列表。
7、*變量名盡可能多或者是沒有。
8、丟棄變量。_
是一個慣例，是不成文的規定。如果不關心一個變量，可以將其丟棄。_是合法的標示符，看到下劃線就知道是被舍棄的變量。
9、總結。_這個變量本身無任何意義，沒有任何可讀性。
三、集set
1、set翻譯為集合。
2、Collection翻譯為集合類型，是一個大概念。
3、Set是可變的，無序的，不重復的，元素的集合.
4、空的大括號是字典，大括號里面有元素的稱為set。
5、空的集合就是s=set（）。 ????列表和bytes不能。
6、Set定義，初始化； ??()括號里面加可迭代的對象。
s1=set()
s2=set(range(5))
s3={(1,2),3,’a’}
7、必須是可hash（）的才能夠作為列表。
8、Set的元素。Set的元素要求必須可以hash。目前不可以hash的類型有list、set。
1）元素不可以索引。
2）Set可以迭代。
9、Set增加。add（elem），如果元素存在什么都不做。 add(‘abc’) ??s.add(15)
10、Update(*others)，合并其他元素到set中?？梢詫懚鄠€可迭代對象。 就地修改。update(‘bcd’)
11、元素移除。remove（） ?discard（）不管有沒有都不會報出異常。。pop（）
clear（）移除所有元素清除。
12、set修改，查找。 ?要么刪除，要么加入新的元素。K就是對值進行求hash，然后房間放東西，查找的時候直接去房間拿東西。
成員運算符。In和no int判斷元素是否在set中。 效率比較低。
13、set成員運算符的比較。
list和set的比較。Set的效率比較高，原因是因為hash。
14、Set和線性結構。
線性結構的查詢時間復雜度是O(n)，即隨著規模的增大而增加耗時。
Set ?dict等結構，內部使用hash作為key，時間復雜度可以做到O（1），查詢時間和數據規模無關。
15、不可變類型，成為可哈希類型。（想要哈希的話就應該有明確的值）。 拿所給的值。列出散落值。
16、可hash的類型。
數值型int 。Float。Complex。
布爾值True ?Flase
字符串string，bytes
tuple
None
都是不可變類型，成為可哈希的類型，hashable。
17、集合
概念。
1)全集
所有元素的集合，例如實數集，所有實數組成的集合就是全集。
2)子集（subset）和超集（superset）
一個集合A所有的元素都在另一個集合B內，A是B的子集，B是A的超集。
3）真字集合真超集。
A是B的子集，且A不等于B，A就是B的真子集，B就是A的真超集。
4）并集，多個集合合并的結果。
5）交集，多個集合公共的部分。
6）差集，集合中除去和其它集合公共部分。
7）并集：將兩個集合A和B的所有元素合并到一起，組成的集合稱作集合A和集合B的并集。Union(*others) ??返回和多個集合合并后的新的集合。
8）|運算符重載 ?等同于union。
9）Update（*others） ??和多個集合合并，就地修改。
10）|=等同于update。
11）交集：集合A和集合B，由所有屬于A且屬于B的元素組成的集合。
Intersection(*others) 返回和多個元素的交集。
&等同于intersection
Intersection_update(*others) 獲取和多個集合的交集，并就地修改。
&=等同于intersection_update.
12）集合運算 ?差集
集合A和集合B，由所有不屬于A且不屬于B的元素組成的集合。
Difference（*others） ?返回和對個集合的差集。
– 等同于difference
Difference_update(*others)
獲取和多個集合的差集并就地修改。
-=等同于 difference_update
13)對稱差集 ?集合A和B，由所有不屬于A和B的交集元素組成的集合，計做作（A-B）∪（B-A）
Symmetic_difference(other) 返回和另一個集合的差集。
Symmetric_difference_update(other)獲取和另一個幾個的差集并就地修改。
^等同于Symmetic_difference
^=等同于Symmetric_difference_update
14）集合運算。
Issubset（set）、<= ?判斷當前集合是否是另一個集合的子集。
Set1<set2 判斷set1是否是set2的真子集。
Issuperset（other）、>= ??判斷當前集合是否是other的超集。
Set1>set2 判斷set1是否是set的真超集。
Isdisjoint（other） ?當前集合另一個集合沒有交集。沒有交集，返回True。
集合去重，做隨機運算。
四、選擇排序
- 簡單選擇性排序。
簡單選擇排序，兩兩比較大小，找出極值，（極大值和極小值）被放置在固定位置的某一端。結果分為升序和降序。
簡單選擇排序總結：
需要數據的一輪輪比較，并在每一輪中發現極值。
沒有辦法知道當前輪是否已經達到排序要求，但是可以知道極值。
遍歷次數1，。。。N-1之和n（n-1）/2
時間復雜程度O（n（**2））。
減少了交換次數，提高了效率，性能略好于冒泡法。
五、字典。dict
1）定義
Key-value鍵值對的數據的集合，可變的無序的，key不重復
2）初始化，定義.
d={} 空的
d=dict(a=1,b=2) ????{‘a’: 1, ‘b’: 2}
類方法。d=dict.fromkeys(range(5))
d=dict.fromkeys(range(5),0)
dict(**kwargs) 使用name=value對初始化一個字典
dict(iterable, **kwarg) 使用可迭代對象和name=value對構造字典，不過可迭代對象的元素必須是一個二元結構
d = dict(((1,’a’),(2,’b’))) 或者 d = dict(([1,’a’],[2,’b’]))
dict(mapping, **kwarg) 使用一個字典構建另一個字典
d = {‘a’:10, ‘b’:20, ‘c’:None, ‘d’:[1,2,3]}
3）字典元素的訪問
d[key] ??返回key對應的值。
key不存在拋出KeyError異常
get （key[,default]） ?d.get(6,2000)不會報錯。 ?key 不存在返回缺省值。
返回key對應的值value
key不存在返回缺省值，如果沒有設置缺省值就返回None
setdefault（key[，default])
setdefault(100,300)不存在的話創建，存在的話不改變。
返回key對應的值value
key不存在，添加kv對，value為default，并返回default，如果default沒有設置，缺省為None
4）增加和修改。
d=[key]=100將key對應的值修改為value。創建后直接賦值。Key存在不變，不存在直接賦值。Key是唯一的，key的位置是隨機的。
d[key] = value
將key對應的值修改為value
key不存在添加新的kv對
update([other]) -> None
使用另一個字典的kv對更新本字典
key不存在，就添加
key存在，覆蓋已經存在的key對應的值
就地修改
d.update(red=1)
d.update(((‘red’,2),))
d.update({‘red’:3})
5）字典刪除。
pop（key[，default]）。彈出元素。pop（key）
popitem （） 移除并返回一個任意的鍵值對。
返回的是二元組，，key和value對應的。
clear（）清空字典。
6）字典刪除del。
del實際上刪除的是名稱，而不是對象。本質上減少了一個對象的引用。
7）字典的遍歷。 for i in ??dict ??拿出所有的key。拿到的都是key值。
遍歷k
for k in d.keys():????????????????????????for k in d:
print(k)???????????????????????????print(k)
for key in d.keys():
print(key)
遍歷value
for value in d.values():???????????????for k in d:
print(value)????????????????????print(d.get(k))
for k in d:
print(d[k])????????????????????????????for k in d.keys():
print(d.get(k))
遍歷k,v對
for key,value in d.items():
print(key,value)
for k ,_ in d.items():
print(k)
for _,v in d.items():
print(v)
8）字典遍歷的總結。
Keys，values,Items方法返回一個類似一個生成器的可迭代對象，不會把函數的返回值復制到內存中。
dictionary view對象。
字典的entry的動態的試圖，字典變化，視圖將反應出這些變化。
9）字典遍歷和移除元素
移除字符串，str。
keys=[]
for k in keys:
d.pop(k)
print(k)
for 循環過程中是堅決不允許移除元素的。
10)字典的key
要求必須和set的元素要求一致，，
Key必須可hash，key是去重復的。
d = {1 : 0, 2.0 : 3, “abc” : None, (‘hello’, ‘world’, ‘python’) : “string”, b’abc’ : ‘135’}
{1: 0, 2.0: 3, b’abc’: ‘135’, ‘abc’: None, (‘hello’, ‘world’, ‘python’): ‘string’}
11）defaultdict
collections.defaultdict([default_factory[, …]])
collentions.default
import random
from collections import defaultdict
d=defaultdict(list)
for i in ‘abcdef’:
for i in range(random.randint(1,5)):
d[k].append(i)
print(d)
12）ordereddict有序的字典。
collections.OrderedDict([items])
key并不是按照加入的順序排列，可以使用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())
有序字典可以記錄元素插入的順序，打印的時候也是按照這個順序輸出打印。
應用的用途：
假如使用字典記錄了N個產品，這些產品使用ID由小到大加入到字典中
除了使用字典檢索的遍歷，有時候需要取出ID，但是希望是按照輸入的順序，因為輸入順序是有序的
否則還需要重新把遍歷到的值排序.
六、解析式、生成器。
1、標準庫datetime：datetime模塊。datetime.now()
1）對日期，時間，時間戳的處理。
datetime類
類方法:today() 返回本地時區當前時間的datetime對象
now(tz=None) 返回當前時間的datetime對象，時間到微秒，如果tz為None，返回
和today()一樣
utcnow() 沒有時區的當前時間
fromtimestamp(timestamp, tz=None) 從一個時間戳返回一個datetime對象
datetime對象，timestamp（）返回一個到微妙的時間戳。
時間戳:格林威治時間1970年1月1日0點到現在的秒數
2)datetime對象
構造方法 datetime.datetime(2016, 12, 6, 16, 29, 43, 79043)
year、month、day、hour、minute、second、microsecond，取datetime對象的年月日時
分秒及微秒
weekday() 返回星期的天，周一0，周日6
isoweekday() 返回星期的天，周一1，周日7
date() 返回日期date對象
time() 返回時間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對象
datetime2 = datetime1 + timedelta
datetime2 = datetime1 – timedelta
timedelta = datetime1 – datetime2
構造方法
datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0,
minutes=0, hours=0, weeks=0)
year = datetime.timedelta(days=365)
total_seconds() 返回時間差的總秒數
time
time.sleep(secs) 將調用線程掛起指定的秒數
2、列表解析式
1）b=[i for i in range(10)]
print(b)
使用[]括號，內部是for循環，if語句可以多選。
返回一個新的列表。
2）編譯器會優化，不會因為簡寫而影響效率，反而因優化提高了效率。
減少工作量，減少出錯。
簡化代碼，可讀性增強。
3、生產器表達式。
1)(返回值 for元素 in 可迭代對象 if條件）
利用小括號。
返回一個生成器。
返回的是生成器對象.
2）和列表解析式的區別，表達式是按需計算（或稱為惰性求值，延遲計算）需要的時候才會出現。 ?????不會立即生成一個值。 ??迭代器是可迭代對象，但是可迭代對象但不一定是可迭代器。
列表解析式立即返回一個值。
3）生成器：可迭代對象，迭代器。
g=(i for i in range(5))
for i in g:
print(i)
4、生成器，可迭代對象，迭代器。
next迭代器查看。 ??next（）包裝的是不同的迭代器的數字。
1)next總結
延遲計算
返回迭代器，可以迭代
從前到后走完一遍后，不能回頭
2）不添加next的總結
總結
立即計算
返回的不是迭代器，返回可迭代對象列表
從前到后走完一遍后，可以重新回頭迭代.
it=(print(“{}”.format(i+1))for i in range(2))
first=next(it)
second=next(it)
val=first+second ???此種情況不成立。
Print返回值是none。
成立的表達式：
it = (x for x in range(10) if x %2)
first=next(it)
second=next(it)
val=first+second
print(first,second)
5、生成器和列表解析式的對比。
1)計算方式：生成器表達式延遲計算，列表解析式立即計算。
2）內存占用：單從返回值來看，生成器表達式省內存，列表解析式返回新的列表。
生成器沒有數據，內存占用極少，但是使用的時候，雖然一個個返回數據，但是使用的內存也不多。
列表解析式構造新的列表需要占用內存。
3）計算速度：計算時間來看，生成器耗時非常短，列表解析式耗時長。
但是生成器本身并沒有任何返回值，只返回了一個生成器對象。
列表解析式構造并返回了一個新的列表。
6、集合解析式
{返回值 for 元素 in 可迭代對象，if} ?立即返回一個對象。
使用一個大括號。
{(x,x+1)for x in range(10)}
7、字典解析式。
{K：v} 使用key，value值 ?立即返回一個字典。
8、總結
一般來說，多應用解析式，簡短，高效。
迭代器和生成器是不同的對象，但都是可迭代對象。
七、習題練習
1、求楊輝三角第m行第k列的值
m=5
k=4
a=[]
for i in range(m):
pre=[1]
a.append(pre)
if i==0:
continue
for j in range(1,i):
pre.append(a[i-1][j-1]+a[i-1][j])
pre.append(1)
print(a)
2、# 打印矩陣
import copy
f1=[[1,2,3],[4,5,6],[7,8,9]]
f2=copy.deepcopy(f1)
for i in range(len(f1)):
for j in range(len(f2)):
f2[i][j]=f1[j][i]
print(f1)
print(f2)
3、#打印矩陣
f3=[[1,2,3],[4,5,6]]
f4=([[1,1],[1,1],[1,1]])
for i in range(len(f4)):
for j in range(len(f4)-1):
if i<=1:
f4[i][j-1]=f3[j-1][i]
elif i==2:
f4[i][j]=f3[j][i]
print(f3)
print(f4)
4、#判斷數字
import random
nums=[]
repetition=[]
withoutrepetition=[]
for i in range(10):
nums.append(random.randrange(1,21))
print(nums)
length=len(nums)
for x in range(length):
print(‘number:{0}:出現次數:{1}’.format(nums[x],(nums.count(nums[x]))))
if nums.count(nums[x])>=2:
repetition.append(‘{}:’.format(nums[x]))
elif nums.count(nums[x])==1:
withoutrepetition.append(‘{}: ‘.format(nums[x]))
print(“重復的數字是”,set(repetition))
print(“不重復的數字是”,withoutrepetition)
5、#簡單選擇排序
b=[1,3,5,7,2,8,6,9,4]
length=len(b)
for i in range(length):
maxindex=i
for j in range(i+1,length):
if b[j]>b[maxindex]:
maxindex=j
if i!=maxindex:
b[i],b[maxindex]=b[maxindex],b[i]
print(a)
6、利用字典打印用戶輸入的數字
num=input(‘please input’)
d={}
for i in num:
if i not in d.keys():
d[i]=1
else:
d[i]+=1
print(d)
7、數字重復次數統計
import random
nums=[]
d={}
for i in range(100):
nums.append(random.randint(-1000,1000))
#print(nums)
for j in nums:
if j not in d:
d[j]=1
else:
d[j]+=1
#print(d)
d1=sorted(d.items())
print(d1)
8、字符串統計
a=’abcdefghijklmnopqrstuvwxyz’
d={}
words=[]
for i in range(100):
words.append(random.choice(a)+random.choice(a))
print(words)
for j in words:
if j not in d.keys():
d[j]=1
else:
d[j]+=1
print(d)
d1=sorted(d.items())
print(d1)
9、返回1-10平方的列表
lst = [(i**2) for i in range(1,11)]
print(lst)
10、有一個列表lst = [1,4,9,16,2,5,10,15]，生成一個新列表，要求新列表元素是lst相鄰2項的和
lst = [1,4,9,16,2,5,10,15]
lst1 = [lst[i]+lst[i+1] for i in range(len(lst)-1)]
print(lst1)
11、打印九九乘法表
[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)]
12、?“0001.abadicddws” 是ID格式，要求ID格式是以點號分割，左邊是4位從1開始的整數，右邊是
10位隨機小寫英文字母。請依次生成前100個ID的列表。
import random
[‘{:04}.{}’.format(j,”.join(random.choice(bytes(range(97,123)).decode())for i in range(10))) for j in range(1,101)]
本文來自投稿，不代表Linux運維部落立場，如若轉載，請注明出處：http://www.www58058.com/95141
