Python Learning(八)-面向对象

python实现q-learning算法 关于q-learning算法,可参照以下博客,我只是复现作者的算法,如有错误,请私信改正。 A Painless Q-learning Tutorial (一个 Q-learning 算法的简明教程)_peghoty-优快云博客 import numpy as np import pandas as pd class QL: def __init__(self, actions, gamma=0.8, e_greedy=0.9): self.actions = act. 阅读详情

八 面向对象

对象(Object)

什么是对象?

  • 对象是内存中专门用来存储数据的一块区域

  • 对象中可以存放各种数据

  • 对象由三部分组成(id,type,value)

面向对象(oop)

  • Python是一门面向对象的编程语言
  • Python中的所有操作,都是通过对象来进行的
  • 对应的是面向过程的编程语言,指的是将程序的逻辑分解为一步步的抽象来完成程序
  • 面向过程编写的代码往往只适用于一个功能,不方便扩展,可复用性低
  • 面向对象的编程语言关注的是对象而不是过程,一切都是对象
类(class)
  • 我们目前学习的对象都是Python的内置对象
  • 自定义对象(class)
  • 类,简单理解他就是一个图纸,程序中需要根据类创建对象
  • 我们称对象是类的instance实例
  • 如果多个对象是通过一个类创建的,那么我们称这些对象是一类对象
  • 自定义的类都需要使用大写字母开头,大驼峰命名法

定义一个简单的类

类创建语法:

class 类名([父类]):

​ 代码块

class MyClass():
    pass
mc=MyClass()
print(MyClass)
print(isinstance(mc,MyClass))
# __main__.MyClass
# True
mc =MyClass() #mc 就是MyClass的实例
mc_2=MyClass()

实际上类也是一个对象,就是用来创建对象的对象,可以看下每个类的type

使用类创建对象的流程 mc=MyClass()

1. 创建一个变量mc
2. 在内存中创建一个新的对象
3. 分配地址,type就等于MyClass
4. 将对象的id赋值给变量mc	

现在我们通过MyClass创建的对象什么都没有,相当于一个空盒子,可以像对象中添加变量称为属性

属性语法:

对象.属性=属性值

mc.name=‘tom’

类的定义
  • 类和对象是对现实生活中的内容抽象
  • 实际上所有的事物都有俩部分构成
    1. 数据(属性)
    2. 行为(方法)
class Person:
	name='tom'
	def sayHello():
		print('Hello')
p1=Person()
p2=Person()


print(p1.name,p2.name)
p1.sayHello()
# TypeError: sayHello() takes no arguments (1 given)

属性和方法都定义在类对象中,为什么实例可以访问到类中的属性和方法

  • 属性和方法的查找流程

    1. 当我们调用一个对象的属性时,解析器会先在当前对象中寻找是否含有该属性
    2. 如果有则直接返回当前的对象的属性值
    3. 如果没有则去当前对象的类对象中去寻找,如果有则返回类对象的属性值(就是type对应的类对象)
  • 所以共有的属性和方法应该存在类对象中,实例独有的属性和方法需要自定义

    比如:人共有的吃饭/睡觉等方法是共有的,名字是自定义的

方法调用和函数调用的区别:

如果是函数的调用传几个参数就是几个参数,如果是方法的调用默认至少有一个参数.

注意:方法调用时,第一个参数由解析器自动传递,所以定义方法时,至少要定义一个形参

这里第一个参数,就是调用方法的对象本身,如果p1调的,则第一个参数就是p1对象,p2调的则第一个参数就是p2对象,一般我们都会将这个参数命名为self

class Person:
	name='tom'
	def sayHello(self):
		print(self)
p1=Person()
p1.sayHello()
print(p1)
p2=Person()
p2.sayHello()
print(p2)
#<__main__.Person instance at 0x7f688ec60638>
#<__main__.Person instance at 0x7f688ec60638>
#<__main__.Person instance at 0x7f688ec60680>
#<__main__.Person instance at 0x7f688ec60680>
对象的初始化

在类中可以定义一些特殊的方法(魔术方法),以_开头_结尾的方法

特殊方法不需要我们自己调用,会在类对象创建的时候自动调用,这样可以避免必要属性不传导致的错误.

