字典,元组,集合的使用

一,字典:

1.定义方式:{}内用逗号分隔开多个元素,每一个元素都是key:value的形式,value可以是任意数据类型,而key通常应该是字符串类型,但是key必须为不可变类型。否则会报错。

三种方式:

# 1.一般使用的字典方式

d1 = {'name':'jason','password':123}

# 2.关键字(键值对)方式

d2 = dict(name='jason',password=123,age=18)

# 3.列表(for循环)

l = [
    ['name','jason'],
    ['age',18],
    ['hobby','read']
]
d={}
for k ,v in l:
    d[k]=v
print(d)

# 或者直接强转
print(dict(l))

 

2.用途:存多个值,但每一个值都有一个key与之对应,key对值有描述功能。多用于存的值表示的是不同的状态时,例如存的值有姓名、年龄、身高、体重、爱好。

3.特点:

    1) .存一个值or多个值:多个值,值可以是多个类型,key必须是不可变类型,通常应该是不可变类型中的字符串类型

    2) 有序or无序:无序

    3) 可变or不可变:可变数据类型

4.常用操作和内置方法:

1)按key存取值:可存可取
2)长度len

3)成员运算in 或not in

4)删除del(可以删除字典,也可以删除字典中的元素)、pop(通过key删除值)、popitem(随机从字典中删除一个键值对)

5)键keys、值values、键值对items

6)for循环

7)get() 根据键从字典中取值

8)update() 合并两个列表

9)fromkeys() 快速生成字典

10)setdefault()

11)clear()  、copy()

 

1)按key存取值:可存可取

# dic之按key存取值
dic = {'a': 1, 'b': 2}

print(f"first dic['a']: {dic['a']}")

dic['a'] = 3

print(f"second dic['a']: {dic['a']}")

'''
first dic['a']: 1
second dic['a']: 3
'''

2) 长度len

# dic之长度len
dic = {'a': 1, 'b': 2}

print(f"len(dic): {len(dic)}")
'''
len(dic): 2
'''

3) 成员运算in 或not in

# dic之成员运算in和not in
dic = {'a': 1, 'b': 2}

print(f"'a' in dic: {'a' in dic}")
print(f"1 in dic: {1 in dic}")

'''
'a' in dic: True
1 in dic: False
'''

4) 删除del

# del,pop,popitem

dic={'name':'zhang','age':18,'gender':'male','hobby':'reading','province':'wan'}

res=dic.pop('age')
print(res)
print(dic)

res1=dic.popitem()  #随机删除一个键值对,一般删除尾部的键值对
print(res1)
print(dic)

del(dic['name'])
print(dic)
#del(dic) # 会报错
#print(dic)   # 会报错

'''
18
{'name': 'zhang', 'gender': 'male', 'hobby': 'reading', 'province': 'wan'}
('province', 'wan')
{'name': 'zhang', 'gender': 'male', 'hobby': 'reading'}
{'gender': 'male', 'hobby': 'reading'}
'''

5)键keys、值values、键值对items

# dic之键keys()、值values()、键值对items(),python2中取出的是列表(鸡蛋);python3中取出的是元组(鸡),需要用for循环取值
dic = {'a': 1, 'b': 2}

print(f"dic.keys(): {dic.keys()}")
print(f"dic.values(): {dic.values()}")
print(f"dic.items(): {dic.items()}")

'''
dic.keys(): dict_keys(['a', 'b'])
dic.values(): dict_values([1, 2])
dic.items(): dict_items([('a', 1), ('b', 2)])
'''

6) for 循环

# dic之循环
# dic是无序的,但是python3采用了底层优化算法,所以看起来是有序的,但是python2中的字典是无序
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

for k, v in dic.items():  # items可以换成keys()、values()
    print(k, v)

'''
a 1
b 2
c 3
d 4
'''

7) get (根据键从字典中取值)

# get(参数1,参数2) 取值:
'''
1.只有参数1,当字典中存在该键(key)的时候,返回对应的值(value);当字典中不存在该键(key)的时候,返回None,不会报错;
2.两个参数同时存在,当字典中存在该键(key)的时候,返回字典中对应的值(value);当字典中不存在该键(key)的时候,返回参数2(自己设定的value)
'''

dic1={'name':'zhang','age':18,'gender':'male','hobby':'reading','province':'wan'}

print(dic1.get('name'))
print(dic1.get('name','张三'))
print(dic1.get('lucky_color'))
print(dic1.get('lucky_color','blue'))

'''
zhang
zhang
None
blue
'''

8) update 

# dic之update()  更新字典
# 原字典中没有该键值对则添加,原字典中有的键值对会被新字典中的键值对覆盖,即换掉;

