python基础05

元组 tuple

元组是不可变的序列，同list一样，元组是可以存储任意类型的数据的容器

		元组的表达方式：
		　用小括号()括起来，单个元素括起来后加逗号(,)区分单个对象还是元组
		创建空元组的字面值：
		　　t=() #创建一个空元组用t绑定
		创建非空元组的字面值
		　t = 200,  #创建一个只有一个数字２００的元组
		  t = (20,)
		  t =(1,2,3)
		  t = 100,200,300
		
		创建的元组的错误示例：
		    t = (20) t绑定整数２０，不是元组
		    x,y,z = (100,200,300) #序列赋值
		    x,y,z = 100,200,300
		    x,y,z = [100,200,300] 
		    x,y,z = "ABC" #序列赋值，不是元组
		
		type(x) 函数返回ｘ的类型
		
		元组的构造函数　tuple
		  tuple() 生成一个空的元组，等同于（）
		  tuple(iterable) 用可迭代对象生成一个新的元组
		
		  示例：
		        t = tuple()
		        t = tuple("ABC")
		        t = tuple(range(1,10,3))

元组的运算：

＋　＋＝　＊　＊＝
t = (1,2,3) + (4,5,6) #t = (1,2,3,4,5,6)
t = (1,2,3)
t +=(4,5,6) #t = (1,2,3,4,5,6)
t = (1,2)*3  #t = (1,2,1,2,1,2,1,2)
t *= 3  #t = (1,2,1,2,1,2,1,2)
比较运算
< <= > >= == !=
比较规则与列表比较规则完全相同
in / not in 运算符
等同于列表的　in / not in 运算符
索引　和　切片
索引取值和切片取值规则与列表完全相同
注：　元组不支持　索引赋值和切片赋值


len(x) 返回序列的长度
max(x)  返回序列的最大元素
min(x)  返回序列中的最小元素
sum(x)  返回序列中所有元素的和（元素必须是数字类型）

any(x) 真值测试，如果列表中的一个值为真值则返回true
all(x) 真值测试，如果列表中的所有值为真值则返回true

字典　dict

１、字典是一种可变的容器，可以存储任意类型的数据
２、字典中的每个数据都是用”键“(key)进行索引的，而不是像序列(str,list,tuple)可以用整数进行索引
３、字典中的数据没有先后顺序，字典的存储是元序
４、字典中的数据以键(key)-值(value)对形式进行存储
５、字典的键不能重复，且只能用不可变类型作为字典的键

创建字典的字面值方式
　　字典的表示方式以{}括起来，以冒号(:)分隔键值对，各值之间用逗号分隔开

创建空字典
d = {}
创建非空字典：
　　d = {“姓名”:“tarena”,“年龄”:35}
　　d = {“one”: 1, “two”:2}
　　 d = {1:“one”,2:“二”,３:[1,2,3]}
d = {“a”:list(range(10))}
d = {“a”:{“b”:100,“c”:[1,2,3]}}

创建字典的构造函数
　dict() #生成一个空的字典　等同于{}
dict(iterable) 用可迭代对象创建一个列表
dict(**kwargs) 关键字传参形式生成一个字典
示例
　d = dict()
L = [ (1,2),(3,4),“AB”]
d = dict(L) #{1: 2, 3: 4, ‘A’: ‘B’}

>>> d = dict(name="chenhuaqi",age=15)
>>> d
{'name': 'chenhuaqi', 'age': 15}
字典的键必须为不可变类型的值

可变的类型有四种：
　　　　list(列表)，dict(字典），set(集合)，bytearray(字节组数)
　　　　除上述四种其他为不可变类型

字典的基本操作

字典的键索引
　　　　　语法：
　　　　　　字典【键】
　　　　　　作用：
　　　　　　　用键获取字典的键对应的值
　　　示例：
d = {“name”: “tarena”, “age”: 16}
print(d[“name”], “的年龄是”，d[“age”])

添加和修改字典的元素
　　语法
　　　字典[键]　＝　值
　　　说明：
　　　　　键不存在时，创建键，并让键绑定对应的值
　　　　　键存在，修改键绑定的值
　　　示例：
　　　　d = {}
d[“name”] = “小张”　＃添加一个键值对
d[“年龄”]　＝　２０　＃添加一个键值对
d[“年龄”]　＋＝１　＃修改“年龄”　这个键对应的值

删除字典元素
　del 语句
　　　语法：
　　　　　del 字典[键]
示例：
d = dict(name=“小张”,age=20)
del d[“age”]
print(d) #{‘name’: ‘小张’}

字典的键判断　in , not in 运算符
　　可以用 in 运算符判断一个键是否存在于字典中，如果存在　则返回True,否则返回False
not in 返回值与 in 相反
例如：
　　d = {“name”:“tarena”,“age”:15}
“name” in d #true
15 in d # False
“age” not in d # False

字典的迭代访问

字典是可迭代对象，字典只能对键进行迭代访问
　　
　示例：
　　　d = {0:“零”，５：“五”，１：“壹”，２：“贰”}
　　　for n in d:
print(n) # 0 5 1 2

可以用于字典的函数
　len(x) 返回字典的键值对儿的个数
　max(x) 返回字典的键的最大值
　min(x) 返回字典的键的最小值
　sum(x) 返回字典的所有键的和
　any(x) 真值测试，只对键进行测试，只要有一个键为真值，结果就返回True
　all(x) 真值测试，所有键的真值结果才返回True
示例：
d = {0:“零”,5:“五”,1:“壹”,2:“贰”}

字典的方法

方法 说明
D代表字典对象
D.clear() 清空字典
D.pop(key) 移除键，同时返回此键所对应的值
D.copy() 返回字典D的副本,只复制一层(浅拷贝)
D.update(D2) 将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
D.get(key, default=None) 返回键key所对应的值,如果没有此键，则返回default

D.keys() 返回可迭代的 dict_keys 集合对象
!!!D.values() 返回可迭代的 dict_values 值对象
#for x in d.values():
… print(x)
…
零
贰
五
>>>

!!!D.items() 返回可迭代的 dict_items 对象

d = {0:“零”,5:“五”,1:“壹”,2:“贰”}
d
{0: ‘零’, 1: ‘壹’, 2: ‘贰’, 5: ‘五’}

for k, v in d.items():
… print(k,v)
…
0 零
1 壹
2 贰
5 五

字典推导式

用可迭代对象创建字典的表达式

语法：
　　{键表达式: 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
　　注：
　　　　[] 的内容代表可省略
　　示例：
　　　　生成一个字典: 键为数字０－９，值为键的平方
　　＃　如{0:0,1:1,2:4,3:9,…9:81}
d = {x:x**2 for x in range(10)}

字典推导式的嵌套

语法同列表推导式的嵌套

字典　ＶＳ　列表

１、都是可变的容器
２、索引方式不同，列表用整数索引，字典用键索引
３、列表的存储是有序的。字典的存储是无序的
４、字典的插入　删除　修改的速度可能会快于列表（重要）