创建对象的流程 :

  1. 创建一个变量
  2. 在内存中创建一个对象
  3. _init_(self)方法执行
  4. 将对象的id赋值给变量
一个标准类的流程
class Person:
	def __init__(self,name):
		self.name=name
	def sayHello(self):
		print('i am '+ self.name)
p1=Person('tom')
p1.sayHello()
print(p1.name)
p2=Person('jack')
p2.sayHello()
print(p2.name)
# i am tom
# tom
# i am jack
# jack

类的基本结构

class类名([父类]):

​ 公共的属性

​ #对象的初始化方法

​ def _init_(self,…):

​ …

​ def method(self):

​ …

目前对象的属性可以随意修改,非常不安全,不论对错例如:只需要p.name=…就行,所以引入封装

封装

封装是面向对象的三大特性之一

封装指的是隐藏对象中一些不希望被外部所访问到的属性或方法

如何隐藏对象中的一个属性?

  1. 修改对象的属性名为外部知道的名字

  2. getter and setter

  3. getter setter 方法其实也可以有妙用 比如get方法 用户获取商品价格的时候计算PU UV

    set方法 用户修改密码的时候给出提醒

  4. 使用getter方法可以表示一些计算的属性 比如计算长方形的面积

  5. 可以使用__双下划线开头的属性,这个是隐藏属性只能在类的内部访问,(相当于java中的private),无法通过对象访问

  6. 其实隐藏属性只不过是Python自动为属性修改了一个名字,__属性实际上是改为了,_类命_属性名

  7. 一般情况下我们使用_单下划线开头属性表示私有属性,没有特殊需要不要修改私有属性(只是不希望你改)

    class Person:
    	def __init__(self,name):
    		self._name=name
    	def get_name(self):
    		return self._name
    	def set_name(self,name):
    		self._name=name
    
    p=Person('hetao')
    print(p.get_name())
    
    
class Person:
	def __init__(self,name,age,price):
		self.hidden_name=name
		self.hidden_age=age
		self.hidden_price=price
	def get_name(self):
		return self.hidden_name
	def set_name(self,name):
		self.hidden_name=name
	def get_age(self):
		return self.hidden_age
	def set_age(self,age):
		if age>0:
			self.hidden_age=age
	def get_price(self):
		return self.hidden_price
	def set_price(self,price):
		self.hidden_price=price
	def sayHello(self):
		print('i am '+ self.hidden_name)
p=Person('hetao',2,'1800')
print(p.get_price())
p.set_price(2000)
print(p.get_price())
# 1800
# 2000
装饰器

property装饰器,用来将一个get方法,装换为对象的属性

添加为property装饰器以后,我们就可以像调用属性一样使用get方法

使用property装饰的方法,必须和属性名是一样的 @属性名.setter(注意:有setter必须有getter)

class Person:
	def __init__(self,name):
		self._name=name
	@property
	def name(self):
		print('get is running')
		return self._name

	@name.setter
	def name(self,name):
		print('set is running')
		self._name=name

p=Person('hetao')
print(p.name)
p.name='tom'
print(p.name)
# get is running
# hetao
# set is running
# get is running
# tom
继承

在定义类的同时,可以在括号中指定当前类的父类,子类可以继承父类中所有的属性和方法

class Animal:
	def run(self):
		print('running funny')
	def sleep(self):
		print('sleeping deeply')

class Dog(Animal):
	def bark(self):
		print('wang wang wang')

d=Dog()
d.run()
print(issubclass(Dog,Animal))
print(isinstance(d,Animal))
# running funny
# True
# True

如果在创建类时省略了父类,默认父类为Object,Object是所有类的父类,所有的类都继承Object

如果子类的方法和父类方法重复,这个时候调用谁?

重写
class Animal:
	def run(self):
		print('running funny')
	def sleep(self):
		print('sleeping deeply')

class Dog(Animal):
	def run(self):
		print('dog is running')
	def bark(self):
		print('wang wang wang')

d=Dog()
d.run()
# dog is running

调用一个对象的方法时,如果有调用当前对象的方法,没有的话调用父类中去寻找,直到Object

