主要内容：
2、集合
3、元组
4、字典
复习:
字符串和元组一样，只能读不能写。列表和字典可以嵌套任何东西，列表可以嵌套列表
L = list("hello") # L = ['h', 'e', 'l', 'l', 'o']
集合、字典是无序的；列表、元组、字符串是有序的
集合、字典、列表是可以修改的；元组、字符串、数字是不能修改的
for 语句中的else 语句，意思是for中的循环结束后，再走else中的代码，字典中的键就相当于列表可中索引的数字
集合操作
集合是无序不重复的数组组合，主要作用
- 去重，把一个列表变成集合，就自动去重了
- 关系测试，测试两组数据之前的交集、差集、并集等关系
常用操作：
1 #Author:凌贤鹏 2 s = set([3,4,5,6,7]) #创建一个数字集合{3, 4, 5, 6, 7} 3 w = set([2,3,4]) 4 t = set("hello")# 遍历字符串中的每个字符,拆开成单个字符{'h', 'e', 'l', 'o'} 5 my_set = set(("hello",))#创建一个含有一个元素的集合，{'hello'}要有逗号，没有逗号，还是会拆开来 6 print(my_set) 7 my_set = set(("haha","wode","en"))#创建一个含有多个元素的集合{'en', 'haha', 'wode'} 8 print(my_set) 9 print(s&w)#求交集{3, 4} 10 print(s | w)#求并集{2, 3, 4, 5, 6, 7} 11 print(s-w)#求差集，减去相同的元素{5, 6, 7} 12 print(w-s)#{2} 13 print(s ^ w)#并集减去交集 14 t.add('w') 15 print(t)#{'o', 'e', 'l', 'h', 'w'} 16 print(t.add('w'))#None############# 17 t.update([12,23,34]) 18 print(t)#添加多项{34, 'o', 'w', 12, 'h', 'l', 23, 'e'} 19 #我们输入字符串试试 20 t.update("wode")#将字符串拆分单个字符后，然后再一个个添加到集合中,有重复的会忽略。，{'w', 'h', 34, 'd', 'l', 12, 23, 'e', 'o'} 21 print(t) 22 t.update({"wode"})#将字符串添加到集合中,{'h', 34, 'e', 'o', 'wode', 12, 'l', 'd', 23, 'w'} 23 print(t) 24 t.remove(34)#如果要移除的元素不存在则会发生错误 25 print(t)#移除元素，{'w', 'e', 'o', 'l', 12, 'h', 23} 26 t.discard('hahaha')#不存在不会发生错误 27 print(t)#{'w', 12, 'e', 'l', 23, 'o', 'h'} 28 t.pop()#随机删除集合中的元素,这个方法返回值是删除的数，不是返回None 29 print(t)#{12, 'w', 23, 'l', 'o', 'h'} 30 print(len(t))#计算集合中的元素 31 t.clear() 32 print(t)#set() 33 print(3 in s)#判断元素在集合s中是否存在，True
s.add() #添加集合
s.remove() #删除指定数
s.discard() #和remove()一样，但是当删除指定元素不存在时，不会报错
s.clear() #清空集合
s.pop() #弹出最后一个书或弹出指定数
集合推导式： {表达式 for 变量 in 可迭代对象 [if 真值表达式]} [ ]可以省略
集合推导式同样也可以嵌套
{x for x in range(10)} #返回集合
创建空集合：s = set()
| 生成两个集合的并集
& 生成两个集合的交集
- 生成两个集合的补集
^ 生成两个集合的对称补集（也就是两个集合的并集减去交集）
> 判断一个集合是另一个集合的超集
< 判断一个集合是另一个集合的子集
==, != 判断集合是否相同
in , not in 判断集合是否在另一个字典中
len(s), sum(s), max(s), min(s), sum(s), any(s), all(s)
固定集合 frozenset
固定集合是不可变、无序的，含有唯一元素的不可迭代的集合，
作用：固定集合可以作为字典的键，还可以作为字典的值
固定集合的构造函数
frozenset() 创建一个空的固定集合
frozenset(iterable) 用可迭代对象创建一个固定的集合
固定集合的运算和集合的运算完全一样
元组
元组是不可修改的有序序列，元组使用小括号，列表使用大括号，元组只含一个元素时，需要在后面添加逗号，否者会被当做运算符来处理，元组和字符串一样，有序的，所以可以下标索引从0开始，可以进行截取、组合等。
1 tuple1 = ("wo","ai","ni")#('wo', 'ai', 'ni') 2 print(tuple1) 3 tuple2 = (1,2,3,4,5)#(1, 2, 3, 4, 5) 4 print(tuple2) 5 tuple3 = "wo","ai","ni"#不需要括号也可以('wo', 'ai', 'ni') 6 print(type(tuple3))#<class 'tuple'>类型为元组类型 7 tup1 = ()#() 8 print(tup1) 9 tup2 = (50) 10 print(tup2)#50,不加逗号，类型为整型 11 tup3 = (50,) 12 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.访问元组
1 tup1 =(11,2,33) 2 tup2 = ('wode','nvli') 3 print("tup1[0]:",tup1[0])#tup1[0]: 11 4 print("tup1[0:2]:",tup1[0:2])#tup1[0:2]: (11, 2)
2.删除元组
元组中的值是不能被删除的，但我们可以删除整个元组
1 tup = ('Google', 'Runoob', 1997, 2000) 2 print (tup) 3 del tup; 4 print ("删除后的元组 tup : ") 5 print (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(列表) 将列表转换成元组
1 reversed(可迭代对象) #返回反向顺序的可迭代对象（临时性的） 2 sorted(iterable, key=None, reverse=False) #返回已排序的列表
1 t = (4, 8, 6, 2, 7) 2 L = [x for x in reversed(t)] 3 # L = [7, 2, 6, 8, 4] # 原来先后顺序的反向 4 for x in reversed(t): 5 print(x) # 打印: 7 2 6 8 4 6 7 L2 = sorted(t) # L2 = [2, 4, 6, 7, 8] 8 L3 = sorted(t, reverse=True) # L3 = [8, 7, 6, 4, 2]
字典
1.字典是可变的无序序列，可以存储任意类型对象，字典的每个键值key=>value对用冒号：分割，每个键值对之间用逗号，分割，整个字典包括在花括号{}中，
键在字典中是唯一的，如果重复，后面的键值对会替换前面的。
键必须是不可变的类型对象，所以只能用数字、字符串、元组充当，列表就不行
1 d = {"key1":'value1',"key2":'value2'} 2 print(d)#{'key2': 'value2', 'key1': 'value1'} 3 dict = {'a':2,'b':1,'b':3} 4 print(dict)#{'a': 2, 'b': 3}重复最后的一个键值对会替换前面的，值不需要唯一
值可以取任意的数据类型
创建字典，
当键不存在时，创建键，并绑定对应的值，当键存在时，修改键绑定的值
1 dict1 = {'c':4}#创建字典 2 dict2 = {'abc':134,24:45}#创建字典
访问字典，把键放入方括号中进行索引，但是访问字典中不存在的键会出错
1 print(dict['a'])#访问字典，把键放入方括号中进行索引 2 print(dict["c"])#访问字典中不存在的键会出错
修改和创建字典
1 dict['a'] =8#修改字典中键的值{'a': 8, 'b': 3} 2 print(dict) 3 dict['wode'] = 'maya'#向字典中增加值{'a': 8, 'b': 3, 'wode': 'maya'} 4 print(dict)
删除字典、清空字典、删除字典中的键值对
1 del dict['wode']#删除字典中的键，就相当于删除了值{'a': 8, 'b': 3} 2 print(dict) 3 dict.clear()#清空字典的所有键 4 print(dict) 5 del dict#删除字典 6 print(dict['wode'])
字典的内置函数
1 cmp(dict1, dict2)#比较两个字典元素。 2 len(dict)#计算字典元素个数，即键的总数。 3 str(dict)#输出字典可打印的字符串表示。 4 type(variable)#返回输入的变量类型，如果变量是字典就返回字典类型。
字典方法
dict.clear()#删除字典内所有元素
dict.copy()#返回一个字典的浅复制
dict.fromkeys(seq[, val])#创建一个新字典，以序列 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.has_key(key)#如果键在字典dict里返回true，否则返回false
dict.items()#以列表形式返回可遍历的(键, 值) 元组数组
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()返回的是两个数，一个是字典的键，一个是字典的值，
dict.keys()#以列表返回一个字典所有的键
1 dict = {'Name': 'Zara', 'Age': 7} 2 3 print "Value : %s" % dict.keys()#Value : ['Age', 'Name']
dict.setdefault(key, default=None)#和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2)#把字典dict2的键-值对更新到dict里
dict.values()#以列表返回字典中的所有值
pop(key[,default])#删除字典给定键 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'}
popitem()#随机返回并删除字典中的一对键和值。
序列相关函数：
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)