7.10周报

周报

上周内容回顾

数据类型的内置方法

• 整型和浮点型(没有内置方法只有类型的转换 python对数字不敏感会有误差)
• 字符串的内置方法

索引取值相关方法 
分割：split() 
拼接：join()  + 
获取字符串长度：len() 
大小写转换：upper()lower() isupper() islower() 
获取单个字符数量：count() 
判断是否纯数字：isdigit()
判断首尾字符：starswith() endswith() 
删除首尾指定字符：strip() lstrip() rstrip()
替换：replace() 
字符串格式化输出：format() 

• 列表的内置方法

通用删除:del
指名道姓删除:remove()
先取除数值再删除:pop()
查询数据值对应的索引值:index()
统计某个数据出现的次数:count()
排序:sort() (默认为升序)
降序sort(reverse = True)
反转:reverse()

• 字典内置方法

类型转换：
print(dict(['name','john'),('age',20)])	#{'name': 'john', 'age': 20}
print(dict(name='john', age=20))  # {'name': 'john', 'age': 20}
1.取值操作：print(dict.get())
2.统计字典内键值对个数:len()
3.修改数据:dict = {'username': 'john', 'age': 20}
dict['username'] = 'tony'  # 键存在则修改
print(dict)  # {'username': 'tony', 'age': 20}
4.添加数据：dict = {'username': 'jason', 'age': 18}
dict['hobby'] = ['read', 'run']  # 键不存在则增加
print(dict)  # {'username': 'jason', 'age': 18, 'hobby': ['read', 'run']}
5.删除数据
方式一：del
dict = {'username': 'jason', 'age': 18} del dict['username']
print(dict)  # {'age': 18}

方式二：pop() dict = {'username': 'jason', 'age': 18} res = dict.pop()
print(dict, res)  # {'username': 'jason'} 18

方式三：popitem() 随机删除