父类中所有的方法都会被子类继承,包括特殊方法,如果不初始化父类中的属性会报错,所有希望直接调用父类中的init方法来初始化父类中的属性super()

super()

通过super()返回对象调用父类方法时,不需要传递self(python3中)

class Animal(object):
	def __init__(self,name,age):
		self._name=name
		self._age=age
	@property
	def name(self):
		self._name=name
	@name.setter
	def name(self,name):
		self._name=name
	@property
	def age(self):
		self._age=age
	@age.setter
	def age(self,age):
		self._age=age
class Dog(Animal):
	def __init__(self,name,age):
		super(Dog,self).__init__(name,age)
	@property
	def name(self):
		self._name=name
	@name.setter
	def name(self,name):
		self._name=name
	@property
	def age(self):
		self._age=age
	@age.setter
	def age(self,age):
		self._age=age


d=Dog('tom',18)
# python2
class Animal:
	def __init__(self,name,age):
		self._name=name
		self._age=age
	@property
	def name(self):
		self._name=name
	@name.setter
	def name(self,name):
		self._name=name
	@property
	def age(self):
		self._age=age
	@age.setter
	def age(self,age):
		self._age=age
class Dog(Animal):
	def __init__(self,name,age):
		super( ).__init__(name)
		self._age=age
	@property
	def name(self):
		self._name=name
	@name.setter
	def name(self,name):
		self._name=name
	@property
	def age(self):
		self._age=age
	@age.setter
	def age(self,age):
		self._age=age


d=Dog('tom',18)
# python3

类名.__bases__这个属性可以用来获取当前类的所有父类

class A(object):
	def test(self):
		print('a')
class B(object):
	def test(self):
		print('b')
class C(A,B):
	def test(self):
		print('c')
print(C.__bases__)
#(<class '__main__.A'>, <class '__main__.B'>)

如果多个父类中有重名的方法,会先调前面的

class A(object):
	def test(self):
		print('a')
class B(object):
	def test(self):
		print('b')
class C(B,A):
	pass
c=C()
c.test() 
# b

没有特殊情况下我们一般不会用多重继承

比如

		object 2
    A 1				B 3
    
    		c 4
    		
    		D 5
	class D(A,B,C):
		pass
	d=D()
	d.test()这个时候的调用顺序如上
	# 先找第一个父类A,如果A中没有找A的父类Object,Object没有找B,b没有找b的父类(因为Object已经找过不再找了,然后是c,c找不到找c的父类(因为abObject都找过不再找),然后是找d)
	# 所以多重继承太过复杂
多态

多态从字面理解是多种形态

java中的多态指的是父类的应用对应子类的对象,这样更加灵活使用

Animal animal =new Cat();

在Python中调用不同的子类将会产生不同的行为,而无需知道这种子类实际上是什么,这是多态重要的应用场景

多态的具体好处可以用一句话来概括: 一个接口,多种实现

  • 增加了程序的灵活性,不论对象如何变化,使用者都是通过同一种形式去调用
  • 增加了程序的额外可扩展性
多态和多态性(鸭子类型)

多态指的是一类事物的多种形态,比如animal类可以有多种子类(猫/狗/猪等)

多态性指的具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名,调用不同内容的函数

比如len()函数可以传递列表,元组等

任意定义一个函数只要有__len__方法也可以使用len()函数

class A(object):
	def __len__(self):
		return 10

c=A()
print(len(c))
# 10

面向对象的三大特征

  • 封装

    确保了对象中的数据安全

  • 继承

    保证了对象的可扩展性

  • 多态

    保证了程序的灵活性

类中的属性和方法
类属性
class A(object):
	count=0
	def __init__(self):
		self.name='tom'
a=A()
print(a.count)
A.count=100
print(A.count)
# 0
# 100
  • 类属性,可以直接在类中定义的属性是类属性
  • 类属性可以通过类或类的实例访问
  • 但是类属性只能通过类对象来修改,无法通过实例对象来修改
实例属性
  • 通过实例对象添加的属性属于实力属性
  • 实例属性只能通过实例对象来访问和修改,类对象无法访问修改
class A(object):
	count=0
	def __init__(self):
		self.name='tom'
