AI学习_线程_python爬虫_numpy

线程：

#线程同步（线程安全）
#同步:效率低，安全度高
#异步:效率高，安全度低
#在绝大部分代码中，都是线程异步，因为效率最高
#只有极少部分，在对安全性要求高的，才是线程同步

matplotlib：画图模组

数据可视化的模组，可以画柱状、折线、圆饼、散点图

爬虫

核心内容：
①用伪装器header 连接上待爬取网页
②用正则表达式提取出网页源文件的指定内容
③获取open()、xlwt模组等保存读取的内容

下为爬取PRTS中时装回廊的案例

import requests  # 爬虫模组
import re  # 正则表达式模组
import xlwt
import xlsxwriter


def get_page(target_url):
    # 伪装器header
    header = {
        'Accept-Language': 'zh-CN,zh;q=0.8,zh-TW;q=0.7, zh-HK;q=0.5,en-US;q=0.3,en;q=0.2',
        'Connection': 'keep-alive',
        'User-Agent': 'Mozilla/5.0(X11; Linux x86_64;rv:60.0) Gecko/20100101 Firefox/60.0',
        "Upgrade-Insecure-Requests": '1'
    }
    response = requests.get(target_url, headers=header)
    if response.status_code == 200:
        return response  # 返回请求本身
    else:
        return "请求错误"


def get_not_br_skin_list(page_content):
    # 找到时装列表到最后一个空“罗比菈塔”之前的所有内容
    skin_list_start = re.compile(r'<h2>(.*)<div id="MenuSidebar"', re.S)
    # 并去掉换行
    return str(re.findall(skin_list_start, page_content.text)[0]).replace("&nbsp;", "") \
        .replace("...<br>", "") \
        .replace("  ", "") \
        .replace("\n", "")  # replace替换指定字符)


def get_table_list(text_content, temp_list, page_object):
    reSkinName = r'<span class="mw-headline" id=".*?">(.*?)</span>'
    reWhoSkinText = r'<p style="margin:5px; margin-bottom:10px;">(.*?)</p>.*?</p>.*?<th width="20%">'
    reSkinText = r'<p style="margin:5px;"><i>(.*?)</i></p></td></tr>.*?<th width="20%">'
    reSkinMaker = r'<th width="90px">画师</th><td width="105px">(.*?)</td><th width="90px">'
    reSkinGet = r'获得途径</th><td width="105px">(.*?)</td>'

    reSkinSeries = r'<td width="30%">.*?</td></tr><tr><th>所属时装组</th><td colspan="3">(.*?)</td>'
    reSkinLongText = r'时装描述.*?"text-align:left;"><p>(.*?)</p>'
    reSkinImgUrl = r'<td colspan="4">.*?width="400" height="400" data-src="/images/thumb/(.*?)/400px'

    temp_list.append(re.findall(reSkinName, text_content))  # 皮肤名
    temp_list.append(re.findall(reWhoSkinText, text_content))  # 皮肤持有者
    temp_list.append(re.findall(reSkinText, text_content))  # 皮肤短介绍
    temp_list.append(re.findall(reSkinMaker, text_content))  # 画师
    get_list = re.findall(reSkinGet, text_content)  # 获得方式
    for item in range(len(get_list)):
        if get_list[item][:2] == "<a":
            get_list[item] = re.findall('<a .*?>(.*?)</a>', get_list[item])[0]
    temp_list.append(get_list)
    temp_list.append(re.findall(reSkinSeries, text_content))  # 皮肤系列
    temp_list.append(re.findall(reSkinLongText, text_content))  # 皮肤长介绍
    temp_url = re.findall(reSkinImgUrl, text_content)  # 皮肤预览地址列表
    for i in range(len(temp_url)):
        temp_url[i] = "https://prts.wiki/images/" + temp_url[i]

    name_number = 0  # 图片文件名
    # for item in temp_url:
    #     # 用.content获取图片地址的二进制文件流
    #     img_content = get_page(item).content
    #     # 写入指定位置
    #     with open("img/" + str(name_number) + ".png", "wb") as f:
    #         f.write(img_content)
    #         name_number += 1

    temp_list.append(temp_url)


