一、python基础
pip常用命令
pip3 install xxx 安装模块
pip3 install Django==3.2.7 安装Django（指定版本）
pip3 uninstall xxx 移除模块
pip3 show xxx 查看模块
python -V (或者--version ,有些-v) 查看版本(子模块可以采取 xxx.__version__)
python -m xxxxx 执行xxx命令
（如果没有添加环境变量， 可以采用命令添加前缀的方法）
pip freeze > requirements.txt 导出模块方法：（可以添加前缀python -m ）
pip install -r requirements.txt 导入模块方法：
pip install --upgrade pip 更新pip模块
tree ./web /F 查看文件树,基本目录结构
（1.文件开头：
Windows默认的是GBK编码, 所以 xxxx.py 声明的是 #-*- coding:GBK-*-;
而Linux 默认的是utf8编码, 所以 xxxx.py声明的是 #-*- coding:utf8 -*-。
（2.文件对应的后缀名：
csv文件 （.csv）
xlwt （.xls）
(3.常用函数
3.1 res = type("1111") 检测类型 , None值的变量类型是 NoneType，空类型并不是不需要声明
3.2 list = headers .splitlines() 把字符串按照行进行拆分，返回一个列表
1.list列表
list = [] 新建一个空的列表
le = len(list) 列表元素个数
list.append("") 追加 ， 不能追加多个元素
list.insert(n,"") 插入
list.remove("") 删除
list.pop( [ /n] ) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值（n指定元素)
list.index("") 索引（位置）
list.clear() 清空
list.reverse() 反转
list.sort() 排序 # 降序list.sort(reverse=True) 默认升序，还有一个key参数=排序规则
*res = list.count("123") 统计某个元素在列表中出现的次数
*list2 = list.copy() 复制列表
newList = list(seq) 将元组转换为列表
L[start:] 从start到末尾的列表
L[start:end: [step] ] 从start到end的列表 （step是步长，表示切片的个数，注意不包括end项）
pic_css= list(set(pic_css_pre_link)) 对列表中的元素去重，set内置函数
list += ["aaa"] 追加列表
list = list1 + list2 连接列表
list = ["a","b"] * 2 数乘列表 (列表可以直接使用‘=’号复制，生成新的列表)
res =('111' in list) 判断是否存在列表内
list.extend(list2) 连接两个列表
maxItem = max(list) 返回列表元素最大值
minItem = min(list) 返回列表元素最小值
（1.sort（） 指定key排序规则
# 获取列表的第二个元素
def getSecondListItem(elem):
return elem[1]
tList= [(2, 2), (3, 4), (4, 1), (1, 3)] # 列表
tList.sort(key=getSecondListItem) # 指定第二个元素排序
print('排序列表：', random) # 输出类别
（2.列表推导式
b_list = [x * x for x in a_range if x % 2 == 0]
dp = [[False] * n for _ in range(n)]
生成二维矩阵列表
2.tuple元组
（1.元组和列表的高度相似性，列表的切片全适用（切片并不改变原始数据），所以只需要记住一个原则:
列表中修改元素值以元组都不可用， 列表中不修改元素值的操作元组基本上都可以用。
（2.元组和列表是可以互相转换的。使用tuple(list)可以将一个列表转换成元组，反过来list(tuple)也可以
将一个元组转换成列表。
t= tuple(list) 将列表转换为元组
3.dict字典
dict = {} # 新建一个空的字典
dict["a"] = "abc" # 添加、修改字典数据
value1 = dict['name'] # 获取字典数据
value2 = dict.get('name',["apple"]) # 获取字典数据,返回指定键的值，如果键不在字典中返回 default 设置的默认值
del dict["a"] # 删除指定的键和值
res = dict.pop("a",["defalut"]) # 删除字典给定键 key 所对应的值，并返回,默认的值是为了避免出现异常
dict.setdefault("a",None) # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default (默认'None')
dict.items() # 视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
dict.keys() # 返回字典的值,不允许使用dict.keys()[n] 来获取数据，下同
dict.values() # 返回字典的值
re = ("hello" in dict) # 如果键在字典dict里返回true，否则返回false ， 也可以判断字符串
dict.clear() # 清空字典
dict.update(dict2) # 把字典dict2的键/值对更新到dict里
dict = dict2.copy() #返回一个字典的浅复制
list = sorted(dict.items(),key=lambda d: d[0]) # 对字典的进行排序，d[0] 或者d[1],并返回一个列表
（1.视图对象的使用
dict = {'eggs': "1", 'sausage': "2", 'bacon': "3", 'spam': "4"}
for value in dict.values():
print(value)
for key in dict.keys():
print(key)
for key,value in dict.items():
print(key,value) # 不能使用dict.item()[n]来索引数据,但可以通过len(dict.items()) 来获取对象的大小
4.str字符串函数
（1)字符串大小写转换
S.lower): 字母大写转换成小写。
S.upper(): 字母小写转换成大
S.swapcase(): 字母大写转换小写，小写转换成大写.
S.title(): 将首字母大写。
（2)字符串搜索、替换
S.find(substr,[start,[end]l): 返回S中出现Substr的第一个字母的标号，如果S中没
有substr 则返回-1，start和 end 作用就相当于在S[start:end]中搜索。
S.count(substr,[start, [end]l) :计算substr在S中出现的次数。
S.replace(oldstr,newstr,[count): 把S中的oldstar替换为 newstr,count为替换次数
S.strip([chars]): 把S左右两端chars中有的字符全部去掉,一般用于 去除空格
S.lstrip([chars]): 把S左端 chars中所有的字符全部去掉。
S.rstrip([chars]): 把S右端 chars 中所有的字符全部去掉。
（3）字符串分割
S.split([sep,[maxsplit]]): 以sep为分隔符，把S分成一个list。maxsplit表示分割的次数,默认的分割符为空白字符
S.join(seq): 把seq代表的序列—字符串序列,用S连接起来。
使用： res = "#".join(["I","love","python"]) => I#love#python
(4）字符串编码、解码
S.decode([encoding]): 将以 encoding编码的S解码成unicode编码。
S.encode([encoding)): 将以unicode 编码的S编码成encoding, encoding可以是 gb2312、gbk、 big5 ...
使用： newStr = str.decode("GBK").encode("utf8")
不管是编码还是解码，针对的都是unnicode字符编码，所以必须将原字符串转换成unicode编码格式
（5）字符串测试
S.isalpha(): S是否全是字母,至少有一个字符。 字,至少有一个字符。
S.isdigit(): S是否全是数字
S.isspace(): S是否全是空白字符,至少有一个字符。
S.islower(): S中的字母是否全是小写。
S.isupper(): S中的字母是否全是大写。
S.istitle(): S是否是首字母大写的。
(6.字符串转换成整形
string.atoi(tt) 转换成整型
string.atof(tt) 转换成浮点型
int(tt) 转换成整型
float(tt) 转换成浮点型
(7.math库
import math
math.ceil(4.2) 调用math的库
5.import模块化
from .models import * ## 从当前的models.py中导入所有函数
from ..utils import allow,router ## 从上上级下的utils文件夹导入图片allow.py,router.py模块
from ..models.serializers import * ## 从上上级下的models文件夹serializers.py中导入所有模块
if __name__=='__main__':
主函数
6.os文件模块
'''
os.path 模块
os.path.join(a,b) 连接路径a+b
os.path.exists() 判断文件是否存在
os.path.isdir() 判断path是否是目录
os.path.isfile() 判断path是否是文件
os.getatime() 返回文件的最后访问时间
os.getctime() 返回文件的创建时间
os.getmtime() 返回文件的最后修改时间
os.getsize() 返回文件的大小
os模块
os.listdir(a) 返回指定的文件夹a包含的文件或文件夹的名字的列表。
os.mkdir(a) 创建文件夹a
os.rename(a,b) a替换名称为b
os.open(file,mode) 按照mode指定的权限打开文件
os.remove(file) 删除指定的文件 可以是名称
os.stat(file) 返回指定文件的所有属性
shutil模块
shutil.copy(src,dst) 把src图片文件复制到dst路径中
shutil.move(src,dst) 把src图片文件移动到dst路径中 ,有内存占用的问题
shutil.rmtree(path) #删除文件夹
PIL中的Image模块
img = Image.open(file)
imge.size 获取图片的尺寸
ima = Image.open('photo2.png')
ima = ima.crop((left,top,right,bottom))
ima.save('photo3.png') 在图片中截取图片
'''
1.图片批量命名
import os
'''
os.path.join(a,b) 连接路径a+b
os.listdir(a) 返回指定的文件夹a包含的文件或文件夹的名字的列表。
os.mkdir(a) 创建文件夹a
os.path.exits(a) 检测是否存在文件a
os.rename(a,b) a替换名称为b
'''
if __name__=='__main__':
path = 'c:/Users/Icy-yun/Desktop/new/'
base_path = str(input('Please enter the name of the image folder:'))
print(path+base_path)
start_path=path+base_path
if os.path.exists(start_path):
print(True)
for i, file in enumerate (os.listdir (start_path)):
os.rename(start_path+'/'+file,start_path+'/'+str(i+1)+'-python.jpg')
dst= start_path+'/'+str(i+1)+'-python.jpg'
print(dst)
else:
print(False)
2.移动图片位置
import os
from PIL import Image ###os.path.getsize("xxxx")可以获取一个文件的大小
import shutil
fileName = 'picture'
directory = 'c:/Users/Icy-yun/Desktop/' # os.path模块都要求使用组对路径
src = directory+fileName # 桌面上旧文件夹
dst = directory+'newPicture' # 桌面上新建的文件夹
if not os.path.exists(dst):
os.mkdir(dst)
old_src_files = []
new_dst_files = []
for file in os.listdir(src):
print(file) # os.path.getsize(directory+'/'+file)获取的是文件大小
img = Image.open(src+'/'+file) # img.size 引入PIL 模块中的Image模块，获取图片文件尺寸，结果是一个元组
if (img.size)[1] > 1500:
old_src = src+'/'+file
new_dst = dst+'/'+file # 引入shutil模块，
old_src_files.append(old_src)
new_dst_files.append(new_dst)
for old_src,new_dst in zip(old_src_files,new_dst_files):
try:
shutil.move(old_src, new_dst) # 移动图片 # shutil.copyfile(src,st) 复制图片
print(f'==该{old_src}图片已经移动到新的文件夹中==')
except PermissionError:
print(f'最后一张{old_src}原图片没有删除')
pass
7.常用技巧和正则
1.生成列表,字典
# (1).二维列表
list = []
for row in range(3):
list.append([])
for j in range(4):
list[row].append(j)
print(list)
# (2).字典+列表
list = []
info = {
'title':'love',
'content':'empty'
}
list.append(info)
print(list)
# (3).字典
dir = {}
keys = ['one','two','three']
values = ['第一','第二','第三']
for key,value in zip(keys,values):
dir[key]=value
print(dir)
(4).join的使用
语法： ‘sep’.join(seq)
参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串
返回值：返回一个以分隔符sep连接各个元素后生成的字符串
2.创建新的文件夹
import os
if __name__ == '__main__':
# 检测文件夹是否存在
dir = 'c:/practise/hello'
if not os.path.exists(dir): #创建文件夹
os.mkdir(dir)
print('创建成功！')
else:
print('地址已经存在')
print("="*50)
3.字符串转换成元组(正则)
import re
headers_str = '''
123 小明 江西 5600
45 小红 北京 153
'''
n = 3
# ('张三', '男', '篮球'),
# ('李四', '男', '乒乓球'),
# ('王舞', '女', '羽毛球'),
# pattern = '^(.*?)(.*?)(.*)$'
# # 1 2 3
before_pattern = '^(.*?) ' # ^匹配字符串开头,$匹配字符串结尾
after_pattern = '(.*)$'
pattern = before_pattern+after_pattern
before_regex = '(\'\\1\', '
after_regex = '\'\\%d\'), '%n
regex = before_regex + after_regex # 括号和逗号不用转义字符，单引号需要\
if n>=2:
# global pattern #函数中才能使用global关键字
middle_pattern = ''
for i in range(n-2): # 0 ~ 3-2
middle_pattern = middle_pattern + '(.*?) '
pattern = before_pattern + middle_pattern + after_pattern
middle_regex = ''
for i in range(n - 2): # 0 ~ 3-2
middle_regex = middle_regex + '\'\\%d\', '%(i+2)
regex = before_regex + middle_regex + after_regex
# print(pattern)
# print(regex)
for line in headers_str.splitlines():
if len(line) == 0:
continue
# list = re.findall('\S*', line) # ×匹配0~无限次， ？匹配0~1次 . 匹配无限次
# line = ''
# for li in list:
# line = line + li + ' ' # 这里会出现2个空格
count = 50
i = 0
while i < count:
line = re.sub(' ',' ',line)
i += 1
line = line.strip()
# print(line)
print(re.sub(pattern, regex, line)) # pattern为匹配的正则表达式，regex为替换的字符串
else:
print('error')
4.字符串转换成字典(正则)
import re
headers_str='''
Referer: https://wenku.baidu.com/search?word=python&lm=0&od=0&fr=top_home&ie=utf-8
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)
Chrome/86.0.4240.111 Safari/537.36
'''
pattern = '^(.*?): (.*)$'
# 1 2
for line in headers_str.splitlines():
print(re.sub(pattern,'\'\\1\': \'\\2\',',line))
8.功能实战演练
1.图片文字识别(pytesseract)
# 图片识别文字
import pytesseract
from PIL import Image
# 读取图片
path = 'C:/Users/Icy-yun/Desktop/new/hello4.png'
im = Image.open(path)
# # 识别文字
# string = pytesseract.image_to_string(im)
# 识别文字，并指定语言
string = pytesseract.image_to_string(im, lang='chi_sim')
print(string)
result1 = string.replace(' ','')
result2 = result1.replace('\n','')
result3 = result2.replace('。','\n')
print(result3)
2.字体文件转换(TTFont)
from fontTools.ttLib import TTFont
# import requests
font = TTFont('C:/Users/Icy-yun/Desktop/DY2.woff')
font.saveXML('C:/Users/Icy-yun/Desktop/font2.xml') # 转换格式
best_map = font['cmap'].getBestCmap() # 获取元素
print(best_map)
new_best_map={} # 创建一个字典
for key,value in best_map.items():
new_best_map[hex(key)] = value
new_best_map[key] = value
3.图片插入到word文档里
from docx import Document
from docx.shared import Pt
# 文件存储路径
path = "C:/Users/Icy-yun/Desktop/"
# 读取文档
doc = Document(path + "hello.docx")
# 添加图片，后面的参数设置图片尺寸，可以选填
doc.add_picture (path + 'picture.png', width=Pt(400))
doc.add_picture (path + 'picture.png', width=Pt(400)) # 插入2张相同的图片
doc.save(path + "hello.docx") # 也可以创建新的word文档 读取文档的时候改成doc = Document()
print('图片已经插入word文档')
知识点5：把表格插入word文档里（初级程序）
from docx import Document
# 文件存储路径
path = 'c:/Users/Icy-yun/Desktop/'
# 读取文档
doc = Document()
# 添加一个4行、3列的表格，style引入样式，初始化
doc_table = doc.add_table(rows = 4,cols = 3,style ='Table Grid')
# 设置表头 # 注意，在本机的电脑应先在word文档设置，表格样式应用于所有插入文档
doc_table.rows[0].cells[0].text = '姓名'
doc_table.rows[0].cells[1].text = '性别'
doc_table.rows[0].cells[2].text = '兴趣'
# 表体数据存储
date = (
('张三', '男', '篮球'),
('李四', '男', '乒乓球'),
('王舞', '女', '羽毛球'),
)
# 添加数据，add_row()新增一行
for a, b, c in date:
new_row = doc_table.add_row()
new_row.cells[0].text = a
new_row.cells[1].text = b
new_row.cells[2].text = c
# 存储文档
doc.save(path + 'new.docx')
print('表格已经插入word文档')
4.表格插入word文档里(final)
# 使用正则表达式将headers转换成python字典格式的工具函数
import re
from docx import Document
headers_str = '''
123 小明 江西 1265
45 小红 北京 56
456 小刚 福建 56549
'''
def get_numbers(headers_str): # 统计每行的列数
line = ''
for he in headers_str.splitlines(): # 统计个数
if len(he) == 0:
continue
line = he
break
i = 0
count = 50
while i < count:
line = re.sub(' ', ' ',line)
i += 1
line = line.strip()
list1 = line.split(' ')
return len(list1)
def get_parse(headers_str,n): # 获取所有的数据
if n>=2:
list = []
row = 0
for line in headers_str.splitlines(): # ×匹配0~无限次， ？匹配0~1次 . 匹配无限次
if len(line) == 0:
continue # 这里会出现2个空格
count = 50
i = 0
while i < count:
line = re.sub(' ',' ',line)
i += 1
line = line.strip()
result = line.split(' ')
list.append([])
for j in range(n):
list[row].append(result[j])
row += 1
return list
else:
list = []
print('错误！插入的数据不正确！')
return list
def get_print(data, n): # 在word文档打印表格
if len(data)>0:
column = n
# 读取文档
doc = Document()
# 添加一个1行、n列的表格，style引入样式 ，第一行作为标题
doc_table = doc.add_table(rows=1, cols=column, style='Table Grid')
# 设置表头 # 注意，在本机的电脑应先在word文档设置，表格样式应用于所有插入文档
# doc_table.rows[0].cells[0].text = '姓名'
# # 表体数据存储
# date =[
# ['张三', '男', '篮球'],
# ['李四', '男', '乒乓球'],
# ['王舞', '女', '羽毛球']
# ]
# 添加数据，add_row()新增一行
for row_date in data:
new_row = doc_table.add_row()
for i in range(len(row_date)):
new_row.cells[i].text = row_date[i]
# 文件存储路径，在桌面的new.docx文件里
path = 'c:/Users/Icy-yun/Desktop/'
doc.save(path + 'new.docx')
print('表格制作成功！')
else:
print('错误！表格制作失败!')
if __name__=='__main__':
n = get_numbers(headers_str)
data = get_parse(headers_str,n)
get_print(data,n)
5.生成Word文档(python-docx)
python实现生成Word、docx文件的方法分析 - python基础 - 谷谷点程序
一、快速开始
from docx import Document
document = Document()
1、段落
加一个段落，下面paragraph 是前面内容的光标指向，后面再该处插入一句话。
paragraph = document.add_paragraph('Lorem ipsum dolor sit amet.')
prior_paragraph = paragraph.insert_paragraph_before('Lorem ipsum')
后面加一句话
paragraph = document.add_paragraph('Lorem ipsum ')
paragraph.add_run('dolor sit amet.')
添加段落风格
document.add_paragraph('Lorem ipsum dolor sit amet.', style='ListBullet')
使用blod、italic 等等
paragraph = document.add_paragraph('Lorem ipsum ')
run = paragraph.add_run('dolor')
run.bold = True
run.italic = True
paragraph.add_run('dolor').bold = True
2、标题
level表示标题的大小
document.add_heading('The role of dolphins', level=2)
3、分页
document.add_page_break()
4、表格
table = document.add_table(rows=2, cols=2)
访问方法：
取出来，单独赋值
cell = table.cell(0, 1)
cell.text = 'parrot, possibly dead'
依然使用二维数组类似的索引。
row = table.rows[1]
row.cells[0].text = 'Foo bar to you.'
row.cells[1].text = 'And a hearty foo bar to you too sir!'
分清楚结构
for row in table.rows:
for cell in row.cells:
print(cell.text)
查看信息
row_count = len(table.rows)
col_count = len(table.columns)
添加一行
row = table.add_row()
动态添加表格
table = document.add_table(1, 3)
# 标题
heading_cells = table.rows[0].cells
heading_cells[0].text = 'Qty'
heading_cells[1].text = 'SKU'
heading_cells[2].text = 'Description'
# 添加内容
for item in items:
cells = table.add_row().cells
cells[0].text = str(item.column1)
cells[1].text = item.column2
cells[2].text = item.column3
5、添加图片
from docx.shared import Inches
document.add_picture('image-filename.png', width=Inches(1.25), height=Inches(1.25))
二、操作document
只能打开07之后的，会覆盖。
document = Document('existing-document-file.docx')
document.save('new-file-name.docx')
打开文件
f = open('foobar.docx', 'rb')
document = Document(f)
f.close()
# or
with open('foobar.docx', 'rb') as f:
source_stream = StringIO(f.read())
document = Document(source_stream)
source_stream.close()
...
target_stream = StringIO()
document.save(target_stream)
三、操作text
段落居中
from docx.enum.text import WD_ALIGN_PARAGRAPH
document = Document()
paragraph = document.add_paragraph()
paragraph_format = paragraph.paragraph_format
paragraph_format.alignment = WD_ALIGN_PARAGRAPH.CENTER
左边整体缩进
from docx.shared import Inches
paragraph = document.add_paragraph()
paragraph_format = paragraph.paragraph_format
paragraph_format.left_indent = Inches(0.5)
右边整体缩进
from docx.shared import Pt
paragraph_format.right_indent = Pt(24)
首行缩进
paragraph_format.first_line_indent = Inches(-0.25)
从字体调节，字体大小
run = document.add_paragraph().add_run()
font = run.font
from docx.shared import Pt
font.size = Pt(10.5) # 5号字体
font.italic = True
font.underline = True
字体颜色
from docx.shared import RGBColor
font.color.rgb = RGBColor(0x42, 0x24, 0xE9)
(1.实战事例
from docx import Document
from docx.shared import Inches
document = Document()
# 添加一个标题
document.add_heading('The role of dolphins', level=2)
# 添加一个段落
paragraph = document.add_paragraph('Lorem ipsum dolor sit amet.')
paragraph.add_run('dolor sit amet.')
# 段落缩进
paragraph_format = paragraph.paragraph_format
paragraph_format.left_indent = Inches(0.5)
document.save('new-file-name.docx')
6.生成Word文档(docxtpl)
python-docx template 操作word文档_qcyfred的博客-CSDN博客_python-docx-template
Welcome to python-docx-template’s documentation! — python-docx-template 0.9.x documentation
import xlrd2 # 1.2.0
#import os
#path='C:\Users\Administrator\Desktop\测试文件夹'
#print(os.path.exists(path))
from docxtpl import DocxTemplate
def main():
# data = xlrd2.open_workbook(r'C:\Users\Administrator\PycharmProjects\pythonProject3\记录.xlsx')
data = xlrd2.open_workbook(r'C:\Users\Icy-yun\Desktop\测试111.xlsx')
for x in range(0, 1): # 这儿可以循环多张表
print(x)
table = data.sheets()[x]
names = data.sheet_names()[x] # 获取表名
nrows = table.nrows
print(names,nrows)
for i in range(nrows):
b1 = table.row_values(i)[0] # 索引号
# c1 = table.row_values(i)[3] # 日期
# d1 = table.row_values(i)[4] # 审计项目
# e1 = table.row_values(i)[5] # 被审计单位
# f1 = table.row_values(i)[6] # 审计事项
# g1 = table.row_values(i)[7] # 审计事项记录
# h1 = table.row_values(i)[8] # 附件
# i1 = table.row_values(i)[9] # 共几件
# j1 = table.row_values(i)[10] # 共几页
# k1 = table.row_values(i)[11] # 编制人
# l1 = table.row_values(i)[12] # 小组长
# m1 = table.row_values(i)[13] # 主审
# n1 = table.row_values(i)[14] # 组长
context = {
"b1": b1, # 索引号
# "c1": c1, # 日期
# "d1": d1, # 审计项目
# "e1": e1, # 被审计单位
# "f1": f1, # 审计事项
# "g1": g1, # 审计事项记录
# "h1": h1, # 附件
# "i1": i1, # 共几件
# "j1": j1, # 共几页
# "k1": k1, # 编制人
# "l1": l1, # 小组长
# "m1": m1, # 主审
# "n1": n1 # 组长
}
print(context)
# word = DocxTemplate(r'C:\Users\Administrator\PycharmProjects\pythonProject3\记录模板.doc')
word = DocxTemplate(r'C:\Users\Icy-yun\Desktop\测试111.docx')
print(context)
word.render(context)
# 根据word模板文件，生成新的word文件
word.save(b1 + "-" + "{}".format(b1) + ".docx")
print("保存成功")
main()
9.network网络学习
1.threading多线程
import time
import threading
# def task(count):
# for i in count:
# print('任务执行中...')
# time.sleep(0.2)
# else:
# print('任务执行完毕')
# def task():
# time.sleep(1)
# print('当前线程：',threading.current_thread().name)
# def show_info():
# for i in range(5):
# print('test',i)
# time.sleep(0.5)
# g_list = []
# def add_data():
# for i in range(5):
# g_list.append(i)
# print('add:',i)
# time.sleep(0.2)
# print('add_data:',g_list)
# def read_data():
# # time.sleep(5)
# print('read_data',g_list)
# g_num = 0
# lock = threading.Lock() #创建互斥锁
# def sum_num1():
# lock.acquire() # 加入锁
# for i in range(1000000):
# global g_num
# g_num += 1
# print('sum:',g_num)
# lock.release() # 释放锁
# def sum_num2():
# lock.acquire() # 加入锁
# for i in range(1000000):
# global g_num
# g_num += 1
# print('sum:',g_num)
# lock.release() # 释放锁
lock = threading.Lock() # 创建死锁
def get_value(index):
lock.acquire()
print(threading.current_thread())
my_list = [2,6,8,7]
if index >= len(my_list):
print('下标越界',index)
lock.release()
return
value = my_list[index]
print(value)
time.sleep(0.2)
lock.release()
if __name__=='__main__':
# 创建子线程
# sub_thread = threading.Thread(target=task,args=(range(5),)) # 元组的形式
# sub_thread.start()
# sub_thread = threading.Thread (target=task, kwargs={'count':range (5)}) # 字典有形式
# sub_thread.start ()
# for _ in range(5):
# sub_thread = threading.Thread(target=task)
# sub_thread.start()
# sub_thread = threading.Thread (target=show_info)
# sub_thread.start()
# time.sleep(1)
# print('over')
# 守护主线程
# sub_thread = threading.Thread (target=show_info,daemon=True)
# sub_thread.start()
# time.sleep(1)
# print('over')
# write_thread = threading.Thread(target=add_data)
# read_thread = threading.Thread(target=read_data)
# write_thread.start()
# # write_thread.join() # 等待写入 线程结束后再运行
# read_thread.start()
# sum1_thread = threading.Thread(target=sum_num1)
# sum2_thread = threading.Thread(target=sum_num2)
# sum1_thread.start()
# # sum1_thread.join() # １.线程等待
# sum2_thread.start()
for i in range(30):
get_data = threading.Thread(target=get_value,args=(i,))
get_data.start()
# 1.线程之间执行是无序的
# 2.主线程会等待所有子线程执行结束再结束
# 3.线程之间共享全局变量
# 4.线程之间共享全局变量数据出现错误问题
# 解决方法 线程同步
# 1.线程等待(join) 《线程联合》
# 2.互斥锁 对共享数据进行锁定，保证同一时刻只能有一个线程去操作
# 互斥锁会让线程的性能下降
# 死锁 一直等待对方释放锁 ,导致的结果：应用程序停止响应
# 多线程可以完成多任务
用threading模块创建多线程
#
#0.常用的方法
# executor = concurrent.futures.ThreadPoolExecutor(max_workers=5) （import concurrent.futures）
# for i in range(0, 20):
# executor.submit(hello,i) # 多线程进行多任务
# executor.shutdown()
# 0.1常用的方法
# get_thread = threading.Thread(target=download,args=[url])
# get_thread.start()
# 1.传入一个函数并创建Thread实例，然后调用start方法开始执行
# import random
# import time,threading
#
# def thread_run(urls):
# print('Current %s is running...' %threading.current_thread().name)
# for url in urls:
# print('%s --->>>%s ' %(threading.current_thread().name,url))
# time.sleep(random.random())
# print ('%s ended...' % threading.current_thread ().name)
#
# print('%s is running ...' %threading.current_thread().name)
# t1 = threading.Thread(target=thread_run,name='Thread_1',args=(['url_1','url_2','url_3'],))
# t2 = threading.Thread(target=thread_run,name='Thread_2',args=(['url_4','url_5','url_6'],))
# t1.start()
# t2.start()
# t1.join()
# t2.join()
# print ('%s ended...' % threading.current_thread ().name)
#２.从threading.Thread继承创建线程类,重写__init__和run方法
import time,threading
import random
class myThread(threading.Thread):
def __init__(self,name,urls):
threading.Thread.__init__(self,name=name)
self.urls=urls
def run(self):
print('Current %s is running...' %threading.current_thread().name)
for url in self.urls:
print('%s --->>>%s '%(threading.current_thread().name,url))
time.sleep(random.random())
print('%s ended' %threading.current_thread().name)
print('%s is running ...' %threading.current_thread().name)
t1 = myThread(name='Thread_1',urls=['url_1','url_2','url_3'])
t2 = myThread(name='Thread_2',urls=['url_4','url_5','url_6'])
t1.start()
t2.start()
t1.join()
t2.join()
print ('%s ended...' % threading.current_thread ().name)
2.multiprocessing 多进程
# 使用multiprocessing模块创建多进程
# 0.常用的方法
from multiprocessing import Pool
# pool = Pool(processes=3)
# pool.map(target,args)
# 1.使用Pool类，使用进程池批量创建多个子进程
# import os,time,random
# from multiprocessing import Pool
#
# def run_proc(name):
# print('Child process %s（%s） Running...' %(name,os.getpid()))
# time.sleep(random.random()*3)
# print('Task %s end' %name)
#
# if __name__=='__main__':
# print('Parent process %s.' %os.getpid())
# p = Pool(processes=3) # 创建一个容量为3的进程池
# for i in range(5):
# p .apply_async(run_proc,args=(str(i),)) # 添加5个任务
# print('Waiting for all subprocesses done...')
# p.close() # close()方法停止添加进程
# p.join() # join()方法实现进程间的同步，等待所有的子进程执行完毕
# print('Process end')
# 2.使用process类，process动态生成多个进程
import os
from multiprocessing import Process
def run_proc(name):
print('Child process %s（%s） Running...' %(name,os.getpid()))
if __name__=='__main__':
print('Parent process %s.' %os.getpid())
for i in range(5):
p = Process(target=run_proc,args=(str(i),)) # 创建一个进程
print('Process will start.')
p.start() # start()方法启动进程
p.join() # join()方法实现进程间的同步
print('Process end')
3.QueueManager分布式进程
# taskManager.py # 服务进程
import queue as Queue
from multiprocessing.managers import BaseManager
from multiprocessing import freeze_support
# 任务个数
task_number = 10
# 1.定义收发队列task_queue和result_queue,用来存放任务和结果
task_queue = Queue.Queue(task_number)
result_queue = Queue.Queue(task_number)
def get_task():
return task_queue
def get_result():
return result_queue
class QueueManager(BaseManager): # 创建类似的QueueManager
pass
def win_run():
# 2.把创建的两个队列注册在网络上，将Queue对象在网络中暴露
# （Windows下绑定调用接口不能使用lambda,所以只能先定义函数再绑定）
QueueManager.register('get_task_queue',callable = get_task)
QueueManager.register ('get_result_queue', callable=get_result)
# 3.绑定端口并设置验证口令，这个相当于对象的初始化
# （Windows下需要填写IP地址，Linux下不填默认为本地）
# authkey='xxx' 换成 authkey=bytes('qiye', encoding='utf-8')
manager = QueueManager(address = ('127.0.0.1',8001),authkey = bytes('qiye', encoding='utf-8'))
# 4.启动管理，监听信息通道
manager.start()
try:
# 5.通过管理实例的方法获得通过网络访问的Queue对象（任务队列和结果队列）
task = manager.get_task_queue()
result = manager.get_result_queue()
# 6.添加任务
for url in ['ImageUrl_'+str(i) for i in range(10)]:
print('put task %s ...' %url)
task.put(url)
print('try get result...')
# 7.获取返回结果
for i in range(10):
print('result is %s' %result.get(timeout=10))
except:
print('Manager error')
finally:
# 8.关闭管理
# 一定要关闭。否则会报管道示关闭的错误
manager.shutdown()
if __name__ =='__main__':
# Windows下多进程可能会有问题，添加这名可以缓解
freeze_support()
win_run()
# taskWorker.py # 任务进程
import time
from multiprocessing.managers import BaseManager
# 1.创建类似的QueueManager
class QueueManager(BaseManager):
pass
# 2.使用QueueManager注册用于获取Queue的方法名称
QueueManager.register('get_task_queue')
QueueManager.register('get_result_queue')
# 3.连接到服务器:
server_addr = '127.0.0.1'
print('Connet to server %s...' %server_addr)
# 4.端口和验证口令，注意保持与服务进程完全一致
# authkey='xxx' 换成 authkey=bytes('qiye', encoding='utf-8')
m = QueueManager(address=(server_addr,8001),authkey = bytes('qiye', encoding='utf-8'))
m.connect() # 从网络连接
# 5.获取Queue对象,进行本地化
task = m.get_task_queue()
result = m.get_result_queue()
# 6.从task队列获取任务，并把结果写入result队列
while(not task.empty()):
image_url = task.get(True,timeout=5)
print('run task download %s ...' %image_url)
time.sleep(1)
result.put('%s--->success' %image_url)
print('worker exit.') # 处理结束
4.TCP,UDP网络编程
# TCP编程
## serverSocket.py
import socket
import threading
import time
def dealclient(sock,addr):
# 第四步：接收传来的数据 ，并改善给对方数据
print('Accept new connection from %s :%s...' %addr)
sock.send(b'Hello,I am server')
while True:
data = sock.recv(1024)
time.sleep(1)
if not data or data.decode('utf-8') == 'exit':
break
print('-->>%s!' %data.decode('utf-8'))
sock.send(('Loop_Msg:%s!' %data.decode('utf-8')).encode('utf-8'))
# 第五步：关闭Socket
sock.close()
print('Connection from %s:%s closed' %addr)
if __name__=='__main__':
# 第一步：创建一个基于IPv4和TCP协议的Socket
# Socket绑定的IP(127.0.0.1为本机IP)与端口
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('127.0.0.1',9999))
# 第二步：监听连接
s.listen(5)
print('Waiting for connection...')
while True:
# 第三步：接收一个新连接
sock,addr = s.accept()
# 创建新线程来处理TCP连接
t = threading.Thread(target=dealclient,args=(sock,addr))
t.start()
## customSocket.py
import socket
# 初始化Socket
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 连接目标的IP和端口
s.connect(('127.0.0.1',9999))
# 接收消息
print('-->>'+s.recv(1024).decode('utf-8'))
# 发送消息
s.send(b'Hello,I am a client')
print('-->>'+s.recv(1024).decode('utf-8'))
s.send(b'exit')
# 关闭Socket
s.close()
======================================
======================================
'''
# server.py
UDP编程
'''
#coding : utf-8
import socket
#创建Socket，绑定指定的IP和端口
# SOCK_DGRAM 指定了这个Socket 的类型是UDP，绑定端口和TCP示例一样。
s = socket.socket (socket.AF_INET,socket.SOCK_DGRAM)
s.bind(('127.0.0.1',9999))
print ( 'Bind UDP on 9999...' )
while True :
#直接发送数据和接收数据
data, addr = s.recvfrom(1024)
print('Received from %s : %s.' % addr)
s.sendto(b' He1lo,%s ! ' % data, addr)
'''
# custom.py
UDP编程
'''
# 客户端的创建和运行更加简单，创建Socket，直接可以与服务端进行数据交扌如下:
# coding : utf-8
import socket
s = socket.socket(socket .AF_INET,socket.SOCK_DGRAM)
for data in [b'He1lo',b'World']:
#发送数据:
s.sendto(data,('127.0.0.1',9999))
#接收数据:
print(s.recv(1024).decode('utf-8'))
s.close()
10.常用文件知识
1.常用的库
重要但未知 twisted
BeautifulSoup库 beautifulsoup4 from bs4 import BeautifulSoup
lxml解析库 lxml from lxml import etree
parsel解析库 parsel --parsel.Selector(response.text)
Selector解析 from scrapy import Selector --Selector(text = response.text)
Scrapy爬虫框架 scrapy
PyMySQL数据库 pymysql
jieba词频统计库 jieba
jsonpath解析库 jsonpath
pyinstaller打包库 pyinstaller --直接cmd pyinstaller -F -i favico.ico XXX.py --noconsole
cxfreeze打包库 cx_freeze --直接cmd cxfreeze --icon=favico1.ico ceshi.py --base-name="win32gui"
pygame游戏库 pygame
python-docx文档库 python-docx from docx import Document/from docx.shared import Pt
requests网页请求库 requests
selenium模拟库 selenium from selenium import webdriver driver = webdriver.Chrome() ，driver.get(XXX)
tqdm进度条库 tqdm from tqdm import tqdm for link in tqdm(m3u8):
xlwt表格库 xlwt
tkinterGUI库 from tkinter import */ from tkinter import scrolledtext, messagebox
messagebox.showinfo(title='提示', message='网页地址不能为空！')
scrolledtext.ScrolledText(self.root, width=86, height=28, font=('等线(中文正文)', 13))
urllib网页请求库 from urllib import request
webbrowser浏览库 webbrowser.open(XXX）
threading多线程库
multiprocessing多进程库 from multiprocessing import Pool
time时间库 time.sleep(1) /time.time()/time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
csv表格库
json库
pprint格式化库
os文件库
shutil库 shuitil.rmtree(file)
PIL图片库 from PIL import Image img = Image.open(file) ，imge.size /ima = Image.open('photo2.png')，ima = ima.crop((left,top,right,bottom))，ima.save('photo3.png')
pickle序列化库 相当于（Math.random() 和random.nextInt(100)）
random库 random.random()/random.uniform(0.1,0.5)/random.randint(0,9)/random.choice(user_agent)
subprocess库 res = subprocess.run("C:/Users/Icy-yun/Desktop/hi.docx", shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) /(os.system('XXX'))
chardet解码库 chardet import chardet res.encoding = chardet.detect(res.content)['encoding']
hashlib加密库 import hashlib words = string.encode('utf-8'),md5 = hashlib.md5(words).hexdigest()
datetime库 from datetime import datetime a = datetime.now() 当前时间
不常用的库：
1.aiohttp异步 aiohttp
asyncio异步 asyncio
2.pytesseract图片识别 pytesseract(+exe文件)
# taskManager.py # 服务进程
import queue as Queue
from multiprocessing.managers import BaseManager
from multiprocessing import freeze_support
# taskWorker.py # 任务进程
import time
from multiprocessing.managers import BaseManager
禁用库
UserAgent库 fake_useragent from fake_useragent import UserAgent 'User-Agent':UserAgent().random
2.常用的文件格式
一、图片的常用格式：
jpg, png, gif, wmf, tiff, jpeg, bmp, tga,
二、视频的常用格式：
mp4, wmv, avi, mkv, 3gp, rmm, rmvb
电脑里播放的一般为 rm\rmvb\wmv\avi\mp4\3gp\mkv
电视一般支持的格式为 rm\rmvb\avi
手机一般支持的格式为 rm\rmvb\avi\mp4\3gp
而mkv则一般用于高清影片，一般一个影片文件大概4G左右。
avi .mpg .mpeg .mpe .m1v .m2v .mpv2 .mp2V .dat .ts .tp .tpr .pva .pss .mp4 .m4V。
m4P .m4b .3gP .3gPP .3g2 .3gP2 .ogg .mov .qt .amr .rm .ram .rmvb .rpm
都是比较流行的视频格式。
视频最好但是较大的有.avi .mpg .mpeg
视频比较平均适合做电影的有.rm .ram .rmvb
小视频.3gp .wmv .mov
三、常见的文档格式：
txt, doc, pdf, html, htm
纯文本格式文件： txt
格式化的文本：docx, doc
便携式文档格式文件： pdf
超文本标记语言(HTML)：html, htm
四、常见的音乐格式
mp3, wma, wav, cda, aiff, au,
五、常见的表格格式
csv, xls, xlsx, pptx
六、常见的字体格式
字体文件的扩展名有eot、otf、fon、font、ttf、ttc、woff等。其中，大家最常用的，应该是ttf格式。
3.exe执行命令
1.单行命令
$ cat yourspider1start.pyfrom scrapy import cmdline
#方法1
cmdline.execute('scrapy crawl yourspidername".split())
#方法2
sys.argv = ['scrapy' . 'crawl', 'down_info_spider]
cmdline.execute()
#方法3,创建子进程执行外部程序。方法仅仅返回外部程序的执行结果。0表示执行成功。
os.system('scrapy crawl down_info_spider')
#方法4： （建议使用，但无法使用多选命令）
import subprocess
subprocess.Popen('scrapy crawl down_info_spider')
2.&多行命令
os.system('cd Scrapy_frame/scrapy_demo0 && python -m scrapy crawl demo_spider')
4.request请求数据
#coding:utf-8
import requests, json
url="https://api.sendcloud.net/apiv2/mail/send"
# 您需要登录SendCloud创建API_USER，使用API_USER和API_KEY才可以进行邮件的发送。
params = {"apiUser": "您账户中的API_USER", \
"apiKey" : "API_USER所对应的API_KEY",\
"from" : "service@sendcloud.im", \
"fromName" : "SendCloud测试邮件", \
"to" : "收件人地址", \
"subject" : "来自SendCloud的第一封邮件！", \
"html": "你太棒了！你已成功的从SendCloud发送了一封测试邮件，接下来快登录前台去完善账户信息吧！", \
}
r = requests.post(url, files={}, data=params)
print r.text
扫一扫
3307
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
