day 7 -10 集合，文本、文件操作，函数

day7

一、回顾

1、列表和字典在循环里边尽量不要删除元素，很麻烦

2、元组：如果元组里边只有一个逗号，且不加逗号，次元素是什么类型，就是什么类型。

二、集合

 '''
 集合：可变的数据类型，它里边的元素，是不可变数据类型；无序，不重复
    {}
 '''
 #错的：
 # set1 = set({, , })
 # set2 = {, , , [, ], {'name': "alex"}}

 # 对的
 set1 = {'alex', 'wusir', 'ritian', 'egon', 'barry', 'barry'}
 # 增add、update
 # add
 # set1.add('女神')
 # update
 # set1.update('abv')

 # 删
 # pop:随机删除
 # set1.pop()      # 返回删除的元素
 # remove：按照元素删除
 # set1.remove("alex")     # 没有元素会报错
 # set1.clear()

 # 查
 # for i in set1:
 #     print(i)

 # 集合
 set1 = {, , , , }
 set2 = {, , , , }

 # 交集
 # print(set1 & set2)
 # print(set1.intersection(set2))

 # 并集
 # print(set1 | set2)
 # print(set2.union(set1))

 # 反交集
 # print(set1 ^ set2)
 # print(set1.symmetric_difference(set2))

 # 差集
 # print(set1 - set2)
 # print(set1.difference(set2))

 # 子集：返回True 或者 False
 # set1 = {, , }
 # set2 = {, , , , , }
 # print(set1 < set2)
 # print(set1.issubset(set2))
 # 超集：返回True 或者 False
 # print(set1 > set2)
 # print(set1.issuperset(set2))

 # 去重
 # li = [,,,,,,,,,,,]
 # li = set(li)
 # li = list(li)
 # print(li)

 # 冻住集合，变为不可变类型
 s = frozenset('barry')

day8

1、文件操作

 # 绝对路径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('咚')

文本文件操作

2、解码

 s = 'abf'
 b = s.encode('utf-8')
 print(b)
 #byte --->str decode 解码
 s1 = b.decode('gbk')
 print(s1)

day9

1、复习

 # 文件处理

     # 打开文件
         # 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','小护士班主任')  #重命名文件

文件操作复习

2、返回值

 # 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定义函数的返回值

3、函数的参数问题

 # 没有参数
 #   定义参数和调用参数的括号都不写内容
 # 有一个参数
 #   传什么就是什么
 # 有多个参数
     # 按照位置传参
     # 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:
     """

函数的形参和实参

day10

1、复习和作业讲解

2、默认函数陷阱

 def qqxing(l = []):
     l.append(1)
     print(l)

 qqxing()
 qqxing([])
 qqxing()
 qqxing()

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

默认函数陷阱

3、函数的命名空间

 # 函数进阶

 # 命名空间个作用域

 # 内置的命名空间
     # 就是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变量，那么这个变量在局部的所有操作对全局的变量有效

函数的命名空间

4、函数的嵌套和作用域链

 # 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('')

函数的嵌套和作用域链（闭包）