Python基础学习篇
简介：
Python由荷兰数学和计算机科学研究学会的吉多·范罗苏姆（Guido van Rossum）于1990 年代初设计。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上快速开发应用的编程语言。
Python可以应用于众多领域，如：数据分析、网络服务、图像处理、数值计算和科学计算等众多领域。互联网公司广泛使用Python来做的事一般有：自动化运维、自动化测试、大数据分析、爬虫、Web开发等。
2021年，Tiobe将Python加冕为最受欢迎的编程语言，20年来首次将其置于Java、C之上。
数据类型：
Python3 的八个标准数据类型:
数据类型
子类
示例
Number（数字）
int
a = 2
float
a = 21.5
complex
a = 3j
String（字符串）
str
a = "Hello World!"
List（列表）
list
a = ["cloud", "23", "male"]
range
a = range(10)
Tuple（元组）
tuple
a = ("cloud", "23", "male")
Set（集合）
set
a = {"cloud", "23", "male"}
frozenset
a = frozenset({"cloud",23, "male"})
Dictionary（字典）
dict
a = {"name":"cloud","age":23}
Bool(布尔类型)
True
a = True
False
a = False
二进制类型
bytes
b"Hello"
bytearray
bytearray(7)
memoryview
memoryview(bytes(7))
Python3 的八个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
NUMBER
数字数据类型用于存储数值。数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。
数学函数
1 # 返回数字的绝对值
2 abs(-5)
3 # 返回数字的上入整数
4 import math
5 print(math.ceil(3.2))
6 # 返回e的幂次方
7 math.exp(3)
8 # 返回数字flot类型的绝对值
9 math.fabs(-3)
10 # 返回数字的下舍整数
11 math.floor(3.7)
12 # 返回数字的自然对数
13 math.log(7.31)
14 # 返回以10为基数的自然对数
15 math.log10(7)
16 # 返回给定参数的最大值
17 max(5,7,9,14)
18 # 返回给定参数的最小值
19 min(5,7,9,14)
20 # 返回数值的整数部分和小数部分，以浮点型表示
21 math.modf(37.5)
22 # 返回2的3次方
23 pow(2,3)
24 # 四舍五入，给出n则保留小数位数
25 round(3.141592,3)
26 round(3.741592)
27 # 开平方
28 math.sqrt(4)
数学函数
随机数函数
随机数可以用于数学，安全等领域中，经常被嵌入到算法中，提高算法效率，以及提高程序的安全性。
1 # 从序列中随机挑选一个元素
2 import random
3 random.choice(range(20))
4 # 递增基数集合中的一个随机数，基数默认值为1
5 random.randrange(5,30,2)
6 # 生成0到1之间的一个随机数
7 random.random()
8 # 随机排序
9 wu = [3,5,1,7]
10 random.shuffle(wu)
11 print(wu)
12 # 生成指定范围内的一个数
13 random.uniform(2,10)
三角函数
1 import math
2
3 # 反余弦弧度值
4 math.acos(8)
5 # 反正弦弧度值
6 math.asin(8)
7 # 反正切弧度值
8 math.atan(8)
9 # x和y坐标的反正切值
10 math.atan2(6,7)
11 # 弧度的余弦值
12 math.cos(7)
13 # 欧几里得范数
14 math.hypot(2,3)
15 # 弧度的正弦值
16 math.sin(9)
17 # 弧度的正切值
18 math.tan(6)
19 # 将弧度转为角度
20 math.degrees(5)
21 # 将角度转为弧度
22 math.radians(5)
三角函数
STR
字符串是 Python 中最常用的数据类型。我们可以使用单引号或双引号来创建字符串。
创建
1 wu = 'cloud'
2 zhang = "Fang"
查询
1 # 查询第一个元素
2 wu[0]
3 # 查询第二个到第四个元素，不包含第四个
4 wu[1:3]
修改
1 # 修改第五个元素之后的值
2 wu[:4]+'s'
内置方法
1 # 第一个字符转为大写
2 wu.capitalize()
3 # 将字符串居中，两边按指定字符填充
4 wu.center(31,'*')
5 # 统计字符在字符串中出现的次数，可以指定匹配范围
6 fe = 'haffsfjajldjafjkaklfjkajfka'
7 fe.count('j',2,17)
8 # 编码,将字符串转为bytes类型
9 he = wu.encode(encoding='utf-8')
10 print(he)
11 # 解码,将bytes类型转为字符串
12 wu = he.decode(encoding='utf8')
13 print(wu)
14 # 检查字符串是否以某个字符开头，可以指定范围
15 fe1 = 'ha'
16 fe.startswith(fe1)
17 fe.atartswith(fe1,0,18)
18 # 检查字符串是否以某个字符结束，可以指定范围
19 fe1 = 'aj'
20 fe.endswith(fe1)
21 fe.endswith(fe1,2,18)
22 # 将字符串中tab符号转化为空格,默认是8个空格，可以指定数量
23 fe2 = 'jdalkjsfkl\tsadlkjal'
24 fe3 = fe2.expandtabs()
25 print(fe3)
26 fe3 = fe2.expandtabs(3)
27 print(fe3)
28 # 从左边开始检查字符串中是否包含该字符，可指定范围，包含返回索引，不包含返回-1
29 fe2.find('sfk',2,15)
30 # 从右边开始检查字符串中是否包含该字符，可指定范围，包含返回索引，不包含返回-1
31 fe2.rfind('sfk',2,15)
32 # 从左边开始检查字符串中是否包含该字符,可指定范围，包含返回索引，不存在发生异常
33 fe2.index('sfk',3,13)
34 # 从右边开始检查字符串中是否包含该字符,可指定范围，包含返回索引，不存在发生异常
35 fe2.rindex('sfk',3,13)
36 # 判断所有字符是否都是字母或数字
37 fe2.isalnum()
38 # 判断所有字符是否都是字母或中文
39 fe2.isalpha()
40 # 1、判断所有字符是否都是数字
41 s4 = '123546'
42 s4.isdigit()
43 # 2、判断所有字符是否都是数字
44 s4.isnumeric()
45 # 判断所有字母是否都是大写
46 s5 = 'DFHFSJKFH'
47 s5.islower()
48 # 判断所有字母是否都是小写
49 s6 = 'dhfshsf'
50 s6.isupper()
51 # 判断是否是空字符串
52 s7 = " "
53 s7.isspace()
54 # 检查首字母是否是大写
55 s8 = 'Hello!'
56 s8.istitle()
57 # 以指定字符为分隔符，拼接序列内的所有元素，返回一个新字符串
58 s9 = '-'
59 li = ['c','l','o','u','d']
60 s9.join(li)
61 # 返回字符串长度
62 len(s8)
63 # 将原字符串左对齐，并*填充至长度30,默认使用空格填充
64 s8.ljust(30,'*')
65 # 将原字符串右对齐，并*填充至长度30,默认使用空格填充
66 s8.rjust(30,'*')
67 # 将原字符串右对齐，并0填充至长度30
68 s8.zfill(30)
69 # 截取字符串头尾的字符或空格
70 s9 = ' sjdkaj '
71 s9.strip()
72 s10 = 'dkshdk'
73 s10.lstrip('dk')
74 # 截取字符串左边的字符或空格
75 s9 = ' sjdkaj '
76 s9.lstrip()
77 s10 = 'dkshdk'
78 s10.lstrip('dk')
79 # 截取字符串右边的字符或空格
80 s9 = ' sjdkaj '
81 s9.rstrip()
82 s10 = 'dkshdk'
83 s10.rstrip('dk')
84 # 返回字符串中最大字母
85 max(s10)
86 # 返回字符串中最小字母
87 min(s10)
88 # 字符h替换成s12的字符1次
89 s11 = 'hfjhfhSDfhksfh'
90 s12 = 'zz'
91 s11.replace('h',s12,1)
92 # 按指定字符截取字符串，可指定截取次数
93 s11.split('f',2)
94 # 将所有大写字符转化为小写
95 s11.lower()
96 # 字符串反转，大写转小写，小写转大写
97 s11.swapcase()
98 # 将字符串首字母大写
99 s11.title()
100 # 小写转大写
101 s11.upper()
102 # 检查是否包含十进制字符
103 s11.isdecimal()
内置方法
LIST
列表是 Python 中最基本的数据结构。列表中的每个值都有对应的位置值，称之为索引，索引以0开始。列表都可以进行的操作包括索引，切片，加，乘，检查成员。它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型
创建
1 list = [1,2,3,4,5]
2 list1 = [7,8,9,10,11]
查询：从左往右下标是0开始，从右往左下标是1开始
1 print(list1[0])
2 print(list1[-2])
3 print(list1[1:4])
修改：对列表的数据项进行修改，也可以使用 append() 方法来追加列表项
1 list1[2] = 11
2 print(list1[2])
3 list1.append(6)
4 print(list1)
删除：使用 del 语句来删除列表的的元素
1 del list1[2]
2 print(list1)
列表操作符：+ 号用于组合，* 号用于重复列表
1 # 查询列表长度
2 print(len(list1))
3 #组合列表lise和list1
4 print(list2+list1)
5 #重复list
6 print(list1 * 4)
7 #判断元素是否存在列表中
8 print(3 in list1)
9 #迭代
10 for i in list1:print(i,end="")
列表截取与拼接
1 #读取第三个元素
2 print(list1[2])
3 #从右往左读取第三个元素
4 print(list1[-3])
5 #输出第三个元素开始后的所有元素
6 print(list1[2:])
嵌套列表：在列表里创建其他列表作为元素。
1 x=[list2,list1]
2 print(x)
列表函数
1 #查询列表长度
2 print(list1)
3 #查询列表元素最大值
4 print(max(list1))
5 #查询列表元素最小值
6 print(min(list1))
7 #将元组转化为列表
8 a = (12,13,14,15,)
9 a = list(a)
10 print(a)
列表方法
1 #在列表末尾添加新元素
2 list1.append(21)
3 #统计列表中某个元素的个数
4 list1.count(2)
5 #在列表末尾添加另一个序列的元素
6 list1.extend(list2)
7 #从列表中找出某个值第一个匹配的索引
8 list1.index(21)
9 #将对象插入列表的索引3的位置
10 list1.insert(3,23)
11 #移除列表的一个元素，默认最后一个，也可以设置索引选择，并返回该元素
12 list1.pop([1])
13 #删除列表中某元素的第一匹配项
14 list1.remove(1)
15 #反向列表中的元素
16 list1.reverse()
17 #对原列表进行排序reverse = True 降序， reverse = False 升序（默认）
18 list1.sort(reverse=True)
19 #清空列表元素
20 list1.clear()
21 #复制列表
22 list2.copy()
列表方法
tuple
元组是不可变类型，使用小括号( )
创建：
1 tup1 = (1,2,3,4,5)
2 tup2 = ('a','b','c','d','f')
3 # 当元组只有一个元素时，需要在元素后面添加逗号
4 tup3 = ('year',)
查询：使用索引查询元组中的元素
1 print(tup1[0])
2 print(tup1[1:3])
修改：元组是不可变类型，但是允许连接组合
1 tup4 = tup1+tup2
2 print(tup4)
删除：元组中的元素不允许删除，但是可以删除整个元组
1 del tup3
运算符： 和列表一样，元组之间也是可以用 + 号和 * 号进行运算。
1 # 查询元组长度
2 len(tup1)
3 # 元组连接
4 tup3 = tup1+tup2
5 # 复制元组
6 tup5 = tup1*2
7 # 查询元素是否存在元组
8 print(2 in tup1)
9 # 迭代
10 for i in tup1:print(i,end="")
索引及截取
1 #读取第三个元素
2 print(tup1[2])
3 #从右往左读取第三个元素
4 print(tup1[-3])
5 #输出第三个元素开始后的所有元素
6 print(tup1[2:])
内置函数
1 #查询元组长度
2 print(len(tup1))
3 #查询元组元素最大值
4 print(max(tup1))
5 #查询元组元素最小值
6 print(min(tup1))
7 #将列表转化为元组
8 a = [12,13,14,15]
9 a = tuple(a)
10 print(a)
元组不可变是指元组所指向内存中的内容不可变
1 # 2322544450056
2 print(id(tup1))
3 tup1 = ('q','w','e')
4 # 2322547972680
5 print(id(tup1))
Dictionary
字典是可变类型，可存储任意类型的对象，字典使用花括号{}，每个对之间以逗号分割，每个键值对以冒号：分割，键必须是唯一的，不可变的，如字符串、数字、元组，但值可修改。表达方式如下：
A = {key1 : value1, key2 : value2, key3 : value3 }
创建：
1 wu = {'name':'cloud','age':23,'sex':'male'}
2 zhang = {'name':'Fang','age':18,'sex':'female'}
查询：用方括号包括需要查询的键
1 print(wu['name'])
2 print(zhang['age'])
修改：添加新的键/值对，修改已有的键/值对
1 # 添加
2 wu['city'] = 'zhangzhou'
3 # 修改
4 wu['age'] = 24
删除：删除某个元素或字典，也可清空字典，删除之后再次查询会发生异常
1 # 删除单一元素
2 del wu['city']
3 # 清空字典内所有元素
4 wu.clear()
5 # 删除这个字典
6 del wu
内置函数
1 # 查询字典长度
2 len(zhang)
3 # 将字典转化成字符串表示
4 str(zhang)
5 # 查看类型
6 type(zhang)
内置方法
1 # 清空字典内所有元素
2 zhang.clear()
3 # 浅拷贝
4 zhang.copy()
5 # 使用序列的值创建新字典
6 a = ('name','age','sex')
7 b = 1
8 wu = dict.fromkeys(a,b)
9 print(wu)
10 # 返回键对应的值，如果键不存在则返回默认值
11 print(wu.get('name'))
12 print(wu.get('city','xiamen'))
13 # 判断键是否在字典中
14 'city' in wu
15 # 以列表返回一个视图对象
16 wu.items()
17 # 返回一个视图对象
18 wu.keys()
19 # 键存在则返回，不存在在创建，并且添加默认值
20 wu.setdefault('city','zhangzhou')
21 # 将另一个字典的元素更新到本字典
22 wu.update(zhang)
23 # 返回值的视图对象
24 wu.values()
25 # 删除键对应的值并返回，否则返回默认值
26 wu.pop('city',100)
27 # 删除字典最后一组键值对并返回
28 print(wu.popitem())
内置方法
SET
集合是一个无序的并且不重复的序列，使用花括号{ }或者set( )创建，创建空集合时需使用set( )。
创建
1 wu = {'cloud',18,'male'}
2 zhang = set('Fang',18,'fimale')
添加：元素可以是数字，字符串，列表，元组，字典等，添加时如果元素存在则不进行操作
1 # 添加方式一add()
2 wu.add('zhangzhou')
3 # 添加方式二update()
4 wu.update({6,7})
删除
1 # 删除方式一remove(),如果元素不存在，则报错
2 wu.remove({6,7})
3 # 删除方式二discard(),元素不存在不会报错
4 wu.discard(7)
5 # 删除方式三pop(),随即删除某个元素
6 wu.pop()
查看集合长度
1 len(wu)
清空集合
1 wu.clear()
判断元素是否存在
1 'zhangzhou' in wu
内置方法
1 # 添加元素
2 wu.add('red')
3 # 删除所有元素
4 wu.clear()
5 # 拷贝
6 wu.copy()
7 # 返回wu中不存在zhang的差集
8 wu.difference(zhang)
9 # 删除wu中存在zhang的元素
10 wu.difference_update(zhang)
11 # 删除集合中的指定元素，元素不存在不会发生错误
12 wu.discard('red')
13 # 返回多个集合的交集，返回一个新集合
14 wu.intersection(zhang)
15 # 在原集合上返回多个集合的交集
16 wu.intersection_update(zhang)
17 # 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
18 wu.isdisjoint(zhang)
19 # 判断集合是否是另一集合的子集，如果是则返回 True，否则返回 False
20 wu.issubset(zhang)
21 # 判断集合是否是另一集合的父集，如果是则返回 True，否则返回 False
22 wu.issuperset(zhang)
23 # 随机删除某个元素
24 wu.pop()
25 # 删除指定元素
26 wu.remove('red')
27 # 返回一个新集合，包含指定两个集合的差集
28 wu.symmetric_difference(zhang)
29 # 在a集合上删除与b集合的交集，并添加b集合的差集
30 wu.symmetric_difference_update(zhang)
31 # 返回两个集合的并集
32 wu.union(zhang)
33 # 添加新元素
34 wu.update('Feng')
内置方法
运算符
Python提供7种运算符：
- 算术运算符
- 比较（关系）运算符
- 赋值运算符
- 逻辑运算符
- 位运算符
- 成员运算符
- 身份运算符
运算符优先级从高到低：（*）>>>（~、+、-）>>>（、/、%、//）>>>（+、-）>>>（>>、<
算术运算符
1 a = 10
2 b = 2
3 c = 0
4 # 加 +
5 c = a + b
6 # 减 -
7 c = a - b
8 # 乘 *
9 c = a * b
10 # 除 /
11 c = a / b
12 # 取模 %
13 c = a % b
14 # 幂 **
15 c = a ** b
16 # 整除 //
17 c = a // b
算术运算符
比较运算符
1 a = 10 2 b = 2 3 4 # 等于 == 5 if a == b: 6 print('等于 ==') 7 # 不等于 ！= 8 else: 9 print('不等于 ！=') 10 11 # 大于 > 12 if a > b: 13 print('大于 >') 14 # 小于 < 15 else: 16 print('小于 <') 17 18 # 大于等于 >= 19 if a >= b: 20 print('大于等于 >=') 21 # 小于等于 <=<> 22 else: 23 print('小于等于 <=<>')
比较运算符
赋值运算符
1 # 赋值 =
2 a = 10
3 b = 0
4 # 加法赋值 +=
5 b += a
6 # 减法赋值 -=
7 b -= a
8 # 乘法赋值 *=
9 b *= a
10 # 除法赋值 /=
11 b /= a
12 # 取模赋值 %=
13 b %= a
14 # 幂赋值 **=
15 b **= a
16 # 取整除赋值 //=
17 b //= a
18 # 海象运算符 := python3.8版本之后才有
19 if (c := len(a)) > 10:
20 print(c)
赋值运算符
位运算符：把数字转为二进制进行计算
1 a = 10 2 b = 7 3 c = 0 4 # 与运算：相应位都为1，则为1否则为0 & 5 c = a & b 6 # 或运算：相应位有一个1，则为1否则为0 丨 7 c = a | b 8 # 异或运算：相应位不同时为1，不同为0 ^ 9 c = a ^ b 10 # 取反运算：对数据进行按位取反，1变0，0变1 ~ 11 c = ~a 12 # 左移运算：二进制位左移若干位，高位丢弃，低位补零 << 13 c = a << 4 14 # 右移运算：二进制位右移若干位 >> 15 c = a >> 3
位运算符
逻辑运算符
1 a = 0
2 b = 5
3
4 # 布尔与:两个为true输出true，否则为false and
5 if (a and b):
6 print(True)
7 else:
8 print(False)
9 # 布尔或:一个为true输出true，否则为false or
10 if (a or b):
11 print(True)
12 else:
13 print(False)
14 # 布尔非:如果为true输出false,否则为true not
15 if not(a and b):
16 print(False)
17 else:
18 print(True)
逻辑运算符
成员运算符
1 a = [1,2,3,4,5]
2 b = 11
3 c = 2
4
5 # in 如果指定值在序列中返回true,否则返回false
6 if ( c in a ):
7 print(True)
8 else:
9 print(False)
10 # not in 如果指定值不在序列中返回true,否则返回false
11 if ( b not in a ):
12 print(True)
13 else:
14 print(False)
成员运算符
条件控制：
1 name = input('请输入用户名：')
2
3 if name == "wu":
4 print("超级管理员")
5 elif name == "zhang":
6 print("普通管理员")
7 elif name == "cloud":
8 print("业务主管")
9 else:
10 print("普通用户")
循环语句
Python提供了两个循环语句功能for和while
While：如果条件为True,则执行
1 # while
2 sum = 0
3 while sum < 10:
4 print("{}小于10".format(sum))
5 sum += 1
无限循环：表达式永远为True
1 # while
2 sum = 0
3 while sum < 10:
4 print("Hello,Word!!!")
While + else 语句：当条件为false时，执行else语句
1 sum = 0
2 while sum < 10:
3 print("{}小于10".format(sum))
4 sum += 1
5 else:
6 print("{}等于10！".format(sum))
for:通常用于遍历可迭代对象，如列表，字符串等
1 # for
2 wu = ['cloud',23,'male','zhangzhou']
3 for i in wu:
4 print(i)
break：结束循环
1 # break
2 a = 0
3 while a:
4 if a == 5:
5 break
6 a += 1
7 print('{}小于10！'.format(a))
Continue：跳出本次循环
1 # continue
2 a = 0
3 while a :
4 a += 1
5 if a == 5:
6 continue
7 print('当前循环值为{}'.format(a))
迭代器
迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，迭代器只能往前不会后退。一次只取一个元素，同时记录取值位置，下一个元素如果存在，则取出，如果不存在，则报异常 StopIteration。迭代器有两个基本的方法：iter() 和 next()。
1 li = [1,2,3,4,5]
2 # 创建迭代器
3 it = iter(li)
4 # 输出迭代器的下一个元素
5 print (next(it))
6 print (next(it))
生成器
yield 的函数被称为生成器（generator）。生成器只能用于迭代，可以简单理解为生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。对于生成器只有使用时才创建，从而避免内存浪费。
1 # -*- coding:utf-8 -*-
2 # @Author:Wu FengYun
3
4 import sys
5
6
7 # 生成器函数 - 斐波那契
8 def fibonacci(a):
9 b, c, counter = 0, 1, 0
10 while True:
11 if (counter > a):
12 return
13 yield b
14 b, c = c, b + c
15 counter += 1
16
17
18 # f 是一个迭代器，由生成器返回生成
19 f = fibonacci(20)
20 while True:
21 try:
22 print(next(f), end=" ")
23 except StopIteration:
24 sys.exit()
生成器
Original: https://www.cnblogs.com/wufengyun/p/15410254.html
Author: wufengyun
Title: python基础篇(一)
相关阅读
Title: 如何用Python将普通视频变成动漫视频
最近几个月，毒教材被曝光引发争议，那些编写度教材的人着实可恶。咱程序员也没有手绘插画能力，但咱可以借助强大的深度学习模型将视频转动漫。所以今天的目标是让任何具有python语言基本能力的程序员，实现短视频转动漫效果。
效果展示
; 一、思路流程
- 读取视频帧
- 将每一帧图像转为动漫帧
- 将转换后的动漫帧转为视频
难点在于如何将图像转为动漫效果。这里我们使用基于深度学习的动漫效果转换模型，考虑到许多读者对这块不了解，因此我这边准备好了源码和模型，直接调用即可。不想看文章细节的可以直接拖到文章末尾，获取源码。
二、图像转动漫
为了让大家不关心深度学习模型，已经为大家准备好了转换后的onnx类型模型。接下来按顺序介绍运行onnx模型流程。
安装onnxruntime库
pip install onnxruntime
# 源码及Python资料教程、电子书领取群 279199867
如果想要用GPU加速，可以安装GPU版本的onnxruntime:
pip install onnxruntime-gpu
需要注意的是：
onnxruntime-gpu的版本跟CUDA有关联，具体对应关系如下：
当然，如果用CPU运行，那就不需要考虑那么多了。考虑到通用性，本文全部以CPU版本onnxruntime。
运行模型
先导入onnxruntime库，创建InferenceSession对象，调用run函数。
如下所示
import onnxruntime as rt
sess = rt.InferenceSession(MODEL_PATH)
inp_name = sess.get_inputs()[0].name
out = sess.run(None, {inp_name: inp_image})
具体到我们这里的动漫效果，实现细节如下：
import cv2
import numpy as np
import onnxruntime as rt
# MODEL = "models/anime_1.onnx"
MODEL = "models/anime_2.onnx"
sess = rt.InferenceSession(MODEL)
inp_name = sess.get_inputs()[0].name
def infer(rgb):
rgb = np.expand_dims(rgb, 0)
rgb = rgb * 2.0 / 255.0 - 1
rgb = rgb.astype(np.float32)
out = sess.run(None, {inp_name: rgb})
out = out[0][0]
out = (out+1)/2*255
out = np.clip(out, 0, 255).astype(np.uint8)
return out
def preprocess(rgb):
pad_w = 0
pad_h = 0
h,w,__ = rgb.shape
N = 2**3
if h%N!=0:
pad_h=(h//N+1)*N-h
if w%2!=0:
pad_w=(w//N+1)*N-w
# print(pad_w, pad_h, w, h)
rgb = np.pad(rgb, ((0,pad_h),(0, pad_w),(0,0)), "reflect")
return rgb, pad_w, pad_h
其中, preprocess函数确保输入图像的宽高是8的整数倍。这里主要是因为考虑到深度学习模型有下采样，确保每次下采样能被2整除。
单帧效果展示
三、视频帧读取与视频帧写入
这里使用Opencv库，提取视频中每一帧并调用回调函数将视频帧回传。在将图片转视频过程中，通过定义VideoWriter类型变量WRITE确保唯一性。具体实现代码如下：
import cv2
from tqdm import tqdm
WRITER = None
def write_frame(frame, out_path, fps=30):
global WRITER
if WRITER is None:
size = frame.shape[0:2][::-1]
WRITER = cv2.VideoWriter(
out_path,
cv2.VideoWriter_fourcc(*'mp4v'), # 编码器
fps,
size)
WRITER.write(frame)
def extract_frames(video_path, callback):
video = cv2.VideoCapture(video_path)
num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
for _ in tqdm(range(num_frames)):
_, frame = video.read()
if frame is not None:
callback(frame)
else:
break
完整源码获取点击 蓝色字体 获取哟~
给大家推荐一套爬虫教程，涵盖常见大部分案例，非常实用！
代码总是学完就忘记？100个爬虫实战项目！让你沉迷学习丨学以致用丨下一个Python大神就是你！
Original: https://www.cnblogs.com/hahaa/p/16583200.html
Author: 轻松学Python
Title: 如何用Python将普通视频变成动漫视频