可迭代对象：列表、字符串、元组

列表（list []）的“魔法”

　　定义

　　　　列表是一种类，中括号把数据元素（可以是数字、字符串、列表、布尔值...）括起来，用逗号作分割符。　　有序，元素可被修改。

　　特性

　　　　深灰“魔法”

　　　　——可索引（下标）取值；

　　　　——可切片，切片结果也是列表；

　　　　　　　　li=[1,12,9,'age','alex']　　#通过list类创建的对象，li

　　　　　　　　li[1:3]=[120,90]

　　　　　　　　输出

　　　　　　　　　　[1,120,90,'age','alex']

　　　　——支持in操作

　　　　——支持for/while循环。

　　　　——可嵌套

　　　　　　　　查找嵌套列表的元素可在[]后再加[]

　　　　——列表元素可以被修改

　　　　　　　　li[1]=2

　　　　　　　　li[2]=9

　　　　　　　　输出

　　　　　　　　　　[1,2,9,'age','alex']

　　　　——列表元素可以删除

　　　　　　　　...

　　　　　　　　del li[1]

　　　　　　　　输出

　　　　　　　　　　[1,9,'age','alex']

　　　　　　　　del li[1:3]

　　　　　　　　输出

　　　　　　　　　　[1,'alex']

　　　　——字符串转列表，用list()

　　　　　　　　s='abcdf'

　　　　　　　　new_s=list(s)

　　　　　　　　print(new_s)

　　　　　　　　输出

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

　　　　——列表转字符串

　　　　　　　　'''　　li=[11,22,33,'123','alex']　　

　　　　　　　　　　  r=str(li)

　　　　　　　　　　  print(r)　　#输出‘[11,22,33,'123','alex']’　　'''

　　　　　　1.既有数字，又有字符串，写for循环依次处理

　　　　　　　　for i in li:

　　　　　　　　　　s=s+srt(i)

　　　　　　　　print(s)

　　　　　　2.只有字符串，使用join

　　　　　　　　li=['123','alex']

　　　　　　　　v=''.join(li)

　　　　　　　　print(v)

　　　　　　　　输出

　　　　　　　　　　123alex

　　灰“魔法”——list类中提供的方法

　　　　- append（原来值最后追加，对列表本身进行修改，而非像字符串一样，创建一个新变量添加元素）

　　　　- clear（清空列表，使列表变成[]）

　　　　- copy（（浅）拷贝）

　　　　　　li=[11,22,33,44]

　　　　　　v=li.copy

　　　　　　print(v)

　　　　　　输出

　　　　　　　　[11,22,33,44]

　　　　- count（计算元素出现的次数）

　　　　- extend（扩展源列表）

 　　　　　　li=[11,22,33,44]

　　　　　　li.extend([9898,'不得了'])　　#相当于执行了for循环

　　　　　　print(li)

　　　　　　'''　　li.append([9898,'不得了'])　　#整体放进去

　　　　　　　　  print(li)　　'''

　　　　　　'''　　li.extend('不得了')

　　　　　　　　  print(li)　　'''

　　　　　　输出

　　　　　　　　[11,22,33,44.9898,‘不得了’]

　　　　　　　　'''　　[11,22,33,44,[9898,‘不得了’]]　　'''

　　　　　　　　'''　　[11,22,33,44,‘不','得','了’]　　'''

　　　　- index（根据值获取当前值索引位置，左边优先）

　　　　　　li=[11,22,33,44]

　　　　　　v=li.index(22)

　　　　　　print(v)

　　　　　　输出

　　　　　　　　1

　　　　- insert（在指定索引位置插入元素）

　　　　　　li=[11,22,33,44]

　　　　　　li.insert(0,99)

　　　　　　print(li)

　　　　　　输出

　　　　　　　　[99,11,22,33,44]

　　　　- pop （删除某个值{默认最后的值}，并获取删除的值）; - remove（删除列表中的指定值，左边优先）

　　　　　　li=[11,22,33,44]

　　　　　　v=li.pop()

　　　　　　print(v)

