python集合、元组、字典

主要内容：

2、集合

3、元组

4、字典

复习:

　　字符串和元组一样，只能读不能写。列表和字典可以嵌套任何东西，列表可以嵌套列表

　　l = list("hello")  # l = ['h', 'e', 'l', 'l', 'o']

　　集合、字典是无序的；列表、元组、字符串是有序的

　　集合、字典、列表是可以修改的；元组、字符串、数字是不能修改的

　　for 语句中的else 语句，意思是for中的循环结束后，再走else中的代码，字典中的键就相当于列表可中索引的数字

集合

　　集合是可修改的无序的不重复的序列，集合使用花括号{}

　　主要作用

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

创建集合

　　语法：set(可迭代对象)

　　创建空集合：s = set()

s = set([3,4,5,6,7])    #创建一个数字集合{3, 4, 5, 6, 7}
w = set([2,3,4])
t = set("hello")# 遍历字符串中的每个字符,拆开成单个字符{'h', 'e', 'l', 'o'}

my_set1 = set(("hello",)) # 创建含有一个元素的集合，有逗号说明是元组
my_set2 = set(("haha","wode","en"))#创建一个含有多个元素的集合

print("s:",s)   # s: {3, 4, 5, 6, 7}
print("w:",w)   # w: {2, 3, 4}
print("my_set1:",my_set1) # {'hello'}
print("my_set2:",my_set2)   # {'en', 'haha', 'wode'}

s.add()　　#添加集合

s.updata(可迭代对象)　　# 添加多项

s.remove(x)　　#删除指定元树x，如果x不存在则会发生错误

s.discard()　　#和remove()一样，但是当删除指定元素不存在时，不会报错

s.clear()　　#清空集合

s.pop()　　#弹出最后一个书或弹出指定数

s = set([4,5])    #创建一个数字集合{3, 4, 5}

s.add('w')
print("添加后的s：",s)   # {4, 5, 'w'}

s.update(['ni','hao','ya'])    # 添加多项
print("添加多项后的s：",s)     # {'hao', 'ya', 4, 5, 'w', 'ni'}

# 我们输入字符串试试
s.update("hid") # 将字符串拆分单个字符后，然后再一个个添加到集合中,有重复的会忽略。，
print(s)        # {'hao', 'ya', 4, 5, 'w', 'h', 'ni', 'i', 'd'}

s.remove("hao")         # 移除元素
print("移除元素",s)      # {'w', 'e', 'o', 'l', 12, 'h', 23}

s.discard('ya')         # 移除元素，不存在不会发生错误
print(s)                # {'d', 4, 5, 'i', 'ni', 'w', 'h'}

s.pop()                # 随机删除集合中的元素,这个方法返回值是删除的数，不是返回none
print(s)                # {4, 5, 'i', 'ni', 'w', 'h'}

s.clear()
print(s)                # set()

|　　生成两个集合的并集

&　　生成两个集合的交集

-　　生成两个集合的补集

^　　生成两个集合的对称补集（也就是两个集合的并集减去交集）

>　　判断一个集合是另一个集合的超集

<　　判断一个集合是另一个集合的子集

==,  !=　　判断集合是否相同

in , not in 　　判断集合是否在另一个集合中

len(s),　　sum(s),　　max(s),　　min(s),　　sum(s),　　any(s),　　all(s)

s = set([3,4,5,6,7])    #创建一个数字集合{3, 4, 5, 6, 7}
w = set([2,3,4])

print("求交集:",s&w)      # {3, 4}
print("求并集:",s | w)    # {2, 3, 4, 5, 6, 7}
print("求差集:",s-w)      # 减去相同的元素 {5, 6, 7}
print("求差集:",w-s)      # 减去相同的元素 {2}
print("并集减去交集:",s ^ w)    # {2, 5, 6, 7}

print(len(s))   # 5
print(3 in s)   # true

 

固定集合  frozenset

　　固定集合是不可变、无序的，含有唯一元素的不可迭代的集合，

　　作用：固定集合可以作为字典的键，还可以作为字典的值

固定集合的构造函数

　　frozenset()　　创建一个空的固定集合

