bytes类型

input--out---correction(输入输出正确）
***第一模块回顾
    byte类型：数据存到硬盘，硬盘只能存储2进制。
            gbk/utf-8--->>decode(解码）--->>unicode
            Unicode--->>encode(编码）--->>gbk/utf-8(2进制）
            文字--》utf-8/gbk-->>2进制
            图片--》jpg/png-->>2进制
            音乐--》mp3/wav-->>2进制
            视频--》mp4/mov-->>2进制
        bytes类型，以16进制形式表示，2个16进制数（如0x e 5）构成一个byte（字节），
        以‘b’来标识
    1byte = 8bit
    python3文件的默认编码是utf-8（pycharm默认加载文件都是用utf-8编码）
    eg：f = open('bytes.txt','w',encoding='gbk')  # 自己指定编码
    eg：f = open('bytes.txt','wb')  # 以2进制模式就不用指定编码
            
        ‘wb’-----二进制写（必须是二进制）
        ‘w’------文件写（必须是字符串）
            
            python按你指定的编码来编成2进制
            
    总结 ： 1，字符存硬盘 要变成bytes
            2，网络传输  字符要变成bytes类型
            
**深浅copy
    dict,list,set,（和变量赋值指向不一样）
    s = {'name' : 'alex', .....}
    s2 = s ,此时s2和s是共享 同一份数据的（指向同一个内存地址(杯子）），
    s，s2改dict，list，set里面的任一元素会同时改。
    
    深浅copy（借助copy模块）
    s.copy，浅copy（只复制第一层）复制一份数据，
    只能改第一层的（第一层独立），里面的嵌套断线的数据改了会同时变
    
    s.deepcopy，深copy，所有层都完全独立。
    
**编码转换
    >>> s
    '你好未来'
    >>> s.encode('utf-8')  #编码，以utf-8编码成2进制
    b'\xe4（2个16进制数）\xbd\xa0\xe5\xa5\xbd\xe6\x9c\xaa\xe6\x9d\xa5'#12个字节
    >>> s_utf8 = s.encode('utf-8')
    >>> s_utf8
    b'\xe4\xbd\xa0\xe5\xa5\xbd\xe6\x9c\xaa\xe6\x9d\xa5'

    >>> s_utf8.decode('utf-8')  #以utf-8格式解码，也可以不写，就会以python3默认的utf-8
    '你好未来'
    
**编码与解码（以utf-8格式编码的就必须用utf-8解码，不然会报错）
    
    gbk/utf-8--->>decode(解码）--->>unicode
    Unicode--->>encode(编码）--->>gbk/utf-8(2进制）
    s.encode('utf-8')-->>以utf-8格式编码成2进制
    s.dncode('utf-8')-->>从2进制解码成unicode str
    
**编码的转换：把文字从一种编码转成另外一种，比如，从gbk转成utf-8
        Unicode：万国码，跟所有的编码之间有映射关系
            >>> s
            '你好未来'
            >>> s.encode('utf-8')
            b'\xe4\xbd\xa0\xe5\xa5\xbd\xe6\x9c\xaa\xe6\x9d\xa5'
            >>> s
            '你好未来'
            >>> s.encode('gbk')
            b'\xc4\xe3\xba\xc3\xce\xb4\xc0\xb4'
            >>> s_gbk = s.encode('gbk')
            >>> s_gbk.decode('gbk')
            '你好未来'
            >>> s_gbk.decode('gbk').encode('utf-8')  #gbk转换为utf-8
            b'\xe4\xbd\xa0\xe5\xa5\xbd\xe6\x9c\xaa\xe6\x9d\xa5'
2进制模式：rb  wb  ab
r 文本模式，把2进制解码成str，Unicode



**函数
    特性：1，减少重复  2，使程序易扩展  3， 使程序易维护

    返回值（return），意味着函数的中止
    
    def register(name, age, major, country = 'CN',*args,**kwargs):  # 这里country是默认参数
        info = """
        --------你的注册信息---------
        name:  %s
        age:  %s
        major:  %s
        country:  %s
        """ % (name,age,major, country)
        print(info)
    
    register('alex', 22, 'cs')
    register('al', 22, 'math')
    register('ax', 22, 'us', 'US')
    
    函数的参数： 形参和实参
    
    函数参数的优先级：位置参数  >  默认参数/关键参数
    
    
                函数外部的代码要想获取函数的执行结果，就可以在函数里用return
                语句把结果返回。
                def stu_register(name, age, course = 'PY', country = 'CN'):
                    print('-----注册学生信息-----‘）
                    print('Name:', name)
                    print('Age:', age)
                    print('Country:', country)
                    print('Course:', course)
                    if age > 22:
                        return False
                    else:
                        return True
                registriation_status = stu_register('alex', 22, course='PY', 'CN')
                if registriation_status:
                    print('注册成功’）
                else:
                    print('too old to be a student.')
                
*注意：1.函数在执行过程中，只要遇到return语句，就会停止执行并返回结果，所以
    也可以理解为return语句代表函数的结束。
    2.如果未在函数中指定return，那这个函数的返回值为None
    
    函数返回多个值
        def test():
            return 1,2,3,4,5   #  返回多个值会以tuple包起来
        print(test())


**全局变量和局部变量    （locals()方法，打印所有的局部变量
                      globals()方法，打印所有的全局变量）（从局部变量》嵌套变量》全局变量）
        name = 'alex'  #  全局变量
        def change():
            name = '金角大王'  #局部变量
            global name #  在函数内部声明（创建）一个全局变量
            print(name)
            print(locals())
            print(globals())
        
        change()
        print(name)
        
**函数传递列表，字典，集合时发生的现象        
            d = {'name':'alex', 'age':28, 'hobby':'dabaojian'}
            l = ['rebeeca', 'katrina', 'rachel']
                    
            def change_data(info, girls):
                info['hobby'] = 'study'
                girls.append('xiaoyun')
            change_data(d,l)
            print(d,l)##  dic,li 这个内存地址没有变，只是里面的元素变了

            结果为d 为{'name': 'alex', 'age': 22, 'hobbie': 'study'}
            l为['Rebeeca', 'Katrina', 'Rachel', 'xiaoyun']

**嵌套函数，匿名函数和高阶函数    
    嵌套函数        name = '小猿圈'
                    def change():
                        # name = '小猿圈，自学编程'
                        def change2():
                            #global name 如果声明了这句，下面的name改的是最外层的全局变量
                            # name = '小猿圈，自学编程,不要钱'
                            print('第3层打印', name)
                        change2()  # 调用内层函数
                        print('第2层打印', name)
                    change()
                    print('最外层打印',name)
                    
    匿名函数
        c = lambda x,y:x**y
        print(c(2,8))
    与下面的代码等价：
        def calc(x, y):
            return x**y
        print(calc(2, 8))
    
    
            例子:    def calc(x):
                    return x**2
                #res = map(calc, [1,2,3,4,5,6])
                res = map(lambda x:x**2,[1,2,3,4,5,6]）#lambda函数中最多加一个三元运算
                print(res)
                for i in res:
                    print(i)
    
    高阶函数：1,接收一个或者多个函数作为输入 2，return返回另外一个函数
        def get_abs(n):
            if n < 0:
                n = int(str(n).strip('-'))
            return n
        def add(x,y,f):
            return f(x) + f(y)
        res = add(3, -6, get_abs）
        print(res)