python集合、字典、运算符

python集合、字典、运算符

1.集合

创建：{} set([])  注意：创建空的集合要用set()
    特点：元素唯一，无序
    运算： & 交集  | 并集  - 差集
    方法： 
    s.add(x)     添加单个元素
    s.update()   添加多个元素
    s.remove()   移除元素
    s.clear()    清空集合

2.字典

  创建: {key:value} (大括号创建字典的键时要加引号)
        dict(key=value) （括号里赋值方式，名字=对象，不要引号）
        字典里的键和值用‘：’隔开，一对键和值组成一个项，项和项之间用‘，’隔开
  特点：
    键唯一，重复会被重新复制
    无序

    添加和取值
        cidt[key]=value  key存在则修改值，没有则添加
    属性方法
    .update({ })  在字典中添加多个项

    .items()      返回字典的各个项

    .keys()       返回字典的键

    .values()     返回字典的值

    .get(k)       如果键k在，返回键k的值，不存在则返回None

    .get(k,x)     如果键k在，返回键k的值，不存在则返回x

    .pop(k)       返回并移除键k所对应的元素，不存在则抛出异常

    .pop(k,x)     返回并移除键k所对应的元素，不存在则返回x

    总结：
        key唯一，故可以是数字，字符串，元组

总结：
    可变对象：list set dict
    不可变对象： str tuple 数值类型（int、float、bool、complex)

3.运算符

算术运算符：+ ，- ， *， /， %， **，//
    赋值运算符：= ，+=，-=， *=，/=，%=， **=
    比较运算符：==，!=， >， <， >=，<=
    成员运算符：in , not in
    身份运算符：is , is not
        判断两个名字是否指向同一个对象，当id相同时返回True(==比较运算是判断的值)
    逻辑运算符：and，or，not
        and(与) 两个条件都满足时才返回True
        or(或)  有一个条件满足了就返回True
        not(非) 取反

    计算顺序：默认地，运算符优先级表决定了哪个运算符在别的运算符之前计算。然而，如果你想要改变它们的计算顺序，你得使用圆括号
    结合规律：运算符通常由左向右结合，即具有相同优先级的运算符按照从左向右的顺序计算
'''
**                            #幂运算
+   -  *   /   %              #算术运算符
<  >  <=  >=                  #比较运算符
==  !=                        #比较运算符
=  %=  /=  -=  +=  *=  **=    #赋值运算符
is    is not                  #身份运算符
in    not in                  #成员运算符
not  >  and  > or             #逻辑运算符
'''

课后练习：

###集合字典运算符

#se={1,2,3,4}  set
se={1,2,2,4}  #去重
se={1,'a',2,'b'} #无序

#特性：唯一，无序
se=set()  #定义一个空集合

##集合的运算
se1={1,2,3};se2={2,3,4}
se1|se2  #并集   俩个集合加起来去重

se1&se2  #交集 取俩集合重复的元素

se1-se2 #差集  前面的集合减去俩个集合重复的部分

se1^se2 #与非集 取各自独立的元素



#se.add(3)  添加单个元素
se.update('456') #添加可迭代对象
se.remove('5')  #指定移除

se.pop()#随机抛出一个

##字典  唯一的映射类型    
di={'w':123,'l':456,'x':789} #dictdi={1:11,2:22} 元素只要满足键值对形式
di=dict()
di=dict(_1=123) #符合变量命名规则

#字典取值跟修改
di={'w':123,'l':456,'x':789}
di['x']
di['x']=987

#特点：无序 key唯一不可变
di.fromkeys(['a','b','c'],123)#用给定的键建立新的字典，每一个键默认对应值none（自定义）

di.get('r','我不在这里')#取值，存在就返回对应值，不存在默认返回none（可自定义）

di.items()#list(di.items()) 查看字典的每一项
di.keys()#查看字典的所有键
di.values()#查看字典的值

di.pop('w',123)#指定键，删除对应的值，如果键不存在，可以自定义返回值
di.popitem()#随机删除某一项


