2022.4.8学习总结

1.面向对象，理解为主

'''
面向对象
面向对象是一个编程思想（写代码的套路）
编程思想：
1.面向过程
2.面向对象
以上两种都属于写代码的套路(⽅法) ,最终⽬的都是为了将代码书写出来,只不过过程和思考⽅法不太⼀样.
面向过程：
1.关注的是具体步骤的实现，所有功能都是自己书写的
2.定义一个个函数，最终按照顺序调用函数
面向对象
1.关注的是结果，谁（对象）能帮我做这件事
2.找一个对象（），让对象去做
类和对象
面向对象的核心是找一个对象去帮我们处理事情，在程序代码中，对象是有类创建的，类和对象是面向对象编程中非常重要的两个概念类
抽象的概念，对对个特征和行为相同或相似事物的统称
泛指的（指代多个，而不是具体的一个人）、对象
具体存在的一个事物，看得见摸得着的
特指的（指代一个）河豚---类
大河豚-----类
我家里的那只河豚宝宝----对象类的组成
1.类名（给这多个事物起一个名字）
2.属性（事物的特征，即有什么，一般文字中的名词）
3.方法（事物的行为，即什么事，一般是动词）类的抽象（类的设计）
类的抽象，其实就是找到类的类名，属性和方法需求：
小明今年18岁，身高1.75，每天早上跑完步，回去吃东西
小美今年17岁，身高1.65，小美不跑步，小美喜欢吃东西
类名：人类（Human，People）
属性：名字（name），年龄（age），身高（height）
方法：跑步（run）吃（eat）需求
一只黄颜色的狗狗叫大黄
看见生人汪汪叫
看见家人摇尾巴类名：狗类（Dog）
属性：颜色（color），名字（name）
方法：汪汪叫（bark），摇尾巴（shake）面向代码的步骤
1.定义类，在定义类之前先设计类
2.创建对象，使用第一步定义的类创建对象
3.通过对象调用方法
'''
'''
面向对象基本代码的书写
1.定义类
先定义简单的类，不包含属性，在python中定义类需要使用关键字class
方法：方法的本质是在类中定义的函数，只不过，第一个参数是selfclass 类名：#在缩进中书写的内容，都是类的代码def 方法名（self）：  #就是一个方法pass2.创建对象
创建对象是使用类名进行创建，即类名（） #创建 对象，这个对象在后续不能继续使用，创建的对象想要在后续的代码中继续使用，需要使用一个变量将这个对象保存起来变量 = 类名（） #这个变量中保存的是对象的地址，一般可以成为这个变量的对象一个类可以创建多个对象，只要出现类名（）就是创建一个对象，每个对象的地址是不一样的3.调用方法对象.方法名()列表.sort()列表.append()4.案例实现
需求：小猫爱吃鱼，小猫要喝水
类名：Cat
属性：无
方法：eat drink
'''
'''
class Cat:def eat(self):print('小猫爱吃鱼')def drink(self):print('小猫爱喝水')
miaomiao = Cat()    #创建对象
miaomiao.eat()     #通过对象调用方法
miaomiao.drink()  #通过对象调用方法
'''
'''
self的说明class Cat:
# 在缩进中书写 ⽅法
def eat(self): # self 会⾃动出现,暂不管
print('⼩猫爱吃⻥...')
black_cat.eat()
1. 从函数的语法上讲, self是形参, 就可以是任意的变量名,
只不过我们习惯性将这个形参写作 self
2. self 是普通的形参, 但是在调⽤的时候没有传递实参值,
原因是, Python 解释器在执⾏代码的时候, ⾃动的将调⽤这个
⽅法的对象 传递给了 self, 即 self 的本质是对象
3. 验证, 只需要确定 通过哪个对象调⽤, 对象的引⽤和 self
的引⽤是⼀样的
4. self 是函数中的局部变量, 直接创建的对象是全局变量
'''
'''
之间的关系
class Cat:
# 在缩进中书写 ⽅法
def eat(self): # self 会⾃动出现,暂不管
print(f'{id(self)}, self')
print('⼩猫爱吃⻥...')
# 2. 创建对象
blue_cat = Cat()
print(f'{id(blue_cat)}, blue_cat')
# 3. 通过对象调⽤类中的⽅法
blue_cat.eat() # blue_cat 对象调⽤ eat ⽅法, 解释器就
会将 blue_cat 对象传给 self
print('_*_' * 30)
# 创建对象
black_cat = Cat()
print(f"{id(black_cat)}, black_cat")
black_cat.eat() # black_cat 对象调⽤ eat ⽅法, 解释器
就会将 black_cat 对象传给 self
'''
'''
对象的属性的操作
添加属性
对象.属性名 = 属性值类内部添加在内部方法中，self是对象
self.属性名 = 属性值类内部添加在内部方法中，self是对象
self.属性名 = 属性值
#在类中添加属性一般写在__init__方法中类外部添加
对象.属性名 = 属性值   #一般不用获取属性对象.属性名类内部
在内部方法中，self是对象
self.属性名类外部
对象.属性名  #一般很少用
'''
'''
class Cat():     #创建类def eat(self):print(f'{id(self)}',self)print(f'喵喵{self.name}爱吃鱼')jumiaomiao = Cat()     #创建对象
print(f'{id(jumiaomiao)},jumiaomiao')
jumiaomiao.name = '橘猫'   #给类添加属性
jumiaomiao.eat()    #t通过对象调用类
print('-'*40)baimiaomiao = Cat()   #创建对象
baimiaomiao.name = '白猫'
print(f'{id(baimiaomiao)},baimiaomiao')
baimiaomiao.eat()
'''
'''
魔方方法
python 中有⼀类⽅法, 以两个下划线开头,两个下划线结尾,并
且在满⾜某个条件的情况下, 会⾃动调⽤, 这类⽅法称为 魔法⽅
法
学习:
1. 什么情况下⾃动调⽤
2. 有什么⽤, ⽤在哪
3. 书写的注意事项__init__ ⽅法 **
1.什么情况下自动调用---创建对象后自动调用2.有什么用，用在哪里---
给对象添加属性的, (初始化⽅法, 构造⽅法)
某些代码, 在每次创建对象之后, 都要执⾏,就可以将这⾏代码写在 __init__ ⽅法3. 书写的注意事项，如果 init ⽅法中,存在出了 self之外的参数, 在创建对象的时候必须传参
'''
'''
class Cat:
# 定义添加属性的⽅法def __init__(self, name, age): # 这个⽅法是创建对象之后调⽤self.name = name # 给对象添加 name 属性self.age = age # 给对象添加 age 属性def show_info(self):  # 输出属性信息print(f'⼩猫的名字是: {self.name}, 年龄是:{self.age}')blue_cat = Cat('蓝猫', 2) # 创建对象,不要在⾃⼰类缩进中创建# Cat() # 创建对象 ,会输出
blue = blue_cat
blue.show_info()black_cat = Cat('⿊猫', 3)# Cat() # 创建对象 ,会输出
black_cat.show_info()'''
'''
__str__ ⽅法 *
1. 什么情况下⾃动调⽤
> 使⽤ print(对象) 打印对象的时候 会⾃动调⽤
2. 有什么⽤, ⽤在哪
> 在这个⽅法中⼀般书写对象的 属性信息的, 即打印对象
的时候想要查看什么信息,在这个⽅法中进⾏定义的
> 如果类中没有定义 __str__ ⽅法, print(对象) ,默认
输出对象的引⽤地址
3. 书写的注意事项
> 这个⽅法必须返回 ⼀个字符串
'''
'''
class Cat:def __init__(self, n, age): # 这个⽅法是创建对象 之后调⽤ # 定义添加属性的⽅法self.name = n # 给对象添加 name 属性self.age = age # 给对象添加 age 属性def __str__(self):return f'⼩猫的名字是: {self.name}, 年龄是:{self.age}'# ⽅法必须返回⼀个字符串, 只要是字符串就⾏,blue_cat = Cat('蓝猫', 2)  # 创建对象,不要在⾃⼰类缩进中创建 # Cat() # 创建对象 ,会输出
print(blue_cat)
# 创建⿊猫
black_cat = Cat('⿊猫', 3)
print(black_cat)
'''
'''
__del__ ⽅法 [了解]
_init__ ⽅法, 创建对象之后,会⾃动调⽤ (构造⽅法)
__del__ ⽅法, 对象被删除销毁时, ⾃动调⽤的(遗⾔, 处理后
事) (析构⽅法)
1. 调⽤场景, 程序代码运⾏结束, 所有对象都被销毁
2. 调⽤场景, 直接使⽤ del 删除对象(如果对象有多个名字(多
个对象引⽤⼀个对象),需要吧所有的对象都删除才⾏ )
'''
'''
class Demo:def __init__(self, name):print('我是 __init__, 我被调⽤了 ')self.name = namedef __del__(self):print(f'{self.name} 没了, 给他处理后事...')a = Demo('a')  # Demo('a')
b = Demo('b')
del a  # 删除销毁 对象,
print('代码运⾏结束')
'''
'''
案例1
1.小明 体重75公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西体重增加1公斤
类名: ⼈类 Person
属性: 姓名 name, 体重 weight
⽅法: 跑步 run
吃东⻄ eat
添加属性 __init__
属性信息 __str__
'''
'''
class Person:def __init__(self, name, weight):self.name = nameself.weight = weightdef __str__(self):return f"姓名: {self.name}, 体重:{self.weight} kg"def run(self):print(f'{self.name} 跑步 5 km, 体重减少了')self.weight -= 0.5 # 减体重, 即修改属性def eat(self):print(f'{self.name} ⼤餐⼀顿, 体重增加了')self.weight += 1# 修改体重xm = Person('⼩明', 75.0)
print(xm)
xm.run()
print(xm)
xm.eat()
print(xm)
'''
'''# 定义家具类 封装案例
class HouseItem:     #   """家具类"""def __init__(self, name, area):    #  """添加属性的方法"""self.name = nameself.area = areadef __str__(self):return f'家具名字{self.name}, 占地面积 {self.area} 平米'class House:                            #  房子类def __init__(self,name,area):self.name = name# 户型self.total_area= area   # 总面积self.free_area =area   # 剩余面积self.item_list = []   # 家具名称列表def __str__(self):return f"户型: {self.name}, 总面积:{self.total_area}平米, 剩余面积:{self.free_area} 平米, " \f"家具名称列表: {self.item_list}"def add_item(self, item):     # item 表示的家具的对象if self.free_area > item.area:  # 判断房子的剩余面积(self.free_area)和家具的占地面积(item.area)之间的关系 # self 表示的 房子对象, 缺少一个家具对象使用传参解决self.item_list.append(item.name)   # 添加家具, ---> 向列表中添加数据self.free_area -= item.area  # 修改剩余面积print(f'{item.name} 添加成功')else:print('剩余面积不足, 换个大房子吧')# 创建家具对象
bed = HouseItem('席梦思', 4)
chest = HouseItem('衣柜', 2)
table = HouseItem('餐桌', 1.5)
print(bed)
print(chest)
print(table)
# 创建房子对象
house = House('三室一厅', 150)
print(house)
# 添加 床
house.add_item(bed)
print(house)
''''''
class LoginPage:def __init__(self, username, password, code):self.username = usernameself.password = passwordself.code = codeself.btn = '登录'def login(self):print(f'1. 输入用户名 {self.username}')print(f'2. 输入密码 {self.password}')print(f'3. 输入验证码 {self.code}')print(f"4. 点击按钮 {self.btn}")login = LoginPage('admin', '123456', '8888')
login.login()'''
'''
私有和公有
1. 在 Python 中定义的方法和属性, 可以添加访问控制权限(即在什么地方可以使用这个属性和方法)
2. 访问控制权限分为两种, 公有权限, 私有权限
3. 公有权限
> 直接书写的方法和属性, 都是公有的
> 公有的方法和属性, 可以在任意地方访问和使用
4. 私有权限
> 在类内部, 属性名或者方法名 前边加上两个 下划线 , 这个属性或者方法 就变为 私有的
> 私有的方法和属性, 只能在当前类的内部使用
5. 什么时候定义私有
> 1. 某个属性或者方法,不想在类外部被访问和使用, 就将其定义为私有即可
> 2. 测试中,一般不怎么使用, 直接公有即可
> 3. 开发中,会根据需求文档, 确定什么作为私有
6. 如果想要在类外部操作私有属性, 方法是, 在类内部定义公有的方法, 我们通过这个公有方法去操作
# 补充:
# 对象.__dict__  魔法属性, 可以将对象具有的属性组成字典返回
'''
'''
#定义一个 Person 类, 属性 name, age(私有)class Person:def __init__(self, name, age):self.name = name  # 姓名  私有的本质, 是 Python 解释器执行代码,发现属性名或者方法名前有两个_, 会将这个名字重命名 会在这个名字的前边加上 _类名前缀,即 self.__age ===> self._Person__ageself.__age = age  # 年龄, 将其定义为私有属性, 属性名前加上两个 _def __str__(self):  # 在类内部可以访问私有属性的return f'名字: {self.name}, 年龄: {self.__age}'xm = Person('小明', 18)
print(xm)
# 在类外部直接访问 age 属性
# print(xm.__age) # 会报错, 在类外部不能直接使用私有属性
# 直接修改 age 属性
xm.__age = 20  # 这个不是修改私有属性, 是添加了一个公有的属性 __age
print(xm)# 名字: 小明, 年龄: 18
print(xm._Person__age)# 能用但是不要用 18
xm._Person__age = 19
print(xm)   # 名字: 小明, 年龄: 19
'''
'''
继承
1. 继承描述的是类与类之间的关系
2. 继承的好处: 减少代码的冗余(相同的代码不需要多次重复书写), 可以直接使用
语法
# class A(object):
class A: # 没有写父类,但也有父类, object, object 类是 Python 中最顶级(原始)的类
pass
class  B(A):  # 类 B, 继承类 Apass
术语:
1. A 类, 称为是 父类(基类)
2. B 类, 称为是 子类(派生类)
单继承: 一个类只继承一个父类,称为单继承
继承之后的特点:
> 子类(B)继承父类(A)之后, 子类的对象可以直接使用父类中定义的公有属性和方法
案例
1. 定义一个 动物类, 吃
2. 定义一个 狗类, 继承动物类, 吃, 叫
3. 定义一个 哮天犬类, 继承 狗类
'''
'''
# 1. 定义一个 动物类, 吃
class Animal:def eat(self):print('要吃东西')
# 2. 定义一个 狗类, 继承动物类, 吃, 叫
class Dog(Animal):def bark(self):print('汪汪汪叫....')
# 3. 定义一个 哮天犬类, 继承 狗类
class XTQ(Dog):pass
# 创建 动物类的对象
# ani = Animal()
# ani.eat()
# 创建狗类对象
# dog = Dog()
# dog.eat() # 调用父类中的方法
# dog.bark()  # 调用自己类中方法
# 创建哮天犬类对象
xtq = XTQ()
xtq.bark() # 调用 父类 Dog 类的方法
xtq.eat() # 可以调用 父类的父类中的方法
'''
'''
python 中 对象.方法() 调用方法
1. 现在自己的类中的去找有没有这个方法 如果有,直接调用
2. 如果没有去父类中 查找, 如果有,直接调用
3. 如果没有, 去父类的父类中查找, 如果有直接调用
4 ...
5. 如果 object 类中有,直接调用, 如果没有,代码报错
'''
'''
重写
重写: 在子类中定义了和父类中名字相同的方法, 就是重写
重写的原因: 父类中的方法,不能满足子类对象的需求,所以重写
重写之后的特点: 调用子类字节的方法, 不再调用父类中的方法
重写的方式:
>1. 覆盖(父类中功能完全抛弃,不要,重写书写)
>2. 扩展(父类中功能还调用,只是添加一些新的功能) (使用较多)
覆盖
1. 直接在子类中 定义和父类中名字相同的方法
2. 直接在方法中书写新的代码
'''
'''
class Dog:def bark(self):print('汪汪汪叫.....')
class XTQ(Dog):  # XTQ 类bark 方法不再是汪汪汪叫, 改为 嗷嗷嗷叫def bark(self):print('嗷嗷嗷叫...')
xtq = XTQ()
xtq.bark()
'''
#扩展父类中的功能
'''
1. 直接在子类中 定义和父类中名字相同的方法
2. 在合适的地方调用 父类中方法  super().方法()
3. 书写添加的新功能
'''
'''
class Dog:def bark(self):print('汪汪汪叫.....')print('汪汪汪叫.....')
class XTQ(Dog):           #XTQ 类bark 方法不再是汪汪汪叫, 改为 # 1. 先 嗷嗷嗷叫(新功能) 2, 汪汪汪叫(父类中功能) 3. 嗷嗷嗷叫 (新功能)def bark(self):print('嗷嗷嗷叫...')  # 调用父类中的代码super().bark() # print() 如果父类中代码有多行呢?print('嗷嗷嗷叫...')xtq = XTQ()
xtq.bark()
'''
'''
多态[了解]
1. 是一种写代码,调用的一种技巧
2. 同一个方法, 传入不同的对象, 执行得到不同的结果, 这种现象称为是多态
3. 多态 可以 增加代码的灵活度
--------
哪个对象调用方法, 就去自己的类中去查找这个方法, 找不到去父类中找属性和方法
Python 中一切皆对象.
即 使用 class 定义的类 也是一个对象对象的划分
实例对象(实例)
1. 通过 类名() 创建的对象, 我们称为实例对象,简称实例
2. 创建对象的过程称为是类的实例化
3. 我们平时所说的对象就是指 实例对象(实例)
4. 每个实例对象, 都有自己的内存空间, 在自己的内存空间中保存自己的属性(实例属性)类对象(类)
1. 类对象 就是 类, 或者可以认为是 类名
2. 类对象是 Python 解释器在执行代码的过程中 创建的
3. 类对象的作用: ① 使用类对象创建实例 类名(),  ② 类对象 也有自己的内存空间, 可以保存一些属性值信息
(类属性)
4. 在一个代码中, 一个类 只有一份内存空间
'''
'''
属性的划分
实例属性
概念: 是实例对象 具有的属性
定义和使用
在 init 方法中, 使用 self.属性名 = 属性值 定义
在方法中是 使用 self.属性名 来获取(调用)内存
实例属性,在每个实例中 都存在一份 使用时机
1. 基本上 99% 都是实例属性,即通过 self 去定义
2. 找多个对象,来判断这个值是不是都是一样的, 如果都是一样的, 同时变化,则一般定义为 类属性, 否则定义
为 实例属性
'''
'''
类属性
概念: 是 类对象 具有的属性
定义和使用
在类内部,方法外部,直接定义的变量 ,就是类属性
使用:  类对象.属性名 = 属性值  or  类名.属性名 = 属性值
类对象.属性名  or  类名.属性名内存
只有 类对象 中存在一份方法的划分
方法, 使用 def 关键字定义在类中的函数就是方法
实例方法(最常用)
定义
# 在类中直接定义的方法 就是 实例方法
class Demo:def func(self):  # 参数一般写作 self,表示的是实例对象pass定义时机(什么时候用)
如果在方法中需要使用实例属性(即需要使用 self), 则这个方法必须定义为 实例方法调用
对象.方法名()  # 不需要给 self 传参 类方法(会用)
定义
# 在方法名字的上方书写 @classmethod 装饰器(使用 @classmethod 装饰的方法)
class Demo:
@classmethoddef func(cls):  # 参数一般写作 cls, 表示的是类对象(即类名) classpass定义时机(什么时候用)
1. 前提, 方法中不需要使用 实例属性(即 self)
2. 用到了类属性, 可以将这个方法定义为类方法,(也可以定义为实例方法)调用
# 1. 通过类对象调用
类名.方法名()  # 也不需要给 cls 传参, python 解释器自动传递
# 2. 通过实例对象调用
实例.方法名()  # 也不需要给 cls 传参, python 解释器自动传递
'''
'''
静态方法(基本不用)
定义
# 在方法名字的上方书写 @staticmethod 装饰器(使用 @staticmethod 装饰的方法)
class Demo:@staticmethoddef func():  # 一般没有参数pass定义时机(什么时候用)
1. 前提, 方法中不需要使用 实例属性(即 self)
2. 也不使用 类属性, 可以将这个方法定义为 静态方法调用
# 1. 通过类对象调用
类名.方法名()
# 2. 通过实例对象调用
实例.方法名()
'''
'''
#练习 1  定义一个 Dog 类, 定义一个类属性 count,用来记录创建该类对象的个数. (即每创建一个对象,count 的值就要加1)实例属性 name
class Dog: # 定义类属性count = 0def __init__(self, name):   # 定义实例属性, init 方法中self.name = name # 实例属性Dog.count += 1   # 因为每创建一个对象,就会调用 init 方法, 就将个数加 1 的操作,写在 init 方法中print(Dog.count) # 0  # 在类外部  # 打印输出目前创建几个对象dog1 = Dog('小花')   # 创建一个对象# 打印输出目前创建几个对象
print(Dog.count)  # 1
dog2 = Dog # 不是创建对象, 个数不变的
dog3 = dog1  # 不是创建对象, 个数不变的
print(Dog.count)  # 1
dog4 = Dog('大黄')  # 创建一个对象 , 个数 + 1
print(Dog.count)  # 2
dog5 = Dog('小白')
print(Dog.count) # 3# 补充, 可以使用 实例对象.类属性名 来获取类属性的值 (原因, 实例对象属性的查找顺序, 先在实例属性中找,找到直接使用
# 没有找到会去类属性中 找, 找到了可以使用, 没有找到 报错)
print(dog1.count) # 3
print(dog4.count)  # 3
print(dog5.count)  # 3'''
'''
补充
哈希（hash）: 是一个算法， 可以对数据产生一个唯一的值（指纹）
is 可以用来判断两个对象是不是同一个对象，即 两个对象的引用是否相同
a is b  === > id(a) == id(b)
面试中可能会问： is 和 == 的区别？
==  只判断数据值是否相同， is 判断引用是否相同
'''
'''
import random
class Game: # 类属性, 游戏的最高分top_score = 0def __init__(self, name): # 定义实例属性 nameself.name = namedef show_help(self):print('这是游戏的帮助信息')def show_top_score(self):print(f'游戏的最高分为 {Game.top_score}')def start_game(self):print(f'{self.name} 开始一局游戏, 游戏中 ...,', end='')score = random.randint(10, 100)  # 本次游戏的得分print(f'本次游戏得分为 {score}')if score > Game.top_score:  # 修改最高分Game.top_score = scorexw = Game('小王')
xw.start_game()
xw.show_top_score()
xw.start_game()
xw.show_top_score()
xw.show_help()
'''

