巩固复习(对以前的随笔总结)_05

PageRank算法

def create(q,graph,N):
    #compute Probability Matrix
    L = [[(1-q)/N]*N for i in range(N)]
    for node,edges in enumerate(graph):
        num_edge = len(edges)
        for each in edges:
            L[each][node] += q/num_edge
    return L
def transform(A):
    n,m = len(A),len(A[0])
    new_A = [[A[j][i] for j in range(n) ] for i in range(m)]
    return new_A
def mul(A,B):
    n = len(A)
    m = len(B[0])
    B = transform(B)
    next = [[0]*m for i in range(n)]
    for i in range(n):
        row = A[i]
        for j in range(m):
            col = B[j]
            next[i][j] = sum([row[k]*col[k] for k in range(n)])
    return next
def power(A,N):
    n = len(A)
    assert(len(A[0])==n)
    final_ans,temp = A,A
    N-=1
    while N>0:
        if N&1:
            final_ans = mul(final_ans,temp)
        temp = mul(temp,temp)
        N >>=1
    return final_ans
def PageRank(q,graph,N):
    X = [[1] for i in range(N)]
    A = create(q,graph,N)
    X = mul(power(A,20),X)
    return X
print(PageRank(0.85,[[1,2],[2],[0]],3))


————————————————
原文链接：https://blog.csdn.net/pp634077956/java/article/details/52604137

穷人版PageRank算法的Python实现

#用于存储图
class Graph():
    def __init__(self):
        self.linked_node_map = {}#邻接表，
        self.PR_map ={}#存储每个节点的入度
    
    #添加节点
    def add_node(self, node_id):
        if node_id not in self.linked_node_map:
            self.linked_node_map[node_id] = set({})
            self.PR_map[node_id] = 0
        else:
            print("这个节点已经存在")
    
    #增加一个从Node1指向node2的边。允许添加新节点
    def add_link(self, node1, node2):
        if node1 not in self.linked_node_map:
            self.add_node(node1)
        if node2 not in self.linked_node_map:
            self.add_node(node2)
        self.linked_node_map[node1].add(node2)#为node1添加一个邻接节点，表示ndoe2引用了node1
    
    #计算pr
    def get_PR(self, epoch_num=10, d=0.5):#配置迭代轮数，以及阻尼系数
        for i in range(epoch_num):
            for node in self.PR_map:#遍历每一个节点
                self.PR_map[node] = (1-d) + d*sum([self.PR_map[temp_node] for temp_node in self.linked_node_map[node]])#原始版公式
            print(self.PR_map)
            

edges = [[1,2], [3,2], [3,5], [1,3], [2,3], [3, 1], [5,1]]#模拟的一个网页链接网络       
if __name__ == '__main__':
    graph = Graph()
    for edge in edges:
        graph.add_link(edge[0], edge[1])
    graph.get_PR()

分解质因数

把一个合数分解成若干个质因数的乘积的形式，即求质因数的过程叫做分解质因数。

Python练习题问题如下：
要求：将一个正整数分解质因数；例如您输入90，分解打印90=2*3*3*5。
Python解题思路分析：
这道题需要分三部分来分解，具体分解说明如下。
1、首先当这个质数恰等于n的情况下，则说明分解质因数的过程已经结束，打印出即可。
2、如果遇到n<>k，但n能被k整除的情况，则应打印出k的值。同时用n除以k的商，作为新的正整数你n，之后再重复执行第一步的操作。
3、如果n不能被k整除时，那么用k+1作为k的值，再来重复执行第一步的操作系统。

def reduceNum(n):
    print ('{} = '.format(n))
    if not isinstance(n, int) or n <= 0 :
        print ('请输入一个正确的数字')
        exit(0)
    elif n in [1] :
        # 如果 n 为 1
        print('{}'.format(n))
    while n not in [1] : # 循环保证递归
        for index in range(2, n + 1) :
            if n % index == 0:
                n //= index # n 等于 n//index
                if n == 1: 
                    print (index) 
                else : # index 一定是素数
                    print ('{} *'.format(index),end = "   ")
                break
reduceNum(90)
reduceNum(100)

计算皮球下落速度

问题简述：假设一支皮球从100米高度自由落下。条件，每次落地后反跳回原高度的一半后，再落下。
要求：算出这支皮球，在它在第10次落地时，共经过多少米？第10次反弹多高？

解题思路
总共初始高度 100 米
高度 每次弹起一半距离

每一次弹起  上升的高度和下降的高度 是一次的距离

每一次弹起,高度都会是之前的一半

Sn = 100.0
Hn = Sn / 2
 
for n in range(2,11):
    Sn += 2 * Hn
    Hn /= 2
 
print ('总共经过  %.2f 米' % Sn)
print ('第十次反弹 %.2f 米' % Hn)

给定年月日,判断是这一年的第几天

# 输入年月日
year = int(input('year:'))
month = int(input('month:'))
day = int(input('day:'))

# 将正常情况下,每一个月的累计天数放入到元组中进行保存
months = (0,31,59,90,120,151,181,212,243,273,304,334)

if 0 < month <= 12:
    # 如果输入的数据正确,月份在 1~12 之间
    sum_days = months[month - 1]
    # 总天数就为 列表中的天数,索引值根据 输入的月份进行选择
else:
    print ('数据错误,请重新输入')

# 加上输入的日期
sum_days += day

# 默认不是闰年
leap = 0 

# 判断是否是闰年,被 400 整除,可以整除4 但是不能被 100 除掉 
if (year % 400 == 0) or ((year % 4 == 0) and (year % 100 != 0)):
    leap = 1
    # 如果为 1 则表示 这一年是闰年

if (leap == 1) and (month > 2):
    # 当这一年是闰年,并且月份大于 2 时,说明存在 29 日,所以总天数再增加 1
    sum_days += 1

print ('这是 %d 年的第 %d 天.' % (year,sum_days))

实验1-5

Django暂时停止更新,先把学校实验报告弄完


'''
计算
1.输入半径,输出面积和周长
2.输入面积,输出半径及周长
3.输入周长,输出半径及面积
'''
'''1.输入半径,输出面积和周长'''
from math import pi

'''定义半径'''
r = int(input("请输入半径的值(整数)"))
if r <= 0 :
    exit("请重新输入半径")
''' S 面积: pi * r * r '''
S = pi * pow(r,2)
print(" 半径为 %d 的圆,面积为 %.2f"%(r,S))
'''C 周长: C = 2 * pi * r '''
C = 2 * pi * r
print(" 半径为 %d 的圆,周长为 %.2f"%(r,C))

'''2.输入面积,输出半径及周长'''
from math import pi,sqrt

S = float(input("请输入圆的面积(支持小数格式)"))
if S < 0 :
    exit("请重新输入面积")
'''r 半径: r = sqrt(S/pi)'''
r = sqrt(S/pi)

print("面积为 %.2f 的圆,半径为 %.2f"%(S,r))
'''C 周长: C = 2 * pi * r '''
C = 2 * pi * r
print("面积为 %.2f 的圆,周长为 %.2f"%(S,C))

'''3.输入周长,输出半径及面积'''
from math import pi

C = float(input("请输入圆的周长(支持小数格式)"))
if C < 0 :
    exit("请重新输入周长")
'''r 半径: r = C/(2*pi)'''
r = C/(2*pi)

print("周长为 %.2f 的圆,半径为 %.2f"%(C,r))
''' S 面积: pi * r * r '''
S = pi * pow(r,2)
print("周长为 %.2f 的圆,面积为 %.2f"%(C,S))


'''
数据结构
列表练习
 1.创建列表对象 [110,'dog','cat',120,'apple']
 2.在字符串 'dog' 和 'cat' 之间插入空列表
 3.删除 'apple' 这个字符串
 4.查找出 110、120 两个数值,并以 10 为乘数做自乘运算
'''
'''1.创建列表对象 [110,'dog','cat',120,'apple']'''
# '''创建一个名为 lst 的列表对象'''
lst = [110,'dog','cat',120,'apple']
print(lst)

'''2.在字符串 'dog' 和 'cat' 之间插入空列表'''
lst = [110,'dog','cat',120,'apple']
'''添加元素到 'dog' 和 'cat' 之间'''
lst.insert(2,[])
print(lst)

'''3.删除 'apple' 这个字符串'''
lst = [110,'dog','cat',120,'apple']
'''删除最后一个元素'''
lst.pop()
print(lst)

'''4.查找出 110、120 两个数值,并以 10 为乘数做自乘运算'''
lst = [110,'dog','cat',120,'apple']
try:
    '''如果找不到数据,进行异常处理'''
    lst[lst.index(110)] *= 10
    lst[lst.index(120)] *= 10
except Exception as e:
    print(e)
print(lst)


'''
元组练习
 1.创建列表 ['pen','paper',10,False,2.5] 赋给变量并查看变量的类型
 2.将变量转换为 tuple 类型,查看变量的类型
 3.查询元组中的元素 False 的位置
 4.根据获得的位置提取元素
'''
'''1.创建列表 ['pen','paper',10,False,2.5] 赋给变量并查看变量的类型'''
lst = ['pen','paper',10,False,2.5]
'''查看变量类型'''
print("变量的类型",type(lst))

'''2.将变量转换为 tuple 类型,查看变量的类型'''
lst = tuple(lst)
print("变量的类型",type(lst))

'''3.查询元组中的元素 False 的位置'''
if False in lst:
    print("False 的位置为(从0开始): ",lst.index(False))
    '''4.根据获得的位置提取元素'''
    print("根据获得的位置提取的元素为: ",lst[lst.index(False)])
else:
    print("不在元组中")


'''
1.创建字典{‘Math’:96,’English’:86,’Chinese’:95.5,
’Biology’:86,’Physics’:None}
2.在字典中添加键对{‘Histore’:88}
3.删除{’Physics’:None}键值对
4.将键‘Chinese’所对应的值进行四舍五入后取整
5.查询键“Math”的对应值
'''
'''1.创建字典'''
dic = {'Math':96,'English':86,'Chinese':95.5,'Biology':86,'Physics':None}
print(dic)

'''2.添加键值对'''
dic['Histore'] = 88
print(dic)

'''3.删除{’Physics’:None}键值对'''
del dic['Physics']
print(dic)

'''4.将键‘Chinese’所对应的值进行四舍五入后取整'''
print(round(dic['Chinese']))

'''5.查询键“Math”的对应值'''
print(dic['Math'])


'''
1.创建列表[‘apple’,’pear’,’watermelon’,’peach’]并赋给变量
2.用list()创建列表[‘pear’,’banana’,’orange’,’peach’,’grape’]，并赋给变量
3.将创建的两个列表对象转换为集合类型
4.求两个集合的并集、交集和差集
'''
'''1.创建列表'''
lst = ['apple','pear','watermelon','peach']
print(lst)

'''2.用list()创建,并赋给变量'''
lstTwo = list(('pear','banana','orange','peach','grape'))
print(lstTwo)

'''3.将创建的两个列表对象转换为集合类型'''
lst = set(lst)
lstTwo = set(lstTwo)

'''4.求两个集合的并集、交集和差集'''
print("并集是:",lst | lstTwo)
print("交集是:",lst & lstTwo)
print("差集:")
print(lst - lstTwo)
print(lstTwo - lst)


'''
1 输出数字金字塔
（1）设置输入语句，输入数字
（2）创建变量来存放金字塔层数
（3）编写嵌套循环，控制变量存放每一层的长度
（4）设置条件来打印每一行输出的数字
（5）输出打印结果
'''
num = int(input("请输入金字塔的层数"))
'''cs 层数'''
cs = 1
while cs <= num:
    kk = 1
    t = cs
    length = 2*t - 1
    while kk <= length:
        if kk == 1:
            if kk == length:
                print(format(t,str(2*num-1)+"d"),'\n')
                break
            else:
                print(format(t,str(2*num+1 - 2*cs) + "d"),"",end = "")
                t -= 1
        else:
            if kk == length:
                '''最右侧数字 length 位置上数字为 t'''
                print(t,"\n")
                break
            elif kk <= length/2:
                '''到中间的数字不断减小'''
                print(t,"",end = "")
                t -= 1
            else:
                '''中间的数字到右侧的数字不断增大'''
                print(t,"",end = "")
                t += 1
        kk += 1
    '''层数加 1'''
    cs += 1


'''
（1）使用自定义函数，完成对程序的模块化
（2）学生信息至少包括：姓名、性别及手机号
（3）该系统具有的功能：添加、删除、修改、显示、退出系统
'''
'''创建一个容纳所有学生的基本信息的列表'''
stusInfo = []

def menu():
    '''定义页面显示'''
    print('-'*20)
    print('学生管理系统')
    print('1.添加学生信息')
    print('2.删除学生信息')
    print('3.修改学生信息')
    print('4.显示所有学生信息')
    print('0.退出系统')
    print('-' * 20)

def addStuInfo():
    '''添加学生信息'''

    '''设置变量容纳学生基本信息'''
    newStuName = input('请输入新学生的姓名')
    newStuGender = input('请输入新学生的性别')
    newStuPhone = input('请输入新学生的手机号')

    '''设置字典将变量保存'''
    newStudent = {}
    newStudent['name'] = newStuName
    newStudent['gender'] = newStuGender
    newStudent['phone'] = newStuPhone

    '''添加到信息中'''
    stusInfo.append(newStudent)

def delStuInfo():
    '''删除学生信息'''

    showStusInfo()

    defStuId = int(input('请输入要删除的序号:'))

    '''从列表中删除 该学生'''
    del stusInfo[defStuId - 1]

def changeStuInfo():
    '''修改学生信息'''
    showStusInfo()
    '''查看修改的学生序号'''
    stuId = int(input("请输入需要修改的学生的序号: "))

    changeStuName = input('请输入修改后的学生的姓名')
    changeStuGender = input('请输入修改后的学生的性别')
    changeStuPhone = input('请输入修改后的学生的手机号')

    '''对列表修改学生信息'''
    stusInfo[stuId - 1]['name'] = changeStuName
    stusInfo[stuId - 1]['gender'] = changeStuGender
    stusInfo[stuId - 1]['phone'] = changeStuPhone

def showStusInfo():
    print('-'*30)
    print("学生的信息如下:")
    print('-'*30)
    print('序号   姓名  性别  手机号码')

    '''展示学生序号(位置),姓名,性别,手机号码'''
    stuAddr = 1
    for stuTemp in stusInfo:
        print("%d   %s  %s  %s"%(stuAddr,stuTemp['name'],stuTemp['gender'],stuTemp['phone']))
        stuAddr += 1

def main():
    '''主函数'''
    while True:
        '''显示菜单'''
        menu()
        keyNum = int(input("请输入功能对应的数字"))
        if keyNum == 1:
            addStuInfo()
        elif keyNum == 2:
            delStuInfo()
        elif keyNum == 3:
            changeStuInfo()
        elif keyNum == 4:
            showStusInfo()
        elif keyNum == 0:
            print("欢迎下次使用")
            break


if __name__ == '__main__':
    main()


import numpy as np
'''一维数组'''

'''np.array 方法'''

print(np.array([1,2,3,4]))
# [1 2 3 4]
print(np.array((1,2,3,4)))
# [1 2 3 4]
print(np.array(range(4)))
# [0 1 2 3]

'''np.arange 方法'''
print(np.arange(10))
# [0 1 2 3 4 5 6 7 8 9]

'''np.linspace 方法'''
print(np.linspace(0,10,11))
# [ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
print(np.linspace(0,10,11,endpoint = False))
# [0.         0.90909091 1.81818182 2.72727273 3.63636364 4.54545455
#  5.45454545 6.36363636 7.27272727 8.18181818 9.09090909]

'''np.logspace 方法'''
print(np.logspace(0,100,10))
# [1.00000000e+000 1.29154967e+011 1.66810054e+022 2.15443469e+033
#  2.78255940e+044 3.59381366e+055 4.64158883e+066 5.99484250e+077
#  7.74263683e+088 1.00000000e+100]
print(np.logspace(1,4,4,base = 2))
# [ 2.  4.  8. 16.]

'''zeros 方法'''
print(np.zeros(3))
# [0. 0. 0.]

'''ones 方法'''
print(np.ones(3))
# [1. 1. 1.]


'''二维数组'''

'''np.array 方法'''
print(np.array([[1,2,3],[4,5,6]]))
# [[1 2 3]
#  [4 5 6]]

'''np.identify 方法'''
print(np.identity(3))
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

'''np.empty 方法'''
print(np.empty((3,3)))
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

'''np.zeros 方法'''
print(np.zeros((3,3)))
# [[0. 0. 0.]
#  [0. 0. 0.]
#  [0. 0. 0.]]

'''np.ones 方法'''
print(np.ones((3,3)))
# [[1. 1. 1.]
#  [1. 1. 1.]
#  [1. 1. 1.]]


import numpy as np

'''一维数组'''

'''np.random.randint 方法'''
print(np.random.randint(0,6,3))
# [4 2 1]

'''np.random.rand 方法'''
print(np.random.rand(10))
# [0.12646424 0.59660184 0.52361248 0.1206141  0.28359949 0.46069696
#  0.18397493 0.73839455 0.99115088 0.98297331]

'''np.random.standard_normal 方法'''
print(np.random.standard_normal(3))
# [-0.12944733 -0.32607943  0.58582095]


'''二维数组'''

'''np.random.randint 方法'''
print(np.random.randint(0,6,(3,3)))
# [[0 0 0]
#  [4 4 0]
#  [5 0 3]]

'''多维数组'''
print(np.random.standard_normal((3,4,2)))
# [[[-0.79751104 -1.40814148]
#   [-1.06189896  1.19993648]
#   [ 1.68883868  0.09190824]
#   [ 0.33723433  0.28246094]]
#
#  [[ 0.3065646   1.1177714 ]
#   [-0.48928572  0.55461195]
#   [ 0.3880272  -2.27673705]
#   [-0.97869759 -0.07330554]]
#
#  [[ 0.62155155 -0.17690222]
#   [ 1.61473949 -0.34930031]
#   [-1.41535777  1.32646137]
#   [-0.22865775 -2.00845225]]]


import numpy as np

n = np.array([10,20,30,40])

