Python函数式编程 及案例

Python函数式编程 及案例

Python函数
虚参的类型根据实参来推断,作用类似于模板类型参数,但是更灵活

虚参缺省值

def print_sum(a,b=1,c=0):
s=a+b+c
print(“{0} + {1} + {2} = {3}”.format(a, b, c, s))
return s
x = print_sum(10, 20) # a=10, b=20, c=0

# x = print_sum(10, c=20) # a=10, b=1, c=20
# y = print_sum(“abc “, “xyz”) # a=’abc’, b= ‘xyz’, c=0 error!
y = print_sum(“abc “, “xyz”, ‘!’) # a=’abc’, b= ‘xyz’, c=’!’
z = print_sum(100.0 ,20) # a=100.0, b=1, c=0

虚实结合,实参赋值给虚参,虚参改变后不会影响实参

def swap(a, b):
a, b = b, a # 等价于 tuple 赋值: (a, b) = (b, a)
print(a, b)
x,y=3,4
print(x, y)
swap(x, y)
print(x, y)

列表参数

def lst_sum(lst):
s = 0
for e in lst:
s += e
return s
# s = (1,2,3,4,5) # tuple
# s = [1,2,3,4,5] # list
s = set((1,3,5,7,9)) # set
t = lst_sum(s) # s 可以是 tuple、list、set 等
print(s, t)

*args 和 **kw 参数

*args是可变参数,args接收的是一个 tuple

**kw是关键字参数,kw接收的是一个 dic 调用函数时,如何传入可变参数和关键字参数的语法:

可变参数,既可以直接传入:func(1, 2, 3);又可以先组装成 list 或 tuple,再通过args传入:func((1, 2, 3))

关键字参数既可以直接传入:func(a=1, b=2);又可以先组装成 dict,再通过kw传入:func({‘a’: 1, ‘b’: 2})

使用*args和**kw是Python的习惯写法,当然也可以用其他参数名,但*好使用习惯用法

def func_paras(param1, *params, **words):
print(“param1: “,param1) # ==> Hello!
print(“params: “, params) # ==> (1, 2, 3, 4, 5, ‘abc’)
print(“words: “, words) # ==> {‘word1’: ‘Java’, ‘word2’: ‘Python’}

func_paras(“Hello!”,1,2,3,4,5,”abc”, word1=”Java”, word2=”Python”)

python限定方法参数类型、返回值类型、变量类型等
https://www.cnblogs.com/linkenpark/p/11676297.html

限定方法参数类型、返回值类型、变量类型
基本类型指定

def test(a:int, b:str) -> str:
print(a, b)
return 1000

test(‘test’, ‘abc’)

# 函数test,
# a:int 指定了输入参数a为int类型,
# b:str b为str类型,
# -> str 返回值为srt类型。
*终返回了一个int,此时pycharm就会有警告;
当调用这个方法时,参数a我们输入的是字符串,此时也会有警告;
但非常重要的一点是,pycharm只是提出了警告,但实际上运行是不会报错,毕竟python的本质还是动态语言

def test(b: List[int]) -> str:
print(b)
return ‘abc’
test([1,’a’])

虽然我们指定了List[int]即由int组成的列表,但是,实际中,只要这个列表中存在int(其他的可以为任何类型),就不会出现警告

复杂的类型标注
Vector = List[float]
def scale(scalar: float, vector: Vector) -> Vector:
return [scalar * num for num in vector]
# typechecks; a list of floats qualifies as a Vector.
new_vector = scale(2.0, [1.0, -4.2, 5.4])
print(new_vector)

创建变量时的类型指定

class Employee(NamedTuple):
name: str
id: int = 3

employee = Employee(‘Guido’)
assert employee.id == 3

迭代器、生成器
迭代器(iterator),是函数式编程的基石
生成器(generator),是一类用来简化编写迭代器工作的特殊函数
迭代器,是一个数据流对象;该对象每次只返回一个元素
next() 方法:
无参数,并总是返回数据流中的下一个元素
无元素时,会抛出异常 StopIteration
迭代器未必是有限的
iter() 函数:
接受任意对象并试图返回一个迭代器
对象若不支持迭代时,抛出 TypeError 异常
对象若能生成迭代器,则称为 iterable,可迭代的对象类型有:
元组、列表、序列(字符串)、字典(key)、集合、文件等
for X in Y 等价于 for X in iter(Y)
list(iterator), 把迭代器具体化成列表
tuple(iterator), 把迭代器具体化成元组

L = [1, 2, 3]
it = iter(L) #转化为 迭代器
print(it)
print(it.__next__()) # ==> 1 等价于 next(it)
print(next(it)) # ==> 2
print(next(it)) # ==> 3
print(next(it)) # StopIteration
it = iter([1, 2, 3]) # 转化为迭代器
for x in it:
print(x) # ==> 1 2 3
t = tuple(iter(L)) # ==> (1, 2, 3) – 元组
lst = list(it) # ==> [] – 空列表,it 已空
print(t, lst)
a, b, c = iter([1, 2, 3]) # 解压
print(a,b,c)

生成器(generator) – yield
普通的函数返回(return)一个值,而生成器返回(yield)一个能返回数据流的迭代器。当你调用一个生成器函数,它并不会返回单独的值,而是返回一个支持生成器协议的生成器对象
当执行 yield 表达式i时,生成器会输出 i 的值,就像 return 表达式一样。yield 和 return *大的区别在于,到达 yield 的时候生成器的执行状态会挂起并保留局部变量。在下一次调用生成器 next() 方法的时候,函数会恢复执行。
yield进一步阅读:Python3之携程 https://www.cnblogs.com/zhangxinqi/p/8337207.html

def generate_ints(N):
for i in range(N):
yield i # 用 yield 取代 return
gen = generate_ints(3)
print(gen)
print(next(gen))
print(next(gen))
print(next(gen))
for i in generate_ints(5):
print(i)
a, b, c = generate_ints(3)
print(a, b, c,”\n”)

斐波拉契数列

def generate_fab(n): # 生成斐波拉契数列的前 n 个数
for i in range(2):
yield 1
x = y = 1
for i in range(2, n):
z = x + y
x, y = y, z
yield z
for k in generate_fab(10):
print(k)
print()

yield 变成了一个表达式,返回一个可以赋给变量或执行操作的值: val = (yield i)。而send(value) 方法向生成器val发送值value

def counter(maximum):
i = 0
while i < maximum:
val = (yield i)
# If value provided, change counter
if val !=None:
i = val # i = val +1
else:
i += 1

it = counter(20)
L1 = [next(it) for i in range(3)] # 列表推导式,见 2.3 节
print(L1) # ==> [0, 1, 2]
it.send(8)# 向 it 发送值 8, val = 8
L1.extend([next(it) for i in range(3)])#list.extend() 合并列表
print(L1)
it.send(15) # 向 it 发送值 15
L1.extend([next(it) for i in range(3)])
print(L1) # ==> [0, 1, 2, 9, 10, 11, 16, 17, 18]
it.send(5) # 向 it 发送值 5
L1.extend([next(it) for i in range(3)])
print(L1) # ==> [0, 1, 2, 9, 10, 11, 16, 17, 18, 6, 7, 8]

生成器表达式() 与 列表推导式[]
Generator expression – returns iterator

stripped_iter = (line.strip() for line in line_list)
print(stripped_iter, tuple(stripped_iter))

List comprehension – returns list

stripped_list = [line.strip() for line in line_list]
print(stripped_list)

if – 加过滤条件

stripped_list = [line.strip() for line in line_list if line != “\n”]
print(stripped_list)

生成器表达式的一般形式(语法):
( expression for expr1 in sequence1
if condition1
for expr2 in sequence2
if condition2

for exprN in sequenceN
if conditionN )
等价于:

