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('')
函数的嵌套和作用域链（闭包）