第三节-内置数据结构

可迭代对象iterable 

• 一个对象
• 每次能够返回x的成员

for x in rang(10):

for x in "abcdes":

for x in [0,1,2,3]:

• 用法

rang(start,stop,step=1)

等价于【start,stop)

反向操作：

rang(20,4,-4)依次返回20,16,12,8

区别：

1. python3中rang()相当于python中xrang()
2. 2中也有rang()函数，是生成列表

数据结构基本问题：

• 增删查改
• 切片

#1、逆序输出
a = '12345'
print (a)
print (a[::-1])
>>
12345
54321

#2、扩展、插入、修改、删除、排序
#扩展
a1 = [11,22,24,29,30,32]
print(a1)
a1.append(28)
print(a1)
#插入
a1.insert(4,57)
print(a1)
#修改
a1[0] = 6
print(a1)
#删除
a1.remove(32)
print(a1)
#排序
print(a1)
for i in range(0,7):
for j in range(i,7):
if a1[i] > a1[j]:
b = a1[i]
a1[i] = a1[j]
a1[j] = b
print(a1)
list.reverse(a1)
print(a1)
#feeling list
a3 = a1[1:6]
print(a1[2:5])
print(a3)
>>
[11, 22, 24, 29, 30, 32]
[11, 22, 24, 29, 30, 32, 28]
[11, 22, 24, 29, 57, 30, 32, 28]
[6, 22, 24, 29, 57, 30, 32, 28]
[6, 22, 24, 29, 57, 30, 28]
[6, 22, 24, 29, 57, 30, 28]
[6, 22, 24, 28, 29, 30, 57]
[57, 30, 29, 28, 24, 22, 6]
[29, 28, 24]
[30, 29, 28, 24, 22]

#3、判断2是否在列表里
#前期实验思路
a2 = [1,2,3,4,5]
for i in a2:
j = 5
if i==j:
print('%d在列表a2中'%j)
break
print ("%d不在列表a2中" %j)
#3、正确方法
a3 = [1,2,3,4,5]
j = 1
if j in a3:
print('%d在列表a3中'%j)
else:
print('%d不在列表a3中' % j)
>>
5在列表a2中
5不在列表a2中
1在列表a3中

#4、列表推导式
b = [23,45,22,44,25,66,78]
用列表推导式完成下面习题：
1) 生成所有奇数组成的列表
2) 输出结果: ['the content 23','the content 45']
3) 输出结果: [25, 47, 24, 46, 27, 68, 80]

#1 列表推导式
b = [23,45,22,44,25,66,78]
a4 = [ x for x in b if x%2 !=0]
print("T4.1::",a4)
#2 格式化输出
a5 = ['the content %d'%x for x in b[0:2:1]]
print("T4.2::",a5)
#3 列表推导式运算
a6 = [x + 2 for x in b]
print("T4.3::",a6)
>>
T4.1:: [23, 45, 25]
T4.2:: ['the content 23', 'the content 45']
T4.3:: [25, 47, 24, 46, 27, 68, 80]

• list.remove(x) :删除第一次出现的x（如果没有，报错）
• tuple([1,2,3]) :将列表等结构转换成元组  （1，2，3）
• sorted() 函数对所有可迭代的对象进行排序操作

>>>a = [5,7,6,3,4,1,2]

>>> b = sorted(a) # 保留原列表

>>> a [5, 7, 6, 3, 4, 1, 2]

>>> b [1, 2, 3, 4, 5, 6, 7]

>>> L=[('b',2),('a',1),('c',3),('d',4)]

>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数

[('a', 1), ('b', 2), ('c', 3), ('d', 4)]  

>>> sorted(L, key=lambda x:x[1]) # 利用key 

[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] 

>>> sorted(students, key=lambda s: s[2]) # 按年龄排序

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

>>> sorted(students, key=lambda s: s[2], reverse=True) # 按降序 

[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] 

6、字典

x = {'a':'b',  'c':'d'}

#可有一下表达：

'a' in x

'c' in x

'b' in x.values()     #'b' in x 表达错误

'd' in x.values()

7、pop( )函数  ： 用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

x = [1,2,3,2,3] 

a = x.pop() 

>>a = 1 

>>x =[1,2,3,2]

8、 set() 函数 ： 创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等 

创建集合

>>>x = set('runoob') 

>> y = set('google') 

>>> x, y 

