关于大一第二学期学习的成果

一，python方面

1，利用pyecharts绘图的简单代码示例

#导包，导入Line功能

from pyecharts.charts import Line

from pyecharts.options import TitleOpts,LegendOpts,ToolboxOpts,VisualMapOpts

#得到折线图对象

line=Line()

#添加x，y轴数据

line.add_xaxis(["中国","美国","英国"])

line.add_yaxis("GDP",[30,20,10])

#设置全局配置项

line.set_global_opts(

title_opts=TitleOpts(title="GDP展示",pos_left="center",pos_bottom="1%"), #一定要注意加逗号 #pos_left是管水平位置（居中），bottom是管上下

legend_opts=LegendOpts(is_show=True),

toolbox_opts=ToolboxOpts(is_show=True),

visualmap_opts=VisualMapOpts(is_show=True),

)

#生成图表

line.render()

2，使用lambda定义匿名函数的小例子

my_list=[["a",33],["b",11],["c",22]]
def a(e):
return e[1]
my_list.sort(key=a,reverse=True)

my_list.sort(key=lambda e:e[1],reverse=True)
print(my_list)

3，类型注释

基础语法： 变量:类型=什么 变量：类型[类型]=什么

方式一

a:list[int]=[1,3,4,3]

b:tuple[str,int,bool]=("s",3,True)

c:dict[str,int]={"xie":2}

方式二

a=random.randint(1,9) #type:int

函数和方法的形参类型注解语法

具体语法

def 函数方法名(形参名:类型,形参名:类型) :

def add(x:int,y:int)->int:#返回值注解

return x+y

使用Union联合类型注解

from typing import Union

a:list[Union[str,int]]=[1,4,"af"]

b:dict[str,Union[str,int]]={"name":"xie","age":14}

函数中也适用

def func(data:Union[int,str])->Union[int,str]:

    pass

4,多态

class Animal:    #抽象类含有抽象方法
    def speck(self):
        pass          #方法体空实现是抽象方法
class dog(Animal):
    def speck(self):
        print("汪汪汪")
class cat(Animal):
    def speck(self):
        print("喵喵喵")

def make_noise(animal:Animal):#以父类做定义声明
    animal.speck()
    dog=dog()#以子类做实际工作
    cat=cat()
make_noise(dog)
make_noise(cat)

5，闭包

def outer(logo):
    def inner(msg):
        print(f"<{logo}>{msg}<{logo}>")
    return inner
fn1=outer("bro")
fn1("x")
fn1("xio")

6,递归

import os

def test_os():

# print(os.listdir("D:/test"))#此方法是看文件里边有什么内容

# print(os.path.isdir())#判断此文件是否为文件夹

# print(os.path.exists())#判断指定路径是否存在

#找所有文件

def get_files_recursion_from_dir(path):

file_list=[]

if os.path.exists(path):

for f in os.listdir(path):

new_path=path+"/"+f #组装路径

if os.path.isdir(new_path):

file_list+=get_files_recursion_from_dir(new_path) #如果是找所有文件必须加上前面的变量相加

else:

file_list.append(new_path)

else:

print("不存在")

return []

return file_list

7，类的有关代码知识

类（classs） 调用类的时候类名加（）
class Dog:#类的名称得大写
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def sit(self):
        print(f'{self.name}is now sitting')#访问类内部变量前面必须加 self. 但是使用外部的变量就不用
    def roll_over(self):
        print(f'{self.name}rolled over')
my_dog=Dog('sah',12)

print(f'我的狗的名字是{my_dog.name}')
print(f'我的狗今年{my_dog.age}岁了')
my_dog.sit()
my_dog.roll_over()

给属性指定默认值
class Car:
    def __init__(self,make,model,year):
        self.make=make
        self.model=model
        self.year=year
        self.mile=0#可以直接添加属性
    def s1 (self):
        print(f'{self.mile}')
    def s2(self,mile2):
        if mile2>=self.mile:
        self.mile=mile2
        else:
        print('错误')
    def a(self):
        some=f'{self.make}{self.year},{self.model}'
        return some.title()
    def add(self,m):#可以通过方法累加
        self.mile+=m

