python学习 第六天课后总结：

<br class="Apple-interchange-newline"><div></div>

 

 

 

python学习 第六天课后总结：

今日内容：

  一，元组：tuple()    跟python其它数据类型一样，tuple()也是一个可将字符串转换成元组的内置函数

    特点：

      1，被元组转换的对象，一定是可迭代的对象，数字可不行滴，一般字符串或列表，转换后都会被拆成单个元素

         在无组中存在，可以被for 循环给迭代的。

 

 

      2，元组是有序排列，可通过索引值进行索引，当然也可以计算它的长度

          例：tu = (a,b,c,d,e)    #定义一个元组

              print(len(tu))        #会显示： 3   当前元组的元素数量为3

              s1 = tu[2:]           #对元组进行切片，索取元组的元素并给变量s1赋值

              print(tu.index(b,1,3)) #在元组中索引指定的元素x，指定从索引值1开始，

                #   显示为 1             到索引值3结束的范围查找值为b的元素位置，默认可不指定范围

              print(len(tu))    # 显示为 5  表示此元组中共有五个元素

      3，元组是不可变类型的python数据类型。里面的元素是不可更改滴,但如果元素为列表，或字典时，可变列表或

         列表的值。

          例：t2 = (1,["a","b","c"],{"name":"Frank"})

              t2[1][2] = "d"          #重新定义元素中索引值为1的列表中的索引位置为2的值

              t2[2]["name"] = "aibapspl#重新定义元素中索引值为2的字典中的索引位置为"name"的值

              print(t2)                 #显示为：(1, ['a', 'b', 'd'], {'name': 'aibapspl'})

      4，如果定义元组时，值只有一个，在此元素后一定要加一个逗号，代表后面还有元素，可被for循环迭代。

          例： tu1 = tuple(1,)      #当元素只有一个时，定义元组时，此元素后面一定要加逗号！

      5，应用场景： 根据需要，元组和列表可以互相转换。

          例 li = [1,2,3]              #定义一个列表

             tu = tuple(li)           #使用tuple()内置函数转换列表

             print(type(tu))          #查看转换后的类型

              <class 'tuple'>         #显示为元组类型

             l2 = list(tu)            #使用函数list()转换无组

             print(type(l2))          #查看转换后的类型

                <class 'list'>        #显示为列表类型

  二，字典 dict{} 此数据类型为python语言中唯一的mapping类型，即一个key对应一个value

    特点： 

       1， 字典内的元素都是以键值对形式存在，即key:value的形式一一对应,key与value之间使用冒号分隔，每个           元素之间使用逗号隔开

           key:只能是不可变类型，如数字类型，元组，字符串和布尔型

           value: 所有类型都可以为value

              例： dic1 = {123:None,None:123,(1,2):[a,b],True:None,{"s":2}:1.92,2.16:2.16}

        2，字典中的key具有唯一性，如果字典中已存在一个值，如果再赋值一个相同的key，字典中key的值会被覆盖

              例：dic1 = {123: None,}     #定义一个字典

                  dic1[123] = "abc"       #替换字典中key为123的值为"abc"

                  print(dic1)             #打印字典

                  {123: 'abc'}

        3， 字典是无序存储的，所以无法使用index()索引，只能靠取key来更改key的值，

              例： dic1 = {123: None}     #定义一个字典

                  print(dic1[123])        #查询字典中key为123的值

                  abc                     #显示key的值为abc

                  print(type(dic1[123]))  #查询这个key的值的类型

                  <class 'str'>           #显示为字符串类型

         内置属性的使用方法：

             .pop()       根据key来指定要删除的元素

              例：  dic1 = {123: None,"name":"Frank"}     #定义一个字典

                    dic1.pop("name")                      #删除一个key为"name"的元素

                    print(dic1）                           #打字删除后的字典

                    {123: None}                           #结果显示，key为"name"的元素已删除

             .copy()      浅拷贝  相当系统另申请一个内存空间以来存放与原字典一样的值

               例： dic1 = {123: None}           #定义一个字典

                    dic2 = dic1.copy()          #字典dice2复制dict1的值

                    print(dic2)                 #打字dice2的值

                    {123: None}                 #显示dice2的值

                    print(id(dic1),id(dic2))    #打印出二个字典的内存id

                    4567702768 4644934784       #显示出二个字典的内存id不相同

    三，集合  set()  

        特点：

          1，单列的数据集合，内部可以存储任意类型的数据，但每个数据都具有唯一性

                例： li = [1,2,3,4,2] #创建一个空集合

                    s1 = set(li)      #将列表转换成集合

                    print(s1)         #打印出集合的值

                    {1, 2, 3, 4}

                    print(type(s1))   #打印类型

                    <class 'set'>     #显示的类型为集合

          2，无序存储 无法使用key或索引值来取值

        使用场景：集合间的运算

                例：s1 = {1,2,3,"x"}      #创建四个集合

                    s2 = {1,2,3,"y"}

                    s3 = {4,5,6}  

                    s4 = {1,2,3,4,5,6}

                    print(type(s1),type(s2),type(s3),type(s4))  #打印类型

                    <class 'set'> <class 'set'> <class 'set'> <class 'set'> #显示都为集合

             交集：&

                   print(s1 & s2)   #打印出二个集合之间的交集，即相同的元素

                   {1, 2, 3}        #显示出二个集合间的相同元素

             并集：|

                  print(s1 | s2)    #打出出二个集合的并集，即把二个集合的所有元素集合，并去除重复元素

                  {1, 2, 3, 'x', 'y'} #显示出二个集合的所有元素，并去除了重复的部分

             差集：-

                  print(s4 - s3)     #打印出s4与s3的差集 即用s4里的所有元素减去s3的元素，留下的就是s3                                       中没有的元素

                  {1, 2, 3}           #显示出s3中没有的元素

              也可使用函数： 集合一.symmetric_difference(集合二)来完成来完成 

                   print(s4.symmetric_difference(s3))  #打印出s4与s3的差集 即用s4里的所有元素减去                  {1, 2, 3}                             s3的元素，留下的就是s3中没有的元素

                  print(s4.symmetric_difference(s3))

             对称交集： ^

                   print(s1 ^ s2)     #打印出二个集合的对称交集 即显示出二个集合中相互没有的元素

                   {'x', 'y'}         #显示出这二个集合相互没有的元素

                   也可使用函数： 集合一.symmetric_difference(集合二)来完成

                   print(s1.symmetric_difference(s2))

                   {'x', 'y'}         ##显示出这二个集合相互欠缺的元素