Python必会操作

命令行参数

import sys
import cv2
def show_pic(img):
   cv2.imshow('image',img)
   cv2.waitKey(0)
   cv2.destroyAllWindows()
def main():
   print("start")
   print (sys.argv)
   image_1 = sys.argv[1]
   image_2 = sys.argv[2]
   src = cv2.imread(image_1)
   show_pic(src)
   print("end")
if __name__ == "__main__":
   main()

运行方式

说明： 更加深入学习命令行参数，学习argparse这个模块。tensortflow也内置了命令行参数的API，
很多深度学习代码不能直接运行，需要设置参数，路径等。如果不会写界面，大多需要用到命令行参数。

目录操作

import sys
import os
def root_ope():
   current_file = __file__                              #获取执行的Python完整文件名,D:\server\root.py 1
   print (current_file,"1")                     
   base_name = os.path.basename(current_file)           #获取文件名，不包含目录,root.py 2
   print (base_name,"2")
   current_root =  os.path.dirname(__file__)            #获取当前文件的上级（父）目录,D:\server 3
   print (current_root,"3")
   current_up =  os.path.dirname(current_root)          #获取当前文件的上级目录,D:\ 4
   print (current_up,"4") 
   file_list = os.listdir(current_root)                 #获取此目录下的所有文件及目录，返回列表,['a.png', 'a1.png', ..... ] 5
   print (file_list,"5")
   file_root1 = os.path.join(current_root,file_list[0]) #拼接目录,D:\server\a.png 6
   file_root2 = current_root+"\\"+file_list[0]          #拼接目录,D:\server\a.png 7
   print (file_root1,"6")
   print (file_root2,"7")
   replace_file_root1 = file_root1 .replace("\\","/")   #替换字符,D:/server/a.png 8
   print (replace_file_root1,"8")
   split_file_root1 = file_root1.split("\\")            #根据字符分离字符串,['D:', 'server', 'a.png'] 9
   print (split_file_root1,"9")
   split_file_root2 = file_root1.split(".")             #根据字符分离字符串,['D:\\server\\a', 'png'] 10
   print (split_file_root2,"10")
   child_name_ext = os.path.splitext(file_root1)        #获取文件后缀名,('D:\\server\\a', '.png') 11
   print (child_name_ext,"11")

def getListFiles(path): 
   """
   遍历目录下的所有文件，包含所有层级目录，os.walk类似于一个迭代器。
   """

   print(type(os.walk(path)))
   ret = [] 
   for root, dirs, files in os.walk(path): 
       #print (root,dirs)
       for filespath in files: 
           #print(os.path.join(root,filespath))
           ret.append(os.path.join(root,filespath)) 
   return ret


def main():
   root_ope()
   file = getListFiles("D:/server/pic_xiangsi")
   print ("file_counter:",len(file))

if __name__ == "__main__":
   main()

os.walk

运行 for (root, dirs, files) in os.walk(‘a’):

#第一次运行时，当前遍历目录为 a
所以 root == ‘a’
dirs == [ ‘b’, ‘c’, ‘d’]
files == [ ‘4.txt’, ‘5.txt’]

#接着遍历 dirs 中的每一个目录
b: root = ‘a\b’
dirs = []
files = [ ‘1.txt’, ‘2.txt’]

#dirs为空，返回
# 遍历c
c: root = ‘a\c’
dirs = []
files = [ ‘3.txt’ ]

#遍历d
d: root = ‘a\b’
dirs = []
files = []
遍历完毕，退出循环

说明： 深度学习，图像处理，目标检测，神经网络等操作时需要对文件进行处理，都要求掌握基本的目录、
文件处理以及文件的基本能力。

文件操作

import sys
import cv2
import os
import csv
import json
import xml
import random
import pandas as pd
import xml.etree.ElementTree as ET
from xml.dom import minidom
from xml.dom.minidom import parse

"""
此外文件读写还可以写成这种形式，更加简洁，方便，会自动关闭文件。
with open("text.txt","w") as f:
   f.write("data")

with open("text.txt","r") as f:
   data = f.read()
   data = f.readlines()


json.dumps(test_dict) #将数据转化为字符串

## type print (type(120))

## help print (help(json))

## dir print (dir(json))

"""
"""
0001.xml
<annotation verified="no">
 <folder>pic</folder>
 <filename>0001</filename>
 <path>E:\Download\object_detection_training\object_detection\dataset\pic\0001.jpg</path>
 <source>
   <database>Unknown</database>
 </source>
 <size>
   <width>356</width>
   <height>240</height>
   <depth>3</depth>
 </size>
 <segmented>0</segmented>
 <object>
   <type>bndbox</type>
   <name>tortoise</name>
   <pose>Unspecified</pose>
   <truncated>0</truncated>
   <difficult>0</difficult>
   <bndbox>
     <xmin>38</xmin>
     <ymin>27</ymin>
     <xmax>329</xmax>
     <ymax>234</ymax>
   </bndbox>
 </object>
</annotation>
"""
def file_read(filename):
   f = open(filename,"r")
   data = f.read()
   print (data)
   f.close()
   return data

