python基础：函数传参、全局变量、局部变量、内置函数、匿名函数、递归、os模块、time模块、解包

---恢复内容开始---

一、函数相关：

1.1位置参数：

ef hello(name,sex,county='china'):
    pass
#hello('hh','nv')   #位置参数、默认参数

1.2可变参数：也叫参数组，在参数名前加*，一般习惯命名为*args

*args 特性：

（1）不必传

（2）不限制参数个数，可传一个或多个

（3）传多个参数的时候，args把传的值放在一个元组中

def send_email(*args):
    print("发邮件")
    print（args）   #结果为一个元组

调用：
send_email('h')
send_email()
send_email('h','daibai','test')

1.3**kwargs:两个**，关键字参数：

(1).不限制参数个数，传多个参数时，把参数放在一个字典里

(2).传参必须使用关键字调用，key=value格式

(3).不是必传

def send_email(**kwargs)：

　　print（“发邮件”）

　　print(kwargs)

send_email(name='xiaohei',age='17'）

1.4 注意事项：

#参数调用例子及错误示范
def myfunc(name,addr,phone,qq):
    print(name,addr,phone,qq)
myfunc(phone=110,addr='bks',qq='9459666',name='hh')    #正确。关键字调用，可以不用按位置调用
myfunc('hh',phone=110,addr='bks',qq='9459666')    #正确。位置参数可以与关键字调用共同用，但注意使用方法
#myfunc('hh',phone=110,addr='bks','9459666')     #错误示范。关键字参数后边，不能再用位置参数，用了关键字传值后，后边的值都要用关键字参数

def myfunc1(name,addr='bks',*args):
    print(name,addr,args)
myfunc1('xiaohei')
myfunc1('xiaohei','xiaobai')         #按位置传，xiaobai传给addr
myfunc1('xiaohei','xiaobai','tiantongyuan','huilongguan')     #按位置传，xiaobai传给addr,xiaohei给name，其他值都传给args
#myfunc(name='xiaohei',addr='xiaobai','abc')       #报错：如果用前边用关键字传值，args在最后就无法传值了。

def myfunc2(name,addr='bks',**kwargs):
    print(name,addr,kwargs)
myfunc2(name='xiaohei',addr='xiaobai',kwargs='abc')    #前边传关键字，多元参数就用kwargs

def myfunc3(name,addr='bks',*args,**kwargs):
    print(name,addr,kwargs)
myfunc2(name='xiaohei',addr='xiaobai',age='18',sex='nv')    #调用的时候   age和sex都给了kwargs,因为args不能传关键字，且可以为空

 2、函数传参：

2.1 解包：

def connect(ip,port,username,password):
    print(ip)
    print(port)
    print(password)
    print(username)

info=('192.167.1.102','3306','name','123456')
list=['192.16.108.227','3306','hehe','123456']
se={1,2,3,4}             #可以解包，但是是无序的
s='1234'   
dic = {'ip':'127.0.0.1','port':3307,'username':'root','password':'1233'}
#以上几种，均可以解包
connect(*info)      #解包：把元组解成：'192.16.108.227','3306','hehe','123456'
connect(*list)          #解包：把list解成：'192.16.108.227','3306','hehe','123456'
connect(**dic)    #解包：'ip'='127.0.0.1','port'=3307,'username'='root','password'='1233'，   字典解包 ，要用关键字传值，所以是两个**
#两**：关键字传值

3.递归：

#递归：函数自己调用自己
#递归最多递归999次，所以如果死循环，函数会报错
#用递归，一定要指定一个结束的条件，不能进入死循环

count=0
def hello():
    global count
    count+=1
    print('hello')
    print(count)
    hello()
hello()   #结果会报错，因为是个死循环

def test():
    num=input("输入一个数字")
    if num%2==0:#判断输入的数字是不是偶数
           return True#如果是偶数的话，程序就退出了，返回true
    print("不是偶数")  
    return test()#如果不是偶数的话继续调用自己，输入值
print(test1())#调用test

4.内置函数：

4.1 dir（）#可以打印这个模块或变量下可以调用的方法

#coding=utf-8
#python3 默认字符集是utf-8

import random
#dir（）#可以打印这个模块或变量下可以调用的方法
print(dir(random))  #可以打印这个模块或变量下可以调用的方法
print(dir(s))

4.2 排序：sorted():被排内容的必须是同一种数据类型

s=sorted(s)    #字符串排序后会成为list
se=sorted(se)   #排序，被排的必须是同一种数据类型
print(s)

4.3判断：

#all():判断，可判断迭代的对象里面的值是否都是真
#非零即真，非空即真
print(all([1,2,3,4,5,0])
#any():判断可迭代的对象里面的值是否有一个为真
print(any([1,2,3,4,5,0])) 
#bool('s')  #把一个对象转为布尔类型，可判断非空 非零情况
print(bool('s')) 
#十进制转二进制：
print(bin(10))   #10进制转2进制
#打印数字对应的ascii码
print(chr(32))  #打印数字对应的ascii

 5.执行python代码：exec()、eval()

s='print("hello,world")'
s2='print(dir(random)) '
s3='''
print("hello")
'''
exec(s)
exec(s2)       #执行python代码
exec(s3)
res=eval('1+1')    #只能执行简单的python代码
print(res)
res2=eval("{'1','2','3','4'}")
print(res2)

6.匿名函数：lambda  

import random,string,os
niming=lambda x:x+1  #冒号前是要传的参数，冒号后是返回值
#同下：
def niming2(x):
    return x+1
print(niming(1))
print(niming2(1))

7.循环调用函数：map()、filter() 

7.1  map():循环取值并调用

def choice(a):
    return(a+1)
#同上
result=list(map(choice,[1,2,3,4,5,6]))    #如果不转成list， map的结果是一个对象，必须转成list才能被执行
print(result)    
#函数名也是变量名，可以直接调用               

stus=['han','xiaoming','caicai','xiaohei']
for stu in stus:
    os.mkdir(stu)
同上
result=list(map(os.mkdir,stus))       #迭代器：必须转成list才能被执行
print(result)                #mkdir函数没有返回值，所有返回的list 都是None
map():
1.map是循环调用函数的
2.map会把函数每次调用的返回值保存，最后返回。如果调用的函数没有返回值，就返回none

def add_prx(name):
    return 'cnz_%s'%name
res=list(map(add_prx,stus))
print(res)

7.2 ：filter:()  

#1.循环的调用函数
#2.帮你过滤传入的参数，函数的返回结果是True那就保存，返回false就不要了

stus=['1','2','3','']
def add_prx(name):
    return name
res=list(map(add_prx,stus))
print(res)   #结果：['1', '2', '3', '']，没有过滤空的
res2=list(filter(add_prx,stus))
print(res2)   #['1', '2', '3']  过滤了空的（False）

score=['50','90','80','20','90']
result=list(filter(lambda score:score>60,score))    #如果score<60,返回false,就不返回了)
print(result)
#代码同下：

score_list=[90,40,59,80,79]
def panduan(score):
    return score>60
result=list(filter(panduan,score_list))

二、全局变量、局部变量

全局变量：
大家都可以用的变量
全局变量定义在最上边

不可变的数据类型，如int，string，stuple，需要修改全局变量必须加global
可变的数据类型，如字典、list、set，不需要加global
局部变量
函数里面定义的都是局部变量
调用函数结束后，局部变量就释放了

language='python'  #全局：int、string、tuple这三种数据类型，如果要修改全局变量的话，需要用global
list=[1,2,3,4]     #list、dict、set这种可以修改的变量类型，不需要加gloable也可以修改全局变量

def hello():
    global language    #声明，更改全局变量，更改后全局变量改为本函数中定义的局部变量。
    language='java'
    list.append('hello')           #可以直接修改，不需要声明
    print('language')

def xiaobai():
    print(list)           #结果是list=[1,2,3,4,'hello']  
    print(language)   #结果是Java
hello()
xiaobai()

练习：

#练习1
money=500
def test(consume):
    return money-consume

def test1(money):
    return test(money)+money
money=test1(money)
print(money)


运行结果是500

#练习2：
def test():
    global a
    a = 5
def test1():
    c = a + 5
    return c
res = test1()
print(res)
#运行结果会报错， 由于没有定义a,调用是也没有先调用test（），所以在执行test1（）时，a是没有定义的

三、time模块

3.1取格式化好的时间

#表示时间：
#时间戳：从计算机诞生的时间到现在过了多少秒
#格式化好的时间：2019-6-16

#获取格式化好的时间：
print(time.strftime('%y-%m-%d %H:%M:%S'))   #获取当前时间，连接符自己定义
print(time.strftime('%Y.%m.%d %H:%M:%S'))
print(time.strftime('%H:%M:%S'))   #只获取时间，不获取日期

3.2、取时间戳：print(time.time())

转换为时间戳后，方便进行计算。

比如说，取三天后的时间： print(1560674721+60*60*24) 

3.3 、时间戳转化为格式化的时间：先把时间戳转化为时间元组，再把时间元组转化为格式化时间

time_tuple=time.gmtime(1560674916)      #通过时间戳获取标准时区的时间元组

time_tuple=time.localtime(1560674916)     #通过时间戳获取当地时区的时间元组

#时间元组转为格式化时间：time.strftime

print(time.strftime('%Y.%m.%d %H:%M:%S',time_tuple))

3.4、格式化时间转为时间戳：先转为时间元组，再转为时间戳

#转时间元组：time.strptime()

time_tuple=time.strptime('19-06-16 16:00:00','%y-%m-%d %H:%M:%S')#前后的格式必须对应
print(time_tuple)

#时间元组转时间戳：time.mktime(time_tuple)

3.5、格式化时间和时间戳互相转化的函数

def str_to_timestamp(str=None,format='%Y-%m-%d %H:%M:%S'):
    #格式化时间转时间戳,如果不传格式化好的时间，就返回当前的时间戳
    if str:
        time_tuple = time.strptime(str,format)
        return int(time.mktime(time_tuple))
    return time.time()

str_to_timestamp()

def timestamp_to_str(timestamp=None,format='%Y-%m-%d %H:%M:%S'):
    '''这个是把时间戳转换成格式化好的时间，如果不传时间戳，那么就返回当前的时间'''
    if timestamp:
        time_tuple=time.localtime(timestamp)
        return time.strftime(format,time_tuple)
    return time.strftime(format)
timestamp_to_str()

四、OS模块   与操作系统相关的模块

print(os.listdir(r'E:cnz6_16'))#列出某个目录下边文件夹的文件
print(os.path.isfile(r'E:cnz6_16'))   #判断是不是文件
print(os.path.isdir(r'E:cnz6_16'    )) #判断是不是文件夹

os.mkdir('test')    #当前路径下创建文件夹,
os.makedir('test2')
#以上两种方式的区别
# os.mkdir(r'E:cnz6_17hanmin')  #父目录不存在创建会报错，
# os.makedirs(r'E:cnz6_18hanmin2')   #父目录不存在也可以创建，

os.rename(r'E:cnz6_16笔记','biji.txt')   #重命名文件
os.remove(r'E:cnz6_16笔记')  #删除文件，不能删除文件夹
os.rmdir(r'E:cnz6_16	est'   )#只能删除空文件夹
os.getcwd()  #获取当前工作路径
os.chdir( path )  #修改当前工作路径
os.system('ipconfig')   #执行操作系统命令
result=os.popen('ipconfig').read()   #获取命令执行结果
os.path.getsize('biji.txt')    #获取文件大小
os.walk('E:cnz6_16')#获取目录下的所有文件夹、文件

os.path.dirname(r''E:cnz6_16'')  #获取目录的父目录

os.path.join(path,path,path,username)#连接几个路径，不需要管分隔符
os.path.abspath(__file__)   #获取当前路径的绝对路径

for cur_dir,dirs,files in os.walk(r'E:cnz6_16'):#三个参数代表的含义是固定的，位置也是固定的，3个参数必传
    print（cur_dir）  #当前文件夹
    print（dirs）      #当前目录下的所有文件夹
    print(files)   #当前目录下的所有文件
    break

练习：查找指定目录下，有哪些文件：.mp4,.txt结尾的文件

#1.获取目录下有哪些文件  os.walk()
#2.判断文件名是否以.mp4,.txt结尾

def  find_files(path):
    for cur_dir,dirs,files in os.walk(path):
        print('当前查找路径'，path)
        for file in files:
            if file.endswith('.mp4') or file.endswith('.txt'):
                print('该目录下有寻找文件',file)
                break
find_files(r'E:/')

os.path.dirname(r''E:cnz6_16'')  #获取目录的父目录
os.path.join(path,path,path,username)   #连接几个路径，不需要管分隔符
print(os.path.join('e:\','users','a.txt'))
 os.path.abspath()    #通过相对路径取绝对路径
print(os.path.abspath('../6_2'))       #两个点代表上级目录，一个点代表当前路径，带点的是相对路径。
os.path.exists() #判断文件是否存在
print(os.path.exists(r'E:cnz'))
 os.path.split()       #分割路径和文件名
print(os.path.split(r'E:cnz6_16iji.txt'))

os.path.gettime()#获取某个文件的修改时间,返回时间戳
os.path.getctime() #获取某个文件的创建时间,返回时间戳
os.path.getatime()#获取某个文件的最后访问的时间,返回时间戳
print(os.path.getctime(r'E:cnz6_16iji.txt'))
print(os.path.getmtime(r'E:cnz6_16iji.txt'))
print(os.path.getatime(r'E:cnz6_16iji.txt'))