6.快速获取键 值 键值对数据  keys()  values()  items()
dict = {'username': 'jason', 'age': 18} print(dict.keys())  #
dict_keys(['username', 'age']) print(dict.values())  #
dict_keys(['jason', 18]) print(dict.items())  #
dict_keys([('username', 'jason'), ('age', 18)]

7.修改字典数据 键存在则修改 不存在则新增 update() dict = {'username': 'jason', 'age': 18} dict.update({'username': 'jasonNB'}) print(dict)  # {'username': 'jasonNB', 'age': 18} dict.update({'hobby': ['read', 'run']})
print(dict)  # {'username': 'jasonNB', 'age': 18, 'hobby': ['read', 'run']}
8.快速构造字典  给的值默认情况下所有的键都指向同一地址
res = dict.formkeys([1, 2, 3], None) print(res)  # {1: None, 2: None, 3: None} res = dict.formkeys(['username', 'age'], [])
res['username'].append('jason') print(res)  # {'username': ['jason'], 'age': ['jason']}  因为指向的是同一个地址 所以都改变了
9.setdefault()  键存在则获取键对应的值 键不存在则设置 并返回设置的新值
dict = {'username': 'jason', 'age': 18} 
res =dict.setdefault('username', 'jasonNB') 
print(dict, res)  #{'username': 'jason', 'age': 18} jason 
res = dict.setdefault('hobby', 'read') 
print(dict, res)  # {'username': 'jason', 'age': 18, 'hobby': 'read'} read

• 元组内置方法

关键字：tuple
类型转换：支持for循环的数据类型可以转元组 
注意事项：当元组只有一个数据时，需在数据结尾加, 否则生成的就是该数据数据类型的数据 	
t1 = (12) 	
t2 = (12,) 	
print(type(t1))  # int 	
print(type(t2))  # tuple 
内置方法：
	1.索引相关操作
	2.统计元组内数据值的个数 len()
	3.查与改 	
t1 = (11, 22, 33, 44, 55, 66) 	
print(t1[0])  # 11 	
t1[0] = 1  # 报错 不能改 注：这种修改改的是绑定的地址 	
面试题： 	
t1 = (11, 22, 33, [11, 22]) 	
t1[-1].append(33) 	
print(t1)  # (11, 22, 33, [11, 22, 33]) 注：append只是给list中添加数据 并没有改变地址绑定

• 集合内置方法

s1 = {'jason', 'kevin', 'tony', 'jerry'}
s2 = {'jason', 'tony', 'oscar', 'carsh'}
1.求共同好友
print(s1 & s2)  # {'jason', 'tony'}
2.求s1 s2各自独有的好友
print(s1 - s2)  # {'kevin', 'jerry'}
print(s2 - s1)  # {'oscar', 'carsh'}
3.求s1 s2 所有的好友
print(s1 | s2)  # {'jason', 'kevin', 'tony', 'jerry', 'oscar', 'carsh'}
4.求s1 s2不共同拥有的好友
print(s1 ^ s2)  # {'kevin', 'jerry', 'oscar', 'carsh'}
5.子集 父集
s1 = {1, 2, 3, 4, 5}
s2 = {1, 2, 3}
s3 = {3, 2, 1}
print(s1 > s2)  # True
print(s1 > s3)  # True 集合是无序的

• 可变类型和不可变类型

为什么字符串调用内置方法是产生新的值
列表调用内置方法是改变自身
"""
1.可变类型  list 
    值改变（内置方法） 内存地址可以不变
2.不可变类型  str  int  float bool 
    值改变 内存地址肯定变

垃圾回收机制

1.引用计数
数据每次被使用（名字绑定、数据相互绑定） 都会记1
只要计数不为0 就不会被清除
2.标记清除
引用计数中存在循环引用的数据 而引用计数机制无法清除该内存
标记清除就是专门针对这类数据
每隔一段时间扫码全部数据 并给循环引用记上标记 然后一次性清除
3.分代回收
因为标记清除每次清除都会占用大量资源
所以采取分代机制 少用的为0 稍多的为1 最频繁的为2 以此来划分 级别越高清除的时间间隔越长

补充知识

1.为了取消\与字母之间组合而成的特殊意义符号
	在字符串前使用r取消转义
		如：
			print(r'\n\b\c’)  # \n\b\c
2.with上下文管理
	可以同时打开多个文件
3.循环数据类型的时候不要轻易修改数据类型内部的数据个数
	如：
		l1 = [1, 2, 3, 4, 5, 6, 7]
		for i in l1:
			pop(l1)

文件的读写模式

1.r  只读模式  默认模式
	文件路径不存在则报错
2.w  只写模式
	文件路径不存在则新建一个该路径的文件  路径存在则清空原有的内容再等待后续操作
3.a  只追加模式
	文件路径不存在则新建一个该路径的文件  路径存在不清空原有的内容 而是默认在内容末尾等待后续操作

文件的操作模式

1.t  文本模式  默认模式
	rt  wt  at
	只能操控文本文件
	必须指定encodig参数
	操作以字符串为单位
2.b  二进制模式
	rb  wb  ab
	可以操作所有类型文件
	不需要指定encoding参数
	操作以字节（bytes）为单位

文件处理的诸多方法

read()  仅在r模式下可用 默认读取全部内容 之后光标处于读取内容的末尾
readline()  读取一行  多配合for使用  减少资源占用
readlines()  读取全部 以列表的形式将每行内容存储到返回值中
readable()  判断文件可读性
write()  仅在 b a 模式下可用
writelines()  将可被for循环的数据类型中的值 依次写入文件中
writable()  判断文件可写性

文件内光标的移动

read()补充
read()括号内可以输入数字
具我们所知，直接调用read()，会读取全部内容，然后再次读取就读不到东西了，但其实原理是，在调用read()后，读取全部数据后，光标会停在内容末尾，而read()就是从当前光标位置开始阅读，直到读完，所以在第二次调用read()时，光标处于内容末尾，所以读不到东西，而通过输入数字，可以指定光标的位移量，达到只读取指定数量内容的目的

# 文件a.txt内容如下
# 你好a你好a你a好

# 在 rt 模式下read()内输入数字
with open('a.txt', 'rt', encoding='utf8') as f:
    print(f.read(3))  # 你好a
    print(f.read(4))  # 你好a你
    print(f.read(6))  # a好

# 在 rb 模式下read()内输入数字
with open('a.txt', 'rb') as f:
    print(f.read(3).decode('utf8'))  # 你
    print(f.read(4).decode('utf8'))  # 好a
    print(f.read(6).decode('utf8'))  # 你好

"""可以发现在两种模式下 相同的read() 却读出了不同的内容"""

文件修改两种方法

# 覆盖写
with open('a.txt', 'rb') as f:
    data = f.read()

with open('a.txt'm 'wb') as f:
    f.write(data)
"""
这种方法只占用一个磁盘空间，但操作大文件时会造成内存溢出
"""

# 重命名
with open('a.txt', 'rb') as f1, open('b.txt', 'wb') as f2:
    for line in f1:  # 通过for循环一次获取每一行的数据
        f2.write(line)
# 然后删除a.txt 给b.txt重命名为a.txt
# 这种方法同一时间可能占用两个磁盘空间，但大幅度减少了内存溢出的概率

函数

函数的简介

用于减少重复代码的编译量

函数与循环的关系

循环是在相同的位置反复执行相同的代码 函数是在不同的位置反复执行相同的代码

函数的本质

可以将函数看成制作完成（定义）的工具 在需要使用（调用）时 直接使用（调用）

函数的语法结构

# 定义
def 函数名(形参1, 形参2, ...):
    """注释"""
    函数体代码
    return 返回值
# 调用
函数名(实参1, 实参2, ...)

语法结构分析

在定义阶段
def 定义函数的关键字
函数名 用于绑定函数体代码 定义时尽量做到见名知意

def get_user_info():  # 可以知道 该函数用于 获取用户信息

括号 在定义函数时函数名后面必须跟括号
形参 函数体需要输入的数据 一般来讲 有多少形参 调用函数时就需要输入多少数据
注释 用于介绍函数的功能 以及需要的参数
函数体代码 整个函数的核心
return 用于返回数据的关键字 可以不写 默认为None
返回值 使调用函数时产生一个可以被接收的数据 接收方式 变量名 = 函数名()

在调用阶段
函数名 使用函数名加括号的形式进行调用
括号 函数调用时必须添加括号
实参 与形参绑定 一般情况下 有多少形参 就需要输入多少实参

函数的定义与调用

定义与调用的关系
函数在调用前 必须先定义 既定义在调用语句的上面

定义与调用的方法
通过def关键字进行定义，使用函数名加括号的方式进行调用

定义与调用逻辑
函数在定义阶段不会执行代码块代码，在调用时才会执行，在定义阶段只检测函数体代码语法

函数名解释

函数名绑定的是一块内存地址，里面存放了函数体代码
要想运行该代码 就需要调用函数>>>:函数名加括号
函数名加括号执行优先级最高（定义阶段除外）

函数的分类

内置函数
解释器提前定义好的函数，用户可以直接调用，如len() print() input()
内置函数可以直接调用，但数据类型的内置方法必须以数据类型.内置方法的方式才可以使用
既数据类型的独有方法

l1 = [1, 2, 3, 4, 5]
print(len(l1))  # 5 print 和 len 可以直接使用
l1.remove(2)  # 需要以 数据类型.内置方法 的方式
print(l1)  # [1, 3, 4, 5]

空函数
没有实际的意义，用于前期框架的搭建，表明要实现的功能

def run():
	pass
def fly():
	pass

无参函数
函数定义阶段没有形参

def func():  # 没有形参
    print('这里是func')

func()  # 不需要参数就可以调用
# 执行结果
# 这里是func

有参函数
函数定义阶段有形参

def func(a, b):  # 有参数 需要输入
    print(a, b)

func(2, 3)  # 需要输入实参
# 执行结果
# 2 3

函数的返回值

返回值的性质
返回值就是调用函数之后产生的结果，有时可有可无
通过以下方法获取函数返回值
变量名 = 函数名()
上述方法有返回值则返回返回值，没有则默认返回 None

情况1：函数无return关键字
返回None

def func():pass  # 函数内若只有一行 可以写成这种形式
res = func()
print(res)  # None

情况2：函数有return关键字 但return后不跟数据
返回None

def func(): return
res = func()
return(res)  # None

情况3：函数有return关键字 return后跟单个数据
返回该数据

def func(): return 123
res = func()
print(res)  # 123

情况4：函数有return关键字 return后跟多个数据
将多个数据以元组的形式传出

def func(): return 123, 342, 221, 2233
res = func()
print(res)  # (123, 342, 221, 2233)

return 在函数中的作用
就像break在循环中的作用 读到就会退出函数

def func():
    print(123)
    return
    print(321)

func()
# 运行结果
# 123

函数的参数

参数的分类
参数可大致分为 形参和实参两种参数
形参是函数定义阶段括号内的参数
实参是函数调用阶段括号内的参数

def func(形参):
    pass
func(实参)

形参与实参的关系
形参与实参就像是变量名与数据值
函数调用的阶段 实参与形参 临时绑定 在函数执行结束时结束绑定关系

位置参数
在函数定义阶段括号内从左往右依次填写的变量名，称之为位置形参
在函数调用阶段括号内从左往右依次填写的数据值，称之为位置实参

关键字参数
在函数调用阶段可以以 形参=数据值 的形式 为形参赋值 关键字参数必须在位置参数后面
多个关键字参数之间可以随意调动位置

def func(a, b, c):
    print(a, b, c)
func(123, c=222, b=999)
# 运行结果
# 123 999 222
"""
1.指名道姓的给形参传值（打破了位置的限制）
2.位置实参必须在关键字实参的前面
    小诀窍：无论是形参还是实参 都遵循短（简单）的在前面 长（复杂的）的在后面
3.同一个形参在一次调用中 只能传一次值
"""

默认值参数
在函数定义阶段可以给形参指定一个默认值
在函数调用阶段就可以不输入该形参的数据 而使用默认数据
默认值参数必须在位置参数的后面

def func(a, b, c=888):
    print(a, b, c)
func(b=999, a=777)
# 运行结果
# 777 999 888

可变长参数
可以打破形参与实参的个数限制，随意传值

def func(*args, **kwargs):  # args 和 kwargs 只是变量名 可以任意修改 但要符合命名规范
    print(args, kwargs)

func(1, 2, 3, 4, 5, 6, 7, name='jason', age=18)
# 运行结果
# (1, 2, 3, 4, 5, 6, 7) {'name': 'jason', 'age': 18}

本周内容回顾

函数进阶

/* 和 ** 在实参中的作用
*可以将列表中的数据依次传入形参中

def func(*args): print(args)
l1 = [1, 2, 3, 4, 5]
func(l1)  # ([1, 2, 3, 4, 5], )  可以看出 只是将列表传入 而不是内部数据依次传入
func(*l1)  # (1, 2, 3, 4, 5)

**可以将字典中的数据已关键字参数的形式传入

def func(*args, **kwargs): print(args, kwargs)
d1 = {'name': 'jason', 'age': 18}
func(d1)  # ({'name': 'jason', 'age': 18},) {}
func(**d1)  # () {'name': 'jason', 'age': 18}

命名关键字参数
作用：要求函数的某些参数必须以关键字参数的形式传参

def func(a, b, *args, c, **kwargs):  # * 和 ** 中的形参 就必须以关键字的形式传入
    print(a, b, args, c, kwargs)

func(1, 2, 3, 4, 5, c=4, f=15, e=123)
# 运行结果
# 1 2 (3, 4, 5) 4 {'f': 15, 'e': 123}

名称空间

名称空间的定义
用于存储变量名与数据的绑定关系的空间

名称空间的分类
内置名称空间
python解释器打开时立刻创建的空间
用于存放内置方法 与内置变量
无法直接修改或删除该空间的东西
解释器关闭 空间关闭

全局名称空间
py文件运行是产生的名称空间 用于存储程序运行后产生的变量名
程序结束 空间关闭

局部名称空间
函数调用是产生的名称空间 用于存储函数调用阶段产生的变量名
函数运行结束 空间关闭

名称查找顺序
在查找名称空间时 要先知道当前在什么空间
1.若在局部名称空间
查找顺序：局部名称空间>>>全局名称空间>>>内置名称空间
2.若在全局名称空间
查找顺序：全局名称空间>>>内置名称空间

名称空间的作用域
内置名称空间
在全局任意位置都可以调用（全局有效）

全局名称空间
在全局任意位置都可以调用（全局有效）

局部名称空间
在各自局部空间可以调用（局部有效）

global 与 nonlocal关键字
主要用于修改不可变类型的数据

# global 用于在局部空间修改全局名词空间中的数据
a = 10
def func1():a = 20
func1()
print(a)  # 10  只是在局部空间内产生了一个新的a 并没有修改全局名称空间中的a

def func2():
    global a
    a = 20
func2()
print(a)  # 20  修改成功

# 若想要修改的数据为可变类型
l1 = [1, 2, 3, 4, 5]
def func():l1.append(6)
func()
print(l1)  # [1, 2, 3, 4, 5, 6]  也可以修改 因为可变类型的操作只是修改自身数据 并没有产生新的值

# nonlocal 用于在嵌套局部空间中 修改上一层局部空间内的数据
def func1():
    a = 10
    def func2():
        a = 20
    func2()
    print(a)

func1()  # 10  只是在内部空间的内部空间中产生了一个新的a

def func3():
    a = 10
    def func4():
        nonlocal a
        a = 20
    func4()
    print(a)

func3()  # 20

函数名的多钟使用方式

函数名可以用作赋值

def func():
    print('from func')

res = func  # 将 func 所绑定的代码块 与 res 进行绑定
res()
# 运行结果
# from func

函数名可以用作返回值

def func1():
    def func2():
        print('from func2')
    return func2

res = func1()  # res 获取func1的返回值 func2 与func2所绑定的代码块进行绑定
res()  # 实则调用的是func2

# 运行结果
# from func2

函数名可以用作实参

def func1():
    print('from func1')

def func2(func_name):
    func_name()

func2(func1)

# 运行结果
# from func1

函数名可以用作容器类型数据的数据值

def func1():
    print('from func1')

l1 = [1, 2, 3, 4, func1]
l1[4]()

# 运行结果
# from func1

装饰器

闭包函数

闭包函数的条件
1.定义在函数内部的函数
2.内部函数使用的外部名称空间中的变量名

def func1():
    s = 'from func1'
    def func2():
        print(s)
    return fucn2

res = func1()
res()

# 运行结果
# from func1

装饰器简介
装饰器并不是全新的知识 而是所学的一些知识的集合

装饰器本质
在不改变被装饰函数的调用方式和内部代码的情况下给被装饰对象添加功能

装饰器原则
对修改封闭 对扩张开放

知识储备 time模块

import time  # import关键字用于导入已有的模块  模块就类似工具箱
time.time()  # 获取当前时间距离1970年1月1日0时0分0秒的 秒数 既：时间戳
# 实际运用：一段代码执行的秒数
def func():
    time.sleep(3)  # 运行到这时原地等待3秒

start_time = time.time()  # 记录开始时间
func()
end_time = time.time()  # 记录结束时间
print(end_time - start_time)  # 结束时间减去开始时间获得的秒数 就是代码执行的时间

装饰器模版

def outer(func_name):
    def inner(*args, **kwargs):
        """这里执行函数运行前执行的代码"""
        res = func_name(*args, **kwargs)
        """这里执行函数运行后执行的代码"""
        return res
    return inner

装饰器语法糖

def outer(func_name):
    def inner(*args, **kwargs):
        """这里执行函数运行前执行的代码"""
        res = func_name(*args, **kwargs)
        """这里执行函数运行后执行的代码"""
        return res
    return inner

@outer  # 可以看做 func = outer(func)
def func():
    pass

装饰器进阶

多层装饰器

def outer1(func_name):
    print('加载了 outer1')
    def inner(*args, **kwargs):
        print('from outer1')
        res = func_name(*args, **kwargs)
        return res
    return inner

def outer2(func_name):
    print('加载了 outer2')
    def inner(*args, **kwargs):
        print('from outer2')
        res = func_name(*args, **kwargs)
        return res
    return inner

def outer3(func_name):
    print('加载了 outer3')
    def inner(*args, **kwargs):
        print('from outer3')
        res = func_name(*args, **kwargs)
        return res
    return inner


@outer1  # 看做 outer2 = outer1(outer2)
@outer2  # 看做 outer3 = outer2(outer3)
@outer3  # 看做 func = outer3(func)
def func():
    pass

# 运行结果
# 加载了 outer3
# 加载了 outer2
# 加载了 outer1
# 得知 绑定装饰器时 从下往上开始加载

# 加入func()
func()

# 运行结果
# 加载了 outer3
# 加载了 outer2
# 加载了 outer1
# from outer1
# from outer2
# from outer3
# 得知 运行函数时 装饰器从上往下运行

有参装饰器

用于对数据来源的判定 分组

# 当要对装饰器内输入参数时 发现
def outer(func_name):  # 这里不能输入 语法糖加入时无法输入参数
    def inner(*args, **kwargs):  # 这里不能输入 因为若要添加一个额外的参数 函数调用时修改了调用方式
        res = func_name(*args, **kwargs)
        return res
    return inner

# 解决方法
# 对装饰器整体进行闭包

def outer1(target_user):  # 在这就可以输入参数并且不影响原函数的调用方式 与内部代码
    def outer(func_name):
        def inner(*args, **kwargs):
            if target_user == 'student':
                print('调用了有关学生的方法')
            elif target_user == 'teacher':
                print('调用了有关老师的方法')
            res = func_name(*args, **kwargs)
            return res
        return inner
    return outer

# 使用方法
@outer1('student')
def get_student_info():pass
@outer1('teacher')
def get_teacher_info():pass

get_student_info()
get_teacher_info()
get_teacher_info()
get_student_info()

# 运行结果
# 调用了有关学生的方法
# 调用了有关老师的方法
# 调用了有关老师的方法
# 调用了有关学生的方法

算法

算法的定义
解决问题的方法

二分法
局限性：数据有序排序，当数据在开头或结尾时，比顺序查找费时间

三元表达式

# 语法
# 数据值1 if 条件 else 数据值2
# 条件成立 返回数据1  条件不成立 返回数据2

# 使用
res = 10 if 5 > 20 else 12
print(res)  # 12

各种生成式

列表生成式

# 例子
l1 = [1, 2, 3, 4, 5, 6]
l2 = [i for i in l1 if i != 4]
print(l2)  # [1, 2, 3, 5, 6]

# 语法结构
# [变量名的相关处理 for 变量名 in 数据集]
# 先执行for循环  然后将一个个的数据值交给for循环前面处理
# [变量名的相关处理 for 变量名 in 数据集 if 条件]
# 先执行for循环  然后将一个个的数据值交给if判断 结果为True则最后交给for循环前面处理

字典生成式

# 例子
new_dict = {i: 'jason' for i in range(4)}
print(new_dict)  # {0: 'jason', 1: 'jason', 2: 'jason', 3: 'jason'}
new_dict = {i: 'jason' for i in range(4) if i != 2}
print(new_dict)  # {0: 'jason', 1: 'jason', 3: 'jason'}

# 语法结构
# [K: V for 变量名 in 数据集]
# 可以在外部定义V 或 K 然后在内部进行输入
# [K: V for 变量名 in 数据集 if 条件]
# 与列表生成式相似

集合生成式

匿名函数

匿名函数定义
没有名字的函数

关键字
lambda

语法结构

lambda 形参:返回值

# 可以看做

def xxx(形参):  # xxx只是随便写的 不是说匿名函数的函数名为xxx
    return 返回值

匿名函数作用
常用作与各种内置函数结合使用

重要内置函数

map()

用map()可以对容器内所有数据执行相同操作

l1 = [100,110,120,110,111,333]
# 需求：将列表内所有数据值自减1
res = map(lambda x:x-1, l1)
print(list(res))

filter()

使用filter可以删除列表内的数据值

l1 = ['686','coco', 'v10', 'jojo','lin']
#需求是移除列表内的Lin
res = filter(lambda a:a != 'lin', l1)
print(list(res))

reduce()

化整为零的过程(对参数列表中多个数据进行累积)

l1 = [12321, 324, 324, 2352, 123, 4532]
# 需求是求列表中所有数据的总和 再加20
from functools import reduce	#Python3.x reduce()被移到functools模块里，如果要使用则需要引入functools模块来调用reduce()函数：

res = reduce(lambda x, y: x + y, l1，20)
print(res)

zip()

zip()用于将可迭代的对象作为参数，并将对象中对应的元素打包成元组，然后返回由这些元组组成的列表

n1 = ['686', 'coco', 'jojo']
n2 = [1, 2, 1]
n3 = ['m4', 'ak', 'm4']
res = zip(n1, n2, n3)
print(list(res))
#结果
'''
[('686', 1, 'm4'), ('coco', 2, 'ak'), ('jojo', 1, 'm4')]
'''