def write_excel(dataList, sheet, first_col, text):
    if first_col[0] == 0:
        col = ("皮肤名", "皮肤持有者", "皮肤简短介绍", "画师", "获得方式", "皮肤系列", "皮肤完整介绍", "皮肤预览")
        for flag in range(0, len(col)):
            sheet.write(0, flag, col[flag])
    else:
        first_col[0] += 1
        sheet.write(first_col[0], 0, skin_series)  # 切换实装系列时加上<系列名>

    flag_2 = 0
    for a in range(0, len(dataList)):
        for j in range(0, len(dataList[a])):
            if a == 0: flag_2 += 1
            print(first_col[0])

            sheet.write(first_col[0] + j + 1, a, dataList[a][j])
            # if dataList[a][j][0:5] == "https":
            #     print("F" + str(j))
            #     sheet_new.insert_image("F" + str(j + 2), "img/" + "%s" % j + ".png")
            # else:
            #     sheet.write(j + 1, a, dataList[a][j])

    first_col[0] += flag_2
    book.save('明日方舟_皮肤一览.xls')
    # book_new.close()


if __name__ == '__main__':
    data_list = []
    all_skin_list = ["忒斯特收藏", "时代", "0011™制造", "0011-飙系列",
                     "珊瑚海岸", "玛尔特", "巫异盛宴", "寒武纪™系列",
                     "冰原信使", "生命之地", "雷神开拓者", "雷神推进者",
                     "斗争血脉", "罗德厨房", "缠梦古堡", "啸风", "音律联觉",
                     "合作款", "闪耀阶梯", "成就之星"]
    img_number = 0
    lost_col = [0]

    book = xlwt.Workbook(encoding="utf-8", style_compression=0)
    # book_new = xlsxwriter.Workbook("明日方舟_时装回廊_珊瑚海岸.xlsx")
    operation_sheet = book.add_sheet("明日方舟_时装回廊_珊瑚海岸", cell_overwrite_ok=True)
    # sheet_new = book_new.add_worksheet("明日方舟时装回廊珊瑚海岸")

    for skin_series in all_skin_list:
        page_object = get_page("https://prts.wiki/w/时装回廊/" + skin_series)  # 获取页面response
        print("https://prts.wiki/w/时装回廊/" + skin_series)
        page_str = get_not_br_skin_list(page_object)  # 获取无换行网页文本
        get_table_list(page_str, data_list, page_object)  # 将文本拆分为列表项
        write_excel(data_list, operation_sheet, lost_col, skin_series)
        data_list = []
    # print(data_list)

numpy

基于C实现的数学模组
主要使用数组功能
可以使用更多的数据类型来当做元素
还可以实现复杂的矩阵功能

详细内容请复习代码

import numpy as np

# 使用基于c实现的数学模组——numpy
# 使用array方法创建一个numpy数组
# numpy的元素长度固定，且只能存放同种类型的元素
# numpy可以使用更多数据类型当做元素，如无符号数字uint8、64位长整形int64等
# array常用属性：object数组、ndmin数组维度、dtype元素的数据类型

print("#创建数组练习↓")

print(np.array([1, 2, 3]))
print(np.array([[1, 2], [3, 4]]))
print(np.array([1, 2, 3, 4, 5], ndmin=5))  # ndmin:维度数
print(np.array([1, 2, 3], dtype=str))  # dtype:元素的数据类型

# .dtype属性有多种含义：①元素的数据类型 ②元素的储存长度(int8/int64) ③数据的字节顺序
# 字节顺序有 小端法<（默认）[最小值存在最小地址]、大端法>[最大值存在最小地址]两种方式

# .dtype支持“别名”，如
# int8,int16,int32,int64
# 'i1','i2','i4','i8'来代替

print("#dtpye别名使用↓")
dt = np.dtype(np.int64)
print(dt)
dt = np.dtype('i8')
print(dt)
dt = np.dtype('i4')
print(dt)
dt = np.dtype('i2')
print(dt)
dt = np.dtype('i1')
print(dt)

