第三节-内置数据结构
可迭代对象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 升序(默认)。
阅读更多
文章标签: Python learnning
个人分类: Python
想对作者说点什么? 我来说一句

疯狂android讲义第三章3.3节

2014年07月24日 3.09MB 下载

没有更多推荐了,返回首页

不良信息举报

第三节-内置数据结构

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