zip合成器，元组，字典基础知识

★zip：合成器能将列表，等东西合成字典

nos =(1001,1002,1005,1008)
name = ("peng","ze","ping","lihai")
print (dict (zip(nos,name)))
结果：{1008: 'lihai', 1001: 'peng', 1002: 'ze', 1005: 'ping'}
或者：
nos =(1001,1002,1005,1008)
name = ["peng","ze","ping","lihai"]

print (dict (zip(nos,name)))
结果：{1008: 'lihai', 1001: 'peng', 1002: 'ze', 1005: 'ping'}
或者：
nos =[1001,1002,1005,1008]
name = ["peng","ze","ping","lihai"]
print (dict (zip(nos,name)))
结果同上

元组 tuple

  元组是不可改变的序列，同list一样，元组可以存放任意类型的元素
  元组一但创建将不可改变

元组的表示方式:
　　　用小括号() 括起来，单个元素括起来后加逗号(，)区分单个对象还是元组

创建空元组的字面值表达式

  t = ()  				# () 是创建一个空的元组对象  t = ()  				# () 是创建一个空的元组对象

创建非空元组的字面值表达式:
t = 200， 是元组 结果：（200，）
t = (20，) 是元组 结果：（20，）
t = (1， 2， 3) 是元组 结果：（1，2，3）
t = 100， 200， 300 是元组 结果：（100，200，300）
注:
type(x)函数 可以返回对象x的类型

元组错误示例:
t = (200) # t 绑定的是200这个对象，不是元组 结果为：200

x， y， z = 100， 200， 300 # 序列赋值
x， y， z = (100， 200， 300)
x， y， z = “ABC”
x， y， z = [100， 200， 300]
元组的构造函数tuple
tuple() 生成一个空的元组　，等同于()
tuple(iterable) 用可迭代对象生成一个元组

示例:
　　 t = tuple()
t = tuple(“ABC”) #元组（‘A’, ‘B’, ‘C’)
t =list (“abc”) #列表 【‘a’，‘b’，‘c’】
t = tuple(range(1， 10， 2))

元组的运算:

• 用于用拼接方式创建一个新的元组 (生产新的对象)

• 用于生成新的重复的元组 (生成新的对象)

t = (1，2，3) + (4， 5， 6) # t = (1，2，3，4，5，6)
t += (7，8，9) # t = (1，2，3，4，5，6，7，8，9)
t = (1，2) * 3 # t = (1,2，1,2，1,2)
t *= 4 # t = (1,2，1,2，1,2…)
列表的比较运算:
< <= > >= == != 规则与列表的比较规则完全相同

元组的in / not in 运算符
用于判断元素是否存在于元组中,规则写列表完全相同

索引　index
用法等于同列表的索引
元组不支持索引赋值

切片
用法与列表的切片用法相同
元组的切片返回一个新的元组
元组不能切片赋值

元组可以用for循环取出里面的元素：
列如：

L = tuple("abc")
print(L)
for x in L:
	print(x)

结果：
(‘a’, ‘b’, ‘c’)
a
b
c
元组的方法:

  T.index(v[,begin[,end]])  返回对应元素的索引下标， begin 为开始索引，end为结束索引，当v不存在时触发ValueError错误
  T.count(x)  返回元组中对应的元素个数

序列小结:

字符串 str
列表 list (可变的)
元组 tuple (不可变的)

序列相关的函数:
len(x), max(x), min(x), sum(x), any(x), all(x)

reversed(x) 返回反向顺序的可迭代对象

示例:

s = "ABC"
for ch in s:
    print(ch)  # A B C 
L = [1，3， 7， 9]
L2 = [x **2 for x in reversed(L)]  # [81， 49， 9， 1]

字典 dict

  什么是字典:什么是字典:
1. 字典是一种可变的容器，可以存储任意类型的数据
2. 字典中的每个数据都是用'键'(key)进行索引的，而不像序列可以用索引下标进行索引
3. 字典中的数据没有先后顺序关系,字典的存储是无序的
4. 字典中的数据以键--值对(key-value)对形式进行映射存储 
5. 字典的键不能重复,且只能用不可变类型作为字典的键5. 字典的键不能重复,且只能用不可变类型作为字典的键5. 字典的键不能重复,且只能用不可变类型作为字典的键
6.不能进行+  *  - 等运算

字典的字面值表示方法:

   以{  } 括起来，以冒号(:) 分隔键-值对，各键值对用逗号分隔开

创建空字典:

    d = { } 			 # { } 表达式用来创建一个空的字典d = { } 			 # { } 表达式用来创建一个空的字典

创建非空字典:

d = {‘name’: ‘weimingze’， ‘age’: 35 }
d = {‘a’: 100}
d = {‘a’: tuple("ABC")}    #{'a': ('A', 'B', 'C')}
d = {‘abc’: list("ABC")}		#{'a': ['A', 'B', 'C']}
d = {‘a’： {‘b’:100， ‘c’：200}}
d = {True:’真值’， False: ‘假值’， None:’空’， 100:’一百’}
d = {(1970， 1， 1): ‘计算机元年’}

字典的构造函数 dict

  dict()  			创建一个空的字典,等同于{  }dict()  			创建一个空的字典,等同于{  }
  dict(列表)  		用可迭代对象创建一个新的字典dict(列表)  		用可迭代对象创建一个新的字典
  dict(**kwargs)  	用关键字传参形式创建一个新的字典dict(**kwargs)  	用关键字传参形式创建一个新的字典

