python 遍历内嵌tuple_python常用内置方法

列表类型

类型转换：但凡能被for循环遍历的类型都可以当作参数传给list()转换成列表

例如：

res = list("hello")

print(res)

['h', 'e', 'l', 'l', 'o']

# 内置方法

1,按照索引存取值(正向存取+反向存取)：即可以取也可以改

l = [111,'zyl','wyy']

l[0] = 222

print(l) # 可以取也可以改，索引存在则修改对应的值

l = [222,'zyl','wyy']

但是无论取值操作还是赋值操作：索引不存在则报错

如果想要在列表中追加值

l.append('yy')

print(l) # .append在列表末尾追加一个值

l = [222,'zyl','wyy','yy']

如果想在某一位置在列表中插入值

l.insert(0,'zz')

print(l) # .insert在列表中按索引位置插入值

l = ['zz',222,'zyl','wyy','yy']

如果想让两个列表的值放在一起

l = [111,'zyl','wyy']

ll = [1,2,3]

l.extend(ll)

print(l) # .extend在类表中添加另外一个列表

[111, 'zyl', 'wyy', 1, 2, 3]

删除列表中的值

方法一：

del l[0]

print(l) # del 删除索引中的值

方法二：

l.pop() # 根据索引删除列表中的值，不指定索引，默认删除最后一个

pop方法会返回一个你删除的元素

res = l.pop()

print(res)9

print(l)

方法三：

remove根据元素删除 返回None

l.remove('zyl')

print(l)

计算列表中元素个数

l.len()

查看列表中元素出现的次数

l.count()

查找列表中元素所在的索引。没有报错

l.index()

清空列表中所有的元素

l.clear() # ()内不用传值

将列表中元素倒过来

l.reverse() # ()也不用传值，不是排序就是将列表倒过来

将列表中元素排序 ，列表中必须是同种类型才可以排序

l.sort() 默认从小到大排序

l.sort(reverse=True) # 从大到小排序，设置为降序

元组类型

# 元组就是一个”一个不可变的列表“

# 1，作用：按照索引位置存放多个值，只用于读不用于改

# 2，定义：()内用逗号分隔开多个任意类型的元素

t =(1,1.1,'zyl',[111,222],{'name':'wyy'})

print(t,type(t))

(1, 1.1, 'zyl', [111, 222], {'name': 'wyy'})

如果元组内只有一个元素，必须加逗号

t(1,)

print(t)

元组不能更改，但是可以改元组里面列表和字典的值

例如

t =(1,1.1,'zyl',[111,222],{'name':'wyy'})

t[3][0] = 555

t[4][0] = 'aaa'

print(t,type(t))

(1, 1.1, 'zyl', [555, 222], {'name': 'wyy', 0: 'aaa'})

(参考深浅拷贝)

类型转换：

print(tuple("hellp"))

print(tuple([1,2,3]))

print(tuple({"a":111,"b":222}))

('h', 'e', 'l', 'l', 'p')

(1, 2, 3)

('a', 'b')

内置方法

# 查长度

len()

# 索引取值

t = ('zyl', 'wyy', 'yy', 'zz')

print(t[0])

zyl

# 切片(顾头不顾尾，步长)

t = ('zyl', 'wyy', 'yy', 'zz')

print(t[1:3:2])

('wyy',)

# 成员运算

t = ('zyl', 'wyy', 'yy', 'zz')

print('zyl' in t) # zyl在不在t元组中

True

# 循环

t = ('zyl', 'wyy', 'yy', 'zz')

for name in t:

print(name)

zyl

wyy

yy

zz

# count() 查看列表中元素出现的次数

t = ('zyl', 'wyy', 'yy', 'zz')

print(t.count('zyl'))

1

# index() 查找列表中元素所在的索引。没有报错

t = ('zyl', 'wyy', 'yy', 'zz')

print(t.index('zyl'))

0

字典类型

字典类型：

# 作用：存信息，比如年龄，姓名，体重等

# 定义{}内用逗号分隔开多个key：value，其中value可以使任意类型，但是key必须是不可变类型

d = {"age":18}

print(d['age'])

18

d ={} 默认定义出来的是空字典

# 数据类型转换

# 1、按key存取值：可存可取

# 1.1 取

>>> dic = {

'name': 'xxx',

'age': 18,

'hobbies': ['play game', 'basketball']

}

>>> dic['name']

'xxx'

>>> dic['hobbies'][1]

'basketball'

# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value

>>> dic['gender'] = 'male'

>>> dic{'name': 'xxx', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}

# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值

>>> dic['name'] = 'zyl'

>>> dic{'name': 'zyl', 'age': 18, 'hobbies': ['play game', 'basketball']}

# 2、长度len

>>> len(dic)

3

# 3、成员运算in和not in

>>> 'name' in dic # 判断某个值是否是字典的key

True

# 4、删除

>>> dic.pop('name') # 通过指定字典的key来删除字典的键值对

>>> dic{'age': 18, 'hobbies': ['play game', 'basketball']}

# 5、键keys()，值values()，键值对items()

>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}

# 获取字典所有的key

>>> dict_keys = dic.keys()

>>> print(dict_keys)

dict_keys(['age', 'hobbies', 'name'])

# 获取字典所有的value

>>> dic.values()

>>> dict_values = dic.values()

>>> print(dict_values)

dict_values(['xxx', 18, ['play game', 'basketball']])

# 获取字典所有的键值对

>>> dic.items()

dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

# 6、循环

# 6.1 默认遍历的是字典的key

>>> for key in dic:

... print(key)

...

