Python环境配置与数据处理

最新推荐文章于 2023-11-22 18:19:42 发布

Fu-yu

最新推荐文章于 2023-11-22 18:19:42 发布

阅读量727

点赞数 1

文章标签： python numpy 机器学习

本文链接：https://blog.csdn.net/weixin_53573350/article/details/129433355

版权

文章目录

一、使用jupyter完成numpy练习题
二、完成python例题
三、numpy、pandas、matplotlib库的使用
1、NumPy
- 2、Pandas
- 3、Matplotlib
四、什么是图灵测试？
总结

一、使用jupyter完成numpy练习题

导入相关库：

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

1、创建一个长度为10的一维全为0的ndarray对象，然后让第5个元素等于1

s1 = np.zeros(shape=10)
s1

array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

s1[4]=1
s1

array([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])

2、创建一个元素为从10到49的ndarray对象

np.random.randint(10,50,size=10)

array([30, 40, 20, 29, 15, 31, 44, 43, 39, 16])

np.linspace(10,49,10)

array([10.        , 14.33333333, 18.66666667, 23.        , 27.33333333,
       31.66666667, 36.        , 40.33333333, 44.66666667, 49.        ])

a=np.arange(10,50)
a

array([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])

3、将第2题的所有元素位置反转

a[::-1]

array([49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33,
       32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
       15, 14, 13, 12, 11, 10])

4、使用np.random.random创建一个10*10的ndarray对象，并打印出最大最小元素

a4=np.random.random(size=(10,10))
a4

array([[0.84963344, 0.52193858, 0.40046462, 0.91688202, 0.33948197,
        0.18229247, 0.20290391, 0.14684504, 0.09105184, 0.38096906],
       [0.78893725, 0.35469795, 0.56324011, 0.15918106, 0.16595219,
        0.9600235 , 0.08428207, 0.53306459, 0.58896476, 0.81656599],
       [0.01204347, 0.05254314, 0.89499528, 0.34365146, 0.87412094,
        0.97189492, 0.09538986, 0.2685505 , 0.01271626, 0.04886558],
       [0.84413439, 0.57868676, 0.00381633, 0.09407042, 0.82364586,
        0.28078574, 0.1815065 , 0.86463671, 0.83517863, 0.55315357],
       [0.72349285, 0.97060785, 0.34913176, 0.30378778, 0.66865014,
        0.72219816, 0.24682824, 0.76280834, 0.62427318, 0.04165361],
       [0.07294234, 0.72374661, 0.23570441, 0.96002683, 0.16271328,
        0.92591483, 0.50789039, 0.03163551, 0.26854299, 0.53866947],
       [0.05959793, 0.25098973, 0.91568194, 0.05362635, 0.04214313,
        0.27564456, 0.23721149, 0.83185231, 0.49989365, 0.41739213],
       [0.43569383, 0.60168255, 0.59438072, 0.62796623, 0.52094514,
        0.9573592 , 0.04193474, 0.56189379, 0.97340363, 0.12791454],
       [0.48119751, 0.28793064, 0.22574439, 0.3882722 , 0.71614186,
        0.36532182, 0.22203905, 0.39183272, 0.23674981, 0.24011717],
       [0.47522477, 0.33882795, 0.33241641, 0.89353453, 0.7186746 ,
        0.76697417, 0.56340086, 0.02186578, 0.10413262, 0.65368922]])

zmin,zmax=a4.min(),a4.max()
zmin,zmax

(0.003816329434768506, 0.9734036266212456)

5、创建一个10*10的ndarray对象，且矩阵边界全为1，里面全为0

import numpy as np
nd = np.zeros(shape=(10,10),dtype = np.int8)
nd[[0,9]]=1
nd[:,[0,9]]=1
nd

array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
       [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
       [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], dtype=int8)

a5 = np.ones((10,10))
a5

array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])

a5[1:-1,1:-1]=0
a5

array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])

6、创建一个每一行都是从0到4的5*5矩阵

l= [0,1,2,3,4]
nd = np.array( l * 5 )
nd.reshape(5,5)

array([[0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4]])