a=A()
a.name='jack'
print(a.name)
# jack
实例方法
  • 在类中定义,以self为第一个参数的方法都是实例方法
  • 实例方法在调用的时候,Python会将调用对象作为self传入
  • 实例方法可以通过实例和类调用,通过类调用时候不会传self,此时必须手动传递self
class A(object):
	count=0
	def __init__(self):
		self.name='tom'
	def test(self):
		print('test')
a=A()
a.test()
A.test(a)
# test
# test
类方法
  • 在类的内部,@classmethod 来修饰的方法属于类方法
  • 类方法的第一个参数是cls,也会被自动传递,cls就是当前的类对象
  • 类方法和实例方法的区别 实例方法的参数是self,而类方法的第一个参数是cls
  • 类方法可以通过类去调用,也可以通过实例调用,没有区别
class A(object):
	count=0
	def __init__(self):
		self.name='tom'
	@classmethod
	def test(cls):
		print('test')

A.test()
# test
静态方法
  • 在类中使用@staticmethod 来修饰的方法属于静态方法
  • 静态方法不需要指定任何的默认参数,静态方法可以通过类和实例去调用
  • 静态方法,基本上是一个和当前类无关的方法,只是保存到当前类中的函数
  • 静态方法一般都是一些工具方法
class A(object):
	count=0
	def __init__(self):
		self.name='tom'
	@staticmethod
	def test():
		print('test')
a=A()
a.test()
A.test()
# test
# test
垃圾回收

在程序中没有被引用的对象就是垃圾,垃圾回收就是将垃圾对象从内存中进行删除(Python中有自动的垃圾回收机制)

class A(object):
	def __init__(self):
		self.name='tom'
a=A()
print(a.name)
a=None # 将a设置为None 此时没有任何变量使用A()对象进行引用,就是变成了垃圾 程序结束的时候也会触发垃圾回收
class A(object):
	def __init__(self):
		self.name='tom'
	def __del__(self): # 这是个魔术方法,当对象没有引用的时候会自动调用这个方法
		print('i was deleted')
a=A()
print(a.name)
a=None
# tom
# i was deleted
特殊方法(魔术方法)
  • 特殊方法都是双下划线开头和结尾的
  • 特殊方法一般不需要手动调用,在特殊的情况下自动执行
__str()__

可以指定对象转换为字符串的结果

class Person(object):
	def __init__(self,name,age):
		self.name=name
		self.age=age
    def __str__(self):
		return 'Person [name=%s,age=%d]'%(self.name,slef.age)
p1=Person('TOM',18)
p2=Person('jack',16)

#1 .print(p1) # 当我们在打印对象的时候,实际上是调用了对象中的特殊方法__str__
# <__main__.Person object at 0x7f08d587b410> 
# 2 .print(p1)# Person [name='tom',age=18]
__repr__

直接在交互模式中输出的结果

例如

>>> a='hello'
>>> print(a)
hello # 调用的str
>>> a
'hello' # 调用的repr
>>> 
__gt__

大于比较

class Person(object):
	def __init__(self,name,age):
		self.name=name
		self.age=age
	def __gt__(self,other):
		return self.age>other.age
p1=Person('TOM',18)
p2=Person('jack',16)

print(p1>p2)
# True
  • lt <
  • le <=
  • eq =
  • ne !=
  • gt >
  • ge >=
__len__

__bool__ 本来是判断对象是否为空

class Person(object):
	def __init__(self,name,age):
		self.name=name
		self.age=age
	def __gt__(self,other):
		return self.age>other.age
p1=Person('TOM',18)
p2=Person('jack',16)
p1=None
print(bool(p1)) # false

可以通过bool来指定对像转为布尔值的条件

还有许多的魔法方法都可以改比如加减乘除,都是多态的表现

模块
创建模块

模块化,指的是将一个完整的程序分解为一个一个小的模块,通过将模块组合,搭建出一个完整的程序

在Python中一个py文件就是一个模块,创建模块就是创建py文件

注意:模块名要符合合格的标识符的规范