print("#dtpye，自定义数据类型（结构化数据类型）不常用↓")
dt = np.dtype([('age', np.int32)])  # 自定义一个名为dt的数据类型，注意dtype的自定义格式
a = np.array([(18,), (19,), (20,)], dtype=dt)
print(a)
print(a['age'])  # 输出a中属性为age的元素

# 注意，虽然字符串类型的数字可以被隐式转换为int数字
# 但纯写字符还是转换不了的
# a = np.array([('abc',),(123)],dtype=dt) # 无法转换‘abc’
b = np.array([123, 123], dtype=dt)  # 注意此处的写法与输出格式的不同
print(b)  # 输出格式：[(123,) (123,)]

print("#dtpye，自定义类型person，包含name、age、height↓")
person = np.dtype([('name', "S10"), ('age', np.int8), ('height', np.int8)])
# 注意：在dtype中定义字符串类型时，要使用如“S10”、“S60”等s+字符串长度的别名

person_list1 = np.array([('tom', 16, 172)], dtype=person)
person_list2 = np.array([('jerry', 20, 140), ('gogy', 23, 180)], dtype=person)
print(person_list1)
print(person_list2)  # [(b'jerry', 20, -116) (b'gogy', 23,  -76)] 注意输出中，字符串前的b

print("#numpy数组属性↓")
a = np.array([(1, 2, 3), (4, 5, 6)])
print(a.ndim)  # 维度，也叫秩
print(a.shape)  # 形状，几*几，当前2*3(2, 3)
print(a.size)  # 元素个数
print(a.dtype)  # 元素数据类型
print(a.itemsize)  # 单个元素长度
print(a.flags)  # 数组详细信息
print(a.real)  # 数组实部
print(a.imag)  # 虚部

print("#shape调整数组大小，注意最终size(元素个数必须一致)")

a = np.array([(1, 2, 3), [4, 5, 6]])
print(a.shape)
# shape调整数组大小，注意最终size(元素个数必须一致)
a.shape = (3, 2)
print(a.shape)
print(a)

print("#创建数组的几种方式（不同的初始值）")
a = np.empty([3, 3], dtype=int)
print(a)  # empty:默认值为整形的随机数（不定义属性则为浮点型随机数）
b = np.zeros(5)
print(b)  # zeros:为浮点的0
b1 = np.zeros((2, 3), dtype=int)
print(b1)  # 也可以更改维度和默认类型
c = np.ones(5)
print(c)  # ones:为浮点的1
d = np.arange(10, 20, 2)  # 以起始值、结束值、步长：来生成一维数组
print(d)

print("#切片和索引")
a = np.arange(1, 20, 2)
print(a)
b1 = a[5:9:2]  # 常规切片
b2 = a[..., :9:2]  # ...,代表起始位置
b3 = slice(5, 9, 2)  # 返回一个“切片对象”，可以用来切不同的数组
print(b1)
print(b2)
print(a[b3])

print("#高级索引")

x = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
# 下即为“高级索引”，行数即为待索引数组的“维度数”
y = x[[1, 2, 0],  # 从1，从2，从0
      [0, 2, 2]]  # 到0，到2，到2
print(y)
# 最终抓取到x中的x[1][0]、x[2][2]、x[0][2]

print("#高级索引应用实例：寻找二维数组的四个角")
# c = np.array([[1, 2, 3, 4, 5],
#               [6, 7, 8, 9, 10],
#               [11, 12, 13, 14, 15],
#               [16, 17, 18, 19, 20]])
c = np.arange(1, 21)  # 也可以使用arange生成
c.shape = (4, 5)
rows = np.array([[0], [0], [3], [3]])
cols = np.array([[0], [4], [0], [4]])
y = c[rows, cols]
print('4 * 5的四个角是')
print(y)