nd6_1=np.arange(0,5,1)
nd6_1

array([0, 1, 2, 3, 4])

nd6=np.arange(0,25).reshape(5,5)
nd6

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])

nd6[0:5]=nd6_1
nd6

array([[0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4]])

7、创建一个范围在(0,1)之间的长度为12的等差数列

np.linspace(0,1,12)

array([0.        , 0.09090909, 0.18181818, 0.27272727, 0.36363636,
       0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182,
       0.90909091, 1.        ])

8、创建一个长度为10的随机数组并排序

a8=np.random.random(10)
a8

array([0.96886843, 0.8796034 , 0.35797692, 0.34376246, 0.82445199,
       0.49888544, 0.79513371, 0.98232429, 0.17530282, 0.67737586])

np.sort(a8)

array([0.17530282, 0.34376246, 0.35797692, 0.49888544, 0.67737586,
       0.79513371, 0.82445199, 0.8796034 , 0.96886843, 0.98232429])

a8.argsort()

array([8, 3, 2, 5, 9, 6, 4, 1, 0, 7], dtype=int64)

a8[a8.argsort()]

array([0.17530282, 0.34376246, 0.35797692, 0.49888544, 0.67737586,
       0.79513371, 0.82445199, 0.8796034 , 0.96886843, 0.98232429])

9、创建一个长度为10的随机数组并将最大值替换为-100

nd = np.random.randint(0,10,size=10)
display(nd)
index_max = nd.argmax()

array([0, 5, 7, 6, 9, 2, 6, 8, 7, 1])

nd[index_max]

all_index_max= np.argwhere(nd == nd[index_max]).reshape(-1)
all_index_max

array([4], dtype=int64)

nd[all_index_max]=-100
nd

array([   0,    5,    7,    6, -100,    2,    6,    8,    7,    1])

10、如何根据第3列来对一个5*5矩阵排序

n10=np.random.randint(0,100,size=(5,5))
n10

array([[ 9, 53, 13, 30, 46],
       [85, 87, 81, 42, 72],
       [90, 95, 97, 87,  9],
       [24, 28, 10, 50,  2],
       [15, 49, 75, 42, 31]])

n10[:,2]

array([13, 81, 97, 10, 75])

np.argsort(n10[:,2])

array([3, 0, 4, 1, 2], dtype=int64)

n10[np.argsort(n10[:,2])]

array([[24, 28, 10, 50,  2],
       [ 9, 53, 13, 30, 46],
       [15, 49, 75, 42, 31],
       [85, 87, 81, 42, 72],
       [90, 95, 97, 87,  9]])

11、给定一个4维矩阵，如何得到最后两维的和

n11=np.random.randint(0,100,size=(2,3,3,3))
n11

array([[[[ 3, 46, 22],
         [59, 17, 86],
         [93, 48, 64]],

        [[ 5, 67, 66],
         [46, 25,  2],
         [95, 36, 46]],

        [[16, 15,  7],
         [ 9, 19, 73],
         [20, 47, 78]]],


       [[[43, 39, 33],
         [98, 29, 74],
         [72, 88, 66]],

        [[ 7, 92, 75],
         [20, 61, 22],
         [92, 19, 55]],

        [[90, 44,  3],
         [44, 17, 45],
         [53, 11, 64]]]])

n11.sum(axis=(2,3))

array([[438, 388, 284],
       [542, 443, 371]])

n11.sum(axis=(-1,-2))

array([[438, 388, 284],
       [542, 443, 371]])

12、给定数组[1, 2, 3, 4, 5]，如何得到在这个数组的每个元素之间插入3个0后的新数组

nd1=np.arange(1,6)
nd2=np.zeros(shape=17,dtype=int)
nd2[::4]=nd1
nd2

array([1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5])

n12=np.array([1,2,3,4,5]).reshape(5,1)
n12

array([[1],
       [2],
       [3],
       [4],
       [5]])

n12_1=np.zeros((5,3))
n12_1

array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

n12=np.concatenate([n12,n12_1],axis=1)
n12

