python练习01_有一个n*n的整数方阵要求计算出

numpy13道习题练习

#1.创建1个数组，元素为1-1000，提取里面3的倍数的元素和4的倍数的元素并连接放入1个新数组，打印这个新数组。

import numpy as np
array_1=np.arange(100)
array_2=array_1[array_1 %3==0]
array_3=array_1[array_1 %4==0]
array_4=np.append(array_2,array_3)
for i,num in enumerate(array_4):
    print(num,end=",")

1
2
3
4
5
6
7
8
9
10

#2.交换二维数组（n*m）arr中的第i列和第j列。
import numpy as np
def giveArray(n,m):
  a1= np.arange(n*m).reshape(n,m)
  return a1    
def swap1(i,j,a):
 a1=np.array(a)
 print(a1)
 row,column=np.shape(a1)
 for t in range(column):
     k=a[i-1][t]
     a[i-1][t]=a[j-1][t]
     a[j-1][t]=k
ar_1=giveArray(5,7)
swap1(1,2,ar_1)
print(ar_1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#3.反转二维数组（n*m）arr中的行与列。
import numpy as np
def giveArray(n,m):
  a1= np.arange(n*m).reshape(n,m)
  return a1
arr1=giveArray(4,5)[::-1]
print("row",arr1)
arr2=giveArray(4,5)[:,::-1]
print("column",arr2)
1
2
3
4
5
6
7
8
9

#4.创建一个5×5的二维数组，以包含5到100之间的随机数。
import numpy as np
a=np.random.randint(5,100,size=(5,5))
print(a)
1
2
3
4

#5.给定一个n×n的方阵，本题要求计算该矩阵除副对角线、最后一列和最后一行以外的所有元素之和。副对角线为从矩阵的右上角至左下角的连线。
import numpy as np
def giveArray(n,m):
  a1= np.arange(n*m).reshape(n,m)
  return a1
a=giveArray(5,5)
print(a)
sum = 0
n=5
for i in range(n):
    for j in range(n):
        if i+j!=n-1 and i!=n-1 and j!=n-1:
            sum+=a[i][j]
print("sum:",sum)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#6.构造足够多的5*5矩阵，寻找矩阵中的幸运数，即一行中最小的数同时又是一列中最大的数。当幸运数的个数大于2个时，打印出这个矩阵。
import numpy as np
def luckyNumbers(self,matr)->list[int]:
        matrix=np.array(matr)
        m=len(matrix)
        n=len(matrix[0])
        min_row=[]
        max_col=[]
       
        for i in range(m):
            min_row.append(min(matrix[i]))
        for j in range(n):
            max_1=0
            for i in range(m):
                if matrix[i][j]>max_1:
                    max_1=matrix[i][j]
            max_col.append(max_1)
 
        result=[]
        for i in range(m):
            for j in range(n):
                if matrix[i][j]==min_row[i] and matrix[i][j]==max_col[j]:
                    result.append(matrix[i][j])  
                                             
        if len(result)>=2:   
           print(result)     
        return result
while True:
 a=np.random.randint(5,100,size=(5,5))
 if len(luckyNumbers(a,a))>=2 :
  print(a)   
  break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#7.创建随机二维数组，并按行与列排序
import numpy as np
a=np.random.randint(5,100,size=(5,5))
print(a)
a1=np.sort(a,0)
print("a1",a1)
a2=np.sort(a,1)
print("a2",a2)
1
2
3
4
5
6
7
8

#8.创建2个随机二维数组，并将它们相乘
import numpy as np
a=np.random.randint(5,100,size=(5,4))
print("a",a)
b=np.random.randint(5,100,size=(4,5))
print("b",b)
c=np.dot(a,b)
print("c",c)
1
2
3
4
5
6
7
8

#9.创建随机二维数组，并打印它的转置矩阵
import numpy as np
a=np.random.randint(5,100,size=(5,4))
print("a",a)
a=a.transpose()
print("a",a)
1
2
3
4
5
6

#10.创建随机二维5*5数组，打印第1列大于20和第三列小于70的行
import numpy as np
a=np.random.randint(5,100,size=(5,4))
print("a",a)
con=(a[:,0]>20)&(a[:,2]<50)
print(a[con])
1
2
3
4
5
6

#11.野外正在进行8（n=8）口石油勘探井的发掘工作，每一口井能够开发出油的概率是0.3（p=0.3）。请问，最终所有的勘探井都勘探失败的概率？
# -*- coding: GBK -*-
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
np.random.seed(20200605)
n = 8
p = 0.3
size = 50000
x = np.random.binomial(n, p, size)
y = stats.binom.rvs(n, p, size=size)
for i in range(8):
 print(np.sum(x == i) / size)  # 0.3897
plt.hist(x,density=True)
plt.xlabel('success times')
plt.ylabel('appear times')
plt.show()
#它返回一个列表，列表中每个元素表示随机变量中对应值的概率
s = stats.binom.pmf(range(9), n, p)
print(np.around(s, 3))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#12.创建2维数组并进行随机抽样
# -*- coding: GBK -*-
import numpy as np
import random
def giveArray(n,m):
  a1= np.arange(n*m).reshape(n,m)
  return a1
a=giveArray(60,60)
b=a.flatten()
c1=np.random.choice(b,400,False)
print("c1:")
print(c1)
c2=random.sample(list(b),400)
print("c2:")
print(c2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#13.求出矩阵A的伴随矩阵
# -*- coding: GBK -*-
import numpy as np
a=np.random.randint(2,10,size=(5,5))
print("a")
print(a)
a_=np.linalg.det(a)
b=np.linalg.inv(a)
a_b=b*a_
print("a_b")
print(a_b)
1
2
3
4
5
6
7
8
9
10
11

pandas 4道习题练习

这里使用了Automobile_data.csv的数据集，链接：https://download.csdn.net/download/qq_52112285/87530100

#1.找到最贵的汽车公司名称，打印丰田汽车的详细信息
# -*- coding: GBK -*-
import pandas as pd

#引入csv路径
df = pd.read_csv(r"Automobile_data.csv")

df = df [['company','price']][df.price==df['price'].max()]
print (df)
df = pd.read_csv(r"Automobile_data.csv")
car_Manufacturers = df.groupby('company')
toyotaDf = car_Manufacturers.get_group('toyota')
print(toyotaDf)
1
2
3
4
5
6
7
8
9
10
11
12
13

#2.找到每家公司的最高价格汽车；按价格列对所有汽车进行排序
# -*- coding: GBK -*-
import pandas as pd

#引入csv路径
df = pd.read_csv(r"Automobile_data.csv")
car_Manufacturers = df.groupby('company')
mileageDf = car_Manufacturers['company','average-mileage'].mean()
print(mileageDf)
carsDf = df.sort_values(by=['price', 'horsepower'], ascending=False)
print(carsDf.head(5))
1
2
3
4
5
6
7
8
9
10
11

#3.使用以下两个字典创建两个数据框。
#GermanCars = {'Company': ['Ford', 'Mercedes', 'BMV', 'Audi'], 'Price': [23845, 171995, 135925 , 71400]}
#japaneseCars = {'Company': ['Toyota', 'Honda', 'Nissan', 'Mitsubishi '], 'Price': [29995, 23600, 61500 , 58900]}
import pandas as pd

GermanCars = {'Company': ['Ford', 'Mercedes', 'BMV', 'Audi'], 'Price': [23845, 171995, 135925 , 71400]}
carsDf1 = pd.DataFrame.from_dict(GermanCars)

japaneseCars = {'Company': ['Toyota', 'Honda', 'Nissan', 'Mitsubishi '], 'Price': [29995, 23600, 61500 , 58900]}
carsDf2 = pd.DataFrame.from_dict(japaneseCars)

carsDf = pd.concat([carsDf1, carsDf2], keys=["Germany", "Japan"])
print(carsDf)
1
2
3
4
5
6
7
8
9
10
11
12
13

#4.使用以下两个字典创建两个数据框，合并两个数据框，并将第二个数据框作为新列附加到第一个数据框。
#Car_Price = {'Company': ['Toyota', 'Honda', 'BMV', 'Audi'], 'Price': [23845, 17995, 135925 , 71400]}
#car_Horsepower = {'Company': ['Toyota', 'Honda', 'BMV', 'Audi'], 'horsepower': [141, 80, 182 , 160]}
import pandas as pd

Car_Price = {'Company': ['Toyota', 'Honda', 'BMV', 'Audi'], 'Price': [23845, 17995, 135925 , 71400]}
carPriceDf = pd.DataFrame.from_dict(Car_Price)

car_Horsepower = {'Company': ['Toyota', 'Honda', 'BMV', 'Audi'], 'horsepower': [141, 80, 182 , 160]}
carsHorsepowerDf = pd.DataFrame.from_dict(car_Horsepower)

carsDf = pd.merge(carPriceDf, carsHorsepowerDf, on="Company")
print(carsDf)
1
2
3
4
5
6
7
8
9
10
11
12
13

matplotlib 3道习题练习

#1.用matplotlib动态模拟投4000次骰子的柱状图
%matplotlib notebook
import matplotlib.pyplot as plt
import matplotlib.animation
import numpy as np
import random
import seaborn as sns
import sys
def update(frame_number,rolls,values,frequencies):
 plt.cla()
 for i in range(rolls):
     frequencies[random.randrange(1,7)-1]+=1
 #rolls=[random.randrange(1,7) for i in range(rolls)    ]
 #values,frequencies=np.unique(rolls,return_counts=True)  
 title= f'Die frequencies for {sum(frequencies):,} Rolls'  
 sns.set_style("whitegrid")
 axes =sns.barplot(x=values,y=frequencies,palette="bright")
 axes.set_title(title)
  #axes.set(xlabel='Die Value',ylabel="frequency")
 axes.set_ylim(top=max(frequencies)*1.1)
 for bar ,frequency in zip(axes.patches,frequencies):
    text_x=bar.get_x()+bar.get_width()/2
    text_y=bar.get_height()
    text=f'{frequency:,}\n {frequency /sum(frequencies):.3%}'
    axes.text(text_x,text_y,text,fontsize=12,ha="center",va="bottom")
number_of_frames=4000
roll_per_frame =30
sns.set_style("whitegrid")
figure =plt.figure("rolling dice")
values=list(range(1,7))
frequencies=[0]*6
die_animation=matplotlib.animation.FuncAnimation(figure,update,repeat=False,frames=number_of_frames,interval=33,
 fargs=(roll_per_frame,values,frequencies)                                                )
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#2.绘制垂直于x轴x<4 and x>6的参考区域，以及y轴y<0.2 and y>-0.2的参考区域,并标出峰值
# -*- coding: GBK -*-
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0.05, 10, 100)
y = np.sin(x)
plt.plot(x, y)
plt.axvspan(xmin=4, xmax=6, facecolor='r', alpha=0.3) # 垂直x轴
plt.axhspan(ymin=-0.2, ymax=0.2, facecolor='y', alpha=0.3);  # 垂直y轴
plt.text(3.2, 0, 'sin(x)', weight='bold', color='r')
plt.annotate('maximum',xy=(np.pi/2, 1),xytext=(np.pi/2+1, 1),
             weight='bold',
             color='r',
             arrowprops=dict(arrowstyle='->', connectionstyle='arc3', color='r'));
plt.grid()
plt.show()


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#3.绘制图像，将它分到不同区域展示
# -*- coding: GBK -*-
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 10, 1000)
fig, ax = plt.subplots()

