一. 字符编码
核心:以什么编码写的存入硬盘,就以什么编码取出
1.1 内存使用的是unicode编码,全是两个字节提高传输速度..一般都是使用utf-8的万国编码,优点是节省空间.缺点是运行速度相对较慢
1.2 数据最先产生在内存中的 是unicode格式,想要传输就要转化成二进制的bytes格式
1 #unicode----->encode(utf-8)------>bytes 2 拿到bytes，就可以往文件内存放或者基于网络传输 3 #bytes------>decode(gbk)------->unicode
1.3 文件-gbk/utf-8=文件.encode(‘gbk/utf-8‘) 这是指定文件编码类型 或者转换 编码.encode将文件编码成某种类型
文件-gbk/utf-8=文件.decode(‘gbk/utf-8‘) 这是指定文件编码类型 或者转换 解码.decode 将文件解码成某种类型
1.4 了解 python3里面默认是utf-8来编写和读取文件 utf-8是Unicode万国编码的转变形式
二.文件处理
2.1 关键词 和with 语法
open --打开文件 encoding=‘utf-8‘--打开文件的编码格式 close--关闭文件夹 read--读取文件内容 readline()--逐行读取 (print自带换行符) end=‘ ‘可以去除 readlines---每一行都读进来
with open as read_f with语法可以打开多个文件
2.1.1
文件句柄 = open(‘文件路径‘, ‘模式‘)
打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。
2.2
上下文管理 with
with open (‘aaa.py‘,‘r‘,encoding=‘utf-8‘) as read_f,
open(‘aaa_new.py‘,‘w‘,encoding=‘utf-8‘)as writ_f:
date=read_f.read()
write_f.wriet(data)
2.3文件打开模式
f=open(‘r‘)=只读模式 f=open(‘r+‘)=读写模式(光标在文件末尾)文件不存在就会报错
f=open(‘w‘)=只写模式,文件不存在创建新的文件,文件存在则清空(不能读只能写)
f=open(‘w+‘)=创建文件读写 想当于w模式加了r的模式
f=open(‘a‘)=只追加写模式,文件不存在 则报错,文件存在会在末尾追加
f=open(‘a+‘)=在文件末尾读写 直接添加内容到文件尾部
2.4文件内容的修改
for line in f:
print(line,end="") 文件再大 同时只取一行内容
总结性代码
那不了解就抄5遍
上下文管理
with open(‘aaaa.py‘,‘r‘,encoding=‘utf-8‘) as read_f, open(‘aaaa_new.py‘,‘w‘,encoding=‘utf-8‘) as write_f:
data=read_f.read()
write_f.write(data)
循环取文件每一行内容
with open(‘a.txt‘,‘r‘,encoding=‘utf-8‘) as f:
while True:
line=f.readline()
if not line:break
print(line,end=‘‘)
lines=f.readlines() #只适用于小文件
print(lines)
data=f.read()
print(type(data))
for line in f: #推荐使用
print(line,end=‘‘)
文件的修改
方式一：只适用于小文件
import os
with open(‘a.txt‘,‘r‘,encoding=‘utf-8‘) as read_f, open(‘a.txt.swap‘,‘w‘,encoding=‘utf-8‘) as write_f:
data=read_f.read()
write_f.write(data.replace(‘alex_SB‘,‘alex_BSB‘))
os.remove(‘a.txt‘)
os.rename(‘a.txt.swap‘,‘a.txt‘)
方式二：
import os
with open(‘a.txt‘,‘r‘,encoding=‘utf-8‘) as read_f, open(‘a.txt.swap‘,‘w‘,encoding=‘utf-8‘) as write_f:
for line in read_f:
write_f.write(line.replace(‘alex_BSB‘,‘BB_alex_SB‘))
os.remove(‘a.txt‘)
os.rename(‘a.txt.swap‘,‘a.txt‘)
三.函数 参数 和返回值
3.1为什么要有函数? 减少带码冗余,增强代码可读性
函数分类? 内置函数的自定义函数 自定义函数以def开头
函数的调用? 调用函数以函数的名称加()来调用
3.2返回值可以返回一个值和多个值 和任意类型的值 return就是返回需要的那个值 定义完函数之后在末尾添加
作用就是结束整个函数的运行
看代码
def ret_demo1():
‘‘‘返回多个值‘‘‘
return 1,2,3,4
def ret_demo2():
‘‘‘返回多个任意类型的值‘‘‘
return 1,[‘a‘,‘b‘],3,4
ret1 = ret_demo1()
print(ret1)
ret2 = ret_demo2()
print(ret2)
3.3参数
参数分为形参和实参
3.3.1形参就是def后面 跟的参数 分为位置参数 默认参数 和动态参数
位置参数必须传值
默认参数可以不传值
默认参数 不懂写5遍 脑子笨最好的办法
def stu_info(name,sex = "male"):
"""打印学生信息函数，由于班中大部分学生都是男生，
所以设置默认参数sex的默认值为‘male‘
"""
print(name,sex)
stu_info(‘alex‘)
stu_info(‘eva‘,‘female‘)
动态参数分为两种 *args 分解元组 **kwargs分解字典 以下看代码
老规矩 不懂就是抄就抄
def fun2(*args):
print(args)
t=(1,2,3,4)
fun2(*t)
**kwarg
def stu_info(**kwargs):
print(kwargs)
print(kwargs[‘name‘],kwargs[‘sex‘])
stu_info(name = ‘alex‘,sex = ‘male‘)
3.4 实参 :就是实即要传入的参数==传参
也是分为两种方式 位置传参和关键字传参 看代码
位置参数 老规矩
def mymax(x,y):
#此时x=10,y=20
the_max = x if x > y else y
return the_max
ma = mymax(10,20)
print(ma)
关键字传参
def mymax(x,y):
#此时x = 20,y = 10
print(x,y)
the_max = x if x > y else y
return the_max
ma = mymax(y = 10,x = 20)
print(ma)
补充几点
函数的嵌套 和 函数名
函数的嵌套就是为了保护 内部函数在外部调用(其实自己没明白这句话什么意思...等文科130的解释一下吧)
函数嵌套 7月28日
def animal():
def tiger():
print(‘bark‘)
print(‘eat‘)
tiger()
animal()
#函数嵌套使用
def f1():
print(a) #无法获取f2的a的值，注意执行顺序
print(‘f1‘)
def f2():
a = 10
f1()
f2()
函数名的本质就是内存地址 下面的代码借用他人的
#!/usr/bin/env python
#_*_coding:utf-8_*_
def func():
print(‘func‘)
print(func) #函数func内存地址
f = func #就是函数的内存地址
print(f) #函数func内存地址
f() #执行代码
#############
l = [f] #还是函数内存地址
print(l)
l[0] == f #用索引取值
l[0]()
#可以用作函数的参数
def func():
print(‘func‘)
def func2(f):
print(f) #func的内存地址
f() #执行func函数
print(‘func2‘)
func2(func)
#可以作为函数的返回值
def func():
print(‘func‘)
def func2(f): #1 接收func函数的内存地址
print(‘func2‘)
return f #2 返回给fu函数func函数的内存地址
fu = func2(func)
fu() #3 执行函数func
#如果我想在全局使用内部的函数
四.作用域 闭包 局部变量和全局变量
4.1 作用域的定义和作用
分为内置函数空间..在哪里都可以用
全局函数空间..他不能用局部的但是局部的可以用他的
局部函数空间(自定义函数) 在自己定义的空间内可以用 (注意一点就是 它只在调用的时候加载)
爷爷 爸爸 儿子 =内置 全局 局部 就是这个作用域最好的解释!!!
全局作用域：全局命名空间、内置命名空间
局部作用域：局部命名空间
站在全局看：
使用名字:name=123
如果全局有：用全局的
如果全局没有：用内置的(这个内置是python自带的函数)
为什么要有作用域的概念：
为了函数内的变量不会影响到全局
不懂就抄
#全局命名空间
a = 5
b = 8
#局部命名空间（函数）
def my_max():
c = a if a > b else b
return c
m = my_max()
print(m)
作用域在定义函数时就已经固定住了，不会随着调用位置的改变而改变
白话就是:定义一个函数可以使用的范围
作用:作用域：(老师总结的 太详细了 )
1.小范围的可以用大范围的
2.但是大范围的不能用小范围的
3.范围从大到小
4.在小范围内，如果要用一个变量，是当前这个小范围有的，就用自己的
5.如果在小范围内没有，就用上一级的，上一级没有就用上上一级的，以此类推。
6.如果都没有，报错
4.2闭包闭包闭包闭包闭包闭包闭包闭包闭包闭包闭包闭包闭包闭包闭包闭包
4.2.1闭包函数的定义和解释
内部函数，包含了对外部作用域中变量的引用
闭包
1.闭 内部的函数
2.包 包含了对外部函数作用域中变量的引用
3.内部函数调用全局的变量和return一个返回值
4.函数名可以当做函数的参数
5.闭包函数多用于装饰器中(自己目前的理解)
#闭包的常用形式
def hei():
x = 20
def inner():
print(x) #局部的
return inner
如果在一个内部函数里：inner()就是这个内部函数，
对在外部作用域（但不是在全局作用域）的变量进行引用：x就是被引用的变量，x在外部作用域hei()里面，但不在全局作用域里。
则这个内部函数inner()就是一个闭包。
五.装饰器(各种装饰器/带参数的装饰器)和语法糖(重点..听了两天懵懵懂懂)
总结之前写点自己的理解
装饰器=用之前先写好模板放在那里 然后一句一句的写原函数 最后想办法把两者加起来
5.1装饰器是什么?
装饰器也是一个函数
字面意思:就是装饰某件东西让其变得高雅.....其实就是装饰闭包函数
真是意思:为其他函数加上其他新功能
5.2装饰器原则和方式
原则:对扩展是开放的 对修改是封闭的,在不改变原代码和原函数的调用方式的情况下给原函数加上新的功能
装饰器必须放到被装饰的函数上边，并且独占一行；多个装饰器下 ，按照先下后上执行。
5.3装饰固定代码(想办法记住 最贱的办法就是抄 印到脑子里 10遍)
代码不懂就敲 一言不合就5遍
def timer(func):
def inner(*args,**kwargs):
‘‘‘执行函数之前要做的‘‘‘
re = func(*args,**kwargs)
‘‘‘执行函数之后要做的‘‘‘
return re
return inner
2.默写代码
import time
def timer(func):
def inner(*args,**kwargs):
start = time.time()
re = func(*args,**kwargs)
print(time.time() - start)
return re
return inner
@timer #==> func2 = timer(func2)
def func2(a):
print(‘in func2 and get a:%s‘%(a))
return ‘fun2 over‘