array([[1., 0., 0., 0.],
       [2., 0., 0., 0.],
       [3., 0., 0., 0.],
       [4., 0., 0., 0.],
       [5., 0., 0., 0.]])

n12.reshape(-1)

array([1., 0., 0., 0., 2., 0., 0., 0., 3., 0., 0., 0., 4., 0., 0., 0., 5.,
       0., 0., 0.])

13、给定一个二维矩阵，如何交换其中两行的元素？

n13=np.random.randint(0,100,size=(3,3))
n13

array([[32, 21, 16],
       [66, 92, 34],
       [67,  0, 25]])

n13[[0,2,1]]

array([[32, 21, 16],
       [67,  0, 25],
       [66, 92, 34]])

14、创建一个100000长度的随机数组，使用两种方法对其求三次方，并比较所用时间

n14=np.random.random(size=1000)
n14=np.random.randint (0,1000000,(5))
n14

array([ 21080, 517749, 198604, 352682, 915069])

%timeit np.power(n14,3)

1.83 µs ± 168 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit n14**3

1.6 µs ± 209 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

n14_2=np.dot(n14,n14)
%timeit np.dot(n14_2,n14)

3.13 µs ± 395 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

15、创建一个5 * 3随机矩阵和一个3 * 2随机矩阵，求矩阵积

n15_53=np.random.randint(0,100,size=(5,3))
n15_53

array([[93, 80, 74],
       [61, 85, 94],
       [30, 50, 16],
       [38, 92, 82],
       [49, 93, 74]])

n15_32=np.random.randint(0,100,size=(3,2))
n15_32

array([[28, 21],
       [38,  8],
       [84, 93]])

np.dot(n15_53,n15_32)

array([[11860,  9475],
       [12834, 10703],
       [ 4084,  2518],
       [11448,  9160],
       [11122,  8655]])

16、矩阵的每一行的元素都减去该行的平均值

n16=np.random.randint(0,100,size=(3,3))
n16

array([[29, 49, 94],
       [43, 92, 62],
       [67, 84, 63]])

n16_1=n16.mean(axis=1).reshape(3,1)#对行求平均值
n16_1

array([[57.33333333],
       [65.66666667],
       [71.33333333]])

n16-n16_1

array([[-28.33333333,  -8.33333333,  36.66666667],
       [-22.66666667,  26.33333333,  -3.66666667],
       [ -4.33333333,  12.66666667,  -8.33333333]])

17、打印出以下函数（要求使用np.zeros创建8*8的矩阵）：

[[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]]

nd=np.ones(shape=(8,8),dtype=int)
nd[::2,::2]=0
nd[1::2,1::2]=0
nd

array([[0, 1, 0, 1, 0, 1, 0, 1],
       [1, 0, 1, 0, 1, 0, 1, 0],
       [0, 1, 0, 1, 0, 1, 0, 1],
       [1, 0, 1, 0, 1, 0, 1, 0],
       [0, 1, 0, 1, 0, 1, 0, 1],
       [1, 0, 1, 0, 1, 0, 1, 0],
       [0, 1, 0, 1, 0, 1, 0, 1],
       [1, 0, 1, 0, 1, 0, 1, 0]])

n17=np.zeros(shape=(8,8))
n17

array([[0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0.]])

n17[1::2,1::2]=1
n17[::2,::2]=1
n17

array([[1., 0., 1., 0., 1., 0., 1., 0.],
       [0., 1., 0., 1., 0., 1., 0., 1.],
       [1., 0., 1., 0., 1., 0., 1., 0.],
       [0., 1., 0., 1., 0., 1., 0., 1.],
       [1., 0., 1., 0., 1., 0., 1., 0.],
       [0., 1., 0., 1., 0., 1., 0., 1.],
       [1., 0., 1., 0., 1., 0., 1., 0.],
       [0., 1., 0., 1., 0., 1., 0., 1.]])

18、正则化一个5*5随机矩阵
【正则的概念：假设a是矩阵中的一个元素，max/min分别是矩阵元素的最大最小值，则正则化后a = (a - min)/(max - min)】