lines = []
styles = ['-', '--', '-.', ':']
x = np.linspace(0, 10, 1000)

for i in range(4):
    lines += ax.plot(x, np.sin(x - i * np.pi / 2),styles[i], color='black')
ax.axis('equal')
ax.legend(lines[:2], ['line A', 'line B'],
          loc='upper right', frameon=False)

from matplotlib.legend import Legend
leg = Legend(ax, lines[2:], ['line C', 'line D'],
             loc='lower right', frameon=False)
ax.add_artist(leg)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

10道python习题练习

#1.定义一个至少有两个方法的类:

#getString:从控制台输入获取一个字符串

#printString:打印大写字符串。

class InputOutString(object):
    def __init__(self):
        self.s = ""

    def getString(self):
        print("give your input")
        self.s = input()
    
    def printString(self):
        print(self.s.upper())

strObj = InputOutString()
strObj.getString()
strObj.printString()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#2.输入数字X,Y，生成一个X*Y的二维数组，数组的第i行和第j列的元素值应为i*j。
input_str = input()
dimensions=[int(x) for x in input_str.split(',')]
rowNum=dimensions[0]
colNum=dimensions[1]
multilist = [[0 for col in range(colNum)] for row in range(rowNum)]

for row in range(rowNum):
    for col in range(colNum):
        multilist[row][col]= row*col