my_car=Car('asd','saf',4152)
print(my_car.a())
my_car.mile=23#可以直接更改里程数
my_car.s2(34)
my_car.s1()
my_car.add(45)
my_car.s1()
#继承类
class ElectricCar(Car):
    def __init__(self,make,year,model):
        super().__init__(make,year,model)#super让子类能用父类的方法
        self.better_size=40
#在子类中重新起的方法
    def describe_brtter_size(self):
        print(f'my better size is {self.better_size}')
my_leaf=ElectricCar('SAHF',23,'AS')
print(my_leaf.a())
my_leaf.describe_brtter_size()

from car import Car 可以从文件中调用car类
from car import Car,Electeric 掉用多个类
#导入整个模块
import car
from car import * #导入模块中所有类
在类中也可以使用as起别名

应用
class Clock:
id=None
price=None
def ring(self):
import winsound#发出一些小声音
winsound.Beep(2000,3000)
clock1=Clock()
clock1.id=234
clock1.price=19.3
print(f"id:{clock1.id} price:{clock1.price}")
clock1.ring()


__init__（self，）：构造方法 他是自动执行
class Student:
name=None
age=None
tel=None
def __init__(self,name,age,tel):#自动执行（只要调用类）
self.name=name#name=外部传入的name
self.age=age
self.tel=tel
stu=Student("xie",12,122222)
print(stu.tel)

类的内置方法

一.__str__(self):方法
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
stu=Student("xiebro",19)
print(stu)#结果：<__main__.Student object at 0x000001ADBDAFCD90>
#当类对象需要被转换为字符串时，会输出如上结果（内存地址）
#内存地址没多大用，我们可以通过__str__方法，控制类转换为字符串的行为。
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return f"name={self.name},age={self.age}"
stu=Student("xiebro",19)
print(stu)
二.__lt__内置方法
 __lt__小于比较方法
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
stu1=Student("xiebro",12)
stu2=Student("bro",14)
print(stu1<stu2)#直接报错
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def __lt__(self, other):
return self.age<other.age
stu1=Student("xiebro",12)
stu2=Student("bro",14)
print(stu1<stu2)#True
print(stu1>stu2)#False
三.__le__内置方法
#__le__用于小于等于比较符号方法
class Student():
def __init__(self,name,age):
self.name=name
self.age=age
def __le__(self, other):
return self.age<=other.age
stu1=Student("xiebro",12)
stu2=Student("bro",13)
print(stu2>=stu1)#True
print(stu1>=stu2)#False
四.__eq__内置方法
class student:
def __init__(self,name,age):
self.name=name
self.age=age
def __eq__(self, other):
return self.age==other.age
stu1=student("xiebro",19)
stu2=student("bro",19)
print(stu1==stu2)#Ture



类中私有的用法及概念      
定义私有类只需要在前边加入__
class phone:
    IMEI=None
    __current=None#私有
    def call_5g(self):
        print("5g已经开启")
    def __keep_(self):#私有
       print("让CPU以但和模式运行以节省电量")
phone1=phone()
phone1.__current=33#私有变量赋值 不报错但无效
print((phone.__current))#报错
phone.__keep_#使用私有方法 报错
它可以被其他成员使用
class phone:
    IMEI=None
    __current=0.5#私有
    def call_5g(self):
        if self.__current>=1:
            print("5g已经开启")
        else:
            self.__keep_()
        print("电量不足,并设置一旦和运行来省电")
    def __keep_(self):#私有
        print("让CPU以但和模式运行以节省电量")
phone1=phone()


私有变量和类的例题（内部调用）
class Phone:
    __is_5g_enable=True
    def __check(self):
        if self.__is_5g_enable:
            print("5g开启")
        else:
            print("5g关闭，请使用4g网络")
    def call_by_5g(self):
        self.__check()
        print("正在通话中")
phone=Phone()
phone.call_by_5g()
类的继承
1.单继承
class Phone():
IMEI=None
producer=None
def call_by_4g(self):
print("4g通话")
class Phone2022(Phone):
face_id=True
def call_by_5g(self):
print("2022最新5g通话")
phone=Phone2022()
phone.call_by_5g()
2.多继承
class newphone(Phone,s,d):
pass#只是让语法不报错
对于父类中同名的成员变量调用的时候谁在左边就调用谁的