　　frozenset(iterable)　　用可迭代对象创建一个固定的集合

固定集合的运算和集合的运算完全一样

集合推导式：　　{表达式  for  变量  in  可迭代对象  [if  真值表达式]}　# [ ]可以省略

　　　　　　　　集合推导式同样也可以嵌套

　　　　　　　　{x for x in range(10)}　　#返回集合

元组

　　元组是不可修改的有序序列，元组使用小括号()，列表使用综括号[]，可以存储任意的数据类型

　　元组只含一个元素时，需要在后面添加逗号，否者会被当做变量来处理

　　括号可以省略

 1 tuple2 = (1,2,'wo',4,5)
 2 print(tuple2)   # (1, 2, 'wo', 4, 5)
 3 tuple3 = "wo","ai","ni"     # 不需要括号也可以
 4 print(tuple3)   # ('wo', 'ai', 'ni')
 5 print(type(tuple3)) # <class 'tuple'>类型为元组类型
 6 tup1 = ()       #()
 7 print(tup1)
 8 tup2 = (50)     # 不加逗号，类型为整型
 9 print(tup2)     #50,
10 tup3 = (50,)    # 加逗号，类型为元组
11 print(tup3)     #(50,)

1 t = tuple()    #创建一个空元组
2 t = ()    #创建一个空元组
3 x, y, z = 100, 200, 300  # 序列赋值1 2 3 x,y,z是整型
4 x, y, z = (100, 200, 300)  # 序列赋值 100 200 300整型
5 x, y, z = [100, 200, 300]  # 序列赋值
6 x, y, z = 'abc'            # 序列赋值 a b c 字符串
7 t.index(v[, begin[, end]]) #返回对应元素的索引下标
8 t.count(x)  #返回元组中对应的元素个数

1.访问元组

tup1 =(11,2,33)
print("tup1[0]:",tup1[0])       # tup1[0]: 11
print("tup1[0:2]:",tup1[0:2])   # tup1[0:2]: (11, 2)

2.删除元组

　　元组中的值是不能被删除的，但我们可以删除整个元组

tup = ('google', 'runoob', 1997, 2000)
del tup
print ("删除后的元组 tup : ",tup) # name 'tup' is not defined

3.元组运算符

python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('hi!',) * 4	('hi!', 'hi!', 'hi!', 'hi!')	复制
3 in (1, 2, 3)	true	元素是否存在
for x in (1, 2, 3); print (x)	1 2 3	迭代

 

 元组的相加和相乘是创建了一个新的元组，原来的元组并没有改变，也改变不了

4.元组索引，截取

l = ('google', 'taobao', 'runoob')

python 表达式	结果	描述
l[2]	'runoob'	读取第三个元素
l[-2]	'taobao'	反向读取；读取倒数第二个元素
l[1:]	('taobao', 'runoob')	截取元素，从第二个开始后的所有元素。

 

5.元组的其他内置函数

　　len　　max　　min　　

　　tuple(列表)　　将列表转换成元组

reversed(可迭代对象)　　#返回反向顺序的可迭代对象（临时性的）
sorted(iterable, key=none, reverse=false)　　#返回已排序的列表

t = (4, 8, 6, 2, 7)
l = [x for x in reversed(t)]
# l = [7, 2, 6, 8, 4]  # 原来先后顺序的反向
for x in reversed(t):
  print(x)  #  打印: 7  2  6  8  4

l2 = sorted(t)  # l2 = [2, 4, 6, 7, 8]
l3 = sorted(t, reverse=true)  # l3 = [8, 7, 6, 4, 2]

字典

　　字典是可修改的无序序列，字典使用花括号{}，可以存储任意类型对象，

　　字典由键值对组成{key:value}

　　键在字典中是唯一的，如果重复，后面的键值对会替换前面的。

　　键必须是不可变的类型对象，只能用数字、字符串、元组充当，列表就不行，值可以取任意的数据类型

d = {"key1":'value1',"key2":'value2'}
print(d)      # {'key2': 'value2', 'key1': 'value1'}
dict = {'a':2,'b':1,'b':3}    # 重复最后的一个键值对会替换前面的，值不需要唯一
print(dict)   # {'a': 2, 'b': 3}