如何在其它模块中引入外部模块

  1. import模块名 (模块名,就是Python文件的名字,不需要py后缀)

    • import test_module

    • 模块可以引入同一个模块多次,但是模块的实例只会创建一个

  2. import 模块名 as 模块别名

    • import test_module as test
    • print(test)
    • import 可以在程序的任意位置调用,一般都写在开头
    • 没一个模块都有一个__name__属性可以查看当前模块的文件名
    • 注意__name__属性为__main__的模块是主模块,一个程序中只会有一个主模块,就是通过python执行的模块
使用模块

访问模块中的属性:模块名.变量名

#bb.py
a=10
b=20
# aa.py
import bb
print(bb.a)
# 10

访问模块中的函数:模块名.函数名

访问模块中的类: 模块名.类

也可以引入模块中的部分内容

语法:from 模块名 import 变量,变量…

  • from m import Person,test
  • from m import * #一般不会轻易使用 会和主模块冲突

也可以为引入的变量使用别名

语法:from 模块名 import 变量 as 别名

  • from m import test2 as new_test2

添加了_的变量只能在模块内部访问,相当与私有变量,通过import *引入时不会看见 但import m 可以

*规定某些代码,只有当当前模块是主模块的时候才执行,而当前代码被其它模块引入的时候不需要执行

if __name__=='__main__':
    pass
包 package
  • 包也是一个模块,当我们模块中代码过多时,或者一个模块需要被分解成多个模块时,就需要使用到包

  • 普通的模块就是一个py文件,包就相当于一个文件夹

  • 包中必须要有一个__init__.py

from hello import a,b
print(a.xxx)
print(b.xxx)

包的好处就是可以把功能相似的代码放到一块

__pycache__

模块缓存文件,py在执行前,需要被解析器转为机器码,然后再执行,所以我们在使用模块(包)时,需要将模块的代码转为机器码然后再交由计算机执行,而为了提高程序运行性能,Python会在编译一次过后,将代码保存到一个缓存文件中,下次加载这个包时,不再重新编译,加载缓存缓存中的.

python标准库

开箱即用(在官方文档中global module index中可以找到全局的索引库)

为了实现开箱即用,Python中提供了一个模块的标准库,标准库是Python安装自带的

sys模块,提供了一些变量和函数,可以获取到Python的解析器

pprint模块,提供了我们一个方法pprint()该方法可以用来对打印的数据做简单的格式化

import sys
import pprint
print(sys.argv)# 获取在命令行执行这个py脚本的参数
print(sys.modules) # 返回所有引入的模块,是一个字典,key是模块名字 value是模块对象
pprint.pprint(sys.modules) # 返回pretty(漂亮)的print语句
pprint.pprint(sys.path) # 他是一个列表,列表中保存的是模块的搜索路径(这个是pprint的路径) 
print(sys.platform) #表示当前Python运行的操作系统环境
sys.exit('gg')# 用来退出程序

os模块,让我们对操作系统进行访问

import pprint
import os

pprint.pprint(os.environ)# 返回的是系统的环境变量是个字典
os.system('ls') # 可以直接执行Linux命令
Q-learning 强化学习是一种机器学习范式,目标是让智能体(Agent)通过与环境(Environment)的交互,学习如何采取行动以最大化长期的累积奖励(Cumulative Reward)。试错学习:智能体通过尝试不同行动,观察结果,逐步改进策略。延迟奖励:奖励可能不是即时的,智能体需要考虑长期收益。序列决策:智能体的决策是连续的,每一步行动会影响后续状态。游戏(如AlphaGo)机器人控制自动驾驶推荐系统。 阅读详情

相关推荐

Learning Python: Powerful ObjectOriented Programming

作者:禅与计算机程序设计艺术 1.简介 Python是一个非常具有魅力的语言。它的简单、易用、易读、跨平台、丰富的库、支持多种编程范式以及海量第三方库的特性,都让它成为了一种正在被越来越多的人所喜爱的编程语言。本系列文章将带领大家了解Python编程的一些基本概念、术语、原理、操作方法以及应用场景,帮助

AI天才研究院 889

第十四章:面向对象 - 类的简介

