import jieba
import jieba.analyse

jieba.analyse.textrank(sentence, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v'))

[('科技', 1.0), ('创新', 0.6818768373499384), ('研究', 0.39785607069634815), ('科学家', 0.39327521713414126), ...]

import string
import jieba.analyse
import wordcloud
from wordcloud import WordCloud
import matplotlib.pyplot as plt


def read_file(file):
    """接收文件名为参数，将文件中的内容读为字符串，只保留文件中的英文字母和西文符号，过滤掉中
    文，所有字符转为小写，将其中所有标点、符号替换为空格，返回字符串。"""
    # =======================================================
    # 此处去掉注释符号“#”并补充你的代码
    with open('Who Moved My Cheese.txt','r') as f:
        str=''.join(i for i in f.read() if ord(i) < 256)
        for i in str:
            if i in string.punctuation:
                str=str.replace(i,'')
            elif i=='\n':
                str=str.replace('\n',' ')
        return str.lower()
    # =======================================================


def word_frequency(txt):
    """
    @参数 txt：去除标点、符号的文本，字符串
    接收去除标点、符号的字符串，统计并返回每个单词出现的次数。返回值为字典类型，单词为键，对
    应出现的次数为值。"""
    # =======================================================
    # 此处去掉注释符号“#”并补充你的代码
    dic={}
    for i in txt.split():
        dic[i]=dic.get(i,0)+1
    return dic
    # =======================================================


def draw_cloud_en_freq(en_frequency):
    """
    @参数 en_frequency：词频，字典类型
    绘制词云，传入参数为词频，设定图片的宽度600，高度400，背景白色、字体最大值150、
    图片边缘为5。
    """
    # =======================================================
    # 此处去掉注释符号“#”并补充你的代码
    wc=wordcloud.WordCloud(width=600,height=400,max_font_size=150,margin=5,background_color='white')
    wc.generate_from_frequencies(en_frequency)
    wc.to_file('en_freq.png')
    # =======================================================


def draw_cloud_en_txt(text):
    """
    @参数 text：读文件获取的文本，字符串
    绘制词云，传入参数为文本(字符串)，设定图片的宽度600，高度400，背景白色、字体最大值150、
    图片边缘为5。"""
    # =======================================================
    # 此处去掉注释符号“#”并补充你的代码
    wc = wordcloud.WordCloud(width=600, height=400, max_font_size=150, margin=5, background_color='white')
    wc.generate(text)
    wc.to_file('en_txt.png')
    # =======================================================


def read_file_cn(file):
    """接收文件名为参数，将文件中的内容读为字符串"""
    # =======================================================
    # 此处去掉注释符号“#”并补充你的代码
    with open('scientist.txt','r',encoding='utf-8') as f:
        return f.read()
    # =======================================================


def word_frequency_cn(txt):
    """
    @参数 txt：读文件获取的文本，字符串
    传入参数为读文件获取的文本字符串。jieba.analyse.textrank()可用参数topK设置最多返回多少个按
    词频降序排列的关键词列表，数据格式为列表：[('人民', 1.0), ('中国', 0.9533997295396189), ...]
    将列表转为字典:{'人民': 1.0, '中国': 0.9533997295396189,...}，返回这个字典,字典的键是关键词，
    值是关键词的权值。"""
    # =======================================================
    # 此处去掉注释符号“#”并补充你的代码
    dic={}
    for k, v in jieba.analyse.textrank(txt, topK=60, withWeight=True, allowPOS=('ns', 'n', 'vn', 'n')):
        dic[k]=v
    return dic
    # =======================================================


def draw_cloud_cn(frequency_dict):
    """
    @参数 frequency_dict：词频，字典类型
    接收词频字典为参数，用'ball.jpg'做词云背景。利用matplotlib中的imread('ball.jpg')从图像文件读
    入数据,得到一个表示图像的NumPy数组。"""
    # =======================================================
    # 此处去掉注释符号“#”并补充你的代码
    im=plt.imread('ball.jpg')
    wc = wordcloud.WordCloud(mask=im,font_path='msyh.ttc',background_color='white')
    wc.generate_from_frequencies(frequency_dict)
    wc.to_file('cn.png')
    # =======================================================


if __name__ == '__main__':
    filename = 'Who Moved My Cheese.txt'  # 英文文件名
    filename_cn = 'data/scientist.txt'      # 用于生成词云的中文文件名
    content = read_file(filename)              # 调用函数返回字典类型的数据
    frequency_result = word_frequency(content)
    draw_cloud_en_freq(frequency_result)
    draw_cloud_en_txt(content)
    content_cn = read_file_cn(filename_cn)
    frequency = word_frequency_cn(content_cn)  # 利用jieba对文本进行分词，并统计词频
    draw_cloud_cn(frequency)                   # 绘制词云

import os
import numpy as np


# 设置常量，对应各列数据的语义，方便索引
HIGH = 0
LOW = 1
OPEN = 2
CLOSE = 3
VOLUME = 4
ADJCLOSE = 5

# def file_list(file):
#     """
#     @参数 file: 文件名，字符串类型
#     将文件中的股票代码与股票名称读入到字典中，返回股票代码字典。
#     ['600000', '600004', '600006', '600007', '600008', '600009',...]
#     """
# 下面代码区域随便放pass或一个没有语法错误的语句就可以，只占位置，不起作用
# 点击在此输入代码

def statistics_of_all(code_list):
    """
    @参数 code_list：股票代码列表，列表类型
    接收股票数据文件名列表，逐个统计各股票数据文件涨跌幅、总成交量、最高价和最低价。
    涨跌幅计算公式为：(最新记录收盘价-最早记录收盘价) / 最早记录收盘价 * 100
    为方便处理，读入数据时，略过日期列。
    """
    statistics_of_stock = []
    for code in code_list:
        data_of_code = np.genfromtxt(code, dtype=None,
                                     usecols=[1, 2, 3, 4, 5, 6], delimiter=',',
                                     skip_header=1)
        # 计算当前股票涨跌幅、总成交量、最高价和最低价
        uplift_or_fall = round((data_of_code[:, CLOSE][-1] - data_of_code[:, CLOSE][0]) / data_of_code[:, CLOSE][0] * 100, 2)
        volumes = round(sum(data_of_code[:, VOLUME]), 2)
        high = round(max(data_of_code[:, HIGH]), 2)
        low = round(min(data_of_code[:, LOW]), 2)
        statistics_of_stock.append([code[:6], uplift_or_fall, volumes, high, low])
    return statistics_of_stock  # 每支股票涨跌幅、总成交量、最高价和最低价


def top_10_uplift(statistics_of_stock):
    """
    @参数 statistics_of_stock：每支股票涨跌幅、总成交量、最高价和最低价统计信息，列表类型
    按涨幅降序排序，涨幅相同时按股票代码降序排序，取排名前10的股票，
    返回排名前10的股票代码，返回值为列表类型。
    """
    sort_by_uplift = sorted(statistics_of_stock, key=lambda x: (x[1], x[0]), reverse=True)[:10]
    top_uplift = [x[0] for x in sort_by_uplift]
    print(top_uplift)
    return top_uplift


def top_10_fall(statistics_of_stock):
    """
    @参数 statistics_of_stock：每支股票涨跌幅、总成交量、最高价和最低价统计信息，列表类型
    按跌幅升序排序，跌幅相同时，按股票代码升序排序，取排名前10的股票，返回跌幅最大的10支股
    票代码的集合。
    """
    sort_by_fall = sorted(statistics_of_stock, key=lambda x: (x[1], x[0]))[:10]
    top_fall = [x[0] for x in sort_by_fall]
    return top_fall


def top_10_volumes(statistics_of_stock):
    """
    @参数 statistics_of_stock：每支股票涨跌幅、总成交量、最高价和最低价统计信息，列表类型
    按成交量降序排序，成交量相同时，按股票代码降序排序，取成交量前10的股票代码，返回成交量
    最大的10支股票代码列表。
    """
    sort_by_volumes = sorted(statistics_of_stock, key=lambda x: (x[2], x[0]),reverse=True)[:10]
    top_volumes = [x[0] for x in sort_by_volumes]
    return top_volumes

def top_10_high(statistics_of_stock):
    """
    @参数 statistics_of_stock：每支股票涨跌幅、总成交量、最高价和最低价统计信息，列表类型
    按最高价降序排序，最高价相同时，按股票代码降序排序返回，取排名前10的股票，返回最高价最
    高的10支股票代码的列表。
    """
    sort_by_high = sorted(statistics_of_stock, key=lambda x: (x[3], x[0]),reverse=True)[:10]
    top_high = [x[0] for x in sort_by_high]
    return top_high

def top_10_low(statistics_of_stock):
    """
    @参数 statistics_of_stock：每支股票涨跌幅、总成交量、最高价和最低价统计信息，列表类型
    按最低价升序排序，最低价相同时，按股票代码升序排序，取排名前10的股票，返回最低价最低的
    10支股票代码集合。
    """
    sort_by_low = sorted(statistics_of_stock, key=lambda x: (x[4], x[0]))[:10]
    top_low = [x[0] for x in sort_by_low]
    return top_low


def uplift_and_volumes(top_uplift, top_volumes):
    """
    @参数 top_high，最高价在前10名的股票代码，字符串
    @参数 top_volumes，成交量在前10名的股票代码，字符串
    返回一个列表，其元素依序为以下4个：
    涨幅和成交量均在前10名的股票，按股票代码升序，列表
    涨幅或成交量在前10名的股票,按股票代码升序，列表
    涨幅前10名，但成交量未进前10名的股票,按股票代码升序，列表
    涨幅和成交量不同时在前10名的股票,按股票代码升序，列表
    """
    both_of = sorted(set(top_uplift) & set(top_volumes))
    any_of = sorted(set(top_uplift) | set(top_volumes))
    uplift_no_volumes = sorted(set(top_uplift) - set(top_volumes))
    uplift_or_volumes = sorted(set(top_uplift) ^ set(top_volumes))
    # print(both_of,any_of,uplift_no_volumes,uplift_or_volumes)
    return [both_of,any_of,uplift_no_volumes,uplift_or_volumes]


def high_and_uplift(top_uplift, top_high):
    """
    @参数 top_high，最高价在前10名的股票代码，字符串
    @参数 top_uplift，涨幅在前10名的股票代码，字符串
    返回一个列表，其元素依序为以下4个：
    涨幅和最高价均在前10名的股票代码,按股票代码升序，列表
    涨幅或最高价在前10名的股票代码,按股票代码升序，列表
    涨幅前10名，但最高价未进前10名的股票代码,按股票代码升序，列表
    涨幅和最高价不同时在前10名的股票,按股票代码升序，列表
    票代码。
    """
    both_of = sorted(set(top_uplift) & set(top_high))
    any_of = sorted(set(top_uplift) | set(top_high))
    uplift_no_high= sorted(set(top_uplift) - set(top_high))
    uplift_or_high = sorted(set(top_uplift) ^ set(top_high))
    return [both_of, any_of, uplift_no_high, uplift_or_high]

def low_and_fall(top_fall, top_low):
    """
    @参数 top_low，最低价在前10名的股票代码，字符串
    @参数 top_fall，跌幅在前10名的股票代码，字符串
    返回一个列表，其元素依序为以下4个
    跌幅和最低价均在前10名的股票代码,按股票代码升序，列表
    跌幅或最低价在前10名的股票代码,按股票代码升序，列表
    跌幅前10名，但最低价未进前10名的股票代码,按股票代码升序，列表
    跌幅和最低价不同时在前10名的股票,按股票代码升序，列表
    """
    both_of = sorted(set(top_fall) & set(top_low))
    any_of = sorted(set(top_fall) | set(top_low))
    fall_no_low = sorted(set(top_fall) - set(top_low))
    fall_or_low = sorted(set(top_fall) ^ set(top_low))
    return [both_of, any_of, fall_no_low, fall_or_low]

def operation():
    """接收一个字符串为参数，根据参数值调用不同函数完成任务"""
    statistics_of_list = statistics_of_all(stock_lst)  # 对获取的股票数据进行统计
    uplift_set = top_10_uplift(statistics_of_list)     # 涨幅前10名集合
    fall_set = top_10_fall(statistics_of_list)         # 跌幅前10名集合
    volumes_set = top_10_volumes(statistics_of_list)   # 成交量前10名集合
    high_set = top_10_high(statistics_of_list)         # 最高价前10名集合
    low_set = top_10_low(statistics_of_list)           # 最低价前10名集合

    opt = input()
    if opt == '涨幅与成交量':       # 输出抽中的单词
        u_and_v = uplift_and_volumes(uplift_set, volumes_set)
        print('涨幅和成交量均在前10名的股票:')
        print(u_and_v[0])  # 涨幅和成交量均在前10名的股票
        print('涨幅或成交量在前10名的股票:')
        print(u_and_v[1])  # 涨幅或成交量在前10名的股票
        print('涨幅前10名，但成交量未进前10名的股票:')
        print(u_and_v[2])  # 涨幅前10名，但成交量未进前10名的股票
        print('涨幅和成交量不同时在前10名的股票:')
        print(u_and_v[3])  # 涨幅和成交量均在前10名的股票
    elif opt == '涨幅与最高价':
        h_and_u=high_and_uplift(uplift_set,high_set)
        print('涨幅和最高价均在前10名的股票:')
        print(h_and_u[0])  # 涨幅和成交量均在前10名的股票
        print('涨幅或最高价在前10名的股票:')
        print(h_and_u[1])  # 涨幅或成交量在前10名的股票
        print('涨幅前10名，但最高价未进前10名的股票:')
        print(h_and_u[2])  # 涨幅前10名，但成交量未进前10名的股票
        print('涨幅和最高价不同时在前10名的股票:')
        print(h_and_u[3])  # 涨幅和成交量均在前10名的股票
    elif opt == '跌幅与最低价':
        l_and_f=low_and_fall(fall_set,low_set)
        print('跌幅和最低价均在前10名的股票:')
        print(l_and_f[0])  # 涨幅和成交量均在前10名的股票
        print('跌幅或最低价在前10名的股票:')
        print(l_and_f[1])  # 涨幅或成交量在前10名的股票
        print('跌幅前10名，但最低价未进前10名的股票:')
        print(l_and_f[2])  # 涨幅前10名，但成交量未进前10名的股票
        print('跌幅和最低价不同时在前10名的股票:')
        print(l_and_f[3])  # 涨幅和成交量均在前10名的股票
    else:
        print('输入错误')


if __name__ == '__main__':
    # filename = './data/沪市股票top300.csv'              # 股票名称与代码文件
    stock_lst = ['600000.csv', '600004.csv', '600006.csv',
                 '600007.csv', '600008.csv', '600009.csv',
                 '600010.csv', '600011.csv', '600012.csv',
                 '600015.csv', '600016.csv', '600018.csv',
                 '600019.csv', '600020.csv', '600026.csv',
                 '600028.csv', '600029.csv', '600030.csv',
                 '600031.csv', '600033.csv', '600036.csv']
    operation()

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.pyplot import MultipleLocator

pi=np.pi
x=np.linspace(-pi,pi)
xaxis=round(pi/6,2)
sin=np.sin(x)
cos=np.cos(x)
tan=np.tan(x)

plt.figure(figsize=(30,3))

ax_sin=plt.subplot(131).plot(x,sin,'r')
plt.grid(True)
plt.title('sin(x)')
plt.gca().xaxis.set_major_locator(MultipleLocator(xaxis))


ax_cos=plt.subplot(132).plot(x,cos,'g')
plt.grid(True)
plt.title('cos(x)')
plt.gca().xaxis.set_major_locator(MultipleLocator(xaxis))

ax_tan=plt.subplot(133).plot(x,tan,'b')
plt.grid(True)
plt.title('tan(x)')
plt.gca().xaxis.set_major_locator(MultipleLocator(xaxis))

plt.show()

import matplotlib.pyplot as plt
#plt.plot(x,y) 需先创建图像对象
#...
plt.title('str')

import matplotlib.pyplot as plt
#plt.plot(x,y) 需先创建图像对象
#...
plt.grid(True)

import matplotlib.pyplot as plt
#plt.plot(x,y) 需先创建图像对象
#...
#整个figure被分成1*3块
plt.subplot(131) # 使用1*3中的第1个区域（1行1列）
plt.subplot(132) # 使用1*3中的第2个区域（1行2列）
plt.subplot(133) # 使用1*3中的第2个区域（1行3列）
plt.show()

​

import matplotlib.pyplot as plt
#plt.plot(x,y) 需先创建图像对象
#...
#整个figure被分成2*2块
plt.subplot(221) # 使用2*2中的第1个区域（1行1列）
plt.subplot(222) # 使用2*2中的第2个区域（1行2列）
plt.subplot(212) # 将2*2块重新划分为2*1块，并使用2*1中的第2个区域（2*1中的第1个区域已被前两个使用）                       
plt.show() 

​

from PIL import Image
import numpy as np

vec_el=np.pi/2.2
vec_az=np.pi/4.

depth=10
im=Image.open('scene.png').convert('L')
a=np.asarray(im).astype('float')
grad=np.gradient(a)
grad_x,grad_y=grad
grad_x=grad_x*depth/100.
grad_y=grad_y*depth/100.
dx=np.cos(vec_el)*np.cos(vec_az)
dy=np.cos(vec_el)*np.sin(vec_az)
dz=np.sin(vec_el)
A=np.sqrt(grad_x**2+grad_y**2+1.)
uni_x=grad_x/A
uni_y=grad_y/A
uni_z=1./A
a2=255*(dx*uni_x+dy*uni_y+dz*uni_z)
a2=a2.clip(0,255)
im2=Image.fromarray(a2.astype('uint8'))
im2.save('HandDraw.jpg')