def file_write(filename,data):
   f = open(filename,"w")
   f.write(data)
   f.close()

def list_line_write(filename,list):
   f = open(filename,"w")
   for i,data in  enumerate(list):
   	f.write(str(data)+"\n")
   f.close()

def list_line_read(filename):
   f = open(filename,"r")
   list = f.readlines()
   for i,data in  enumerate(list):
   	print (i,data)
   f.close()
   return list

def json_read(filename):
   with open(filename,"r") as f:
   	data = json.load(f)
   return data

def json_write(filename,data):
   with open(filename,"w") as f:
   	json.dump(data,f,indent = 4)
def csv_read(filename):
   all_list = []
   with open(filename) as f:
   	f_csv = csv.reader(f)
   	for i,row in enumerate(f_csv):
   		all_list.append(row)
   return all_list

def csv_write(filename,data):
   column_name = ['1', '2', '3', '4', '5', '6', '7', '8','9','10','11', '12', '13', '14', '1', '16', '17', '18','19','20']
   data_pd = pd.DataFrame(data, columns=column_name)
   data_pd.to_csv(filename, index=None)

def xml_read(filename):
   xml_list = []
   tree = ET.parse(filename)
   root = tree.getroot()
   for member in root.findall('object'):
   	value = (
   			root.find('filename').text,
   			int(root.find('size').find("width").text),
   			int(root.find('size').find("height").text),
   			member.find("name").text,
   			int(member.find("bndbox")[0].text),
   			int(member.find("bndbox")[1].text),
   			int(member.find("bndbox")[2].text),
   			int(member.find("bndbox")[3].text)
   			 )
   xml_list.append(value)
   return xml_list

def xml_write(filename,data):
   #xml_obj = minidom.getDOMImplementation()
   #doc = xml_obj.createDocument(None, None, None)
   doc = minidom.Document()
   xmemlElement = doc.createElement('annotation')
   doc.appendChild(xmemlElement)
   
   filename_element  = doc.createElement('filename')
   filename_text = doc.createTextNode(data[0][0])
   filename_element.appendChild(filename_text)
   xmemlElement.appendChild(filename_element)

   size_element  = doc.createElement('size')
   size_element_width = doc.createElement("width")
   size_element_height = doc.createElement("height")
   size_element_width_text = doc.createTextNode(str(data[0][2]))
   size_element_height_text = doc.createTextNode(str(data[0][1]))
   size_element_width.appendChild(size_element_width_text)
   size_element_height.appendChild(size_element_height_text)

   size_element.appendChild(size_element_width)
   size_element.appendChild(size_element_height)
   xmemlElement.appendChild(size_element)

   object_element  = doc.createElement('object')
   object_element_name = doc.createElement("name")
   object_element_name_text = doc.createTextNode(data[0][3])
   object_element_bndbox = doc.createElement("bndbox")

   object_element_bndbox_xmin = doc.createElement("xmin")
   object_element_bndbox_ymin = doc.createElement("ymin")
   object_element_bndbox_xmax = doc.createElement("xmax")
   object_element_bndbox_ymax = doc.createElement("ymax")

   object_element_bndbox.appendChild(object_element_bndbox_xmin)
   object_element_bndbox.appendChild(object_element_bndbox_ymin)
   object_element_bndbox.appendChild(object_element_bndbox_xmax)
   object_element_bndbox.appendChild(object_element_bndbox_ymax)

   object_element_bndbox_xmin_text = doc.createTextNode(str(data[0][4]))
   object_element_bndbox_ymin_text = doc.createTextNode(str(data[0][5]))
   object_element_bndbox_xmax_text = doc.createTextNode(str(data[0][6]))
   object_element_bndbox_ymax_text = doc.createTextNode(str(data[0][7]))

   object_element_bndbox_xmin.appendChild(object_element_bndbox_xmin_text)
   object_element_bndbox_ymin.appendChild(object_element_bndbox_ymin_text)
   object_element_bndbox_xmax.appendChild(object_element_bndbox_xmax_text)
   object_element_bndbox_ymax.appendChild(object_element_bndbox_ymax_text)

   object_element_name.appendChild(object_element_name_text)
   object_element.appendChild(object_element_name)
   object_element.appendChild(object_element_bndbox)
   xmemlElement.appendChild(object_element)

   with open(filename,"w") as f:
   	doc.writexml(f, indent='\t', addindent='\t', newl='\n', encoding="utf-8")


