# 第三节-内置数据结构

• 一个对象
• 每次能够返回x的成员
for x in rang(10):
for x in "abcdes":
for x in [0,1,2,3]:
• 用法
rang(start,stop,step=1)

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')
>>> 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 升序（默认）。

• 广告
• 抄袭
• 版权
• 政治
• 色情
• 无意义
• 其他

120