【数学建模学习笔记【集训十天】之第二天】，面试题分享

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型.

常用 NumPy 基本类型

名称 描述
bool_ :【布尔型数据类型（True 或者 False）】
int_ : 【默认的整数类型（类似于 C 语言中的 long，int32 或 int64）】
intc :【与 C 的 int 类型一样，一般是 int32 或 int 64】
intp :【用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）】
int8 :【字节（-128 to 127）】
int16 :【整数（-32768 to 32767）】
int32 :【整数（-2147483648 to 2147483647）】
int64 ：【整数（-9223372036854775808 to 9223372036854775807）】
uint8 ：【无符号整数（0 to 255）】
uint16 ：【无符号整数（0 to 65535）】
uint32 ：【无符号整数（0 to 4294967295）】
uint64 ：【无符号整数（0 to 18446744073709551615）】
float_ float64 ：【类型的简写】
float16 ：【半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位】
float32 ：【单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位】
float64 ：【双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位】
complex_ complex128： 【类型的简写，即 128 位复数】
complex64 ：【复数，表示双 32 位浮点数（实数部分和虚数部分）】
complex128 ：【复数，表示双 64 位浮点数（实数部分和虚数部分）】

相关学习、代码如下：

'''

# numpy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括 np.bool\_，np.int32，np.float32，等等。

'''


#　Numpy 类型对象：
'''
dtype 对象是使用以下语法构造的：

numpy.dtype(object, align, copy)

object - 要转换为的数据类型对象
align - 如果为 true，填充字段使其类似 C 的结构体。
copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

'''

# 1: 使用标量类型
import numpy as np

lxw = np.dtype(np.int32)
print(lxw)


print()
# 2: int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
import numpy as np

lxw2 = np.dtype('i8')       # int64
print(lxw2)


print()
# 3: 字节顺序标注
import numpy as np

lxw3 = np.dtype('<i4')      # int32
print(lxw3)


print()
# 4: 首先创建结构化数据类型
import numpy as np

lxw4 = np.dtype([('age', np.int8)])     # i1
print(lxw4)


print()
# 5: 将数据类型应用于 ndarray 对象
import numpy as np

lxw5 = np.dtype([('age', np.int32)])
a = np.array([(10,), (20,), (30,)], dtype=lxw5)
print(a)


print()
# 6: 类型字段名可以用于存取实际的 age 列
import numpy as np

lxw6 = np.dtype([('age', np.int64)])
a = np.array([(10,), (20,), (30,)], dtype=lxw6)
print(a['age'])


print()
# 7: 定义一个结构化数据类型 student，包含字符串字段 name，整数字段 age，及浮点字段 marks，并将这个 dtype 应用到 ndarray 对象
import numpy as np

student = np.dtype([('name', 'S20'), ('age', 'i2'), ('marks', 'f4')])
print(student)      # 运行结果：[('name', 'S20'), ('age', '<i2'), ('marks', '<f4')]


print()
# 8:
import numpy as np

student2 = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
lxw = np.array([('lxw', 21, 52), ('cw', 22, 58)], dtype=student2)
print(lxw)          # 运行结果：[(b'lxw', 21, 52.) (b'cw', 22, 58.)]


# 每个内建类型都有一个唯一定义它的字符代码，如下：
'''
字符 对应类型
b 布尔型
i.csv (有符号) 整型
u 无符号整型 integer
f 浮点型
c 复数浮点型
m timedelta（时间间隔）
M datetime（日期时间）
O (Python) 对象
S, a (byte-)字符串
U Unicode
V 原始数据 (void)

'''


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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

---

4 Numpy 数组属性

在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。

比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。

相关代码学习、如下

# -\*- coding = utf-8 -\*-
# @Time : 2022/6/28 16:52
# @Author : lxw\_pro
# @File : Numpy-数组属性-4.py
# @Software : PyCharm


# NumPy 的数组中比较重要 ndarray 对象属性有：
'''
属性 说明
ndarray.ndim 秩，即轴的数量或维度的数量
ndarray.shape 数组的维度，对于矩阵，n 行 m 列
ndarray.size 数组元素的总个数，相当于 .shape 中 n\*m 的值
ndarray.dtype ndarray 对象的元素类型
ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags ndarray 对象的内存信息
ndarray.real ndarray元素的实部
ndarray.imag ndarray 元素的虚部
ndarray.data 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

'''

# ndarray.ndim

# ndarray.ndim 用于返回数组的维数，等于秩。
import numpy as np

lxw = np.arange(36)
print(lxw.ndim)             # a 现只有一个维度

# 现调整其大小
a = lxw.reshape(2, 6, 3)    # 现在拥有三个维度
print(a.ndim)


print()
# ndarray.shape
# ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。

# ndarray.shape 也可以用于调整数组大小。

import numpy as np

lxw2 = np.array([[169, 175, 165], [52, 55, 50]])
print(lxw2.shape)   # shape: 数组的维度


print()
# 调整数组大小:
import numpy as np