01 - 面向对象 - 面向对象举例 所谓面向对象的编程语言,简单理解就是语言中所有的操作都是 通过对象来完成的 面向过程就是将程序的逻辑分解成一个一个的步骤 通过对每个步骤的抽象来完成程序 ‘’’ 孩子吃西瓜 1.妈妈穿衣服穿鞋出门 2.妈妈骑电动车 3.妈妈到超市门口放好电动车 4.妈妈买西瓜 5.妈妈结账 6.妈妈骑电动车回家 7.到家孩子吃西瓜 ‘’’ 这种方式编写的代码往往只适用于一个功...

maihailunP1的博客 283

Reinforcement Learning in Python:实践指南

1.背景介绍 人工智能(Artificial Intelligence, AI)是一门研究如何让计算机自主地学习、理解、推理和决策的科学。人工智能的一个重要分支是强化学习(Reinforcement Learning, RL),它研究如何让计算机通过与环境的互动来学习如何做出最佳决策。强化学习的目标是让计算机能够在不同的状态下自主地选择行动,从而最大化

AI天才研究院 927

面向对象编程一 类的基本介绍

面向对象编程介绍:(如果可以把对象归类的时候,使用面向对象编程) 面向对象编程:Object Oriented Programming,简称OOP,是一种程序设计思想。 需要注意的是,与之对应的是面向过程编程思想。实际上,能够使用面向对象编程思想实现的程序,也都能通过面向过程完成。只是看哪种思想更适合当前开发需求。 面向过程与面向对象区别: √ 面向过程:根据业务逻辑从上到下写代码 √ 面向对象:将数据与函数绑定到一起,进行封装。减少重复代码的重写过程 面向对象概念及术语: 类、对象、实例化实例变量、类变量

yuyejisi的博客 303

掌握Python编程:《Learning Python 5th Edition》实战指南

类型注解的语法是通过在变量、参数或返回语句后添加冒号和类型名称来实现的。例如:函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段。在Python中,函数定义使用def关键字,后接函数标识符名称和圆括号,其中可以包括一些参数,然后是一个冒号。上面的例子定义了一个简单的函数greet,它接受一个参数name,并返回一个字符串。函数通过return语句返回结果,如果函数中没有return语句,或者return后面没有跟任何表达式,则函数返回None。

weixin_34456923的博客 1040

《Learning Python(第五版)》全面深入Python编程学习指南

在本章中,我们将介绍Python的基本语法,并通过实例来加深对这些基础概念的理解。Python是一种高级编程语言,以其简洁明了的语法和强大的功能而受到广泛的欢迎。我们将从Python的数据类型开始,然后逐步深入到变量的使用、控制结构以及简单的输入输出操作。在Python中,属性和方法是类的两个主要组成部分。属性通常是存储在类实例中的变量,而方法是定义行为的函数。

weixin_35995661的博客 1114

Python Q-learning 算法详解与应用案例

本文详细介绍了 Q-learning 的基本原理,提供了 Python 中的面向对象实现,并通过简单环境和迷宫游戏的案例展示了其应用。Q-learning 是一种强大的强化学习工具,在多种领域有广泛的应用潜力。希望本文能为读者理解和应用 Q-learning 提供帮助。

闲人编程的博客 3179

一个完整的 Double Q-Learning示例(python实现)

外层循环:控制训练的总回合数(episodes)内层循环:控制每个回合内的交互步数(steps)智能体 - 环境交互:执行动作 → 接收反馈 → 更新策略数据预处理多轮实验取平均以减少随机性移动平均平滑曲线,突出趋势视觉编码颜色区分不同算法区间填充表示不确定性可读性优化清晰的标题和轴标签适当的网格线和图例此代码通过科学的可视化设计,为强化学习算法对比提供了直观的分析工具,有助于快速识别算法性能差异和稳定性特征。数据预处理确保 Q 表数值范围合理,避免极端值影响整体可视化效果。

搏博的专栏 1599

从新手到高手:learning-python-2896241项目的类与对象编程详解

learning-python-2896241项目是LinkedIn Learning Python课程的实践仓库,专为Python初学者设计。本文将通过项目中的实例代码,带你掌握类与对象编程的核心概念,从基础语法到继承应用,轻松跨越面向对象编程的门槛。 ## 面向对象编程:Python世界的基石 🧱 在Python中,一切皆为对象。类(Class)是创建对象的蓝图,而对象则是类的实例。项目