示例:
d = dict() 键 值 键 值
d = dict([(‘name’，‘tarena’)，(‘age’，15)]) #{“name”：“tarena”，“age”:15}
d = dict(([‘name’，‘weimingze’]， “AB”)) #{‘name’: ‘weimingze’, ‘A’: ‘B’}
d = dict(name=’Tarena’， age=15) #{‘name’: ‘tarena’, ‘age’: 15}

字典的操作
字典的键索引

用[ ] 运算符可以获取字典内'键'对应的'值'

语法:

v = 字典[键]
值 =字典[键]

示例:

d = {‘name’: ‘tarena’， ‘age’: 15}
print(d[‘name’]， ‘今年’， d[‘age’]， ‘岁’)
结果：tarena 今年 15 岁

添加/修改字典的元素
语法:

字典[键] = 表达式（值）

示例:

d = { }
d['name'] = 'tarena'  	#创建新的键'name'同时关联值    结果：{'name': 'tarena'}
d['age'] = 15  			# 创建键并绑定15    结果{'name': 'tarena', 'age': 15}	
d['age'] = 16  			# 修改原来的键'age',重新绑定为16 
					{'name': 'tarena', 'age': 16}

说明:

键不存在，创建键，并绑定值
键存在，修改键的绑定关系

删除字典元素 del语句

del 字典[键]
示例:
d = {1:‘一’， ‘hello’: ‘world’， False:‘假值’}
del d[‘hello’] 删除的是’hello’: 'world’键–值对

字典的 in / not in 运算符

  in用来判断一个键是否存在于字典中,如果存在返回 True,否则返回Falsein用来判断一个键是否存在于字典中,如果存在返回 True,否则返回False
 
  not in 的返回结果与in 相反not in 的返回结果与in 相反

示例: “键” 值

  d = {'name': '小张', 'age': 20}
  'name' in d  				# True
  'age' not in d 			# False
  '小张' in d   			# False  (只判断键,不判断值)
  20 not in d  				# True

练习:
1.写程序,实现以下要求:
1) 将如下数据形成一个字典 seasons
键 值
1 ‘春季有1,2,3月’
2 ‘夏季有4,5,6月’
3 ‘秋季有7,8,9月’
4 ‘冬季有10,11,12月’
2) 让用户输入一个整数代表这个季度,打印这个季度有信息
如果用户输入的信息不在字典中,则打印"信息不存在"
答案1： 添加/修改字典的元素

 seasons = {}                             字典[键] = 表达式
 seasons[1] = '春季有1,2,3月'
 seasons[2] = '夏季有4,5,6月'
 seasons[3] = '秋季有7,8,9月'
 seasons[4] = '冬季有10,11,12月'
 print(seasons)

答案2：
加上答案一内容
n = int(input("请输入季节: "))
if n in seasons:
    print(n， ‘ :’ ， seasons[n])
else:
    print("信息不存在")

字典的迭代访问

  字典是可迭代对象,字典只能对'键'进行访问字典是可迭代对象,字典只能对'键'进行访问

示例:

d= {'aaa': 111， 'bbb': 222， 'ccc': 333}
for k in d:
    print(k)

输出：
aaa
bbb
ccc

可以用于字典的函数:

  len(x)  返回字典的键值对个数
  max(x)  返回字典键的最大值
  min(x)  返回字典键的最小值
  sum(x)  返回字典所有键的和
  any(x)  真值测试,只对键进行测试
  all(x)  真值测试,全部键为真值.结果才为True

示例:

  d = {0: '零', 5:'伍', 8:'捌', 3:'叁'}
  len(d)  # 4        d字典中有0 5 8 3这四个键
  max(d)  # 8		最大键的值
  min(d)  # 0        
  sum(d)  # 16         键值的和
  any(d)  # True
  all(d)  # False

字典的方法

  方法名       说明
  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集合对象           key “键“
  D.values()    返回可迭代的dict_value集合对象			 value“值”
  D.items()     返回可迭代的dict_item对象				item：(key ， value）

示例:
  d = {1: 'One', 2: "Two"}
  d2 = {2: '二', 3: '三'}
  d3 = d.copy()  			# 复制
  d3.pop(1)  				# d3 = {2: "Two"}
  d.update(d2) 			    # d = {1: 'One', 2: '二', 3: '三'}

  d = {1: 'One', 2: '二', 3: '三'}
  for k in d.keys():        #返回可迭代的键集合对象
      print(k)  				 # 1 2 3
  for v in d.values():     #返回可迭代的值集合对象
      print(v)  				# 'One' '二' '三'
  for t in d.items():			#返回可迭代的键和值对象	
      print(t)  				#   (1, 'One')
(2, '二') 
(3, '三')




字典[键] = 表达式（值）例如：
d['name'] = 'tarena'  	#创建新的键'name'同时关联值    结果：{'name': 'tarena'}
d.items()     返回可迭代的dict_item对象				item：(键 ， 值）

例子：
d= {1:'one',2:"er",3:"sad"}
for t  in d.items():
print (t)
                       for k， v in d.items(): 这个循环把字典中键的值给了k
						键对应的值给了v

结果：
(1, 'one')
(2, 'er')
(3, 'sad')