1.类型转换：   
　　#字符串转换成元组
　　　　b=“123”
　　　　c=tuple（b）     #转换类型
　　　　print（c）----- （"1","2","3"） 　　
　　　　print(type(c))----<class 'tuple'> #tuple类型 　　
   #列表转换成元组：
　　　  b=[1,2,3,4]
　　　　c=tuple（b）     #转换类型
　　　　print（c）----- (1, 2, 3, 4)
　　　　print(type(c))-----<class 'tuple'> #tuple类型 　　　　

　　#元组转换成列表
　　　 tu=（1,2,3,4）
　　　 c=list（tu）      #转换类型
　　　 print（c）-----([1,2,3,4])
　　　 print(type(c))-----<class 'list'>   #list类型

    #元组转换成字符串 
　　　　s=""
　　　　tu=（1,2,3,4）
　　　　for i in tu:  -----#遍历列表
　　　　　　s=s+str(i) -----#将每个元素转换成str类型相加
　　　　print(s)------1234
　　　　print(type(s))----<class 'str'>   #str类型

　　
　　　 注#数字不能转换成列表list，也不能转换成元组  反之也不能

　　　　　　　tu=（1,2,3,4,5,6）

　　　　　　　　#索引取值：
　　　　　　　　　　v=tu[0]  #获取tu元组中下表为0的元素 
　　　　　　　　　　print(v) -----1

　　　　　　　　#切片取值：
　　　　　　　　　　v=li[0:3]  #获取tu元组中下表0到3的元素 含头不含尾　　　　　   
　　　　　　　　　　print(v)----- （1,2,3）  #切片元组返回值是元组 
　　　　　　　　　　print（tu[0:3:2]）-----(1, 3）  #从下标是0的元素开始取值 每俩个取一个  到下标是3的元素结束，取值不包含3

　　　　　　　　#查询：
　　　　　　　　　　　a in li  #在就返回True  不在就false
　　　　　　　　　　  not in   #和 in 操作符相反

　　　　　　 　#获取列表的长度

　　　　　　　　　　v=len（tu）  #获取元组的长度 
　　　　　　　　　　print（v）----- 6


　　　　　　　　#循环语句： 
　　　　　　　　　　for item in tu #循环遍历 
　　　　　　　　　　　　print（item） ------1 2 3 4 5 6 在元组内是什么类型，循环出来之后还是什么类型
　　　　　　　　　　while 条件：

　　　　　　　　　　　  执行代码块

#程序程序：
　　  　tua=（1,2,3）
　　　  tub=（4,5,6）
　　    tu = tua +tub  #元组与元组相加（就是俩个元组组合到一块）
　　　print（li）
#运行结果：（1, 2, 3, 4, 5, 6）
#程序程序：
　　　tua=（1,2,3）
　　　tu =tua*3　#元组可以与数字相乘（重复相应次数再组合） 　
     print（tu）  
#运行结果：（1, 2, 3, 1, 2, 3, 1, 2, 3）

tu=[1,2,3,4,5，6]


   <1> tu.count(参数)   #获取参数在元组中出现的次数。  参数可以是变量,可以是任何数据类型   

　 <2>  li.index（参数1，开始索引，结尾索引）  #获取指定值的索引位置。 在开始索引，结尾索引范围中间，寻找参数1的索引 不包含结尾索引（含头不含尾） 。 从左到右找到第一个就返回索引值。找不到就报错

　　　　　　　　info={"name":"momo","age":18,"成绩":{"语文":80,"数学":85},"上课时间":["周一","周二","周三"]}

　　　　　　　　#索引取值： 　　　　　　　　　　
　　　　　　　　　　　　v=info[name] 　　#获取info字典中key为name的元素 
　　　　　　　　　　　　print(v) -----momo 　　　
　　　　　　　　#切片取值： 因为字典是无序的所以不能通过切片取值　　　

　　　　　　　　#查询：
　　　　　　　　　　　键 in info  #在就返回True  不在就false
　　　　　　　　　　 键 not in info #和 in 操作符相反

　　　　　　 　#获取列表的长度

　　　　　　　　　　v=len（info）  #获取字典的长度 
　　　　　　　　　　print（v）----- 4
　　　　　　　　#修改：直接重新赋值

　　　　　　　　#删除元素：del info[key]

　　　　　　　　
　　　　　　　　#循环语句： 
　　　　　　　　　　

　　　　　　　　　　　　for item in info：
　　　　　　　　　　　　　　　　print(item)-----#默认只循环获取key
　　　　　　　　　　　　for item in info.keys（）：
　　　　　　　　　　　　　　　　print(item)----- #只循环获取key
　　　　　　　　　　　　for item in info.values（）：
　　　　　　　　　　　　　　　　print(item)----- #只循环获取值
　　　　　　　　　　　　for k，v in info.items（）：
　　　　　　　　　　　　　　　　print(item)----- #循环获取键值对

　　　　　　　　　　while 条件：

　　　　　　　　　　　  执行代码块

　　　　　　　　　　　　<1>.info.clear（）： #清空列表
　　　　　　　　　　　　<2>.info.copy（）： #拷贝（浅拷贝）


　　　　　　　　　　　　@staticmethod（）----- #静态方法  直接用dict.的方法
　　　　　　　　　　　　<3>dict.fromkeys（参数1，参数2）#创建字典。参数1为key 必须为可迭代对象  参数2为统一的value值。返回值为字典


            
　　　　　　　　　　　　<4>dict.get(参数1，参数2) #参数1为键，当键不存在时也不会报错   参数2，当键不存在时会返回参数2  存在的话忽略参数2
　　　　　　　　　　　　<5>dict.pop(key,参数2)   #pop删除指定键值对，并获取对应的值，参数1必须为key，当参数1不存在时，就返回参数2，存在就忽略参数2
                
　　　　　　　　　　　　<6>dict.popitem（）     #无参数  随机删除一对键值对。并获取值，默认返回值类型为元组
                   　　　　　　　　 k，v=dict.popitem（） #k接收 key    v接收 value

　　　　　　　　　　　　<7>dict.setdefault（key，value）   #设置值。如果已经存在，就不设置，只获取当前key对应的值，如果不存在，就设置，并获取当前设置的key对应的值

　　　　　　　　　　　　<8>dict.update(参数)    #更新  参数可以是字典   参数还可以是（k1=123，k2=“lkd”）原字典存在的键值对进行覆盖，远字典不存在的进行添加
　　　　　　　　　　　　<9>dict.values（）      #无参数。返回 dict_values(['value1', 'value2', 'value3'])
　　　　　　　　　　　　<10>dict.keys（）       #无参数。返回 dict_keys(['key1', 'key2', 'key3'])
　　　　　　　　　　　　<11>dict.items（）      #无参数。返回 dict_items([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])