创建字典，

　　当键不存在时，创建键，并绑定对应的值，当键存在时，修改键绑定的值

# 创建字典dict
dict1 = {'a':2,'b':1,'b':3}    # 重复最后的一个键值对会替换前面的，值不需要唯一
print(dict1)   # {'a': 2, 'b': 3}
dict1['c'] = 4   # 当键不存在时，增加键，并绑定对应的值，
print(dict1)     # {'a': 2, 'b': 3, 'c': 4}
dict1['c'] = 134   # 当键存在时，修改键绑定的值
print(dict1)     # {'a': 2, 'b': 3, 'c': 134}

　　访问字典，把键放入方括号中进行索引，但是访问字典中不存在的键会出错

1 print(dict['a'])#访问字典，把键放入方括号中进行索引
2 print(dict["c"])#访问字典中不存在的键会出错

　　删除字典、清空字典、删除字典中的键值对

dict1 = {'a':2,'b':1,'c':3}

del dict1['a']  # 删除字典中的键"a，就相当于删除了值2
print(dict1)    # {'b': 1, 'c': 3}
dict1.clear()   # 清空字典的所有键
print(dict1)    # {}
del dict1       # 删除字典

 

　　字典的内置函数

　　cmp(dict1, dict2)

　　# 比较两个字典元素。如果两个字典的元素相同返回0，
　　# 如果字典dict1大于字典dict2返回1，
　　# 如果字典dict1小于字典dict2返回-1。

　　len(dict) 　　 # 计算字典元素个数，即键的总数。
　　str(dict)　　# 输出字典可打印的字符串表示。
　　type(variable)　　# 返回输入的变量类型，如果变量是字典就返回字典类型。

 

　　字典方法

dict.clear()#删除字典内所有元素
dict.copy()#返回一个字典的浅复制

#创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值

 1 seq = ('google', 'runoob', 'taobao')
 2 seq1 = 'fkjsahf'
 3 dict = dict.fromkeys(seq)
 4 print("新字典为 : %s" % str(dict))
 5 dict = dict.fromkeys(seq, 10)
 6 print("新字典为 : %s" % str(dict))
 7 dict = dict.fromkeys(seq1, 10)
 8 print("新字典为 : %s" % str(dict))
 9 
10 #新字典为 : {'runoob': none, 'taobao': none, 'google': none}
11 #新字典为 : {'runoob': 10, 'taobao': 10, 'google': 10}
12 #新字典为 : {'j': 10, 'k': 10, 'h': 10, 'a': 10, 'f': 10, 's': 10

 dict.get(key, default=none)#返回指定键key的值，如果值不在字典中返回default值，default = none

1 dict = {'name': 'zara', 'age': 27}
2 
3 print "value : %s" %  dict.get('age')#value : 27
4 print "value : %s" %  dict.get('sex', "never")#value : never

#如果键在字典dict里返回true，否则返回false
#以列表形式返回可遍历的(键, 值) 元组数组

 1 dict = {'google': 'www.google.com', 'runoob': 'www.runoob.com', 'taobao': 'www.taobao.com'}
 2  
 3 print "字典值 : %s" %  dict.items()
 4  
 5 # 遍历字典列表
 6 for key,values in  dict.items():
 7     print key,values
 8 
 9 #字典值 : [('google', 'www.google.com'), ('taobao', #'www.taobao.com'), ('runoob', 'www.runoob.com')]
10 #google www.google.com
11 #taobao www.taobao.com
12 #runoob www.runoob.com

dict.items()返回的是两个数，一个是字典的键，一个是字典的值，

#以列表返回一个字典所有的键

1 dict = {'name': 'zara', 'age': 7}
2 
3 print "value : %s" %  dict.keys()#value : ['age', 'name']

dict.setdefault(key, default=none)#和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
#把字典dict2的键-值对更新到dict里
#以列表返回字典中的所有值
#删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

1 site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
2 pop_obj=site.pop('name')
3 print(pop_obj)    # 输出 ：菜鸟教程
4 print(site)    #{'alexa': 10000, 'url': 'www.runoob.com'}

