序列（列表、元组、字符串）字典小题

一.已知：元组 a = (1,2,3) 利用list方法，输出下面的结果：(1,2,4)

二. 已知：b = [9,5,36,25,4,1,2]

1.求出列表b的长度，最大值，最小值。

2.取值：取出25

3.切片：输出[5,36,25]

4. 删除：删除列表中25这个数字

5.扩充：将列表c =[7,6,11]扩充到列表b中

6. 排序：对b列表进行从小到大的排序输出，然后再反向使列表从大到小输出

7. 插入：将26插入到列表中，

使得最后输出结果为：b = [36, 26, 11, 9, 7, 6, 5, 4, 2, 1]

========================================================================

一、已知字典ainfo = {'name':'lily','age':20}

1.加入两项使得输出的结果：

ainfo = {'name':'lily','age':20,'gender':'female','class':8}

2.访问字典中的所有项，访问字典的键，访问字典中的值

二、将这三项内容创建字典,按下面规则添加到同一个对象中:

(name = 'lily',age= '20,gender = 'female',class = 8) 

(name ='jack',age= 25,gender ='male',class =8)

(name ='jane',age= 19,gender ='female',class =8)

1.将这三项内容创建的三个字典放到一个列表里。

2.将这三项内容创建的三个字典放到一个字典里，要求字典以个人姓名为键，其他信息组成的字典为姓名这个键所对应的值。（字典里面嵌套字典）

例如info = {'lily'：{'age':20,'gender':'female','class':8}}

=================================华丽的分隔符=================================

>>> # 一.已知：元组 a = (1,2,3) 利用list方法，输出下面的结果：(1,2,4)

>>> a = (1,2,3)

>>> a = list(a)  #给a 这个对象强制转换为list数据类型，再给这个对象起个 a的名字。

>>> print a  #打印a这个对象

[1, 2, 3]

>>> #题目要求输出结果为（1，2，3）分析知道结果对象为tuple类型，list()可以使用remove移除子串3或者pop方法出栈最后一个子串，然后使用append追加对象4.

>>> a.pop()

3

>>> a.append(4)

>>> print a  #打印a对象，我们会发现跟题目结果不一样，我们这里还需要转换一下tuple类型

[1, 2, 4]

>>> a = tuple(a)  #给a 这个对象强制转换为tuple数据类型，再给这个对象起个 a的名字。

>>> print a #我们再来看结果

(1, 2, 4)

>>> #remove方法类型，唯一区别是remove()传参为子串对象，而pop()传参为index。

>>> 

>>> #二. 已知：b = [9,5,36,25,4,1,2]

>>> b = [9,5,36,25,4,1,2]

>>> #求出列表b的长度，最大值，最小值。

>>> len(b)  #长度

7

>>> max(b)  #最大值 max方法是使用iterable迭代b对象的参数，返回其最大的item。或者使用两个或两个以上的实参，返回最大的实参。

36

>>> min(b)  #最小值 min()方法和max()一样都是使用iterable迭代b对象的实际参数（argument），返回其最小的item。或者使用两个或两个以上的实参（argument）,返回最小的实参（argument）。

1

>>> #max() min() 方法返回的为value。

>>> #2.取值：取出25

>>> b[3]  #此题可以使用索引，正向索引或者反向索引

25

>>> b[-4] #反向索引

25

>>> #3.切片：输出[5,36,25]

>>> b[1:4] #index切片，切片分为正向索引切片和反向索引切片。

[5, 36, 25]

>>> b[-6:-3]  #反向索引切片，切片格式为[start:end:step]不写step,默认为1。

[5, 36, 25]

>>> #4. 删除：删除列表中25这个数字

>>> b.remove(25)  #操作方法L.remove(value) ,删除第一次出现的值(value),如果发现L.remove(value) value == vlaue,就是值不存在，则报错 ValueError:  错误。我查看了帮助 告诉我“Raises ValueError if the value is not present.” Raises百度翻译的结果是举起提起。不明白这里为什么不是return返回。

>>> print b  #打印 b 对象。

[9, 5, 36, 4, 1, 2]

>>> #5.扩充：将列表c =[7,6,11]扩充到列表b中

>>> c =[7,6,11]

>>> b.extend(c)  #L.extend(iterable),通过iterable迭代器追加到b对象的扩展列表。

>>> print b  #打印b对象的结果。

[9, 5, 36, 4, 1, 2, 7, 6, 11]

>>> #我们发现[7,6,11]是按照顺序扩展到尾部。这正是通过iterable迭代添加到 b 对象。

>>> #6. 排序：对b列表进行从小到大的排序输出，然后再反向使列表从大到小输出

>>> #考虑了一个python提供了两种排序方式列表方法的成员sort,内置函数sorted

>>> #sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list 从帮组中了解到sorted提供了一个迭代器，cmp(compare)是比较函数，比较什么由key决定,有默认值，迭代集合中的一项;

>>> #key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项;

>>> #reverse：排序规则. reverse = True 或者 reverse = False，有默认值。

>>> #返回值：是一个经过排序的可迭代类型，与iterable一样。

>>> #我们看到sorted返回值为new sorted list ，一个新产生的列表。

>>> #sort方法：L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;

>>> #cmp(x, y) -> -1, 0, 1

>>> #关于cmp比较函数，我还了解的比较浅，根据百度得到的知识记录下来：

>>> #可以认为是compare（比较）的意思。在进行比较的时候将个数做减法运算，这个运算是影响符号位的，（大数减小数，符号位为+，反则为-）所以执行该指令后你可以通过查询符号位CF是0还是1就可以知道两个数那个大了。根据汇编知识里了解到，不知python是否适用，以后精通后，有能力再回头看看源码。这里知识表示看不懂！！！了解怎么用是现在的目标。

>>> b.sort(b)

Traceback (most recent call last):

  File "<pyshell#292>", line 1, in <module>

    b.sort(b)

TypeError: 'list' object is not callable

>>> #b.sort()  #唉，上面传了错误的参数返回报错，默认参数help里可以看到。

>>> b.sort()

>>> print b  #打印 对象 b

[1, 2, 4, 5, 6, 7, 9, 11, 36]

>>> #为了模拟sorted,刚好之前无意学了一点random函数，使用random打乱b对象列表里值的顺序。

>>> #查看帮助，告诉我们shuffle属性 将list 列表 x in place;应该是一个for循环重新随机放置遍历到的值，return None。下面我们使用一下。

>>> #shuffle(self, x, random=None) 再解释一下这个方法self调用自己这个函数，x 是传参的list的名字。random=None,默认参数。

>>> random.shuffle(b)

Traceback (most recent call last):

  File "<pyshell#299>", line 1, in <module>

    random.shuffle(b)

NameError: name 'random' is not defined

>>> import random  #悲剧了，他告诉我们random没有定义，我们import 导入一下。

>>> random.shuffle(b) #将b这个对象传入到参数。

>>> print b  #打印对象b 查看结果

[5, 36, 2, 7, 11, 9, 4, 1, 6]

>>> sorted(b) #sorted进行重新排序

[1, 2, 4, 5, 6, 7, 9, 11, 36]

>>> #注意啊！我们使用了sorted他是有返回值的。那么说说它与sort的区别吧。

>>> #sorted是python内置函数，注意观察颜色，sort是list的成员方法。sorted是生成一个新的列表，而sort是对元素列表原位排序，这个方法改变列表，而不是返回排序后的列表，所有我们使用sort()方法后，它没有返回。而sorted则返回了值。

>>> #7. 插入：将26插入到列表中，使得最后输出结果为：b = [36, 26, 11, 9, 7, 6, 5, 4, 2, 1]

>>> #少了一个方向排序，reverse

>>> b.reverse()  #L.reverse() -- reverse *IN PLACE* 循环反向放置

>>> print b  #打印 对象 b 查看结果。

[6, 1, 4, 9, 11, 7, 2, 36, 5]

>>> b.sort()

>>> b

[1, 2, 4, 5, 6, 7, 9, 11, 36]

>>> b.reverse()

>>> b

[36, 11, 9, 7, 6, 5, 4, 2, 1]

>>> print b

[36, 11, 9, 7, 6, 5, 4, 2, 1]

>>> 

>>> #7. 插入：将26插入到列表中，使得最后输出结果为：b = [36, 26, 11, 9, 7, 6, 5, 4, 2, 1]

>>> b.insert(1，26)  #L.insert(index, object) -- insert object before index，insert方法前面为要插入对象index的前面。

SyntaxError: invalid syntax

>>> b

[36, 11, 9, 7, 6, 5, 4, 2, 1]

>>> b.insert(1,26)

>>> #前面报错，仔细发现是逗号使用中文半角了。

>>> 

>>> 

>>> #==================华丽的分隔符===========================

>>> #一、已知字典ainfo = {'name':'lily','age':20}

>>> #1.加入两项使得输出的结果：ainfo = {'name':'lily','age':20,'gender':'female','class':8}

>>> ainfo = {'name':'lily','age':20}

>>> ainfo['gender'] = 'female'; ainfo['class'] = 8

>>> ainfo #查看结果

{'gender': 'female', 'age': 20, 'name': 'lily', 'class': 8}

>>> #字典集合无序，元组字符串序列有序

>>> #2.访问字典中的所有项，访问字典的键，访问字典中的值

>>> ainfo.items()  #字典的项格式为键值对的元组的列表

[('gender', 'female'), ('age', 20), ('name', 'lily'), ('class', 8)]

>>> ainfo.keys()  #字典keys的列表

['gender', 'age', 'name', 'class']

>>> ainfo.values()  #字典中的值 values列表

['female', 20, 'lily', 8]

>>> #二、将这三项内容创建字典,按下面规则添加到同一个对象中:

>>> #(name = 'lily',age= '20,gender = 'female',class = 8)

>>> #(name ='jack',age= 25,gender ='male',class =8)

>>> #(name ='jane',age= 19,gender ='female',class =8)

>>> #1.将这三项内容创建的三个字典放到一个列表里。

>>> binfo = {name:'jack',age:25,gender:'male','class':8}

Traceback (most recent call last):

  File "<pyshell#339>", line 1, in <module>

    binfo = {name:'jack',age:25,gender:'male','class':8}

NameError: name 'name' is not defined

>>> binfo = {'name':'jack','age':25,'gender':'male','class':8}

>>> cinfo = {'name' ='jane','age'= 19,'gender' ='female','class' =8}

SyntaxError: invalid syntax

>>> cinfo : {'name':'jane','age':19,'gender':'female','class':8}

SyntaxError: invalid syntax

>>> cinfo = {'name':'jane','age':19,'gender':'female','class':8}

>>> #分析，根据所学的知识，D.items()方法返回值为列表格式元组键值对，然后将结果对象起个名字，再将对象使用list.extend()方法扩展。

>>> a = ainfo.items()

>>> b = binfo.items()

>>> c = cinfo.items()

>>> print a  #打印结果

[('gender', 'female'), ('age', 20), ('name', 'lily'), ('class', 8)]

>>> print b

[('gender', 'male'), ('age', 25), ('name', 'jack'), ('class', 8)]

>>> print c

[('gender', 'female'), ('age', 19), ('name', 'jane'), ('class', 8)]

>>> a.extend(b)

>>> a.extend(c)

>>> print a  #查看最后的结果就是题目要求的三个字典放在一个列表里了。

[('gender', 'female'), ('age', 20), ('name', 'lily'), ('class', 8), ('gender', 'male'), ('age', 25), ('name', 'jack'), ('class', 8), ('gender', 'female'), ('age', 19), ('name', 'jane'), ('class', 8)]

>>> #2.将这三项内容创建的三个字典放到一个字典里，要求字典以个人姓名为键，其他信息组成的字典为姓名这个键所对应的值。（字典里面嵌套字典）

>>> #例如info = {'lily'：{'age':20,'gender':'female','class':8}}

>>> ainfo={'name': 'lily','age':20,'gender':'female','class':8}  #创建字典ainfo

>>> binfo={'name':'jack','age':25,'gender':'male','class':8}  #创建字典binfo

>>> cinfo={'name':'jane','age':19,'gender':'female','class':8}  #创建字典cinfo

>>> dic={}  #初始化一个字典dic

>>> dic[ainfo.pop('name')]=ainfo  #添加一个新值（value）ainfo,key 为ainfo.pop('name')的对象。

>>> dic[binfo.pop('name')]=binfo  #添加一个新值（value）binfo,key 为binfo.pop('name')的对象。

>>> dic[cinfo.pop('name')]=cinfo  #添加一个新值（value）cinfo,key 为cinfo.pop('name')的对象。

>>> print dic  #打印dic字典看结果。

{'jane': {'gender': 'female', 'age': 19, 'class': 8}, 'lily': {'gender': 'female', 'age': 20, 'class': 8}, 'jack': {'gender': 'male', 'age': 25, 'class': 8}}

>>>