print("#广播，不同大小的数组运算时，对小数组进行的'自动复制操作'↓")
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 4, 3, 4, 5])
z = x * y
print(z)
# 当两个数组'只有一个维度不一致'时，自动触发广播
a = np.array([[0, 0, 0],
              [10, 10, 10],
              [20, 20, 20],
              [30, 30, 30]])
b = np.array([[1, 1, 1]])  # 被广播的数组扩大至4*3
print(a + b)

print("#numpy迭代↓")
# 迭代器对象numpy.nditer
a = np.arange(9).reshape(3, 3)  # 使用reshape快速定义形状
print(a)
# nditer默认是行序优先，使用order="F"转置
for x in np.nditer(a):
    print(x, end="")

print("#numpy广播+迭代↓")
x = np.arange(1, 10).reshape(3, 3)  # 生成3*3数组
print(x)
y = np.array([1, 2, 3], dtype=int)  # 生成1*3数组
print(y)
for x, y in np.nditer([x, y]):
    print("%d-%d " % (x, y), end=",")

print("#numpy小测试↓")
s = np.ones([2, 4])
print(s.dtype)  # 什么类型
print(np.arange(10, 5, -1))  # 打印一个从10到6的一位数组
a = np.array(['100', '2200'], dtype=np.string_)
print(a.dtype)  # 打印结果为S4,四位字符串
a = np.array([1, 2, 3, 4])
print(a * 2)  # 标量计算，全体*2
print(a > 2)  # 逻辑运算，输出“哪些值小于二”[False False  True  True]
b = np.array([2, 4, 6, 8])
print(a * b)
print(a > b)  # 数组间的逻辑计算

a = np.array([[1, 3],
              [5, 7],
              [9, 11]])
print(a[2, 1])  # 新的索引操作，使用","关键字，降低了一个维度
print(a[1, 1])
a = np.array([
    [[1, 2], [3, 4]],
    [[5, 6], [7, 8]]
])
print(a)
print(a[1, 0])  # 打印结果[5 6]，
a = np.array([1, 3, 5, 7, 9, 11])
b = a[0:4]  # 旧切片，拿出a中0-3的部分
b[0] = 100
print(a)

print("#numpy的特殊切片，以及使用”,“来降维↓")
a = np.array([[1, 2],
              [3, 4],
              [5, 6]])
print(a[:2][:1])
# 分2步看，
# 先提取0-2的部分
# 再提取“0-2的部分”里0-1的部分


print(a[:2, :1])
# 分2步看
# ②提取出第一维度0-2的部分
# ③提取出“0-2的部分”中，下一维度的0-1的部分
# 得到[ [1,],
#       [3,] ]

print("#布尔和整数数组索引↓")
a = np.array([1, 2, 3, 4, 5, 6])
b = np.array([True, False, True, False, True, False])
print(a[b])  # 只提取True的部分
a = np.array([1, 2, 3, 4, 5, 6])
b = a[[0, 2, 1]]
print(b)  # 提取出对应下标的部分

print("#reshape修改数组形状↓")
x = np.arange(1, 11)
print(x)
y = x.reshape(2, 5)
print(y)  # 注意：前后元素的总长度(size)必须不变

print("#transpose翻转数组↓")
x = np.arange(9).reshape(3, 3)
print(x)  # 翻转前
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]
print(np.transpose(x))  # 翻转后
# [[0 3 6]
#  [1 4 7]
#  [2 5 8]]

print("#broadcast(广播的基础方法)修改数组维度↓")
x = np.array([
    [1],
    [2],
    [3]
])
y = np.array([4,
              5,
              6])
# 对y广播x
r, c = np.broadcast(x, y).iters
for i in range(9):
    print(next(r), next(c))  # 会返回迭代器的下一个元素

print("#concatenate连接数组↓")
x = np.array([[1, 2], [3, 4]])
print(x)
y = np.array([[5, 6], [7, 8]])
print(y)
# axis=0、0轴连接
print(np.concatenate((x, y), axis=0))  # 从0轴——二维中是竖轴——连接
# axis=1、1轴连接
print(np.concatenate((x, y), axis=1))  # 从1轴——二维中是横轴——连接