　　　　　　print(li)

　　　　　　v1=li.pop(1)

　　　　　　print(v1)

　　　　　　print(li)

　　　　　　输出

　　　　　　　　44

　　　　　　　　[11,22,33]

　　　　　　　　22

　　　　　　　　[11,33]

　　　　　　li=[11,22,33,22,44]

　　　　　　li.remove(22)

　　　　　　print(li)

　　　　　　输出

　　　　　　　　[11,33,22,44]

p.s.　　删除操作 pop / remove / del li[0] / del li[7:9] / clear

　　　　- reverse（将当前列表进行反转）

　　　　　　li=[11,22,33,22,44]

　　　　　　li.reverse()

　　　　　　print(li)

　　　　　　输出

　　　　　　　　[44,22,33,22,11]

　　　　- sort

　　　　　　li=[11,44,22,33,22]

　　　　　　li.sort()

　　　　　　print(li)

　　　　　　li.sort(reverse=True)

　　　　　　print(li)

　　　　　　输出

　　　　　　　　[11,22,22,33,44]

　　　　　　　　[44,33,22,22,11]

p.s. - cmp ; - key 涉及函数，lambda表达式　　内置函数sorted 函数处补充

元组tuple

　　圆括号括元素，元素的一级元素不可被修改，不能被增加或者删除。一般写元祖的时候，推荐最后加逗号，不影响元组长度，逗号后面是空的。　　有序。

　　特性

　　　　——可索引

　　　　　　tu=(111,'alex',(11,22),[(33,44)],True,33,44,)

　　　　　　v=tu[0]

　　　　　　print(v)

　　　　　　输出

　　　　　　　　111

　　　　——可切片

　　　　　　...

　　　　　　v=tu[0:2]

　　　　　　print(v)

　　　　　　输出

　　　　　　　　(111,'alex')

　　　　——不可修改、增加或删除

　　　　——可for循环，是可迭代对象

　　　　——字符串/列表/元组可相互转换

　　　　　　s='asdfasdf0'

　　　　　　li=['asdf',1231]

　　　　　　tu=(123,123,'asdf')

　　　　　　tu1=('asdf','asdf')

　　　　　　v=tuple(s)

　　　　　　print(v)

　　　　　　v=tuple(li)

　　　　　　print(v)

　　　　　　v=list(tu)

　　　　　　print(v)

　　　　　　v='_'.join(tu1)

　　　　　　print(v)

　　　　　　输出

　　　　　　　　('a','s','d,'f','a','s','d,'f','0')

　　　　　　　　('asdf',1231)

　　　　　　　　[123,123,'asdf']

　　　　　　　　asdf_asdf

　　　　——二级或更高级元素可修改

　　　　　　tu=(111,'alex',(11,22),[(33,44)],True,33,44,)

　　　　　　tu[3][0]=567

　　　　　　print(tu)

　　　　　　输出

　　　　　　　　(111,'alex',(11,22),[567],True,33,44,)

　　两个方法

　　　　- count 获取指定元素在元组中出现的次数

　　　　- index 获取指定元素在元组中第一次出现的索引值

字典dict

　　字典的value可以是任何值；字典的key不能是布尔值、列表和字典。　　字典无序，因为无序所以没有系统生成的索引，通过键来找值。

　　info={

　　　　'k1':18,　　#键值对

　　　　'k2':True

　　　　'k3’:[

　　　　　　11,

　　　　　　[],

　　　　　　()

　　　　　　22,

　　　　　　33,

　　　　　　{

　　　　　　　　'kk1':'vv1',

　　　　　　　　'kk2':'vv2',

　　　　　　　　'kk3':(11,22),　　#找这里的第一个元素 v=info['k3'][5]['kk3'][0]

　　　　　　}

　　　　]

　　　　‘k4’:(11,22,33,44)

　　　　 }

　　　　info1={

　　　　　　1:'asdf',

　　　　　　'k1':'asdf',

　　　　　　True:'123',

　　　　　　[11,22]；123,

　　　　　　(11,22):123,

　　　　　　{'k1:v1'}:123,

　　　　}