def create_list():
   list_all = []
   for i in range(10):
   	list = []
   	for j in range(20):
   		list.append(random.randint(0,20))
   	list_all.append(list)
   return list_all

def create_dict():
   dict_all = {}
   for i in range(10):
   	list = []
   	for j in range(20):
   		list.append(random.randint(0,20))
   	dict_all[str(i)] = list

   return dict_all

def main():
   
   print ("satrt".center(30,"-"))
   list_data = create_list()
   #print (list_data)
   dict_data = create_dict()
   #print (dict_data)

   file_write("list.txt",str(list_data))
   file_read("list.txt")

   list_line_write("list_lines.txt",list_data)
   list_line_read("list_lines.txt")

   json_write("dict_data.json",dict_data)
   json_write("list_data.json",list_data)

   list_data = json_read("list_data.json")
   #print (list_data)
   dict_data = json_read("dict_data.json")
   #print (dict_data)

   csv_write("list_data.csv",list_data )
   list_data = csv_read("list_data.csv")
   #print (list_data)

   xml_data = xml_read("0001.xml")
   print (xml_data)
   xml_write("new.xml",xml_data)

   print ("end".center(30,"-"))


if __name__ == "__main__":
   main()
   

说明:
深度学习，图像处理，目标检测，神经网络等操作时需要对文件进行处理，都要求掌握基本的目录、
文件处理以及文件的基本能力。 包含基本文件读写，列表，字典，元组操作。
1.基本文件读写方式，及数据简单处理
2.json文件读写方式，及数据简单处理
3.xml文件读写方式，及数据简单处理
4.csv文件读写方式，及数据简单处理

自定义模块调用

root_look.py(自定义的模块，不运行它)

import sys
import cv2
import os

class GetRootFiles(object):
   def __init__(self):
       print ("look root file")
   def look_root(self,path):
       ret = [] 
       for root, dirs, files in os.walk(path): 
           #print (root,dirs)
           for filespath in files: 
               #print(os.path.join(root,filespath))
               ret.append(os.path.join(root,filespath)) 
       return ret

def getListFiles(path): 
   """
   遍历目录下的所有文件，包含所有层级目录，os.walk类似于一个迭代器。
   """
   ret = [] 
   for root, dirs, files in os.walk(path): 
       #print (root,dirs)
       for filespath in files: 
           #print(os.path.join(root,filespath))
           ret.append(os.path.join(root,filespath)) 
   return ret


def main():
   root_ope()
   file = getListFiles("D:/server/pic_xiangsi")
   print ("file_counter:",len(file))



if __name__ == "__main__":
   main()

use_moudle.py (运行这个文件，调用自定义模块)

import root_look
from root_look import getListFiles
from root_look import GetRootFiles

def main():

   #data = root_look.getListFiles("D:/server/pic_xiangsi")
   #data = getListFiles("D:/server/pic_xiangsi")
   #data = GetRootFiles().look_root("D:/server/pic_xiangsi")
   data = root_look.GetRootFiles().look_root("D:/server/pic_xiangsi")
   for i,li in enumerate(data):
   	print (i,li)

main()

if __name__ == "__main__":
   main()
   
"""
look root file
0 D:/server/pic_xiangsi\alcremie.png
1 D:/server/pic_xiangsi\altaria.png
2 D:/server/pic_xiangsi\current.json
3 D:/server/pic_xiangsi\dataset_xsd.py
4 D:/server/pic_xiangsi\display_rect_check.py
5 D:/server/pic_xiangsi\get_record_num_file.py
6 D:/server/pic_xiangsi\network.py
7 D:/server/pic_xiangsi\network1.py
...
...

"""  

说明:
将两个文件放入同级目录，调用自定义的函数或类模块。
也可以放在Python的模块包的路径下。
当存在两个同名的模块时，优先调用同级目录的模块。
当存在不同版本的模块时，可以采用此方法。
我们有时需要修改别人写的模块，必须知道基本的原理，以及模块包的结构。

构建项目工程模块包

暂时 等待，日后更新