MIT 6.00 1x Lecture 6 Objects 对象 学习笔记

l MIT6.00 1x (麻省理工：计算机科学和Python编程导论)

Lecture 6 Objects  对象

6.1 Tuples  元组

Compound data types 复合数据类型

• Have seen a sampling of different classesof algorithms   已经见识过了不同类别的算法思想

– Exhaustive enumeration  穷举法

– Guess and check  猜测检验法

– Bisection  二分法

– Divide and conquer   分而治之

• All have been applied so far to simpledata types  它们现在仅应用于简单数据类型

– Numbers 类似于数字

– Strings         字符串

•Tuples        元组

•Lists          列表

•Dictionaries    字典

Tuples  元组

• Ordered sequence of elements (similar tostrings)  元组里的元素是有序排列的 就像字符串

• Elements can be more than just characters   元组里的元素不仅仅可以是字符或者字符串，元素也可以是元组

Operations on tuples 元组的操作

语法见上（基本同字符串）

一 相加 就是把两个元组串联

二 索引  和之前的字符串一样，索引也是从0开始的

三 切片 和字符串操作一样 从开始的数字到（结束的数字减一）

四 单例（singletons）  如果说元组里之后一个元素，就要必须在这个元素后面加逗号 ，这就叫单例（必须放入逗号为了区分表达式和单个元素的元组的区别）

 

 

 

当一个数组只有一个元素，您必须这样表示：（元素名，）

Manipulating tuples 操纵多元组

• Can iterate over tuples just as we caniterate over strings 可以迭代元组就好像迭代字符串

求公约数

把所求的所有公约数相加

6.2 LISTS 列表

Lists 列表

• Look a lot like tuples  列表看起来很像元组

– Ordered sequence of values, each identified by an index   列表也是一些值得有序序列，每个元素都可以通过索引识别

– Use [1, 2, 3] rather than (1, 2, 3)  但是列表使用方括号而非元组的圆括号

– Singletons are now just [4] rather than (4, )  单例就不用放入烦人的逗号了

• BIG DIFFERENCE  很大的不同

– Lists are mutable!!  列表是可变的！

– While tuple, int, float, str are immutable  元组、整数、浮点数、字符串都是不可变的

– So lists can be modified after they are created! 列表可以在它们被创建后被修改

Why should this matter? 为什么要做这件事（修改列表）

• Some data objects we want to treat asfixed  有些数据对象，我们确实想要把他们当作固定的东西对待

– Can create new versions of them  可以创建他们的新版本

– Can bind variable names to them  可以给他们绑定变量名

– But don’t want to change them   但是我不想改变他们

– Generally valuable when these data objects will be referencedfrequently but elements don’t change  当我们频繁引用这些数据对象时，他们的内部元素不会改变，这很有用

• Some data objects may want to supportmodifications to elements, either for efficiency or because elements are proneto change  另一方面，在某些情况下，数据对象可能想要支持对其内部元素的修改

• Mutable structures are more prone to bugsin use, but provide great flexibility 尽管可变结构非常灵活，但他们也更容易产生bug

Visualizing lists 可视化列表

Structures of lists 列表的结构

• Consider 假设

• Are these the same thing?  它们是一样的东西嘛？

– They print the same thing   它们输出了一样的东西

– But let’s try adding something to one of these 但是不一定，让我们测试一下

Mutability of lists 易变的列表

• Let’s evaluate 让我们求值

• Append is a method (hence the .) that hasa side effect  append（由于点号.）是一个有父子哦用的方法

– It doesn’t create a new list, it mutates the existing one to add anew element to the end  他不会创建新的列表，它会改变已有的列表，它在末尾增加了一个新元素，使列表变长

• So if we print Univs and Univs1 we getdifferent things

Why? 为什么

     加入元素之前                                     加入元素之后

Observations 现象

• Elements of Univs are not copies of thelists to which Techs and Ivys are bound, but are the lists themselves!  Univs中的元素不是对列表的复制，其中和ixys与和techs都有绑定关系，它们都是列表

• This effect is called aliasing:  这一效果我们称为 别名

– There are two distinct paths to a data object  表示这又两个不同的方法都通向这个数据对象

• One through the variable Techs  一条是通过tech变量

• A second through the first element oflist object to which Univs is bound 第二条我们是通过univs绑定到列表的第一个元素

– Can mutate object through either path, but effect will be visible throughboth  结果是我们可以通过任意一条路对元素进行修改，但是结果对两者都可见

– Convenient but treacherous   很便利，但也可能背叛你

We can directly change elements 我们可以直接改变元素

列表可以这么做，但是元组不行的!

 

 

注：sum（）函数，表示把列表内的所有元素相加得出值，

要使用sum（）函数，必须保证里面的元素都是数字类型

 

 

Is的意思类似于==，但又不一样

==仅比较值，is比较两个对象是否是同一个对象（比较三个方面内存，值，对象类型）

 

 

 

列表要慎用a列表=b列表 这样将导致b列表改变，a列表也会改变

6.3 OPERATIONS ON LISTS 列表的操作

Operations on lists 列表的操作

•Iteration 迭代

Append versus flatten 追加与串联

 此图中上面是追加，下面是串联

In more detail 更多细节

追加                                       串联

 

串联可以不让一整个列表作为一个元素，每个元素同样的地位（有序化）

Cloning 克隆（通过克隆创建列表的拷贝）

• Avoid mutating a list over which one isiterating  避免在一个迭代的列表中改变

• Example: 例子

 

 

L1.REMOVE（e1） 这个语句的含义是，从列表L1中移除e1这个元素

这个函数的意思是把L1中，与L2相同的元素移除

 我们通过移除得到的结果应该是【3，4】，但结果确实[2,3,4]