lxw3 = np.array([[123, 234, 345], [456, 567, 789]])
lxw3.shape = (3, 2)
print(lxw3)


print()
# NumPy 也提供了 reshape 函数来调整数组大小:
import numpy as np

lxw4 = np.array([[23, 543, 65], [32, 54, 76]])
c = lxw4.reshape(2, 3)  # reshape: 调整数组大小
print(c)


print()
# ndarray.itemsize
# ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。

# 例如，一个元素类型为 float64 的数组 itemsize 属性值为 8(float64 占用 64 个 bits,
# 每个字节长度为 8，所以 64/8，占用 8 个字节），又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）

import numpy as np

# 数组的 dtype 为 int8（一个字节）
x = np.array([1, 2, 3, 4, 5], dtype=np.int8)
print(x.itemsize)

# 数组的dtypy现在为float64(八个字节）
y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
print(y.itemsize)   # itemsize: 占用字节个数


# 拓展：
# 整体转化为整数型
print(np.array([3.5, 6.6, 8.9], dtype=int))

# 设置copy参数，默认为True
a = np.array([2, 5, 6, 8, 9])
b = np.array(a)                     # 复制a
print(b)                            # 控制台打印b
print(f'a: {id(a)}, b: {id(b)}')     # 可打印出a和b的内存地址


print('='\*20)
# 类似于列表的引用赋值
b = a
print(f'a: {id(a)}, b: {id(b)}')


# 创建一个矩阵
lxw5 = np.mat([1, 2, 3, 4, 5])
print(type(lxw5))   # 矩阵类型： <class 'numpy.matrix'>

# 复制出副本，并保持原类型
yy = np.array(lxw5, subok=True)
print(type(yy))

# 只复制副本，不管其类型
by = np.array(lxw5, subok=False)    # False: 使用数组的数据类型
print(type(by))

print(id(yy), id(by))


print('='\*20)
# 使用数组的copy()方法：
c = np.array([2, 5, 6, 2])
cp = c.copy()
print(id(c), id(cp))


print()
# ndarray.flags
'''
ndarray.flags 返回 ndarray 对象的内存信息，包含以下属性：

属性 描述
C\_CONTIGUOUS (C) 数据是在一个单一的C风格的连续段中
F\_CONTIGUOUS (F) 数据是在一个单一的Fortran风格的连续段中
OWNDATA (O) 数组拥有它所使用的内存或从另一个对象中借用它
WRITEABLE (W) 数据区域可以被写入，将该值设置为 False，则数据为只读
ALIGNED (A) 数据和所有元素都适当地对齐到硬件上
UPDATEIFCOPY (U) 这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新

'''

import numpy as np

lxw4 = np.array([1, 3, 5, 6, 7])
print(lxw4.flags)   # flags: 其内存信息


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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

学习来源于哔哩哔哩和菜鸟教程
学习可自行点击：【菜鸟教程】
【2022B站最新最好的数据分析课程推荐】

---

Pandas学习

当然，做这些的前提是首先把文件准备好

文件准备

文件太长，故只截取了部分，当然，此文件可自行弄类似的也可以！

1 pandas新增数据列

在进行数据分析时，经常需要按照一定条件创造新的数据列，然后再进一步分析

• 直接赋值
• df.apply()方法
• df.assign()方法
• 按条件进行分组分别赋值

# -\*- coding = utf-8 -\*-
# @Time : 2022/6/28 16:20
# @Author : lxw\_pro
# @File : pandas新增数据列.py
# @Software : PyCharm

# 1:
import pandas as pd

# 读取数据
lxw = pd.read_csv('sites.csv')

# print(lxw.head())

df = pd.DataFrame(lxw)

# print(df)

df['lrl'] = df['lrl'].map(lambda x: x.rstrip('%'))

# print(df)

df.loc[:, 'jf'] = df['yye'] - df['sku\_cost\_prc']

# 返回的是Series
# print(df.head())


# 2:
def get\_cha(n):
    if n['yye'] > 5:
        return '高价'
    elif n['yye'] < 2:
        return '低价'
    else:
        return '正常价'


df.loc[:, 'yye\_type'] = df.apply(get_cha, axis=1)

# print(df.head())

print(df['yye\_type'].value_counts())


# 3:
# 可同时添加多个新列

print(df.assign(
    yye_bh=lambda x: x['yye']\*2-3,
    sl_zj=lambda x: x['sku\_cnt']\*6
).head(10))


# 4:

# 按条件先选择数据，然后对这部分数据赋值新列

# 先创建空列
df['zyye\_type'] = ''

df.loc[df['yye'] - df['sku\_cnt']>8, 'zyye\_type'] = '高'
df.loc[df['yye'] - df['sku\_cnt'] <= 8, 'zyye\_type'] = '低'

print(df.head())


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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

下面分别是每个小问对应运行效果：

1：

2：

3：

4：

---

2 Pandas数据统计函数

# Pandas数据统计函数