nd=np.random.randint(0,100,size=(5,5))
v_min=nd.min()
v_max=nd.max()
(nd-v_min)/(v_max-v_min)

array([[0.92857143, 0.28571429, 0.15306122, 0.23469388, 1.        ],
       [0.75510204, 0.67346939, 0.80612245, 0.34693878, 0.40816327],
       [0.16326531, 0.12244898, 0.56122449, 0.17346939, 0.79591837],
       [0.33673469, 0.36734694, 0.        , 1.        , 0.71428571],
       [0.43877551, 0.14285714, 0.2755102 , 0.17346939, 0.10204082]])

n18=np.random.randint(0,100,size=(5,5))
n18

array([[51,  2, 95, 33, 90],
       [45, 14, 76, 19, 11],
       [24,  5, 35, 60,  9],
       [23, 59, 14, 16, 78],
       [83, 17, 74, 16, 21]])

nmax,nmin=n18.max(),n18.min()
nmax,nmin

(95, 2)

n18=(n18-nmin)/(nmax-nmin)
n18

array([[0.52688172, 0.        , 1.        , 0.33333333, 0.94623656],
       [0.46236559, 0.12903226, 0.79569892, 0.1827957 , 0.09677419],
       [0.23655914, 0.03225806, 0.35483871, 0.62365591, 0.07526882],
       [0.22580645, 0.61290323, 0.12903226, 0.15053763, 0.8172043 ],
       [0.87096774, 0.16129032, 0.77419355, 0.15053763, 0.20430108]])

19、将一个一维数组转化为二进制表示矩阵。例如
[1,2,3]
转化为
[[0,0,1],
[0,1,0],
[0,1,1]]

1 and 0

1 or 1

1 & 2

I=np.array([1,2,3])
I

array([1, 2, 3])

A=I.reshape(-1,1)
A

array([[1],
       [2],
       [3]])

B=2**np.arange(3)
B

array([1, 2, 4], dtype=int32)

M=A&B
M

array([[1, 0, 0],
       [0, 2, 0],
       [1, 2, 0]], dtype=int32)

M != 0
M

array([[1, 0, 0],
       [0, 2, 0],
       [1, 2, 0]], dtype=int32)

M[M !=0]=1
M

array([[1, 0, 0],
       [0, 1, 0],
       [1, 1, 0]], dtype=int32)

M[:,::-1]
M

array([[1, 0, 0],
       [0, 1, 0],
       [1, 1, 0]], dtype=int32)

20、实现冒泡排序法

n20=[12,32,22,14,14,67,44,32,87,54,15]
for i in range(len(n20)-1):
    for j in range(len(n20)-i-1):
        if n20[j]>n20[j+1]:
            n20[j],n20[j+1]=n20[j+1],n20[j]
n20

[12, 14, 14, 15, 22, 32, 32, 44, 54, 67, 87]

二、完成python例题

1、python语言综合示例——好好学习，天天向上

import random #包含随机数模块，以生成随机数
#定义fib_loop函数，构造斐波那锲数列
def fib_loop(n):
    listNum=[]
    a,b=0,1
    # for结构，循环体重复运行n次
    for i in range(n):
        a,b=b,a+b
        listNum.append(a)
        #print(i,listNum)#把注释符号去掉，可以查看运行结果
    return listNum #返回一个数据列表listNum
listPlan=['吃零食','学习','学习','学习','看电影','学习','旅游','睡觉','学习']
listNum=fib_loop(6)#调用fib_loop函数生成斐波那锲数列
varIdx=random.randint(0,5)#生成0~5的随机数varIdx
varRandom=listNum[varIdx]
print ('今日计划',listPlan[varRandom])

今日计划 学习

2、数值类型不可改变

i=3
print(id(i))
i+=1
print(id(i))

2944003107184
2944003107216

通过id函数，可以看到变量i在加1后，内存已经改变。也就是说，i+=1不是原有的int对象增加1，而是重新创建了一个int对象，其值为4.

3、字符串的访问

