1.函数
写代码的方式：面向过程-->函数式编程（多）-->面向对象编程
1.1 函数基础概念
-
函数基本结构
def func(arg): return arg v1 = func(123) -
写函数
- def func(a1,a2):pass
- def func(a1,a2=None): pass
- def func(arg,*kwargs):pass
执行函数
位置参数在前/关键字参数在后
-
函数内部的数据是否会混乱
- 函数内部执行相互之间不会混乱
- 执行完毕 + 内部元素不被其他人使用 => 销毁
注意：函数在何时被谁创建？
-
面试题
-
函数可以做参数【知识点】
def func(arg): () def show(): pass func(show) -
函数的参数传递的会什么？【内存地址=引用or值】
v = [11,2,33,4] def func(arg): print(id(arg))#列表内存地址 prirnt(id(v)) #查看列表内存地址 func(v) #与上面结果相同 #传递的是内存地址*arg, **kwargs的作用：接受任意个位置参数和关键字参数，并且一定要保证位置参数在关键字参数的前面。
-
1.2参数
补充：对于函数默认值慎用可变类型
#如果想要给value设置默认是空列表
#不推荐（坑）
def func(data,value=[]):
pass
#推荐
def fuunc(data,value=None):
if not value:
value = []
def func(data,value=[]): #函数内部写入一个空列表value=[]
value.append(data)
return value
v1 = func(1) #[1,]
v2 = func(1,[11,22,33]) #[11,22,33,1]
v3 = func(2) #[1,2]
print(v1) #[1,2]
[图片上传失败...(image-8f2a4f-1586439145257)]
-
面试题
def func(a,b=[])有什么陷阱？
-
看代码写结果
def func(a,b=[]): b.append(a) return b l1 = func(1) l2 = func(2,[11,22,33]) l3 = func(3) print(l1,l2,l3) [1,3],[11,22,33,2],[1,3]def func(a,b=[]): b.append(a) print(b) l1 = func(1) #[1] l2 = func(2,[11,22,33]) #[11,22,33,2] l3 = func(3) #[1,3]
1.3返回值
name = "景女神"
def func():
def inner():
print(name)
return inner()
v = func()
print(v) #景女神 None
name = "景女神"
def func():
def inner():
print(name)
return "老男孩"
return inner()
v = func()
print(v) #景女神 老男孩
name = "景女神"
def func():
def inner():
print(name)
return "老男孩"
return inner
v = func()
print(v)
#<function func.<locals>.inner at 0x000000000222A6A8> inner函数的内存
常见的数据类型可以返回
-
函数也可以返回
def func(): def inner(): pass return inner v = func() -
特殊
- 默认没返回就是None
- return 1,2,3等价于retuen(1，2，3)
-
补充：分析函数执行的内存
def func(name): def inner(): print(name) return 123 v1 = func('alex') v2 = func('eric') v1() v2()闭包
#不是闭包 def func1(name): def inner(): return 123 return inner #是闭包：封装的值+内容，函数需要使用 def func2(name): def inner(): print(name) return 123 return inner -
执行函数
-
函数不被调用，内部代码永远不执行
def func(): return i func_list = [] for i in range(10): func_list.append(func) print(i) # 9 v1 = func_list[4]() # 9 v2 = func_list[0]() # 9func_list = [] for i in range(10): #func_list.append(lambda:x) # 函数不被调用，内部函数永远不执行（不知道是什么） fun_list.append(lambda:i) # 函数不被调用，内部函数永远不执行（不知道是什么） print(func_list) func_list[2]()
-
-
执行函数式=时，会新创建一块内存保存自己函数执行的信息。 => 闭包
def base(): return arg def func(arg): def inner(): return arg return inner base_list = [] # [base,base,] func_list = [] #[由第一次执行func函数的内存地址，内部arg=0创建的inner函数,有arg=1的inner函数] for i in range(10): # i=0,1 base_list.append(base) func_list.append(func(i)) # 1.base_list和func_list中分别保存的是什么？ ''' base_list 中存储的都是base函数 func_list 中存储的都是inner函数，特别要说的是每个Inner是在不同的地址创建 ''' #2.如果循环打印什么？ for item in base_list(): v = item() print(v) # 都是9 for data in func_list(): v = data() print(v) # 0,1,2,3,4,5,6,7,8,9
1.4作用域
1.5递归
函数自己调用自己。（效率低）
def f1():
print(1)
func() #默认递归1000次
func()
def func(i):
print(i)
func(i+1)
func(1)
# 1+2+3+4+5……
def func(a):
if a == 5:
return 10000
result = func(a+1) + 10
return result
v = func(1)
print(v) #10040
def func(a):
if a == 5:
return 10000
result = func(a+1) + 10
v=func(1) # None
def func(a):
if a == 5:
return 10000
result = func(a+1) + 10
return result
v = func(1)
print(v) #10040
def func(a):
if a == 5:
return 10000
result = func(a+1) + 10
v=func(1) # None
[图片上传失败...(image-b5da8c-1586439145257)]
总结
-
传参：位置参数 > 关键字参数
def func(*args,**kwargs): #args是arguments的缩写，表示位置参数；kwargs是keyword arguments 的缩写，表示关键字参数。收集参数的两种收集方式：*打包成元组，**打包成字典。 print(args,kwargs) func(12,3,*[11,22]) (12, 3, 11, 22) {} func(('alex','yyp'),name = 'eric') (('olex', 'yyp'),) {'name': 'eric'}
函数不被调用，内部代码永远不执行
每次调用函数时，都会为此次调用开辟一块内存，内存可以保存自己以后想要用的值
-
函数作用域，如果自己作用域中没有，则往上级作用域找。
func_list=[] for i in range(10): func_list.append(lambda x:x+i) # i = 9 /func_list = [函数，函数，函数，函数，函数，函数，函数，函数，函数，函数] for i in rnge(0,len(func_list)): # i已经被重置了！！！自己有不找别人的，没有了从上级找。 # i = 0;函数（0）结果是：0 # i = 1；函数（1）结果是：2 result = func_list[i](i) print(result) # 0，2，4，6，8，10，12，14，16，18func_list=[] for i in range(10): func_list.append(lambda x:x+i) # i = 9/func_list=[函数，函数，函数，函数，函数，函数，函数，函数，函数，函数] for j in range(0,len(func_list)): result = func_list[j][j] #0 + 9 / 1 + 9 print(result)def func(name): v = lambda x:x+name return v v1 = func("yyp") # name v2 = v1("20181799") # x print(v1,v2)
2.内置函数和匿名函数
-
内置函数
-
输入输出
- input
-
强制转换
- int
- bool
- str
- list
- tuple
- dict
- set
-
数字相关
max
min
sum
abs
divmod
float
pow
round
-
进制
- bin
- oct
- int
- hex
-
其他
- len
- range
- id
- type
- open
-
-
匿名函数
-
与filter/map/reduce函数搭配使用
def odd(x): return x % 2 temp = filter(odd,range(10)) list(temp) [1,2,3,5,7,9] list(filter(lambda x : x % 2,range(10))) [1,3,5,7,9]list(map(lambda x: x * 2,range(10))) [0,2,4,6,8,10,12,14,16,18] list(map(lambda:x,y : x + y,[1,3,5],[10,30,50,66,69])) [11,33,55]def add(x,y): return x + y reduce(add,[1,2,3,4,5] #计算列表和：1+2+3+4+5 15 reduce(lambda x,y : x + y,[1,2,3,4,5]) 15
-
3.装饰器
带参数的装饰器：flask框架+django缓存+写装饰器实现被装饰的函数要执行N次
3.1. 基本格式
def x(func):
def inner(*args,**kwargs):
data = func(*args,**kwargs) # 执行原函数并获取返回值
return data
return inner
@x # 语法糖
# index = x(index) ,将index函数作为参数传递给x()
def index():
pass
3.2 .关于参数
def x(func):
def inner(name):
return func(name)
return inner
@x # 语法糖
# index = x(index) ,将index函数作为参数传递给x()
def index(name):
pass
def x(func):
def inner(a1,a2):
return func(a1,a2)
return inner
@x # 语法糖
# index = x(index) ,将index函数作为参数传递给x()
def index(a1,a2):
pass
#index = inner
如果给好几个函数写一个统一的装饰器，怎么办？
def x1(func):
def inner(*args,**kwargs):
#args是arguments的缩写，表示位置参数；kwargs是keyword arguments 的缩写，表示关键字参数。收集参数的两种收集方式：*打包成元组，**打包成字典。
return func(*args,**kwargs)
return inner
@x1
def f1():
pass
@x1
def f2(a1):
pass
@x1
def f3(a1,a2):
pass
3.3.关于返回值
def x1(func):
def inner(*args,**kwargs):
data=func(*args,**kwargs) #999
return 666
return inner
@x1
def f1():
print(123)
return 999
v1 = f1() #666
#f1 = inner，抓住这个本质，是否有返回值，取决于inner是否有返回值
装饰器建议写法：
def x1(func):
def inner(*args,**kwargs):
data=func(*args,**kwargs)
return data
return inner
3.4.关于前后
def x1(func):
def inner(*args,**kwargs):
print("调用原函数之前")
data=func(*args,**kwargs) # 执行原函数并获取返回值
print("调用原函数之后")
return data
return inner
作业题1（执行原函数以前）：
请为以下函数编写一个装饰器，添加上装饰器后可以实现：执行read_userinfo函数时，先检查文件路径是否存在，如果存在则输入文件路径存在，如果不存在则输入文件路径不存在，并且不再执行read_userinfo函数体中的内容，再将content变量负值给None。
import os
def wrapper(func):
def inner(*args,**kwargs):
#检查路径是否存在
path = args[0]
if not os.path.exists(path):
#路径不存在
print('路径不存在')
return None
result = func(*args,**kwargs)
return result
return inner
@wrapper
def read_userinfo(path):
file_obj = open(path,mode='r',encoding='utf-8')
data = file_obj.read()
file_obj.close()
return data
content = read_userinfo('/usr/bin/xxx/xxx')
print(content)
"""
如何查看一个路径是否存在?
import os
result = os.path.exists('路径地址')
# result为True，则表示路径存在
# result为False,则表示路径不存在
"""
作业题2（执行原函数以后）：
请为以下所有函数编写一个装饰器，添加上装饰器后可以实现：将被装饰的函数执行五次，将每次执行函数的结果按照顺序放到列表中，最终返回列表。
import random
def wrapper(func):
def inner(*args,**kwargs):
value = []
for i in range(5):
data = func(*args,**kwargs)
value.append(data)
return value
return inner
def func():
return random.randint(1,4)
result = func()
print(result)
3.5. 带参数的装饰器
#第一步：执行 ret = xxx(index)
#第二步：将返回值赋值给 index = ret
@xxx
def index():
pass
#第一步：执行 v1=uuu(9)
#第二步：ret = v1(index)
#第三步：index = ret
@uuu(9)
def index():
pass
#普通的装饰器
def wrapper(func):
def inner(*args,**kwargs):
result = func(*args,**kwargs)
return result
return inner
@wrapper
def index():
pass
#带参数的装饰器
def x(counter):
print("x函数") # 执行后会打印
def wrapper(func):
print("wrappper函数") # 执行后会打印
def inner(*args,**kwargs):
print("inner") # 调用index（）后才打印
result = func(*args,**kwargs)
return result
return inner
return wrapper
@x(9) #index = x(9)(index)
def index():
pass
#写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次，把每次的结果添加到列表中，最终返回列表。
def x(counter):
def wrapper(index):
def inner(*args,**kwargs):
v=[]
for i in range(counter):
data = index(*args,**kwargs)
v.append(data)
return v
return inner
return wrapper
@x(5)
def index():
return 8
result = index()
print(result)
#打印[8,8,8,8,8]
#while循环，注意思考前后问题
def x(counter):
def wrapper(func):
def inner(*args, **kwargs):
i = 0
v = []
while i < counter:
data = func(*args, **kwargs)
v.append(data)
i += 1
return v
return inner
return wrapper
@x(5)
def index():
return 8
#写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次，并返回最后一次执行的结果【面试题】
def x(counter):
def wrapper(index):
def inner(*args,**kwargs):
for i in range(counter):
data = index(*args,**kwargs)
return data
return inner
return wrapper
@x(5)
def index():
return 8
result = index()
print(result)
#写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次，并返回结果中的最大值
def x(counter):
def wrapper(index):
def inner(*args,**kwargs):
value = None # value = 0 也可以
for i in range(counter):
data = index(*args,**kwargs)
if data > value:
value = data
return value
return inner
return wrapper
@x(5)
def index():
return 8
result = index()
print(result)
#假如1000个函数中990个函数需要装一个装饰器，另外10个加不同的功能。
def x(counter):
def wrapper(func):
def inner(*args,**wargs):
if counter:
return 123
return func(*args,**kwargs)
return inner
return wrapper
@x(True)
def func990():
pass
@x(False)
def func10():
pass
3.6.之后讲
元数据：Flask框架
-
多个装饰器:Flask框架
@x1 @x2 def func(): pass
总结
-
基本装饰器（更重要）
def x(func): def inner(*args,**kwargs): data = func(*args,**kwargs) # 执行原函数并获取返回值 return data return inner @x # 语法糖 # index = x(index) ,将index函数作为参数传递给x() def index(): pass -
带参数的装饰器
def x(counter): print("x函数") # 执行后会打印 def wrapper(func): print("wrappper函数") # 执行后会打印 def inner(*args,**kwargs): print("inner") # 调用index（）后才打印 result = func(*args,**kwargs) return result return inner return wrapper @x(9) #index = x(9)(index) def index(): pass
作业题
-
为函数写一个装饰器，在函数执行之后输入after
def wrapper(func): def inner(): data = func() print("after") return data # 不能丢 return inner @wrapper def func(): print(123) func() -
为函数写一个装饰器，把函数的返回值+100，然后再返回
def wrapper(func): def inner(): data1 = func() data1 += 100 return data1 return inner @wrapper def func(): return 7 result = func() print(result) -
为函数写一个装饰器，根据参数不同做不同操作
flag为True，则让原函数执行后返回值加100，并返回
-
flag为False，则原函数执行后返回值减100，并返回
def x(flag): def wrapper(func): def inner(*args, **kwargs): data = func(*args, **kwargs) if flag: data += 100 else: data -= 100 return data return inner return wrapper @x(True) def f1(): return 11 @x(False) def f2(): return 22 r2 = f2() print(r2)
4.模块
python解释器相关的数据。
4.1模块基本知识
-
内置模块，python内部提供的功能
import sys print(sys.argv) -
第三方模块 下载/安装/使用
#把pip.exe所在目录添加到环境变量中。 pip install 要安装的模块名称如果不是最新的版本则输入以下命令自动更新
- Python+版本号 -m pip install -upgrade pip
安装完成后，如果导入不成功
- 重启Pycharm
- 安装出错
-
自定义模块
-
xxxx.py
def f1(): print("f1") def f2(): print("f2") -
x1.py
#调用自定义模块 import xxxx xxxx.f1() xxxx.f2() -
运行
python x1.py
-
4.1.内置模块
4.1.1sys
-
sys.getrefcount，获取一个值的引用计数
print(sys.getrefcount(a)) sys.getrecursionlimit，Python默认支持的递归数量
-
sys.stdout.write --> print(进度)
#\r 回到当前行的起始位置 应用：进度条。与end=''搭配 print("123123",end = '') print("你好"，end='') # 打印结果：123123你好 print("123123\r",end = '') print("你好"，end='') # 打印结果：你好 print("123123\r",end = '') # 打印结果：：123123 所以不是清空掉而是回到了当前行的起始位置import time for i inrange(1,101): msg = "%s%%\r" %i # %% 输出 % print(msg,end='') time.sleep(0.05)impotr os #1.读取文件大小（字节） file_size = os.stat("20190409_192149.mp4").st_size #2.一点一点的读取文件 read_size = 0 with open("20190409_192149.mp4",mode='rb') as f1,open("a.mp4",mode='wb') as f2: while read_size < file_size: chunk = f1.read(1024) #每次最多去读取1024个字节 f2.write(chunk) read_size += len(chunk) val = int(read_size / file_size * 100) print("%s%%\r" %val,end ='') -
sys.argv【常用！】
#让用户执行脚本传入要删除的文件路径，在内部帮助用户将目录删除。 """ C：\Python36\python36.exe D:/code/s21day14/7.模块传参.py D:/test C：\Python36\python36.exe D:/code/s21day14/7.模块传参.py """ import sys #获取用户执行脚本时，传入的参数 #C：\Python36\python36.exe D:/code/s21day14/7.模块传参.py D:/test #sys.argv = [D:/code/s21day14/7.模块传参.py , D:/test] path = sys.argv[1] #删除目录 import shutil shutil.rmtree(path) sys是解释器相关的数据：递归次数/引用次数
-
sys.path,默认python去导入模块时，会按照sys.path中的路径挨个查找
import sys sys.path.append('D：\\') import oldboy作业题4：写一个脚本，接收两个参数
- 第一个参数：文件
- 第二个参数：内容
请将第二个参数中的内容写入到文件（第一个参数）中。
#执行脚本：Python test.py oldboy.txt 你好 import sys if len(sys.atgv) < 3: print("参数不够，请重新运行") #sys.exit(0) 终止程序 else: file_path = sys.argv[1] #sys.argv[0]是默认的脚本路径 content = sys.argv[2] with open(file_path,mode = 'w',encoding = 'utf-8') as f: f.write(content)
4.1.2 os
和操作系统相关的数据
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.stat("20190409_192149.mp4").st_size 获取文件大小
-
os.path.abspath() 获取一个文件的绝对路径
path = "20190409_192149.mp4" # D:\code\s21day14\20190409_192149.mp4 import os v1 = os.path.abspath(path) print(v1) # 打印结果：D:\code\s21day14\20190409_192149.mp4 -
os.path.dirname() 获取路径的上级目录
import os v = r"D:\code\s21day14\20190409_192149.mp4" #r是转义 print(os.path.dirname(v)) # 打印结果D:\code\s21day14 -
os.path.join，路径的拼接
import os path = "D:\code\s21day14" v = 'n.txt' result = os.path.join(path,v) print(result) #打印结果：D:\code\n.txt\s21day14\n.txt result = os.path.join(path,'n1','n2','n3') ptint(result) #打印结果：D:\code\n.txt\s21day14\n1\n2\n3 -
os.path.lisdir，查看目录下所有的文件【第一层】
import os result = os.lisdir(r'D:\code\s21day14') for path in result: print(path)作业题6：写代码
path = r"D:\code\test.pdf" v = os.path.dirname(path) result = os.lisdir(v)
-
os.walk，查看目录下所有的文件【所有层】（面试）
import os result = os.walk(r'D:\code\s21day14') for a,b,c in result: #a,正在查看的目录，b，此目录下的文件夹，c，此目录下的所有文件 for item in c: path = os.path.join(a,item) print(path)作业题5：写函数实现，查看一个路径下的所有文件【所有】。
def get_file_list(path): """ 查看路径下的所有文件 :param path: 指定的路径 :return: """ result = os.walk(path) time(三种类型)
getpass
random
hashlib
datetime和timezone【了解】
4.1.3 json
json是一个特殊的字符串。【长得像列表/字典/字符串（只能是双引号）/数字/真假】
最外侧必须是容器，列表或字典。json中没有元组，如果输入元组会自动转化为列表，也没有集合，如果输入集合会报错。
import json
#序列化，将python的值转换为json格式的字符串
v = [12, 3, 4, {'k1':'a1'}, True, 'asdf']
v1 = json.dumps(v)
print(v1)
#打印的结果：[12, 3, 4, {"k1": "a1"}, true, "asdf"]
import json
#反列化，将json格式的字符串转换为Python的数据类型
v2 = '["alex", 123]'
print(type(v2))
v3 = json.loads(v2)
print(v3, type(v3))
#打印的结果：
<class 'str'>
['alex', 123] <class 'list'>
Python的数据类型中支持json的
+-------------------+---------------+
| Python | JSON |
+===================+===============+
| dict | object |
+-------------------+---------------+
| list, tuple | array |
+-------------------+---------------+
| str | string |
+-------------------+---------------+
| int, float | number |
+-------------------+---------------+
| True | true |
+-------------------+---------------+
| False | false |
+-------------------+---------------+
| None | null |
+----------------------------------+
4.1.4 shutil
#删除目录,无返回值
import shutil
shutil.rmtree(path)
#将目录test重命名为ttt
shuil.move('test','ttt')
#压缩文件
shutil.make_archive('zzh','zip','D:\close\s21day16\lizhong')
#解压文件,把压缩文件zzh.zip解压到指定路径，不指定的话默认是解压到当前目录
shutil.unpack_archive('zzh.zip',extract_dir='D:\\code",format='zip')
4.1.5 pickle
-
json和pickle
- json，优点：所有语言通用；缺点：只能序列化基本的数据类型list/dict/int……
- pickle，优点：Python中所有的东西都能被他序列化（sockle对象）;缺点：序列化的内容只有Python认识
-
示例
#序列化集合 import pickle v = {1, 2, 3, 4} val = pickle.dumps(v) print(val，type(val)) #打印结果：b'\x80\x03cbuiltins\nset\nq\x00]q\x01(K\x01K\x02K\x03K\x04e\x85q\x02Rq\x03.' <class 'bytes'> data = pickle.loads(val) print(data, type(data)) #打印结果：{1, 2, 3, 4} <class 'set'>#序列化函数 def f1(): print("f1") v1 = pickle.dumps(f1) print(v1, type(v1)) #打印结果：b'\x80\x03c__main__\nf1\nq\x00.' <class 'bytes'> v2 = pickle.loads(v1) print(v2,type(v2)) v2() #打印结果：<function f1 at 0x0000000001CFC1E0> <class 'function'> f1
示例：
import os
import shutil
from datetime import datatime
ctime = datatime.now().strftime(%Y-%m-%d-%H-%M-%S)
#1.压缩lizhongwen文件夹 zip
#2.放到code目录（默认不存在）
#3.将文件家压到：D：\x1目录中
ifnot os.path.exists('code'):
os.makedirs('code')
shutil.make_archive(os.path.join('code',ctime),'zip','D:\code\s21day16\lizhongwei')
file_path = os.path.join('code',ctime) + 'zip'
shutil.unpack_archive(file_path,r'D:\x1','zip')
4.1.6 time&datetime模块
UTG/GMT（世界时间） 0时区的时间
本地时间：本地时区的时间
time模块
time.time()，时间戳：1970-1-1 00：00
time.sleep(10)，等待秒数
time.timezone ，（与电脑设置有关，与自己所在的时区无关）
-
应用示例
import time print(time.time()) #打印结果：1585999180.5692067 https://login.wx.qq.com/cgi-bin/mmwebwx-bin/login?loginicon=true&uuid=IcVkx2vl0w==&tip=0&r=-1156342701&_=1585999223820 1585999223820就是时间戳
datetime模块
from datetime import datetime, timezone, timedelta
# ############获取datetime格式的时间########################
v1 = datetime.now() #获取当前本地时间
print(v1)
#2020-04-04 19:54:08.946231 东八区
v2 = datetime.utcnow() #获取UTC时间(时区为0的时间)
print(v2)
#2020-04-04 11:56:05.804118
tz1 = timezone(timedelta(hours=7)) #获取东7区时间
print(tz1)
#UTC+07:00
v3 = datetime.now(tz1)
print(v3)
#2020-04-04 19:00:07.842844+07:00
tz2 = timezone(timedelta(hours=-7)) #获取西7区时间
print(tz2)
#UTC-07:00
v4 = datetime.now(tz2)
print(v4)
#2020-04-04 05:00:07.842844-07:00
# ############datetime格式的时间转换成字符串########################
v1 = datetime.now()
print(v1,type(v1))
#2020-04-04 20:04:21.846759 <class 'datetime.datetime'>
v2 = '2020-04-04'
print(v2,type(v2))
#2020-04-04 <class 'str'>
v3 = v1.strftime('%Y-%m-%d %H-%M-%S')')
print(v3,type(v3))
#2020-04-04 20-09-06 <class 'str'>
# ############字符串转换成datetime格式的时间#######################
v4 = datetime.strptime('2011-11-11', '%Y-%m-%d')
print(v4, type(v4))
#2011-11-11 00:00:00 <class 'datetime.datetime'>
# ############datetime格式的时间的加减########################
v5 = v1 + timedelta(days=140) v1的基础上加140天
print(v5)
#2020-08-22 20:17:50.432627
v6 = v5.strftime('%Y-%m-%d')
print(v6, type(v6))
#2020-08-22 <class 'str'> 字符串转换成datetime格式方面进行时间加减运算
# ############时间戳和datetime的关系########################
ctime = time.time()
print(ctime)
v7 = datetime.fromtimestamp(ctime) #时间戳转换datetime
print(v7)
# 2020-04-04 20:25:18.417265
v8 = datetime.now()
v9 = v8.timestamp()
print(v9)
#1586003232.825178
[图片上传失败...(image-99dc2a-1586439145257)]
以后写代码时，都要加上此文件。
4.2.3 模块的调用
示例一
#yyp.py文件的内容
def show():
print('我是yyp')
def func():
pass
print(456)
#导入模块，先加载此模块中所有的值到内存。
import yyp
print(123)
#调用模块中的函数
yyp.func()
#结果是：
456
123
#导入模块
from yyp import func,show
from yyp import func
from yyp import show
from yyp import * #使用通配符星号来导入模块中所有的命名空间
func（）
#导入模块
from yyp import show as f 如果名字冲突相同可以起别名
def show():
print(123)
f()
# 我是yyp
from yyp import show
def show():
print(123)
# 结果是123
导入模块：
- import 模块,函数（）
- from 模块 import 函数（） 函数（）
- from 模块 import 函数（） as 别名 别名（）
示例二
import lizhong.jd #调用lizhong（文件夹）模块下的jd.py文件
lizhong.jd.f1() #调用jd.py文件下的f1函数
=====================================
from lizhong import jd
jd.f1()
=====================================
from lizhong.jd import f1
f1()
总结
- 模块和要执行的py文件在同一目录 且 需要模块中的很多功能时，推荐用：import模块
- 其他推荐：from 模块 import 模块 模块.函数（）
- 其他推荐：from 模块.模块 import 函数（）
注意：sys.path的作用
[图片上传失败...(image-47d0aa-1586439145257)]
[图片上传失败...(image-3aa917-1586439145257)]
两种导入的方式
[图片上传失败...(image-1e57a8-1586439145257)]
4.2.4 内置模块
os
sys
time
-
json
dunps
loads
-
注意
补充：字典或列表中如果有中文，序列化时想要保留中文显示，使用如下操作
-
v = {'k1': 'alex', 'k2':'李杰'} import json val = json.dumps(v) print(val) #打印结果：{"k1": "alex", "k2": "\u674e\u6770"}v = {'k1': 'alex', 'k2':'李杰'} import json val = json.dumps(v, ensure_ascii=False) print(val) #打印结果：{"k1": "alex", "k2": "李杰"}
random
getpass
shutil
copy
作业题7：斐波那契数列4000000内最大的数 【面试题】
num1 = 0
num2 = 1
count = 0
while num2 < 4000000:
print(num2,end='')# 3524578
num1, num2 = num2, num1 + num2
count += 1
print(num1, count) # num1 = num2-->最后一次的num2赋值给了num1。
# 打印结果：11235813213455891442333776109871597258441816765109461771128657463687502512139319641831781151422983204013462692178309 3524578 3524578 33
作业题8：上机编程实现以下功能：【面试题】
dicta = {'a':1,"b":2,"c":3,"d":4,"f":"hello"}
dictb = {"b":3,"d":5,"e":7,"k":"world"}
要求写一段代码，实现两个字典的相加，不同的key对应的值保留，相同的key对应的值相加，如果是字符串就拼接。
dicta = {'a':1,"b":2,"c":3,"d":4,"f":"hello"}
dictb = {"b":3,"d":5,"e":7,"k":"world"}
for k,v in dictb.items(): #注意使用dict.item（）内置方法
if k not in dicta:
dicta[k] = v
continue
dicta[k] +=v
print(dicta)
作业题9：看一下代码，写出结果（出错的题）【后端开发面试题】
def extendList(val, list=[]): #这个list= [] 不建议
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123, [])
list3 = extendList('a')
print(list1, list2, list3)
#打印内容为：[10,'a'],[123],[10,'a']
#建议变量名不要用:str/list/tuple/set/dict/float
user_list = [11,22,33] # 推荐
list = [11,22,33] # 不推荐
list = 'alex'
v = [11,22,33]
v1 = list(v)
# 'alex'([11,22,33]会报错！
作业题10：写出由 tupleA 和 tupleB 实现 info 的过程。【后端开发面试题】
tupleA = (11,22,33)
tupleB = ("k1","vv","asdf")
info = {}
for i in range(0,len(tupleA)):
info[tupleA[i]]=tuoleB[i]
print(info)
info = {"k1":11,"vv":22,"asdf":33}
"""
补充range知识点
Python2:
xrange:不会在内存中立即创建，而是在循环时，边循环边创建
range： 在内存中立即把所有的值都创建
Python1:
range：不会在内存中立即创建，而是在循环时，边循环边创建
list(range(10)) = range （python2中的）
"""
作业题11：Python代码获取命令行参数。【后端开发面试题】
sys.argv
作业题12：已知 ip = '192.168.0.100'，代码实现提取ip的各部分并写入列表
ip = '192.168.0.100'
list1 = ip.split('.') # 字符串转换为列表
print(list1)
#打印结果：['192', '168', '0', '100']
IP = '.'.join(list1) # 列表转换为字符串
print(IP) # 192.168.0.100
print(type(IP)) # str
作业题112 编程题：1000以内的完美数（如果一个数恰好等于他的因子之和，则称该数为完美数）
eg:6 = 1*2 *3 = 1+2+3
for i in range(1, 1001):
num_list=[]
# 每次循环进来，都要对这个数进行求所有约数
for j in range(1, i):
if i % j == 0 :
num_list.append(j)
val = 1
for item in num_list:
val *= item
if i == sum(num_list):
print(i)
总结作业题中出现的重点知识点
- 构造字典核函数对应关系，避免重复的 If else
- a = 1,b = 2 ==> a,b = b,a
- 装饰器
- 找文件路径
- 脚本参数
- sys.exit
- range/xrange
- 读大文件
- 面试题如果有歧义，一定要给出多种情况。
