一、可变参数
定义函数时，有时候我们不确定调用的时候会传递多少个参数(不传参也可以)。此时，可用包裹(packing)位置参数（*args），或者包裹关键字参数（**kwargs），来进行参数传递，会显得非常方便。
1、包裹位置传递
def send_sms(*args): # 可变参数，参数组
print('phones',args)
def say(word):
print(word)
say(word='nihao')
send_sms(110,138,119)
say('nihao')
#传入的参数是一个列表时，前面不加*号的情况下，当做一个参数值处理
#传入的参数是一个列表时，前面加*号的情况下，当做多个参数值处理
我们传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递。
2、包裹关键字传递
kargs是一个字典(dict)，收集所有关键字参数
# 关键字参数
def kwfunc(**info): # 两个星号传参数要输入key：value、key：value...
print(info)
kwfunc()
# kwfunc(age='123',name='小黑')
def t1(word,country='Chine',*args,**kwargs):
print(word)
print(country)
print(args)
print(kwargs)
t1('哈哈','Japan',138,120,name='小河',addr='北京')
这两个是Python中的可变参数。*args 表示任何多个无名参数，它是一个tuple；**kwargs 表示关键字参数，它是一个dict。并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前，像different(a=1, b='2', c=3, a', 1, None, )这样调用的话，会提示语法错误“SyntaxError: non-keyword arg after keyword arg”。
知道*args和**kwarg是什么了吧。还有一个很漂亮的用法，就是创建字典：
def kw_dict(**kwargs):
return kwargs
result = kw_dict(aa=1,bb=2,cc=3)
print(result)
二、内置函数
input()print()len()type()str()tuple()set()dict()list()
1、sorted() 函数对所有可迭代的对象进行排序（默认升序）操作。
# 1、sorted() 排序，生成的是列表
l='dfdsafdsadafds'
sorted(l) # 排序函数
print(sorted(l))
# 对列表进行排序
print(sorted([1,2,5,30,4,22])) # [1, 2, 4, 5, 22, 30]
# 对字典进行排序
dict = {23:42,1:0,98:46,47:-28}
print( sorted(dict) ) # 只对key排序
# [1, 23, 47, 98]
print( sorted(dict.items()) ) # 默认按key进行排序
# [(1, 0), (23, 42), (47, -28), (98, 46)]
print( sorted(dict.items(),key=lambda x:x[1]) ) # 用匿名函数实现按value进行排序
# [(47, -28), (1, 0), (23, 42), (98, 46)]
2、map()帮你循环调用函数的，保存返回值，返回的是一个list。map接受一个函数名和序列
map()接收函数f和list，并通过把函数f依次作用在list的每个元素上，得到一个新的list并返回。
def inToStr(num):
return str(num).zfill(2)
l=range(1,7)
x=[1,2,3,4,5,6]
y=[1,2,3,4,5,6]
print(list(map(inToStr,l))) # 传函数名字和序列名字
print(list(map(inToStr,x)))
print(list(map(inToStr,y)))
l = [1,2,3,4,5,6,7,8,9,10]
def t(num):
if num%2 == 0:
return True
# l2 = list(filter(t,l))
l3 = list(map(t,l))
# print(l2)
print(l3)
3、filter()过滤器，帮你循环调用函数，如果函数返回false，那么就过滤掉这个值，是指从你传入这个list里面过滤
filter()用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，可用list()来转换为列表。
注意： filter()接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回True或 False，最后将返回 True 的元素放到新列表中。
def abc(num):
if num%2==0:
return True
res2 = list(filter(abc,range(1,11)))
print(res2)
res = filter(lambda n:n>5,range(10)) # 过滤掉0-9中不符合n>5的数据
for i in res: # 循环打印符合n>5的数据
print(i)
4、max()函数返回给定参数的最大值，参数可以为序列。
print("max(10,20,30):" , max(10,20,30) )
# max(10,20,30): 30
print("max(10,-2,3.4):" , max(10,-2,3.4) )
# max(10,-2,3.4): 10
print("max({'b':2,'a':1,'c':0}):" , max({'b':2,'a':1,'c':0}) ) # 字典，默认按key排序
# max({'b':2,'a':1,'c':0}): c
5、sum()函数对参数进行求和计算
print(sum([1,2,3,4,5])) # [15] print(sum(range(1,101))) # 1-100的和 # [5050] # [6] print( sum([1,2,3],4) ) # 列表计算总和后再加4，得到结果10 # [10] print( sum( (1,2,3),4 ) ) # 元组计算总和后再加4，得到结果10 # [10]
6、round()保留几位小数
round() 方法返回浮点数x的四舍五入值。（除非对精确度没什么要求，否则尽量避开用round()函数）
f=1.245344 print(round(f,2)) # 保留2位小数 # [1.25] print( round(4.3)) # 只有一个参数时，默认保留到整数 # [4] print( round(2.678,2)) # 保留2位小数 # [2.68] print( round(5/3,3)) # 运算表达式并保留3位小数 # [1.667]
7、chr()把数字转化成对应的ascii码表里对应的值
chr()函数用一个范围在range(256)内（即0～255）的整数作参数，返回一个对应的ASCII数值。
print(chr(65)) # [A]
8、ord()把字母转成对应的ascii码表里对应的数字
ord()函数是chr()的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的ASCII数值，或者Unicode数值，如果所给的 Unicode 字符超出了定义范围，则会引发一个 TypeError 的异常。
print(ord('A'))
# [65]
9、dir()查看某个对象里有哪些方法
dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
a=[] import random print(dir(a)) print(dir(random)) print( dir() ) # 获得当前模块的属性列表 # 返回：['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__'] print( dir([]) ) # 查看列表的方法 # 返回：['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', # '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', # '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', # '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', # 'sort']
10、bool()布尔类型的，返回True False
bool() 函数用于将给定参数转换为布尔类型，如果参数不为空或不为0，返回True；参数为0或没有参数，返回False。
a='jj'
b={}
c=[1,2]
d=0
print(bool(a)) # [True]
print(bool(b)) # [False]
print(bool(c)) # [True]
print(bool(d)) # [False]
11、eval()执行一些简单的Python代码，运算、定义变量
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
s ='{"a":"1"}'
res = eval(s)
print(res)
# [{'a': '1'}]
12、exec()执行一些复杂的代码，exec函数没有返回值就是none
exec() 执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码。
s2 = '''
for i in range(5):
print(i)'''
print(exec(s2))
exec("for i in range(5): print('iter time is %d'%i)") # 执行复杂的for循环
# iter time is 0
# iter time is 1
# iter time is 2
# iter time is 3
# iter time is 4
13、zip()把多个list揉到一起，把多个list变成了多维数组
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。可以使用 list() 转换来输出列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。利用 * 号操作符，可以将元组解压为列表。
name = ['nhy','lyy','sss']
money = [22,30,40,333,4444,555]
print(list(zip(name,money)))
# [('nhy', 22), ('lyy', 30), ('sss', 40)]
a = [1,2,3]
b = [4,5,6]
c = [7,8,9,10]
for i in zip(a,b):
print(i)
# 返回结果：
# (1, 4)
# (2, 5)
# (3, 6)
print(list(zip(a,b))) # list() 转换为列表
# [(1, 4), (2, 5), (3, 6)]
print(list(zip(b,c))) # 元素个数与最短的列表一致
# [(4, 7), (5, 8), (6, 9)]
a1,a2 = zip(*zip(a,b)) # 用zip(*)解压
print(list(a1)) # [1, 2, 3]
print(list(a2)) # [4, 5, 6]
14、lambda:匿名函数，功能很简单的一个函数，用完一次就拉倒
a=lambda num:str(num).zfill(2) # 匿名函数，冒号前面是入参，冒号后面是返回值 print(a(1)) print(list(map(lambda num:str(num).zfill(2),range(1,7))))
三、导入第三方模块
<一>、模块、包
1、模块
模块实质上就是一个python文件。它是用来组织代码的，意思就是把python代码写到里面，文件名就是模块的名称，test.py test就是模块的名称
2、包
包，package本质就是一个文件夹，和文件夹不一样的是它有一个__init__.py文件。包是从逻辑上来组织模块的，也就是说它是用来存放模块的，如果想到如其他目录下的模块，那么这个目录必须是一个包才可以导入。
<二>、模块分类
1、标准模块、标准包
python自带的这些模块，直接import就能用的
import string,random,datetime,os,sys,json,hashlib
2、第三方模块
别人写好的一些模块，你要安装之后才可以用
想实现某个功能，可以先去百度搜一下有没有第三方模块
3、自己写的python文件
<三>、安装第三方模块
1、傻瓜式的
(1) 直接在命令行窗口输入命令 pip install pymysql 、pip install redis
pip在python3.4以上的版本是自带的。但这种方式需要保证pycharm中的Project Interpreter路径是Python安装路径，否则即使窗口显示下载安装成功，依然不能成功import
因为命令行下载下来的第三方安装包存储在Python安装路径\python3\Lib\site-packages
而pycharm import时，是从pycharm->File->Settings->Project Interpreter->设置的路径下\python\venv\Lib\site-packages去取第三方安装包
(2) 也可以直接在pycharm中安装第三方模块，这样安装的模块会放在Project Interpreter->设置的路径下\python\venv\Lib\site-packages下，就可以直接使用。
(3) 若提示pip命令不存在
输入 where pip
若提示pip不是内部命令
pycharm External Libraries
备注：python 3.5以后 scripts自动加入到计算机环境变量
没有pip命令的怎么搞
a、pycharm里面点python console
b、找到python安装目录
c、然后把安装目录下的scripts目录，加入到环境变量里面即可
ps：环境变量在PATH里面加
(4) Unknown or unsupported command 'install' 出来这个问提怎么解决
a、打开 C:\strawberry\perl\bin\
b、把这个目录下的pip 都改成其他的名字，这个对其他的没有影响
2、手动安装
限制外网无法直接下载时，可以找别人下载好包然后手动安装
(1) 百度搜索：python redis
(2) 找到网址：https://pypi.python.org/pypi/redis#downloads，下载安装包
(3) 安装whl结尾的安装包
shift+右键，在此处打开命令行窗口（或者在地址栏中直接输入cmd）
pip install redis-2.10.6-py2.py3-none-any.whl
(4) 安装tar.gz结尾的安装包
a、解压这个压缩包
b、进入到这个解压之后的文件夹里面(shift+右键，在此处打开命令行窗口（或者在地址栏中直接输入cmd）)
c、在命令行里面运行 python setup.py install
3、卸载模块
pip uninstall xxx #卸载
<四>、导入模块的顺序、实质
1、python导入模块时候的顺序：
(1) 从当前目录下找需要导入的python文件
(2) 从python的环境变量中找 sys.path
2、导入模块的实质：
就是把python文件从头到尾执行一次
举个例子：
(1) 自定义一个python模块 dr.py，放在当前目录下
name = 'hello'
def my():
print('python')
my()
(2) 新建一个tmp.py
import dr #导入文件的时候已经把python文件执行了一次,打印出python print(dr.name) #打印出hello dr.my() #打印出python
上面的代码还可以用下面这种方式写
from dr import name,my #这种调用自定义函数时不用再写“文件名.函数”，直接写函数或者变量名 print(name) my()
from dr import * #导入所有的 #from aa import * my() #尽量不要用，因为看源码的时候会很难看出来函数属于哪个文件
(3) 当把dr.py放在sys.path其中一个环境变量下后，dr.就可以点出函数了
(4) 当前目录和path环境变量下都有dr.py，会优先选择当前目录下的dr.py
四、导入模块
Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
例子
下例是个简单的模块 support.py：
def print_func( par ):
print "Hello : ", par
return
*******************************************************
name = 'tools文件'
def test():
print('test函数')
return 'abc'
if __name__ == '__main__':
# 如果本模块被导入了，通过__name == __main__防止执行下面的代码
test()
print(name)
*******************************************************
1、import 语句
模块的引入
模块定义好后，我们可以使用 import 语句来引入模块，语法如下：
import module1[, module2[,... moduleN]]
比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时，必须这样引用：
模块名.函数名
当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support.py，需要把命令放在脚本的顶端：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")
一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
# import tools # import模块的实质就是把模块从上到下执行一边
# result=tools.test()
#
# print(tools.namne)
# print('result',result)
import sys
sys.path.insert(0,r'E:\PycharmProjects\mjz\day4')
# print(sys.path)
import tools
print(tools.name)
二、from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
from modname import name1[, name2[, ... nameN]]
例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：
from fib import fibonacci
这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。
3、from…import* 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
例如我们想一次性引入 math 模块中所有的东西，语句如下：
from math import *
4、搜索路径
当你导入一个模块，Python 解析器对模块位置的搜索顺序是：
- 1、当前目录
- 2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
- 3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
五、OS模块
操作系统相关的东西都在os模块里面：import os
import os
os.remove() # 删除文件
os.rename() # 重命名
os.mkdir(r'E:\besttest') # 创建文件夹,如果不指定绝对路径，在当前目录下创建；如果父目录不存在，会报错
os.makedirs(r'case/login') # 创建文件夹：makedirs父目录不存在，回创建父目录
os.path.getsize('products.json') # 获取文件大小
os.path.exists('products.json') # 判断是否存在，返回True或False
os.path.getatime('products.json') # 最近一次操作时间
os.path.getctime('products.json') # createtime
os.path.getmtime('products.json') # modifytime
os.path.split(r'E:\PycharmProjects\mjz\day4\products.json') # 分割文件路径和文件名
os.path.isfile(r'test\ly1\aaa') # 是否为文件，若文件不存在，也会返回False
os.path.isdir(r'test\ly1\aaa') # 是否为文件夹
os.path.dirname(r'test\ly1\aaa') # 取父目录
os.path.abspath('__file__') # 根据相对路径获取绝对路径 .一个点代表当前目录；..两个点代码上层目录
os.path.join('test','a.txt') # 拼接路径
os.getcwd() # 取当前路径
os.chdir() # 更改当前目录，可以写相对路径或者绝对路径 ..进入上一级目录 .代表当前目录
os.environ # 查看电脑的环境变量
os.popen('ipconfig').read() # 拿到返回的结果用popen
os.system('ipconfig') # 执行操作系统命令，返回0代表执行命令成功，1表示命令执行不成功
os.system('cale') # 执行操作系统命令
files=os.listdir(r'E:\PycharmProjects\mjz\day4') # 获取某个目录下的文件 print(files) print(os.path.isdir(r'E:\PycharmProjects\mjz\day3')) print(os.path.isfile(r'E:\PycharmProjects\mjz\day3')) os.chdir(r'E:\PycharmProjects\mjz\day3') print(os.getcwd()) # 获取当前路径
搜索目录下“.vep”格式文件
name = 'vep'
def search_file(path,name):
for cur_dir,dirs,files in os.walk(r'E:\PycharmProjects\mjz\day4'):
for file in files:
if name in file:
abs_path = cur_dir+'/'+file
print('找到%s,路径是%s' %(file,abs_path))
print(cur_dir,dirs,files)
print('==============')
search_file('/',name)
六、时间模块
time模块可以用于格式化日期和时间，时间间隔是以秒为单位的浮点小数。每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
下面是time模块常用的一些时间格式转换的函数。时间戳可以直接比较大小。
1、时间戳
#想时间戳和格式化好的时间互相转换的话，都要先转成时间元组，然后才能转
print(time.time()) # 获取当前时间戳
# [1571581554.5838938]
print(time.strftime('%Y-%m-%d %H:%M:%S')) # 当前格式化好的时间
# [2019-10-20 22:25:54]
2、从计算机诞生那一秒到现在过了多少秒
# 1、时间戳转成时间元组 timestamp = 1571476513 time_tuple = time.localtime(timestamp) # 以当前时间时区转化 print(time_tuple) # 时间元组 # [time.struct_time(tm_year=2019, tm_mon=10, tm_mday=19, tm_hour=17, tm_min=15, tm_sec=13, tm_wday=5, tm_yday=292, tm_isdst=0)] # tm_开头的元组
# time_tuple = time.gmtime(timestamp) # 以标准时区的时间转换 默认取标准时区的时间元组，如果传入了一个时间戳，那么就把时间戳转化成时间元组
result = time.strftime('%Y-%m-%d %H:%M:%S',time_tuple) # 把时间元组转换成格式化好的时间
print(result)
# [2019-10-20 22:25:54]
def timestamp_to_str(timestamp=None,format='%Y-%m-%d %H:%M:%S'):
"""时间戳转格式化好的时间，默认返回当前时间"""
if timestamp:
time_tuple = time.localtime(timestamp) # 以当前时区的时间转换
result =time.strftime(format,time_tuple)
else:
result = time.strftime(format)
return result
# 2、时间转成时间戳
s = '2019-10-20 22:25:54'
time_tuple = time.strptime(s,'%Y-%m-%d %H:%M:%S') # 格式化好的时间，转时间元组的
result = time.mktime(time_tuple) # 把时间元组转成时间
print(result)
def str_to_timestamp(string=None,format='%Y-%m-%d %H:%M:%S'):
'''格式化好的字符串转时间戳，默认返回当前时间戳'''
if string:
time_tuple = time.strptime(string,format)
result =time.mktime(time_tuple)
else:
result = time.time()
return int(result)
# 3、获取10天后的时间 t1 = str_to_timestamp() + 60*60*24*10 result = timestamp_to_str(t1) print(result) # [2019-10-30 22:49:06]