print(multilist)
1
2
3
4
5
6
7
8
9
10
11
12

#3.找到1000到3000之间的所有数字(包括这两个数字)，使得每个数字都是偶数。得到的数字应该以逗号分隔的顺序打印在一行上。
values = []
for i in range(1000, 3001):
    s = str(i)
    if (int(s[0])%2==0) and (int(s[1])%2==0) and (int(s[2])%2==0) and (int(s[3])%2==0):
        values.append(s)
print(",".join(values))
1
2
3
4
5
6
7

#4.编写一个程序，根据控制台输入的事务日志计算银行帐户的净额。事务日志格式如下所示:D 100 ,W 200 D代表存款，W代表提款。
netAmount = 0
while True:
    s = input()
    if not s:
        break
    values = s.split(" ")
    operation = values[0]
    amount = int(values[1])
    if operation=="D":
        netAmount+=amount
    elif operation=="W":
        netAmount-=amount
    else:
        pass
print(netAmount)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#5 .检查用户输入的密码是否有效。

#检查密码的标准如下:



#1. [a-z]之间至少有一个字母

#2. [0-9]之间至少有一个数字

#3.[A-Z]之间至少有一个字母

#4. 至少1个[$#@]字符

#5. 交易密码最小长度:6

#6. 交易密码最大长度为12