(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) # 重复的被删除 

>>> x & y # 交集 

set(['o']) 

>>> x | y # 并集 

set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u']) 

>>> x - y # 差集 

set(['r', 'b', 'u', 'n'])

9、使用列表推导式生成包含10个数字5的列表

print([5 for i in range(10)]) #i满足条件，增加5进列表

>>

[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]

10、切片操作增加元素                        :感觉是一种切片替换作用

x = [ 1 , 1 , 1 , 1 , 1 , 1 ,]

x[ 0 : 0 ] = [ 3 ]

print (x)

x[ 0 : 1 ] = [ 4 ]

print (x)

x[ 0 : 3 ]=[ 0 ]

print (x)

>>

[3, 1, 1, 1, 1, 1, 1]

[4, 1, 1, 1, 1, 1, 1]

[0, 1, 1, 1, 1]

11、字典、 zip( )函数  :将可迭代对象组合

将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表

>>>a = [1,2,3] 

>>> b = [4,5,6] 

>>> c = [4,5,6,7,8] 

>>> zipped = zip(a,b)  # 打包为元组的列表 

[(1, 4), (2, 5), (3, 6)] 

>>> zip(a,c)                  # 元素个数与最短的列表一致 

[(1, 4), (2, 5), (3, 6)] 

>>> zip(*zipped)          # 与 zip 相反，可理解为解压，返回二维矩阵式 

[(1, 2, 3), (4, 5, 6)]

a = [ 'name' , 'age' , 'sex' ]

b = [ 'tht' , 24 , 'male' ]

c = dict ( zip (a,b))

print (c)

>>

{'name': 'tht', 'age': 24, 'sex': 'male'}

a = ['name','age','sex']

b = [ 'tht' , 24 , 'male' ]

d = list(zip(a,b))

e = tuple ( zip (a,b))

print (d)

print (e)

>>

[('name', 'tht'), ('age', 24), ('sex', 'male')]

(('name', 'tht'), ('age', 24), ('sex', 'male'))

12、sort( )函数、sorted( )函数

sort( )是可变对象(字典、列表)的方法，无参数，无返回值， sort( )会改变可变对象，因此无需返回值。sort()方法是可变对象独有的方法或者属性，而作为不可变对象如元组、字符串是不具有这些方法的，如果调用将会返回一个异常。

 a=[5,4,3,2,1]

 a.sort()

>>> [1, 2, 3, 4, 5]

 a

>>>  [1, 2, 3, 4, 5]

sorted()是python的内置函数， 并不是可变对象 (列表、字典)的特有方法，sorted()函数需要一个参数(参数可以是列表、字典、元组、字符串)，无论传递什么参数， 都将返回一个以列表为容器的返回值，如果是字典将返回键的列表。

mystring="54321"

mytuple=(5,4,3,2,1)

mylist=[5,4,3,2,1]

sorted(mystring)

>>> [1, 2, 3, 4, 5]

mystring

>>>"54321"

sorted(mytuple)

>>>[1, 2, 3, 4, 5]

sorted(mylist)

>>>[1, 2, 3, 4, 5]

reverse ( )与sort的使用方式一样，而reversed( )与sorted( )的使用方式相同

reversed( )函数是返回序列 seq 的反向访问的迭代子。参数可以是列表，元组，字符串，不改变原对象， reversed（）之后，只在第一次遍历时返回值。

>>> l=[1,2,3,4,5]

>>> ll=reversed(l)

>>> l

[1, 2, 3, 4, 5]

>>> ll

<listreverseiterator object at 0x06A9E930>

>>> for i in ll:  #第一次遍历

...     print i,

... 

5 4 3 2 1

>>> for i in ll:  #第二次遍历为空

...     print i

... 

>>> s='cba'

>>> ss=reversed(s)

>>> s

'cba'

>>> ss

<reversed object at 0x06A07E70>

>>> list(ss)   #第一次

['a', 'b', 'c']

>>> list(ss)   #第二次为空

[]

另外，还可以使用切片实现序列反转

print ( sorted ([ 1 , 2 , 3 ], reverse = True ))

w = reversed ([ 1 , 2 , 3 ])

print (w)

>>

[3, 2, 1]

<list_reverseiterator object at 0x00000000023CAAC8>

sorted( )函数

sorted(iterable[, cmp[, key[, reverse]]])

• iterable -- 可迭代对象。
• cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。