dic1 = {'a': 1, 'b': 2}
dic2 = {'a':2,'b':5,'c': 3}
dic1.update(dic2)
print(dic1)print(f"dic1: {dic1}")

'''
{'a': 2, 'b': 5, 'c': 3}
'''

 

 

9) fromkeys

# dic之fromkeys(参数1,参数2)
'''
fromkeys 可以传入两个参数,参数1可以是除了数字类型的任意数据类型,不传参数2,生成的字典的value都默认为None;指定了参数2,返回你指定的参数2(value)。
'''

l=['name', 'age', 'sex']
dic1 = dict.fromkeys(l, None)
dic2 = dict.fromkeys(l, '保密')
print(f"dic1: {dic1}")
print(f"dic2: {dic2}")

'''
dic1: {'name': None, 'age': None, 'sex': None}
dic1: {'name':  '保密', 'age': '保密', 'sex': '保密'}
'''

10) setdefault

# setdefault()  可以给字典新增键值对

d1 = {'name':'jason','pwd':123}
res1 = d1.setdefault('name','xxoo')  # 当键存在的情况下 不修改值 并且将原先key对应值返回给你

res2 = d1.setdefault('age',18)  # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你

print(d1,res1)
print(d1,res2)


'''
{'name': 'jason', 'pwd': 123} jason
{'name': 'jason', 'pwd': 123, 'age': 18} 18
'''

11)clear()  、copy()

#copy() 浅拷贝  clear() 清空字典

d1 = {'name':'jason','pwd':123}
print(id(d1))
d2=d1.copy()
print(id(d2))
d1.clear()
print(d1)

'''
31338432
31379816
{}
'''

 

 

二、元组

元组是不可变的列表,即元组的值不可更改,因此元组一般只用于只存不取的需求。也因此元组可以被列表取代掉,所以元组相比较列表使用的很少。元组相比较列表的优点为:列表的值修改后,列表的结构将会发生改变,而元组只需要存储,因此列表在某种程度上而言需要占用更多的内存。

1.定义:在()内可以有多个任意类型的值,逗号分隔元素

2.用途:多个装备、多个爱好、多门课程,甚至是多个女朋友

3.元组的两种定义方式:

t1=(1,2,3,4,5)
t2=tuple((1,2,3,4,5))

print('t1:',t1)
print('t2:',t2)

'''
t1: (1, 2, 3, 4, 5)
t2: (1, 2, 3, 4, 5)
'''

 

# 当元组中元素只有一个时,必须要加一个逗号,不然就只是一个普通元素

name_str = ('egon')  # ()只是普通包含的意思
name_tuple = ('egon',)

print(f"type(name_str): {type(name_str)}")
print(f"type(name_tuple): {type(name_tuple)}")

'''
type(name_str): 
type(name_tuple): 
'''

4.特点:

    1) .存一个值or多个值:多个值

    2) 有序or无序:有序

    3) 可变or不可变:不可变数据类型

 

5.内置方法的使用

1)索引取值

2)切片(顾头不顾尾,步长)

3)长度len

4)成员运算in或者not in

5)for 循环

6) count

7) index

 

1)索引取值

# tuple之索引取值

name_tuple = ('nick', 'jason', 'tank', 'sean')
# name_tuple[0] = 'nick handsom'  # 报错

print(f"name_tuple[0]: {name_tuple[0]}")

'''
name_tuple[0]: nick
'''

2)切片(顾头不顾尾,步长)

# tuple之切片

name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple[1:3:2]: {name_tuple[1:3:2]}")
'''
name_tuple[1:3:2]: ('jason',)
'''

3)长度len

# tuple之长度
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"len(name_tuple): {len(name_tuple)}")
'''
len(name_tuple): 4
'''

4)成员运算in或者not in

# tuple之成员运算
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"'nick' in name_tuple: {'nick' in name_tuple}")
'''
'nick' in name_tuple: True
'''

5)for 循环

# tuple之循环
name_tuple = ('nick', 'jason', 'tank', 'sean')

for name in name_tuple:
    print(name)
'''
nick
jason
tank
sean
'''


6) count()

# tuple之count()
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple.count('nick'): {name_tuple.count('nick')}")
'''
name_tuple.count('nick'): 1
'''

7) index()

# tuple之index()
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple.index('nick'): {name_tuple.index('nick')}")

'''
name_tuple.index('nick'): 0
'''

 

三、集合

集合可以理解成一个集合体,学习Python的学生可以是一个集合体;学习Linux的学生可以是一个集合体

pythoners = ['jason', 'nick', 'tank', 'sean']
linuxers = ['nick', 'egon', 'kevin']

