总结
机会是留给有准备的人，大家在求职之前应该要明确自己的态度，熟悉求职流程，做好充分的准备，把一些可预见的事情做好。
对于应届毕业生来说，校招更适合你们，因为绝大部分都不会有工作经验，企业也不会有工作经验的需求。同时，你也不需要伪造高大上的实战经验，以此让自己的简历能够脱颖而出，反倒会让面试官有所怀疑。
你在大学时期应该明确自己的发展方向，如果你在大一就确定你以后想成为Java工程师，那就不要花太多的时间去学习其他的技术语言，高数之类的，不如好好想着如何夯实Java基础。下图涵盖了应届生乃至转行过来的小白要学习的Java内容：
请转发本文支持一下
从字面了解，一个是能用没几次的，一个是能用好多次的。
如果你还有所疑惑，那么是肯定的，因为，你现在脑子里面只是有了一个概念，却很模糊。
那么就跟着我来带你详细了解了解！
条件控制语句，就是通过判断条件来执行我们的代码，就像数学流程图里的是和否。
1. 单支if语句
我们先来看看格式：
if 条件:
代码
这个翻译成汉语就是
如果 条件是真的：
执行代码
结束
如果 条件是假的
结束
流程就是这样的
2. 简单使用
那么我们来看一个小小的例子吧
a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
print("两数之和小于10")
来看看运行起来是什么样子的吧
懂了没？是不是很简单？没错，条件控制语句就是做这个的，不过这只是最简单的条件控制语句，下面我们来看看稍微复杂一点的。
3. 多支判断
格式：
if 条件:
代码
elif 条件:
代码
else:
代码
使用：
继续使用上面的例子
a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
print("两数之和小于10")
elif c==10:
print("两数之和等于10")
else:
print("两数之和大于10")
好的，好的，我们的程序能做的事更多了
这次就输入一个5一个6吧
欧克，完美的实现了我们的功能
1.8 循环控制语句
循环，循环，何为循环，就是一直进行，不会停止
那么怎么停止呢？那也得我们自己设置条件
循环控制语句有两种，一种是for循环，一种是while循环。
1. for循环
格式：
一般来说，for循环使用较多
for 临时变量 in 循环的条件:
代码
我们的for循环需要一个临时变量，不需要提前定义一个变量去接收循环里面的值
这样对于内存也是一种释放，提前定义变量的话，就是一个全局变量，会一直占用内存，而这个for循环的临时变量就在循环结束后销毁，释放内存。
用白话文讲就是，临时变量只能在循环开始-循环结束前活着，循环结束的时候就是临时变量寿终正寝的时候，有点类似于卸磨杀驴（手动狗头）
而且我们的for并不需要我们手动更新变量
使用：
还记不记得上一篇的变量最后面，我们使用了10个print()函数输出了10次Hello World！
那么我们也可以用我们的循环，用更少的代码，实现这个效果
a = "Hello World!"
for i in range(10):
print(a)
代码中的i是从0开始的，而这个range()函数里面的值，就是从i到10（不含10），因此，会循环10次
来运行看看吧
完美，达到了我们的目的
2. while循环
格式：
while 条件:
代码
使用：
还是上面的，输出10次Hello World！
a = "Hello World!"
i = 0
while i<10:
print(a)
i+=1
while循环不仅需要定义全局变量，而且还需要我们自己手动更新变量的值（i）
如果不更新的话，i的值就不会改变，条件就会一直成立，循环就不会停止，因此，使用while的时候，一定不要忘了更新变量
3. 主动循环结束
三种语句：break return continue都可以使循环停止
不过return一般都是用到函数里面的，都是使用break
而continue 不是用来终止循环的，具体作用看下面代码示例
break：
看汉语也有个大概思想：打破
它的作用是打破循环，使循环碰到它后终止
break的作用是打破结构体，使程序退出当前代码块
下面看这个例子，我们要实现的功能是循环获取用户从键盘输入的数据，直到输入q来推出程序
while True:
a = input()
if a == "q":
break
else:
print(a + " 输入成功，输入 'q' 退出程序")
运行结果：
此时我们发现，输入q推出了，但是我们看着并不舒服，我们还可以加个提示，或者让他再输入一次“确认”来确认是否要推出
while True:
a = input()
if a == "q":
print("确定要推退出，确定的话，请输入确定退出来确定")
if input() == "确定退出":
print("已退出，程序结束")
break
else:
print(a + " 输入成功，输入 'q' 退出程序")
运行结果：
这样就完美了，我这可不是谁字数啊，我这是强迫症（认真脸）！
continue：
continue是跳出当前循环，执行下一循环，也就是说，他并没有令循环终止的能力，他只能令循环少循环一些次数
我们先把上面的代码里面的break换成continue试试
while True:
a = input()
if a == "q":
print("确定要推退出，确定的话，请输入确定退出来确定")
if input() == "确定退出":
print("已退出，程序结束")
else:
print(a + " 输入成功，输入 'q' 退出程序")
行不通
退出不了！
果然吧，那么continue有啥用呢？
我先不说，你先看：
for i in range(10):
if i % 5 == 0:
continue
else:
print(i)
运行结果：
return：
return意为返回，是用在函数中的返回值的，至于函数是什么，我们会在本专栏中陆续讲述，你先看效果就可以了
我们计算当i的值循环到5时，让a+b，然后计算完终止
当i为5时，不管循环是否进行完，都会强行终止
def sum(a, b):
for i in range(10):
if i<a:
pass
else:
a+=b
return a
print(sum(5, 2))
pass的意思就相当于什么都不做
运行结果为：7
那么如果我们把return的位置换一下呢？
def sum(a, b):
for i in range(10):
if i<a:
pass
else:
a+=b
return a
print(sum(5, 2))
我们的循环会在第一次就终止，因为第一次i的值为0，满足判断条件，执行return语句，结束循环
那么如果我们再换一下呢？我们这次放在循环外面，那么肯定是循环执行完才会结束了，会把a+=b执行一次，还是7
def sum(a, b):
for i in range(10):
if i<a:
pass
else:
a+=b
return a
print(sum(5, 2))
第四阶段
1.9 函数式编程
注意不要和数学中的函数搞混了
那么到底什么是函数呢？
函数其实就是当我们在程序中需要大量重复的代码块，我们将其封装成一个代码块，用一个名字来表示，而这个名字是标识符。需要遵循标识符的规则。
函数的优点就是避免了代码重复率，提高开发效率。
举个例子：我们需要让电脑给我们表白（骚话），输出一段情话，就比如这一段
"我爱你"
"我要给你生猴子"
"啊啊啊，好喜欢你"
按照之前所学，一个一个的print()就行了嘛
但是我需要你什么时候都能给我来一段表白（骚话）呢？
这个时候恐怕用循环就不妥了吧，就用我们的函数了
当然，python自带的有很多内置函数，而我们自己定义的函数叫做自定义函数。
1. 无参函数：
无参函数是最基本的函数，基本上很少用到，都是拿来练习理解函数的。
def 函数名字():
代码
使用：
# 定义
def Qinghua():
print("我爱你")
print("我要给你生猴子")
print("啊啊啊，好喜欢你")
# 调用
Qinghua()
运行结果：
好像，并没有多大作用吗!
其实不然，看这个
# 定义
def Qinghua():
print("我爱你")
print("我要给你生猴子")
print("啊啊啊，好喜欢你")
# 调用
Qinghua()
for i in range(10):
print("经过了{}秒".format(i))
Qinghua()
他可以在你任何想使用的时候，都可以通过调用的形式使用，而不需要你再打了。
就像变量一样，不过函数要比普通的变量复杂一些
2. 有参函数
函数是可以传递参数的，而参数分为形参和实参
形参就是形式上的参数，就像一家公司有员工，清洁工，董事长等职位，但是有些职位却空着，这些空着的职位，就相当于形参，需要有人去做这个职位，才能发挥作用，而这个能发挥职位作用的人，就叫做实参（实际参数）。
而我们定义有参函数的时候，需要定义形参来表示我们的函数，有这些东西，你想让我们的函数去发挥作用的话，就需要给我们传递实际参数。
有参有参，在哪里体现的有参呢？
在我们定义的时候，我们需要在括号里面定义形参，用于接收参数
而在我们调用的时候，也是通过函数名后面的括号传递实参的
使用：
我们会定义一个有参函数来使两个参数拼接在一起，并遍历
def PinJie(a, b):
str_ = str(a)+str(b)
print(str_)
for i in str_:
print(i)
PinJie("sasa", 4564)
#也可以这么写
"""
PinJie(a="sasa",b=4564)
这样写的好处是
就算你的位置写错了
参数传递的也还是对的
也就是说，参数传递的位置不固定
就像这样
PinJie (b=4564, a='sasa')
是完全一样的
"""
运行：
3. return的作用
之前说过，return一般是使用在函数中的，那么他的作用是什么呢？
先根据见名知意的规律来解读：返回
确实，他的作用就是返回，返回值
通过return xxx来达到返回值得目的，这里是返回了xxx这个东西，至于xxx 是什么。。众所周知，xxx可以什么都是！
那么返回的值到了哪里呢？到了函数的调用那里，这个函数名字(参数)就是返回的值
使用：
看上面的那个函数，他显示拼接后的结果，使用了print()函数（内置函数）
那么我们使用return试试
def PinJie(a, b):
str_ = str(a)+str(b)
return str_
for i in str_:
print(i)
PinJie("sasa", 4564)
那么会怎么样呢？
答案是，什么都不会显示！
为什么呢？因为我们没有使用print()函数（瞎说，那不是有！）
为什么这么说呢？因为上次讲过，return用于结束一段代码，而我们在中间return，下面的训话也就不会被执行，就直接结束了。
怎么显示循环呢？把return放在函数最下面，我就不展示了，自己去试试，不然优点水字数！（狗头保命！）
那么上面说了返回的值被 **函数名()**接收了，那么他现在就是一个值了，想要让它显示，那么只能用print()了啊！
def PinJie(a, b):
str_ = str(a)+str(b)
return str_
for i in str_:
print(i)
p = PinJie("sasa", 4564)
print(p)
结果：
他就显示了返回值，也就是函数拼接的结果
1.10 面向对象编程
第五阶段
1. 理解
编程语言有面向对象（Java，Python）和面向过程（C语言）之分，面向对象需要一些抽象的思维才行。
面向过程和面向对象有什么区别呢？
面向过程注重亲力亲为，意思也就是自己去干这件事；而面向对象更倾向于找个人给自己做事。
就拿那个老生常谈的例子来说吧——洗衣服：
面向过程：
面向过程的洗衣服是：
- 把衣服拿到洗衣机旁边
- 放进去
- 等待
- 捞出来
等下一次洗衣服，你还得重复这些操作
而这就是函数式编程
面向对象：
而面向对象则是：
创造一个机器人
教他如何洗衣服
把衣服拿到洗衣机旁边
放进去
等待
捞出来
让他去干活
等下一次需要洗衣服，就让机器人去干就行了
而面向对象绕不开的就是类和对象了，接着往下看吧
2. 类
类是个抽象的东西，比如说人类，动物类，植物类，类是具有某些相同特征的事物的集合
那么如何定义一个属于我们的类呢？有三种方法，推荐使用第三种
# 定义一个Xxx类
class Xxx:
代码块
class Xxx():
代码块
class Xxx(object):
代码
这就成了
而类需要有属性，行为（方法）等东西
而属性就是在类里面的局部变量
而行为就是定义在类里面的函数
构造方法：
而每个类都有一些默认的行为（方法），比如这个构造方法__init__
每个类都默认有这个构造方法，而 构造方法里面的内容是会在实例化的时候就运行的，也就是，你实例化的时候，就会调用这个__init__构造方法。
而对象是什么呢？
3. 对象
对象是类的实例化，拿人类来说，人是一个类，而我们每个人都是人这个类的实例化对象。
看代码：
# 定义一个人类
class Person(object):
pass
# 实例化对象
xiaoming = Person()
很明显，xiaoming是Person这个类的实例化对象，换句话说，xiaoming是个Person，在这句话里，xiaoming就是对象，Person就是类
4. 代码实现洗衣机
代码：
class Robot(object):
def \_\_init\_\_(self):
print("把衣服拿到洗衣机旁边")
print("把衣服放进洗衣机")
print("等衣服洗好")
print("把衣服捞出来")
xiaoming = Robot()
运行结果：
5. 封装
可以将构造方法的参数，进行封装，让其在每个方法中都可以调用
想着这样的代码就是错的
class Person(object):
def \_\_init\_\_(self, name, age):
pass
def speak(self):
print(f"{age}岁的{name}会说话")
Menger = Person("布小禅", 20)
name = Menger.name
age = Menger.age
person.speak()
print("姓名：{} \n年龄：{}".format(name, age))
因为speak方法里面的name和age，计算机不知道是谁，计算机不认识他们两个，而刚刚那两行self.name = name和self.age = age就是相当于告诉计算机name和age是类的参数
class Person(object):
def \_\_init\_\_(self, name, age):
self.name = name
self.age = age
def speak(self):
print(f"{age}岁的{name}会说话")
Menger = Person("布小禅", 20)
name = Menger.name
age = Menger.age
Menger.speak()
print("姓名：{} \n年龄：{}".format(name, age))
这样就对了，输出为：
姓名：布小禅
年龄：20
6. 继承
Python的面向对象是可以继承的，就像你继承了你爸爸和你妈妈的部分特征，Python中的子类，继承父类，说起继承，其实你们也都见过了，就我上一篇说的三种定义类的方法的第三种：
class ClassNmae(object):
代码块
那个ClassNmae后面的括号里的object就是父类，而ClassName是子类
子类继承父类的所有东西
7. 私有化
上篇说过封装，既将我们不想让别人看到代码的内容，但是又需要用到的内容，通过类内部调用来实现调用。
说到这里却不得不提一下上篇的：
class Person(object):
def \_\_init\_\_(self, name, age):
self.xxx = name
self.xxxx = age
这里面self后面的名字，是可以自己随意命名的，上一篇和后面一样只是为了好记忆罢了
只要你记得住，便是颠倒也是无事
属性私有化：
何为属性私有？
举个例子便是：你的私房钱，你的手机电脑里面的小秘密等等这些不想被别人知道的东西
那么上面就说了，封装的目的是什么，不就是隐藏那些不想让别人知道的代码吗
所以有个属性私有化，可以让你的类属性变成私有的，这可和上篇的封装不一样，封装了还能通过实例化对象调用；这个属性一旦变成私有的，你在类外部是无法调用的
那我想用了怎么办？在类内部调用嘛！
好，叭叭了这么多，想必你们也得烦了，上代码
使用格式：
class Xxx(object):
age = 20
_name = "Xxx"
这种前面带着一个下划线的就是私有属性，无法通过类外部实例化对象的方法进行调用
具体应用：
"""
定义一个挺人类
含有姓名，年龄，体重，身高
将体重设置私有化
通过类内部调用使得能够在类外部看到你的体重
"""
class Person(object):
_weight = 70
def \_\_init\_\_(self, name, age, height):
self.name = name
self.age = age
self.height = height
def weightPrint(self):
print("我的体重是：", self._weight)
person = Person("布小禅", 20, 180)
person.weightPrint()
这个体重就无法通过person.weight、person._weight这样调用，因为这个属性是私有的
方法私有化：
我觉得这个倒是不必多说，只需要在定义的类方法名字前面也加一个_就可以了
class Person(object):
def \_love(self):
print("我暗恋Xxx")
这个方法也是无法通过实例化对象来调用的，调用需要这样：
class Person(object):
def \_love(self):
print("我暗恋Xxx")
def speakLove(self):
self._love()
二、 numpy快速入门
第六阶段
numpy是什么？
扩展库numpy是Python支持科学计算的重要扩展库，是数据分析和科学计算领域如scipy、pandas、sklearn 等众多扩展库中的必备扩展库之一，提供了强大的N维数组及其相关运算、复杂的广播函数、C/C++和Fortran代码集成工具以及线性代数、傅里叶变换和随机数生成等功能。本章童点介绍数组与矩阵及其相关运算，为学习和理解后面章节中的数据分析、机器学习打下良好的基础。
简单来说就是你用来为人工智能领域打基础的东西，私话说得好，基础不牢，地动山摇嘛~
所以这个地方可要好好学习哦~~
2.1 简单使用
在numpy中使用的不是自带的数据类型list，而是numpy中的ndarray
那为什么使用ndarray而不是使用list呢？
因为ndarray是由c/c++写出来的，占用内存更小，使用速度更快
创建一个ndarray的方法有很多，这里说下使用array方法转化的
#!/usr/bin/env python
# -\*- coding: utf-8 -\*-
# @Author： Smly
# @datetime： 2021/9/26 22:22
# @Version： 1.0
import numpy as np
li = [1, 2, 3]
tp = (1, 2, 3)
nday1 = np.array(li)
nday2 = np.array(tp)
print("\*\*\*\*\*类型\*\*\*\*\*")
print(type(nday1))
print(type(nday2))
print("\*\*\*\*\*数组\*\*\*\*\*")
print(nday1)
print(nday2)
输出结果：
\*\*\*\*\*类型\*\*\*\*\*
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>
\*\*\*\*\*数组\*\*\*\*\*
[1 2 3]
[1 2 3]
2.2 数组使用
如果元素相同的话，可以进行加减乘除
- 在元素个数相同的情况下，可以进行数组间的加减
- 在元素个数相同的情况下，可以进行数组间的乘除
- 对某个数进行的乘除，可以自动进行到所有元素
看例子理解：
#!/usr/bin/env python
# -\*- coding: utf-8 -\*-
# @Author： Smly
# @datetime： 2021/9/26 22:22
# @Version： 1.0
import numpy as np
li = [1, 2, 3] # 列表
tp = (1, 2, 3) # 元组
nday1 = np.array(li) # 内置方法将列表转为ndarray
nday2 = np.array(tp) # 内置方法将元组转为ndarray
nday3 = np.array(range(5)) # 使用range内置函数方法生成ndarray连续数组
nday4 = np.array(range(5, 10)) # 使用range内置函数方法生成ndarray连续数组
print("\*\*\*\*\*类型\*\*\*\*\*")
print(type(nday1))
print(type(nday2))
print(type(nday3))
print(type(nday4))
print("\*\*\*\*\*数组\*\*\*\*\*")
print(nday1)
print(nday2)
print(nday3)
print(nday4)
print("\*\*\*\*\*数组加减\*\*\*\*\*")
print(nday2 + nday1)
print(nday2 - nday1)
print(nday4 - nday3)
print(nday3 + nday4)
# 在元素个数相同的情况下，可以进行数组间的加减
print("\*\*\*\*\*数组乘除\*\*\*\*\*")
print(nday2 \* nday1)
print(nday2 // nday1)
print(nday4 \* nday3)
print(nday4 // nday3)
# 在元素个数相同的情况下，可以进行数组间的乘除
print(nday1 \* 3)
print(nday2 // 2)
print(nday3 \* 2)
print(nday4 // 2)
# 对某个数进行的乘除，可以自动进行到所有元素
运行结果：
\*\*\*\*\*类型\*\*\*\*\*
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>
\*\*\*\*\*数组\*\*\*\*\*
[1 2 3]
[1 2 3]
[0 1 2 3 4]
[5 6 7 8 9]
\*\*\*\*\*数组加减\*\*\*\*\*
[2 4 6]
[0 0 0]
[5 5 5 5 5]
[ 5 7 9 11 13]
\*\*\*\*\*数组乘除\*\*\*\*\*
[1 4 9]
[1 1 1]
[ 0 6 14 24 36]
[0 0 0 0 0]
[3 6 9]
[0 1 1]
[0 2 4 6 8]
[2 3 3 4 4]
2.2 创建数组
刚刚的array()方法是将列表和元组等迭代对象转为ndarray数组
接下来要说的是自动创建数组
1. 使用empty创建空数组
里面会有初始值，但是数组初始为None
#!/usr/bin/env python
# -\*- coding: utf-8 -\*-
# @Author： Smly
# @datetime： 2021/9/28 12:29
# @Version： 1.0
import numpy as np
em1 = np.empty(5) # 创建一个长度为5的空数组
em2 = np.empty((2, 2)) # 创建一个2\*2的空二维数组
print("一维数组，长度为5", em1)
print("二维数组，长度为2\*2", em2)
输出结果：
[9.96754604e-312 9.96754614e-312 2.60799828e-310 9.34609789e-307
0.00000000e+000]
[[6.95299778e-310 9.96747617e-312]
[0.00000000e+000 6.95299776e-310]]
2. 使用arange函数创建
arange是numpy自带的的一个方法，作用与range这个Python内置函数相差无几，都是生成数组
先导入numpy包
import numpy as np
然后创建数组
print("\*\*\*\*\*ararge创建数组\*\*\*\*\*")
aran_arr1 = np.arange(5)
aran_arr2 = np.arange(5, 10)
print("\*\*\*\*\*类型\*\*\*\*\*")
print(type(aran_arr1))
print(type(aran_arr2))
print("\*\*\*\*\*数组\*\*\*\*\*")
print(aran_arr1)
print(aran_arr2)
3. 使用zeros函数生成数组
zeros函数是numpy自带的方法，作用是生成指定数量的全0一维数组，全0二维数组等
看下面的例子：
生成一个具有三个元素的一维数组和一个具有五个元素的一维数组：
#!/usr/bin/env python
# -\*- coding: utf-8 -\*-
# @Author： Smly
# @datetime： 2021/9/27 21:31
# @Version： 1.0
import numpy as np
zero_arr = np.zeros(3)
zrro_arr2 = np.zeros(5)
print(zero_arr)
print(zrro_arr2)
运行结果：
[0. 0. 0.]
[0. 0. 0. 0. 0.]
当然这只是一位数组，你还可以生成二维数组，也就是矩阵
使用如下代码可以生成一个三行三列的矩阵
zero_arr3 = np.zeros((3, 3))
输出看看：
print(zero-arr3)
运行结果：
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
4. ones函数生成数组
使用ones函数生成全1函数，方法同zeros
import numpy as np
ones_arr1 = np.ones(3)
输出结果：
[1. 1. 1.]
生成一个三行三列的矩阵
import numpy as np
ones_arr2 = np.ones((3, 3))
输出结果：
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
5. diag函数生成对角矩阵
什么是对角矩阵?你应该听说过对角线，矩阵就是生成在对角线上的矩阵
函数参数是一个元祖
看代码和运行结果能够理解的更深刻
import numpy as np
diag_arr = np.diag((4, 3, 2, 1))
将diag_arr的输出的结果为：
[[4 0 0 0]
[0 3 0 0]
[0 0 2 0]
[0 0 0 1]]
看，对角线是不是你函数的参数，这下理解了吧
6. N维数组
N维数组就是多维数组，可以理解为数组里面还是数组，里面还是数组，可以参照这个形式
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
这个概念确实有点抽象，有点难理解。这就是一个三维数组，是通过三维列表使用array方法转换成ndarray的
代码：
#!/usr/bin/env python
# -\*- coding: utf-8 -\*-
# @Author： Smly
# @datetime： 2021/9/27 13:29
# @Version： 1.0
import numpy as np
li = [
[[1, 2], [3, 4]],
[[5, 6], [7, 8]]
]
te1 = np.array(li)
print(te1)
当然，二维数组也算是N维数组
2.3 矩阵
数组是数组，矩阵是矩阵。
数组是一种数据结构，可以存储多种数据，可以有多维
矩阵是数学中的一个概念，只能存放数字，并且只能是二维的形式
生成矩阵的方法就和生成N维数组的方法是一样的
先使用列表创建二维列表，然后再使用numpy的方法转成矩阵，当然也有好几中生成矩阵的方法
import numpy as np
li = [[1, 2, 3, 4], [5, 6, 7, 8]]
j1 = np.matrix(li)
print(j1)
print(type(j1))
print(j1.dtype)
输出该矩阵：
输出矩阵： [[1 2 3 4]
[5 6 7 8]]
矩阵在Python的类型： <class 'numpy.matrix'>
在numpy中的类型： int32
矩阵可以进行各种数学运算，在numpy子女宫都得到了很好的支持，这里就不细说了
2.4 广播
何为广播，广播就是能将你的东西发送到各个区域，一般在计算机中是将信息发送到局域网络中的每个计算机中。
而在numpy中也有广播，只不过他是将元素自动补到数组，矩阵上，就像你在上面看到的，一个数组乘除一个元素，数组中的所有元素都会乘这个数
import numpy as np
li1 = [1, 2, 3, 4]
print(np.array(li1)\*10)
输出结果：
[10 20 30 40]
这个就是广播，就是将数字10播到li转成的数组中，能够让数组所有元素都乘10。
而不同维度的数组也可以这样
#!/usr/bin/env python
# -\*- coding: utf-8 -\*-
# @Author： Smly
# @datetime： 2021/9/27 13:40
# @Version： 1.0
import numpy as np
li = [[1, 2, 3, 4], [5, 6, 7, 8], [2, 4, 6, 8]]
gb1 = np.array(li)
li1 = [1, 2, 3, 4]
gb2 = np.array(li1)
print(gb1\*gb2)
将一维数组的每个元素挨个广播到二维数组，前提是：
二维数组中的一维数组的个数与一维数组的个数是相同的
运行结果：
[[ 1 4 9 16]
[ 5 12 21 32]
[ 2 8 18 32]]
2.5 访问数组元素
numpy自带了一个insert函数，可以往数组中插入元素
看实例：
li = [[1, 2, 3, 4], [5, 6, 7, 8], [2, 4, 6, 8]]
gb1 = np.array(li)
np.insert(gb1, 1, [1, 2, 3, 4])
输出结果：
[1 1 2 3 4 2 3 4 5 6 7 8 2 4 6 8]
还有一个自带的add函数，可以进行数组的相加减
数组嘛，可以使用下标来获取数组元素
import numpy as np
li1 = [1, 2, 3, 4]
gb2 = np.array(li1)
print(gb2[1])
输出结果为：
2
当然，它是一个数组，你理所应当的也可以使用循环语句来遍历数组
三、matplotlib快速入门
第七阶段
matplotlib是一个将数据可视化的模块。
什么你连什么是数据可视化都不知道是什么？
高中学的函数（可别跟Python中的函数搞混了）知道吧，把函数的图像画出来，就是数据可视化了
matplotlib是一个数据可视化的标准库，与numpy模块，pandas模块都很适用。
它能够绘制多种形式的图像，包括：
- 折线图 —— plot ()
- 散点图 —— scatter ()
- 饼状图 —— pie ()
- 柱状图 —— bar ()
- 雷达图 —— polar ()
- 三维图 —— mplot3d
3.1 基础理论
作图，我们需要有数据，坐标轴标签，标题，坐标轴刻度等属性。
- 数据可以使用numpy生成一维列表，在数学中也叫向量。
- 坐标轴标签由xlabel()，ylabel()方法（函数）设置
- 标题由title()方法（函数）设置
- 坐标轴刻度可以使用xticks ()，yticks ()方法（函数）设置
3.2 绘制折线图
导入模块：
import numpy as np
# numpy用于生成数据
import matplotlib.pyplot as plt
# 使用matplotlib中的pyplot模块进行绘图
生成x轴，y轴数据：
x = np.arange(0,6,0.1) # x轴数据
y = np.sin(x) # y轴数据
绘制图案：
plt.plot(x,y,label="sin")
# 以x为x轴数据，y为y轴数据，绘制折线图，并设置线上的标签为sin
设置标题等属性：
plt.xlabel("number") # x轴标签
plt.ylabel("sin") # y轴标签
plt.title("sin fun") # 图像标题
使图像显示出来：
plt.show() # 显示图像
图像显示效果：
3.3 绘制散点图
将代码绘制图像的plt.plot()修改成plt.scatter()
全部代码：
import numpy as np
# numpy用于生成数据
import matplotlib.pyplot as plt
# 使用matplotlib中的pyplot模块进行绘图
x = np.arange(0, 6, 0.1) # x轴数据
y = np.sin(x) # y轴数据
plt.scatter(x, y, label="sin")
# 以x为x轴数据，y为y轴数据，绘制折线图，并设置线上的标签为sin
plt.xlabel("number") # x轴标签
plt.ylabel("sin") # y轴标签
plt.title("sin fun") # 图像标题
plt.show() # 显示图像
3.4 绘制饼状图
绘制一个编程语言的饼状图，数据随便写的，不要当真，还有一点，默认不支持中文
先导入模块
import numpy as np
# numpy用于生成数据
import matplotlib.pyplot as plt
# 使用matplotlib中的pyplot模块进行绘图
创建数据：
student_souce = np.array([25, 35, 45, 60])
绘制图案：
plt.pie(student_souce, labels=["C", "Python", "Java", "C+++"], autopct='%.2f%%')
# 设置student\_souce为数据，每个数据的名字为labels的参数，并格式化输出各个所占百分比
设置标题与显示图像：
plt.title("Test") # 图像标题
plt.show() # 显示图像
完整代码：
#!/usr/bin/env python
# -\*- coding: utf-8 -\*-
# @Author： Smly
# @datetime： 2021/9/28 12:56
# @Version： 1.0
import numpy as np
# numpy用于生成数据
import matplotlib.pyplot as plt
# 使用matplotlib中的pyplot模块进行绘图
student_souce = np.array([25, 35, 45, 60])
plt.pie(student_souce, labels=["C", "Python", "Java", "C+++"], autopct='%.2f%%')
# 设置student\_souce为数据，每个数据的名字为labels的参数，并格式化输出各个所占百分比
plt.title("Test") # 图像标题
plt.show() # 显示图像
# 最后
整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。
其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料，我这差不多来回搞了三个多月，收集整理真的很不容易，其中还有很多自己的一些知识总结。正是因为很麻烦，所以对以上这些学习复习资料感兴趣，
> **本文已被[CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)收录**
**[需要这份系统化的资料的朋友，可以点击这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**
d4237212bdd.png)
#### 3.3 绘制散点图
将代码绘制图像的`plt.plot()`修改成`plt.scatter()`
全部代码：
import numpy as np
numpy用于生成数据
import matplotlib.pyplot as plt
使用matplotlib中的pyplot模块进行绘图
x = np.arange(0, 6, 0.1) # x轴数据
y = np.sin(x) # y轴数据
plt.scatter(x, y, label=“sin”)
以x为x轴数据，y为y轴数据，绘制折线图，并设置线上的标签为sin
plt.xlabel(“number”) # x轴标签
plt.ylabel(“sin”) # y轴标签
plt.title(“sin fun”) # 图像标题
plt.show() # 显示图像
#### 3.4 绘制饼状图
绘制一个编程语言的饼状图，数据随便写的，不要当真，还有一点，默认不支持中文
先导入模块
import numpy as np
numpy用于生成数据
import matplotlib.pyplot as plt
使用matplotlib中的pyplot模块进行绘图
创建数据：
student_souce = np.array([25, 35, 45, 60])
绘制图案：
plt.pie(student_souce, labels=[“C”, “Python”, “Java”, “C+++”], autopct=‘%.2f%%’)
设置student_souce为数据，每个数据的名字为labels的参数，并格式化输出各个所占百分比
设置标题与显示图像：
plt.title(“Test”) # 图像标题
plt.show() # 显示图像
完整代码：
#!/usr/bin/env python
-*- coding: utf-8 -*-
@Author： Smly
@datetime： 2021/9/28 12:56
@Version： 1.0
import numpy as np
numpy用于生成数据
import matplotlib.pyplot as plt
使用matplotlib中的pyplot模块进行绘图
student_souce = np.array([25, 35, 45, 60])
plt.pie(student_souce, labels=[“C”, “Python”, “Java”, “C+++”], autopct=‘%.2f%%’)
设置student_souce为数据，每个数据的名字为labels的参数，并格式化输出各个所占百分比
plt.title(“Test”) # 图像标题
plt.show() # 显示图像
最后
整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。
[外链图片转存中…(img-965vpSz3-1715497776325)]
[外链图片转存中…(img-tSo7OExg-1715497776325)]
其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料，我这差不多来回搞了三个多月，收集整理真的很不容易，其中还有很多自己的一些知识总结。正是因为很麻烦，所以对以上这些学习复习资料感兴趣，
2154
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