age

hobbies

name

# 6.2 只遍历key

>>> for key in dic.keys():

... print(key)

...

age

hobbies

name

# 6.3 只遍历value

>>> for key in dic.values():

... print(key)

...

18

['play game', 'basketball']

xxx

# 6.4 遍历key与value

>>> for key in dic.items():

... print(key)

...

('age', 18)

('hobbies', ['play game', 'basketball'])

('name', 'xxx')

1.get()

>>> dic= {'k1':'zyl','k2':'wyy','k3':'yy'}

>>> dic.get('k1')

'zyl' # key存在，则获取key对应的value值

>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None

>>> print(res)

None

>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值

>>> print(res)

666

# ps:字典取值建议使用get方法

2.pop()

>>> dic= {'k1':'zyl','k2':'wyy','k3':'yy'}

>>> v = dic.pop('k2') # 删除指定的key对应的键值对,并返回值

>>> print(dic)

>>> print(v)

>>> {'k1': 'zyl', 'k3': 'yy'}

>>> wyy

3.popitem()

>>> dic= {'k1':'zyl','k2':'wyy','k3':'yy'}

>>> item = dic.popitem() # 随机删除一组键值对,并将删除的键值放到元组内返回

>>> print(dic)

>>> print(item)

{'k1': 'zyl', 'k2': 'wyy'}

('k3', 'yy')

4.update()

# 用新字典更新旧字典，有则修改，无则添加

>>> dic= {'k1':'zyl','k2':'wyy','k3':'yy'}

>>> dic.update({'k1':'zy','k4':'xxx'})

{'k1': 'zy', 'k2': 'wyy', 'k3': 'yy', 'k4': 'xxx'}

5.fromkeys()

>>> dic = dict.fromkeys(['k1','k2','k3'],[]) # # 跟[]，则value值为[],不跟，默认是None

>>> print(dic)

{'k1': [], 'k2': [], 'k3': []}

6.setdefault()

# key不存在则新增键值对，并将新增的value返回

>>> dic={'k1':111,'k2':222}

>>> res=dic.setdefault('k3',333)

>>> print(res)

333

>>> print(dic) # 字典中新增了键值对

{'k1': 111, 'k2': 222, 'k3': 333,}

# key存在则不做任何修改，并返回已存在key对应的value值

>>> dic={'k1':111,'k2':222}

>>> res=dic.setdefault('k1',666)

>>> print(res)

111

>>> print(dic) # 字典不变

{'k1': 111, 'k2': 222}

集合类型

集合也可以存放多个值，但主要用于：去重、关系运算

"""

定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：

1：每个元素必须是不可变类型

2：集合内没有重复的元素

3：集合内元素无序

"""

s = {1,2,3,4} # 本质 s = set({1,2,3,4})

""""""

注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?

d = {} # 默认是空字典

s = set() # 这才是定义空集合

""""""

# 类型转换

但凡能被for循环的遍历的数据类型(强调：遍历出的每一个值都必须为不可变类型)都可以传给set()转换成集合类型

>>> s = set([1,2,3,4])

>>> s1 = set((1,2,3,4))

>>> s2 = set({'name':'zyl',})

>>> s3 = set('zyl')

>>> s,s1,s2,s3

{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'z', 'y', 'l'}

# 关系运算

我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算

friends1 = {"zyl","wyy","yy","zz"}

friends2 = {"fzf","zht","yy","zz"}

# 1.合集(|)：求两个用户所有的好友(重复好友只留一个)

print(friends1 | friends2)

{'yy', 'fzf', 'zht', 'wyy', 'zz', 'zyl'}

# 2.交集(&)：求两个用户的共同好友

print(friends1 & friends2)

{'yy', 'zz'}

# 3.差集(-)：

print(friends1 - friends2) # friends1独有的好友

{'zyl', 'wyy'}

print(friends2 - friends1) # friends2独有的好友

{'zht', 'fzf'}

# 4.对称差集(^) # 去掉共有的好友

print(friends1 ^ friends2)

{'fzf', 'zyl', 'wyy', 'zht'}

# 5.值是否相等(==)

print(friends1 == friends2)

False

# 6.父集：一个集合是否包含另外一个集合

# 6.1 包含则返回True

print({1,2,3} > {1,2})

True

# 6.2 不存在包含关系，则返回False

print({1,2,3} > {1,3,4,5})

False

# 7.子集

print({1,2} < {1,2,3})

True

print({1,2} <= {1,2,3})

True

集合去重

# 1. 只能针对不可变类型

# 2. 集合本身是无序的，去重之后无法保留原来的顺序

例如：

l = ['a', 'b', 1, 'a', 'a']

s=set(l) # 将列表转成了集合

print(s)

{1, 'a', 'b'} # 将重复的a去除，排列无序

l_new=list(s) # 再将集合转回列表

print(l_new)

['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如

l=[

{'name':'zyl','age':18,'sex':'male'},

{'name':'wyy','age':16,'sex':'male'},

{'name':'yy','age':20,'sex':'female'},

{'name':'aa','age':18,'sex':'male'},

{'name':'aa','age':18,'sex':'male'},

]

new_l=[]

for dic in l:

if dic not in new_l:

new_l.append(dic)

print(new_l)

[{'name': 'zyl', 'age': 18, 'sex': 'male'},

{'name': 'wyy', 'age': 16, 'sex': 'male'},

{'name': 'yy', 'age': 20, 'sex': 'female'},

{'name': 'aa', 'age': 18, 'sex': 'male'}]

# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重

打赏

微信扫一扫，打赏作者吧～