week3_notebooke1

今日内容：
编码
集合
深浅cpoy
文件操作
函数
初始函数
函数的返回值
函数的传参

初识：
   # == 数值比较
   # is 比较的是内存地址
   # id 测试的是内存地址
   # 小数据池 str int
      # int： -5 -- 256

      # str：
            #1，不能含有特殊字符
            #2，单个元素*int不能超过21
1、编码：
   a.类别：
      Ascii：数字、字母、特殊字符
         - 字节：8位表示一个字节
         - 字符：能够看到的内容的最小组成单位
               abc、中国
      unicode:万国码
         - 两个字节表示一个字符

      utf-8：最少用8位表示1个字符
         - 欧洲：两个字节
         - 亚洲：三个字节
         - 英文：一个字节
      gbk：国标
         - 英文：1个字节
         - 中文：两个字节

      注意：
         - 不同编码之间的二进制是不能互相识别的
         - 对于文件的存储及传输，不能是Unicode的编码，只能为bytes
         - 对于python3中：
            - str：内部编码方式为Unicode
            - bytes：和str操作方法一直，但内部编码方式：非Unicode，可以为utf-8、gbk、gb2312
               str和bytes对比：
                  字母：显示一致
                  中文：无法识别
   b.转换：
      注意：用什么编码，就用什么解码
         - 字符串转换一致
         - 中文：
               s1 = '中国'
               a1 = s1.encode('utf-8').decode('utf-8')
               b1 = a1.encode('gbk')

2、集合
   - 含义：
         a.里面元素可哈希不可变，元素唯一不重复、无序。
         b.集合本身是不可哈希的
   - 用途：
         a.关系测试
            set1 = {1,2,3,4,5}
            set2 = {4,5,6,7,8}

            - print(set1 & set2)   #交集
              print(set1.intersection(set2))
            - print(set1 ^ set2)   #反交集

            - print(set1 | set2)   #并集
              print(set1.difference(set2))

            - print(set1 - set2)   #差集

            set1 = {1,2,3}
            set2 = {1,2,3,4,5,6}

            - print(set2 > set1)   #子集
              print(set1.)

            - print(set2 > set1)   #超集
              prin(set2.issuperset(set1))

            - set1 = {1,2,3}
              print(frozenset(set1))   #动集合

         b.去重
            set = {1,1,2,2,3,4,4,5}
            print(set)
   - 使用：
      增：
         set1 = {'alex','anthony','chris','neil'}
         - set1.add('wusir')

         set1.update('王立功')
         print(set1)
      删：
         set1 = {'alex','anthony','chris','neil'}

         - set1.pop()   #随机删除

         - set1.remove('alex')  #按照元素删除

         - set1.clear() #清空集合

         - del set1 #删除整个集合    

      查：
         set1 = {'alex','anthony','chris','neil'}
         - for i in set1:
            print(i)

3、深浅cpoy
      s1 = [1,2,3]
      s2 = s1
      s1.append(666)
      print(s1,s2)
   - 浅copy:第一层各自独立，从第二层开始共用同一个内存地址
      s1 = [1,2,3,[11,22]]
      s2 = s2

   - 深copy：无论多少层，都是互相独立的
      import copy
      copy.
   - 切片：浅copy

4、文件操作
   含义：
      f1 文件句柄，f,file,file_hander,f_h
      open()调用的内置函数，内置函数调用的系统内部的open，一切对文件的操作都是基于文件句柄
   方式：
      读：r rt rb 
         r+模式   读写，
         r模式   read(n) #n对于字符而言
         rb模式         #对于字节而言
         readline      #按行读取
         readlines     #放入列表，每一行相当于一个元素
         for循环

      写：w
         w，没有源文件创建文件，源文件已存在，先清空，再写入。

      追加：a
         a，没有源文件创建文件，源文件存在，内容写到最后。

   其他方法：
         readable()    是否可读
         writeable()       是否可写
         seek()       调整光标,seek(0)光标调整到开头,seek(0,2),调整到末尾.
         tell()       显示光标所在位置
         truncate()    截断数据，按照字节对源文件进行处理,必须在a或者a+模式
         with open     不用主动关闭句柄
         文件的修改：
            1、以读模式打开源文件
            2、以写模式打开新文件
            3、将源文件读出按照要求修改将修改后的内容写入到新文件
            4、删除源文件
            5、将新文件重命名为源文件

         同一个文件句柄可以写多次

5、函数
   定义：
      def 关键字  函数名():
         函数体
      函数：以功能为导向

      return:返回值
         a. 终止函数    return
         b. 给函数的执行者返回值 return 666
         c.
            '''
               return 或者 return None
               return 单个值
               return 多个值 会将多个值放到一个元祖中
            '''

            def my_len():
               count = 0
               for i in s:
                  couont += 1
               return count
            s = 'fdsfdsfsdfds'
            my_len()
      传参：

            def my_len(argv):  # 形式参数，形参
               count = 0
               for i in argv:
                  couont += 1
               return count
            s = 'fdsfdsfsdfds'
            my_len(s)     # 实际参数，实参

            print(my_len(s))

         - 实参角度：
               - 位置参数：一一对应,按照顺序
                     def func1(a,b,c):
                        print(a,b,c)
                     func1(1,2,'anthony')

                     # def my_max(num1, num2):
                     #     if num1 > num2:
                     #         return num1
                     #     else:
                     #         return num2
                     #
                     #
                     # print(my_max(13, 23))

                     # def my_max(num1, num2):return num1 if num1>num2 else num2
                     #
                     #
                     # print(my_max(13, 23))

               - 关键字参数：一一对应
                     def func2(a,b):
                        print(a,b)
                     func2(a=1,b=2)

               - 混合参数：关键字参数必须在位置参数后面
                     def func3(a,b,c,d):
                        print(a,b,c,d)
                     func3(1,3,d=4,c=9)

            - 形参角度:

               - 位置参数:一一对应,按照顺序

               - 默认参数：默认参数在位置参数的后面

               - 动态参数：*args  **kwargs  万能参数（*在函数定义的时候,代表聚合）魔法应用
                     args：所有的位置参数，放在一个元祖中
                     kwargs:所有的关键字参数，放在一个字典中

                     def func3(*args,**kwargs): （*在函数定义的时候,代表聚合）
                        print(args)
                        print(kwargs)
                     func3(*[1,2,3],*(22,33))  (*函数执行的时候,代表打散)

               - 形参的顺序：
                     位置参数 --> 默认参数 --> 关键字参数