　　　　print(info1)

　　　　输出

　　　　　　{'k1':'asdf',1:'123',(11,22):123}

　　　　　　True 1 False 0 这里True和键1重复了 key重复时只能保留一个

　　　　　　布尔值、列表和字典（涉及到哈希表）不能作为字典的key，常数、元组可以

　　　　　　（列表或字典若作为key会报错）

　　特性

　　　　——通过键来找值

　　　　——不可切片

　　　　——支持del删除 键值对　　del info['k1']　　del info['k3'][5]['kk1']

　　　　——默认for循环输出里面元素，只输出key

　　　　　　　　for item in info{.keys}()

　　　　　　for item in info.values()　　输出value

　　　　　　for k,v in info.items()　　输出key和value

　　　　——while循环不太好用，key不是常规索引

　　方法

　　　　- fromkeys

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 v=dict.fromkeys(['k1',123,'999'])
4 v1=dict.fromkeys(['k1',123,'999'],123)
5 print(v,v1)

　　　　输出

　　·　　　　{'k1': None, 123: None, '999': None} {'k1': 123, 123: 123, '999': 123}

　　　　- get

1 ...
2 dic={'k1':'v1'}
3 v=dic.get('k1')
4 print(v)
5 v=dic.get('kk1')
6 print(v)
7 v=dic.get('kk1',111)    #第一个数是想获取的key，
8 print(v)                #如果不存在结果为第二个值，
9                         #如果存在则获取其对应value

　　　　输出

　　　　　　v1

　　　　　　None

　　　　　　111

　　　　- pop（如果要删除的键值对不存在，dic.pop(key,default）返回default的值）; - popitem（随机删除一个键值对，dic.popitem()）

1 ...
2 dic={'k1':'v1','k2':'v2'}
3 v=dic.pop('k1')
4 print(dic,v)

　　　　输出

　　　　　　{'k2': 'v2'} v1

　　　　- setdefault（设置值，如果已经存在则不设置，获取当前key对应的value；不存在，设置，获取当前key对应的value）

1 ...
2 dic={'k1':'v1','k2':'v2'}
3 v=dic.setdefault('k1','123')
4 print(dic,v)
5 dic={'k1':'v1','k2':'v2'}
6 v=dic.setdefault('k111','123')
7 print(dic,v)

　　　　输出

　　　　　　{'k1': 'v1', 'k2': 'v2'} v1

　　　　　　{'k1': 'v1', 'k2': 'v2', 'k111': '123'} 123

　　　　- update

1 ...
2 dic={'k1':'v1','k2':'v2'}
3 dic.update({'k1':'111','k3':123})
4 print(dic)
#另一种写法：dic.update(k1=123,k3=345,k5='asdf')
　　输出{'k1': 123, 'k5':'asdf','k2': 'v2', 'k3': 345}

　　　　输出

　　　　　　{'k1': '111', 'k2': 'v2', 'k3': 123}

整理

　　一、数字

　　　　int()

　　二、字符串

　　　　replace / find / join / strip / startswith / split / upper / lower / format

　　　　**kwargs 代表 可以传 key=value 或者 传字典 **{}

1 ...
2 template='I am {name},age:{age}'
3 v=template.format(name='alex',age=19)
4 #v=template.format(**{'name':'alex','age':19})  和上面的一样效果
5 print(v)

　　　　输出

　　　　　　I am alex,age:19

　　三、列表

　　　　append / extend / insert

　　　　索引、切片、循环

　　四、元组

　　　　忽略

　　　　索引、切片、循环　　以及元素不能被修改

　　五、字典

　　　　get / update / keys / values / items

　　　　for，索引

　　　　列表元组字符串字典可做in操作

1 ...
2 dic={'k1':'v1','k2':'v2'}
3 v='k1' in dic
4 print(v)

　　　　输出

　　　　　　True

　　六、布尔值

　　　　本身内存里就是0或1

　　　　bool(...)

　　　　None '' 0 {} [] () 都是假的

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有