#您的程序应该接受由逗号分隔的密码序列，并将根据上述标准检查它们。将打印符合条件的密码，每个密码之间用逗号分隔。
import re
netAmount = 0
a_in=input("input your passcode.\n")
a=a_in.split(",")
def showOk(mstr):
    
    kk=[False,False,False,False]
    for j in range(len(mstr)):
     a=[]
     a.append(bool(re.search(r'[a-z]',mstr[j])))
     a.append(bool(re.search(r'[A-Z]',mstr[j])))
     a.append(bool(re.search(r'[0-9]',mstr[j])))
     a.append(bool(re.search(r'[$#@]',mstr[j])))
     p=a.index(True)
     if not(p is None):
       kk[p]=True 
        
    return kk[0] and kk[1] and kk[2] and kk[3] 
t=[]    
for k,i in enumerate(a) :
   
   if len(i)>12 or len(i)<6:
       a.remove(i)
   else:
       b=list(i) 
       if showOk(b):
           t.append("".join(b))  
for k,i in enumerate(t):
    print(i,end=",")   
     
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#6.机器人从原点(0,0)开始在平面上运动。机器人可以按照给定的步骤向上、向下、向左和向右移动。方向后面的数字是步长。请编写一个程序，
#计算经过一系列移动后到当前位置到原点的距离。如果距离是浮点数，则只打印最近的整数。例子:
#UP 5
#DOWN 3
#LEFT 3
#RIGHT 2
#那么，程序的输出应该是:2
import math
pos = [0,0]
while True:
    s = input()
    if not s:
        break
    movement = s.split(" ")
    direction = movement[0]
    steps = int(movement[1])
    if direction=="UP":
        pos[0]+=steps
    elif direction=="DOWN":
        pos[0]-=steps
    elif direction=="LEFT":
        pos[1]-=steps
    elif direction=="RIGHT":
        pos[1]+=steps
    else:
        pass

