---

  1、集合（set）

创建：{}  set([])

注意：创建空的集合要用set()，{}这个表示的是一个空字典

特点：元素唯一，无序，可变

运算： & 交集 | 并集 - 差集

方法： 

s.add(x) 添加单个元素

s.update() 添加多个元素

s.remove() 移除元素

s.clear() 清空集合

example：

 

se = {1,2,3,4}

se2 = {1,2,3,3,4}

se3 = {1,2,3,'d',4}

#se2[0]   因为集合是无序，所以不能索引

 

#set（）,相当于强制类型转换

se5 = set([1,2,3])

li = [1,2]

#se6 = {'a',li} #可变对象，不能成为集合的元素，破坏唯一性

 

 

###集合的运算  并  交  差 与非^

se1 ={1,2,3,4,5}

se2 = {4,5,6,7,'a'}

se1 | se2  #将两个 集合，拼接到一起，去掉重复部分

se1 | se2 | se3

 

se1 & se2  #取出相同部分

 

se1 - se2  #减去两个集合 共有的部分

 

se1 ^ se2  # 首先相等于将俩个集合并，然去掉重复部分

 

#集合常用方法

se.add(5)

se.clear() 

se.update(['a','b','c','d']) #同时可以添加多元素,

se.update((1,2,3,4))  #必须是可迭代对象

se.update('wsx')

#se.remove('jia')  #移除指定元素

se.pop()   #由于集合无序的，所以 pop 是随机弹出

 

# 空集合

s = set()

 

# 集合取值

se = list(se)   #可以转成list，然后用索引

se[0]

 

#集合 是可变的

se ={1,2,3}

se.add('jianeng')

 

---

  2、强制类型转换

 

a = int(1.1)

b = float(1)

 

c = bool(0)

c = bool(1)

 

d = complex(2)

 

li =[1,2,3]

tu =(1,2,3)

s ='abc'

 

li = list(tu)

li =list(s)

#li = list(1)  必须是可迭代对象

 

tu = tuple(li)

tu = tuple(s)

#tu = tuple(1) 必须是可迭代对象

 

s =str(li)   #"['a', 'b', 'c']"

s = str(tu)  #"('a', 'b', 'c')"   

s = str(1)

 

---

  3、字典

 

创建: {key:value} (大括号创建字典的键时要加引号)

dict(key=value) （括号里赋值方式，名字=对象，不要引号）

字典里的键和值用‘：’隔开，一对键和值组成一个项，项和项之间用‘，’隔开

特点：

键值唯一，重复会被重新复制、无序、可变

 

添加和取值

dict[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

example:

 

# di[0]  无序 

di ={'a':2,'b':3,'c':4,'a':1} # key  唯一

#di6 = {li:55,'a':1} # key不可变的

 

#两种定义方式

di5 = {'a':1}

di3 = {1:2}

 

# 符合，命名规范 

di2 = dict(a = 1)

#di4 = dict(1 =2)

 

##字典取值,通过key

di['a']

 

##添加，修改。没有就添加，有就修改

di['a'] =10

di['jianeng'] = 'jianeng'

di['jianeng'] = 5

 

####字典的自带方法

#di.clear()

di2 = di.copy()  #生成一个新的对象

di.fromkeys('asd')

di.fromkeys('asd',2)  

 

di.get('a')

di.get('d','not find')

 

di.items() #返回每一个键值对

list(di.items()) 

list(di.items())[0]

 

di.keys()

list(di.keys())

 

di.pop('a')   #指定弹出

di.pop('w','not find') #如果没有‘w’,就返回‘not find’

 

di.popitem() #随机弹出

 

di.setdefault('b',12)  #有，就你返回原来的value

di.setdefault('a',12)  #没有，就添加

 

di.update({'a':10,'jianeng':'jianeng'}) #有，就更新。没有，就添加

 

di.values()

list(di.values())

 

---

  4、运算符

 

算术运算符：+ ，- ， *， /， %， **，//

    赋值运算符：= ，+=，-=， *=，/=，%=， **=

    比较运算符：==，!=， >， <， >=，<=

    成员运算符：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             #逻辑运算符

'''

---

Python基本数据类型：https://www.songqinnet.com/article/966

Python序列类型各自方法：https://www.songqinnet.com/article/970

Python字符串拼接和格式化输出：https://www.songqinnet.com/article/973

Python集合、字典及运算符：https://www.songqinnet.com/article/975

Python条件与循环语句：https://www.songqinnet.com/article/978

Python函数基础：https://www.songqinnet.com/article/981

 

---