str = 'Picture'
print(str[1:3])#第二、三个字符
print(str[-3:-1])#倒数第二、三个字符
print(str[3:-1])#正数第四个到倒数第二个字符
print(str[-6:7])#倒数第六个到正数第七个字符
print(str[2:])#第三个字符开始的所有字符
print(str*2)#输出字符串两次
print(str+"TEST")#连接字符串

ic
ur
tur
icture
cture
PicturePicture
PictureTEST

4、列表的访问

list = ['a',56,1.13,'HelloWorld',[7,8,9]]
print(list)#完整列表
print([list[4]])#第五个元素
print(list[-2:5])#倒数第二个到正数第五个元素
print(list[2:])#第三个元素开始的所有元素

['a', 56, 1.13, 'HelloWorld', [7, 8, 9]]
[[7, 8, 9]]
['HelloWorld', [7, 8, 9]]
[1.13, 'HelloWorld', [7, 8, 9]]

5、列表元素的修改

a=[1,2,3,4,5,6]
a[0]=9#将第一个元素设为9
print(a)
a.append(7)#在列表末尾追加7
print(a)
a[2:5]=[]#将第三列第五个元素值设为空值
print(a)
a.pop(2)#将第三个元素移除
print(a)

[9, 2, 3, 4, 5, 6]
[9, 2, 3, 4, 5, 6, 7]
[9, 2, 6, 7]
[9, 2, 7]

6、列表的遍历

lis=['重庆','北京','上海','天津']
#（1）直接遍历
for item in lis:
    print(item)
#(2)按索引遍历
for i in enumerate(lis):
    print(i)
#(3)通过下标遍历
for i in range(len(lis)):
    print (lis[i])

重庆
北京
上海
天津
(0, '重庆')
(1, '北京')
(2, '上海')
(3, '天津')
重庆
北京
上海
天津

7、元组的访问

tuple=('SpiderMan',2017,33.4,'Homecoming',14)
tinytule=(16,'Marvel')
print(tuple)#输出完整元组
print(tuple[0])#输出元组第一个元素
print(tuple[3:4])#输出第四个元组
print(tuple+tinytule)#连接元组

('SpiderMan', 2017, 33.4, 'Homecoming', 14)
SpiderMan
('Homecoming',)
('SpiderMan', 2017, 33.4, 'Homecoming', 14, 16, 'Marvel')

8、字典的访问

dict = {'Name':'Mary','Age':7,'Class':'First'};
print(dict)
print('Name:',dict['Name'])
print('Age:',dict['Age'])

{'Name': 'Mary', 'Age': 7, 'Class': 'First'}
Name: Mary
Age: 7

9、修改删除字典

dict = {'Name':'Zara','Class':'First'};
print(dict)
#添加add
dict['Gender']="Female"
print(dict)
#修改update
dict.update({"No":"001"})
print(dict)
#可以使用update方法添加、修改多个数据
dict.update({'Gender':"F","Id":1})
print(dict)
#删除一个字典键用del命令
del dict['Gender']
print(dict)
#清空字典用clear命令
dict.clear()
print(dict)

{'Name': 'Zara', 'Class': 'First'}
{'Name': 'Zara', 'Class': 'First', 'Gender': 'Female'}
{'Name': 'Zara', 'Class': 'First', 'Gender': 'Female', 'No': '001'}
{'Name': 'Zara', 'Class': 'First', 'Gender': 'F', 'No': '001', 'Id': 1}
{'Name': 'Zara', 'Class': 'First', 'No': '001', 'Id': 1}
{}

10、创建集合并对集合成员进行检验

#创建一个空集合
var = set()
#显示集合内容及类型
print(var,type(var))
#具有数据的集合
var={'LiLei','HanMeiMei','ZhangHua','LiLei','LiLei'}
print(var,type(var))
#判断元素在集合内
result = 'LiLei' in var
print(result)
#判断元素不在集合内
result = 'lilei'not in var   #大小写敏感
print(result)

set() <class 'set'>
{'HanMeiMei', 'ZhangHua', 'LiLei'} <class 'set'>
True
True

11、添加删除集合元素

