python学习篇 - 函数
1.深浅拷贝
浅拷贝：就是只拷贝第一层数据，第二层数据共用，如果修改第一层数据，那么另一个的数据也改变
深拷贝：不光第一层拷贝，下一层的也拷贝，这是两个数据，改变一个，另一个不改变
2.代码块
is 判断内存地址
== 判断两边的值是否相等
repr 给程序员用的，显示原生数据
print 给用户用的，做了一些美化
3.
name = input(">>>") name 变量是字符串数据类型
4. () > not>and >or
print('''
文能提笔安天下
武能上马定乾坤
心存谋略何人胜
古今英雄唯是君
''')
print(1 > 1 or 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) #True
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 #false
'''
解释：其中and并列，有一个错误的就都是错误的了，然后看or
and 左边不是0，看右边。是0就是0
or 左边不是0，看左边，否则看右边
and 左边不是0，看右边
'''
函数
函数定义：函数是组织好的，可重复使用的，用来实现相关功能的代码块
规范：def 函数名（）
def userinfo():
print('username is ok')
userinfo() #调用函数的执行过程
看到定义一个函数，就在内存开辟了一个空间，存放函数
碰到调用的
执行函数体里面的内容
函数的返回值：
return
遇到return,函数结束，后面的东西不执行 *
返回多个结果是元祖，
什么都不写就是None
只会在函数里面用
def returnNewList(dic):
for li in dic:
if len(dic[li]) > 2:
dic[li] = dic[li][0:2]
#注意注意注意*********
#这里不能写return，写了直接退出，不会执行第二次的循环
else:
pass
return dic
dic = {"k1":"v1v2", "k2":[11,22,33,44]}
print(returnNewList(dic))函数的参数
写在函数定义的位置就是形参，调用的位置就是实参
关键字参数，就是使用关键字赋值的方式给函数传参
import os
def studentNews(news,updateNews,oldname, finame):
'''
函数是用来操作文件的
news 输入存在的字符串
updateNews 要修改的字符串
oldname 存在的文件
finame 修改后的文件名
'''
with open(oldname, encoding='utf-8', mode='r+') as f_h1,\
open('my.txt', encoding='utf-8', mode='a') as f_h2:
new = f_h1.read()
res = new.replace(news, updateNews)
f_h2.write(res)
os.remove(oldname)
os.rename('my.txt', finame)
print(f_h1)
while 1:
str = input("请输入信息:").strip()
newstr = str.split(',')
news,updateNews,oldname,finame = newstr
studentNews(news,updateNews,oldname, finame)函数的动态参数：
def func(a,d,f,*args,name='colr',**kwargs):
print(a,d,f)
print(args)
print(name)
print(kwargs)
func(1,2,3,2,3,4,5,6,name='ll',age=23,sex='nv') #kwargs必须是字符串
动态参数：
用途：在不确定接受参数的时候，使用*args和**kwargs
位置参数在前面，关键字参数在后面
在实参调用的时候， * 可以将迭代对象打散
在形参处，使用 * 就是在聚合
1.1关于*args
#args当形参不知道有几个的时候用这个，返回的是元祖
例子：
def func(a, *args):
print(a)
print(args)
func(1,'b',[1,2,3],{1,2,3},5,6) #这里面不能写变量1.2关于**kwargs
def func(a,x=1,**kwargs):
print(a)
print(kwargs['e']) #能打印出来，是一个字典
func(1,x=2,e=45,f=2)
dic = {'a':'b','c':'d'}
lis = [1, 2, 3, 4]
s = 'asdasdasd'
def func(*kwargs):
print(kwargs)
func(**dic) #字典
func(*lis) #列表
func(*s) #字符串1.3 命名空间
执行顺序： 内置空间代码 》 自己写的python文件 》 函数中的代码
取值顺序 ：局部空间 》 全局空间 》 内置空间
1.4 作用域
a = 10
def func():
global a #声明修改a
a+=1
func()
print(a)all = 0
def sum_num(*sum):
global all
for i in sum:
all = all + i
print(all)
sum_num(1,2,6,5,1) #all 在外面，函数内部可以看到，却不能修改函数名的使用
函数名是函数的内存地址，可以赋值给变量（函数名可以充当容器）
def f():
def a():
def b():
def c():
return 'abc'
return c()
return b()
return a()
print(f()) #能获取到abc，如果中间没有return,则为None
关于闭包：
1.1 闭包属于嵌套函数
1.2 在第二个函数内部使用第一个函数里面的非全局变量
def wrapper():
money = 10
def inner(num):
nonlocal money
money + = num
print(money)
print(inner.__closure__) #这里打印不是none，则是闭包
return inner
wrapper()(100)1.3 可迭代对象
具有.__iter__ 方法的就是可迭代对象
具有__iter__ 和 __next__就是一个迭代器
li = [1,2,3]
a = li.__iter__()
print(a.__next__())
print(a.__next__())
print(a.__next__())
例子2：
li = [1,2,3,4,5,6,7,8]
em = li.__iter__()
while 1:
try:
print(em.__next__())
except StopIteration:
break
1.4递归函数
import sys
sys.setrecursionlimit(10)
count = 0
def func():
global count
count += 1
print(count)
if count == 500:
return
func()
func()
'''
写函数，传入一个参数n，返回n的阶乘
例如:cal(7) 计算7*6*5*4*3*2*1
'''
def cal(num):
if num == 1:
return 1
return(num*(cal(num-1)))
print(cal(5))
"""
写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]
"""
lis1 = ['红心', '草花', '方片', '黑桃']
lis2 = ['A', 2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K']
lis3 = []
def func_f():
def card(*args):
lis3.append(args)
for li in lis1:
for li2 in lis2:
card(li, li2)
func_f()
print(lis3)
装饰器：
开放封闭原则：开放对扩展；封闭修改源代码；不能改变了人家的调用方式
import time
def warpper(f): # 接受被装饰的函数内存地址
def inner(*args,**kwargs): # 接受被装饰函数的参数
start_time = time.time() # 新功能
ret = f(*args,**kwargs) # 调用被装饰的函数,被装饰参数带上
end_time = time.time()
print('%s函数的运行时间:%s'%(f.__name__,end_time - start_time))
return ret # 被装饰的函数返回值
return inner
@warpper # func = warpper(func) 语法糖
def func(*args,**kwargs):
print(args) # 打印被装饰的函数参数
print('这是主功能!')
time.sleep(1)
return '大妈' # 返回值
ret = func(5) #ret = func(5) == inner(5) 返回值 func(5)
print(ret) # 被装饰的函数返回值内置函数
print(abs(-98)) # 求绝对值 正的负的 出来后全都是正的
print(bin(10)) # 将10进制转为2进制
print(callable(func)) # 检查这个对象是否可以调用
print(dir(1,2)) # 查看对象所有的方法
print(id('s')) # 查看数据的内存地址 ***
# print(isinstance([1,2,3],str)) #判断这个数据时什么类型 ***
# iter # 判断是不是可迭代对象 ***
# len() # 获取数据的长度 *****
# list() # 转换成一个列表 ***
print(max(1,2,3,4,5)) # 求最大值 ***
# li = [1,2,3,4]
# ls = [5,6,7,4,5,6]
# lst = ['a','b','c','d','e']
# print(list(zip(li,ls,lst))) #拉链 ****
匿名函数
lambda 关键字 x参数：x是返回值
一行函数，用于简单需求
print((lambda x:x)(5))
lambda 的返回值只能是一个
f = lambda x,y:x*y
print(f.__name__)
print(f(5,6))
print(sorted([7,2,3,4],reverse = True))
例子1：
li = ['你好啊', '我好', '大家都很好']
# def func(li):
# return len(li)
# print(sorted(li, key = func))
print(sorted(li,key=lambda x:len(x)))
例子2
li = [
{'age':19},
{'age':52},
{'age':48},
{'age':13},
]
def func(li):
return li['age']
print(sorted(li,key=func))
print(sorted(li, key=lambda x: x['age']))
例子3：
li = [1,2,3,4]
def func(li):
for i in li:
if i>2:
print(i)
func(li)
li = [1,2,3,4]
print(list(filter(lambda x:x>2,li)))
例子4：
from functools import reduce
li = [1,2,3,4]
def func(x,y):
return x*10+y
print(reduce(func,li))
例子5：
li = [1,2,3,4,5]
print(list(map(lambda x:x+10,li)))
#[11, 12, 13, 14, 15]
例子6：
li = [1,2,3,4,5]
def func(i):
return i+10
print(list(map(func,li)))
#[11, 12, 13, 14, 15]