# 即报名pythoners又报名linux的学生
py_li_list = []
for stu in pythoners:
    if stu in linuxers:
        py_li_list.append(stu)
print(f"pythoners and linuxers: {py_li_list}")

'''
pythoners and linuxers: ['nick']
'''

1.用途:用于关系运算的集合体,由于集合内的元素无序且集合元素不可重复,因此集合可以去重,但是去重后的集合会打乱原来元素的顺序

2.定义:{}内用逗号分隔开多个元素,每个元素必须是不可变类型。

字典,元组,集合的使用_第1张图片

3.集合的元素遵循三个原则:
  1) 每个元素必须是不可变类型

  2) 没有重复的元素

  3) 无序

4.特点:

  1)存一个值or多个值:多个值,且值为不可变类型;

  2)有序or无序:无序

  3)可变or不可变:可变数据类型

5.常用操作+内置方法

1)长度len

2)成员运算in 或者 not in

3)|并集、union

4)&交集、intersection

5)-差集、difference

6)^对称差集、symmetric_difference

7)父集:>、>= 、issuperset

8)子集:<、<= 、issubset

9) add

10) pop、remove、discard、clear

11)update

12)copy 浅拷贝

 

1)长度len

# set之长度len
s = {1, 2, 'a'}

print(f"len(s): {len(s)}")
'''
len(s): 3
'''

2)成员运算in 或者 not in

# set之成员运算in和not in
s = {1, 2, 'a'}

print(f"1 in s: {1 in s}")
'''
1 in s: True
'''

 

字典,元组,集合的使用_第2张图片

 

3)|并集、union

# str之|并集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners|linuxers: {pythoners|linuxers}")
print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")

'''
pythoners|linuxers: {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
pythoners.union(linuxers): {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
'''

4)&交集、intersection

# str之&交集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners&linuxers: {pythoners&linuxers}")
print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")

'''
pythoners&linuxers: {'nick'}
pythoners.intersection(linuxers): {'nick'}
'''

 

5)-差集、difference

# str之-差集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners-linuxers: {pythoners-linuxers}")
print(f"pythoners.difference(linuxers): {pythoners.difference(linuxers)}")
'''
pythoners-linuxers: {'tank', 'jason', 'sean'}
pythoners.difference(linuxers): {'tank', 'jason', 'sean'}
'''

6)^对称差集、symmetric_difference

# str之^对称差集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners^linuxers: {pythoners^linuxers}")
print(
    f"pythoners.symmetric_difference(linuxers): {pythoners.symmetric_difference(linuxers)}")

'''
pythoners^linuxers: {'egon', 'tank', 'kevin', 'jason', 'sean'}
pythoners.symmetric_difference(linuxers): {'egon', 'tank', 'kevin', 'jason', 'sean'}
'''

7) 父集:>、>= 、issuperset

# str之父集:>、>=
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(f"pythoners>linuxers: {pythoners>linuxers}")
print(f"pythoners>=linuxers: {pythoners>=linuxers}")
print(f"pythoners>=javaers: {pythoners>=javaers}")
print(f"pythoners.issuperset(javaers): {pythoners.issuperset(javaers)}")

'''
pythoners>linuxers: False
pythoners>=linuxers: False
pythoners>=javaers: True
pythoners.issuperset(javaers): True
'''

8)子集:<、<= 、issubset

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(f"pythoners")
print(f"pythoners<=linuxers: {pythoners<=linuxers}")
print(f"javaers.issubset(pythoners): {javaers.issubset(pythoners)}")

'''
pythoners'''

9) add()

# set之add()
s = {1, 2, 'a'}
s.add(3)

print(s)
'''
{1, 2, 3, 'a'}
'''

 

10) pop、remove、discard、clear

s1={1,2,'a'}
s1.pop()  # 随机删除一个元素
s1.remove(1) # 指定要删除的元素
s1.remove('b')  # 删除不存在的元素,报错
s1.discard('a') # 指定要删除的元素
s1.discard('b') # 删除没有的元素,不报错,仍然返回原集合
s1.clear()  # 清空集合,返回空集合 set()
print(s1)

 

11)update

s1={1,2,'a'}
s2={4,'a'}
s1.update(s2)
print(s1)

'''
{1, 2, 'a', 4}
'''

12)copy

s1={1,2,'a'}
print(s1,id(s1))
s2=s1.copy()
print(s2,id(s2))

'''
s1: {1, 2, 'a'} 167312520
s2: {1, 2, 'a'} 167311400
'''

 

转载于:https://www.cnblogs.com/zhangchaocoming/p/11530532.html

你可能感兴趣的:(字典,元组,集合的使用)