var={'LiLei','HanMeiMei','ZhangHua'}
#add方法添加元素
var.add('LiBai')
print(var)
#update方法首先拆分元素，然后依次添加
var.update('DuFu')
print(var)#数据项无序，且去除重复项
var.remove('D')
var.remove('F')
var.remove('u')
print(var)

{'HanMeiMei', 'ZhangHua', 'LiLei', 'LiBai'}
{'u', 'HanMeiMei', 'ZhangHua', 'LiBai', 'LiLei', 'D', 'F'}
{'HanMeiMei', 'ZhangHua', 'LiBai', 'LiLei'}

12、集合的遍历

anml=('紫貂','松貂','青鼬','狼獾')
for item in anml:
    print(anml)

('紫貂', '松貂', '青鼬', '狼獾')
('紫貂', '松貂', '青鼬', '狼獾')
('紫貂', '松貂', '青鼬', '狼獾')
('紫貂', '松貂', '青鼬', '狼獾')

anml=('紫貂','松貂','青鼬','狼獾')
for item in enumerate(anml):
    print(anml)

('紫貂', '松貂', '青鼬', '狼獾')
('紫貂', '松貂', '青鼬', '狼獾')
('紫貂', '松貂', '青鼬', '狼獾')
('紫貂', '松貂', '青鼬', '狼獾')

13、集合的交集、并集（合集）、差集

#分别构造獾和貂两个集合
Huan={'猪獾','蜜獾','狼獾'}
Diao={'紫貂','松貂','美洲水鼬','狼獾'}
#交集
DiaoXiong=Huan&Diao
print('貂熊是：',DiaoXiong)
#并集
Youke=Huan|Diao
print('鼬科的是：',Youke)
#差集
DiaoT=Diao-Huan
print('除去獾的貂类：',DiaoT)

貂熊是： {'狼獾'}
鼬科的是： {'紫貂', '蜜獾', '猪獾', '松貂', '美洲水鼬', '狼獾'}
除去獾的貂类： {'紫貂', '美洲水鼬', '松貂'}

三、numpy、pandas、matplotlib库的使用

1、NumPy

1、创建一个一维ndarray数组、二维数组

import numpy as np
#创建一个一维数组
a = np.array([1,2,3])
print (a)
#创建一个二维数组
b = np.array([[1,2],[2,3]])
print (b)
#使用ndmin参数设置数组的最小维度
c = np.array([1,2,3,4,5],ndmin=2)
print (c)
#使用dtype参数设置数组类型为复数
d = np.array([[1,2,3],[4,5,6]],dtype = complex)
print(d)
d1=d.itemsize # 每个元素所占用的字节数目
d2=d.dtype.name # 元素类型
d1,d2

[1 2 3]
[[1 2]
 [2 3]]
[[1 2 3 4 5]]
[[1.+0.j 2.+0.j 3.+0.j]
 [4.+0.j 5.+0.j 6.+0.j]]





(16, 'complex128')

2、使用axis参数设置当前轴

import numpy as np
arr = np.array([[0,1,2],[3,4,5]])
print (arr)
print(arr.sum(axis=0))
print(arr.sum(axis=1))

[[0 1 2]
 [3 4 5]]
[3 5 7]
[ 3 12]

在这个程序中，首先使用arr.sum(axis=0)进行垂直（列）方向的求和计算，然后使用arr.sum(axis=1)沿行方向进行计算。

3、生成3~9的步长为0.2的数组

import numpy as np
arr = np.arange(3,9,0.2)
print(arr)

[3.  3.2 3.4 3.6 3.8 4.  4.2 4.4 4.6 4.8 5.  5.2 5.4 5.6 5.8 6.  6.2 6.4
 6.6 6.8 7.  7.2 7.4 7.6 7.8 8.  8.2 8.4 8.6 8.8]

4、创建随机数组

#生成2行3列的随机浮点数组
a = np.random.rand(2,3)
#生成2行2列的10以内的随机整数数组
b = np.random.randint(0,10,(2,2))
#生成2行3列的[1,2)的随机浮点数组
c = np.random.uniform(1,2,(2,3))
print (a)
print (b)
print (c)