di.setdefault('w',123)#类似get，存在就返回值，不存在就更新到字典，对应值默认none（可以自定义）

di={'l': 456, 'x': None, 'w': 123}
di2={'p':234,'x':123}
di.update(di2) #{'l': 456, 'x': 123, 'w': 123, 'p': 234}
'''
将一个字典di2的内容添加并更新覆盖到原来的字典di
'''
#运算符
a=1;b=2
a==1 and not b==3 #True

输出结果如下：

{1, 2, 4}
{1, 2, 'b', 'a'}
set()
{1, 2, 3} {2, 3, 4}
{1, 2, 3, 4}
{2, 3}
{1}
{1, 4}
{1, 2, 3, 'a', 'b'}
{1, 2, 3, 'a', 'b', '5', '4', '6'}
{1, 2, 3, 'a', 'b', '4', '6'}
{2, 3, 'a', 'b', '4', '6'}
{'w': 123, 'l': 456, 'x': 789}
{}
{'_1': 123}
{'w': 123, 'l': 456, 'x': 789}
789
{'w': 123, 'l': 456, 'x': 987}
{'w': 123, 'l': 456, 'x': 987}
我不在这里
dict_items([('w', 123), ('l', 456), ('x', 987)])
dict_keys(['w', 'l', 'x'])
dict_values([123, 456, 987])
{'l': 456, 'w': 123}
{'l': 456, 'x': 123, 'w': 123, 'p': 234}
True

问题解答：

#1.有两个列表 x = [1,2,3,'a','b','c']  y = ['a','b','c'] 找出x列表中在y 中也有的元素
x = set([1,2,3,'a','b','c'])
y = set(['a','b','c'])
print(x&y)
#2.新建一个字典，用3种方法往字典里面插入值；用 4 种方法取出values，用2种方法取出key
dict1 = {'Alice': 2341, 'Beth': 9102, 'Cecil': 3258}
#1.
dict1.setdefault('Bob',7845)
print('1.\n',dict1)
dict1.update({'Jack':4568})
print('2.\n',dict1)
dict1['kiky']=1234
print('3.\n',dict1)
print(dict1.get('kiky'))
print(dict1['kiky'])
d1=dict1.values()
print(list(d1)[2])
print(dict1.setdefault('Bob'))
d2=dict1.keys()
print(list(d2)[2])
d3=dict1.items()
print(list(d3)[2][0])
#3.定义我们学过的每种数据类型，并且注明，哪些是可变，哪些是不可变的
value=12 #int
value1=1.2 #float
value2=True #bool
value3=1+2j #complex
print(type(value))
print('数值类型:不可变',value)
tup=(1,2,3,4,5)
print(type(tup))
print('元组类型:不可变',tup)
str1='123456'
print(type(str1))
print('字符串类型:不可变',str1)
li=[1,2,3,4]
print(type(li))
print('列表类型:可变',li)
set1=set()
print(type(set1))
print('集合类型:可变',set1)
dict1={'Jack':4568}
print(type(dict1))
print('字典类型:可变',dict1)

输出结果：

{'a', 'c', 'b'}
1.
 {'Alice': 2341, 'Beth': 9102, 'Cecil': 3258, 'Bob': 7845}
2.
 {'Alice': 2341, 'Beth': 9102, 'Cecil': 3258, 'Bob': 7845, 'Jack': 4568}
3.
 {'Alice': 2341, 'Beth': 9102, 'Cecil': 3258, 'Bob': 7845, 'Jack': 4568, 'kiky': 1234}
1234
1234
3258
7845
Cecil
Cecil
<class 'int'>
数值类型:不可变 12
<class 'tuple'>
元组类型:不可变 (1, 2, 3, 4, 5)
<class 'str'>
字符串类型:不可变 123456
<class 'list'>
列表类型:可变 [1, 2, 3, 4]
<class 'set'>
集合类型:可变 set()
<class 'dict'>
字典类型:可变 {'Jack': 4568}