子类对父类的复写
class Phone():
IMEI="S"
def call_by_5g(self):
print("a")
class nPhone(Phone):#想复写直接在子类中从新写一下就ok
IMEI = "A"
def call_by_5g(self):
print("b")
第一种方式
print(f"调用父类中复写的变量{Phone.IMEI}")#第一种方式
Phone.call_by_5g(self)
第二种方式
print(f"调用父类中复写的变量{super().IMEI}")#第二种方式
super().call_by_5g()

8，装饰器

也是一种闭包，其功能就是在不破坏目标函数原有的代码和功能的前提下，为目标函数增加新功能。

def sleep():

import random

import time

print("睡眠中。。。。。")

time.sleep(random.randint(1,5))

def outer(func):

def inner():

print("我要睡觉了")

func()

print("我睡醒了")

return inner

fn=outer(sleep)#fn代表sleep

fn()

   第二种写法

def outer(func):

def inner():

print("我要睡觉了")

func()

print("我睡醒了")

return inner

@outer#把下边的函数带入上边

def sleep():

import random

import time

print("睡眠中。。。。。")

time.sleep(random.randint(1,5))

sleep()

二，机器学习理论

1，首先学习了线性回归，并使用最小二乘法以及梯度下降来实现

，理解了代价函数公式

3，以及在吴恩达老师课程里边学习到了一般和未知数系数联系画图求合适的W

下面是在csdn上学习的代码示例

import numpy as np
import matplotlib.pyplot as plt
#获取数据
data = np.array([[32, 31], [53, 68], [61, 62], [47, 71], [59, 87], [55, 78], [52, 79], [39, 59], [48, 75], [52, 71],
                 [45, 55], [54, 82], [44, 62], [58, 75], [56, 81], [48, 60], [44, 82], [60, 97], [45, 48], [38, 56],
                 [66, 83], [65, 118], [47, 57], [41, 51], [51, 75], [59, 74], [57, 95], [63, 95], [46, 79], [50, 83]])
x=data[:,0]
y=data[:,1]
#损失函数
def computer_cost(w,b,points):
    #points只是个形参，待会会把data传入的
    total_cost=0
    M=len(points)
    for i in range(M):
        x=points[i,0]
        y=points[i,1]
        total_cost+=(y-w*x-b)**2
    return total_cost/M

def average(data):
    sum=0
    num=len(data)
    for i in range(num):
        sum+=data[i]
    return sum/num

#核心函数
def fit(points):
    M=len(points)
    x_bar=average(points[:,0])
    sum_yx=0
    sum_x2=0
    sum_delta=0
    for i in range(M):
        x=points[i,0]
        y=points[i,1]
        sum_yx+=y*(x-x_bar)
        sum_x2+=x**2
    #核心
    w=sum_yx/(sum_x2-M*(x_bar**2))
    for i in range(M):
        x=points[i,0]
        y=points[i,1]
        sum_delta+=(y-w*x)
        b=sum_delta/M

        return w,b
w,b=fit(data)
print(f"w is:{w}")
print(f"b is:{b}")
cost=computer_cost(w,b,data)
print(f"cost is {cost}")


plt.scatter(x,y)
pred_y=w*x+b
plt.plot(x,pred_y,c='r')
plt.show()

以及梯度下降的代码示例

import numpy as np
import matplotlib.pyplot as plt

data = np.array([[32, 31], [53, 68], [61, 62], [47, 71], [59, 87], [55, 78], [52, 79], [39, 59], [48, 75], [52, 71],
                 [45, 55], [54, 82], [44, 62], [58, 75], [56, 81], [48, 60], [44, 82], [60, 97], [45, 48], [38, 56],
                 [66, 83], [65, 118], [47, 57], [41, 51], [51, 75], [59, 74], [57, 95], [63, 95], [46, 79],
                 [50, 83]])
x=data[:,0]
y=data[:,1]
#定义损失函数
def computer_cost(w,b,data):
    total_cost=0
    M=len(data)
    for i in range(M):
        x=data[i,0]
        y=data[i,1]
        total_cost+=(y-w*x-b)**2
        return total_cost/M