for expr1 in sequence1:
if not (condition1):
continue # Skip this element
for expr2 in sequence2:
if not (condition2):
continue # Skip this element

for exprN in sequenceN:
if not (conditionN):
continue # Skip this element

Python高阶函数、装饰器、偏函数
函数是对象
函数作为对象使用,可以赋值,可作为参数传递等,可以递归;
Python: 一切皆对象

内嵌函数:在函数内部定义的函数;
函数闭包:外部函数返回了内嵌函数,或内部函数引用了外部变量
def g():
count = 0 # g()的局部变量
def counter(): # g()的内嵌函数
nonlocal count # 不是counter()的内部变量,而是它外部g()的变量
count += 1
return count
return counter # 返回函数对象

f1 = g()
f2 = g() # f1 与 f2 执行时,互不影响

print(“f1:”, f1(), f1()) # ==> f1: 1 2
print(“f2:”, f2()) # ==> f2: 1
print(“f1:”,f1(), f1()) # ==> f1: 3 4
print(“f2:”, f2(), f2(), f2()) # ==> f2: 2 3 4

def fiboracci(): # 斐波拉契数列
x = y = 1
def gen(): # 斐波拉契数列生成器
nonlocal x, y
z = x + y
x, y = y, z
return z
return gen
f1 = fiboracci()
f2 = fiboracci()
L1 = [f1() for i in range(10)]
print(L1) # ==> [2, 3, 5, 8, 13, 21, 34, 55, 89, 144]
print([f2() for i in range(8)]) # ==> [2, 3, 5, 8, 13, 21, 34, 55]

高阶函数 -map、reduce、filter、sorted
map

def f1(x):
return x ** 2

L = [1,2,3,4,5,6,7,8,9]
R = list(map(f1, L)) # 让map的结果转换为list
print(“map结果:”, R) # == > map结果: [1, 4, 9, 16, 25, 36, 49, 64, 81]

r2 = map(f1, L)
print(r2) # map对象,是一个可迭代的(iterable)对象
for x in r2:
print(x)

reduce

from functools import reduce
def f2(x, y):
return x * 10 + y
a = reduce(f2, L)
print(“reduce结果为:”, a) # == > reduce结果为: 123456789
filter
def is_odd(n):
return n % 2 == 1
L1 = list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
print(L1) # ==> [1, 5, 9, 15]

zip (不是高阶函数,常用)

L1 =[1,3,5,7,9]
L2 =[10,11,12,13,14]
for x,y in zip(L1,L2):
print(x,y)
L = list(zip(L1,L2))
print(L)

3.4 匿名函数(lambda 表达式)

L6 = list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(“匿名函数:”,L6) # ==> [1, 4, 9, 16, 25, 36, 49, 64, 81]

def f(x):
return x * x

f = lambda x: x * x