print(n + 5)
# [15 25 35 45]
print(n - 10)
# [ 0 10 20 30]
print(n * 2)
# [20 40 60 80]
print(n / 3)
# [ 3.33333333  6.66666667 10.         13.33333333]
print(n // 3)
# [ 3  6 10 13]
print(n % 3)
# [1 2 0 1]
print(n ** 2)
# [ 100  400  900 1600]

n = np.array([1,2,3,4])
print(2 ** n)
# [ 2  4  8 16]
print(16//n)
# [16  8  5  4]

print(np.array([1,2,3,4]) + np.array([1,1,2,2]))
# [2 3 5 6]
print(np.array([1,2,3,4]) + np.array(4))
# [5 6 7 8]

print(n)
# [1 2 3 4]

print(n + n)
# [2 4 6 8]
print(n - n)
# [0 0 0 0]
print(n * n)
# [ 1  4  9 16]
print(n / n)
# [1. 1. 1. 1.]
print(n ** n)
# [  1   4  27 256]

x = np.array([4,7,3])
print(np.argsort(x))
# [2 0 1]

print(x.argmax())
# 1
print(x.argmin())
# 2

print(np.sort(x))
# [3 4 7]

print(np.where(x < 5,0,1))

x = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(x)
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

x.resize((2,5))
print(x)
# [[1 2 3 4 5]
#  [6 7 8 9 0]]

print(np.piecewise(x,[x<3],[lambda x:x + 1]))
# [[2 3 0 0 0]
#  [0 0 0 0 1]]


import pandas as pd
import numpy as np

'''对 sepal_length 这一列进行分析'''
irisSepalLength = np.loadtxt('iris.csv')
print(irisSepalLength[:5])
# [5.1 4.9 4.7 4.6 5. ]

'''对数据进行排序'''
irisSepalLength.sort()
print(irisSepalLength[:15])
# [4.3 4.4 4.4 4.4 4.5 4.6 4.6 4.6 4.6 4.7 4.7 4.8 4.8 4.8 4.8]

'''查看去重后的数据集'''
print(np.unique(irisSepalLength)[:15])
# [4.3 4.4 4.5 4.6 4.7 4.8 4.9 5.  5.1 5.2 5.3 5.4 5.5 5.6 5.7]

'''查看长度的总和'''
print(np.sum(irisSepalLength))
# 876.5

'''累计和'''
print(np.cumsum(irisSepalLength)[:10])
# [ 4.3  8.7 13.1 17.5 22.  26.6 31.2 35.8 40.4 45.1]


'''均值'''
print(np.mean(irisSepalLength))
# 5.843333333333334

'''标准差'''
print(np.std(irisSepalLength))
# 0.8253012917851409

'''方差'''
print(np.var(irisSepalLength))
# 0.6811222222222223

'''最小值'''
print(np.min(irisSepalLength))
# 4.3

'''最大值'''
print(np.max(irisSepalLength))
# 7.9


import pandas as pd

'''创建 Series 对象 s'''
s = pd.Series(range(1,20,5))
print(s)
# 0     1
# 1     6
# 2    11
# 3    16
# dtype: int64

s = pd.Series({'语文':90,'数学':92,'物理':88,'化学':99})
print(s)
# 语文    90
# 数学    92
# 物理    88
# 化学    99
# dtype: int64

'''修改数据'''
s['语文'] = 100
print(s)
# 语文    100
# 数学     92
# 物理     88
# 化学     99
# dtype: int64

'''使用绝对值'''
print(abs(s))
# 语文    100
# 数学     92
# 物理     88
# 化学     99
# dtype: int64

'''对数据列加后缀'''
# s.add_suffix('后缀')

'''查看某些数据是否满足条件'''
print(s.between(90,99,inclusive = True))
# 语文    False
# 数学     True
# 物理    False
# 化学     True
# dtype: bool

'''查看属性最大的列名'''
print(s.idxmax())
# 语文

'''查看属性最小的列名'''
print(s.idxmin())
# 物理

'''大于 95 的列'''
print(s[s > 95])
# 语文    100
# 化学     99
# dtype: int64

'''查看中值'''
print(s.median())
# 95.5

'''大于中值的列'''
print(s[s > s.median()])
# 语文    100
# 化学     99
# dtype: int64

'''查看最小的 3 个值'''
print(s.nsmallest(3))
# 物理    88
# 数学    92
# 化学    99
# dtype: int64


'''查看最大的 3 个值'''
print(s.nlargest(3))
# 语文    100
# 化学     99
# 数学     92
# dtype: int64

'''两个 Series 对象进行相加'''
print(pd.Series(range(5)) + pd.Series(range(7,12)))
# 0     7
# 1     9
# 2    11
# 3    13
# 4    15
# dtype: int64

'''对 Series 对象使用函数'''
print(pd.Series(range(5)).pipe(lambda x,y:(x**y),4))
# 0      0
# 1      1
# 2     16
# 3     81
# 4    256
# dtype: int64

print(pd.Series(range(5)).pipe(lambda x:x + 3))
# 0    3
# 1    4
# 2    5
# 3    6
# 4    7
# dtype: int64

print(pd.Series(range(5)).apply(lambda x:x + 3))
# 0    3
# 1    4
# 2    5
# 3    6
# 4    7
# dtype: int64

'''查看标准差方差'''
print(s)
print(s.std())
# 5.737304826019502
print(s.var())
# 32.916666666666664

'''查看是否全部为真'''
print(any(pd.Series([1,0,1])))
# True

print(all(pd.Series([1,0,1])))
# False


import pandas as pd
import numpy as np

'''创建一个 DataFrame 对象'''
df = pd.DataFrame(np.random.randint(1,5,(5,3)),index = range(5),columns = ['A','B','C'])
print(df)
#    A  B  C
# 0  4  4  2
# 1  1  4  1
# 2  4  3  4
# 3  3  1  3
# 4  2  3  1

'''读取数据'''
market = pd.read_excel('超市营业额.xlsx')
print(market.head())
#      工号  姓名          日期           时段     交易额   柜台
# 0  1001  张三  2019-03-01   9：00-14：00  1664.0  化妆品
# 1  1002  李四  2019-03-01  14：00-21：00   954.0  化妆品
# 2  1003  王五  2019-03-01   9：00-14：00  1407.0   食品
# 3  1004  赵六  2019-03-01  14：00-21：00  1320.0   食品
# 4  1005  周七  2019-03-01   9：00-14：00   994.0  日用品


'''查看不连续行的数据'''
print(market.iloc[[1,8,19],:])
#       工号  姓名          日期           时段     交易额   柜台
# 1   1002  李四  2019-03-01  14：00-21：00   954.0  化妆品
# 8   1001  张三  2019-03-02   9：00-14：00  1530.0  化妆品
# 19  1004  赵六  2019-03-03  14：00-21：00  1236.0   食品

print(market.iloc[[1,8,19],[1,4]])
#     姓名     交易额
# 1   李四   954.0
# 8   张三  1530.0
# 19  赵六  1236.0

'''查看前五条记录的 姓名 时段 和 交易额'''
print(market[['姓名','时段','交易额']].head())
#    姓名           时段     交易额
# 0  张三   9：00-14：00  1664.0
# 1  李四  14：00-21：00   954.0
# 2  王五   9：00-14：00  1407.0
# 3  赵六  14：00-21：00  1320.0
# 4  周七   9：00-14：00   994.0

print(market.loc[[3,4,7],['姓名','时段','柜台']])
#    姓名           时段    柜台
# 3  赵六  14：00-21：00    食品
# 4  周七   9：00-14：00   日用品
# 7  张三  14：00-21：00  蔬菜水果

'''查看交易额大于 2000 的数据'''
print(market[market.交易额 > 1500].head())
#       工号  姓名          日期          时段     交易额    柜台
# 0   1001  张三  2019-03-01  9：00-14：00  1664.0   化妆品
# 8   1001  张三  2019-03-02  9：00-14：00  1530.0   化妆品
# 14  1002  李四  2019-03-02  9：00-14：00  1649.0  蔬菜水果
# 18  1003  王五  2019-03-03  9：00-14：00  1713.0    食品
# 20  1005  周七  2019-03-03  9：00-14：00  1592.0   日用品

'''查看交易额的总和'''
print(market['交易额'].sum())
# 327257.0

print(market[market['时段'] == '9：00-14：00']['交易额'].sum())
# 176029.0

'''查看某员工在 14：00-21：00 的交易数据'''
print(market[(market.姓名 == '张三') & (market.时段 == '14：00-21：00')].head())
#       工号  姓名          日期           时段     交易额    柜台
# 7   1001  张三  2019-03-01  14：00-21：00  1442.0  蔬菜水果
# 39  1001  张三  2019-03-05  14：00-21：00   856.0  蔬菜水果
# 73  1001  张三  2019-03-10  14：00-21：00  1040.0   化妆品
# 91  1001  张三  2019-03-12  14：00-21：00  1435.0    食品
# 99  1001  张三  2019-03-13  14：00-21：00  1333.0    食品

'''查看交易额在 1500 到 2500 的数据'''
print(market[market['交易额'].between(1500,2000)].head())
#       工号  姓名          日期          时段     交易额    柜台
# 0   1001  张三  2019-03-01  9：00-14：00  1664.0   化妆品
# 8   1001  张三  2019-03-02  9：00-14：00  1530.0   化妆品
# 14  1002  李四  2019-03-02  9：00-14：00  1649.0  蔬菜水果
# 18  1003  王五  2019-03-03  9：00-14：00  1713.0    食品
# 20  1005  周七  2019-03-03  9：00-14：00  1592.0   日用品

'''查看描述'''
print(market['交易额'].describe())
# count      246.000000
# mean      1330.313008
# std        904.300720
# min         53.000000
# 25%       1031.250000
# 50%       1259.000000
# 75%       1523.000000
# max      12100.000000
# Name: 交易额, dtype: float64

print(market['交易额'].quantile([0,0.25,0.5,0.75,1]))
# 0.00       53.00
# 0.25     1031.25
# 0.50     1259.00
# 0.75     1523.00
# 1.00    12100.00
# Name: 交易额, dtype: float64

'''查看中值'''
print(market['交易额'].median())
# 1259.0

'''查看最大值'''
print(market['交易额'].max())
# 12100.0
print(market['交易额'].nlargest(5))
# 105    12100.0
# 223     9031.0
# 113     1798.0
# 188     1793.0
# 136     1791.0

'''查看最小值'''
print(market['交易额'].min())
# 53.0
print(market['交易额'].nsmallest(5))
#  76      53.0
# 97      98.0
# 194    114.0
# 86     801.0
# 163    807.0
# Name: 交易额, dtype: float64


 

import pandas as pd

market = pd.read_excel('超市营业额.xlsx')
print(market.head())
#      工号  姓名          日期           时段     交易额   柜台
# 0  1001  张三  2019-03-01   9：00-14：00  1664.0  化妆品
# 1  1002  李四  2019-03-01  14：00-21：00   954.0  化妆品
# 2  1003  王五  2019-03-01   9：00-14：00  1407.0   食品
# 3  1004  赵六  2019-03-01  14：00-21：00  1320.0   食品
# 4  1005  周七  2019-03-01   9：00-14：00   994.0  日用品

'''对数据进行排序'''
print(market.sort_values(by = ['交易额','工号'],ascending = False).head())
#        工号  姓名          日期           时段      交易额    柜台
# 105  1001  张三  2019-03-14   9：00-14：00  12100.0   日用品
# 223  1003  王五  2019-03-28   9：00-14：00   9031.0    食品
# 113  1002  李四  2019-03-15   9：00-14：00   1798.0   日用品
# 188  1002  李四  2019-03-24  14：00-21：00   1793.0  蔬菜水果
# 136  1001  张三  2019-03-17  14：00-21：00   1791.0    食品

print(market.sort_values(by = ['交易额','工号'],ascending = True).head())
#        工号  姓名          日期           时段    交易额    柜台
# 76   1005  周七  2019-03-10   9：00-14：00   53.0   日用品
# 97   1002  李四  2019-03-13  14：00-21：00   98.0   日用品
# 194  1001  张三  2019-03-25  14：00-21：00  114.0   化妆品
# 86   1003  王五  2019-03-11   9：00-14：00  801.0  蔬菜水果
# 163  1006  钱八  2019-03-21   9：00-14：00  807.0  蔬菜水果


'''groupby 对象 的使用'''
print(market.groupby(by = lambda x:x%3)['交易额'].sum())
# 0    113851.0
# 1    108254.0
# 2    105152.0
# Name: 交易额, dtype: float64

'''查看 柜台的交易额 '''
print(market.groupby(by = '柜台')['交易额'].sum())
# 柜台
# 化妆品     75389.0
# 日用品     88162.0
# 蔬菜水果    78532.0
# 食品      85174.0
# Name: 交易额, dtype: float64

'''查看日期个数'''
print(market.groupby(by = '姓名')['日期'].count())
# 姓名
# 周七    42
# 张三    38
# 李四    47
# 王五    40
# 赵六    45
# 钱八    37
# Name: 日期, dtype: int64

'''将员工的营业额汇总出来'''
print(market.groupby(by = '姓名')['交易额'].sum().apply(int))
# 姓名
# 周七    47818
# 张三    58130
# 李四    58730
# 王五    58892
# 赵六    56069
# 钱八    47618
# Name: 交易额, dtype: int64

'''查看交易额的 最大最小平均值和中值'''
print(market.groupby(by = '姓名').agg(['max','min','mean','median'])['交易额'])
#         max    min         mean  median
# 姓名
# 周七   1778.0   53.0  1195.450000  1134.5
# 张三  12100.0  114.0  1529.736842  1290.0
# 李四   1798.0   98.0  1249.574468  1276.0
# 王五   9031.0  801.0  1472.300000  1227.0
# 赵六   1775.0  825.0  1245.977778  1224.0
# 钱八   1737.0  807.0  1322.722222  1381.0

'''处理异常值'''
# 考虑使用其他数据替代

'''处理缺失值'''
print(market[market['交易额'].isnull()])
#        工号  姓名          日期           时段  交易额   柜台
# 110  1005  周七  2019-03-14  14：00-21：00  NaN  化妆品
# 124  1006  钱八  2019-03-16  14：00-21：00  NaN   食品
# 168  1005  周七  2019-03-21  14：00-21：00  NaN   食品
# 考虑使用 平均值 替换

'''处理重复值'''
# 考虑是否删除数据
'''duplicated() 和 drop_duplicates()'''

'''使用透视表,查看前五天的数据'''
print(market.pivot_table(values = '交易额',index = '姓名',columns = '日期',aggfunc = 'sum').iloc[:,:5])

print(market.pivot_table(values = '交易额',index = '姓名',columns = '柜台',aggfunc = 'count').iloc[:,:5])

'''使用交叉表,查看员工和柜台的次数'''
print(pd.crosstab(market['姓名'],market['柜台']))
# 姓名
# 周七    9   11    14   8
# 张三   19    6     6   7
# 李四   16    9    18   4
# 王五    8    9     9  14
# 赵六   10   18     2  15
# 钱八    0    9    14  14

print(pd.crosstab(market['姓名'],market['日期']))
# 日期  2019-03-01  2019-03-02  2019-03-03  ...  2019-03-29  2019-03-30  2019-03-31
# 姓名                                      ...
# 周七           1           1           2  ...           1           1           2
# 张三           2           1           1  ...           1           2           0
# 李四           1           2           1  ...           2           2           2
# 王五           1           2           1  ...           1           1           1
# 赵六           1           1           2  ...           2           1           2
# 钱八           2           1           1  ...           1           1           1

print(pd.crosstab(market['姓名'],market['柜台'],market['交易额'],aggfunc = 'mean').apply(lambda x:round(x)))
# 柜台     化妆品     日用品    蔬菜水果      食品
# 姓名
# 周七  1190.0  1169.0  1174.0  1285.0
# 张三  1209.0  3105.0  1211.0  1323.0
# 李四  1279.0  1123.0  1292.0  1224.0
# 王五  1264.0  1262.0  1164.0  1925.0
# 赵六  1232.0  1294.0  1264.0  1196.0
# 钱八     NaN  1325.0  1326.0  1318.0

学生成绩表数据包括:学号,姓名,高数,英语和计算机三门课成绩,计算每个学生总分,每课程平均分,最高分和最低分

'''
每一个学生的总分,每个课程的平均分,最高分,最低分
'''
# 创建学生列表
stuLst = []

# 创建学生信息
stu1 = {'学号':'1001','姓名':'小明','高数':95,'英语':88,'计算机':80}
stu2 = {'学号':'1002','姓名':'小李','高数':84,'英语':70,'计算机':60}
stu3 = {'学号':'1003','姓名':'小王','高数':79,'英语':78,'计算机':75}

# 将学生列表加入到学生信息中
stuLst.append(stu1)
stuLst.append(stu2)
stuLst.append(stu3)

def sumScore(stuLst):
    '''计算每名学生的总分'''
    for stu in stuLst:
        print(stu['姓名'],"的三科总分是 ",stu['高数'] + stu['英语'] + stu['计算机'])

def meanScore(stuLst):
    '''计算课程的平均分'''
    sumProjectScore_gs = 0
    # 设置高数学科总分
    sumProjectScore_yy = 0
    # 设置英语学科总分
    sumProjectScore_jsj = 0
    # 设置计算机学科总分(_拼音缩写)

    for stu in stuLst:
        sumProjectScore_gs += stu['高数']
        sumProjectScore_yy += stu['英语']
        sumProjectScore_jsj += stu['计算机']

    print("高数的平均分是 %.2f"%(sumProjectScore_gs//len(stuLst)))
    print("英语的平均分是 %.2f" % (sumProjectScore_yy // len(stuLst)))
    print("计算机的平均分是 %.2f" % (sumProjectScore_jsj // len(stuLst)))


def maxScore(stuLst):
    '''求最大值'''
    # 高数 英语 计算机
    gs = []
    yy = []
    jsj = []

    for stu in stuLst:
        gs.append(stu['高数'])
        yy.append(stu['英语'])
        jsj.append(stu['计算机'])
    print("高数的最高分是 %.2f"%(max(gs)))
    print("英语的最高分是 %.2f" % (max(yy)))
    print("计算机的最高分是 %.2f" % (max(jsj)))


def minScore(stuLst):
    '''求最小值'''
    # 高数 英语 计算机
    gs = []
    yy = []
    jsj = []

    for stu in stuLst:
        gs.append(stu['高数'])
        yy.append(stu['英语'])
        jsj.append(stu['计算机'])
    print("高数的最低分是 %.2f" % (min(gs)))
    print("英语的最低分是 %.2f" % (min(yy)))
    print("计算机的最低分是 %.2f" % (min(jsj)))


sumScore(stuLst)
meanScore(stuLst)
maxScore(stuLst)
minScore(stuLst)

四位玫瑰数

for i in range(1000,10000):
    t=str(i)
    if pow(eval(t[0]),4)+pow(eval(t[1]),4)+pow(eval(t[2]),4)+pow(eval(t[3]),4) == i:
        print(i)

四平方和

import math
def f(n):
    if isinstance(n,int):
        for i in range(round(math.sqrt(n))):
            for j in range(round(math.sqrt(n))):
                for k in range(round(math.sqrt(n))):
                    h = math.sqrt(n - i*i - j*j - k*k)
                    # 剪掉使用了的值
                    if h == int(h):
                        print("(%d,%d,%d,%d)"%(i,j,k,h))
                        return 
    else:
        print("(0,0,0,0)")

f(5)
f(12)
f("aaa")

学生管理系统-明日学院的

import re  # 导入正则表达式模块
import os  # 导入操作系统模块

filename = "students.txt"  # 定义保存学生信息的文件名


def menu():
    # 输出菜单
    print('''
    ╔———————学生信息管理系统————————╗
    │                                              │
    │   =============== 功能菜单 ===============   │
    │                                              │
    │   1 录入学生信息                             │
    │   2 查找学生信息                             │
    │   3 删除学生信息                             │
    │   4 修改学生信息                             │
    │   5 排序                                     │
    │   6 统计学生总人数                           │
    │   7 显示所有学生信息                         │
    │   0 退出系统                                 │
    │  ==========================================  │
    │  说明：通过数字或↑↓方向键选择菜单          │
    ╚———————————————————————╝
    ''')


def main():
    ctrl = True  # 标记是否退出系统
    while (ctrl):
        menu()  # 显示菜单
        option = input("请选择：")  # 选择菜单项
        option_str = re.sub("\D", "", option)  # 提取数字
        if option_str in ['0', '1', '2', '3', '4', '5', '6', '7']:
            option_int = int(option_str)
            if option_int == 0:  # 退出系统
                print('您已退出学生成绩管理系统！')
                ctrl = False
            elif option_int == 1:  # 录入学生成绩信息
                insert()
            elif option_int == 2:  # 查找学生成绩信息
                search()
            elif option_int == 3:  # 删除学生成绩信息
                delete()
            elif option_int == 4:  # 修改学生成绩信息
                modify()
            elif option_int == 5:  # 排序
                sort()
            elif option_int == 6:  # 统计学生总数
                total()
            elif option_int == 7:  # 显示所有学生信息
                show()


'''1 录入学生信息'''


def insert():
    stdentList = []        # 保存学生信息的列表
    mark = True  # 是否继续添加
    while mark:
        id = input("请输入ID（如 1001）：")
        if not id:  # ID为空，跳出循环
            break
        name = input("请输入名字：")
        if not name:  # 名字为空，跳出循环
            break
        try:
            english = int(input("请输入英语成绩："))
            python = int(input("请输入Python成绩："))
            c = int(input("请输入C语言成绩："))
        except:
            print("输入无效，不是整型数值．．．．重新录入信息")
            continue
        stdent = {"id": id, "name": name, "english": english, "python": python, "c": c}  # 将输入的学生信息保存到字典
        stdentList.append(stdent)  # 将学生字典添加到列表中
        inputMark = input("是否继续添加？（y/n）:")
        if inputMark == "y":  # 继续添加
            mark = True
        else:  # 不继续添加
            mark = False
    save(stdentList)  # 将学生信息保存到文件
    print("学生信息录入完毕！！！")


# 将学生信息保存到文件
def save(student):
    try:
        students_txt = open(filename, "a")  # 以追加模式打开
    except Exception as e:
        students_txt = open(filename, "w")  # 文件不存在，创建文件并打开
    for info in student:
        students_txt.write(str(info) + "\n")  # 按行存储，添加换行符
    students_txt.close()  # 关闭文件


'''2 查找学生成绩信息'''


def search():
    mark = True
    student_query = []  # 保存查询结果的学生列表
    while mark:
        id = ""
        name = ""
        if os.path.exists(filename):  # 判断文件是否存在
            mode = input("按ID查输入1；按姓名查输入2：")
            if mode == "1":
                id = input("请输入学生ID：")
            elif mode == "2":
                name = input("请输入学生姓名：")
            else:
                print("您的输入有误，请重新输入！")
                search()  # 重新查询
            with open(filename, 'r') as file:  # 打开文件
                student = file.readlines()  # 读取全部内容
                for list in student:
                    d = dict(eval(list))  # 字符串转字典
                    if id != "":  # 判断是否按ID查
                        if d['id'] == id:
                            student_query.append(d)  # 将找到的学生信息保存到列表中
                    elif name != "":  # 判断是否按姓名查
                        if d['name'] == name:
                            student_query.append(d)  # 将找到的学生信息保存到列表中
                show_student(student_query)  # 显示查询结果
                student_query.clear()  # 清空列表
                inputMark = input("是否继续查询？（y/n）:")
                if inputMark == "y":
                    mark = True
                else:
                    mark = False
        else:
            print("暂未保存数据信息...")
            return


'''3 删除学生成绩信息'''


def delete():
    mark = True  # 标记是否循环
    while mark:
        studentId = input("请输入要删除的学生ID：")
        if studentId != "":  # 判断要删除的学生是否存在
            if os.path.exists(filename):  # 判断文件是否存在
                with open(filename, 'r') as rfile:  # 打开文件
                    student_old = rfile.readlines()  # 读取全部内容
            else:
                student_old = []
            ifdel = False  # 标记是否删除
            if student_old:  # 如果存在学生信息
                with open(filename, 'w') as wfile:  # 以写方式打开文件
                    d = {}  # 定义空字典
                    for list in student_old:
                        d = dict(eval(list))  # 字符串转字典
                        if d['id'] != studentId:
                            wfile.write(str(d) + "\n")  # 将一条学生信息写入文件
                        else:
                            ifdel = True  # 标记已经删除
                    if ifdel:
                        print("ID为 %s 的学生信息已经被删除..." % studentId)
                    else:
                        print("没有找到ID为 %s 的学生信息..." % studentId)
            else:  # 不存在学生信息
                print("无学生信息...")
                break  # 退出循环
            show()  # 显示全部学生信息
            inputMark = input("是否继续删除？（y/n）:")
            if inputMark == "y":
                mark = True  # 继续删除
            else:
                mark = False  # 退出删除学生信息功能


'''4 修改学生成绩信息'''


def modify():
    show()  # 显示全部学生信息
    if os.path.exists(filename):  # 判断文件是否存在
        with open(filename, 'r') as rfile:  # 打开文件
            student_old = rfile.readlines()  # 读取全部内容
    else:
        return
    studentid = input("请输入要修改的学生ID：")
    with open(filename, "w") as wfile:  # 以写模式打开文件
        for student in student_old:
            d = dict(eval(student))  # 字符串转字典
            if d["id"] == studentid:  # 是否为要修改的学生
                print("找到了这名学生，可以修改他的信息！")
                while True:  # 输入要修改的信息
                    try:
                        d["name"] = input("请输入姓名：")
                        d["english"] = int(input("请输入英语成绩："))
                        d["python"] = int(input("请输入Python成绩："))
                        d["c"] = int(input("请输入C语言成绩："))
                    except:
                        print("您的输入有误，请重新输入。")
                    else:
                        break  # 跳出循环
                student = str(d)  # 将字典转换为字符串
                wfile.write(student + "\n")   # 将修改的信息写入到文件
                print("修改成功！")
            else:
                wfile.write(student)  # 将未修改的信息写入到文件
    mark = input("是否继续修改其他学生信息？（y/n）：")
    if mark == "y":
        modify()  # 重新执行修改操作


'''5 排序'''


def sort():
    show()  # 显示全部学生信息
    if os.path.exists(filename):  # 判断文件是否存在
        with open(filename, 'r') as file:  # 打开文件
            student_old = file.readlines()  # 读取全部内容
            student_new = []
        for list in student_old:
            d = dict(eval(list))  # 字符串转字典
            student_new.append(d)  # 将转换后的字典添加到列表中
    else:
        return
    ascORdesc = input("请选择（0升序；1降序）：")
    if ascORdesc == "0":  # 按升序排序
        ascORdescBool = False           # 标记变量，为False表示升序排序
    elif ascORdesc == "1":  # 按降序排序
        ascORdescBool = True          # 标记变量，为True表示降序排序
    else:
        print("您的输入有误，请重新输入！")
        sort()  
    mode = input("请选择排序方式（1按英语成绩排序；2按Python成绩排序；3按C语言成绩排序；0按总成绩排序）：")
    if mode == "1":  # 按英语成绩排序
        student_new.sort(key=lambda x: x["english"], reverse=ascORdescBool)
    elif mode == "2":  # 按Python成绩排序
        student_new.sort(key=lambda x: x["python"], reverse=ascORdescBool)
    elif mode == "3":  # 按C语言成绩排序
        student_new.sort(key=lambda x: x["c"], reverse=ascORdescBool)
    elif mode == "0":  # 按总成绩排序
        student_new.sort(key=lambda x: x["english"] + x["python"] + x["c"], reverse=ascORdescBool)
    else:
        print("您的输入有误，请重新输入！")
        sort()
    show_student(student_new)  # 显示排序结果


''' 6 统计学生总数'''


def total():
    if os.path.exists(filename):  # 判断文件是否存在
        with open(filename, 'r') as rfile:  # 打开文件
            student_old = rfile.readlines()  # 读取全部内容
            if student_old:
                print("一共有 %d 名学生！" % len(student_old))
            else:
                print("还没有录入学生信息！")
    else:
        print("暂未保存数据信息...")


''' 7 显示所有学生信息 '''


def show():
    student_new = []
    if os.path.exists(filename):  # 判断文件是否存在
        with open(filename, 'r') as rfile:  # 打开文件
            student_old = rfile.readlines()  # 读取全部内容
        for list in student_old:
            student_new.append(eval(list))  # 将找到的学生信息保存到列表中
        if student_new:
            show_student(student_new)
    else:
        print("暂未保存数据信息...")


# 将保存在列表中的学生信息显示出来
def show_student(studentList):
    if not studentList:
        print("无数据信息 \n")
        return
    format_title = "{:^6}{:^12}\t{:^8}\t{:^10}\t{:^10}\t{:^10}"
    print(format_title.format("ID", "名字", "英语成绩", "Python成绩", "C语言成绩", "总成绩"))
    format_data = "{:^6}{:^12}\t{:^12}\t{:^12}\t{:^12}\t{:^12}"
    for info in studentList:
        print(format_data.format(info.get("id"), info.get("name"), str(info.get("english")), str(info.get("python")),
                                 str(info.get("c")),
                                 str(info.get("english") + info.get("python") + info.get("c")).center(12)))


if __name__ == "__main__":
    main()

定义函数，给定一个列表作为函数参数，将列表中的非数字字符去除

'''定义函数，给定一个列表作为函数参数，将列表中的非数字字符去除。'''
class list:
    def __init__(self,alist):
        self.alist=alist
    def remove_str(self):

        a=""
        for i in self.alist:
            b=str(i)
            a+=b
        "".join (filter(str.isdigit,a))
        print("".join(filter(str.isdigit,a)))
a=list([1,2,3,"q",6,"sd","[][]{"])
a.remove_str()

给定几位数，查看数根(使用函数实现)

def numRoot(num):
    '''定义数根函数'''
    if len(num) == 1:
        return int(num)
    else:
        nums = []
        for i in range(len(num)):
            # 对字符串进行遍历
            nums.append(int(num[i]))
        if sum(nums) >= 10:
            # 如果数值加起来大于 10
            numRoot(str(sum(nums)))
        else:
            # 输出树根
            print(sum(nums))

num = input("请输入一个数，查看它的数根")
numRoot(num)

水果系统(面向过程,面向对象)

fruit = []

def menu():
    print(
        '''
        ********************水果超市********************  （面向对象，面向过程）
                1. 查询全部水果
                2. 查询指定名称的水果
                3. 增加水果（增加到数据库）
                4. 修改水果数量或者价格
                5. 删除水果
                6. 按照价格排序
                7. 退出系统
        ***********************************************
        '''
        )

def showFruit():
    '''功能1 查询全部水果'''
    print('-' * 30)
    print("水果的信息如下:")
    print('-' * 30)
    print('序号 水果名  价格  数量')
    fru_id = 1
    for fru_temp in fruit:
        print("%s   %s   %s    %s "%(fru_id,fru_temp['name'],fru_temp['price'],fru_temp['num']))
        fru_id += 1

def searchFruitName():
    '''功能2 查询指定名称的水果'''
    showFruit()
    fru_name = input("请输入想要查询的水果名称")
    fru_id = 1
    for fru in fruit:
        if fru_name in fru['name']:
            print("该水果信息如下:")
            print("%d   %s  %s    %s " % (fru_id, fru['name'], fru['price'], fru['num']))
            return
        fru_id += 1
    print("没有查询到该水果名称")


def addFruit():
    '''功能3 增加水果（增加到数据库）'''
    newFruitName = input('请输入新水果的名称')
    newFruitPrice = input('请输入新水果的价格')
    newFruitNum =  input('请输入新水果的数量')

    newFruit = {}
    newFruit['name'] = newFruitName
    newFruit['price'] = newFruitPrice
    newFruit['num'] = newFruitNum

    fruit.append(newFruit)


def changeFruit():
    '''功能4 修改水果数量或者价格'''
    showFruit()

    fru_id = int(input("请输入需要修改的水果的序号: "))

    changeFruitName = input('请输入修改后的水果的名称')
    changeFruitPrice = input('请输入修改后的水果的价格')
    changeFruitNum = input('请输入修改后的水果的数量')

    fruit[fru_id - 1]['name'] = changeFruitName
    fruit[fru_id - 1]['price'] = changeFruitPrice
    fruit[fru_id - 1]['num'] = changeFruitNum

def delFruit():
    '''功能5 删除水果'''
    showFruit()
    delFruitId = int(input('请输入要删除的序号:'))
    del fruit[delFruitId - 1]

def sortFruit():
    '''功能6 按照价格排序'''
    showFruit()
    sortStandard = input("请选择(0升序；1降序):")
    if sortStandard == "0":
        sortStandard = True
    elif sortStandard == "1":
        sortStandard = False
    else:
        print("您的输入有误，请重新输入！")
    fruit.sort(key = lambda x:x['price'],reverse = sortStandard)
    showFruit()

def exitSystem():
    '''功能7 退出系统'''
    print("您已经退出水果超市系统")
    exit()

def main():
    notExit = True
    while notExit:
        menu()
        try:
            option = int(input("请选择功能:"))
        except Exception as e:
            print("请重新输入")
        if option in [i for i in range(1,8)]:
            if option == 1:
                showFruit()
            elif option == 2:
                searchFruitName()
            elif option == 3:
                addFruit()
            elif option == 4:
                changeFruit()
            elif option == 5:
                delFruit()
            elif option == 6:
                sortFruit()
            elif option == 7:
                notExit = False
                exitSystem()


if __name__ == '__main__':
    main()

class FruitMarket():
    def __init__(self):
        self.fruit = []

    def showFruit(self):
        '''功能1 查询全部水果'''
        print('-' * 30)
        print("水果的信息如下:")
        print('-' * 30)
        print('序号 水果名  价格  数量')
        fru_id = 1
        for fru_temp in self.fruit:
            print("%s   %s   %s    %s " % (fru_id, fru_temp['name'], fru_temp['price'], fru_temp['num']))
            fru_id += 1

    def searchFruitName(self):
        '''功能2 查询指定名称的水果'''
        self.showFruit()
        fru_name = input("请输入想要查询的水果名称")
        fru_id = 1
        for fru in self.fruit:
            if fru_name in fru['name']:
                print("该水果信息如下:")
                print("%d   %s  %s    %s " % (fru_id, fru['name'], fru['price'], fru['num']))
                return
            fru_id += 1
        print("没有查询到该水果名称")

    def addFruit(self):
        '''功能3 增加水果（增加到数据库）'''
        newFruitName = input('请输入新水果的名称')
        newFruitPrice = input('请输入新水果的价格')
        newFruitNum = input('请输入新水果的数量')

        newFruit = {}
        newFruit['name'] = newFruitName
        newFruit['price'] = newFruitPrice
        newFruit['num'] = newFruitNum

        self.fruit.append(newFruit)

    def changeFruit(self):
        '''功能4 修改水果数量或者价格'''
        self.showFruit()

        fru_id = int(input("请输入需要修改的水果的序号: "))

        changeFruitName = input('请输入修改后的水果的名称')
        changeFruitPrice = input('请输入修改后的水果的价格')
        changeFruitNum = input('请输入修改后的水果的数量')

        self.fruit[fru_id - 1]['name'] = changeFruitName
        self.fruit[fru_id - 1]['price'] = changeFruitPrice
        self.fruit[fru_id - 1]['num'] = changeFruitNum

    def delFruit(self):
        '''功能5 删除水果'''
        self.showFruit()
        delFruitId = int(input('请输入要删除的序号:'))
        del self.fruit[delFruitId - 1]

    def sortFruit(self):
        '''功能6 按照价格排序'''
        self.showFruit()
        sortStandard = input("请选择(0升序；1降序):")
        if sortStandard == "0":
            sortStandard = True
        elif sortStandard == "1":
            sortStandard = False
        else:
            print("您的输入有误，请重新输入！")
        self.fruit.sort(key=lambda x: x['price'], reverse=sortStandard)
        self.showFruit()

    def exitSystem(self):
        '''功能7 退出系统'''
        print("您已经退出水果超市系统")
        exit()
def menu( ):
    print(
        '''
        ********************水果超市********************  （面向对象，面向过程）
                1. 查询全部水果
                2. 查询指定名称的水果
                3. 增加水果（增加到数据库）
                4. 修改水果数量或者价格
                5. 删除水果
                6. 按照价格排序
                7. 退出系统
        ***********************************************
        '''
    )

fruitmarket = FruitMarket()

def main():
    notExit = True
    while notExit:
        menu()
        try:
            option = int(input("请选择功能:"))
        except Exception as e:
            print("请重新输入")
        if option == 1:
            fruitmarket.showFruit()
        elif option == 2:
            fruitmarket.searchFruitName()
        elif option == 3:
            fruitmarket.addFruit()
        elif option == 4:
            fruitmarket.changeFruit()
        elif option == 5:
            fruitmarket.delFruit()
        elif option == 6:
            fruitmarket.sortFruit()
        elif option == 7:
            notExit = False
            fruitmarket.exitSystem()



if __name__ == '__main__':
    main()

matplotlib基础汇总_01

灰度化处理就是将一幅色彩图像转化为灰度图像的过程。彩色图像分为R，G，B三个分量，
分别显示出红绿蓝等各种颜色，灰度化就是使彩色的R，G，B分量相等的过程。
灰度值大的像素点比较亮（像素值最大为255，为白色），反之比较暗（像素最下为0，为黑色）。
    图像灰度化的算法主要有以下3种：
     

data2 = data.mean(axis = 2)

data3 = np.dot(data,[0.299,0.587,0.114])

Matplotlib中的基本图表包括的元素


x轴和y轴
水平和垂直的轴线

x轴和y轴刻度
刻度标示坐标轴的分隔，包括最小刻度和最大刻度

x轴和y轴刻度标签
表示特定坐标轴的值

绘图区域
实际绘图的区域

绘制一条曲线

x = np.arange(0.0,6.0,0.01)
plt.plot(x, x**2)
plt.show()

绘制多条曲线

x = np.arange(1, 5,0.01)
plt.plot(x, x**2)
plt.plot(x, x**3.0)
plt.plot(x, x*3.0)
plt.show()


x = np.arange(1, 5)
plt.plot(x, x*1.5, x, x*3.0, x, x/3.0)
plt.show()

绘制网格线

设置grid参数（参数与plot函数相同）
lw代表linewidth，线的粗细
alpha表示线的明暗程度

# 使用子图显示不同网格线对比
fig  = plt.figure(figsize=(20,3))

x = np.linspace(0, 5, 100)

# 使用默认网格设置
ax1 = fig.add_subplot(131)
ax1.plot(x, x**2, x, x**3,lw=2) 
ax1.grid(True) # 显式网格线

# 对网格线进行设置
ax2 = fig.add_subplot(132)
ax2.plot(x, x**2, x, x**4, lw=2)
ax2.grid(color='r', alpha=0.5, linestyle='dashed', linewidth=0.5) # grid函数中用与plot函数同样的参数设置网格线
# 对网格线进行设置
ax3 = fig.add_subplot(133)
ax3.plot(x, x**2, x, x**4, lw=2)
ax3.grid(color='r', alpha=0.5, linestyle='-.', linewidth=0.5) # grid函数中用与plot函数同样的参数设置网格线

坐标轴界限 axis 方法

x = np.arange(1, 5)
plt.plot(x, x*1.5, x, x*3.0, x, x/3.0)
# plt.axis() # shows the current axis limits values；如果axis方法没有任何参数，则返回当前坐标轴的上下限
# (1.0, 4.0, 0.0, 12.0)
# plt.axis([0, 15, -5, 13]) # set new axes limits；axis方法中有参数，设置坐标轴的上下限；参数顺序为[xmin, xmax, ymin, ymax]
plt.axis(xmax=5,ymax=23) # 可使用xmax,ymax参数
plt.show()


设置紧凑型坐标轴
x = np.arange(1, 5)
plt.plot(x, x*1.5, x, x*3.0, x, x/3.0)
plt.axis('tight') # 紧凑型坐标轴
plt.show()



plt除了axis方法设置坐标轴范围，还可以通过xlim，ylim设置坐标轴范围
x = np.arange(1, 5)
plt.plot(x, x*1.5, x, x*3.0, x, x/3.0)
plt.xlim([0, 5]) # ylim([ymin, ymax])
plt.ylim([-1, 13]) # xlim([xmin, xmax])
plt.show()

坐标轴标签

plt.plot([1, 3, 2, 4])
plt.xlabel('This is the X axis')
plt.ylabel('This is the Y axis')
plt.show()

坐标轴标题

plt.plot([1, 3, 2, 4])
plt.title('Simple plot')
plt.show()

label参数为'_nolegend_'，则图例中不显示


x = np.arange(1, 5)
plt.plot(x, x*1.5, label = '_nolegend_') # label参数为'_nolegend_'，则图例中不显示
plt.plot(x, x*3.0, label='Fast')
plt.plot(x, x/3.0, label='Slow')
plt.legend()
plt.show()

图例 legend

legend方法
两种传参方法：


【推荐使用】在plot函数中增加label参数
在legend方法中传入字符串列表

方法一：
x = np.arange(1, 5)
plt.plot(x, x*1.5, label='Normal') # 在plot函数中增加label参数
plt.plot(x, x*3.0, label='Fast')
plt.plot(x, x/3.0, label='Slow')
plt.legend()
plt.show()

方法二：
x = np.arange(1, 5)
plt.plot(x, x*1.5)
plt.plot(x, x*3.0)
plt.plot(x, x/3.0)
plt.legend(['Normal', 'Fast', 'Slow']) # 在legend方法中传入字符串列表
plt.show()

loc 参数

x = np.arange(1, 5)
plt.plot(x, x*1.5, label='Normal')
plt.plot(x, x*3.0, label='Fast')
plt.plot(x, x/3.0, label='Slow')
plt.legend(loc=10)
plt.show()

loc参数可以是2元素的元组，表示图例左下角的坐标

x = np.arange(1, 5)
plt.plot(x, x*1.5, label='Normal')
plt.plot(x, x*3.0, label='Fast')
plt.plot(x, x/3.0, label='Slow')
plt.legend(loc=(0,1)) # loc参数可以是2元素的元组，表示图例左下角的坐标
plt.show()

ncol参数控制图例中有几列

x = np.arange(1, 5)
plt.plot(x, x*1.5, label='Normal')
plt.plot(x, x*3.0, label='Fast')
plt.plot(x, x/3.0, label='Slow')
plt.legend(loc=0, ncol=2) # ncol控制图例中有几列
plt.show()

linestyle 属性

plt.plot(np.random.randn(1000).cumsum(), linestyle = ':',marker = '.', label='one')
plt.plot(np.random.randn(1000).cumsum(), 'r--', label='two') 
plt.plot(np.random.randn(1000).cumsum(), 'b.', label='three')
plt.legend(loc='best') # loc='best'
plt.show()

保存图片

filename
含有文件路径的字符串或Python的文件型对象。图像格式由文件扩展名推断得出，例如，.pdf推断出PDF，.png推断出PNG （“png”、“pdf”、“svg”、“ps”、“eps”……）
dpi
图像分辨率（每英寸点数），默认为100
facecolor
图像的背景色，默认为“w”（白色）


x = np.random.randn(1000).cumsum()
fig = plt.figure(figsize = (10,3))

splt = fig.add_subplot(111)
splt.plot(x)

fig.savefig(filename = "filena.eps",dpi = 100,facecolor = 'g') 

matplotlib基础汇总_02

设置plot的风格和样式

点和线的样式

颜色

参数color或c

五种定义颜色值的方式

别名
color='r'

合法的HTML颜色名
color = 'red'

HTML十六进制字符串
color = '#eeefff'

归一化到[0, 1]的RGB元组
color = (0.3, 0.3, 0.4)

灰度
color = (0.1)

透明度

y = np.arange(1, 3)
plt.plot(y, c="red", alpha=0.1);    # 设置透明度
plt.plot(y+1, c="red", alpha=0.5);
plt.plot(y+2, c="red", alpha=0.9);

设置背景色
通过plt.subplot()方法传入facecolor参数，来设置坐标轴的背景色

plt.subplot(facecolor='orange');
plt.plot(np.random.randn(10),np.arange(1,11))

线型

不同宽度破折线

# 第一段线2个点的宽度，接下来的空白区5个点的宽度，第二段线5个点的宽度，空白区2个点的宽度，以此类推
plt.plot(np.linspace(-np.pi, np.pi, 256, endpoint=True),
         np.cos(np.linspace(-np.pi, np.pi, 256, endpoint=True)), 
         dashes=[2, 5, 5, 2]);

点型 

y = np.arange(1, 3, 0.2)
plt.plot(y, '1', y+0.5, '2', y+1, '3', y+1.5,'4');
plt.plot(y+2, '3') #不声明marker，默认ls = None
plt.plot(y+2.5,marker = '3') #声明了marker，ls 默认是实线
plt.show()

多参数连用

颜色、点型、线型

x = np.linspace(0, 5, 10)
plt.plot(x,3*x,'r-.')
plt.plot(x, x**2, 'b^:') # blue line with dots
plt.plot(x, x**3, 'go-.') # green dashed line
plt.show()

更多点和线的设置

y = np.arange(1, 3, 0.3)
plt.plot(y, color='blue', 
         linestyle='dashdot', 
         linewidth=4, marker='o',
         markerfacecolor='red', 
         markeredgecolor='black', 
         markeredgewidth=3, 
         markersize=12);
plt.show()

在一条语句中为多个曲线进行设置

多个曲线同一设置¶
plt.plot(x1, y1, x2, y2, fmt, ...)


多个曲线不同设置¶
plt.plot(x1, y1, fmt1, x2, y2, fmt2, ...)

在一条语句中为多个曲线进行设置


多个曲线同一设置¶
plt.plot(x1, y1, x2, y2, fmt, ...)


多个曲线不同设置¶
plt.plot(x1, y1, fmt1, x2, y2, fmt2, ...)

三种设置方式

向方法传入关键字参数


对实例使用一系列的setter方法

x = np.arange(0,10)
y = np.random.randint(10,30,size = 10)
line,= plt.plot(x, y)
line2 = plt.plot(x,y*2,x,y*3)
line.set_linewidth(5)
line2[1].set_marker('o')
print(line,line2)


使用setp()方法
line = plt.plot(x, y)
plt.setp(line, 'linewidth', 1.5,'color','r','marker','o','linestyle','--')

X、Y轴坐标刻度

xticks()和yticks()方法

x = [5, 3, 7, 2, 4, 1]
plt.plot(x);
plt.xticks(range(len(x)), ['a', 'b', 'c', 'd', 'e', 'f']); # 传入位置和标签参数，以修改坐标轴刻度
plt.yticks(range(1, 8, 2));
plt.show()

面向对象方法

set_xticks、set_yticks、set_xticklabels、set_yticklabels方法


fig = plt.figure(figsize=(10, 4))
ax = fig.add_subplot(111)

x = np.linspace(0, 5, 100)

ax.plot(x, x**2, x, x**3, lw=2)

ax.set_xticks([1, 2, 3, 4, 5])
ax.set_xticklabels(['a','b','c','d','e'], fontsize=18)

yticks = [0, 50, 100, 150]
ax.set_yticks(yticks)
ax.set_yticklabels([y for y in yticks], fontsize=18); # use LaTeX formatted labels

正弦余弦：LaTex语法，用$\pi$等表达式在图表上写上希腊字母

x = np.arange(-np.pi,np.pi,0.01)
plt.figure(figsize=(12,9))
plt.plot(x,np.sin(x),x,np.cos(x))

plt.axis([x.min()-1,x.max()+1,-1.2,1.2])

#xticks:参数一刻度，参数二，对应刻度上的值
plt.xticks(np.arange(-np.pi,np.pi+1,np.pi/2),
           ['$-\delta$','$-\pi$/2','0','$\pi$/2','$\pi$'],size = 20)

plt.yticks([-1,0,1],['min','0','max'],size = 20)

plt.show() 

matplotlib基础汇总_03

四图

直方图

【直方图的参数只有一个x！！！不像条形图需要传入x,y】
hist()的参数
bins
可以是一个bin数量的整数值，也可以是表示bin的一个序列。默认值为10
normed
如果值为True，直方图的值将进行归一化处理，形成概率密度，默认值为False
color
指定直方图的颜色。可以是单一颜色值或颜色的序列。如果指定了多个数据集合，颜色序列将会设置为相同的顺序。如果未指定，将会使用一个默认的线条颜色
orientation
通过设置orientation为horizontal创建水平直方图。默认值为vertical


x = np.random.randint(5,size = 5)
display(x)
plt.hist(x,histtype = 'bar'); # 默认绘制10个bin
plt.show()

普通直方图/累计直方图

n = np.random.randn(10000)

fig,axes = plt.subplots(1,2,figsize = (12,4))
axes[0].hist(n,bins = 50)#普通直方图
axes[0].set_title('Default histogram')
axes[0].set_xlim(min(n),max(n))

axes[1].hist(n,bins = 50,cumulative = True)# 累计直方图
axes[1].set_title('Cumulative detailed histogram')
axes[1].set_xlim(min(n),max(n))

正太分布

u = 100 #数学期望
s = 15 #方差
x = np.random.normal(u,s,1000) # 生成正太分布数据

ax = plt.gca() #获取当前图表
ax.set_xlabel('Value')
ax.set_ylabel('Frequency') #设置x，y轴标题

ax.set_title("Histogram normal u = 100 s = 15") #设置图表标题

ax.hist(x,bins = 100,color = 'r',orientation='horizontal')
plt.show()

条形图

bar 

# 第一个参数为条形左下角的x轴坐标，第二个参数为条形的高度；
# matplotlib会自动设置条形的宽度，本例中条形宽0.8
plt.bar([1, 2, 3], [3, 2, 5]); 
plt.show()

# width参数设置条形宽度；color参数设置条形颜色；bottom参数设置条形底部的垂直坐标
plt.bar([1, 2, 3], [3, 2, 5], width=0.5, color='r', bottom=1);
plt.ylim([0, 7])
plt.show()

# 例子：绘制并列条形图

data1 = 10*np.random.rand(5)
data2 = 10*np.random.rand(5)
data3 = 10*np.random.rand(5)

locs = np.arange(1, len(data1)+1)
width = 0.27

plt.bar(locs, data1, width=width);
plt.bar(locs+width, data2, width=width, color='red');
plt.bar(locs+2*width, data3, width=width, color='green') ;
plt.xticks(locs + width*1, locs);
plt.show()

barh

plt.barh([1, 2, 3], [3, 2, 5],height = 0.27,color = 'yellow');
plt.show()

饼图

【饼图也只有一个参数x！】
pie()
饼图适合展示各部分占总体的比例，条形图适合比较各部分的大小

plt.figure(figsize = (4,4)) # 饼图绘制正方形
x = [45,35,20] #百分比
labels = ['Cats','Dogs','Fishes'] #每个区域名称
plt.pie(x,labels = labels)
plt.show()

plt.figure(figsize=(4, 4));
x = [0.1, 0.2, 0.3] # 当各部分之和小于1时，则不计算各部分占总体的比例，饼的大小是数值和1之比
labels = ['Cats', 'Dogs', 'Fishes']
plt.pie(x, labels=labels); # labels参数可以设置各区域标签
plt.show()

# labels参数设置每一块的标签；labeldistance参数设置标签距离圆心的距离（比例值）
# autopct参数设置比例值的显示格式（%1.1f%%）；pctdistance参数设置比例值文字距离圆心的距离
# explode参数设置每一块顶点距圆形的长度（比例值）；colors参数设置每一块的颜色；
# shadow参数为布尔值，设置是否绘制阴影

plt.figure(figsize=(4, 4));
x = [4, 9, 21, 55, 30, 18]
labels = ['Swiss', 'Austria', 'Spain', 'Italy', 'France', 'Benelux']
explode = [0.2, 0.1, 0, 0, 0.1, 0]
colors = ['r', 'k', 'b', 'm', 'c', 'g']
plt.pie(x, 
        labels=labels, 
        labeldistance=1.2,
        explode=explode, 
        colors=colors, 
        autopct='%1.1f%%', 
        pctdistance=0.5, 
        shadow=True);
plt.show()

散点图

【散点图需要两个参数x,y，但此时x不是表示x轴的刻度，而是每个点的横坐标！】
scatter()

# s参数设置散点的大小；c参数设置散点的颜色；marker参数设置散点的形状
x = np.random.randn(1000)
y = np.random.randn(1000)
size = 50*abs(np.random.randn(1000))
colors = np.random.randint(16777215,size = 1000)


li = []
for color in colors:
    a = hex(color)
    str1 = a[2:]
    l = len(str1)
    for i in range(1,7-l):
        str1 = '0'+str1
    str1 = "#" + str1
    li.append(str1)

plt.scatter(x, y,s = size, c=li, marker='d');
plt.show()

import numpy as np
import pandas as pd
from pandas import Series,DataFrame

import matplotlib.pyplot as plt

x = np.random.randn(1000)

y1 = np.random.randn(1000)
y2 = 1.2 + np.exp(x) #exp(x) 返回的是e的x次方

ax1 = plt.subplot(121)
plt.scatter(x,y1,color = 'purple',alpha = 0.3,edgecolors = 'white',label = 'no correl')
plt.xlabel('no correlation')
plt.grid(True)
plt.legend()


ax2 = plt.subplot(122)
plt.scatter(x,y2,color = 'green',alpha = 0.3,edgecolors = 'gray',label = 'correl')
plt.xlabel('correlation')
plt.grid(True)
plt.legend()

plt.show()

图形内的文字、注释、箭头

文字

x = np.arange(0, 7, .01)
y = np.sin(x)
plt.plot(x, y);
plt.text(0.1, -0.04, 'sin(0)=0'); # 位置参数是坐标
plt.show()

注释


# xy参数设置箭头指示的位置，xytext参数设置注释文字的位置
# arrowprops参数以字典的形式设置箭头的样式
# width参数设置箭头长方形部分的宽度，headlength参数设置箭头尖端的长度，
# headwidth参数设置箭头尖端底部的宽度，shrink参数设置箭头顶点、尾部与指示点、注释文字的距离（比例值）

y = [13, 11, 13, 12, 13, 10, 30, 12, 11, 13, 12, 12, 12, 11, 12]
plt.plot(y);
plt.ylim(ymax=35); # 为了让注释不会超出图的范围，需要调整y坐标轴的界限
plt.annotate('this spot must really\nmean something', xy=(6, 30), xytext=(8, 31.5),
             arrowprops=dict(width=15, headlength=20, headwidth=20, facecolor='black', shrink=0.1));
plt.show()

# 生成3个正态分布数据数据集
x1 = np.random.normal(30, 3, 100)
x2 = np.random.normal(20, 2, 100)
x3 = np.random.normal(10, 3, 100)

# 绘制3个数据集，并为每个plot指定一个字符串标签
plt.plot(x1, label='plot') # 如果不想在图例中显示标签，可以将标签设置为_nolegend_
plt.plot(x2, label='2nd plot')
plt.plot(x3, label='last plot')

# 绘制图例
plt.legend(bbox_to_anchor=(0, 1.02, 1, 0.102), # 指定边界框起始位置为(0, 1.02)，并设置宽度为1，高度为0.102
           ncol=3, # 设置列数为3，默认值为1
           mode="expand", # mode为None或者expand，当为expand时，图例框会扩展至整个坐标轴区域
           borderaxespad=0.) # 指定坐标轴和图例边界之间的间距

# 绘制注解
plt.annotate("Important value", # 注解文本的内容
             xy=(55,20), # 箭头终点所在位置
             xytext=(5, 38), # 注解文本的起始位置，箭头由xytext指向xy坐标位置
             arrowprops=dict(arrowstyle='->')); # arrowprops字典定义箭头属性，此处用arrowstyle定义箭头风格

箭头

matplotlib基础汇总_04

3D图形

导包


import numpy as np
import matplotlib.pyplot as plt
#3d图形必须的
from mpl_toolkits.mplot3d.axes3d import Axes3D
%matplotlib inline

生成数据


#系数，由X，Y生成Z
a = 0.7
b =  np.pi 

#计算Z轴的值
def mk_Z(X, Y):
    return 2 + a - 2 * np.cos(X) * np.cos(Y) - a * np.cos(b - 2*X)

#生成X，Y，Z
x = np.linspace(0, 2*np.pi, 100)
y = np.linspace(0, 2*np.pi, 100)
X,Y = np.meshgrid(x, y)
Z = mk_Z(X, Y)

绘制图形

fig = plt.figure(figsize=(14,6))

#创建3d的视图，使用属性projection
ax = fig.add_subplot(1, 2, 1, projection='3d')

ax.plot_surface(X,Y,Z,rstride = 5,cstride = 5)

#创建3d视图，使用colorbar，添加颜色柱
ax = fig.add_subplot(1, 2, 2, projection='3d')
p = ax.plot_surface(X, Y, Z, rstride=5, cstride=5, cmap='rainbow', antialiased=True)
cb = fig.colorbar(p, shrink=0.5)

玫瑰图

#极坐标条形图
def showRose(values,title):
    
    max_value = values.max()
    # 分为8个面元
    N = 8
    # 面元的分隔角度
    angle = np.arange(0.,2 * np.pi, 2 * np.pi / N)
    # 每个面元的大小（半径）
    radius = np.array(values)
    # 设置极坐标条形图
    
    plt.axes([0, 0, 2, 2], polar=True,facecolor = 'g')
    
    colors = [(1 - x/max_value, 1 - x/max_value, 0.75) for x in radius]
    # 画图
    
    plt.bar(angle, radius, width=(2*np.pi/N), bottom=0.0, color=colors)
    plt.title(title,x=0.2, fontsize=20)

绘制图形

#拉韦纳(Ravenna)又译“腊万纳”“拉文纳”“拉温拿”。意大利北部城市。位于距亚得里亚海10公里的沿海平原上


data = np.load('Ravenna_wind.npy')
hist, angle = np.histogram(data,8,[0,360])
showRose(hist,'Ravenna')

城市气候与海洋关系

导包

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame
%matplotlib inline

加载数据

#意大利小镇费拉拉
ferrara1 = pd.read_csv('./ferrara_150715.csv')
ferrara2 = pd.read_csv('./ferrara_250715.csv')
ferrara3 = pd.read_csv('./ferrara_270615.csv')
ferrara = pd.concat([ferrara1,ferrara2,ferrara3],ignore_index=True) 

去除没用的列

asti.drop(['Unnamed: 0'],axis = 1,inplace=True)

bologna.drop(['Unnamed: 0'],axis = 1,inplace=True)

cesena.drop(['Unnamed: 0'],axis = 1,inplace=True)

ferrara.drop(['Unnamed: 0'],axis = 1,inplace=True)

mantova.drop(['Unnamed: 0'],axis = 1,inplace=True)

milano.drop(['Unnamed: 0'],axis = 1,inplace=True)

piacenza.drop(['Unnamed: 0'],axis = 1,inplace=True)

ravenna.drop(['Unnamed: 0'],axis = 1,inplace=True)

torino.drop(['Unnamed: 0'],axis = 1,inplace=True)

获取个城市距离海边距离，最高温度，最低温度，最高湿度，最低湿度


dist = [ravenna['dist'][0],
     cesena['dist'][0],
     faenza['dist'][0],
     ferrara['dist'][0],
     bologna['dist'][0],
     mantova['dist'][0],
     piacenza['dist'][0],
     milano['dist'][0],
     asti['dist'][0],
     torino['dist'][0]
]
temp_max = [ravenna['temp'].max(),
     cesena['temp'].max(),
     faenza['temp'].max(),
     ferrara['temp'].max(),
     bologna['temp'].max(),
     mantova['temp'].max(),
     piacenza['temp'].max(),
     milano['temp'].max(),
     asti['temp'].max(),
     torino['temp'].max()
]
temp_min = [ravenna['temp'].min(),
     cesena['temp'].min(),
     faenza['temp'].min(),
     ferrara['temp'].min(),
     bologna['temp'].min(),
     mantova['temp'].min(),
     piacenza['temp'].min(),
     milano['temp'].min(),
     asti['temp'].min(),
     torino['temp'].min()
]
hum_min = [ravenna['humidity'].min(),
     cesena['humidity'].min(),
     faenza['humidity'].min(),
     ferrara['humidity'].min(),
     bologna['humidity'].min(),
     mantova['humidity'].min(),
     piacenza['humidity'].min(),
     milano['humidity'].min(),
     asti['humidity'].min(),
     torino['humidity'].min()
]
hum_max = [ravenna['humidity'].max(),
     cesena['humidity'].max(),
     faenza['humidity'].max(),
     ferrara['humidity'].max(),
     bologna['humidity'].max(),
     mantova['humidity'].max(),
     piacenza['humidity'].max(),
     milano['humidity'].max(),
     asti['humidity'].max(),
     torino['humidity'].max()
]

显示最高温度与离海远近的关系

plt.axis([0,400,32,35])
plt.plot(dist,temp_max,'ro')

根据距海远近划分数据


观察发现，离海近的可以形成一条直线，离海远的也能形成一条直线。
首先使用numpy：把列表转换为numpy数组，用于后续计算。
分别以100公里和50公里为分界点，划分为离海近和离海远的两组数据

# 把列表转换为numpy数组
x = np.array(dist)
display('x:',x)
y = np.array(temp_max)
display('y:',y)

# 离海近的一组数据
x1 = x[x<100]
x1 = x1.reshape((x1.size,1))
display('x1:',x1)
y1 = y[x<100]
display('y1:',y1)

# 离海远的一组数据
x2 = x[x>50]
x2 = x2.reshape((x2.size,1))
display('x2:',x2)
y2 = y[x>50]
display('y2:',y2)

机器学习计算回归模型


from sklearn.svm import SVR
svr_lin1 = SVR(kernel='linear', C=1e3)
svr_lin2 = SVR(kernel='linear', C=1e3)
svr_lin1.fit(x1, y1)
svr_lin2.fit(x2, y2)
xp1 = np.arange(10,100,10).reshape((9,1))
xp2 = np.arange(50,400,50).reshape((7,1))
yp1 = svr_lin1.predict(xp1)
yp2 = svr_lin2.predict(xp2)

绘制回归曲线


plt.plot(xp1, yp1, c='r', label='Strong sea effect')
plt.plot(xp2, yp2, c='b', label='Light sea effect')
#plt.axis('tight')
plt.legend()
plt.scatter(x, y, c='k', label='data')

最低温度与海洋距离关系

plt.axis((0,400,16,21))
plt.plot(dist,temp_min,'bo')

最低湿度与海洋距离关系


plt.axis([0,400,70,120])
plt.plot(dist,hum_min,'bo')

最高湿度与海洋距离关系

plt.axis([0,400,70,120])
plt.plot(dist,hum_max,'bo')

平均湿度与海洋距离的关系

hum_mean = [ravenna['humidity'].mean(),
     cesena['humidity'].mean(),
     faenza['humidity'].mean(),
     ferrara['humidity'].mean(),
     bologna['humidity'].mean(),
     mantova['humidity'].mean(),
     piacenza['humidity'].mean(),
     milano['humidity'].mean(),
     asti['humidity'].mean(),
     torino['humidity'].mean()
]
plt.plot(dist,hum_mean,'bo')

风速与风向的关系

plt.plot(ravenna['wind_deg'],ravenna['wind_speed'],'ro')

在子图中，同时比较风向与湿度和风力的关系

plt.subplot(211)
plt.plot(cesena['wind_deg'],cesena['humidity'],'bo')
plt.subplot(212)
plt.plot(cesena['wind_deg'],cesena['wind_speed'],'bo')

玫瑰图

def showRoseWind(values,city_name):
    '''
    查看风向图，半径越大，代表这个方向上的风越多
    '''
    max_value = values.max()
    # 分为8个面元
    N = 8
    # 面元的分隔角度
    theta = np.arange(0.,2 * np.pi, 2 * np.pi / N)
    # 每个面元的大小（半径）
    radii = np.array(values)
    # 设置极坐标条形图
    plt.axes([0.025, 0.025, 0.95, 0.95], polar=True)
    colors = [(1 - x/max_value, 1 - x/max_value, 0.75) for x in radii]
    # 画图
    plt.bar(theta, radii, width=(2*np.pi/N), bottom=0.0, color=colors)
    plt.title(city_name,x=0.2, fontsize=20)

用numpy创建一个直方图，将360度划分为8个面元，将数据分类到这8个面元中


hist, bin = np.histogram(ravenna['wind_deg'],8,[0,360])
print(hist)
hist = hist/hist.sum()
print(bin)
showRoseWind(hist,'Ravenna')

计算米兰各个方向的风速

print(milano[milano['wind_deg']<45]['wind_speed'].mean())
print(milano[(milano['wind_deg']>44) & (milano['wind_deg']<90)]['wind_speed'].mean())
print(milano[(milano['wind_deg']>89) & (milano['wind_deg']<135)]['wind_speed'].mean())
print(milano[(milano['wind_deg']>134) & (milano['wind_deg']<180)]['wind_speed'].mean())
print(milano[(milano['wind_deg']>179) & (milano['wind_deg']<225)]['wind_speed'].mean())
print(milano[(milano['wind_deg']>224) & (milano['wind_deg']<270)]['wind_speed'].mean())
print(milano[(milano['wind_deg']>269) & (milano['wind_deg']<315)]['wind_speed'].mean())
print(milano[milano['wind_deg']>314]['wind_speed'].mean())

将各个方向风速保存到列表中

degs = np.arange(45,361,45)
tmp =  []
for deg in degs:
    tmp.append(milano[(milano['wind_deg']>(deg-46)) & (milano['wind_deg']<deg)]['wind_speed'].mean())
speeds = np.array(tmp)
print(speeds)

画出各个方向的风速

N = 8
theta = np.arange(0.,2 * np.pi, 2 * np.pi / N)
radii = np.array(speeds)
plt.axes([0.025, 0.025, 0.95, 0.95], polar=True)
colors = [(1-x/10.0, 1-x/10.0, 0.75) for x in radii]
bars = plt.bar(theta, radii, width=(2*np.pi/N), bottom=0.0, color=colors)
plt.title('Milano',x=0.2, fontsize=20)

抽取函数

def RoseWind_Speed(city):
   degs = np.arange(45,361,45)
   tmp =  []
   for deg in degs:
      tmp.append(city[(city['wind_deg']>(deg-46)) & (city['wind_deg']<deg)]['wind_speed'].mean())
   return np.array(tmp)


def showRoseWind_Speed(speeds,city_name):
   N = 8
   theta = np.arange(0.,2 * np.pi, 2 * np.pi / N)
   radii = np.array(speeds)
   plt.axes([0.025, 0.025, 0.95, 0.95], polar=True)
   colors = [(1-x/10.0, 1-x/10.0, 0.75) for x in radii]
   bars = plt.bar(theta, radii, width=(2*np.pi/N), bottom=0.0, color=colors)
   plt.title(city_name,x=0.2, fontsize=20)

函数调用

showRoseWind_Speed(RoseWind_Speed(ravenna),'Ravenna')

根据列表的值来显示每一个元素出现的次数

lst = ['中雨','雷阵雨','中到大雨','阴','多云','晴','中雨']
dic = {}

for i in lst:
    if i not in dic:
        dic[i] = lst.count(i)

print(dic)

钻石和玻璃球游戏(钻石位置固定)

'''
开始，你可以随意选择一个抽屉，在开启它之前，
主持人会开启另外一个抽屉，露出抽屉里的玻璃球。
这时，主持人会给你一次更换自己选择的机会。
请自己认真分析一下“不换选择能有更高的几率获得钻石，
还是换选择能有更高的几率获得钻石？或几率没有发生变化？”写出你分析的思路和结果。
设法编写python程序验证自己的想法，
验证的结果支持了你的分析结果，还是没有支持你的分析结果，
请写出结果，并附上你的程序代码，并在程序代码中通过注释说明你解决问题的思路。
（提示：可以借助随机数函数完成此程序）
'''
import random
print("钻石和玻璃球的游戏开始了")
# 摆在你面前有3个关闭的抽屉
lst_dic = [{'抽屉':'钻石'},{'抽屉':'玻璃球'},{'抽屉':'玻璃球'}]

# 定义钻石
zs = 0
# 定义玻璃球
blq = 0

def Game(your_choice,lst_dic):

    isLouchu = False
    # 查看主持人是否露出
    for num in range(len(lst_dic)):
        if not isLouchu:
            if lst_dic[your_choice]['抽屉'] == '钻石':
                # 第一种 抽到 钻石
                if num != your_choice:
                    print("主持人露出了 %d 号抽屉的玻璃球"%(num + 1))
                    isLouchu = True
            else:
                # 第二种 抽到 玻璃球
                if num != your_choice and lst_dic[num]['抽屉'] != '钻石':
                    print("主持人露出了 %d 号抽屉的玻璃球"%(num + 1))
                    isLouchu = True

    choice = 'yn'
    you_select = random.choice(choice)
    if you_select == 'y':
        lst_nums = [0,1,2]
        ischoose = False
        for new_choice in lst_nums:
            if not ischoose :
                if (new_choice != num) and (new_choice != your_choice):
                    print("你新的选择是:",new_choice+1,"号抽屉")
                    your_choice = new_choice

                    ischoose = True

        ChooseLater(your_choice)


    else:
        print("不变选择,继续坚持我的 %d 号抽屉"%(your_choice + 1))
        your_choice = your_choice
        ChooseLater(your_choice)

def ChooseLater(your_choice):
    # 选择后进行计数  公布答案
    global zs, blq
    if lst_dic[your_choice]['抽屉'] == '钻石':
        zs += 1
        # 钻石数 +1
    else:
        blq += 1
        # 玻璃球数 +1
    answer_num = 0
    isanswer = False
    for answer in lst_dic:
        if not isanswer:
            if answer['抽屉'] == '钻石':
                print("钻石在 %d 号抽屉 "%(answer_num + 1))
                isanswer = True
        answer_num += 1

nums = int(input("请输入想要实验的次数"))
for i in range(nums):
    # 你可以随意选择一个抽屉
    your_choice = random.randint(0, 2)
    print("你当前想要选择的是 %d 号抽屉" % (your_choice + 1))
    Game(your_choice,lst_dic)

print("抽到的钻石数为: %d"%(zs))

print("抽到的玻璃球数为: %d"%(blq))

print("钻石的概率是 %.2f"%(zs/nums))

小人推心图(网上代码)

from turtle import *

def go_to(x, y):
    up()
    goto(x, y)
    down()


def head(x, y, r):
    go_to(x, y)
    speed(1)
    circle(r)
    leg(x, y)


def leg(x, y):
    right(90)
    forward(180)
    right(30)
    forward(100)
    left(120)
    go_to(x, y - 180)
    forward(100)
    right(120)
    forward(100)
    left(120)
    hand(x, y)


def hand(x, y):
    go_to(x, y - 60)
    forward(100)
    left(60)
    forward(100)
    go_to(x, y - 90)
    right(60)
    forward(100)
    right(60)
    forward(100)
    left(60)
    eye(x, y)


def eye(x, y):
    go_to(x - 50, y + 130)
    right(90)
    forward(50)
    go_to(x + 40, y + 130)
    forward(50)
    left(90)


def big_Circle(size):
    speed(20)
    for i in range(150):
        forward(size)
        right(0.3)


def line(size):
    speed(1)
    forward(51 * size)


def small_Circle(size):
    speed(10)
    for i in range(210):
        forward(size)
        right(0.786)


def heart(x, y, size):
    go_to(x, y)
    left(150)
    begin_fill()
    line(size)
    big_Circle(size)
    small_Circle(size)
    left(120)
    small_Circle(size)
    big_Circle(size)
    line(size)
    end_fill()


def main():
    pensize(2)
    color('red', 'pink')
    head(-120, 100, 100)
    heart(250, -80, 1)
    go_to(200, -300)
    write("To: Hany", move=True, align="left", font=("楷体", 20, "normal"))
    done()

main()

0525习题

for i in range(1000,2201):
    if i % 7 == 0 and i % 5 != 0:
        print(i,end = " ")

def func(num):
    if num == 0:
        return 1

    return num * func(num - 1)
print(func(5))

for i in range(100,1000):
    a = i//100
    b = i//10 % 10
    c = i%100%10
    if a**3 + b**3 + c**3 == i:
        print(i)

name = 'seven'
passwd = '123'
num = 3
while num:
    input_name = input("请输入用户名")
    input_passwd = input("请输入密码")
    if input_name == name and input_passwd == passwd:
        print("登陆成功")
        break
    else:
        print("登陆失败")
    num = num - 1

x,y=eval(input("请输入两个数字，逗号分隔："))
lst_num=[]
for i in range(x):
    L=[]
    for j in range(y):
        L.append(j*i)
    lst_num.append(L)
print(lst_num)

def rank(score):
    if isinstance(score,int):
        if 90 <= score <= 100:
            print("优秀")
        elif 80<= score <= 89:
            print("良好")
        elif 60<= score <= 79:
            print("及格")
        elif 0<= score <= 59:
            print("不及格")
        else:
            print("输入有误!")
try:
    score = eval(input("请输入一个学生的成绩"))
    rank(score)
except Exception as e:
    print("请输入数字")

def test(name):
    if name == 'exit':
        print('欢迎下次使用')
    if name[0].isalpha() or name[0] == '_':
        for i in name[1:]:
            if not (i.isalnum() or i == '_'):
                print('变量名不合法')
                break
        else:
            print('变量名合法!')
    else:
        print('变量名非法!')

name = input()
test(name)

def comb(n,m):
    if(n == m or (not m)):
        return 1
    else:
        return comb(n-1,m) + comb(n-1,m-1)


try:
    n,m = eval(input())
    print(comb(n,m))
except :
    print("输入有误!")

def sort(dct):
    newDct={}
    items = list(dct.items())
    items.sort(key=lambda x:x[1],reverse=True)
    for i in range(len(dct)):
        name,score = items[i]
        newDct[name] = score
        print("第%d名:%s,成绩: %.2f分"%(i+1,name,newDct[name]))

def avg(dct):
    scores = list(dct.values())
    print("最高分:%.2f"%(max(scores)),end = "")
    print("最低分:%.2f" % (min(scores)),end="")
    print("平均分:%.2f" % (sum(scores) / len(scores)),end="")

dct={}
dct['张三'],dct['李四'],dct['王五'],dct['赵六'],dct['侯七']=eval(input())
sort(dct)
avg(dct)

words = "Python"
print("{:#^9}".format(words))

string = "Python"
if "p" in string:
    print(string[:-1])
else:
    print(string[0:4])

# 创建文件data.txt，共100000行，每行存放一个1～100之间的整数
import random
f = open('data.txt','w+')
for i in range(100000):
    f.write(str(random.randint(1,100)) + '\n')
f.seek(0,0)
print(f.read())
f.close()

# 生成100个MAC地址并写入文件中，MAC地址前6位（16进制）为01-AF-3B
# 01-AF-3B(-xx)(-xx)(-xx)
# -xx
# 01-AF-3B-xx
# -xx
# 01-AF-3B-xx-xx
# -xx
# 01-AF-3B-xx-xx-xx


import random
import string

def create_mac():
    mac = '01-AF-3B'
    # 生成16进制的数
    hex_num = string.hexdigits
    for i in range(3):
        # 从16进制字符串中随机选择两个数字
        # 返回值是一个列表
        n = random.sample(hex_num,2)
        # 拼接内容 将小写字母转换称大写字母
        sn = '-' + ''.join(n).upper()
        mac += sn
    return mac

# 主函数 随机生成100个mac地址
def main():
    with open('mac.txt','w') as f:
        for i in range(100):
            mac = create_mac()
            print(mac)
            f.write(mac + '\n')
main()

# 生成一个大文件ips.txt,要求1200行,每行随机为172.25.254.0/24段的ip
# 读取ips.txt文件统计这个文件中ip出现频率排前10的ip

import random
def create_ip(filename):
    ip=['172.25.254.'+str(i) for i in range(1,255)]
    with open(filename,'w') as f:
        for i in range(1200):
            f.write(random.sample(ip,1)[0]+'\n')
create_ip('ips.txt')

ips_dict={}

with open('ips.txt') as f :
    for ip in f:
        ip=ip.strip()
        if ip in ips_dict:
            ips_dict[ip]+=1
        else:
            ips_dict[ip]=1

sorted_ip=sorted(ips_dict.items(),key=lambda x:x[1],reverse=True)[:10]
print(sorted_ip)

jieba尝鲜

import jieba
strings = '我工作在安徽的安徽师范大学，这个大学很美丽，在芜湖'
# print(dir(jieba))
dic_strings = {}
lst_strings = jieba.lcut(strings)
for ci in lst_strings:
    # 对得到的分词进行汇总
    dic_strings[ci] = lst_strings.count(ci)
    # 更改字典中单词出现的次数
print(dic_strings)

inf  无穷
inf = float('inf')

读取文件进行绘图

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

cqlq=pd.read_csv("cqlq.txt",sep="\s+",encoding="gbk")
dxnt=pd.read_csv("dxnt.txt",sep="\s+",encoding="gbk")
ggdq=pd.read_csv("ggdq.txt",sep="\s+",encoding="gbk")
giyy=pd.read_csv("gjyy.txt",sep="\s+",encoding="gbk")



cqlq.columns = ["date","oppr","hipr","lopr","clpr","TR"]
dxnt.columns = ["date","oppr","hipr","lopr","clpr"]
ggdq.columns = ["date","oppr","hipr","lopr","clpr","TR"]
giyy.columns = ["date","oppr","hipr","lopr","clpr","TR"]

a=cqlq
b=dxnt
c=ggdq
d=giyy

ua=(a["clpr"]-a["clpr"].shift(1))/a["clpr"]
ub=(b["clpr"]-b["clpr"].shift(1))/b["clpr"]
uc=(c["clpr"]-c["clpr"].shift(1))/c["clpr"]
ud=(d["clpr"]-d["clpr"].shift(1))/d["clpr"]

u=pd.concat([ua,ub,uc,ud],axis=1)
u.dropna()
miu=u.mean()+0.005
jz=u.cov()
yi = np.ones(4)

miu= np.mat(miu)
jz = np.mat(jz)
yi = np.mat(yi)
nijz = jz.I

a = miu*nijz*miu.T
b =yi*nijz*miu.T
c = yi*nijz*yi.T
deta=a*c-b**2


stock_y=[i*0.0001 for i in range(100)]
stock_x=[(np.sqrt(( c/deta)*(rp-b/c)**2+1/c)).max() for rp in stock_y]

plt.rcParams['font.sans-serif']=['SimHei']
plt.plot(stock_x,stock_y)
plt.xlabel("方差")
plt.ylabel("期望")
print(miu)
print(jz)

plt.show()

 

 

Sqlite3 实现学生信息增删改查

import sqlite3
conn = sqlite3.connect('studentsdb.db')
# 连接数据库
cursor = conn.cursor( )
# 创建数据表

def createDatabase():
    '''创建一个数据表'''
    sql = 'create table student(stuId int primary key,stuName text,stuAge text,stuGender text,stuClass text)'
    cursor.execute(sql)
    conn.commit()

def addInfo(sql = ''):
    '''添加数据'''
    if sql =='':
        # 如果是初始化,则默认会进行增加 6 条数据
        stuInfo = [(1001, '小华', '20', '男', '二班'),
                    (1002, '小明', '19', '女', '二班'),
                    (1003, '小李', '20', '女', '一班'),
                    (1004, '小王', '18', '男', '一班'),
                    (1005, '小刘', '20', '女', '二班'),
                    (1006, '小张', '19', '女', '一班')]
        cursor.executemany("insert into student values(?,?,?,?,?)",stuInfo)
        # 插入多条语句
        conn.commit()


def deleteInfo():
    '''删除数据'''
    cursor.execute("delete from student where stuId = 1005")
    # 将学号为 1005 的小刘同学删除
    conn.commit()

def modifyInfo():
    '''修改数据'''
    sql = "update student set stuAge = ? where stuId = ?"
    cursor.execute(sql,(20,1006))
    # 将小张的年龄修改为 20
    conn.commit()

def selectInfo():
    '''查询学生信息'''
    sql = 'select * from student'
    # 查询全部数据
    cursor.execute(sql)
    print(cursor.fetchall())



def main():
    # 创建一个数据表
    createDatabase()
    # 添加数据
    print("添加六条学生数据之后")
    addInfo()
    selectInfo()
    # 修改数据
    print("将小张的年龄修改为 20")
    modifyInfo()
    selectInfo()
    # 删除数据
    print("将学号为 1005 的小刘同学删除")
    deleteInfo()
    selectInfo()

    # cursor.execute('drop table student')
    # conn.commit()
main()

绘图 示例

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

cqlq=pd.read_csv("cqlq.txt",sep="\s+",encoding="gbk")
dxnt=pd.read_csv("dxnt.txt",sep="\s+",encoding="gbk")
ggdq=pd.read_csv("ggdq.txt",sep="\s+",encoding="gbk")
giyy=pd.read_csv("gjyy.txt",sep="\s+",encoding="gbk")



cqlq.columns = ["date","oppr","hipr","lopr","clpr","TR"]
dxnt.columns = ["date","oppr","hipr","lopr","clpr"]
ggdq.columns = ["date","oppr","hipr","lopr","clpr","TR"]
giyy.columns = ["date","oppr","hipr","lopr","clpr","TR"]

a=cqlq
b=dxnt
c=ggdq
d=giyy

ua=(a["clpr"]-a["clpr"].shift(1))/a["clpr"]
ub=(b["clpr"]-b["clpr"].shift(1))/b["clpr"]
uc=(c["clpr"]-c["clpr"].shift(1))/c["clpr"]
ud=(d["clpr"]-d["clpr"].shift(1))/d["clpr"]

u=pd.concat([ua,ub,uc,ud],axis=1)
u.dropna()
miu=u.mean()+0.005
jz=u.cov()
yi = np.ones(4)

miu= np.mat(miu)
jz = np.mat(jz)
yi = np.mat(yi)
nijz = jz.I

a = miu*nijz*miu.T
b =yi*nijz*miu.T
c = yi*nijz*yi.T
deta=a*c-b**2


stock_y=[i*0.0001 for i in range(100)]
stock_x=[(np.sqrt(( c/deta)*(rp-b/c)**2+1/c)).max() for rp in stock_y]

plt.rcParams['font.sans-serif']=['SimHei']
plt.plot(stock_x,stock_y)
plt.xlabel("方差")
plt.ylabel("期望")
print(miu)
print(jz)

plt.show()

使用正则匹配数字

import re
pattern = '\d+?\.\d+'
s = "[Decimal('90.900000')]"
s2 = "[Decimal('75.900000'),Decimal('57.280000')]"
[print(i,end = " ") for i in re.findall(pattern,s)]
print()
[print(i,end = " ") for i in re.findall(pattern,s2)]

0528习题

'''
1.    编写程序实现：计算并输出标准输入的三个数中绝对值最小的数。
'''
#计算并输出标准输入的三个数中绝对值最小的数。
import math
num1 = int(input())
num2 = int(input())
num3 = int(input())
num_list = (num1, num2, num3)
index_min = 0    #绝对值最小的元素的下标
if math.fabs(num_list[index_min]) > math.fabs(num_list[1]):
    index_min = 1
if math.fabs(num_list[index_min]) > math.fabs(num_list[2]):
    index_min = 2

for n in num_list:
    if math.fabs(num_list[index_min]) == math.fabs(n):
        print(n, end=' ')

'''
2.    编写程序，功能是输入五分制成绩，
输出对应的百分制分数档。 不考虑非法输入的情形。
对应关系为：A: 90~100, B: 80~89, C: 70~79,D: 60~69, E: 0~59
'''
score = int(input())
if 90 <= score <= 100:
    print("A")
elif 80 <= score <= 89:
    print("B")
elif 70 <= score <= 79:
    print("C")
elif 60 <= score <= 69:
    print("D")
elif 0 <= score <= 59:
    print("E")
else:
    print("请输入正确分数")

'''
3.    编写程序，
输入年(year)、月(month)，输出该年份该月的天数。
公历闰年的计算方法为：年份能被4整除且不能被100整除的为闰年；
或者，年份能被400整除的是闰年。
'''
year = int(input("请输入年份"))
month = int(input("请输入月份"))
month_lst = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
if (year %4 == 0 and year % 100 !=0) and year % 400 == 0:
    month_lst[1] = 29
print(month_lst[month - 1])

'''
4.    编写程序，功能是输入一个数，输出该数的绝对值
'''
num = int(input())
print(abs(num))

'''
5.    编写“猜数游戏”程序，
功能是：
如果用户输入的数等于程序选定的数（该数设定为10），则输出“you win”，
否则如果大于选定的数，则输出“too big”，反之输出“too small”。
'''
num = 10
your_num = int(input())
if your_num == num:
    print("you win")
elif your_num > num:
    print("too big")
else:
    print("too small")

关于某一爬虫实例的总结

os.chdir(r"C:\Users\47311\Desktop\code\") #修改为自己文件路径

data = pd.read_excel(r"公司公告2020.xlsx")[:-1] #读入数据，并删除最后一行（最后一行为空值）

读取的数据在 chdir 之下

存在多个数据时,使用字符串类型进行 split 分割 "
可能会出错,需要异常处理 

DataFrame 对象.apply(函数名) 
经常会使用,可以用来赋值新的值

def address(str):            #定义提取公告地址函数
    try:
        return str.split('"')[1]
    except:
        pass
data["公告地址"] = data["公告地址"].apply(address)

对代码进行获取某一个值时 
可以先获取数据上面的内容
html = requests.get(url).text
使用 etree.HTML(html) 进行解析
使用 xpath 读取路径
tree.xpath("xxxx")

返回读取到的内容,对原内容进行更新
return "http://xxxx.com/" + url[0]

data.iterrows()
读取每一行的数据
for index, row in data.iterrows():
row['属性'] 进行获取值

添加文件后缀

name = row['公告标题'].split(':')[0] + row["证券代码"][:6] + "_" + row["公告日期"] + ".pdf"

爬取时,进行必要的条件信息的说明

使用 urlretrieve(url,filename = r' xxx ')
进行保存

当获取到的数据不存在时,可以通过设置一个 len( data )
设置一个长度 ,过滤掉 不到长度的数据

设置一个布尔类型的全局变量
当访问到时 设置为 True
如果没有访问到,则设置为 False
根据全局变量的值,判断是否继续进行访问

是否感染病毒

import random
ganran = float(input("请输入感染概率"))
is_person_ganran = False
# 人是否感染了
person_ganran = random.randint(0,100)
if person_ganran /100 < ganran:
    is_person_ganran = True
print(person_ganran)

if is_person_ganran:
    print("被感染了")
else:
    print("还是正常人")

python文件操作

file = open('abc.txt','r',encoding='utf-8') 

file = open('abc.txt','w',encoding='utf-8')

'w' 写入模式
会清空掉文件,然后再写入
不想完全覆盖掉原文件的话,使用'a' 

关键字with,with open(xxx) as f
避免打开文件后忘记关闭

readline() 读取一行

读取出来的数据 后面都有\n

readlines() 将每一行形成一个元素，放到一个列表中


seek操作

seek(n)光标移动到n位置
注意: 移动单位是byte
如果是utf-8的中文部分要是3的倍数

seek(0,0)默认为0，移动到文件头

seek(0,1)移动到当前位置

seek(0,2)移动到文件尾


tell()  获取当前光标在什么位置

修改文件

将文件中的内容读取到内存中
将信息修改完毕, 然后将源文件删除, 将新文件的名字改成原来文件的名字
可以一行一行的读取修改,避免溢出

pandas 几个重要知识点

将 NaN 替换成某一数值
使用 fillna 
dataframe.fillna(value = 'xxx',inplace=True)

删除某一个值
使用 drop 
dataframe.drop(10,inplace=True)


交换两行的值

    if m != n:
        temp = np.copy(dataframe[m])
        dataframe[m] = dataframe[n]
        dataframe[n] = temp
    else:
        temp = np.copy(dataframe[dataframe.shape[1]-1])
        dataframe[dataframe.shape[1]-1] = dataframe[n]
        dataframe[n] = temp


删除 columns 这些列

    dataframe.drop(columns = list, inplace=True)

一千美元的故事(钱放入信封中)

def dollar(n):
    global story_money
    money = []
    for i in range(10):
        if 2**(i+1) > story_money-sum(money):
            money.append(story_money-2**i+1)
            break
        money.append(2 ** i)
    # print(money)
    answer = []
    if n >= money[-1]:
        answer.append(10)
        n -= money[-1]
    n = list(bin(n))[2:]
    n.reverse()
    rank = 1
    for i in n:
        if i == '1':
            answer.append(rank)
        rank += 1
    print(answer)

story_money = 1000
dollar(500)

给定两个列表,转换为DataFrame类型

import pandas as pd

def get_data():
    q1 = []
    q2 = []
    p1 = input("list 1:")
    p2 = input("list 2:")
    q1=p1.split(',')
    q2=p2.split(',')
    for i,j in zip(range(len(q1)),range(len(q2))):
        q1[i] = int(q1[i])**1
        q2[j] = float(q2[j])**2
    dic = {
        "L":q1,
        "I":q2
    }
    A = pd.DataFrame(dic)
    print(A)

get_data()


1.将输入的使用 split(',') 进行分割

2.使用 for i,j in zip(range(len(q1)),range(len(q2)))
对 q1 和 q2 都进行遍历

3.使用字典,将列表作为值,传递过去
使用 pd.DataFrame 进行转换

通过文档算学生的平均分

tom 85 90
jerry 95 80
lucy 80 90
rose 88 90
jay 76 75
summer 87 85
horry 84 80

dic = {}
with open('score.txt','r') as f:
    lines = f.readlines()
    f.close()
    for line in lines:
        line = line.strip('\n').split(' ')
        dic[line[0]] = (int(line[1]),int(line[2]))
name = input()
if name not in dic.keys():
    print("not found")
else:
    print(sum(dic[name])/len(dic[name]))

0528习题 11-15

'''
6.    一元二次方程：ax2+bx+c=0 （a ╪ 0）
【输入形式】输入a、b和c的值（有理数）
【输出形式】输出x的两个值，或者No（即没有有理数的解）

'''
import math
a = int(input())
b = int(input())
c = int(input())
disc = b*b - 4*a*c
p = -b/(2*a)
if disc > 0:
    q = math.sqrt(disc)/(2*a)
    x1 = p + q
    x2 = p - q
    print("x1 = %s,x2 = %s"%(str(x1,x2)))
elif disc == 0:
    x1 = p
    print("x1 = x2 = ",x1)
else:
    disc = -disc
    q = math.sqrt(disc)/(2*a)
    print("x1 = ",p,"+",q)
    print("x2 = ", p, "-", q)

'''
7.    计算1+1/2+1/3+...+1/n
'''
n = int(input())
sum = 0
for i in range(1,n+1):
    sum += 1/i
print(sum)

'''
8.    编写猜数游戏程序，功能是：允许用户反复输入数，
直至猜中程序选定的数（假定为100）。
输入的数如果大于选定的数，则提示"larger than expected"；
如果小于选定的数，则提示"less than expected"；
如果等于选定的数，则输出"you win"并结束程序。
'''
import random
num = random.randint(1,5)
while True:
    your_num = int(input())
    if your_num == num:
        print("you win")
        break
    elif your_num > num:
        print("larger than expected")
    else:
        print("less than expected")

'''
9.    计算1-100之间的偶数和
'''
num_lst = [i for i in range(1,101) if i % 2 == 0]
print(sum(num_lst))

'''
10.    猴子摘下若干个桃子，第一天吃了桃子的一半多一个，
以后每天吃了前一天剩下的一半多一个，
到第n天吃以前发现只剩下一个桃子，
编写程序实现：据输入的天数计算并输出猴子共摘了几个桃子
【输入形式】输入的一行为一个非负整数，表示一共吃的天数。
【输出形式】输出的一行为一个非负整数，表示共摘了几个桃子，
若输入的数据不合法（如：负数或小数），则输出"illegal data"。
'''
def Peach(day,yesterday_sum,now_rest):
    if day != 0:
        day -= 1
        yesterday_sum = (now_rest + 1) * 2
        now_rest = yesterday_sum
        return Peach(day,yesterday_sum,now_rest)
    else:
        return yesterday_sum
yesterday_sum = 0
now_rest = 1
day = int(input())
if day <= 0:
    print("illegal data")
    exit()
print(Peach(day,yesterday_sum,now_rest))

0528习题 6-10

'''
1.    编写程序，功能是把输入的字符串的大写字母变成小写字母，
小写字母变成大写字母，非字母的字符不作变换。输出变换后的结果
'''
string = input()
s = ''
for str in string:
    if 'a' <= str <= 'z':
        s += str.upper()
    elif 'A' <= str <= 'Z':
        s += str.lower()
    else:
        s += str
print(s)    

'''
2.    已知10个四位数输出所有对称数及个数 n，
例如1221、2332都是对称数。
【输入形式】10个四位数，以空格分隔开
【输出形式】输入的四位数中的所有对称数，对称数个数
'''
input_nums = input().split()
nums = []
for num in input_nums:
    nums.append(int(num))
symmetric_num = []
for num in nums:
    num = str(num)
    if num[0] == num[3] and num[1] == num[2]:
        symmetric_num.append(num)
print("对称数:")
[print(i,end = " ") for i in symmetric_num]
print(len(symmetric_num))
# 1221 2243 2332 1435 1236 5623 4321 4356 6754 3234

'''
学校举办新生歌手大赛，每个选手的成绩
由评委的评分去掉一个最高分和一个最低分剩下评分的平均值得到。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬
编写程序实现：输入第一行指定n，从第二行开始每行输入一个评委的得分（共n行），
计算选手的成绩，并输出。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬
'''
n = int(input())
player = []
for i in range(n):
    score = float(input())
    player.append(score)
player.remove(max(player))
player.remove(min(player))
print("%.1f"%(sum(player)/len(player)))

'''
1.    编写程序实现：计算并输出标准输入的三个数中绝对值最小的数。
'''
#计算并输出标准输入的三个数中绝对值最小的数。
import math
num1 = int(input())
num2 = int(input())
num3 = int(input())
num_list = (num1, num2, num3)
index_min = 0    #绝对值最小的元素的下标
if math.fabs(num_list[index_min]) > math.fabs(num_list[1]):
    index_min = 1
if math.fabs(num_list[index_min]) > math.fabs(num_list[2]):
    index_min = 2

for n in num_list:
    if math.fabs(num_list[index_min]) == math.fabs(n):
        print(n, end=' ')

'''
5.    从键盘输入非0整数，以输入0为输入结束标志，求平均值，统计正数负数个数
【输入形式】 每个整数一行。最后一行是0，表示输入结束。
【输出形式】输出三行。
     第一行是平均值。第二行是正数个数。第三行是负数个数。
'''
nums = []
n_z = 0
n_f = 0
while True:
    num = int(input())
    if num == 0:
        print(sum(nums)/len(nums))
        for n in nums:
            if n > 0:
                n_z += 1
            elif n < 0:
                n_f += 1
        print(n_z)
        print(n_f)
        exit()
    else:
        nums.append(num)

0528习题 16-20

'''
11.    编写程序，判断一个数是不是素数，是则输出“Yes”，不是输出“No”.(while循环)
'''
num = int(input())
i = 2
flag = True
while i < num:
    if num % i ==0:
        flag = False
    i += 1
if flag:
    print("Yes")
else:
    print("No")

'''
12.    编程实现：从键盘输入5个分数，计算平均分。
【输入形式】5个分数，每个分数占一行。
    【输出形式】新起一行输出平均分。
'''
nums = []
for i in range(5):
    num = float(input())
    nums.append(num)
print(sum(nums)/len(nums))

'''
13.    输入3个整数，输出其中最大的一个 。
'''
nums = []
for i in range(3):
    num = int(input())
    nums.append(num)
print(max(nums))

'''
14.    输入n，计算n!（n!=1*2*3*...*n）
'''
n = int(input())
sum = 1
for i in range(1,n+1):
    sum *= i
print(sum)

'''
编写程序，打印菱形图案，行数n从键盘输入。
下为n=3时的图案，其中的点号实际为空格。图案左对齐输出。
'''
n = 3
for i in range(1, n + 1):
    print("  " * (n - i) + "* " * (2 * i - 1))
for i in range(n-1,0,-1):
    print("  " * (n - i) + "* " * (2 * i - 1))

0528习题 21-25

'''
16.    编写程序计算学生的平均分。
【输入形式】输入的第一行表示学生人数n；
标准输入的第2至n+1行表示学生成绩。
【输出形式】输出的一行表示平均分（保留两位小数）。
若输入的数据不合法（学生人数不是大于0的整数，
或学生成绩小于0或大于100），输出“illegal input”。
'''

n = int(input())
nums = []
for i in range(n):
    score = float(input())
    if not 0<= score <= 100:
        print("illegal input")
    nums.append(score)
print("%.2f"%(sum(nums)/len(nums)))

'''
17.    请将一万以内的完全平方数输出 .
'''
for x in range(1,101):
    y = x*x
    if y <= 10000:
        print(y)
    else:
        break

'''
18.    从键盘输入非0整数，以输入0为输入结束标志，求平均值，统计正数负数个数
【输入形式】每个整数一行。最后一行是0，表示输入结束。
【输出形式】输出三行。 第一行是平均值。第二行是正数个数。第三行是负数个数。

'''
nums = []
n_z = 0
n_f = 0
while True:
    num = int(input())
    if num == 0:
        print(sum(nums)/len(nums))
        for n in nums:
            if n > 0:
                n_z += 1
            elif n < 0:
                n_f += 1
        print(n_z)
        print(n_f)
        exit()
    else:
        nums.append(num)

'''
【问题描述】从键盘输入一个大写字母，要求输出其对应的小写字母。
【输入形式】输入大写字母，不考虑不合法输入。
【输出形式】输出对应的小写字母。
【样例输入】A
【样例输出】a
'''
s = input()
print(s.lower())

'''
【问题描述】
从键盘输入三个字符，按ASCII码值从小到大排序输出，字符之间间隔一个空格。
【输入形式】
输入三个字符，每个字符用空格隔开。
【输出形式】
相对应的输出按照ASCII码值从小到大排列的三个字符，每个字符间用空格隔开。
【样例输入】a c b
【样例输出】a b c
'''
strings = input().split(' ')
strings = sorted(strings)
for s in strings:
    print(s,end = " ")

0528习题 26-31

'''
【问题描述】定义一个函数判断是否为素数isPrime（），
主程序通过调用函数输出2-30之间所有的素数。
素数：一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。
【输入形式】无【输出形式】2~30之间所有的索数（逗号分隔）
【样例输入】【样例输出】2,3,5,7,11,13,17,19,23,29，
【样例说明】【评分标准】
'''
def isPrime(n):
    i = 2
    flag = True
    while i < n:
        if n % i == 0:
            flag = False
        i += 1
    if flag:
        return True
    else:
        return False
for i in range(2,31):
    if isPrime(i):
        print(i,end = ',')

'''
【问题描述】有182只兔子，分别装在甲乙两种笼子里，
甲种笼子（x）每个装6只，乙种笼子（y）每个装4只，
两种笼子正好用36个，问两种笼子各用多少个？
【输入形式】无
【输出形式】笼子的个数
【样例输入】
【样例输出】x=*；y=*
【输出说明】
    1)*代表输出的值；
    2)输出的等号和分号都是英文字符
'''
for i in range(1,36):
    x = i
    y = 36 - i
    if 6*x + 4*y == 182:
        print("x=%d;y=%d"%(x,y))

'''
输入圆柱体的底面半径和高，求圆柱体的体积并输出。
圆周率T取固定值3.14。
【输入形式】圆柱体的底面半径和高
【输出形式】圆柱体的体积
【样例输入】2
【样例输出】50.24
'''
r = float(input())
h = float(input())
pi = 3.14
print("%.2f"%(pi*r*r*h))

'''
【问题描述】猴子吃桃问题：
猴子摘下若干个桃子，第一天吃了桃子的一半多一个，
以后每天吃了前一天剩下的一半多一个，
到第n天吃以前发现只剩下一个桃子，
编写程序实现：据输入的天数计算并输出猴子共摘了几个桃子。
【输入形式】n。
【输出形式】共摘了几个桃子
【样例输入】3
【样例输出】10
【样例输入】1
【样例输出】1
'''
day = int(input())
now = 1
yesterday = 0
while day > 1:
    yesterday = (now + 1) * 2
    now = yesterday
    day -= 1
print(now)

'''
输入5名学生的成绩，保存到列表，
统计最高分、最低分、平均分和及格率。平均分
和及格率保留两位小数，及格率的输出格式为x%。
【输入形式】5个人的成绩
【输出形式】最高分、最低分、平均分、及格率
【样例输入】
56
67
55
66
70
【样例输出】
70
55
62.80
60.00%
'''
score = []
for i in range(5):
    num = float(input())
    score.append(num)
n = 0
for i in score:
    if i > 60:
        n += 1

print(max(score))
print(min(score))
print(sum(score)/len(score))
print("%.2f%%"%(n*100/len(score)))

'''
【问题描述】
文件“in.txt”中存储了学生的姓名和成绩，
每个人的姓名成绩放在一行，中间用空格隔开，
形式如下：Sunny 70 Susan 88从文件读取数据后，
存入字典，姓名作为字典的键，成绩作为字典的值。
然后输入姓名，查询相应的成绩，查不到，显示"not found"。
【输入形式】姓名
【输出形式】成绩
【样例输入】键盘输入：Susan
'''
name = input()
flag = False
with open('in.txt','r',encoding='utf-8') as fp:
    for line in fp:
        line = line.replace('\n','')
        if line != "":
            lst = line.split()
            tup = tuple(lst)
            # print(tup)
            if tup[0] == name:
                flag = True
                print(tup[-1])

if not flag:
    print("not found")




in.txt文件内容
Sunny 70
Susan 80

读取 csv , xlsx 表格并添加总分列

import pandas as pd
import numpy as np
data = pd.read_excel('学生成绩表.csv',columns = ['学号','姓名','高数','英语','计算机'])

sum_score = [ ]
for i in range(len(data)):
    sum_score.append(sum(data.loc[i,:][data.columns[2:]]))
data['总分'] = sum_score
print(data['总分'])
data.to_csv('学生成绩表1.csv',encoding='gbk')

matplotlib 显示中文问题

import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号

十进制转换

# bin2dec
# 二进制 to 十进e5a48de588b662616964757a686964616f31333335336437制: int(str,n=10) 
def bin2dec(string_num):
    return str(int(string_num, 2))
 
# hex2dec
# 十六进制 to 十进制
def hex2dec(string_num):
    return str(int(string_num.upper(), 16))
 
# dec2bin
# 十进制 to 二进制: bin() 
def dec2bin(string_num):
    num = int(string_num)
    mid = []
    while True:
        if num == 0: break
        num,rem = divmod(num, 2)
        mid.append(base[rem])
 
    return ''.join([str(x) for x in mid[::-1]])
 
# dec2hex
# 十进制 to 八进制: oct() 
# 十进制 to 十六进制: hex() 
def dec2hex(string_num):
    num = int(string_num)
    mid = []
    while True:
        if num == 0: break
        num,rem = divmod(num, 16)
        mid.append(base[rem])
 
    return ''.join([str(x) for x in mid[::-1]])

base = [str(x) for x in range(10)] + [chr(x) for x in range(ord('A'), ord('A') + 6)]

def dec2bin(string_num):
    '''十进制转换为 二进制'''
    num = int(string_num)
    mid = []
    while True:
        if num == 0: break
        num, rem = divmod(num, 2)
        mid.append(base[rem])

    return ''.join([str(x) for x in mid[::-1]])

def dec2oct(string_num):
    '''转换为 八进制'''
    num = int(string_num)
    mid = []
    while True:
        if num == 0: break
        num, rem = divmod(num, 8)
        mid.append(base[rem])

    return ''.join([str(x) for x in mid[::-1]])


def dec2hex(string_num):
    '''转换为 十六进制'''
    num = int(string_num)
    mid = []
    while True:
        if num == 0: break
        num, rem = divmod(num, 16)
        mid.append(base[rem])

    return ''.join([str(x) for x in mid[::-1]])



num = float(input())

print(dec2bin(num),dec2oct(num),dec2hex(num))

正则表达式巩固

# 导入re模块
import re

# 使用match方法进行匹配操作
result = re.match(正则表达式,要匹配的字符串)

# 如果上一步匹配到数据的话，可以使用group方法来提取数据
result.group()

re.match用来进行正则匹配检查
若字符串匹配正则表达式，则match方法返回匹配对象（Match Object）
否则返回None

import re

result = re.match("itcast","itcast.cn")

result.group()

re.match() 能够匹配出以xxx开头的字符串

大写字母表示 非  
\w 匹配字母,数字,下划线
\W 表示除了字母 数字 下划线的

import re

ret = re.match(".","a")
ret.group()

ret = re.match(".","b")
ret.group()

ret = re.match(".","M")
ret.group()

import re

# 如果hello的首字符小写，那么正则表达式需要小写的h
ret = re.match("h","hello Python")
ret.group()


# 如果hello的首字符大写，那么正则表达式需要大写的H
ret = re.match("H","Hello Python")
ret.group()

# 大小写h都可以的情况
ret = re.match("[hH]","hello Python")
ret.group()
ret = re.match("[hH]","Hello Python")
ret.group()

# 匹配0到9第一种写法
ret = re.match("[0123456789]","7Hello Python")
ret.group()

# 匹配0到9第二种写法
ret = re.match("[0-9]","7Hello Python")
ret.group()

import re

# 普通的匹配方式
ret = re.match("嫦娥1号","嫦娥1号发射成功")
print(ret.group())

ret = re.match("嫦娥2号","嫦娥2号发射成功")
print(ret.group())

ret = re.match("嫦娥3号","嫦娥3号发射成功")
print(ret.group())

# 使用\d进行匹配
ret = re.match("嫦娥\d号","嫦娥1号发射成功")
print(ret.group())

ret = re.match("嫦娥\d号","嫦娥2号发射成功")
print(ret.group())

ret = re.match("嫦娥\d号","嫦娥3号发射成功")
print(ret.group())

正则表达式里使用"\"作为转义字符
需要匹配文本中的字符"\"
使用反斜杠"\\"

import re

ret = re.match("[A-Z][a-z]*","Mm")
print(ret.group())

ret = re.match("[A-Z][a-z]*","Aabcdef")
print(ret.group())

import re

ret = re.match("[a-zA-Z_]+[\w_]*","name1")
print(ret.group())

ret = re.match("[a-zA-Z_]+[\w_]*","_name")
print(ret.group())

ret = re.match("[a-zA-Z_]+[\w_]*","2_name")
print(ret.group())

import re

ret = re.match("[1-9]?[0-9]","7")
print(ret.group())

ret = re.match("[1-9]?[0-9]","33")
print(ret.group())

ret = re.match("[1-9]?[0-9]","09")
print(ret.group())

import re

ret = re.match("[a-zA-Z0-9_]{6}","12a3g45678")
print(ret.group())

ret = re.match("[a-zA-Z0-9_]{8,20}","1ad12f23s34455ff66")
print(ret.group())

import re

# 正确的地址
ret = re.match("[\w]{4,20}@163\.com", "xiaoWang@163.com")
print(ret.group())

# 不正确的地址
ret = re.match("[\w]{4,20}@163\.com", "xiaoWang@163.comheihei")
print(ret.group())

# 通过$来确定末尾
ret = re.match("[\w]{4,20}@163\.com$", "xiaoWang@163.comheihei")
print(ret.group())

\b    匹配一个单词的边界
\B    匹配非单词边界

import re

ret = re.match("[1-9]?\d","8")
print(ret.group())

ret = re.match("[1-9]?\d","78")
print(ret.group())


# 添加|
ret = re.match("[1-9]?\d$|100","8")
print(ret.group())

ret = re.match("[1-9]?\d$|100","78")
print(ret.group())

ret = re.match("[1-9]?\d$|100","100")
print(ret.group())

import re

ret = re.match("\w{4,20}@163\.com", "test@163.com")
print(ret.group())

ret = re.match("\w{4,20}@(163|126|qq)\.com", "test@126.com")
print(ret.group())

ret = re.match("\w{4,20}@(163|126|qq)\.com", "test@qq.com")
print(ret.group())

import re

# 能够完成对正确的字符串的匹配
ret = re.match("<[a-zA-Z]*>\w*</[a-zA-Z]*>", "<html>hh</html>")
print(ret.group())

# 如果遇到非正常的html格式字符串，匹配出错
ret = re.match("<[a-zA-Z]*>\w*</[a-zA-Z]*>", "<html>hh</htmlbalabala>")
print(ret.group())

# 正确的理解思路：如果在第一对<>中是什么，按理说在后面的那对<>中就应该是什么

# 通过引用分组中匹配到的数据即可，但是要注意是元字符串，即类似 r""这种格式
ret = re.match(r"<([a-zA-Z]*)>\w*</\1>", "<html>hh</html>")
print(ret.group())

# 因为2对<>中的数据不一致，所以没有匹配出来
ret = re.match(r"<([a-zA-Z]*)>\w*</\1>", "<html>hh</htmlbalabala>")
print(ret.group())

import re

ret = re.match(r"<(\w*)><(\w*)>.*</\2></\1>", "<html><h1>www.itcast.cn</h1></html>")
print(ret.group())

# 因为子标签不同,导致出错
ret = re.match(r"<(\w*)><(\w*)>.*</\2></\1>", "<html><h1>www.itcast.cn</h2></html>")
print(ret.group())

import re

ret = re.match(r"<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>", "<html><h1>www.itcast.cn</h1></html>")
print(ret.group())

ret = re.match(r"<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>", "<html><h1>www.itcast.cn</h2></html>")
print(ret.group())

import re
ret = re.search(r"\d+", "阅读次数为 9999")
print(ret.group())

import re
ret = re.findall(r"\d+", "python = 9999, c = 7890, c++ = 12345")
print(ret)

import re
ret = re.sub(r"\d+", '998', "python = 997")
print(ret)

import re

def add(temp):
    strNum = temp.group()
    num = int(strNum) + 1
    return str(num)

# 替换的是 原数据 + 1
ret = re.sub(r"\d+", add, "python = 997")
print(ret)

ret = re.sub(r"\d+", add, "python = 99")
print(ret)

import re
ret = re.split(r":| ","info:xiaoZhang 33 shandong")
print(ret)

Python里数量词默认是贪婪的  匹配尽可能多的字符

非贪婪 总匹配尽可能少的字符。

pandas巩固

导包
import pandas as pd

设置输出结果列对齐
pd.set_option('display.unicode.ambiguous_as_wide',True)
pd.set_option('display.unicode.east_asian_width',True)

创建 从 0 开始的非负整数索引
s1 = pd.Series(range(1,20,5))

使用字典创建 Series 字典的键作为索引
s2 = pd.Series({'语文':95,'数学':98,'Python':100,'物理':97,'化学':99})

修改 Series 对象的值
s1[3] = -17

查看 s1 的绝对值
abs(s1)

将 s1 所有的值都加 5、使用加法时，对所有元素都进行
s1 + 5

在 s1 的索引下标前加入参数值
s1.add_prefix(2)

s2 数据的直方图
s2.hist()

每行索引后面加上 hany
s2.add_suffix('hany')

查看 s2 中最大值的索引
s2.argmax()

查看 s2 的值是否在指定区间内
s2.between(90,100,inclusive = True)

查看 s2 中 97 分以上的数据
s2[s2 > 97]

查看 s2 中大于中值的数据
s2[s2 > s2.median()]

s2 与数字之间的运算,开平方根 * 10 保留一位小数
round((s2**0.5)*10,1)

s2 的中值
s2.median()

s2 中最小的两个数
s2.nsmallest(2)

s2 中最大的两个数
s2.nlargest(2)

Series 对象之间的运算,对相同索引进行计算,不是相同索引的使用 NaN
pd.Series(range(5)) + pd.Series(range(5,10))

对 Series 对象使用匿名函数
pd.Series(range(5)).pipe(lambda x,y,z :(x**y)%z,2,5)

pd.Series(range(5)).pipe(lambda x:x+3)

pd.Series(range(5)).pipe(lambda x:x+3).pipe(lambda x:x*3)

对 Series 对象使用匿名函数
pd.Series(range(5)).apply(lambda x:x+3)

查看标准差
pd.Series(range(0,5)).std()

查看无偏方差
pd.Series(range(0,5)).var()

查看无偏标准差
pd.Series(range(0,5)).sem()

查看是否存在等价于 True 的值
any(pd.Series([3,0,True]))

查看是否所有的值都等价于 True
all(pd.Series([3,0,True]))

创建一个 DataFrame 对象
dataframe = pd.DataFrame(np.random.randint(1,20,(5,3)),
                         index = range(5),
                         columns = ['A','B','C'])

索引为时间序列
dataframe2 = pd.DataFrame(np.random.randint(5,15,(9,3)),
                          index = pd.date_range(start = '202003211126',
                                                end = '202003212000',
                                                freq = 'H'),
                          columns = ['Pandas','爬虫','比赛'])

使用字典进行创建
dataframe3 = pd.DataFrame({'语文':[87,79,67,92],
                           '数学':[93,89,80,77],
                           '英语':[88,95,76,77]},
                          index = ['张三','李四','王五','赵六'])

创建时自动扩充
dataframe4 = pd.DataFrame({'A':range(5,10),'B':3})

查看周几
dff['日期'] = pd.to_datetime(data['日期']).dt.weekday_name

按照周几进行分组，查看交易的平均值
dff = dff.groupby('日期').mean().apply(round)
dff.index.name = '周几'

对姓名和日期进行分组,并进行求和
dff = dataframe.groupby(by = ['姓名','日期'],as_index = False).sum()

将 dff 的索引，列 设置成透视表形式
dff = dff.pivot(index = '姓名',columns = '日期',values = '交易额')

查看前一天的数据
dff.iloc[:,:1]

交易总额小于 4000 的人的前三天业绩
dff[dff.sum(axis = 1) < 4000].iloc[:,:3]

工资总额大于 2900 元的员工的姓名
dff[dff.sum(axis = 1) > 2900].index.values

显示前两天每一天的交易总额以及每个人的交易金额
dataframe.pivot_table(values = '交易额',index = '姓名',
                      columns = '日期',aggfunc = 'sum',margins = True).iloc[:,:2]

显示每个人在每个柜台的交易总额
dff = dataframe.groupby(by = ['姓名','柜台'],as_index = False).sum()

dff.pivot(index = '姓名',columns = '柜台',values = '交易额')

查看每人每天的上班次数
dataframe.pivot_table(values = '交易额',index = '姓名',columns = '日期',aggfunc = 'count',margins = True).iloc[:,:1]

查看每个人每天购买的次数
dataframe.pivot_table(values = '交易额',index = '姓名',columns = '日期',aggfunc = 'count',margins = True)

每个人每天上过几次班
pd.crosstab(dataframe.姓名,dataframe.日期,margins = True).iloc[:,:2]

每个人每天去过几次柜台
pd.crosstab(dataframe.姓名,dataframe.柜台)

将每一个人在每一个柜台的交易总额显示出来
pd.crosstab(dataframe.姓名,dataframe.柜台,dataframe.交易额,aggfunc='sum')

每个人在每个柜台交易额的平均值,金额/天数
pd.crosstab(dataframe.姓名,dataframe.柜台,dataframe.交易额,aggfunc = 'mean').apply(lambda  num:round(num,2) )

对 5 的余数进行分组
dataframe.groupby(by = lambda num:num % 5)['交易额'].sum()

查看索引为 7 15 的交易额
dataframe.groupby(by = {7:'索引为7的行',15:'索引为15的行'})['交易额'].sum()

查看不同时段的交易总额
dataframe.groupby(by = '时段')['交易额'].sum()

各柜台的销售总额
dataframe.groupby(by = '柜台')['交易额'].sum()

查看每个人在每个时段购买的次数
count = dataframe.groupby(by = '姓名')['时段'].count()

每个人的交易额平均值并排序
dataframe.groupby(by = '姓名')['交易额'].mean().round(2).sort_values()

每个人的交易额，apply(int) 转换为整数
dataframe.groupby(by = '姓名').sum()['交易额'].apply(int)

每一个员工交易额的中值
data = dataframe.groupby(by = '姓名').median()

查看交易额对应的排名
data['排名'] = data['交易额'].rank(ascending = False)

data[['交易额','排名']]

每个人不同时段的交易额
dataframe.groupby(by = ['姓名','时段'])['交易额'].sum()

设置各时段累计
dataframe.groupby(by = ['姓名'])['时段','交易额'].aggregate({'交易额':np.sum,'时段':lambda x:'各时段累计'})

对指定列进行聚合,查看最大,最小,和,平均值,中值
dataframe.groupby(by = '姓名').agg(['max','min','sum','mean','median'])

查看部分聚合后的结果
dataframe.groupby(by = '姓名').agg(['max','min','sum','mean','median'])['交易额']

查看交易额低于 2000 的三条数据
dataframe[dataframe.交易额 < 2000][:3]

查看上浮了 50% 之后依旧低于 1500 的交易额,查看 4 条数据
dataframe.loc[dataframe.交易额 < 1500,'交易额'] = dataframe[dataframe.交易额 < 1500]['交易额'].map(lambda num:num*1.5)

查看交易额大于 2500 的数据
dataframe[dataframe.交易额 > 2500]

查看交易额低于 900 或 高于 1800 的数据
dataframe[(dataframe.交易额 < 900)|(dataframe.交易额 > 1800)]

将所有低于 200 的交易额都替换成 200
dataframe.loc[dataframe.交易额 < 200,'交易额'] = 200

查看低于 1500 的交易额个数
dataframe.loc[dataframe.交易额 < 1500,'交易额'].count()

将大于 3000 元的都替换为 3000 元
dataframe.loc[dataframe.交易额 > 3000,'交易额'] = 3000

查看有多少行数据
len(dataframe)

丢弃缺失值之后的行数
len(dataframe.dropna())

包含缺失值的行
dataframe[dataframe['交易额'].isnull()]

使用固定值替换缺失值
dff = copy.deepcopy(dataframe)
dff.loc[dff.交易额.isnull(),'交易额'] = 999

使用交易额的均值替换缺失值
dff = copy.deepcopy(dataframe)
for i in dff[dff.交易额.isnull()].index:
    dff.loc[i,'交易额'] = round(dff.loc[dff.姓名 == dff.loc[i,'姓名'],'交易额'].mean())

使用整体均值的 80% 填充缺失值
dataframe.fillna({'交易额':round(dataframe['交易额'].mean() * 0.8)},inplace = True)

查看重复值
dataframe[dataframe.duplicated()]

丢弃重复行
dataframe = dataframe.drop_duplicates()

查看员工业绩波动情况(每一天和昨天的数据作比较)
dff = dataframe.groupby(by = '日期').sum()['交易额'].diff()

对数据使用 map 函数
dff.map(lambda num:'%.2f'%(num))[:5]

查看张三的波动情况
dataframe[dataframe.姓名 == '张三'].groupby(by = '日期').sum()['交易额'].diff()

修改异常值
data.loc[data.交易额 > 3000,'交易额'] = 3000
data.loc[data.交易额 < 200,'交易额'] = 200

删除重复值
data.drop_duplicates(inplace = True)

填充缺失值
data['交易额'].fillna(data['交易额'].mean(),inplace = True)

使用交叉表得到每人在各柜台交易额的平均值
data_group = pd.crosstab(data.姓名,data.柜台,data.交易额,aggfunc = 'mean').apply(round)

绘制柱状图
data_group.plot(kind = 'bar')

使用 concat 连接两个相同结构的 DataFrame 对象
df3 = pd.concat([df1,df2])

合并，忽略原来的索引 ignore_index
df4 = df3.append([df1,df2],ignore_index = True)

按照列进行拆分
df5 = df4.loc[:,['姓名','柜台','交易额']]

按照工号进行合并，随机查看 3 条数据
rows = np.random.randint(0,len(df5),3)
pd.merge(df4,df5).iloc[rows,:]

按照工号进行合并，指定其他同名列的后缀
pd.merge(df1,df2,on = '工号',suffixes = ['_x','_y']).iloc[:,:]

两个表都设置工号为索引 set_index
df2.set_index('工号').join(df3.set_index('工号'),lsuffix = '_x',rsuffix = '_y').iloc[:]

按照交易额和工号降序排序，查看五条数据
dataframe.sort_values(by = ['交易额','工号'],ascending = False)[:5]

按照交易额和工号升序排序，查看五条数据
dataframe.sort_values(by = ['交易额','工号'])[:5]

按照交易额降序和工号升序排序，查看五条数据
dataframe.sort_values(by = ['交易额','工号'],ascending = [False,True])[:5]

按工号升序排序
dataframe.sort_values(by = ['工号'])[:5]

按列名升序排序
dataframe.sort_index(axis = 1)[:5]

每隔五天--5D
pd.date_range(start = '20200101',end = '20200131',freq = '5D')

每隔一周--W
pd.date_range(start = '20200301',end = '20200331',freq = 'W')

间隔两天,五个数据
pd.date_range(start = '20200301',periods = 5,freq = '2D')

间隔三小时，八个数据
pd.date_range(start = '20200301',periods = 8,freq = '3H')

三点开始，十二个数据，间隔一分钟
pd.date_range(start = '202003010300',periods = 12,freq = 'T')

每个月的最后一天
pd.date_range(start = '20190101',end = '20191231',freq = 'M')

间隔一年，六个数据，年末最后一天
pd.date_range(start = '20190101',periods = 6,freq = 'A')

间隔一年，六个数据，年初最后一天
pd.date_range(start = '20200101',periods = 6,freq = 'AS')

使用 Series 对象包含时间序列对象,使用特定索引
data = pd.Series(index = pd.date_range(start = '20200321',periods = 24,freq = 'H'),data = range(24))

三分钟重采样，计算均值
data.resample('3H').mean()

五分钟重采样，求和
data.resample('5H').sum()

计算OHLC open,high,low,close
data.resample('5H').ohlc()

将日期替换为第二天
data.index = data.index + pd.Timedelta('1D')

查看指定日期的年份是否是闰年
pd.Timestamp('20200301').is_leap_year

查看指定日期所在的季度和月份
day = pd.Timestamp('20200321')

查看日期的季度
day.quarter

查看日期所在的月份
day.month

转换为 python 的日期时间对象
day.to_pydatetime()

查看所有的交易额信息
dataframe['交易额'].describe()

查看四分位数
dataframe['交易额'].quantile([0,0.25,0.5,0.75,1.0])

查看最大的交易额数据
dataframe.nlargest(2,'交易额')

查看最后一个日期
dataframe['日期'].max()

查看最小的工号
dataframe['工号'].min()

第一个最小交易额的行下标
index = dataframe['交易额'].idxmin()

第一个最小交易额
dataframe.loc[index,'交易额']

最大交易额的行下标
index = dataframe['交易额'].idxmax()

跳过 1 2 4 行，以第一列姓名为索引
dataframe2 = pd.read_excel('超市营业额.xlsx',
                           skiprows = [1,2,4],
                           index_col = 1)

查看 5 到 10 的数据
dataframe[5:11]

查看第六行的数据
dataframe.iloc[5]

查看第 1 3 4 行的数据
dataframe.iloc[[0,2,3],:]

查看第 1 3 4 行的第 1 2 列
dataframe.iloc[[0,2,3],[0,1]]

查看前五行指定，姓名、时段和交易额的数据
dataframe[['姓名','时段','交易额']][:5]

查看第 2 4 5 行 姓名，交易额 数据 loc 函数
dataframe.loc[[1,3,4],['姓名','交易额']]

查看第四行的姓名数据
dataframe.at[3,'姓名']

某一时段的交易总和
dataframe[dataframe['时段'] == '14:00-21:00']['交易额'].sum()

查看张三总共的交易额
dataframe[dataframe['姓名'].isin(['张三'])]['交易额'].sum()

查看日用品的销售总额
dataframe[dataframe['柜台'] == '日用品']['交易额'].sum()

查看交易额在 1500~3000 之间的记录
dataframe[dataframe['交易额'].between(1500,3000)]

将日期设置为 python 中的日期类型
data.日期 = pd.to_datetime(data.日期)

每七天营业的总额
data.resample('7D',on = '日期').sum()['交易额']

每七天营业总额
data.resample('7D',on = '日期',label = 'right').sum()['交易额']

每七天营业额的平均值
func = lambda item:round(np.sum(item)/len(item),2)
data.resample('7D',on = '日期',label = 'right').apply(func)['交易额']

每七天营业额的平均值
func = lambda num:round(num,2)
data.resample('7D',on = '日期',label = 'right').mean().apply(func)['交易额']

删除工号这一列
data.drop('工号',axis = 1,inplace = True)

按照姓名和柜台进行分组汇总
data = data.groupby(by = ['姓名','柜台']).sum()

查看张三的汇总数据
data.loc['张三',:]

查看张三在蔬菜水果的交易数据
data.loc['张三','蔬菜水果']

丢弃工号列
data.drop('工号',axis = 1,inplace = True)

按照柜台进行排序
dff = data.sort_index(level = '柜台',axis = 0)

按照姓名进行排序
dff = data.sort_index(level = '姓名',axis = 0)

按照柜台进行分组求和
dff = data.groupby(level = '柜台').sum()['交易额']

平均值
data.mean()

标准差
data.std()

协方差
data.cov()

删除缺失值和重复值,inplace = True 直接丢弃
data.dropna(inplace = True)
data.drop_duplicates(inplace = True)

numpy巩固

导包
import numpy as np

创建二维数组
x = np.matrix([[1,2,3],[4,5,6]])

创建一维数组
y = np.matrix([1,2,3,4,5,6])

x 的第二行第二列元素
x[1,1]

矩阵的乘法
x*y

# 相关系数矩阵,可使用在列表元素数组矩阵
# 负相关
np.corrcoef([1,2,3],[8,5,4])
'''
array([[ 1.        , -0.96076892],
       [-0.96076892,  1.        ]])
'''
# 正相关
np.corrcoef([1,2,3],[4,5,7])
'''
array([[1.        , 0.98198051],
       [0.98198051, 1.        ]])
'''

矩阵的方差
np.cov([1,1,1,1,1])

矩阵的标准差
np.std([1,1,1,1,1])

垂直堆叠矩阵
z = np.vstack((x,y))

矩阵的协方差
np.cov(z)

np.cov(x,y)

标准差
np.std(z)

列向标准差
np.std(z,axis = 1)

方差
np.cov(x)

特征值和特征向量
A = np.array([[1,-3,3],[3,-5,3],[6,-6,4]])
e,v = np.linalg.eig(A)
e 为特征值, v 为特征向量

矩阵与特征向量的乘积
np.dot(A,v)

特征值与特征向量的乘积
e * v

验证两个乘积是否相等
np.isclose(np.dot(A,v),(e * v))