'''
1-汇总类统计
2-唯一去重和按值计数
3-相关系数和协方差

'''
import pandas as pd

lxw = pd.read_csv('nba.csv')

# print(lxw.head(3))

# 1:

# 一下子提取所有数字列统计结果
print(lxw.describe())

# 查看单个Series的数据
print(lxw['Age'].mean())

# 年龄最大
print(lxw['Age'].max())

# 体重最轻
print(lxw['Weight'].min())


# 2:

# 2-1 唯一性去重【一般不用于数值项，而是枚举、分类项】
print(lxw['Height'].unique())

print(lxw['Team'].unique())


# 2-2 按值计算
print(lxw['Age'].value_counts())

print(lxw['Team'].value_counts())


# 3:

# 应用：股票涨跌、产品销量波动等等

'''
【来自知乎】
对于两个变量X、Y：
1-协方差：衡量同向程度程度，如果协方差为正，说明X、Y同向变化，协方差越大说明同向程度越高；
 如果协方差为负，说明X、Y反向运动，协方差越小说明方向程度越高。
2-相关系数：衡量相似度程度，当他们的相关系数为1时，说明两个变量变化时的正向相似度最大，
 当相关系数为-1，说明两个变化时的反向相似度最大。
 

'''

# 协方差矩阵：
print(lxw.cov())

# 相关系数矩阵：
print(lxw.corr())

# 单独查看年龄和体重的相关系数
print(lxw['Age'].corr(lxw['Weight']))

# Age和Salary的相关系数
print(lxw['Age'].corr(lxw['Salary']))

# 注意看括号内的相减
print(lxw['Age'].corr(lxw['Salary']-lxw['Weight']))


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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

1:

2-1:

部分2-2：

3：

---

3 Pandas对缺失值的处理

特殊Excel的读取、清洗、处理

# -\*- coding = utf-8 -\*-
# @Time : 2022/6/28 20:00
# @Author : lxw\_pro
# @File : pandas缺失值处理-7.py
# @Software : PyCharm

# Pandas对缺失值的处理
'''
函数用法：
1-isnull和notnull: 检测是否有控制，可用于dataframe和series
2-dropna: 丢弃、删除缺失值
2-1 axis: 删除行还是列，{0 or 'index', 1 or 'columns'}, default()
2-2 how: 如果等于any， 则任何值都为空，都删除；如果等于all所有值都为空，才删除
2-3 inplace: 如果为True，则修改当前dataframe,否则返回新的dataframe
2-4 value: 用于填充的值，可以是单个值，或者字典（key是列名，value是值）
2-5 method: 等于ffill使用前一个不为空的值填充forword fill;等于bfill使用后一个不为空的值填充backword fill
2-6 axis: 按行还是按列填充，{0 or "index", 1 or "columns"}
2-7 inplace: 如果为True则修改当前dataframe，否则返回新的dataframe

'''

# 特殊Excel的读取、清洗、处理

import pandas as pd
# 1: 读取excel时，忽略前几个空行

stu = pd.read_excel("Score表.xlsx", skiprows=14)     # skiprows: 控制在几行以下

print(stu)

# 2: 检测空值
print(stu.isnull())

print(stu['成绩'].isnull())

print(stu['成绩'].notnull())

# 筛选没有空成绩的所有行
print(stu.loc[stu['成绩'].notnull(), :])


# 3: 删除全是空值的列：

# axis: 删除行还是列，{0 or 'index', 1 or 'columns'}, default()
# how: 如果等于any， 则任何值都为空，都删除；如果等于all所有值都为空，才删除
# inplace: 如果为True则修改当前dataframe，否则返回新的dataframe
stu.dropna(axis="columns",  how="all", inplace=True)

print(stu)


# 4: 删除全是空值的行：

stu.dropna(axis="index", how="all", inplace=True)

print(stu)


# 5: 将成绩列为空的填充为0分：
stu.fillna({"成绩": 0})

print(stu)


# 同上：
stu.loc[:, '成绩'] = stu['成绩'].fillna(0)

print(stu)


# 6: 将姓名的缺失值填充【使用前面的有效值填充，用ffill： forward fill】
stu.loc[:, '姓名'] = stu['姓名'].fillna(method='ffill')


**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
![img](https://img-blog.csdnimg.cn/img_convert/89680d39e93864c95e0f5d84219073dd.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

aframe
stu.dropna(axis="columns",  how="all", inplace=True)

print(stu)


# 4: 删除全是空值的行：

stu.dropna(axis="index", how="all", inplace=True)

print(stu)


# 5: 将成绩列为空的填充为0分：
stu.fillna({"成绩": 0})

print(stu)


# 同上：
stu.loc[:, '成绩'] = stu['成绩'].fillna(0)

print(stu)


# 6: 将姓名的缺失值填充【使用前面的有效值填充，用ffill： forward fill】
stu.loc[:, '姓名'] = stu['姓名'].fillna(method='ffill')


**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
[外链图片转存中...(img-twGczALx-1713359452675)]

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117