print("#split连接数组↓")
x = np.arange(1, 10)
print(x)
y = np.split(x, 3)  # 切割参数1的内容，每隔参数2就切割一次
print(y)

print("#apped添加数组元素↓")
x = np.array([[1, 2, 3],
              [4, 5, 6]])
print(x)
print(np.append(x, [7, 8, 9]))
print('轴0添加：')
print(np.append(x, [[7, 8, 9]], axis=0))
print(np.append(x, [[7, 8, 9], [10, 11, 12]], axis=1))
# 注意：append向轴1以上添加数据时，必须根据轴0的数据长度来写数据

print("#delete删除元素↓")
a = np.arange(12).reshape(3, 4)
print(a)
print(np.delete(a, 5))  # 有返回值，返回删除指定位置后的数组
# 删掉一个值后，无法维持3*4，会变回一位数组
print(np.delete(a, 1, axis=1))  # 删除第二列
print(np.delete(a, 1, axis=0))  # 删除第二行

a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(np.delete(a, np.s_[::2]))  # 使用np.s_[::2]找出所有单数

print("#astype复制数组(深拷贝)，转换类型↓")
a = np.array([1, 2, 3, 4, 5], dtype=np.int8)
# a复制为b，类型修改为float16
b = a.astype(dtype=np.float16)  # astype复制数组，还可以在复制时改变数组类型
print(b)
print(d.dtype)

print("#转置↓")
a = np.arange(6).reshape(2, 3)
print(a)
print(a.T)  # 使用关键字T即可转置

print("#(高维数组)轴操作↓")
# 初始轴顺序为(0,1,2)
a = np.arange(24).reshape(2, 3, 4)
print(a)
print(a.shape)
# 轴变换，将轴位置打乱为新位置
a = a.transpose(2, 1, 0)
print(a)
print(a.shape)

print("#dot数组内积和↓")
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])
print(np.dot(a, b))  # 内积和：同下标的数字一一相乘，最后再相加

print("#统计函数amin()与amax()")
# amin()/amax()用于计算数组中的元素沿着指定轴的最小/最大值
a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
print(np.amin(a))  # 找所有的值中最小的
print(np.amin(a, axis=0))  # 找0轴上最小的
print(np.amin(a, axis=1))  # 找1轴上最小的

print(np.amax(a))  # 找所有的值中最大的
print(np.amax(a, axis=0))
print(np.amax(a, axis=1))

print("#统计函数ptp")
# 计算数组中元素最大值最小值的差
a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
print(np.ptp(a))
print(np.ptp(a, axis=0))  # 算0轴上极差
print(np.ptp(a, axis=1))  # 算1轴上极差

print("#算数函数，加减乘除")
a = np.arange(9, dtype=np.int8).reshape(3, 3)
b = np.array([10, 10, 10])
print(np.add(a, b))  # 加
print(np.subtract(a, b))  # 减
print(np.multiply(a, b))  # 乘
print(np.divide(a, b))  # 除

print("#条件筛选函数")
x = np.arange(2, 16)
y = np.where(x > 3)
print(x)
print(y)  # 输出结果：
# (array([ 2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13],
#         dtype=int64),)
# 注意，where输出结果是"值"，而不是索引
print(x[y])

print("#排序函数")
a = np.array([[2, 4], [3, 1]])
print(np.sort(a))  # 只能排序同一行

print("#字符串函数")
print(np.char.add(['hello'], [' xyz']))             # 拼接
print(np.char.multiply('hello', 3))                 # 重复
print(np.char.center('abc', 20, fillchar='*'))      # 居中，使用 20 个 * 使内容居中
print(np.char.capitalize("abcdef"))                 # 全大写
print(np.char.title('i like python'))               # 标题化，也就是首字母大写
print(np.char.split('www.ai.com', sep='.'))         # 分割字符串
print(np.char.join(['*', '='], ['microsoft', 'huawei']))    # 插入字符串，隔一个字符就插入一个
print(np.char.replace('你是日本人', '日本人', '***'))  # 替换(原字符，去掉的字符，替换上的字符)