gitblog_00965的博客 647

掌握Python编程:《Learning Python, 5th Edition》深度解析

Python因其简洁明了的语法和强大的功能而成为IT领域中最受欢迎的编程语言之一。本章节旨在为您提供对Python基础语法的全面介绍,帮助您从零开始理解并掌握Python语言的核心概念。在Python中,函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。函数可以通过参数传递不同的值,实现不同的功能。在Python中,定义函数使用def关键字,一般格式如下:def 函数名(参数列表):函数体。

weixin_36431814的博客 1161

(遇到问题)(已解决)word敲入的公式转化为mathtype

https://www.mathtype.cn/wenti/wordgongshi-zhuanhuan.html 现在越来越多的人在文档中编辑公式的时候会选择MathType来编辑,因为它包含有众多的数学符号和模板,编辑公式时非常方便。但是也有一些人在编辑公式时没有使用MathType公式编辑器,直接使用Word中自带的公式编辑器来编辑的。当我们需要要共享一份文件的时候,这种用自带公式编辑器编辑出来的文件,在我们安装有MathType公式编辑器的电脑里打开时,双击公式没有反应,是无法对它们进行修改的.

计算机视觉 1万+

Homemade Machine Learning 类设计:面向对象编程实践

想要深入理解机器学习算法?Homemade Machine Learning项目通过面向对象的设计模式,为你提供了一个完美的学习范例。这个项目用Python实现了多种流行的机器学习算法,每个算法都被封装成独立的类,采用清晰的模块化架构。 ## 🎯 项目架构概览 Homemade Machine Learning采用模块化的类设计,将每个机器学习算法封装成独立的Python类。整个项目的核心架

gitblog_00953的博客 991

【清风数学建模笔记】第十一讲:时间序列分析

【清风数学建模笔记】第十一讲:时间序列分析

manerzi的博客 835

从0到1:借助Awesome-Learning-Resources掌握Python编程

Awesome-Learning-Resources是一个被誉为"Technology Gold mine"的开源项目,它汇集了丰富的技术学习资料和资源。本指南将带你探索如何利用该项目提供的Python学习资源,从零基础开始系统掌握Python编程技能,让你快速入门并逐步提升。 ## 为什么选择Awesome-Learning-Resources学习Python? 在众多的学习资源中,Awes

gitblog_00401的博客 447

数据预处理之数据平滑处理#matlab

介绍基于 MATLAB 的数据平滑方法,主要介绍 smooth 函数、smoothts 函数和 medfilt1 函数的用法。

m0_56619132的博客 2417

告别Vysor!用Scrcpy在Mac上无线投屏安卓手机(附魅族16th闪退修复实战)

本文详细介绍了如何在Mac上配置和使用开源投屏工具Scrcpy,实现安卓手机无线投屏的高效解决方案。从基础环境准备到高级功能调优,包括无线连接配置、输入控制增强、多设备管理和性能优化等实用技巧,特别针对魅族16th等机型的闪退问题提供了修复方案,帮助用户彻底告别Vysor等商业软件。

weixin_28712661的博客 396

英文版的learning python第五版_豆瓣评分9.1!这本Python书的每个版本我都读了

程序员书库(ID:OpenSourceTop)编译链接:https://annvix.com/blog/review-of-oreillys-learning-python-5th-edition七年前,我还是一名大学生,我的大学不教我高级编程,都是一些编程基础(QBASIC,Visual Basic,Java,Cobol,C,C ++等)我当时喜欢C/C++,但是在学习它的时候难免会遇到障碍,所...

weixin_39901518的博客 717

UE5摄像机抖动全攻略:从Perlin噪点到Sequence实战(附参数调优技巧)

本文深入解析UE5摄像机抖动技术,从Perlin噪点算法到CameraShakeBase蓝图应用,再到Sequence高级控制,提供全面的参数调优技巧。涵盖战斗、爆炸等场景的预设参数,帮助开发者实现专业级抖动效果,提升游戏沉浸感。

weixin_30300225的博客 98

mujoco_learning Python教程:快速实现仿真与数据采集