print(int(round(math.sqrt(pos[1]**2+pos[0]**2))))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#7.定义一个类，它有一个类形参和一个相同的实例形参。可以使用构造参数初始化对象，也可以稍后设置该值.
class Person:
    # Define the class parameter "name"
    name = "Person"
    
    def __init__(self, name = None):
        # self.name is the instance parameter
        self.name = name

Tim = Person("tim")
print("%s name is %s" % (Person.name, Tim.name))

nico = Person()
nico.name = "Nico"
print("%s name is %s" % (Person.name, nico.name))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#8.定义一个名为Shape的类及其子类Square。Square类有一个init函数，它以长度作为参数。这两个类都有一个area函数，
#它可以打印形状的面积，其中shape的面积默认为0。
class Shape(object):
    def __init__(self):
        pass

    def area(self):
        return 0

class Square(Shape):
    def __init__(self, l):
        Shape.__init__(self)
        self.length = l

    def area(self):
        return self.length*self.length

aSquare= Square(3)
print(aSquare.area())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#9.请编写一个使用列表推导式的程序，用控制台输入的给定n以逗号分隔的形式打印斐波那契序列。
def fibo(n):
    p=0
    if n==0:
        return [0]
    elif n==1:
        return [0,1]
    else:
        b=fibo(n-1)
        lb=len(b)
        p=(b[lb-1])+(b[lb-2])
        b.append(p)
        return b
number=int(input("input the number\n")) 
b=fibo(number) 
for i,j in enumerate(b):
    print(j,end=",")  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#10.编写一个二分搜索函数，在排序列表中搜索一个项。该函数应返回列表中要搜索的元素的索引。

import math
def bin_search(li, element):
    bottom = 0
    top = len(li)-1
    index = -1
    while top>=bottom and index==-1:
        mid = int(math.floor((top+bottom)/2.0))
        if li[mid]==element:
            index = mid
        elif li[mid]>element:
            top = mid-1
        else:
            bottom = mid+1

    return index

li=[2,5,7,9,11,17,222]
print(bin_search(li,11))
print(bin_search(li,12))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

图灵测试是指测试者在与被测试者（一个人和一台机器）隔开的情况下，通过一些装置（如键盘）向被测试者随意提问。进行多次测试后，如果有超过30%的测试者不能确定出被测试者是人还是机器，那么这台机器就通过了测试，并被认为具有人类智能。图灵测试一词来源于计算机科学和密码学的先驱阿兰·麦席森·图灵写于1950年的一篇论文《计算机器与智能》，其中30%是图灵对2000年时的机器思考能力的一个预测，目前我们已远远落后于这个预测。
要回答此类问题，应答者要对人类语言的细微之处和人类社会交际本质有着足够深刻的理解。这正是计算机科学家目前仍然无法用数学语言所描述的。
在一间小黑屋里，有这样三个角色：一个人类评审员，两个受试者A和B。其中一个受试者是计算机的人工智能程序，另一个受试者是人类。

评审员无法直接看到受试者，只能通过打字的方式，与两名受试者进行提问沟通。

经过多次的询问和回答，最后由评审员来判断：哪一个受试者是人类，哪一个受试者是计算机。
如果评审员判断错误的几率超过30%，那就说明计算机成功地伪装成人类，骗过了受试者，从而可以认为这样的计算机已经具备了一定的思考能力。

例如六位整数的乘法运算，普通人类根本不可能在短时间内计算出来，如果受试者在一秒内就给出了正确结果，那就太不自然了，显然是计算机程序的回答。

所以，要想让计算机伪装成人类受试者，要学会在某些时候“装傻”。

对于重复的问题，如果受试者只是机械地做出同样的回答，那毫无疑问就是计算机程序了。而人类受试者有自己的情绪，一般不愿意去回答重复的问题。

所以，要想让计算机伪装成人类受试者，要学会模拟人类的情绪。