1.csv
2.excel
Read:
Print sheet (not Workbook) Name:
Get each row:
Write:
3.matplotlib
import numpy as np
from matplotlib import pyplot as plt
import pandas as pd
df =pd.read_excel("Documents/b.xlsx")
df
plt.figure(figsize=(6,4))
plt.title("Train History")
plt.xlabel("Epoch")
plt.ylabel("Number of loss")
plt.plot(df.c,df.d,"r",marker='*', mec='r', mfc='w')
plt.plot(df.a,df.b, marker='*', mec='b', mfc='w')
plt.plot(df.g,df.h,marker='*', mfc='w')
plt.plot(df.e,df.f,"g",marker='*', mec='g', mfc='w')
plt.xticks(range(0,21))
plt.legend(["y=CNN-AlexNet-loss","y=CNN-VGGNet-loss","y=CNN-ResNet-loss","y=Improved CNN-ResNet-loss"])
plt.show
plt.figure(figsize=(6,4))
plt.title("YOLOV4")
plt.xlabel("Batch")
plt.ylabel("acc")
plt.plot(df.a,df.b,"")
plt.plot(df.c,df.d,"")
plt.legend(["train","test"])
plt.show
plt.figure(figsize=(6,4))
plt.xlabel("Precision")
plt.ylabel("Recall")
plt.plot(df.a,df.b, marker='o', mec='b', mfc='w')
plt.plot(df.c,df.d,"r",marker='o', mec='r', mfc='w')
#plt.xticks(range(0,21))
plt.legend(["y=Ours","y=YoloV4"])
plt.show
4. Time complexity
# If a+b+c=1000 and a^2+b^2=c^2 (a, B and C are natural numbers), how to find all possible combinations of a, B and C?
import time
start_time = time.time()
for a in range(0,1001):
for b in range(0,1001):
for c in range(0,1001):
if a+b+c==1000 and a**2+b**2==c**2:
print('a,b,c:%d,%d,%d'%(a,b,c))
end_time = time.time()
print('time:%d'%(end_time-start_time))
print('finished')
Output:
a,b,c:0,500,500
a,b,c:200,375,425
a,b,c:375,200,425
a,b,c:500,0,500
time:203
finished
From small to large, use functions to add elements to the list. Because functions are the encapsulation of basic steps, they cannot be counted as one step
5. Sequence list / linked list
Program = data structure + algorithm: the following figure shows the storage of data: one int takes up 4 bytes (char or B)(1B=8bit), and the following 1 is placed in 4 bytes.
The following int types are stored in order, that is, the sequence table, which is convenient for searching
In the following figure, the left side is the basic form of sequence table, and the right side is the external form (storage address) of elements
The following is the sequence table structure
The sequence table requires that the storage space must be continuous. Once it is insufficient, the data area must be changed dynamically. The linear list is divided into sequential list and linked list. The following figure is a linked list. There is no need to change the original data structure, one more and one more.
6. Six sorts
Stability of sorting algorithm: sort according to the size of the first element in the tuple (maintain the previous order, that is, the first group is stable as follows)
6.1 selection
from time import time # Timing decorator
def timer(func):
def inner(*args,**kwargs):
start = time()
result = func(*args,**kwargs)
end = time()
usedTime = 1000 * (end - start)
print("%s function used %.2f ms" %(func.__name__,usedTime))
return result
return inner
@timer
def select_sort(alist):#Select (traverse) sorting, select the smallest from the right and put it on the left
n = len(alist)
for j in range(n-1):#j:0 to n-2
min_index=j #False minimum subscript, traversing from the first
for i in range(j+1,n):
if alist[min_index]>alist[i]:
min_index=i
alist[j],alist[min_index]=alist[min_index],alist[j]
#Here min_index is the minimum subscript of true
if __name__ == "__main__":
blist = list(range(1,3000 + 1))
import random
blist = random.sample(blist, k=len(blist))
alist = blist[:1000]
select_sort(alist)
print(alist)
6.2 insertion
@timer
def insert_sort(alist):
n=len(alist)
for j in range(1,n):#How many elements are taken from the unordered sequence on the right to perform such a process
#j=[1,2,3,n-1]
#i represents the starting value of inner loop
i=j
#Execute to extract the first element from the unordered sequence on the right, that is, the element at i position
#Then insert it into the correct position on the front
while i>0:
if alist[i]<alist[i-1]:
alist[i],alist[i-1]=alist[i-1],alist[i]
i-=1
else:
break
if __name__ == "__main__":
blist = list(range(1,3000 + 1))
import random
blist = random.sample(blist, k=len(blist))
alist = blist[:1000]
insert_sort(alist)
print(alist)
6.3 Hill
Selective sorting is to select one from the following unordered sequence and put it in the last position in front.
Insert sort is to select one from the following unordered sequence and insert which one in the position of the previous ordered sequence (from right to left).
Hill sorting is an improvement of insertion sorting: 54, 77 and 20 are sorted by insertion, from small to large, and then 26 and 31 are sorted from small to large.
The second row in the figure below is the row with gap=4 in the first row
@timer
def shell_sort(alist):#Shell Sort
n=len(alist) #n=9
gap=n//2 #gap=4
while gap>0:#The number of times the insertion algorithm is executed before gap changes to 0
#The gap step size is different from the ordinary insertion algorithm
for j in range(gap,n):
i=j #j=[gap,gap+1,gap+2,gap+3,..,n-1]
while i>0:
if alist[i]<alist[i-gap]:
alist[i],alist[i-gap]=alist[i-gap],alist[i]
i-=gap
else:
break
gap//=2
if __name__ == "__main__":
blist = list(range(1,3000 + 1))
import random
blist = random.sample(blist, k=len(blist))
alist = blist[:1000]
shell_sort(alist)
print(alist)
6.4 bubbling
@timer
def bubble_sort(alist):
n = len(alist)
for j in range(n-1):
for i in range(n-1-j):
if alist[i]>alist[i+1]:
alist[i],alist[i+1]=alist[i+1],alist[i]
if __name__ == "__main__":
blist = list(range(1,3000 + 1))
import random
blist = random.sample(blist, k=len(blist))#Get k elements randomly from blist
alist = blist[:1000]
#print(alist)
bubble_sort(alist)
print(alist)
6.5 fast exhaust
The previous sorting methods are divided into left and right parts. In the fast row, if the low element is larger than 54 and the high element is smaller than 54, then the low and high elements exchange with each other and continue to go to the middle. When overlapping, the first element of low refers to 54. The position is fixed, and the left and right sides of 54 continue to operate low and high respectively.
def quick_sort(alist,first,last):
if first>=last:
return
mid_value=alist[first]
low=first #low and high are cursors, first is the first element, and last is the last element
high=last
while low<high:#No meeting
while low<high and alist[high]>=mid_value:
high-=1 #high shift left
alist[low]=alist[high]#Element exchange, cursor does not exchange
while low<high and alist[low]<mid_value:
low+=1
alist[high]=alist[low]
#When exiting from the loop, low==high
alist[low]=mid_value
#Perform a quick sort on the list to the left of low
quick_sort(alist,first,low-1)
#Perform a quick sort on the list to the right of low
quick_sort(alist,low+1,last)
def main():
blist = list(range(1,3000 + 1))
import random
blist = random.sample(blist, k=len(blist))
alist = blist[:1000]
quick_sort(alist,0,len(alist)-1)
print(alist)
main()
6.6 consolidation
The following figure splits the two parts until there is only one element, and then compares them.
In the figure above, compare 26 to 17, take out 17, and move the right pointer back. 26 compared with 93, 26 took out 26 and ranked behind 17.
7. Tree traversal
Pre order (pre root): left and right root
Middle order: projection
Post order: left and right roots (from bottom to top)
8. Line / process
8.1 threads
The following 2 (7) means that 2 have been borrowed and 7 are still missing
8.2 process
8.3 process pool
Multi task folder copy:
8.4 coordination process
gevent picture download:
8.5 GIL
python3 main.py, so solve GIL: 1 Replace cpython interpreter (c is compiled and Python is interpreted) 2 Replace thread with another language
B station / know / WeChat official account: Code agriculture programming