[[0.71798114 0.71857507 0.62217763]
 [0.69723009 0.22672762 0.44218167]]
[[6 7]
 [5 1]]
[[1.07755923 1.53177621 1.31095518]
 [1.84774781 1.97211294 1.04802871]]

5、创建二维ndarray的切片

import numpy as np
#创建一个4行6列的二维数组
arr = np.arange(24).reshape(4,6)
print('arr=\n',arr)
#截取第二行到最后一行、第一列到第三列的ndarray
arr1 = arr[1:,:3]
print('B=\n',arr1)

arr=
 [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
B=
 [[ 6  7  8]
 [12 13 14]
 [18 19 20]]

6、转置数组的迭代

import numpy as np
a = np.arange(0,60,5).reshape(3,4)
print(a)
b = a.T
print(b)
print('Iterator in a:')
for x in np.nditer(a):
    print(x,end='|')
print ('\nIterator in a.T:')
for y in np.nditer(b):
    print(y,end='|')

[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
Iterator in a:
0|5|10|15|20|25|30|35|40|45|50|55|
Iterator in a.T:
0|5|10|15|20|25|30|35|40|45|50|55|

7、ndarray的统计计算

import numpy as np
a = np.array([[80,88],[82,81],[84,75],[86,83],[75,81]])
#求每列的最大值（0表示列，1表示行）
result = np.max(a,axis=0)
print(result)
#求每行的最大值
result = np.max(a,axis=1)
print(result)
#求每行的最小值
result = np.min(a,axis=1)
print(result)
#求每列的平均值
result = np.mean(a,axis=0)
print(result)

[86 88]
[88 82 84 86 81]
[80 81 75 83 75]
[81.4 81.6]

2、Pandas

1、从字典数据创建DateFrame

import pandas as pd


dict = {'col1': [1,2,None], 'col2': ['a','b', None]}  # 注意：All arrays must be of the same length，也就是说数组的长度应该要相同，不相同的话可以使用None进行占位
df = pd.DataFrame(dict)
print(df)

   col1  col2
0   1.0     a
1   2.0     b
2   NaN  None

2、由列表组成的字典创建DateFrame

import pandas as pd


list1 = [1,2,3]
list2 = [2,3,4]
df = pd.DataFrame({'col1': list1, 'col2': list2})
print(df)

   col1  col2
0     1     2
1     2     3
2     3     4

3、创建series对象

import pandas as pd
import numpy as np

s1 = pd.Series([1,2,3,4,5])
print(s1)
s2 = pd.Series({"a": 1, "b": 2})  # 字典创建Series，索引值为字典的key值
print(s2['a'])
s3 = pd.Series(data=[1,2,3,4,5], index=np.arange(0,1,0.2))  # 索引值不一定是整数，还可以是其他的一些类型
print(s3[0.2])

0    1
1    2
2    3
3    4
4    5
dtype: int64
1
2

4、增加数据成员：(两个Series对象进行拼接)

import pandas as pd


arr = pd.Series(range(0, 5, 1))
print(arr)
arr = arr.append(arr)
print(arr)

0    0
1    1
2    2
3    3
4    4
dtype: int64
0    0
1    1
2    2
3    3
4    4
0    0
1    1
2    2
3    3
4    4
dtype: int64


C:\Users\Fuyu\AppData\Local\Temp\ipykernel_70232\4061751448.py:6: FutureWarning: The series.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.
  arr = arr.append(arr)

5、使用Pandas模块求方差

import numpy as np
import pandas as pd
a = np.arange(0,60,5)
a = a.reshape(3,4)
df = pd.DataFrame(a)
print (df)
print('-----------')
print (df.std())

    0   1   2   3
0   0   5  10  15
1  20  25  30  35
2  40  45  50  55
-----------
0    20.0
1    20.0
2    20.0
3    20.0
dtype: float64

3、Matplotlib

1、绘制简单的plot图标

import matplotlib.pyplot as plt
fig = plt.figure()
ax1 = fig.add_subplot(2,2,1)
ax2 = fig.add_subplot(2,2,3)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qps83tVv-1678374098583)(output_148_0.png)]