2.明日计划，开始selenum学习

2022.4.8学习总结相关推荐

MAYA 2022基础入门学习教程
流派:电子学习| MP4 |视频:h264,1280×720 |音频:AAC,48.0 KHz 语言:英语+中英文字幕(根据原英文字幕机译更准确)|大小解压后:3.41 GB |时长:4.5小时包含 ...
[2022]李宏毅深度学习与机器学习课程内容总结
[2022]李宏毅深度学习与机器学习课程内容总结课程感受第一讲必修 ML的三个步骤第一讲选修深度学习发展趋势反向传播从线性模型到神经网络为什么要用正则化技术为什么分类是用交叉熵损失函数 ...
2022最新软件测试学习路线图
2022最新软件测试学习路线图! 正在学习或者考虑学习软件测试的小伙伴们有时候是不是觉得很迷茫,学习了软件测试职业到底有哪些发展方向呢?又需要学习哪些内容,掌握到什么程度呢?学习过程中,学习路线是必不 ...
2022 开源轮子学习笔记
2022 开源轮子学习笔记 OKHttp(OKHttp) 总结: OkHttp的内部实现通过一个责任链模式完成,将网络请求的各个阶段封装到各个链条中,实现了各层的解耦. 值得一看的参考: https: ...
2022年Oracle学习计划
2022年Oracle学习计划 Q1(2022-1-1 至 2022-3-31) Q1(一月份) 1.1 ~ 1.14 学习内容: 1.15 ~ 1.30 学习内容: Q1(二月份) 2.11 ~ 2 ...
2022年Java学习笔记目录
一.2022年Java任务驱动课程任务驱动,统摄知识点:2022年Java程序设计讲课笔记二.2022年Java学习笔记 (一)踏上Java开发之旅 Java学习笔记1.1.1 搭建Java开发环 ...
2022年Java学习路线图，精心整理「史上最全」
前言: 很多老铁经常问我:哪些是适合Java零基础学习的视频?应该先学哪个后学哪个?等等问题. 那么,怎么解决这些疑问? 一个系统的Java学习路线正是你最需要的,这也是为什么很多前期自学的小白们到处 ...
2022年Java学习路线图，精心整理
前言: 很多老铁经常问我:哪些是适合Java零基础学习的视频?应该先学哪个后学哪个?等等问题. 那么,怎么解决这些疑问? 一个系统的Java学习路线正是你最需要的,这也是为什么很多前期自学的小白们到处 ...
【深度学习】李宏毅2021/2022春深度学习课程笔记 - Deep Learning Task Tips
文章目录一.深度学习步骤回顾二.常规指导三.训练过程中Loss很大 3.1 原因1:模型过于简单 3.2 原因2:优化得不好 3.3 原因1 or 原因2 ? 四.训练过程Loss小.测试过程L ...
[2022]李宏毅深度学习与机器学习第四讲（选修）-GNN
[2022]李宏毅深度学习与机器学习第四讲(选修)-GNN 做笔记的目的 GNN NN4G DCNN MoNET GTA GIN 做笔记的目的 1.监督自己把50多个小时的视频看下去,所以每看一部分内 ...

2022.4.8学习总结

2022.4.8学习总结相关推荐

最新文章

热门文章