#定义模型的超参数
alpha=0.0001
initial_w=0
initial_b=0
num_iter=10   #迭代的次数
#定义核心梯度下降算法函数
def grad_desc(data,initial_w,initial_b,alpha,num_iter):
    w=initial_w
    b=initial_b
    #定义list保存所有损失函数数值，用来显示下降的过程
    cost_list=[]
    for i in range(num_iter):
        cost_list.append(computer_cost(w,b,data))
        w,b=step_grad_sesc(w,b,alpha,data)
    return [w,b,cost_list]
def step_grad_sesc(current_w,current_b,alpha,data):
    sum_grad_w=0
    sum_grad_b=0
    M=len(data)
    for i in range(M):
        x=data[i,0]
        y=data[i,1]
        sum_grad_w+=(current_w*x+current_b-y)*x
        sum_grad_b+=current_w*x+current_b-y

    grad_w=2/M*sum_grad_w
    grad_b=2/M*sum_grad_b
    updated_w=current_w-alpha*grad_w
    updated_b=current_b-alpha*grad_b
    return updated_w,updated_b


w, b, cost_list = grad_desc(data,initial_w,initial_b,alpha,num_iter)
print("w is: ", w)
print("b is: ", b)
cost = computer_cost(w, b, data)
print("cost is: ", cost)
plt.scatter(x, y)
# 针对每一个x，计算出预测的y值
pred_y = w * x + b
plt.plot(x, pred_y, c='r')
plt.show()

4，以及逻辑回归理论知识

逻辑回归是一种广泛应用于分类问题的机器学习算法，尽管名字中带有“回归”，但实质上是一种分类方法。它通过对数据进行拟合，预测离散型输出变量的概率。

基本概念：

（1）. 逻辑回归的用途：
   - 逻辑回归主要用于解决二分类问题，即预测结果只有两种可能性的情况。例如，判断一封电子邮件是否是垃圾邮件（垃圾邮件分类问题）。

（2.） 假设函数：
   - 逻辑回归基于一个假设函数，该函数采用线性回归的形式，但通过一个逻辑函数（也称为sigmoid函数）将连续的预测输出映射到[0, 1]之间。假设函数可以表示为：
]
     其中，x 是输入特征向量，theta  是参数向量。

（3）. Sigmoid函数：
   - Sigmoid函数将任意实数输入映射到[0, 1]之间的数值，它的图像是一个S形曲线。

理解成本函数

（1）. 成本函数（损失函数）：
   - 逻辑回归的成本函数基于最大似然估计推导而来，用于衡量模型预测概率与实际标签之间的差异。一般使用对数损失函数来定义成本：

     其中， m  是训练样本数，y^(i)是第 i 个样本的实际标签，是模型预测的标签概率。

5，理解神经网络

神经网络是一种模仿人类神经系统工作方式的机器学习模型。它由多层神经元（神经网络的基本单位）组成，每层神经元与下一层相连，并通过权重来传递和处理信息。神经网络可以进行学习和推断，广泛应用于图像识别、语音识别、自然语言处理等领域，尤其在深度学习时代得到了巨大发展和应用。

 主要组成部分：

（1）. 神经元（Neuron）：
   - 神经网络的基本单位，模拟生物神经元的功能。每个神经元接收来自上一层神经元或输入层的信息，并通过激活函数处理后输出给下一层神经元。

（2.） 层（Layer）：
   - 神经网络通常分为输入层、隐藏层和输出层。输入层接收原始数据或特征，隐藏层通过多层次的转换处理数据，输出层生成最终的预测结果。

（3）. 权重（Weight）：
   - 连接神经元之间的每条连接都有一个权重，表示了信息传递的强度和方向。神经网络的训练过程就是调整这些权重，使得网络能够准确预测目标值。

（4）. 偏置（Bias）：
   - 每个神经元通常还有一个偏置项，用于调整神经元激活函数的输入。偏置可以理解为神经元的阈值，影响神经元的激活状态。

（5）. 激活函数（Activation Function）：
   - 激活函数决定了神经元输出的非线性映射关系，常用的激活函数包括sigmoid、ReLU（Rectified Linear Unit）、tanh等，它们使得神经网络能够处理非线性问题和复杂关系。

（6）. 损失函数（Loss Function）：
   - 衡量神经网络预测值与真实值之间的差距，训练过程中通过最小化损失函数来调整网络参数。