python基础-集合、字典、运算符

1.集合

#创建：{} set([])  注意：创建空的集合要用set()
#特点：元素唯一，无序，可变
#定义空集合  s=set()

>>> se={1,2,3,3,4}
>>> se
{1, 2, 3, 4}

>>> se={1,2,3,"d",4}
>>> se
{1, 2, 3, 4, 'd'}

>>> se=set([1,2,3])
{1, 2, 3}

# 运算：
>>> se1={1,2,3,4,5}
>>> se2={4,5,6,7,"a"}

# & 交集 
>>> se1&se2
{4, 5}

# | 并集
>>> se1|se2
{1, 2, 3, 4, 5, 6, 7, 'a'}

#  - 差集
>>> se1 -se2  #se1减去公开的数据
{1, 2, 3}

# ^ 与非 
>>> se1^se2  #se1和se2并集然后去掉重复部分
{1, 2, 3, 6, 7, 'a'}

# 方法： 
>>> se1={1,2,3,4,5}

# s.add(x)    添加单个元素
>>> se1.add(6)
{1, 2, 3, 4, 5, 6}

# s.update()  添加多个元素 ,必须是可迭代对象
>>> se1.update("dd")
>>> se1
{1, 2, 3, 4, 5, 'd'}

# s.remove()  移除元素
>>> s.remove(1)
{2, 3, 4, 5, 'd'}

# s.clear()    清空集合
>>> se1.clear()
set()

#  pop随机弹出
>>> se1.pop
1

#强制类型转换
#数字类型
>>> a=int(1.1)
>>> b=float(1)
>>> c=bool(0) #非0就是True，其他都是False
>>> d=complex(2)

#可迭代强制转换
>>> li=[1,2,3]
>>> li1=(1,2,3)
>>> li2="abc"
>>> li3="abc"

#集合取值，强制类型转换成list
>>> a=set(li)

#系列转元组

>>> a=list(l12)

2.字典

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

#定义字典有两种方式：
第一种：
#定义空字典  s={}
>>> li={"a":1}  
第二种：需要符合命名规范
>>> li=dict(a=2)

#添加和取值
     cidt[key]=value  key存在则修改值，没有则添加
    li={(1,2,3):2}
    >>> li[3]=3  #key存在则修改值，没有则添加
    {(1, 2, 3): 3, 3: 3}

    属性方法
    >>> li={"a":2,"b":3,"c":4}

    #.update({ })  在字典中添加多个项，更新的必须是字典，如果有更新，没有添加值
    >>> li.update({"e":1,"a":10})

    #.items()      返回字典的各个项
     >>> li.items()
    dict_items([('a', 2), ('b', 3), ('c', 4)])

    #.keys()      返回字典的键
    >>> li.keys()
    dict_keys(['a', 'b', 'c'])

    #.values()    返回字典的值
    >>> li.values()
    dict_values([2, 3, 4])

    #.get(k)      如果键k在，返回键k的值，不存在则返回None
    #.get(k,x)    如果键k在，返回键k的值，不存在则返回x
    >>> li.get("d","not found")
    'not found'

    #.pop(k)      返回并移除键k所对应的元素，不存在则抛出异常
    >>> li.pop("d")
    #.pop(k,x)    返回并移除键k所对应的元素，不存在则返回x
    >>> li.pop("d","not found")  #容错处理

    #.popitem()      随机弹出一个元素
    >>> li.popitem()
    ('c', 4)

    #.clear()  清除元素
    >>> li.clear()
    {}

    #.copy()  清除元素
    >>> li.copy()
    {'a': 2, 'b': 3, 'c': 4}

    #.fromkeys()  清除元素
    >>> li2=li.fromkeys("a",2)  #批量生成
    {'a': 2}

    #.setdefault() 里面有元素不做处理，没有元素添加一个值
    >>> li.setdefault("a",12)

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


总结：
    可变对象：list set dict
    不可变对象： str tuple

3.运算符

#算术运算符：+ ，- ， *， /， %， **，//
#赋值运算符：= ，+=，-=， *=，/=，%=， **=
#比较运算符：==，!=， >， <， >=，<=
#成员运算符：in , not in
>>> li=["a","b","c"]
>>> "a" in li
True

#身份运算符：is , is not
>>> a=1
>>> b=1
>>> a is b
True
>>> a is not b
False

        判断两个名字是否指向同一个对象，当id相同时返回True(==比较运算是判断的值)
#逻辑运算符：and，or，not

        >>> a=1
        >>> b=1
        and(与) 两个条件都满足时才返回True
        >>> a==1 and b==2
        False

        or(或)  有一个条件满足了就返回True
        >>> a==1 or b==2
        True

        not(非) 取反
        >>> not a==1
        False

    计算顺序：默认地，运算符优先级表决定了哪个运算符在别的运算符之前计算。然而，如果你想要改变它们的计算顺序，你得使用圆括号

    结合规律：运算符通常由左向右结合，即具有相同优先级的运算符按照从左向右的顺序计算
'''                           
**                            #幂运算
+  -  *  /  %              #算术运算符
<  >  <=  >=                  #比较运算符
==  !=                        #比较运算符
=  %=  /=  -=  +=  *=  **=    #赋值运算符
is    is not                  #身份运算符
in    not in                  #成员运算符
not  >  and  > or            #逻辑运算符
'''