这次给大家分享下自己对于python中对象和引用的认识
[深圳]冒泡(691515082) 20:08:00
首先我们来看两者的概念
[深圳]冒泡(691515082) 20:08:21
我查了下百科：
所谓数据封装就是将一组数据与这组数据有关操作组装在一起，形成一个实体，这个实体就是对象[深圳]冒泡(691515082) 20:08:35
对象这个东东，英文是object
[深圳]冒泡(691515082) 20:08:47
上述是C++中对于对象的一般定义
[深圳]冒泡(691515082) 20:08:58
香港貌似是翻译为“物件”
[深圳]冒泡(691515082) 20:09:11
这里的关键词是“实体”，即对象是实在存在的
RGR(383523756) 20:09:13
台湾？
[深圳]冒泡(691515082) 20:09:31
台湾不了解，大概是香港吧
RGR(383523756) 20:09:52
[深圳]冒泡(691515082) 20:09:58
即，一个对象指的是内存中一块逻辑整体的数据
[深圳]冒泡(691515082) 20:10:16
而引用则类似于handle的概念
[深圳]冒泡(691515082) 20:10:35
可以将引用理解为对象的名字
[深圳]冒泡(691515082) 20:10:41
……………………………………………………
[深圳]冒泡(691515082) 20:10:45
分割线
[深圳]冒泡(691515082) 20:11:06
大家应该听过这么一句话，python中一切都是对象
[深圳]冒泡(691515082) 20:11:32
这句话在我看来是说，python将一切可以对象化的东西都尽量对象化了
[深圳]冒泡(691515082) 20:11:58
例如，整数在python中是一个整数对象，而并非C或java的int这种
[深圳]冒泡(691515082) 20:12:25
python中的int就像是java中的Integer，是一个整数类
[深圳]冒泡(691515082) 20:12:48
1,2,3,4等等整数都是对象，不仅仅存放值，而且拥有自己对应的方法（函数）
[深圳]冒泡(691515082) 20:12:57
看一个简单的语句：
a = 1
这里面，1是对象，a是引用
[深圳]冒泡(691515082) 20:13:43
我们日常说的“a这个对象”确切说应该是“a引用的对象”
[深圳]冒泡(691515082) 20:14:10
一个引用任何时候只能引用一个对象
[深圳]冒泡(691515082) 20:14:24
而一个对象则可以被多个引用所关联
[深圳]冒泡(691515082) 20:14:46
在python中，有两个判断等同的运算符，==和is
[深圳]冒泡(691515082) 20:15:06
其中is是判断是否一个对象，==是判断值是否相等
[深圳]冒泡(691515082) 20:15:11
看个例子
这个例子我们看到，我们将对象10000关联到a和b，两者值是相等的，但是引用是不等的，这就说明，在内存中存在两个10000的对象
[深圳]冒泡(691515082) 20:16:28
a和b分别引用一个
[深圳]冒泡(691515082) 20:17:12
通过内建函数id，可以看到一个对象（或引用关联的对象）的序号（实际就是内存地址）
[深圳]冒泡(691515082) 20:18:00
可以看到，a和b的确引用了不同的对象，且执行id(10000)的时候，python又建立了一个新的10000对象
[深圳]冒泡(691515082) 20:18:47
在这个例子中，先给a关联一个10000对象，然后将a关联的对象再关联给b
[深圳]冒泡(691515082) 20:18:58
因此a和b都引用了同一个对象
No.one(119873357) 20:19:09
本来我以自为很明白。。。给你这么一说，我糊涂了。。
[深圳]冒泡(691515082) 20:19:28
稍等
[深圳]冒泡(691515082) 20:19:31
我画图
[深圳]冒泡(691515082) 20:19:49
先看上面第一个例子
[深圳]冒泡(691515082) 20:20:25
是酱紫的
[深圳]冒泡(691515082) 20:20:29
第二个例子：
[深圳]冒泡(691515082) 20:20:49
酱紫
[深圳]冒泡(691515082) 20:20:53
[深圳]冒泡(691515082) 20:21:15
如果是C比较好的同学，可以将a和b看做指针，10000看做是一块内存[深圳]冒泡(691515082) 20:22:02
第一个是
a = new int(10000)
b = new int(10000)
第二个例子是
a = new int（10000）
b = a
[深圳]冒泡(691515082) 20:22:09
好了，有啥问题先
[深圳]冒泡(691515082) 20:22:36
活在当下刚才给我私下提了个问题
xq(73543) 20:22:39
@[深圳]冒泡讲得很清楚，我是理解了，其他人有不理解的没有
[深圳]冒泡(691515082) 20:22:44
为什么a=1,b=1时a is b是ture，a=10000,b==10000时却是false ? [深圳]冒泡(691515082) 20:22:51
这个问题我稍后回答
[深圳]冒泡(691515082) 20:22:55
先看看其他人有没有问题
活在当下(374927831) 20:23:07
好的
ubuntu(541253467) 20:23:44
理解了
[深圳]冒泡(691515082) 20:23:47
没啊
[深圳]冒泡(691515082) 20:23:52
那我回答下活在当下
[深圳]冒泡(691515082) 20:23:56
做实验
[深圳]冒泡(691515082) 20:24:25
[深圳]冒泡(691515082) 20:24:35
他实际上是问这个矛盾是怎么来的
[深圳]冒泡(691515082) 20:24:52
我们知道，python中整数是个对象，跟C和java不同
No.one(119873357) 20:25:01
看id(a),id(b)就知道了吧。。
[深圳]冒泡(691515082) 20:25:13
如上面的例子，每次碰到10000，都会创建一个新的整数对象
[深圳]冒泡(691515082) 20:25:34
这里问题就来了，如果每次碰到个整数都这么搞，效率上是划不来的No.one(119873357) 20:25:49
java中整数是基本类型
No.one(119873357) 20:25:57
python中是对象，是吧
[深圳]冒泡(691515082) 20:26:09
因此对于一些“常用整数”，python在启动的时候自动创建好，这样一来以后碰到这种整数的时候，就不用内存申请和释放的开销了
[深圳]冒泡(691515082) 20:26:22
@No.one 是的，就跟java的Integer
[深圳]冒泡(691515082) 20:26:39
至于什么是常用整数，具体范围是这样：-5~255
[深圳]冒泡(691515082) 20:27:08
因此对于这个范围内的整数，python是启动就建立好，永远不销毁的对象[深圳]冒泡(691515082) 20:27:29
而这个范围之外的，如果也预先建立好，内存就消耗厉害了
活在当下(374927831) 20:27:55
哦，原来是这样
[深圳]冒泡(691515082) 20:27:59
这就是python设计上的一个均衡，用一点内存的浪费来提高90%以上的运行时间的效率
No.one(119873357) 20:28:03
3Q
xq(73543) 20:28:11
@[深圳]冒泡这种对象内存消耗大吗？那岂不是python程序很消耗内存？[深圳]冒泡(691515082) 20:28:13
类似的还有字符串
No.one(119873357) 20:28:26
对了，is是is instance意思对吗？
[深圳]冒泡(691515082) 20:28:39
所以的单字符形成的字符串，都是intern的，就是类似小整数池这种
xq(73543) 20:28:47
@[深圳]冒泡特别是在做数值运算的时候，不小心就会消耗很多内存吗？
[深圳]冒泡(691515082) 20:29:09
is和isinstance不同
[深圳]冒泡(691515082) 20:29:20
is是判断两个变量（引用）关联的是否是同一个对象
[深圳]冒泡(691515082) 20:29:30
isinstance是判断一个对象是否是一个类的对象
[深圳]冒泡(691515082) 20:29:44
@xq 小整数池很小
[深圳]冒泡(691515082) 20:30:10
至于大的整数，是在运行过程中实时地建立和销毁的
[深圳]冒泡(691515082) 20:30:25
如果要长期保存大量整数，的确会有内存问题
xq(73543) 20:30:42
@[深圳]冒泡理解
[深圳]冒泡(691515082) 20:30:48
但python认为一般情况不会出现这种极端
[深圳]冒泡(691515082) 20:31:08
所以就懒得优化了，事实上整数对象池是只增不减的
RGR(383523756) 20:31:40
python中对象的分配跟C++相同么？是不是也存在栈，堆之类的东西？
[深圳]冒泡(691515082) 20:31:51
如果你的代码运行到某一时刻，同时存在了上千万的整数的对象，那么之后即便不用了，内存也会居高不下，这点在科学计算方面需要特别注意
[深圳]冒泡(691515082) 20:32:26
从C++的角度来看，python对象分配都是在堆中
[深圳]冒泡(691515082) 20:32:36
ok，继续？
xq(73543) 20:33:01
@[深圳]冒泡继续
[深圳]冒泡(691515082) 20:33:10
刚才通过两个例子讲了引用和对象的区别和联系
[深圳]冒泡(691515082) 20:33:43
其中活在当下比较细心，指出了一个和python实现相关的问题，其实这个问题在其他类型的对象也存在
[深圳]冒泡(691515082) 20:33:58
例如None，True，False三个对象是全局唯一的
[深圳]冒泡(691515082) 20:34:19
接下来讲讲容器里的对象
[深圳]冒泡(691515082) 20:34:45
先看这个数据结构，大家认为它可能的布局是什么样：
((1,2,3),(4,5,6))
[深圳]冒泡(691515082) 20:35:06
这是一个元祖，它的两个元素都是元组
[深圳]冒泡(691515082) 20:35:26
而每个元素的元组又各包含三个整数对象
[深圳]冒泡(691515082) 20:35:55
这里需要强调的是，python中的容器（即可以包含其他对象的对象）中存放的“对象”实际上都是引用
[深圳]冒泡(691515082) 20:36:10
画图说明
[深圳]冒泡(691515082) 20:37:18
[深圳]冒泡(691515082) 20:37:25
上面那个结构，布局应该是这样的
[深圳]冒泡(691515082) 20:38:14
即，这是一个包含两个引用的元祖，因此除去python内部的一些信息外，其只有8个字节大小（32位系统）
[深圳]冒泡(691515082) 20:38:31
而这个引用则分别引用到另外两个元祖对象
[深圳]冒泡(691515082) 20:39:10
另外两个元祖对象分别有三个引用，即分别占用12字节，共6个引用最后才分别引用在1,2,3,4,5,6六个整数对象身上
[深圳]冒泡(691515082) 20:39:45
元组之外的其他类似数据类型，如list，dict，set。。。。
[深圳]冒泡(691515082) 20:39:48
都是如此
No.one(119873357) 20:39:59
能否这样说：python中一切都是对象，对象之间的一切操作都是引用？
[深圳]冒泡(691515082) 20:40:09
@No.one 对的
No.one(119873357) 20:40:21
ok,3q
[深圳]冒泡(691515082) 20:40:22
前几天有人问了我一个问题
[深圳]冒泡(691515082) 20:40:39
如果一个list的元素都是元组，排序起来是不是会更慢
[深圳]冒泡(691515082) 20:41:18
他觉得排序要涉及到元素的交换，而元组交换比整数交换要操作更多内存
[深圳]冒泡(691515082) 20:41:30
那么这里大家就可以看到，实际上只是交换引用而已
[深圳]冒泡(691515082) 20:41:34
例如：
[深圳]冒泡(691515082) 20:42:28
[深圳]冒泡(691515082) 20:43:04
从这个例子可以看出，仅仅是l[0]和l[1]的引用交换了，对于1和2两个对象其实没有任何改变
[深圳]冒泡(691515082) 20:43:21
有问题没？
No.one(119873357) 20:43:50
明白。
xq(73543) 20:43:59
@[深圳]冒泡明白
No.one(119873357) 20:44:04
No.one(119873357) 20:44:11
这是为啥，第一个a is b 是true,第二个a is b是否false
[深圳]冒泡(691515082) 20:44:39
@No.one 我上面讲了的
[深圳]冒泡(691515082) 20:44:45
可以去翻聊天记录
[深圳]冒泡(691515082) 20:45:10
接下来讲下引用和对象的变化
No.one(119873357) 20:45:26
你上面讲的a is b是否false啊。。
No.one(119873357) 20:45:31
北京-IP(412532671) 20:46:36
@冒泡 id(a) 返回的是？？
[深圳]冒泡(691515082) 20:46:36
@No.one 私你了
[深圳]冒泡(691515082) 20:46:55
id返回的是一个对象在内存中的地址
No.one(119873357) 20:46:55
嗯，多谢。。
[深圳]冒泡(691515082) 20:47:10
每个对象id(地址)是唯一的，且不会冲突
北京-IP(412532671) 20:47:18
内存值不是[xxxxx]吗这个怎么是长数字
[深圳]冒泡(691515082) 20:47:33
内存地址不就是数字么。。。
[深圳]冒泡(691515082) 20:47:45
0xXXX那种是16进制表示而已
北京-IP(412532671) 20:47:47
哦
北京-IP(412532671) 20:47:49
明白
[深圳]冒泡(691515082) 20:48:00
接下来讲对象的可变和不可变
[深圳]冒泡(691515082) 20:48:08
python的对象分两种
[深圳]冒泡(691515082) 20:48:13
可变对象和不可变对象
[深圳]冒泡(691515082) 20:48:29
顾名思义，可变对象就是一个对象的内容是可变的[深圳]冒泡(691515082) 20:48:41
而不可变对象的内容是不能被变化的
[深圳]冒泡(691515082) 20:49:15
例如，整数是不可变对象
[深圳]冒泡(691515082) 20:49:25
一个整数对象，你不可以改变它的值
[深圳]冒泡(691515082) 20:49:44
之前有人说：
a = 1
a = 2
这不是改变对象a的值了么
[深圳]冒泡(691515082) 20:50:09
上面讲了后就应该明白了，这样做只是将a关联到2而已，1本身没有任何改变北京-IP(412532671) 20:50:24
改变和不可变是两个概念
[深圳]冒泡(691515082) 20:50:29
[深圳]冒泡(691515082) 20:51:38
这个例子中，就改变了l
[深圳]冒泡(691515082) 20:51:45
但是没有改变1和2
[深圳]冒泡(691515082) 20:52:04
通过下标赋值，就改变了l这个对象的内容
RGR(383523756) 20:52:12
建议l改成L或lst
[深圳]冒泡(691515082) 20:52:18
ok
[深圳]冒泡(691515082) 20:52:48
但是在这个过程中，L引用的还是之前的对象
[深圳]冒泡(691515082) 20:52:58
即L的id没有改变，其内容改变了
[深圳]冒泡(691515082) 20:53:18
L.append(xxx)这样也会改变L的内容
[深圳]冒泡(691515082) 20:53:22
但是L不会变
[深圳]冒泡(691515082) 20:53:38
有人问
a+=1是不是改变了对象内容
[深圳]冒泡(691515082) 20:53:55
对+=操作做实验
[深圳]冒泡(691515082) 20:54:15
[深圳]冒泡(691515082) 20:54:41
可以看到，整数运算的时候，a+=1就相当于a=a+1
[深圳]冒泡(691515082) 20:54:47
然后实验下list
[深圳]冒泡(691515082) 20:55:23
[深圳]冒泡(691515082) 20:55:37
[深圳]冒泡(691515082) 20:56:00
可以看到，list和int有区别
[深圳]冒泡(691515082) 20:56:26
list在做+=的时候，是直接在当前列表后面追加需要追加的列表的内容[深圳]冒泡(691515082) 20:56:36
是改变了对象
[深圳]冒泡(691515082) 20:56:54
而在做L=L+[3]的时候，则是先计算右边的加法，生成了一个新的list [深圳]冒泡(691515082) 20:57:07
然后将新list用L引用
[深圳]冒泡(691515082) 20:57:11
这样id就改变了
[深圳]冒泡(691515082) 20:57:41
单纯从效率上讲，+=要快，因为没有创建新的list对象
[深圳]冒泡(691515082) 20:57:47
有问题没
No.one(119873357) 20:58:01
python也真是个奇葩啊
蠢菜鸟(814756809) 20:58:03
extend不是更快吗？
不太懂
[深圳]冒泡(691515082) 20:58:14
extend和+=是一样的
[深圳]冒泡(691515082) 20:58:31
[深圳]冒泡(691515082) 20:58:53
+=右边不一定要list，只要是一个可迭代的对象就行了，例如tuple 蠢菜鸟(814756809) 20:58:55
反正我知道直接加是最慢的。。。
北京-IP(412532671) 20:58:56
+的位置左右都行
[深圳]冒泡(691515082) 20:59:05
事实上extend比+=慢
xq(73543) 20:59:25
@[深圳]冒泡 python为何不把L=L+[3]优化成L+=[3]呢？
北京-IP(412532671) 20:59:24
extend是什么
RGR(383523756) 21:00:00
extend是一个一个加进来，+=是一次加进来？
[深圳]冒泡(691515082) 21:00:05
这是+=
[深圳]冒泡(691515082) 21:00:08
我看过一篇文章建议用extend
北京-IP(412532671) 21:00:23
+= 和 + 一样的
[深圳]冒泡(691515082) 21:00:25
[深圳]冒泡(691515082) 21:00:31
这是extend
你这是哪儿的资料啊
[深圳]冒泡(691515082) 21:00:59
@xq python认为+=和先加再赋值，是不同的意义
No.one(119873357) 21:01:32
本来以为会python简单，听了你一课，发现不会python了。。
[深圳]冒泡(691515082) 21:01:33
+=只是个运算操作，而extend则涉及到了查找函数和调用函数
No.one(119873357) 21:01:42
[深圳]冒泡(691515082) 21:01:50
因此extend做了更多的事情
xq(73543) 21:02:02
@[深圳]冒泡有点学究气氛的实现，不过也可以理解，其他语言中也有类似的情况出现，严格的按照定义来实现语言
[深圳]冒泡(691515082) 21:02:06
明白否？
RGR(383523756) 21:02:18
明白
xq(73543) 21:02:23
@[深圳]冒泡明白了
蠢菜鸟(814756809) 21:02:32
额，我半路进来的
[深圳]冒泡(691515082) 21:02:36
@北京-IP 上面这两张图是python代码的机器码
[深圳]冒泡(691515082) 21:02:56
用dis模块中的接口可以对自己写的东东查看
蠢菜鸟(814756809) 21:02:59
到底用哪个好些，在两个列表相加的时候
[深圳]冒泡(691515082) 21:03:10
其实你不考虑效率，都可以
蠢菜鸟(814756809) 21:03:17
我一直用 extend
[深圳]冒泡(691515082) 21:03:19
extend可能更直观好懂些
[深圳]冒泡(691515082) 21:03:30
当然，这点效率提高可能也不算啥
蠢菜鸟(814756809) 21:03:37
当然考虑效率
[深圳]冒泡(691515082) 21:03:40
所以不纠结了
蠢菜鸟(814756809) 21:03:54
+= 和 extend 不一样吧
[深圳]冒泡(691515082) 21:04:12
额，如果你发现了不一样的地方，欢迎分享
[深圳]冒泡(691515082) 21:04:14
我是认为一样的
[深圳]冒泡(691515082) 21:04:20
好，继续
蠢菜鸟(814756809) 21:04:32
我不知道，研究下再给答案
[深圳]冒泡(691515082) 21:04:35
接下来讲下不可变对象
[深圳]冒泡(691515082) 21:04:50
这类对象其实就几个，内置的
[深圳]冒泡(691515082) 21:05:04
int
float
str
tuple
complex
.......
蠢菜鸟(814756809) 21:05:08
语音可以吗。。
蠢菜鸟(814756809) 21:05:20
多人语音
[深圳]冒泡(691515082) 21:05:23
如果你想“改变”这几类对象的内容，只有新建一个对象[深圳]冒泡(691515082) 21:05:29
语音我这边调不通
北京-IP(412532671) 21:05:29
tuple 是？
蠢菜鸟(814756809) 21:05:34
（）
[深圳]冒泡(691515082) 21:05:37
tuple就是元组
[深圳]冒泡(691515082) 21:05:48
实验：
[深圳]冒泡(691515082) 21:06:25
[深圳]冒泡(691515082) 21:06:40
可以看到，对t进行+=操作，是重新建立了一个tuple对象
而之前引用的(1,2,3)这个对象是没有被改变的
[深圳]冒泡(691515082) 21:07:19
因此，如果你代码里用tuple来做那种需要经常改变内容的数组，会造成很大的效率问题
[深圳]冒泡(691515082) 21:07:42
[深圳]冒泡(691515082) 21:07:55
同样的，也不能像上面这样对tuple里面的值进行改变
[深圳]冒泡(691515082) 21:08:30
再补充下，不可变类型还有None和bool型的（True和False）
[深圳]冒泡(691515082) 21:08:45
字符串str也是不可变类型
[深圳]冒泡(691515082) 21:08:49
这点也需要注意
No.one(119873357) 21:08:51
能推荐本之方便有介绍的书吗
[深圳]冒泡(691515082) 21:09:08
不能像在C里面直接改字符串内容
[深圳]冒泡(691515082) 21:09:13
只能重新建立字符串
[深圳]冒泡(691515082) 21:09:56
关于不可变对象有一点很重要，就是dict的key（或set的元素）必须是不可变对象
[深圳]冒泡(691515082) 21:09:59
实验：
[深圳]冒泡(691515082) 21:10:15
[深圳]冒泡(691515082) 21:10:24
list因为是可变对象，就不能作为字典的key
[深圳]冒泡(691515082) 21:10:52
因为假设可以这么搞，L是一个list，则：
d = {L : 1}
L.append(123)
[深圳]冒泡(691515082) 21:10:57
这样字典就全乱套了
[深圳]冒泡(691515082) 21:11:35
而dict的value则没有这个限制，因为其不需要参与字典相关操作的计算
字符串、tuple都可以作为字典的key
[深圳]冒泡(691515082) 21:12:17
如果你自己定义了一个class，用其对象来做dict的key的话，一定要注意这一点
[深圳]冒泡(691515082) 21:12:35
不要让这个对象的内容可以被外界改变（用私有变量等方式）
[深圳]冒泡(691515082) 21:13:00
有问题没？
北京-IP(412532671) 21:13:04
太术语了
蠢菜鸟(814756809) 21:13:17
讲的很不错
蠢菜鸟(814756809) 21:13:29
技术就应该用术语
[深圳]冒泡(691515082) 21:13:31
ok，继续
[深圳]冒泡(691515082) 21:13:42
接下来讲一个我碰到很多人来问的问题
[深圳]冒泡(691515082) 21:14:07
[深圳]冒泡(691515082) 21:14:29
很多人认为，[[]]*10是创建了一个拥有10个空列表的列表
[深圳]冒泡(691515082) 21:15:07
而事实上这个表达式的执行是将[[]]中第一个元素（空列表）的引用重复了10个
[深圳]冒泡(691515082) 21:15:19
因此改变L[0]，大家都变了
[深圳]冒泡(691515082) 21:16:03
python中对对象的传递、赋值等都是引用的传递赋值
[深圳]冒泡(691515082) 21:16:24
除非用copy库中的接口，可以强制指定复制
北京-IP(412532671) 21:16:24
这位啥时3呢
北京-IP(412532671) 21:17:06
打错了
@北京-IP 你打错了吧
S.U.(50136908) 21:17:17
你打错了
北京-IP(412532671) 21:17:20
嗯
S.U.(50136908) 21:17:20
len(dis)
北京-IP(412532671) 21:17:27
sorry
[深圳]冒泡(691515082) 21:17:49
上面这个乘法，可以展开成下面的等价代码：
L = []
t = []
for i in xrange(10):
L.append(t)
[深圳]冒泡(691515082) 21:18:17
只是一个对象被append了10次而已，而就像前面说的，list容器中存放的只是引用
[深圳]冒泡(691515082) 21:18:41
如果要实现10个不同的空列表，就得这样：
L = []
for i in xrange(10):
L.append([])
[深圳]冒泡(691515082) 21:18:55
每次append的时候，都会新建空列表，这样10个就都不同了
[深圳]冒泡(691515082) 21:19:17
还可以简写成：[[] for i in xrange(10)]
[深圳]冒泡(691515082) 21:20:00
顺便说一下
[深圳]冒泡(691515082) 21:20:12
list的乘法运算也有上面加法运算一样的情况：
[深圳]冒泡(691515082) 21:20:19
L = L * 10
和
L *= 10
是不同的
[深圳]冒泡(691515082) 21:20:57
后者是原地扩展，并没有改变L的引用
[深圳]冒泡(691515082) 21:21:17
有啥问题没？
[深圳]冒泡(691515082) 21:22:06
接下来再看一个例子
[深圳]冒泡(691515082) 21:22:18
[深圳]冒泡(691515082) 21:22:45
这里有人会问第二次为啥不是输出[2]
[深圳]冒泡(691515082) 21:23:14
原因是L的默认值[]是和f绑定在一起，每次调用f的时候用L来引用
[深圳]冒泡(691515082) 21:23:42
因此每次执行的时候，只是将L引用到这个对象，并非每次都新建一个列表然后引用给L
[深圳]冒泡(691515082) 21:24:13
这个列表是在建立f的时候建立的
北京-IP(412532671) 21:24:13
不太懂呀
[深圳]冒泡(691515082) 21:24:39
啥问题？
北京-IP(412532671) 21:24:54
a和L 啥关系
[深圳]冒泡(691515082) 21:25:04
a和L都是参数
[深圳]冒泡(691515082) 21:25:09
L有默认参数
北京-IP(412532671) 21:25:13
f(1) 付给谁啊
[深圳]冒泡(691515082) 21:25:22
这个可以去看函数的相关基础
[深圳]冒泡(691515082) 21:25:47
这个我这边就不讲了
刚开始说过
[深圳]冒泡(691515082) 21:26:00
python中一切都是对象
[深圳]冒泡(691515082) 21:26:04
因此函数也是对象
xq(73543) 21:26:10
这个问题是函数默认参数分配的问题，在python中有专门讲这个的地方
蠢菜鸟(814756809) 21:26:49
请群主把这次讲课的记录保存下来
[深圳]冒泡(691515082) 21:26:55
def f():
pass
No.one(119873357) 21:27:15
我回头整理一下，发到群共享
[深圳]冒泡(691515082) 21:27:21
这个语句，很多人都认为是定义一个函数
[深圳]冒泡(691515082) 21:27:32
事实上跟C里面的函数还是不太一样的
北京-IP(412532671) 21:27:43
主要是传递过程不理解
[深圳]冒泡(691515082) 21:28:00
python在碰到def的时候，会将下面的“代码对象”关联到函数名的引用
北京-IP(412532671) 21:28:48
python 能不能像shell 调试过程啊
RGR(383523756) 21:28:57
函数对象也是不可变对象吧
[深圳]冒泡(691515082) 21:29:04
即差不多相当于：
f = CODEOBJ("pass")
注意等号右边是伪代码，这里只是表明，函数def和变量赋值，在python中没有本质区别
北京-IP(412532671) 21:29:20
这个我回头看下您继续吧
[深圳]冒泡(691515082) 21:29:43
因此在python中
[深圳]冒泡(691515082) 21:29:50
这个f就是对一个函数对象的引用
[深圳]冒泡(691515082) 21:30:12
跟a=1表示a是对象1的引用一样
[深圳]冒泡(691515082) 21:30:24
因此，可以执行：
g=f
[深圳]冒泡(691515082) 21:30:32
这样可以通过g()来调用
[深圳]冒泡(691515082) 21:30:38
跟f()等价
[深圳]冒泡(691515082) 21:31:14
同样
[深圳]冒泡(691515082) 21:31:29
函数对象也可以像一般对象一样作为参数传递[深圳]冒泡(691515082) 21:31:33
例如：
[深圳]冒泡(691515082) 21:32:08
[深圳]冒泡(691515082) 21:32:57
@RGR 函数对象是否可变，我其实也没概念[深圳]冒泡(691515082) 21:33:14
可以试试看，不过一般也没必要去变吧
RGR(383523756) 21:33:28
嗯，你继续
北京-IP(412532671) 21:33:36
就是函数可以调用函数
[深圳]冒泡(691515082) 21:33:44
接下来讲个比较绕的概念
[深圳]冒泡(691515082) 21:33:49
由于python中一切都是对象
[深圳]冒泡(691515082) 21:33:53
类也是对象
[深圳]冒泡(691515082) 21:34:04
class A:
pass
[深圳]冒泡(691515082) 21:34:16
A既是个类，也是个对象
[深圳]冒泡(691515082) 21:34:40
其实这个class语句也相当于：
A=CLASSOBJ("pass")
[深圳]冒泡(691515082) 21:34:49
跟一般的赋值语句没有任何区别
9oclock(283058545) 21:35:19
类和对象不是本来就是同一个东西么?
[深圳]冒泡(691515082) 21:35:24
1.Pso算法 function [xm,fv] = SAPSO( fitness,N,c1,c2,wmax,wmin,M ) % fitness 适应度函数 % N 种群个数 % c1 % c2 % wmax 最大权重 % wmin 最小权重 % M 迭代次数 cg=32;%传感器个数 format long; %-----------------------初始化种群个体 ------------------------------------- for i=1:N %粒子个数为n a1=-17.5:10:12.5; a11=a1*(i+5)/10; [a2,a3]=meshgrid(a1,a11); a4=reshape(a2,1,16); a5=reshape(a3,1,16); b1=-12.5:10:17.5; b11=b1*(i+5)/10; [b2,b3]=meshgrid(b1,b11); b4=reshape(b2,1,16); b5=reshape(b3,1,16); x11=[a4,b4;a5,b5]+20;%ó|ó?μè±èàyà?é￠y1ì?¨ x(:,:,i)=x11';%初始化传感器个数为20 v(:,:,i)=10*rand(cg,2); end %----------------------计算各个粒子适应度------------------------------for i=1:N; p(i)=fitness(x(:,:,i)); y(:,:,i)=x(:,:,i); end pg=x(:,:,N); %pg为全局最优 for i=1:(N-1) if fitness(x(:,:,i)) 面向对象及练习题 1.面向对象 1.1面向对象概念 面向对象是一种编程思想，是对现实世界中的事物进行抽象的方式。应用到代码编程设计中，是一种建立现实世界事物模型的方式。 1.2 面向对象和面向过程区别 面向过程关注的是完成工作的步骤，面向对象关注的是谁能完成工作。 面向对象是在完成工作的时候关注哪些个体能够完成对应的工作，找到对应的个体即可完成对应任务。 2.类 2.1类的概念 类是一系列事物的统称，同类事物必定具有相同的特征。日常事物的特征根据特性分为状态和行为，对应到类中是变量和方法。 特征分类： 状态→变量（成员变量） 行为→方法（成员方法） 统称：类的成员 2.2类定义语法格式 class类名： pass 说明：pass是空语句，不具有任何意义，仅为了保持程序结构完整性 2.3类名的命名规则 类名命名规范：满足大驼峰命名规则 3.对象 3.1对象的概念 对象是类的具体表现形式，是实际存在的个体。（类是一系列事物的统称） 3.2创建对象语法格式 对象名 = 类名() 3.3 注意事项 对象的创建不限制数量，一个类可以创建任意个数的对象 4.成员变量 4.1成员变量的概念 成员变量用于描述对象的固有状态或属性。 4.2定义成员变量语法格式（公有属性/公有变量） class 类名： def __init__(self): self.变量名1 = 值1 self.变量名2 = None 4.3成员变量定义语法格式（独有属性/独有变量） 对象名.变量名 = 值 4.4公有变量与独有变量的区别 ●公有变量在__init__方法中声明，每个对象都具有该变量 ●独有变量在创建对象后声明，只有当前对象具有此变量 ●定义对象的独有变量时，如果独有变量名与公有变量名相同，视为 修改公有变量的值；如果独有变量名与公有变量名不相同，视为定 义新的独有属性 ●None含义是为空，表示没有具体的数据 基本粒子群算法的原理和matlab程序 作者——niewei120（nuaa） 一、粒子群算法的基本原理 粒子群优化算法源自对鸟群捕食行为的研究，最初由Kennedy和Eberhart提出，是一种通用的启发式搜索技术。一群鸟在区域中随机搜索食物，所有鸟知道自己当前位置离食物多远，那么搜索的最简单有效的策略就是搜寻目前离食物最近的鸟的周围区域。PSO 算法利用这种模型得到启示并应用于解决优化问题。PSO 算法中，每个优化问题的解都是粒子在搜索 空间中的位置，所有的粒子都有一个被优化的目标函数所决定的适应值，粒子还有一个速度值决定它们飞翔的方向和距离，然后粒子群就追随当前的最优粒子在解空间中搜索。 PSO 算法首先在给定的解空间中随机初始化粒子群，待优化问题的变量数决定了解空间的维数。每个粒子有了初始位置与初始速度。然后通过迭代寻优。在每一次迭代中，每个粒子通过跟踪两个“极值”来更新自己在解空间中的空间位置与飞翔速度。第一个极值就是单个粒子本身在迭代过程中找到的最优解粒子，这个粒子叫做个体极值。另一个极值是种群所有粒子在迭代过程中所找到的最优解粒子，这个粒子是全局极值。上述的方法叫全局粒子群算法。如果不用种群所有粒子而只用其中一部分作为该粒子的邻居粒子，那么在所有邻居粒子中的极值就是局部极值，该方法称为局部PSO 算法。 速度、位置的更新方程表示为： 每个粒子自身搜索到的历史最优值p i ，p i=(p i1,p i2,....,p iQ)，i=1,2,3,....,n。所有粒子搜索到的最优值p g，p g=(p g1,p g2,....,p gQ)，注意这里的p g只有一个。 是保持原来速度的系数，所以叫做惯性权重。 是粒子跟踪自己历史最优值的权重系数，它表示粒子自身的认识，所以叫“认知”。通常设置为2。 是粒子跟踪群体最优值的权重系数，它表示粒子对整个群体知识的认识，所以叫做“社会知识”，经常叫做“社会”。通常设置为2。 是[0,1]区间内均匀分布的随机数。 是对位置更新的时候，在速度前面加的一个系数，这个系数我们叫做约束因子。通常设 置为1 。 主函数源程序（main.m） %------基本粒子群优化算法（Particle Swarm Optimization）-----------%------名称：基本粒子群优化算法（PSO） %------作用：求解优化问题 %------说明：全局性，并行性，高效的群体智能算法 %------初始格式化--------------------------------------------------clear all; clc; format long; %------给定初始化条件---------------------------------------------- c1=1.4962;%学习因子1 c2=1.4962;%学习因子2 w=0.7298;%惯性权重 MaxDT=1000;%最大迭代次数 D=10;%搜索空间维数（未知数个数） N=40;%初始化群体个体数目 eps=10^(-6);%设置精度(在已知最小值时候用) %------初始化种群的个体(可以在这里限定位置和速度的范围)------------for i=1:N for j=1:D x(i,j)=randn;%随机初始化位置 v(i,j)=randn;%随机初始化速度 end end %------先计算各个粒子的适应度，并初始化Pi和Pg----------------------for i=1:N p(i)=fitness(x(i,:),D); y(i,:)=x(i,:); end pg=x(1,:);%Pg为全局最优 for i=2:N if fitness(x(i,:),D) 基本粒子群算法的原理和matlab 程序 作者—— niewei120 （nuaa） 一、粒子群算法的基本原理 粒子群优化算法源自对鸟群捕食行为的研究，最初由Kennedy 和 Eberhart 提出，是一种通 用的启发式搜索技术。一群鸟在区域中随机搜索食物，所有鸟知道自己当前位置离食物多远， 那么搜索的最简单有效的策略就是搜寻目前离食物最近的鸟的周围区域。PSO 算法利用这种模型得到启示并应用于解决优化问题。PSO 算法中，每个优化问题的解都是粒子在搜索 空间中的位置，所有的粒子都有一个被优化的目标函数所决定的适应值，粒子还有一个速度值决定它们飞翔的方向和距离，然后粒子群就追随当前的最优粒子在解空间中搜索。 PSO 算法首先在给定的解空间中随机初始化粒子群，待优化问题的变量数决定了解空间的维数。每个粒子有了初始位置与初始速度。然后通过迭代寻优。在每一次迭代中，每个粒子通过跟踪两个“极值”来更新自己在解空间中的空间位置与飞翔速度。第一个极值就是单个粒子本身在迭代过程中找到的最优解粒子，这个粒子叫做个体极值。另一个极值是种群所有粒子在迭代过程中所找到的最优解粒子，这个粒子是全局极值。上述的方法叫全局粒子群算法。如果不用种群所有粒子而只用其中一部分作为该粒子的邻居粒子，那么在所有邻居粒子中的极值就是局部极值，该方法称为局部PSO 算法。 速度、位置的更新方程表示为： 每个粒子自身搜索到的历史最优值p i，p i=(p i1 ,p i2 ,....,p iQ )， i=1,2,3,....,n 。所有粒子搜索到的最优值p g， p g=(p g1 ,p g2,....,p gQ )，注意这里的p g只有一个。 是保持原来速度的系数，所以叫做惯性权重。 是粒子跟踪自己历史最优值的权重系数，它表示粒子自身的认识，所以叫“认知”。通常设置为 2 。 是粒子跟踪群体最优值的权重系数，它表示粒子对整个群体知识的认识，所以叫做“社会知识”，经常叫做“社会”。通常设置为2。 是[0,1] 区间内均匀分布的随机数。 是对位置更新的时候，在速度前面加的一个系数，这个系数我们叫做约束因子。通常设 置为 1 。 粒子群优化算法(1)—粒子群优化算法简介 PSO算法就是模拟一群鸟寻找食物的过程，每个鸟就是PSO中的粒子，也就是我们需要求解问题的可能解，这些鸟在寻找食物的过程中，不停改变自己在空中飞行的位置与速度。大家也可以观察一下，鸟群在寻找食物的过程中，开始鸟群比较分散，逐渐这些鸟就会聚成一群，这个群忽高忽低、忽左忽右，直到最后找到食物。这个过程我们转化为一个数学问题。寻找函数y=1-cos(3*x)*exp(-x)的在[0,4]最大值。该函数的图形如下： 当x=0.9350-0.9450，达到最大值y=1.3706。为了得到该函数的最大值，我们在[0, 4]之间随机的洒一些点，为了演示，我们放置两个点，并且计算这两个点的函数值，同时给这两个点设置在[0, 4]之间的一个速度。下面这些点就会按照一定的公式更改自己的位置，到达新位置后，再计算这两个点的值，然后再按照一定的公式更新自己的位置。直到最后在y=1.3706这个点停止自己的更新。这个过程与粒子群算法作为对照如下： 这两个点就是粒子群算法中的粒子。 该函数的最大值就是鸟群中的食物。 计算两个点函数值就是粒子群算法中的适应值，计算用的函数就是粒子群算法中的适应度函数。 更新自己位置的公式就是粒子群算法中的位置速度更新公式。 下面演示一下这个算法运行一次的大概过程： 第一次初始化 第一次更新位置 第二次更新位置 第21次更新 最后的结果（30次迭代） 最后所有的点都集中在最大值的地方。 粒子群优化算法(2)—标准粒子群优化算法 在上一节的叙述中，唯一没有给大家介绍的就是函数的这些随机的点（粒子）是如何运动的，只是说按照一定的公式更新。这个公式就是粒子群算法中的位置速度更新公式。下面就介绍这个公式是什么。在上一节中我们求取函数y=1-cos(3*x)*exp(-x)的在[0, 4]最大值。并在[0,4]之间放置了两个随机的点，这些点的坐标假设为x1=1.5，x2=2.5；这里的点是一个标量，但是我们经常遇到的问题可能是更一般的情况—x 为一个矢量的情况，比如二维z=2*x1+3*x22的情况。这个时候我们的每个粒子均为二维，记粒子P1＝(x11,x12),P2=(x21,x22),P3=(x31,x32)，......Pn=(xn1,xn2)。这里n 为粒子群群体的规模，也就是这个群中粒子的个数，每个粒子的维数为2。更一般的是粒子的维数为q ，这样在这个种群中有n 个粒子，每个粒子为q 维。 由n 个粒子组成的群体对Q 维（就是每个粒子的维数）空间进行搜索。每个粒子表示为：x i ＝（x i1,x i2,x i3,...,x iQ ），每个粒子对应的速度可以表示为v i =(v i1,v i2,v i3,....,v iQ )，每个粒子在搜索时要考虑两个因素： 1. 自己搜索到的历史最优值 p i ，p i =(p i1,p i2,....,p iQ )，i=1,2,3,....,n ； 2. 全部粒子搜索到的最优值p g ，p g =(p g1,p g2,....,p gQ )，注意这里的p g 只有一个。 下面给出粒子群算法的位置速度更新公式： 112()()()()k k k k i i i i v v c rand pbest x c rand gbest x ω+=+??-+??-, 11k k k i i i x x av ++=+. 这里有几个重要的参数需要大家记忆，因为在以后的讲解中将会经常用到，它们是： ω是保持原来速度的系数，所以叫做惯性权重。1c 是粒子跟踪自己历史最优值的权重系数，它表示粒子自身的认识，所以叫“认知”。通常设置为2。2c 是粒子跟踪群体最优值的权重系数，它表示粒子对整个群体知识的认识，所以叫做“社会知识”，经常叫做“社会”。通常设置为2。()rand 是[0,1]区间内均匀分布的随机数。a 是对位置更新的时候，在速度前面加的一个系数，这个系数我们叫做约束因子。通常设置为1。这样一个标准的粒子群算法就介绍结束了。下图是对整个基本的粒子群的过程给一个简单的图形表示。 判断终止条件可是设置适应值到达一定的数值或者循环一定的次数。 注意：这里的粒子是同时跟踪自己的历史最优值与全局（群体）最优值来改变自己的位置预速度的，所以又叫做全局版本的标准粒子群优化算法。 引言 提到面向对象，总是离不开几个重要的术语：多态（Polymorphism），继承（Inheritance）和封装（Encapsulation）。Python也是一种支持OOP的动态语言，本文将简单阐述Python 对面向对象的支持。 在讨论Python的OOP之前，先看几个OOP术语的定义： ?类：对具有相同数据和方法的一组对象的描述或定义。 ?对象：对象是一个类的实例。 ?实例(instance)：一个对象的实例化实现。 ?标识(identity)：每个对象的实例都需要一个可以唯一标识这个实例的标记。 ?实例属性（instance attribute）：一个对象就是一组属性的集合。 ?实例方法(instance method)：所有存取或者更新对象某个实例一条或者多条属性的函数的集合。 ?类属性（classattribute）：属于一个类中所有对象的属性，不会只在某个实例上发生变化 ?类方法（classmethod）：那些无须特定的对性实例就能够工作的从属于类的函数。 1.Python中的类与对象 Python中定义类的方式比较简单： class类名： 类变量 def __init__(self,paramers): def函数(self,...) 其中直接定义在类体中的变量叫类变量，而在类的方法中定义的变量叫实例变量。类的属性包括成员变量和方法，其中方法的定义和普通函数的定义非常类似，但方法必须以self 作为第一个参数。 举例： class MyFirstTestClass: classSpec="itis a test class" def__init__(self,word): print"say "+word defhello(self,name): print"hello "+name 在Python类中定义的方法通常有三种：实例方法，类方法以及静态方法。这三者之间的区别是实例方法一般都以self作为第一个参数，必须和具体的对象实例进行绑定才能访问，而类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod；而静态方法不需要默认的任何参数,跟一般的普通函数类似.定义的时候使用@staticmethod。 class MethodTest(): count= 0 粒子群算法原理及其在函数优化中的应用 1粒子群优化(PSO)算法基本原理 1.1标准粒子群算法 假设在一个D 维的目标搜索空间中，有 m 个代表问题潜在解的粒子组成一 个种群x [X i ,X 2,...,X m ],第i 个粒子的信息可用D 维向量表示为 X i [X ii , X i2,..., X iD ]T ，其速度为V i [V ii ,V i2,...,V iD ]T 。算法首先初始化m 个随机粒 子，然后通过迭代找到最优解。每一次迭代中，粒子通过跟踪2个极值进行信息 交流，一个是第i 个粒子本身找到的最优解，称之为个体极值，即 P i [P il , P i2,...,厢]丁 ；另一个是所有粒子目前找到的最优解，称之为群体极值， 即P g [P gi ,P g2,..., P gD 「。粒子在更新上述2个极值后，根据式(1)和式(2)更新自 己的速度和位置。 t 1 t t t t t\ V i WV i C 1「1（P i X i ） C 2「2（P g X i ） 式中，t 代表当前迭代次数，「1,「2是在[0,1]之间服从均匀分布的随机数，C 1,C 2 称为学习因子，分别调节粒子向个体极值和群体极值方向飞行的步长， w 为惯性 权重，一般在0.1~0.9之间取值。在标准的PSO 算法中，惯性权重w 被设为常数, 通常取w 0.5。在实际应用中，x 需保证在一定的范围内，即x 的每一维的变化 范围均为[X min ,X max ],这在函数优化问题中相当丁自变量的定义域 1.2算法实现步骤 步骤1:表示出PSO 算法中的适应度函数fitness(x)；(编程时最好以函数的 形式保存，便丁多次调用。) 步骤2:初始化PSO 算法中各个参数(如粒子个数，惯性权重，学习因子， 最大迭代次数等)，在自变量x 定义域内随机初始化x ，代入fitness(x)求得适应 度值，通过比较确定起始个体极值P i 和全局极值P g 。 步骤3:通过循环迭代更新x 、p i 和p g : ① 确定惯性权重w 的取值(当w 不是常数时)。 ② 根据式(1)更新粒子的速度V ：1,若速度中的某一维超过了 V max ，则取为 V max - ③ 根据式(2)更新自变量x ,若x 的取值超过其定义域，则在其定义域内重新 初t 1 X i t t 1 X i V i 粒子群算法(1)----粒子群算法简介 一、粒子群算法的历史 粒子群算法源于复杂适应系统（Complex Adaptive System,CAS）。CAS理论于1994年正式提出，CAS中的成员称为主体。比如研究鸟群系统，每个鸟在这个系统中就称为主体。主体有适应性，它能够与环境及其他的主体进行交流，并且根据交流的过程“学习”或“积累经验”改变自身结构与行为。整个系统的演变或进化包括：新层次的产生（小鸟的出生）；分化和多样性的出现（鸟群中的鸟分成许多小的群）；新的主题的出现（鸟寻找食物过程中，不断发现新的食物）。 所以CAS系统中的主体具有4个基本特点（这些特点是粒子群算法发展变化的依据）： 首先，主体是主动的、活动的。 主体与环境及其他主体是相互影响、相互作用的，这种影响是系统发展变化的主要动力。 环境的影响是宏观的，主体之间的影响是微观的，宏观与微观要有机结合。 最后，整个系统可能还要受一些随机因素的影响。 粒子群算法就是对一个CAS系统－－－鸟群社会系统的研究得出的。 粒子群算法（Particle Swarm Optimization, PSO）最早是由Eberhart和Kennedy于1995年提出，它的基本概念源于对鸟群觅食行为的研究。设想这样一个场景:一群鸟在随机搜寻食物，在这个区域里只有一块食物，所有的鸟都不知道食物在哪里，但是它们知道当前的位置离食物还有多远。那么找到食物的最优策略是什么呢?最简单有效的就是搜寻目前离食物最近的鸟的周围区域。 PSO算法就从这种生物种群行为特性中得到启发并用于求解优化问题。在PSO中，每个优化问题的潜在解都可以想象成d维搜索空间上的一个点，我们称之为“粒子”（Particle），所有的粒子都有一个被目标函数决定的适应值(Fitness Value )，每个粒子还有一个速度决定他们飞翔的方向和距离，然后粒子们就追随当前的最优粒子在解空间中搜索。Reynolds对鸟群飞行的研究发现。鸟仅仅是追踪它有限数量的邻居但最终的整体结果是整个鸟群好像在一个中心的控制之下.即复杂的全局行为是由简单规则的相互作用引起的。 二、粒子群算法的具体表述 上面罗嗦了半天，那些都是科研工作者写论文的语气，不过，PSO的历史就像上面说的那样。下面通俗的解释PSO算法。 PSO算法就是模拟一群鸟寻找食物的过程，每个鸟就是PSO中的粒子，也就是我们需要求解问题的可能解，这些鸟在寻找食物的过程中，不停改变自己在空中飞行的位置与速度。大家也可以观察一下，鸟群在寻找食物的过程中，开始鸟群比较分散，逐渐这些鸟就会聚成一群，这个群忽高忽低、忽左忽右，直到最后找到食物。这个过程我们转化为一个数学问题。寻找函数y=1-cos(3*x)*exp(-x)的在[0,4]最大值。该函数的图形如下： 第6章面向对象编程 教案 课程名称：Python编程基础 课程类别：必修 适用专业：大数据技术类相关专业 总学时：48学时（其中理论24学时，实验24学时） 总学分：3.0学分 本章学时：8学时 一、材料清单 （1）《Python编程基础》教材。 （2）配套PPT。 （3）代码。 （4）引导性提问。 （5）探究性问题。 （6）拓展性问题。 二、教学目标与基本要求 1.教学目标 介绍Python面向对象程序设计的发展及其思想，何时及怎样运用面向对象编程；实现了面向对象的核心“类与对象”的创建和使用，并拓展了面向对象常用的功能和方法。 2.基本要求 （1）认识面向对象编程的发展、实例、优点。 （2）了解使用面向对象编程的情形。 （3）掌握类的定义、使用和专有方法。 （4）掌握self参数的使用。 （5）掌握对象的创建（实例化）、删除。 （6）掌握对象的属性、方法引用和私有化方法。 （7）掌握迭代器和生成器。 （8）掌握类的继承、重载、封装等其他方法。 三、问题 1.引导性提问 引导性提问需要教师根据教材内容和学生实际水平，提出问题，启发引导学生去解决问题，提问，从而达到理解、掌握知识，发展各种能力和提高思想觉悟的目的。 （1）用于练习的所有资料都放在您面前了吗？如果不是，缺少哪些？ （2）面向对象与面向过程有什么不同？ （3）类和对象分别是什么？有什么关系？ （4）生成器与迭代器是什么？ （5）继承、重载、封装是什么？ 2.探究性问题 探究性问题需要教师深入钻研教材的基础上精心设计，提问的角度或者在引导性提问的基础上，从重点、难点问题切入，进行插入式提问。或者是对引导式提问中尚未涉及但在课文中又是重要的问题加以设问。 （1）面向对象编程语言有哪些？ （2）为什么要使用面向对象编程？ （3）self参数有什么特点？ （4）类的专有方法与普通的方法有何不同？ （5）对象的创建与调用函数相似吗？ PSO算法 1. 引言 粒子群优化算法(PSO)是一种进化计算技术(evolutionary computation)，有Eberhart博士和kennedy博士发明。源于对鸟群捕食的行为研究。 PSO同遗传算法类似，是一种基于叠代的优化工具。系统初始化为一组随机解，通过叠代搜寻最优值。但是并没有遗传算法用的交叉(crossover)以及变异(mutation)，而是粒子在解空间追随最优的粒子进行搜索。详细的步骤以后的章节介绍 同遗传算法比较，PSO的优势在于简单容易实现并且没有许多参数需要调整。目前已广泛应用于函数优化，神经网络训练，模糊系统控制以及其他遗传算法的应用领域。 2. 背景: 人工生命 "人工生命"是来研究具有某些生命基本特征的人工系统. 人工生命包括两方面的内容 1. 研究如何利用计算技术研究生物现象 2. 研究如何利用生物技术研究计算问题 我们现在关注的是第二部分的内容. 现在已经有很多源于生物现象的计算技巧. 例如, 人工神经网络是简化的大脑模型. 遗传算法是模拟基因进化过程的. 现在我们讨论另一种生物系统- 社会系统. 更确切的是, 在由简单个体组成的群落与环境以及个体之间的互动行为. 也可称做"群智能"(swarm intelligence). 这些模拟系统利用局部信息从而可能产生不可预测的群体行为 例如floys 和boids, 他们都用来模拟鱼群和鸟群的运动规律, 主要用于计算机视觉和计算机辅助设计. 在计算智能(computational intelligence)领域有两种基于群智能的算法. 蚁群算法(ant colony optimization)和粒子群算法(particle swarm optimization). 前者是对蚂蚁群落食物采集过程的模拟. 已经成功运用在很多离散优化问题上. 粒子群优化算法(PSO) 也是起源对简单社会系统的模拟. 最初设想是模拟鸟群觅食的过程. 但后来发现PSO是一种很好的优化工具. 3. 算法介绍 如前所述，PSO模拟鸟群的捕食行为。设想这样一个场景：一群鸟在随机搜索食物。在这个区域里只有一块食物。所有的鸟都不知道食物在那里。但是他们知道当前的位置离食物还有多远。那么找到食物的最优策略是什么呢。最简单有效的就是搜寻目前离食物最近的鸟的周围区域。 PSO从这种模型中得到启示并用于解决优化问题。PSO中，每个优化问题的解都是搜索空间中的一只鸟。我们称之为“粒子”。所有的例子都有一个由被优化的函数决定的适应值(fitness value)，每个粒子还有一个速度决定他们飞翔的方向和距离。然后粒子们就追随当前的最优粒子在解空间中搜索 附录 程序1 当22111==c c ，5.12212==c c ，2.1=w 。 a)%主函数源程序（main.m ） %------基本粒子群算法 （particle swarm optimization ） %------名称： 基本粒子群算法 %------初始格式化 clear all ; %清除所有变量 clc; %清屏 format long ; %将数据显示为长整形科学计数 %------给定初始条条件------------------ N=40; %3初始化群体个数 D=10; %初始化群体维数 T=100; %初始化群体最迭代次数 c11=2; %学习因子1 c21=2; %学习因子2 c12=1.5; c22=1.5; w=1.2; %惯性权重 eps=10^(-6); %设置精度（在已知最小值的时候用） %------初始化种群个体（限定位置和速度）------------ x=zeros(N,D); v=zeros(N,D); for i=1:N for j=1:D x(i,j)=randn; %随机初始化位置 v(i,j)=randn; %随机初始化速度 end end %------显示群位置---------------------- figure(1) for j=1:D if(rem(D,2)>0) subplot((D+1)/2,2,j) else subplot(D/2,2,j) end plot(x(:,j),'b*');grid on xlabel('粒子') ylabel('初始位置') tInfo=strcat('第',char(j+48),'维'); if(j>9) tInfo=strcat('第',char(floor(j/10)+48),char(rem(j,10)+48),'维'); end title(tInfo) end %------显示种群速度 figure(2) for j=1:D if(rem(D,2)>0) subplot((D+1)/2,2,j) else subplot(D/2,2,j) end plot(x(:,j),'b*');grid on xlabel('粒子') ylabel('初始速度') tInfo=strcat('第,char(j+48),'维'); if(j>9) tInfo=strcat('第',char(floor(j/10)+48), char(rem(j,10)+48),'维); end title(tInfo) end figure(3) clear all; clc; format long; %------给定初始化条件---------------------------------------------- c1=1.4962; %学习因子1 c2=1.4962; %学习因子2 w=0.7298; %惯性权重 MaxDT=1000; %最大迭代次数 D=10; %搜索空间维数（未知数个数） N=40; %初始化群体个体数目 eps=10^(-6); %设置精度(在已知最小值时候用) %------初始化种群的个体(可以在这里限定位置和速度的范围)------------ for i=1:N for j=1:D x(i,j)=randn; %随机初始化位置 v(i,j)=randn; %随机初始化速度 end end %------先计算各个粒子的适应度，并初始化Pi和Pg---------------------- for i=1:N p(i)=fitness(x(i,:),D); y(i,:)=x(i,:); end pg=x(1,:); %Pg为全局最优 for i=2:N if fitness(x(i,:),D) 慎用面向对象：开始之前，请阅读《面向对象编程已死》 实际上我并不喜欢面向对象，使用Python以来，我仅仅在wxpython中用过比较多的面向对象。面向对象的设计方式，对我来讲有些繁琐了。 此次教程基本都是网上找来的内容，面向对象的短小的例子一时想不出比较好的。 简介 到目前为止，都是根据操作数据的函数或语句块来设计程序的。这被称为面向过程的编程。还有一种把数据和功能结合起来，用称为对象的东西包裹起来组织程序的方法。 这种方法称为面向对象的编程理念。在大多数时候你可以使用过程性编程，但是有些时候当你想要编写大型程序或是寻求一个更加合适的解决方案的时候，你就得使用面向对象的编程技术。 类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象这个类的实例。这类似于你有一个int类型的变量，这存储整数的变量是int类的实例（对象）。 注意，即便是整数也被作为对象（属于int类）。这和C++、Java（1.5版之前）把整数纯粹作为类型是不同的。通过help(int)了解更多这个类的详情。C#和Java 1.5程序员会熟悉这个概念，因为它类似与封装与解封装的概念。 对象可以使用普通的属于对象的变量存储数据。属于一个对象或类的变量被称为域。对象也可以使用属于类的函数来具有功能。这样的函数被称为类的方法。这些术语帮助我们把它们与孤立的函数和变量区分开来。域和方法可以合称为类的属性。 域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。 类使用class关键字创建。类的域和方法被列在一个缩进块中。 self关键字 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self。 虽然你可以给这个参数任何名称，但是强烈建议你使用self这个名称——其他名称都是不赞成你使用的。使用一个标准的名称有很多优点——你的程序读者可以迅速识别它，如果使用self的话，还有些IDE（集成开发环境）也可以帮助你。 Python中的self等价于C++中的self指针和Java、C#中的this参考。 这也意味着如果你有一个不需要参数的方法，你还是得给这个方法定义一个self参数。类 毕业论文 题目粒子群算法及其参数设置专业信息与计算科学 班级计算061 学号3060811007 学生xx 指导教师徐小平 2010年 I 粒子群优化算法及其参数设置 专业：信息与计算科学 学生： xx 指导教师：徐小平 摘要 粒子群优化是一种新兴的基于群体智能的启发式全局搜索算法，粒子群优化算法通过粒子间的竞争和协作以实现在复杂搜索空间中寻找全局最优点。它具有易理解、易实现、全局搜索能力强等特点，倍受科学与工程领域的广泛关注，已经成为发展最快的智能优化算法之一。论文介绍了粒子群优化算法的基本原理，分析了其特点。论文中围绕粒子群优化算法的原理、特点、参数设置与应用等方面进行全面综述，重点利用单因子方差分析方法，分析了粒群优化算法中的惯性权值，加速因子的设置对算法基本性能的影响，给出算法中的经验参数设置。最后对其未来的研究提出了一些建议及研究方向的展望。 关键词：粒子群优化算法；参数；方差分析；最优解 II Particle swarm optimization algorithm and its parameter set Speciality: Information and Computing Science Student: Ren Kan Advisor: Xu Xiaoping Abstract Particle swarm optimization is an emerging global based on swarm intelligence heuristic search algorithm, particle swarm optimization algorithm competition and collaboration between particles to achieve in complex search space to find the global optimum. It has easy to understand, easy to achieve, the characteristics of strong global search ability, and has never wide field of science and engineering concern, has become the fastest growing one of the intelligent optimization algorithms. This paper introduces the particle swarm optimization basic principles, and analyzes its features. Paper around the particle swarm optimization principles, characteristics, parameters settings and applications to conduct a thorough review, focusing on a single factor analysis of variance, analysis of the particle swarm optimization algorithm in the inertia weight, acceleration factor setting the basic properties of the algorithm the impact of the experience of the algorithm given parameter setting. Finally, its future researched and prospects are proposed. Key word：Particle swarm optimization; Parameter; Variance analysis; Optimal solution III 什么是粒子群优化算法 水电站中长期调度优化的粒子群算法MATLAB源码 水电站中长期优化调度主要是在满足电力系统出力要求以及下游综合用水要求等的前提下，合理地安排水库各个月份的发电流量，使得调度期内的总发电量最大。即在给定预报入库流量过程线、下游综合用水流量过程线、调度期起始水位和终止水位等条件下，通过总水量的合理运用使调度期内水电站的总发电量最大。 %% 参数设置 % GreenSim团队——专业级算法设计&代写程序 % 欢迎访问GreenSim团队主页→https://www.doczj.com/doc/283326926.html,/greensim A=8.5;%出力系数，常数 Tt=730*ones(12,1);%第t个时段的小时数 %注意：一年按363天*24小时算，均分为12个月 HtLB=55*ones(12,1);%第t时段水位约束的下界，单位：米 HtUB=[65;65;65;61;61;61;61;65;65;65;65;65];%第t时段水位约束的上界，单位：米 VtLB=zeros(12,1); VtUB=zeros(12,1); for i=1:12 VtLB(i)=Ht2Vt(HtLB(i)); VtUB(i)=Ht2Vt(HtUB(i)); end %注意：蓄水量Vt和水位Ht之间有一一对应的关系，单位：立方米 NtLB=260000*ones(12,1);%出力约束的下界，单位：千瓦 NtUB=1400000*ones(12,1);%出力约束的上届，单位：千瓦 %注意：Nt=A*Qt*Ht QtLB=308*ones(12,1);%泄流量下界，单位：立方米/秒 QtUB=29200*ones(12,1);%泄流量上界，单位：立方米/秒 qt=[373;859;1568;2100;3210;5049;1596;1160;925;781;572;1010];%入库流量，单位：立方米/秒 %注意：以上三个量，时间单位相乘时，小时乘以3600转化成秒 %% 调用粒子群算法 K=60; N=80; w=0.5; c1=0.3; c2=0.2; [BESTX,BESTY,ALLX,ALLY]=PSO(K,N,w,c1,c2,VtLB,VtUB,QtLB,QtUB,NtLB,NtUB,qt,A,Tt) ; %% X=BESTX{K}; [Vt,Qt,St]=DeCode(X);python面向对象概念及练习题
(完整word版)基本粒子群算法的原理和matlab程序
基本粒子群算法的matlab源程序
(完整word版)基本粒子群算法的原理和matlab程序.doc
粒子群优化算法介绍及matlab程序
python 面向对象学习总结
粒子群算法原理及在函数优化中的应用(附程序)
粒子群算法详解-附matlab代码说明
Python编程基础-面向对象编程教案
粒子群优化算法
粒子群优化算法及其参数设置
粒子群优化算法Matlab源程序
Python教程：面向对象
粒子群算法(优化算法)毕业设计毕设论文(包括源代码实验数据,截图,很全面的)
粒子群优化算法
粒子群优化算法(Particle Swarm optimization,PSO)又翻译为粒子群算法、微粒群算法、或 粒子群优化算法 微粒群优化算法。是通过模拟鸟群觅食行为而发展起来的一种基于群体协作的随机搜索算法。通 常认为它是群集智能 (Swarm intelligence, SI) 的一种。它可以被纳入多主体优化系统 (Multiagent Optimization System, MAOS). 是由 Eberhart 博士和 kennedy 博士发明。 PSO 模拟鸟群的捕食行为。一群鸟在随机搜索食物，在这个区域里只有一块食物。所有的 鸟都不知道食物在那里。但是他们知道当前的位置离食物还有多远。那么找到食物的最优策略是 什么呢。最简单有效的就是搜寻目前离食物最近的鸟的周围区域。 PSO 从这种模型中得到启示并用于解决优化问题。PSO 中，每个优化问题的解都是搜索空 间中的一只鸟。我们称之为“粒子”。所有的粒子都有一个由被优化的函数决定的适应值 (fitnessvalue)，每个粒子还有一个速度决定他们飞翔的方向和距离。然后粒子们就追随当前的最 优粒子在解空间中搜索。 PSO 初始化为一群随机粒子(随机解)，然后通过叠代找到最优解，在每一次叠代中，粒子通 过跟踪两个“极值”来更新自己。第一个就是粒子本身所找到的最优解，这个解叫做个体极值 pBest，另一个极值是整个种群目前找到的最优解，这个极值是全局极值 gBest。另外也可以不 用整个种群而只是用其中一部分最优粒子的邻居，那么在所有邻居中的极值就是局部极值。 [编辑]
PSO 算法介绍[1]
如前所述，PSO 模拟鸟群的捕食行为。设想这样一个场景：一群鸟在随机搜索食物。在这 个区域里只有一块食物。所有的鸟都不知道食物在那里。但是他们知道当前的位置离食物还有多 远 那么找到食物的最优策略是什么呢 最简单有效的就是搜寻目前离食物最近的鸟的周围区域 。 。 。 PSO 从这种模型中得到启示并用于解决优化问题。PSO 中，每个优化问题的解都是搜索空 间中的一只鸟。我们称之为“粒子”。所有的例子都有一个由被优化的函数决定的适应值(fitness value)，每个粒子还有一个速度决定他们飞翔的方向和距离。然后粒子们就追随当前的最优粒子 在解空间中搜索 PSO 初始化为一群随机粒子(随机解)。然后通过叠代找到最优解。在每一次叠代中，粒子通 过跟踪两个"极值"来更新自己 第一个就是粒子本身所找到的最优解 这个解叫做个体极值 pBest. 。 。 另一个极值是整个种群目前找到的最优解。这个极值是全局极值 gBest。另外也可以不用整个种 群而只是用其中一部分最为粒子的邻居，那么在所有邻居中的极值就是局部极值。 在找到这两个最优值时, 粒子根据如下的公式来更新自己的速度和新的位置33水电站中长期调度优化的粒子群算法MATLAB源码
相关主题
文本预览