L6 = list(map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(L6) # ==> [1, 4, 9, 16, 25, 36, 49, 64, 81]

装饰器(Decorator)
给已有函数增加额外的功能,而不需要改变原函数代码及其调用方式

def handle(): # 原业务功能函数
print(“处理主要的业务逻辑 -handle”)

handle() # 原调用方式

新加一个高阶函数,增加额外功能

def log(func): # 装饰器,给函数 func 增加额外功能
counter = 0
def wrapper(*args, **kwargs):
nonlocal counter
counter += 1
print(“counter:%d,执行%s之前” % (counter, func.__name__))
func() # 调用原函数
print(“counter:%d,执行%s之后” % (counter, func.__name__))
return wrapper

def handle(): # 原业务功能函数
print(“处理主要的业务逻辑 -handle”)

调用装饰器对已有函数进行装饰,左边的 handle=wrapper

handle = log(handle) # 每次调用前都要这样做,比较麻烦,也违反开闭原则
handle() # 等价于: log(handle)()

@log# handle = log(handle) 使用log对handle进行封装,左边 handle=wrapper
def handle(): # 原业务功能函数
print(“处理主要的业务逻辑 -handle”)
handle() # 调用方式不变
import time
def log2(time): # 装饰器函数
def decorator(func):
def wrapper(*args, **kwargs):
print(time.title())
print(“执行%s之前” % (func.__name__))
func()
print(“执行%s之后” % (func.__name__))
return wrapper
return decorator
@log2(time=time.ctime()) # 加装饰器
def handle2():
print(“处理主要的业务逻辑 -handle2”)

handle2() # 调用方式不变

进一步阅读 https://blog.csdn.net/mall_lucy/article/details/108791699?utm_source=app

偏函数
当函数的参数个数太多,需要简化时,使用functools.partial可以创建一个新的函数,这个新函数可以固定住原函数的部分参数,从而在调用时更简单

def power(base, exponent):
return base ** exponent

from functools import partial

square = partial(power, exponent=2) # power(base, exponent=2)
print(square(3), square(4)) # ==> 9 16
import functools

通过偏函数声明一个函数名为int2的函数,实现转换成int类型并且参数要和base保持一致*后的结果是10进制的类型

int2 = functools.partial(int, base=2)
print(“二进制的数:”,int2(“1000”)) # ==> 8

python 爬虫搭建代理库

python 爬虫搭建代理库

python 爬虫搭建代理库
*近科研由于需要用到微博签到数据,于是就写了个爬虫程序爬取微博签到位置信息,普通的爬取效率太低, 通过多线程又会被遭到IP的封禁,于是就自己写了个创建代理池的程序。
首先找到一个比较稳定的免费代理ip的网址,我这里推荐两个https://www.kuaidaili.com/free/inha,https://ip.jiangxianli.com。这里我拿第二个举例子。
*步就是爬取这个网站,把里面的ip地址和端口号以及类型给爬取下来,具体爬取方法这里就不再多说,就是*基本的request+bs4就可以了,废话不多说直接上代码

def get_ip():
# 定义三个列表分别存放ip,端口和类型
ips, ports, types = [], [], []
# 请求头
headers = {
“User-Agent”: “Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36 Edg/89.0.774.68”
}
# 这里我爬取了99页
for page in range(1, 100):
try:
url = f’https://ip.jiangxianli.com/?page={page}’
resp = requests.get(url, headers=headers, verify=False)
print(resp.status_code)
# BeautifuSoup解析文档
soup = BeautifulSoup(resp.text, “html.parser”)
tbody = soup.find(“tbody”)
for tr in tbody.find_all(“tr”):
tds = tr.find_all(“td”)
# 将ip,端口号以及类型存入列表
ips.append(tds[0].text)
ports.append(tds[1].text)
types.append((tds[3]).text)
time.sleep(1)
print(f”{page}页”)
except:
print(“请求失败”)
# 返回ip,端口以及类型列表
return ips, ports, types

第二步,就是检验爬取的ip地址是否可用,把可用的代理ip地址存起来,方便以后调用,这里我就用百度的首页来检验了。上代码

def check_ip():
# 获取爬到的数据
ips, ports, types = get_ip()
# 定义请求头
headers = {
“User-Agent”: “Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36 Edg/89.0.774.68”
}
# 定义一个列表保存可以用的ip地址
good_ip = []
for i in range(len(ips)):
# 定义一个代理对象
proxy = {}
# 将遍历得到的ip地址, 端口以及类型存入对象
proxy[types[i]] = ips[i] + “:” + ports[i]
try:
resp = requests.get(“https://www.baidu.com”, headers=headers, proxies=proxy, verify=False)
# 判断请求是否成功
if resp.status_code == 200:
# 把可用的ip 存入事先声明的列表中
good_ip.append(proxy)
print(f”可用的ip{i+1}”)
except Exception as e:
print(proxy, e)
# 返回可用的代理ip列表
return good_ip

something-somethingV2数据集处理

something-somethingV2数据集处理

something-V1视频数108,499,下载的数据集中视频已经被分割成帧;something-V2视频数220,847,格式为webm,是视频,所以需要自己划分成帧,再做进一步处理。

下载
下载地址:https://20bn.com/datasets/something-something/v2

%title插图%num
下载00-19,还有右边的labels文件
下载好后,进入存放这些是压缩包的文件夹,运行以下命令解压并拼接(Linux系统)
cat 20bn-something-something-v2-?? | tar zx
1
对所有视频划分帧
2.1. 安装ffmpeg (配置软连接时注意写对路径!!原文作者路径写错了,直接复制自己的路径比较靠谱)
2.2 代码
from __future__ import print_function, division
import os
import sys
import subprocess

def class_process(dir_path, dst_dir_path):
class_path = dir_path
if not os.path.isdir(class_path):
return

dst_class_path = dst_dir_path
if not os.path.exists(dst_class_path):
os.mkdir(dst_class_path)

for file_name in os.listdir(class_path):
if ‘.webm’ not in file_name:
continue
name, ext = os.path.splitext(file_name)
dst_directory_path = os.path.join(dst_class_path, name)

video_file_path = os.path.join(class_path, file_name)
try:
if os.path.exists(dst_directory_path):
if not os.path.exists(os.path.join(dst_directory_path, ‘000001.jpg’)):
subprocess.call(‘rm -r \”{}\”‘.format(dst_directory_path), shell=True)
print(‘remove {}’.format(dst_directory_path))
os.mkdir(dst_directory_path)
else:
continue
else:
os.mkdir(dst_directory_path)
except:
print(dst_directory_path)
continue
cmd = ‘ffmpeg -i \”{}\” -vf scale=-1:240 \”{}/%06d.jpg\”‘.format(video_file_path, dst_directory_path)
print(cmd)
subprocess.call(cmd, shell=True)
print(‘\n’)

if __name__==”__main__”:
print (“HELLO”)
dir_path = sys.argv[1]
dst_dir_path = sys.argv[2]

count=0
for class_name in os.listdir(dir_path):
print (count)
count=count+1
class_process(dir_path, dst_dir_path)

2.3 运行代码

python 上述代码名.py dir_path dst_dir_path
1
dir_path:解压视频后的路径
dst_dir_path:分割后的帧存放路径

我的:

python video_jpg_ucf101_hmdb51.py /root/data/somethingV2/20bn-something-something-v2/ /root/data/somethingV2_jpg/
1
效果为每个视频保存为一个文件夹,文件夹内包含各帧:

%title插图%num
生成训练列表、测试列表
代码
使用gen_label_sthv2.py进行处理,运行该py文件,修改代码里的文件路径(46行附近):

%title插图%num
这里需要改成自己something-somethingV2的帧的路径。然后运行该代码即可。

 

主进程会等待所有的子进程执行结束再结束

主进程会等待所有的子进程执行结束再结束

主进程会等待所有的子进程执行结束再结束。

import multiprocessing
import time
def task():
while True:
print(“任务执行中…”)
time.sleep(0.2)
#标准python写法,直接执行的模块需要加上判断是否是主模块的代码
if __name__==”__main__”:
sub_process=multiprocessing.Process(target=task)
# 把子进程设置成守护住进程,以后主进程退出子进程直接销毁
# sub_process.daemon=True
sub_process.start()

# 主进程延迟0.5秒钟
time.sleep(0.9)
sub_process.terminate()
print(“over”)
# 结论:主进程会等待子进程执行完成以后程序再退出

# 解决办法:主进程退出,子进程销毁
# 1.让子进程设置成为守护子进程:主进程退出于子进程销毁,子进程会依赖主进程
# 2.让主进程退出之前先让子进程销毁

#输出结果
任务执行中…
任务执行中…
任务执行中…
任务执行中…
任务执行中…
over

进程已结束,退出代码0

假如我们就让主进程执行0.5秒钟,子进程就销毁不再执行,那怎么办呢?

我们可以设置守护主进程 或者 在主进程退出之前 让子进程销毁
守护主进程:

守护主进程就是主进程退出子进程销毁不再执行
子进程销毁:

子进程执行结束

pytorch中创建Tensor张量的几种方法

pytorch中创建Tensor张量的几种方法

以下所有例子没有打印输出,要验证结果请自行打印

1,将python列表和numpy数组转换为pytorch张量

import numpy as np
import torch

a = torch.tensor([1, 2, 3, 4]) # 将python列表转换为torch张量
b = torch.tensor([1, 2, 3, 4], dtype=torch.float32) # 将python列表转换为torch张量并指定数据类型
c = torch.tensor(range(10)) # 转换迭代器为张量
d = torch.tensor(np.array([1, 2, 3, 4])) #转换numpy数组为pytorch张量
e = torch.tensor([[1, 2, 3], #列表嵌套创建张量
[4, 5, 6]])

2,通过pytorch内置的函数创建张量

import torch

a = torch.rand(3, 3) #生成3*3的矩阵,矩阵元素服从[0,1]上的均匀分布
b = torch.randn(2, 3, 4) #生成2*3*4的张量,服从标准正态分布
c = torch.zeros(4, 2, 3) # 生成4*2*3,张量元素全为0
d = torch.ones(3, 4, 2) # 生成3*4*2,张量元素全为1
e = torch.eye(3) # 生成3*3的单位矩阵
f = torch.randint(0, 10, (3, 3)) # 生成0(包含)到10(不包含)之间均匀分布整数的3X3矩阵

3,通过已知张量创建形状相同的张量

import torch

a = torch.randn(3, 3) # 生成一个随机正态分布的张量
b = torch.zeros_like(a) # 生成一个元素全为0的张量,形状和给定张量a相同
c = torch.ones_like(a) # 生成一个元素全为0的张量,形状和给定张量a相同
d = torch.rand_like(a) # 生成一个元素服从(0,1)上的均匀分布的张量,形状和给定张量a相同
e = torch.randn_like(a) # 生成一个元素服从标准正太分布的张量,形状和给定张量a相同

4,通过已知张量创建形状不同但数据类型相同的张量

import torch

a = torch.randn(3, 3) # 生成一个随机正态分布的张量
b = a.new_tensor([1, 2, 3]) # 根据Python列表生成与a相同数值类型的张量
c = a.new_zeros(3, 3) # 生成元素全为0且与a相同数据类型的张量
d = a.new_ones(3, 3) # 生成元素全为1且与a相同数据类型的张量

python办公笔记分享

python办公笔记分享

python 处理办公软件
一、文件处理
1、输出目录下所有文件及文件夹
获取当前python程序运行目录

import os
print(os.getpwd())

路径连接

import os
print(os.path.join(‘pythonTest’, ‘test1’))

列出某个文件夹下所有文件和文件夹

import os
print(os.listdir(‘D:/mycode/’))

循环判断指定文件夹中哪些是文件夹

import os

files = os.listdir()
for file in files:
print(file, os.path.isdir(file))

os.scandir() 查找文件**(更推荐)**

import os

for file in os.scandir(‘D:/mycode/’):
print(file.name, file.path, file.is_dir())

练习: 列出当前目录包含hello字符串的文件的个数(不区分大小写)

import os

num = 0
for file in os.scandir(‘./’):
if not file.is_dir():
if ‘hello’ in file.name.lower():
num += 1
print(“包含hello的文件个数:”, num)

2、遍历、搜索文件及查询文件信息
遍历文件夹

import os

for root, dirs, files in os.walk(‘./’):
print(f’发现文件夹:{root})’)
print(f’文件夹列表:{dirs}’)
print(f’文件列表:{files}’)
print(‘————————–‘)

是否某字符串开头、结尾

print(‘abc.txt’.startswith(‘ab’))
print(‘abc.txt’.endswith(‘.txt’))

搜索指定的文件

模式 意义
* 匹配所有
? 匹配任何单个字符
[seq] 匹配seq中的任何字符
[!seq] 匹配任何不在seq中的字符
import glob
print(glob.glob(‘*.txt’))

递归搜索指定文件

import glob
print(glob.glob(‘**/*.txt’, recursive=True))

匹配文件名

import fnmatch

print(fnmatch.fnmatch(‘lesson1.py’, ‘le*1.py’))
print(fnmatch.fnmatch(‘lesson1.py’, ‘le*[0-9].py’))

查询文件信息

import os

import time
for file in os.scandir():
print(file.name, file.stat().st_size/1024/1024, time.ctime(file.stat().st_mtime))

datetime模块输出时间

import datetime

that_time = datetime.datetime.fromtimestamp(1567764428)
print(that_time)
print(that_time.year, that_time.month, that_time.day, that_time.hour, that_time.minute, that_time.second)

练习: 递归搜索当前文件夹中今年修改的后缀名为 .zip 的所有文件

import os
import glob
import datetime

now_year = datetime.datetime.now().year
print(‘当前目录以下文件为今年的.zip压缩文件:’)
for file in glob.glob(‘**/*.zip’, recursive=True):
file_year = datetime.datetime.fromtimestamp(os.stat(file).st_mtime).year
if file_year == now_year:
print(file, f’文件大小为:{os.stat(file).st_size/1024}KB’)

3、创建临时文件及文件夹
读取文件

f = open(‘test.txt’, ‘r’, encoding=’utf-8′)
text = f.readlines()
print(text)
f.close()

with … as … 写法:

with open(‘test.txt’, ‘r’, encoding=’utf-8′) as f:
text = f.readlines()
print(text)

写入文件

with open(‘test2.txt’, ‘w’, encoding=’utf-8′) as f:
f.write(‘hello world’)

创建临时文件

from tempfile import TemporaryFile

f = TemporaryFile(‘w+’)
f.write(‘hello world’)
f.seek(0)
data = f.readlines()
print(data)
f.close()

创建临时文件夹

from tempfile import TemporaryDirectory

with TemporaryDirectory() as tmp_folder:
print(f’临时文件夹:{tmp_folder}’)

4、批量创建、复制、移动、删除、重命名文件及文件夹
创建文件夹

import os

if not os.path.exists(‘dirname’):
os.mkdir(‘dirname’)

创建多层文件夹

import os
os.makedirs(‘aa/bb/cc’)

复制文件

import shutil

shutil.copy(‘test.txt’, ‘./aa/test.txt’)
shutil.copy(‘test.txt’, ‘./aa/new_test.txt’)

复制文件夹 (新文件夹不能已经存在)

import shutil
shutil.copytree(‘aa/’, ‘dd/’)

移动文件或者文件夹

import shutil

shutil.move(‘test.txt’, ‘bb/’)
shutil.move(‘test.txt’, ‘bb/new_test.txt’)
shutil.move(‘aa/’, ‘bb/’)

重命名文件或文件夹

import os

os.rename(‘test.txt’, ‘new_test.txt’)
os.rename(‘aa/’, ‘new_aa/’)

删除文件

import os
os.remove(‘test.txt’)

删除文件夹

import shutil
shutil.rmtree(‘aa/’)

练习: 找出当前文件夹中所有.zip文件,并加上该文件*后修改日期重命名,然后将所有重命名后的文件移动到backup文件夹中。

import os
import datetime
import shutil

if not os.path.exists(‘backup’):
os.mkdir(‘backup’)
for file in os.scandir():
if file.name.endswith(‘.zip’):
m_format_time = datetime.datetime.fromtimestamp(os.stat(file.name).st_mtime).strftime(‘%Y-%m-%d’)
shutil.move(file.name, ‘backup/’ + m_format_time + ‘-‘ + file.name)

5、创建和解压压缩包
读取压缩包

import zipfile

with zipfile.ZipFile(‘test.zip’, ‘r’) as zipobj:
for file_name in zipobj.namelist():
print(file_name)

读取压缩包内文件的信息

import zipfile

with zipfile.ZipFile(‘test.zip’, ‘r’) as zipobj:
for file_name in zipobj.namelist():
info = zipobj.getinfo(file_name)
print(file_name, info.file_size, info.compress_size)

解压压缩包中的单个文件

import zipfile

with zipfile.ZipFile(‘test.zip’, ‘r’) as zipobj:
zipobj.extract(‘test.txt’)

解压所有文件

import zipfile

with zipfile.ZipFile(‘test.zip’, ‘r’) as zipobj:
zipobj.extractall()

将有密码的压缩包解压

import zipfile

with zipfile.ZipFile(‘test.zip’, ‘r’) as zipobj:
zipobj.extractall(path=’解压/’, pwd=b’123456′)

创建压缩包

import zipfile

file_list = [‘test1.txt’, ‘test2.txt’, ‘test3.txt’]
with zipfile.ZipFile(‘compress.zip’, ‘w’) as zipobj:
for file in file_list:
zipobj.write(file)

向已有压缩包中添加文件

import zipfile

with zipfile.ZipFile(‘compress.zip’, ‘a’) as zipobj:
zipobj.write(‘test4.txt’)

练习: 将当前文件夹所有修改时间在今天之前的文件重命名加上*后修改日期,将所有重命名后的文件都添加到带有今天日期的压缩包里,并将压缩包移动到backup文件夹中,删除原始文件。

import os
import datetime
import zipfile

new_name_list = []
now_time_num = int(datetime.datetime.now().strftime(‘%Y%m%d’))
for file in os.scandir():
if not (file.is_dir() or file.name.endswith(‘.py’)):
file_mtime = os.stat(file.name).st_mtime
file_mtime_num = int(datetime.datetime.fromtimestamp(file_mtime).strftime(‘%Y%m%d’))
if file_mtime_num < now_time_num:
file_mtime_format = datetime.datetime.fromtimestamp(file_mtime).strftime(‘%Y-%m-%d’)
file_new_name = file_mtime_format + ‘-‘ + file.name
print(file.name, file_mtime_format)
os.rename(file.name, file_new_name)
new_name_list.append(file_new_name)

if not os.path.exists(‘backup’):
os.mkdir(‘backup’)
if len(new_name_list) > 0:
now_time = datetime.datetime.now()
now_date_format = now_time.strftime(‘%y-%m-%d’)
compress_name = now_date_format + ‘-compress.zip’
with zipfile.ZipFile(‘./backup/’ + compress_name, ‘w’) as zipobj:
for file_name in new_name_list:
zipobj.write(file_name)
os.remove(file_name)

二、处理 Excel 表格
1、python 打开及读取 Excel 表格内容
打开Excel表格并获取表格名称

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)

获取sheet的尺寸范围

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook[‘Sheet1′]
print(sheet.dimensions)

获取某个单元格数值

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
cell = sheet[‘C1′]
print(cell.value)

获取某个单元格的行、列、坐标

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
cell = sheet[‘C1′]
print(cell.row, cell.column, cell.coordinate)

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
cell = sheet.cell(row=1, column=4)
print(cell.row, cell.column, cell.coordinate)

获取一系列的单元格

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
for row in sheet.iter_rows(min_row=2, max_row=4, min_col=2, max_col=4):
for cell in row:
print(cell)

迭代整个表格的所有行

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
for row in sheet.rows:
print(row)

2、python 向 Excel 表格中写入内容
向某个单元格中写入内容并保存

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
sheet[‘B2’] = ‘hello world’
workbook.save(filename=’test.xlsx’)

插入python列表数据

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
data = [
[‘张三’, 1],
[‘李四’, 2],
[‘王五’, 3]
]
for row in data:
sheet.append(row)
workbook.save(filename=’test.xlsx’)

插入一列

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
sheet.insert_cols(idx=2)
workbook.save(filename=’test.xlsx’)

插入多行

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
sheet.insert_rows(idx=2, amount=3)
workbook.save(filename=’test.xlsx’)

删除行

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
sheet.delete_rows(idx=2, amount=2)
workbook.save(filename=’test.xlsx’)

移动单元格

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
sheet.move_range(‘A1:B2′, cols=2, rows=2)
workbook.save(filename=’test.xlsx’)

创建和删除表格

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
print(workbook.sheetnames)
workbook.create_sheet(‘MySheet’)
sheet = workbook[‘Sheet1′]
workbook.remove(sheet)
workbook.save(filename=’test.xlsx’)

复制表格

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook[‘MySheet’]
workbook.copy_worksheet(sheet)
workbook.save(filename=’test.xlsx’)

修改表格名称

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
workbook[‘MySheet’].title = ‘MyNewSheet’
workbook.save(filename=’test.xlsx’)

创建新的Excel文件

from openpyxl import Workbook

workbook = Workbook()
sheet = workbook.active
sheet.title = ‘表格一’
for i in range(1, 10):
for j in range(1, 10):
sheet.cell(row=i, column=j).value = i * j
workbook.save(filename=’output.xlsx’)

冻结窗格

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
sheet.freeze_panes = ‘B2′
workbook.save(filename=’test.xlsx’)

筛选

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
sheet.auto_filter.ref = sheet.dimensions
workbook.save(filename=’test.xlsx’)

修改字体样式

from openpyxl.styles import Font
from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
cell = sheet[‘A2′]
cell.font = Font(name=’微软雅黑’, size=12, italic=True, bold=True, color=’ff0000′)

获取表格中字体的样式

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
cell = sheet[‘B2′]
font = cell.font
print(font.name, font.size, font.italic, font.bold)

设置对其样式

wrap_text 是否自动换行

from openpyxl import load_workbook
from openpyxl.styles import Alignment

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
cell = sheet[‘B2’]
cell.value = ‘锄禾日当午,汗滴禾下土。’
alignment = Alignment(horizontal=’center’, vertical=’center’, text_rotation=45)
cell.alignment = alignment
workbook.save(filename=’test.xlsx’)

单元格边框设置

from openpyxl import load_workbook
from openpyxl.styles import Border,Side

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
cell = sheet[‘C3′]
side1 = Side(style=’thin’, color=’FF0000′)
side2 = Side(style=’dashed’, color=’0000FF’)
border = Border(left=side1, right=side1, top=side2, bottom=side2)
cell.border = border
workbook.save(filename=’test.xlsx’)

设置填充样式

from openpyxl import load_workbook
from openpyxl.styles import PatternFill, GradientFill

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
cell_d4 = sheet[‘D4′]
pattern_fill = PatternFill(fill_type=’solid’, fgColor=’FF0000′)
cell_d4.fill = pattern_fill
cell_e5 = sheet[‘E5’]
gradient_fill = GradientFill(stop=(‘FF0000′, ’00FF00’, ‘0000FF’))
cell_e5.fill = gradient_fill
workbook.save(filename=’test.xlsx’)

设置行高和列宽

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
sheet.row_dimensions[1].height = 50
sheet.column_dimentsions[‘A’].width = 50
workbook.save(filename=’test.xlsx’)

合并单元格

from openpyxl import load_workbook

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
sheet.merge_cells(‘A1:B2′)
sheet.merge_cells(start_row=5, end_row=7, start_column=5, end_column=7)
workbook.save(filename=’test.xlsx’)

取消合并单元格 unmerge_cells

插入图片

from openpyxl import load_workbook
from openpyxl.drawing.image import Image

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
logo = Image(‘logo.png’)
logo.width = 100
logo.height = 50
sheet.add_image(logo, ‘C1′)
workbook.save(filename=’test.xlsx’)

插入柱状图

from openpyxl import load_workbook
from openpyxl.chart import BarChart, Reference

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
chart = BarChart()
data = Reference(worksheet=sheet, min_row=1, max_row=6, min_col=2, max_col=6)
categories = Reference(sheet, min_col=1, min_row=2, max_row=6)
chart.add_data(data, titles_from_data=True)
chart.set_categories(categories)
sheet.add_chart(chart, ‘A7’)
workbook.save(‘test.xlsx’)

插入条形图

from openpyxl import load_workbook
from openpyxl.chart import LineChart, Reference

workbook = load_workbook(filename=’test.xlsx’)
sheet = workbook.active
chart = LineChart()
data = Reference(worksheet=sheet, min_row=1, max_row=6, min_col=2, max_col=6)
categories = Reference(sheet, min_col=1, min_row=2, max_row=6)
chart.add_data(data, from_rows=True, titles_from_data=True)
chart.set_categories(categories)
sheet.add_chart(chart, ‘A7’)
workbook.save(‘test.xlsx’)

三、处理 PDF 文件
1、提取PDF文字内容
使用 pdfplumber 提取文字

import pdfplumber

with pdfplumber.open(‘test.pdf’) as pdf:
first_page = pdf.pages[0]
print(first_page.extract_text())

使用 pdfplumber 提取单个简单表格

import pdfplumber

with pdfplumber.open(‘test.pdf’) as pdf:
first_page = pdf.pages[0]
table = first_page.extract_table()
print(table)

使用 pdfplumber 提取多个简单表格

import pdfplumber

with pdfplumber.open(‘test.pdf’) as pdf:
table_page = pdf.pages[0]
for table in table_page.extract_tables():
print(table)

提取表格时设定参数

import pdfplumber

with pdfplumber.open(‘test.pdf’) as pdf:
table_page = pdf.pages[0]
table = table_page.extract_table(
table_settings={
“vertical_strategy”: “text”,
“horizontal_strategy”: “text”
}
)
print(table)

使用 pypdf2 分割 pdf

from PyPDF2 import PdfFileReader, PdfFileWriter

pdf_reader = PdfFileReader(‘test.pdf’)
for page in range(pdf_reader.getNumPages()):
pdf_writer = PdfFileWriter()
pdf_writer.addPage(pdf_reader.getPage(page))
with open(f’./分割后的PDF文件/divide_page{page}.pdf’, ‘wb’) as out:
pdf_writer.write(out)

使用 pypdf2 合并 pdf

from PyPDF2 import PdfFileReader, PdfFileWriter

pdf_writer = PdfFileWriter()
for page in range(2):
pdf_reader = PdfFileReader(f’./分割后的PDF文件/divide_page{page}.pdf’)
for page_num in range(pdf_reader.getNumPages()):
pdf_writer.addPage(pdf_reader.getPage(page_num))

with open(‘merge.pdf’, ‘wb’) as out:
pdf_writer.write(out)

使用 pypdf2 旋转 pdf 页面

from PyPDF2 import PdfFileReader, PdfFileWriter

pdf_reader = PdfFileReader(‘test.pdf’)
pdf_writer = PdfFileWriter()
for num in range(pdf_reader.getNumPages()):
if num % 2 == 0:
page = pdf_reader.getPage(num).rotateClockwise(90)
pdf_writer.addPage(page)
else:
page = pdf_reader.getPage(num).rotateCounterClockwise(90)
pdf_writer.addPage(page)

with open(‘rotateTest.pdf’, ‘wb’) as out:
pdf_writer.write(out)

使用 pypdf2 给 pdf 加水印

from PyPDF2 import PdfFileReader, PdfFileWriter
from copy import copy

watermark_pdf = PdfFileReader(‘watermark.pdf’)
watermark_page = watermark_pdf.getPage(0)

pdf_reader = PdfFileReader(‘test.pdf’)
pdf_writer = PdfFileWriter()

for page in range(pdf_reader.getNumPages()):
original_page = pdf_reader.getPage(page)
new_page = copy(watermark_page)
new_page.mergePage(original_page)
pdf_writer.addPage(new_page)

with(open(‘watermarkFile.pdf’, ‘wb’)) as out:
pdf_writer.write(out)

使用 pypdf2 加密 pdf 文件

from PyPDF2 import PdfFileReader, PdfFileWriter

pdf_reader = PdfFileReader(“test.pdf”)
pdf_writer = PdfFileWriter()
for page in range(pdf_reader.getNumPages()):
pdf_writer.addPage(pdf_reader.getPage(page))

pdf_writer.encrypt(“123456”)
with open(‘test_encrypt.pdf’, ‘wb’) as out:
pdf_writer.write(out)

使用 pypdf2 解密 pdf 文件

from PyPDF2 import PdfFileReader, PdfFileWriter

pdf_reader = PdfFileReader(‘test_encrypt.pdf’)
pdf_reader.decrypt(“123456”)
pdf_writer = PdfFileWriter()

for page in range(pdf_reader.getNumPages()):
pdf_writer.addPage(pdf_reader.getPage(page))

with open(‘test_decrypt.pdf’, ‘wb’) as out:
pdf_writer.write(out)

四、处理Word文件
1、Python读取Word文档内容
读取内容

from docx import Document

doc = Document(‘test.docx’)
for paragraph in doc.paragraphs:
print(paragraph.text)

读取文字块

from docx import Document

doc = Document(‘test.docx’)
for paragraph in doc.paragraphs:
for run in paragraph.runs:
print(run.text)

2、Python写入Word文档内容
添加标题、段落

from docx import Document

doc = Document()
doc.add_heading(‘一级标题’, level=1)
paragraph1 = doc.add_paragraph(‘这是*段段落。’)
paragraph2 = doc.add_paragraph()
paragraph2.add_run(‘加粗’).bold = True
paragraph2.add_run(‘普通’)
paragraph2.add_run(‘斜体’).italic = True
doc.save(‘test.docx’)

添加分页

from docx import Document

doc = Document()
doc.add_heading(“*页”, level=2)
doc.add_paragraph(“*页内容”)
doc.add_page_break()
doc.add_heading(“第二页”, level=3)
doc.add_paragraph(“第二页内容”)
doc.save(“test2.docx”)

添加图片

from docx import Document
from docx.shared import Cm

doc = Document()
doc.add_picture(“test.jpg”)
doc.add_picture(“test.jpg”, width=Cm(5))
doc.add_picture(“test.jpg”, width=Cm(5), height=Cm(8))
doc.save(“test3.docx”)

添加表格

from docx import Document

records = [
[‘学号’, ‘姓名’, ‘成绩’],
[101, ‘张三’, 99],
[102, ‘李四’, 96],
[103, ‘王五’, 98]
]

doc = Document()
table = doc.add_table(rows=4, cols=3)
for row in range(4):
cells = table.rows[row].cells
for col in range(3):
cells[col].text = str(records[row][col])

doc.save(‘test4.docx’)

3、Word文档内容编辑
文字样式的修改

from docx import Document
from docx.shared import Pt, RGBColor
from docx.oxml.ns import qn

doc = Document(“test.docx”)
for paragraph in doc.paragraphs:
for run in paragraph.runs:
run.font.bold = True
run.font.italic = True
run.font.underline = True
run.font.strike = True
run.font.shadow = True
run.font.size = Pt(20)
run.font.color.rgb = RGBColor(255, 0, 0)
run.font.name = ‘微软雅黑’
r = run._element.rPr.rFonts
r.set(qn(‘w:eastAsia’), ‘微软雅黑’)

doc.save(“test_modified.docx”)

段落对齐

from docx import Document
from docx.enum.text import WD_ALIGN_PARAGRAPH

doc = Document(‘test.docx’);
for paragraph in doc.paragraphs:
paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER

doc.save(‘test_modified.docx’)

段落行间距

from docx import Document
from docx.enum.text import WD_ALIGN_PARAGRAPH

doc = Document(‘test.docx’)
for paragraph in doc.paragraphs:
paragraph.paragraph_format.line_spacing = 2.0

doc.save(‘test_modified.docx’)

段前段后间距

from docx import Document
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.shared import Pt

doc = Document(‘test.docx’)
for paragraph in doc.paragraphs:
paragraph.paragraph_format.space_before = Pt(12)
paragraph.paragraph_format.space_after = Pt(12)

doc.save(‘test_modified.docx’)

五、处理PPT文件
1、Python读取PPT
读取PPT文字

from pptx import Presentation

prs = Presentation(‘test.pptx’)
for slide in prs.slides:
for shape in slide.shapes:
if shape.has_text_frame:
text_frame = shape.text_frame
print(text_frame.text)

读取PPT段落

from pptx import Presentation

prs = Presentation(‘test.pptx’)
for slide in prs.slides:
for shape in slide.shapes:
text_frame = shape.text_frame
for paragraph in text_frame.paragraphs:
print(paragraph.text)

pytorch的数学计算(元素级别)

pytorch的数学计算(元素级别)

目录
1.*对值、求和、三角函数
2.相乘再相加、相除再相加
3.向上取整、向下取整、夹逼函数、乘法、取相反数、取倒数、取平方根倒数和平方根
4.除法、余数、取小数、四舍五入、指数运算
5.自然对数、平滑对数、幂运算
6.线性插值
7.Sigmoid函数,sign函数,截断值
1.*对值、求和、三角函数
a = torch.Tensor([-1,0,1])
print(torch.abs(a)) # *对值
print(torch.add(a,3)) # 求和
print(torch.cos(a))
print(torch.acos(a)) # 反余弦
———————————————————————
result:
tensor([1., 0., 1.])
tensor([2., 3., 4.])
tensor([0.5403, 1.0000, 0.5403])

2.相乘再相加、相除再相加
a = torch.Tensor([-1,0,1])
b = torch.Tensor([1,2,3])
c = torch.Tensor([4,5,6])
# a,b,c维度必须相同
#a + 0.1*b/c
x = torch.addcdiv(a,0.1,b,c)
print(x)
#a + 0.1*b*c
y = torch.addcmul(a,0.1,b,c)
print(y)
———————————————————————
result:
tensor([-0.9750, 0.0400, 1.0500])
tensor([-0.6000, 1.0000, 2.8000])

3.向上取整、向下取整、夹逼函数、乘法、取相反数、取倒数、取平方根倒数和平方根
x = torch.Tensor([[-1.5,0,1.1],[1.2,2.8,3.6]])
# 向上取整
print(torch.ceil(x))
# 向下取整
print(torch.floor(x))
# 夹逼函数
print(torch.clamp(x,-1.5,1.5)) # 输入 下限 上限
# 乘法
print(torch.mul(x,0.1))
# 取相反数
print(torch.neg(x)) # neg 否定的
# 取倒数
print(torch.reciprocal(x)) # reciprocal 倒数
# 取平方根倒数
print(torch.rsqrt(x[x>0]))
# 平方根
print(torch.sqrt(x)) # 负数没有平方根
———————————————————————
result:
tensor([[-1., 0., 2.],
[ 2., 3., 4.]])
tensor([[-2., 0., 1.],
[ 1., 2., 3.]])
tensor([[-1.5000, 0.0000, 1.1000],
[ 1.2000, 1.5000, 1.5000]])
tensor([[-0.1500, 0.0000, 0.1100],
[ 0.1200, 0.2800, 0.3600]])
tensor([[ 1.5000, -0.0000, -1.1000],
[-1.2000, -2.8000, -3.6000]])
tensor([[-0.6667, inf, 0.9091],
[ 0.8333, 0.3571, 0.2778]])
tensor([0.9535, 0.9129, 0.5976, 0.5270])
tensor([[ nan, 0.0000, 1.0488],
[1.0954, 1.6733, 1.8974]])

4.除法、余数、取小数、四舍五入、指数运算
x = torch.Tensor([4,9])
# 除法
print(torch.div(x,3))
# 余数
q = torch.Tensor([2.1,2.5,2.7])
print(torch.fmod(q,2))
print(torch.remainder(q,2)) # remainder 余数
# 返回浮点数小数部分
print(torch.frac(q))
# 四舍五入
print(torch.round(q))
# 指数运算
print(torch.exp(torch.Tensor([0])))
———————————————————————
result:
tensor([1.3333, 3.0000])
tensor([0.1000, 0.5000, 0.7000])
tensor([0.1000, 0.5000, 0.7000])
tensor([0.1000, 0.5000, 0.7000])
tensor([2., 2., 3.])
tensor([1.])

5.自然对数、平滑对数、幂运算
# 自然对数
x = torch.Tensor([math.e,math.e**2])
print(torch.log(x))
# 平滑对数 对x+1平滑处理后再求对数
print(torch.log1p(x))
# 以2为底的对数
print(torch.log2(x))
# 以10为底的对数
print(torch.log10(x))
# 幂运算
print(torch.pow(x,1),torch.pow(x,2))
———————————————————————
result:
tensor([1., 2.])
tensor([1.3133, 2.1269])
tensor([1.4427, 2.8854])
tensor([0.4343, 0.8686])
tensor([2.7183, 7.3891]) tensor([ 7.3891, 54.5982])

6.线性插值
# 线性插值: out = start + weight(end-start)
x = torch.zeros(10)
print(x)
y = torch.arange(10).float()
print(y)
z = torch.lerp(x,y,0.5)
print(z)
———————————————————————
result:
tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
tensor([0.0000, 0.5000, 1.0000, 1.5000, 2.0000, 2.5000, 3.0000, 3.5000, 4.0000,
4.5000])

7.Sigmoid函数,sign函数,截断值
# Sigmoid函数
x = torch.arange(-5,5,1).float()
print(x)
print(torch.sigmoid(x))
# sign函数: 元素为正返回1 为负返回-1 ,0返回0
print(torch.sign(x))
# 截断值:截取小数点前面的数
print(torch.trunc(torch.Tensor([-0.9,-1.2,-1.9,0,2.2,2.9]))) #trunc 劫取整数部分
———————————————————————
result:
tensor([-5., -4., -3., -2., -1., 0., 1., 2., 3., 4.])
tensor([0.0067, 0.0180, 0.0474, 0.1192, 0.2689, 0.5000, 0.7311, 0.8808, 0.9526,
0.9820])
tensor([-1., -1., -1., -1., -1., 0., 1., 1., 1., 1.])
tensor([-0., -1., -1., 0., 2., 2.])

可视化运行Python的神器Jupyter Notebook

可视化运行Python的神器Jupyter Notebook

 

看动画学算法
以动画的方式,图文并茂讲解常用的算法和数据结构,包括各种排序算法、hash、栈、队列、链表、树、散列表、堆、图等,*对物有所值!
flydean程序那些事
¥39.90
订阅博主
文章目录
简介
Jupyter Notebook
启动notebook server
notebook document 的结构
code cells
markdown cells
raw cells
以模块的形式导入Jupyter Notebooks
简介
如果我们想要运行Python,通常有两种方式,*种方式就是在Python或者IPython的解释器环境中进行交互式运行,还有一种方式就是程序员*喜欢的编写.py文件,在文件中编写python代码,然后运行。

%title插图%num

如果我们想写一篇关于Python的文章,文章里面有代码,还希望代码能够在当前页面运行,可不可以做到呢?

可以的,那就是使用我们今天要介绍的Jupyter Notebook。

Jupyter Notebook
Jupyter项目是从Ipython项目中分出去的,在Ipython3.x之前,他们两个是在一起发布的。在Ipython4.x之后,Jupyter作为一个单独的项目进行开发和管理。因为Jupyter不仅仅可以运行Python程序,它还可以执行其他流程编程语言的运行。

Jupyter Notebook包括三个部分,*个部分是一个web应用程序,提供交互式界面,可以在交互式界面中运行相应的代码。

上图是NoteBook的交互界面,我们可以对文档进行编辑,运行等操作。

主要的功能如下:

在浏览器中进行代码编辑,自动语法突出显示,缩进和制表符完成/自检功能。

从浏览器执行代码的能力,并将计算结果附加到生成它们的代码上。

使用诸如HTML,LaTeX,PNG,SVG等富媒体表示来显示计算结果。例如,可以内嵌包含matplotlib库渲染的具有出版质量的图形。

使用Markdown标记语言在浏览器中对富文本进行的编辑(可以为代码提供注释)不仅限于纯文本。

使用LaTeX轻松在markdown单元中包含数学符号的能力,并由MathJax本地呈现。

第二个部分就是NoteBook的文档了,这个文档存储了要运行的代码和一些描述信息。一般这个文档是以.ipynb的后缀进行存储的。

notebook文档是以json的形式存储的,并用base64进行编码。使用json的好处就是可以在不同的服务器中方便的进行数据的交互。

Notebook documents中除了可运行的代码文件,还可以存储说明等解释性内容,从而将代码和解释内容完美结合,尤其适合做学习笔记使用。

笔记本可以通过nbconvert命令导出为多种静态格式,包括HTML,reStructuredText,LaTeX,PDF等多种格式。

另外文档还可以方便的在网络上进行共享。

第三个部分就是代码运行的核心Kernels,通过不同的Kernels搭配,notebook可以支持运行多种程序。比如:Python,java,go,R,ruby,nodejs等等。

这些Kernels和notebook之间是以Json的形式通过MQ来进行通信的。

启动notebook server
有了文档之后,如果我们想要运行文档,需要启动notebook server。

jupyter notebook
1
默认情况下会开启下面的URL: http://127.0.0.1:8888

启动的时候还可指定要打开的.ipynb文件:

jupyter notebook my_notebook.ipynb
1
具体的notebook界面的操作这里就不多介绍了,基本上和普通的编译器差不多。大家可以自行探索。

notebook document 的结构
notebook中包含了多个cells,每个cell中包含了多行文本输入字段,可以通过Shift-Enter 或者工具栏中的播放按钮来执行其中的代码。

这里的cell有三种类型,分别是code cells,markdown cells和raw cells。

code cells
代码单元允许您编辑和编写新代码,并突出显示完整的语法和制表符。 您使用的编程语言取决于内核,默认内核(IPython)运行Python代码。

执行代码单元时,它包含的代码将发送到与笔记本关联的内核。 然后,从该计算返回的结果将在笔记本中显示为单元格的输出。 输出不仅限于文本,还有许多其他可能的输出形式,包括matplotlib图形和HTML表格(例如,在pandas数据分析包中使用的表格)。

我们看一个code cells的例子:

#%%

import numpy as np
my_arr = np.arange(1000000)
my_list = list(range(1000000))

每个单元格是以 #%% 来进行分隔的。

Ipython本身还支持多种富文本的展示格式,包括HTML,JSON,PNG,JPEG,SVG,LaTeX等。

Ipython提供了一个display方法,我们可以使用display来展示要呈现的对象:

from IPython.display import display
1
display(obj) 将会寻找这个对象所有可能的展示类型,并从中挑选一个*适合的类型进行展示,并将结果存储在Notebook文档里面。

如果你想展示特定类型的对象,那么可以这样:

from IPython.display import (
display_pretty, display_html, display_jpeg,
display_png, display_json, display_latex, display_svg
)

举个展示图片的例子:

from IPython.display import Image
i = Image(filename=’../images/ipython_logo.png’)
i
display(i)

上面的例子中i包含了一个Image对象,直接调用i即可展示,我们也可以显示的调用display(i)。

其他的富文本类型可以参考Image,使用方法都是类似的。

markdown cells
markdown是一种简介的标记语言,使用起来非常简单,使用范围非常广泛,所以notebook document也支持markdown的语法。

先看一个markdown cell的例子:

#%% md

“`python
$ python
Python 3.6.0 | packaged by conda-forge | (default, Jan 13 2017, 23:17:12)
[GCC 4.8.2 20140120 (Red Hat 4.8.2-15)] on linux
Type “help”, “copyright”, “credits” or “license” for more information.
>>> a = 5
>>> print(a)
5
“`

markdown中的语法在notebook中都是可以用的。

还支持标准的LaTeX 和 AMS-LaTeX语法。

raw cells
原始单元格提供了一个可以直接写入输出的位置。 notebook不会对原始单元格中的内容进行计算。

以模块的形式导入Jupyter Notebooks
有时候我们希望以模块的形式导入Jupyter Notebooks,但是可惜的是,Jupyter Notebooks并不是一个标准的python程序,不过Python提供了一些钩子程序,让我们能够方便的进行导入。

首先,我们需要导入一些基本的API :

import io, os, sys, types

from IPython import get_ipython
from nbformat import read
from IPython.core.interactiveshell import InteractiveShell

接下来需要注册NotebookFinder到sys.meta_path:

sys.meta_path.append(NotebookFinder())
1
这个NotebookFinder就是定义的钩子。

我们看下NotebookFinder的定义:

class NotebookFinder(object):
“””Module finder that locates Jupyter Notebooks”””
def __init__(self):
self.loaders = {}

def find_module(self, fullname, path=None):
nb_path = find_notebook(fullname, path)
if not nb_path:
return

key = path
if path:
# lists aren’t hashable
key = os.path.sep.join(path)

if key not in self.loaders:
self.loaders[key] = NotebookLoader(path)
return self.loaders[key]

里面使用了两个重要的方法,find_notebook用来找到notebook,和NotebookLoader,用来加载notebook。

看下find_notebook的定义:

def find_notebook(fullname, path=None):
“””find a notebook, given its fully qualified name and an optional path

This turns “foo.bar” into “foo/bar.ipynb”
and tries turning “Foo_Bar” into “Foo Bar” if Foo_Bar
does not exist.
“””
name = fullname.rsplit(‘.’, 1)[-1]
if not path:
path = [”]
for d in path:
nb_path = os.path.join(d, name + “.ipynb”)
if os.path.isfile(nb_path):
return nb_path
# let import Notebook_Name find “Notebook Name.ipynb”
nb_path = nb_path.replace(“_”, ” “)
if os.path.isfile(nb_path):
return nb_path

看下NotebookLoader的定义:

class NotebookLoader(object):
“””Module Loader for Jupyter Notebooks”””
def __init__(self, path=None):
self.shell = InteractiveShell.instance()
self.path = path

def load_module(self, fullname):
“””import a notebook as a module”””
path = find_notebook(fullname, self.path)

print (“importing Jupyter notebook from %s” % path)

# load the notebook object
with io.open(path, ‘r’, encoding=’utf-8′) as f:
nb = read(f, 4)

# create the module and add it to sys.modules
# if name in sys.modules:
# return sys.modules[name]
mod = types.ModuleType(fullname)
mod.__file__ = path
mod.__loader__ = self
mod.__dict__[‘get_ipython’] = get_ipython
sys.modules[fullname] = mod

# extra work to ensure that magics that would affect the user_ns
# actually affect the notebook module’s ns
save_user_ns = self.shell.user_ns
self.shell.user_ns = mod.__dict__

try:
for cell in nb.cells:
if cell.cell_type == ‘code’:
# transform the input to executable Python
code = self.shell.input_transformer_manager.transform_cell(cell.source)
# run the code in themodule
exec(code, mod.__dict__)
finally:
self.shell.user_ns = save_user_ns
return mod

有了他们,我们就可以直接import我们自己编写的notebook了。

pytest快速入门

pytest快速入门

pytest
学习内容

%title插图%num

特点:

简答、已读
支持参数化
支持运行由unitest编写的测试Case
具有很多第三方插件,并且可以自定义扩展
支持重复执行失败的case
可以和持续集成工具集成
安装及快速入门
安装命令:pip3 install pytest

创建*个测试用例
#1.导入pytest包
import pytest
#2.测试用例方法
def func(x):
return x+1

def test001():
print(‘—–test001用例——-‘)
assert func(3) == 6 #断言失败

def test002():
print(‘——test002用例——–‘)
assert func(3) == 4 #断言成功

#3.执行
if __name__ == ‘__main__’:
pytest.main([“-vs”,”test_sample.py”])

pytest的前后置
(1)函数级别:setup、teardown

用于测试方法的始末
运行一次测试用例会运行一次setup和teardown
# 类之外
def test001():
print(“teat001用例_类外”)

def test002():
print(“test002用例_类外”)

def setup():
print(‘用例开始前执行’)

def teardown():
print(“用例后执行”)

if __name__ == ‘__main__’:
pytest.main([“-vs”,”test_method.py”])

运行结果:

%title插图%num

(2)类级别:setup_class、teardown_class

运行于测试类的始末
(3)类中方法级别

setup_method 、teardown_method
(4)模块级别(需放置类外):setup_module 、teardoen_module

所有模块开始始末
import pytest

def setup_module(self):
print(“模块开始前运行”)

def teardown_module(self):
print(“模块结束后运行”)

class Testclass():

def setup_class(self):
print(“类开始前运行”)

def teardown_class(self):
print(“类结束后运行”)

def setup_method(self):
print(“类中方法开始前运行”)

def teardown_method(self):
print(“类中方法结束后运行”)

def test001(self):
print(“test001用例——类中”)

def test002(self):
print(“test002用例——类中”)

def test003(self):
print(“test003用例——类中”)

if __name__ == ‘__main__’:
pytest.main([“-vs”,”test_class.py”])

运行结果:

%title插图%num
默认运行规则
测试文件以test_.py开头或以.test.py结尾
测试类以Test开头,并且不能带有__init__方法
测试函数以test_开头
自定义运行规则
文件名:pytest.ini(不可更改)
作用域:当前目录和其子目录下的所有case

#标识
[pytest]

#指定默认执行的命令
addopts = -vs

#指定执行case的目录,多个目录用空格隔开
testpaths=./testcase

#指定文件、类、方法的命名规则,多个用空格隔开
python_files = test_*.py
python_classes = Test_* Test*
python_functions = test_* test*

python之二分法

python之二分法
文章目录
python之二分法
一、什么是算法
二、二分法应用场景
示例
一、什么是算法
这里的算法就是基于函数递归的称述拓展

算法就是高效解决问题的方法
二分法就是一种算法
二、二分法应用场景
想要从一个从小到大排列的成千上万个值中找到指定的值
如果使用遍历的话效率太低
那么而二分法就可以*大的缩小问题的规模,以此来提高效率
示例
nums = [-23,-2,4,5,8,90,234,345,467,786,978,8900] # 从小到大排列
def check(num,l):
print(l)
if len(l) == 0:
print(“不存在这个值”)
return
mid_num = len(l) // 2
if num > l[mid_num]: # 说明在中间值得右边
l = l[mid_num+1:] # 使用切片将右边的值从新赋值给 l
check(num,l) # 递归
elif num < l[mid_num]: # 说明在中间值得右边
l = l[:mid_num] # 使用切片将右边的值从新赋值给 l
check(num,l) # 递归
else:
print(“OK!”)

check(8900,nums) # OK!