# 绝对路径D:\测试.txt

 # f = open('D:\测试.txt', mode='r', encoding='gb2312')

 # contert = f.read()

 # print(contert, type(contert))

 # f.close()

 # 只读r

 # f = open('log', mode='r', encoding='utf-8')

 # contert = f.read()

 # print('{}\n{}'.format(contert, type(contert)))

 # f.close()

 # 只读rb

 # f = open('测试', mode='rb')

 # contert = f.read()

 # print('{}\n{}'.format(contert, type(contert)))

 # f.close()

 # 写w：没有的话创建，有的话覆盖原文件

 # 没有创建

 # f = open('log', mode='w', encoding='utf-8')

 # f.write('骑兵步兵')

 # f.close()

 # 覆盖

 # f = open('log', mode='w', encoding='utf-8')

 # f.write('经典拉扣设计的啦')

 # f.close()

 # 写wb：

 # f = open('log', mode='wb')

 # f.write('大手大脚拉开手机'.encode('utf-8'))

 # f.close()

 # 追加

 # a

 # f = open('log', mode='a', encoding='utf-8')

 # f.write('\n追加文字"啦啦啦啦啦啦"')

 # f.close()

 # ab

 # f = open('log', mode='ab')

 # f.write('追加文字"啦啦啦啦啦啦"'.encode('utf-8'))

 # f.close()

 # 读写'r+'：先读，再写

 # f = open('log', mode='r+', encoding='utf-8')

 # print(f.read())

 # f.write('\n读写“哈哈哈”')

 # f.close()

 # 读写r‘+’：先写再读    这种方式会重头开始写，然后一个字符一个字符的覆盖原有内容

 # f = open('log', mode='r+', encoding='utf-8')

 # f.write('aaa')

 # print(f.read())

 # f.close()

 # 写读：w+

 # f = open('log', mode='w+', encoding='utf-8')

 # f.write('aaa')

 # f.seek(0)

 # print(f.read())

 # f.close()

 # 功能详解

 f = open('log', mode='r+', encoding='utf-8')

 # content = f.read(3)       # 前三个字符

 # f.seek(14)                # 按照字节进行跳转光标

 # f.tell()                  # 告诉你光标的位置

 # f.readable()              # 判断是否可读

 # f.readline()              # 一行一行的读

 # print(f.readlines())      # 每一行当成列表中的元素，添加到list中

 # f.truncate(3)               # 截取前三个

 # for line in f:

 #     print(line)

 # f.close()

 # 追加查看

 #  f = open('log', mode='a+', encoding='utf-8')

 # f.write('\n追加文字李二')

 # f.seek(f.tell()-9)

 # print(f.read(2))

 # f.close()

 #with 循环

 # with open('log', mode='a', encoding='utf-8') as l, \

 #         open('测试', mode='a', encoding='utf-8') as c:

 #     l.seek(6)

 #     l.write('咚')

 #     c.seek(6)

 #     c.write('咚')

 # 文件处理

     # 打开文件

         # open(‘路径’,mode'打开方式',encoding'编码方式')

         # 打开方式 r w a r+(可读可写) w+（可写可读） a+(可追加可读) b

             # r+ 打开文件直接写 和读完再写

         # 编码方式：一般用utf-8

     # 操作文件

         # 读:

             # read:一次性读

             # readlines:一次性读

             # readline：一行一行读

                 # 不知道哪里结束

                 # 视频、图片是 用rb打开 文件是bytes，可以按照字节读

             # for循环 --> 最好

         # 写:

             # write：

         # 光标 ——> 文件指针

             # seek ——> 指定光标移动到某个位置

             # tell ——> 获取光标位置

             # truncate ——> 截取文件

     # 关闭文件

         # close

     # 修改文件

         # 文件python没有提供

 # 修改文件方法

 # with open('小护士班主任',encoding='utf-8') as f,open('小护士班主任.bak','w',encoding='utf-8') as f2:

 #     for line in f:

 #         if '星儿' in line:  #班主任:星儿

 #             line = line.replace('星儿','啊娇')

 #         #写文件

 #         f2.write(line) #小护士:金老板

 #

 # import os

 # os.remove('小护士班主任') #删除文件

 # os.rename('小护士班主任.bak','小护士班主任')  #重命名文件

 # def my_main():

 #     return "返回值"

 # 返回值三种情况:

 # 1、没有返回值：①不写return ②只写return ③ return None

 # ①

 # def func():

 #     l = ['老大', '老二']

 # ②只写return，没有返回值

 # def func():

 #     l = ['老大', '老二']

 #     return

 # 2、返回一个值:可以返回任何数据类型，只要返回了就可以接受

 # def func():

 #     return [1, 2, 3, 4]

 # print(func())

 # 3、返回多个值:可以用多个变量接收、也可以用一个变量接受，会接受一个元祖

 #     def func():

 #         return 1, 2

 #

 #

 #     a, b = func()

 #     print(a, b)

 # 参数，定义时候的参数叫做形参，传入参数叫做实参

 # def my_len(形参)

 #     print('6')

 # my_len('实参')

 # 没有参数

 #   定义参数和调用参数的括号都不写内容

 # 有一个参数

 #   传什么就是什么

 # 有多个参数

     # 按照位置传参

     # def my_sum(a, b):

     #     res = a + b

     #     return res

     # my_sum(1, 2)

     # 按照关键字传参

     # def my_sum(a, b):

     #     res = a + b

     #     return res

     # my_sum(b = 2, a = 1)

     # 混着用:必须先按照位置传参，再按照关键字传参

     # def my_sum(a, b):

     #     res = a + b

     #     return res

     # my_sum(1, b = 2)

     # 动态传参

         # def func(*args):

         #     print(args)

         # l = [1,2,3,4,5]

         # func(*l)

         # def func(**kwargs):

         #     print(kwargs)

         # d = {'a':1,'b':2}

         # func(**d)

 # 站在形参角度

     # 位置参数：必须传，且有几个参数就传几个值

     # 默认参数：可以不传，不传的话使用默认值

     # def classmate(name, sex='男'):

     #     print('%s : %s' % (name, sex))

     # classmate('二哥')

     # classmate('小孟', '男')

     # classmate('大猛', '男')

     # classmate('朗哥', '女')

     # 动态参数:可以接受任意个参数*args必须在**kwargs之前

         # ①*args：接收的是按照位置传参的值，组织成一个元祖

         # ②**kwargs：接收是按照关键字传参的,组成一个字典

     # def my_sum(*args):

     #     n = 0

     #     for i in args:

     #         n += i

     #     return n

     # print(my_sum(1, 2, 3, 4))

 # 形参参数的定义顺序：位置参数，*args，默认参数，**kwargs

 # 函数的注释

 def func(l,b):

     """

     :param l:

     :param b:

     """

 def qqxing(l = []):

     l.append(1)

     print(l)

 qqxing()

 qqxing([])

 qqxing()

 qqxing()

 # 如果默认参数的值是一个可变数据类型，那么每一次调用函数的时候，如果不传值就公用这个数据类型的资源

 # 函数进阶

 # 命名空间个作用域

 # 内置的命名空间

     # 就是python解释器一启动就可以使用的名字存置命名空间中

     # 内置命名在启动python解释器的时候被加载进内存里

 # 全局命名空间

     # 实在程序从上到下被执行的过程中依次被加载进内存的

     # 放置了我们设置的所有变量和函数命

 # 局部命名空间

     # 就是函数内部的名字

     # 就是调用函数的时候 才会产生这个命名空间，随着函数执行的结束，这个名称空间就消失了

 # 在局部:可以使用全局、内置命名空间中的名字

 # 在全局：可以使用内置命名空间的名字，但是不能使用局部

 # 再内置：不能使用局部和全局的名字的

 # 作用域

 # 全局作用域 -- 作用在全局 -- 内置和全局名字空间中的名字都属于全局作用域 -- locals

 # 局部作用域 -- 作用在局部 -- 函数（局部名字空间中的名字属于局部作用域） -- globals

 a = 1

 b = 2

 def func():

     x = 'aaa'

     y = 'bbb'

     print(locals())

 func()

 print(globals())

 # globals:永远打印全局的名字

 # locals：输出什么，根据locals所在的位置

 # a = [1,2]

 # def dunc():

 #     a.append(3)

 # dunc()

 # print(a)

 # 对于不可变数据，在局部可以查看全局作用域中的变量

 # 但是不能修改

 # 如果想要修改，需在程序的一开始添加global生命

 # 如果在一个局部（函数）内声明一个global变量，那么这个变量在局部的所有操作对全局的变量有效

 # def max(a, b):

 #     return a if a > b else b

 #

 #

 # def the_max(x, y, z):  # 函数的嵌套调用

 #     c = max(x, y)

 #     return max(c, z)

 #

 #

 # print(the_max(1, 2, 3))

 # nonlocal 只能用于局部变量，找上层中离当前最近一层的局部变量

 # 闭包

 a = 1

 def outer(a):

     def inner():

         nonlocal a

         a += 1

         print(a)

     # print(inner.__closure__)        # 点有这个不返回None就会就是闭包

     return inner

 inner = outer(5)

 inner()

 # import urllib   # 模块，就是一个python文件

 # from urllib.request import urlopen

 # urlopen('')