2、绘制sin（x）函数图形

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-10, 10, 100)
y = np.sin(x)
plt.plot(x, y, marker='o')
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DyZa6ryq-1678374098584)(output_150_0.png)]

3、绘制3d图

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

def randrange(n, randFloor, randCeil):
    rnd = np.random.rand(n)  # 生成n个随机数
    return (randCeil - randFloor) * rnd + randFloor

plt.rcParams['font.sans-serif']=['SimHei']  # 设置中文
fig = plt.figure(figsize=(10, 8)) 
ax = fig.add_subplot(111, projection='3d')  # 添加子3D坐标轴
n = 100
for zmin, zmax, c, m, l in [(4,15,'r','o', '低值'), (13,40,'g','*', '高值')]:
    x = randrange(n, 0, 20)
    y = randrange(n, 0, 20)
    z = randrange(n, zmin, zmax)
    ax.scatter(x, y, z, c=c, marker=m, label=l, s=z*6)

ax.set_xlabel('X-value')
ax.set_ylabel('Y-value')
ax.set_zlabel('Z-value')

ax.set_title('高/低值3D散点图', alpha=0.6, size=15, weight='bold')
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sbgI2lKo-1678374098585)(output_152_0.png)]

4、绘制直线曲线图

import matplotlib.pyplot as plt
import numpy as np

a = np.arange(0,10,1)
plt.xlabel('x')
plt.ylabel('y')
plt.plot(a, a * 1.5, a, a * 2, a, a * a)  # 里面的参数一共分为三组，(（a, a * 1.5）, （a, a * 2）, （a, a * a)）
plt.legend(['1.5x', '2.0x', 'x*x'])
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vtWd1iUL-1678374098585)(output_154_0.png)]

四、什么是图灵测试？

图灵测试（The Turing test）由艾伦·麦席森·图灵提出，指测试者与被测试者（一个人和一台机器）隔开的情况下，通过一些装置（如键盘）向被测试者随意提问。

图灵采用“问”与“答”模式，即观察者通过控制打字机向两个测试对象通话，其中一个是人，另一个是机器。要求观察者不断提出各种问题，从而辨别回答者是人还是机器。图灵还为这项测试亲自拟定了几个示范性问题：

问：请给我写出有关“第四号桥”主题的十四行诗。

答：不要问我这道题，我从来不会写诗。

问：34957加70764等于多少？

答：（停30秒后）105721

问：你会下国际象棋吗？

答：是的。

问：我在我的K1处有棋子K；你仅在K6处有棋子K，在R1处有棋子R。轮到你走，你应该下哪步棋？

答：（停15秒钟后）棋子R走到R8处，将军！

图灵指出：“如果机器在某些现实的条件下，能够非常好地模仿人回答问题，以至提问者在相当长时间里误认它不是机器，那么机器就可以被认为是能够思维的。”

从表面上看，要使机器回答按一定范围提出的问题似乎没有什么困难，可以通过编制特殊的程序来实现。然而，如果提问者并不遵循常规标准，编制回答的程序是极其困难的事情。例如，提问与回答呈现出下列状况：

问：你会下国际象棋吗？

答：是的。

问：你会下国际象棋吗？

答：是的。

问：请再次回答，你会下国际象棋吗？

答：是的。

你多半会想到，面前的这位是一部笨机器。如果提问与回答呈现出另一种状态：

问：你会下国际象棋吗？

答：是的。

问：你会下国际象棋吗？

答：是的，我不是已经说过了吗？

问：请再次回答，你会下国际象棋吗？

答：你烦不烦，干嘛老提同样的问题。

那么，你面前的这位，大概是人而不是机器。上述两种对话的区别在于，第一种可明显地感到回答者是从知识库里提取简单的答案，第二种则具有分析综合的能力，回答者知道观察者在反复提出同样的问题。“图灵测试”没有规定问题的范围和提问的标准，如果想要制造出能通过试验的机器，以我们的技术水平，必须在电脑中储存人类所有可以想到的问题，储存对这些问题的所有合乎常理的回答，并且还需要理智地作出选择。