想要快速掌握MuJoCo物理仿真引擎的Python开发吗?mujoco_learning项目为您提供了完整的Python教程,帮助您从零开始学习如何使用MuJoCo进行机器人仿真、数据采集和可视化。本教程面向Python开发者,特别是机器人和强化学习领域的研究人员,通过实际代码示例讲解如何快速搭建仿真环境、获取传感器数据和控制机器人模型。 ## 🚀 为什么选择mujoco_learning进行

gitblog_01191的博客 724

LIN 协议测试

如下图,使用PicoScope示波器抓取报文Id为0x18的波形,数据场Byte1的长度为519.994μs,Byte1共10bit,计算位时间:tBit= 519.994/10 = 51.9994μs,符合预期。■ 唤醒信号是一个250μs到5ms的显性电平,发送唤醒信号的节点发送唤醒信号后150ms~250ms没有收到其他节点的唤醒信号,发送唤醒信号的节点发送新的唤醒信号。对于LIN主节点,检查发送的帧头长度是否符合设计要求,对于LIN从节点,检查从节点能否正确响应设计范围之内的帧头长度。

m0_63902994的博客 5938

audio语音相关的基础知识-VAD,ASR,AEC,AGC,BF等

有音素之间的间隙,也有静音和语音本身的间隙,为了对数据从时间上进行相对的校准,语音端点检测技术就应运而生了,因此端点检测技术可以决定这种校准的相对精度,使得同一内容的特征更趋于相同,当然,一般情况下是不可能完全相同的。盲源分离的目的是求得源信号的最佳估计,盲辨识的目的是求得传输通道的。这个技术的主要任务是从带有噪声的语音中准确的定位出语音的开始和结束点,因为语音中含有很长的静音,也就是把静音和实际语音分离开来,因为是语音数据的原始处理,所以VAD是语音信号处理过程的关键技术之一。呈现出与会者清晰的声音。

u013250861的博客 1035

《一个 Q-learning 算法的简明教程》之Python代码

本文是对A Painless Q-learning Tutorial (一个 Q-learning 算法的简明教程)中的强化学习教程做的Python代码实现 代码框架参考【莫烦Python】强化学习 Reinforcement Learning 场景简述 一栋房子,共5个房间(最外层也看做一个房间5),目标是快速地从某个房间走出(即走到房间5) 抽象为有向图,并关联奖赏(只有通向房间5的转移有奖赏100,其他情况都为0)。 代码实现 # -*- coding: utf-8 -*- """ Creat.

FengKuangXiaoZuo的博客 953

王者荣耀AI绝悟如何选英雄?

王者荣耀AI绝悟如何选英雄? 【抢射手?抢中单位?「绝悟」在打王者荣耀时是如何选英雄的?】 腾讯 AI Lab 开发的 AI 智能体「绝悟」已让王者峡谷不再只是人类召唤师的竞技场,而且这个 AI 战队在上月底进化成了「完全体」。在一局完整的比赛中,英雄选择阶段是至关重要的(比如五射手或五法师阵容会有官方劝退)。 近日,腾讯 AI Lab 和上海交通大学发布的一篇论文介绍了绝悟的英雄选择策略:Ju...

不断学习,不断进步,提高自己 1万+

强化学习 Q-learning及python例子

文章目录Q-learning原理python例子 本文是作者在学习莫烦的强化学习课程中的笔记,强烈推荐莫烦强化学习。 Q-learning原理 我们以一个走迷宫的小游戏为例:让探索者学会走迷宫. 黄色的是天堂 (reward 1), 黑色的地狱 (reward -1). 大多数 RL 是由 reward 导向的, 所以定义 reward 是 RL 中比较重要的一点. Q-learning原理实际...

freedong的博客 7183

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

Python Learning-目录

一、Python Learning-Python环境安装 二、Python Learning-变量和简单数据类型 三、Python Learning-列表 四、Python Learning-列表的更多操作 五、Python Learning-条件控制语句 六、Python Learning-字典 七、Python Learning-while循环 八、Python Lear...

东南有大树的博客 692

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

上一篇: Python Learnning (七)-函数
下一篇: Python Learning(九)-异常和IO
zax_java
博客等级 码龄8年 62粉丝 23原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值