Why? 为什么

• Inside for loop, Python keeps track ofwhere it is in list using internal counter  内部循环，Python跟踪是利用内部的计数器列表

• When we mutate a list, we change itslength but Python doesn’t update counter 当我们改变一个列表的时候，我们改变了列表的长度，但是python不更新计数器

假设我们删除了第一个元素，原来计数器指向第二个元素，则现在列表长度改变了，第二个元素变成了第一个元素，第三个元素变成了第二个元素，计数器跳过了第二个元素指向了第三个元素

Better is   to  clone最好是克隆（在迭代中）

最好是在迭代中做一个备份，迭代备份的话就不会跳过元素了

必须用  L1Start = L1[:]   这个格式

不能用         L1Start= L1  这个格式创建拷贝

因为下面那种会导致两个对象是同一对象，改变其中一个就会改变另一个

y = x[:]通过分片操作将列表x的元素全部拷贝给y，如果简单的把x赋值给y：y = x，y和x还是指向同一个列表，并没有产生新的副本。

 

 

 

 

 

列表用有一堆有用的函数

Sort（） 给列表排序

Reverse（） 把列表里的元素反向

 

Pop（） 删除列表里索引制定的元素并返回这个元素

Remove（） 删除列表里某一个值得第一个匹配项

 

Attend()   在列表末尾添加新的对象

Extend()  在列表末尾添加另一个序列的多个值

insert() 函数用于将指定对象插入列表的指定位置。

 

index()   函数用于从列表中找出某个值第一个匹配项的索引位置。

Count（） 计算一个对象在列表中出现的次数

 

6.4  FUNCTIONS ASOBJECTS 函数对象

Functions as Objects 函数对象

• Functions are first class objects:   一级对象的概念

– They have types  它有数据类型

– They can be elements of data structures like lists  它可以是数据结构（例如列表）的一个元素，

– They can appear in expressions  他可以出现在表达式中

• As part of an assignment statement                       作为赋值语言的一部分

• As an argument to a function!!    也可以是函数的参数

• Particular useful to use functions asarguments when coupled with lists  当我们想进行列表的连结时，把函数作为参数十分有用

– Aka higher orderprogramming   又名高阶编程

Example 例子

L是一个列表，f是一个函数

Lists of functions  包含函数的列表

L是一个列表，但是列表里面的元素都是函数，x是函数计算的元素

 

 

Generalizations of higher order functions  高阶函数的推广

• Python provides a general purpose HOP,map  python为我们提供了一些通用的高阶程序——过程映射map()

• Simple form – a unary function and acollection of suitable arguments  一个简单的形式联合函数——即有一个参数的函数和一个包含合适参数的集合

• General form – an n-ary function and n  一般形式，n元函数（具有n个参数的函数），和参数的n个集合

Collections of arguments     比如min（）函数就是2元函数，两个列表集合

 

 

 

 

Max（）函数必须有两个变量！

6.5 DICTIONARIES 字典

Dictionaries 字典

• Dict is generalization of lists, but nowindices don’t have to be integers  字典就是列表的一般化产物，但是现在，索引，也就是获取字典元素的方式，不一定是整数

– can be values of any immutable type   可以是任何不可变了类型的值

• Refer to indices as keys, since arbitraryin form  现在这个不叫索引了，而叫键，因为这些键可以拥有任意形式

• A dict is then a collection of pairs  而字典就是键值对的集合，也就是键和相关数值的配对

• Syntax 语法

我们用花括号表示字典，每个元素由 键、冒号、值组成，每个元素用逗号隔开

We access by using a key 我们通过键来使用字典

1.通过键来获取对应的值  字典名 [ key ]

  但是不能通过值来获取对应的键哈

2. 不用使用数字作为索引了

Operations on dicts 字典的操作

1. 可以给字典添加值，语法为 字典名 [ key ] = 值

2. 字典也可以进行迭代

Keys can be complex 键可以非常复杂

Note that keys must be immutable, so haveto use a tuple, not a list  注意 键一定是不可变的值，所以我们可以用元组作为键，但是绝对不能用列表！

 

 

 

Python 字典(Dictionary) has_key()方法

描述

Python 字典(Dictionary) has_key()函数用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false。

语法

has_key()方法语法：

dict.has_key(key)

参数

·        key --要在字典中查找的键。

返回值

如果键在字典里返回true，否则返回false。

实例

以下实例展示了 has_key()函数的使用方法：

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.has_key('Age')

print "Value : %s" %  dict.has_key('Sex')

以上实例输出结果为：

Value : True

Value : False

 

 

 

Python 字典(Dictionary) values()方法

---

描述

Python 字典(Dictionary) values()函数以列表返回字典中的所有值。

语法

values()方法语法：

dict.values()

参数

·        NA。

返回值

返回字典中的所有值。

实例

以下实例展示了 values()函数的使用方法：

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.values()

以上实例输出结果为：

Value : [7, 'Zara']

 

 

 

 

 

Python 字典(Dictionary) keys()方法

---

描述

Python 字典(Dictionary) keys()函数以列表返回一个字典所有的键。

语法

keys()方法语法：

dict.keys()

参数

·        NA。

返回值

返回一个字典所有的键。

实例

以下实例展示了 keys()函数的使用方法：

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.keys()

以上实例输出结果为：

Value : ['Age', 'Name']

 

 

 

 

 

del animals['b']

意思是删除 字典animal 中键“b“对性的值

 

 

 

 

 

 

 

总结

在本讲中，我们介绍了三种复合数据类型，元组，列表和字典，

元组里的元素不可改变

列表里的元素可以改变

字典里的元素可以改变，并且索引不再是数字了，而是专门有一个键值

还学习了这些复合数据类型的基本操作