#随机返回并删除字典中的一对键和值。

 

序列相关函数：
　　len(),max(),min(),sum(),any(),all(){全部都为真都返回真}
列表中的方法：
　　　　l.index(v) #返回元素对应的索引下标
　　　　l.insert(index,obj)
　　l.count(x)
　　l.remove(obj)
　　l.copy()
　　l.append(x)
　　l.extend(lst) #l +=lit
　　l.clear()
　　l.sort()
　　l.pop(索引)
　　l.reverse() #列表的反转
深拷贝deep copy,浅拷贝shallow copy
字符串的方法：
　　str.split() 分割 把字符串的空格用逗号分隔，返回列表
　　str.join() 连接 字符串的分隔符换成join里面的数

小总结

1. 数据类型:
　　数值类型：
　　　　int, float, complex, bool
　　容器:
　　　　不可变的容器
　　　　　　str, tuple, frozenset, bytes(字节串)
　　　　可变的容器
　　　　　　list, dict, set, bytearray(字节数组)

　　　　有序的容器

　　　　　　str(字符串) list(列表) tuple(元组) bytes(字节串) bytearray(字节数组)

　　　　无序的容器

　　　　　　set(集合) dict(字典) 

 推导式总结：

　　　　列表：[x for x in range(10)]返回列表

　　　　集合：{x for x in range(10)}返回集合

　　　　字典：{x:x**2 for x in range(10)}返回字典

2.值:
　　none, false, true

3. 运算符
　　算术运算符
　　　　+ - * / //（保留整数）  %（求余）  **（平方）
　　比较运算符:
　　　　< <= > >= == !=
　　　　in / not in 
　　　　is, is not
　　布尔运算:
　　　　not（非）, and（与）, or（或）
　　　　+(正号) -(负号)
　　　　&（按位与） |（按位或） ^（按位异或） ~（按位取反）
　　　　[] (索引,切片,键索引)

　　表达式:
　　1
　　1 + 2
　　max(1,2,3) # 函数调用是表达式
　　x if x > y else y, 条件表达式，把三条语句融合为一条

语句
表达式语句:
　　所有的表达式都可以单独写在一行，形成一个语句,例:
　　print("hello world")
　　1 + 2
赋值语句:
　　a = 100
　　a = b = c = 100
　　x, y = 100, 200　　#交叉赋值
　　a[0] = 100　　#序列索引赋值
　　dict['name'] = 'tarena' 字典赋值
　　del 语句
　　if 语句
　　while 语句
　　for 语句
　　break 语句
　　continue语句
　　pass 语句

内建函数:

　　len(x), max(x), min(x), sum(x), any(x), all(x)
　　构造函数(用来创建同类型的数据对象)
　　布尔值 bool(x), int(x), float(x), complex(x),
　　list(x), tuple(x), str(x), dict(x), set(x),
　　frozenset(x)
　　abs(x)
　　round(x[,n])　　#四舍五入

1 print(round(80.63756, 2))   # 80.64保留小数点后两位，对第三位进行四舍五入
2 print(round(56.6))  #57

　　pow(x, y, z=none)

1 print(pow(2,2)) #   2**2 = 4
2 print(pow(2,2,2))   # 2 ** 2 % 2 = 0

　　bin(x),返回一个整形int或者长整形long int的二进制表示

print(bin(10))  #0b1010

　　oct(x)将一个整数转换成8进制字符串

print(oct(10))  #0o12

　　hex(x)将10进制整数转换成16进制，以字符串形式表示

print(hex(195))  #0xc3

　　chr(x),用一个范围在0～255整数(ascii)作参数，返回一个对应的字符

1 >>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
2 0 1 a
3 >>> print chr(48), chr(49), chr(97)         # 十进制
4 0 1 a

　　ord(x)以一个字符作为参数，返回对应的 ascii 数值，或者 unicode 数值，

1 >>>ord('a')
2 97
3 >>> ord('b')
4 98
5 >>> ord('c')
6 99

　　range(start, stop, step)
　　input(x), print(x)