1.函数参数的传递规则，先按位置传递参数，再按照关键字传递参数。
#站在实参的角度上：
#按照位置传参
#按照关键字传参
#混着用可以:但是 必须先按照位置传参，再按照关键字传参数
# 不能给同一个变量传多个值
#站在形参的角度上
#位置参数：必须传,且有几个参数就传几个值
#默认参数: 可以不传，如果不传就是用默认的参数，如果传了就用传的
#只有调用函数的时候
#按照位置传 ： 直接写参数的值
#按照关键字： 关键字 = 值
#定义函数的时候：
#位置参数 ： 直接定义参数
#默认参数，关键字参数 ：参数名 = '默认的值'
#动态参数 : 可以接受任意多个参数
#参数名之前加*，习惯参数名args，
#参数名之前加**，习惯参数名kwargs
#顺序：位置参数，*args,默认参数,**kwargs
# 动态参数有两种：可以接受任意个参数
#*args ： 接收的是按照位置传参的值，组织成一个元组
#**kwargs： 接受的是按照关键字传参的值，组织成一个字典
#args必须在kwargs之前
def func(b,a): print(a,b) func(b=2,a = 1) def func(a,b): print('%s,%s'%(a,b)) func('等等','水电费') def func(*args): print(args) func(1,2,[1,2]) def func(**kwargs): print(kwargs) func(a = 1,b =2) def func(*args): print(args) li = [1,2] func(*li) def func(**kwargs): print(kwargs) li = {'a':1,'b':2} func(**li)
2.这两天困扰我的一个问题，安装pycharm没有选中jre时候显示没有安装JDK,安装了1.7的JDK后，又显示could not find main class com/intellij/idea/Main。
后来在网上查找资料发现以下解决方法：
1.应该是是JDK 的版本太低，我的从1.7升级到1.8就解决问题了。
2.官网oracle下载JDK1.8安装包后，按照正常步骤安装，然后修改环境变量如下：
(1)新建->变量名"JAVA_HOME"，变量值"C:\Java\jdk1.8.0_05"（即JDK的安装路径）
(2)编辑->变量名"Path"，在原变量值的最后面加上“;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin”
(3)新建->变量名“CLASSPATH”,变量值“.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar”
详细情况可参考我的百度账号，我的经验收藏的一篇文章
最后成功了，开心。
3.一些小练习
#列表转换为字符串 # li = ['dfd', 'afe', 'd'] # print(''.join(li)) #字符串转换列表 # s = 'skdlffsf' # print(s.split('l',1)) #倒着打印100-0 ''' for i in range(100,-1,-1): print(i) ''' # def func(a,b): # print('%s,%s' % (a, b)) # # func(1,2) s=input('>>>') li = [] for i in s: print(i) if i.isdigit() : if int(i) % 2 == 1: li.append(i) print(len(li))
dic={'最终计算结果':None}
dic={}
content = input('请输入内容：')
s = content.split('+')
sum = 0
for i in s:
sum += int(i)
dic['最终计算结果'] = sum
print(sum,dic)
4.昨天的2道练习题目
# import os # with open('ss', mode='r+', encoding='utf-8"') as f, open('ssss', 'w',encoding = 'utf-8') as f1: # for i in f: # if 'alex' in i: # i = i.replace('alex', 'sb') # f1.write(i) # # os.remove('ss') # os.rename('ssss','ss') # apple 10 # tesla 100000 1 # mac 3000 2 # lenovo 30000 3 # chicken 10 3 li = [] with open('aa',mode='a+',encoding='utf-8') as f: f.write('apple 10 3\n') f.write('tesla 100000 1\n') f.write('mac 3000 2\n') f.write('lenovo 30000 3\n') f.write('chicken 10 3\n') f.seek(0) for i in f: s = i.split() dic = {'name':s[0],'price':s[1],'account':s[2]} li.append(dic) print(li)
5.函数的参数
# def 深圳(): # print('欢迎你') # 深圳() def func(l = []): l.append(1) print(l) func() func([]) func()
6.函数的命名空间和作用域
在这里我们首先回忆一下python代码运行的时候遇到函数是怎么做的。
从python解释器开始执行之后，就在内存中开辟了一个空间
每当遇到一个变量的时候，就把变量名和值之间的对应关系记录下来。
但是当遇到函数定义的时候解释器只是象征性的将函数名读入内存，表示知道这个函数的存在了，至于函数内部的变量和逻辑解释器根本不关心。
等执行到函数调用的时候，python解释器会再开辟一块内存来存储这个函数里的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量会存储在新开辟出来的内存中。函数中的变量只能在函数的内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
我们给这个“存放名字与值的关系”的空间起了一个名字——叫做命名空间
代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间，在函数的运行中开辟的临时的空间叫做局部命名空间
命名空间 有三种
#内置命名空间 —— python解释器
# 就是python解释器一启动就可以使用的名字存储在内置命名空间中
# 内置的名字在启动解释器的时候被加载进内存里
#全局命名空间 —— 我们写的代码但不是函数中的代码
# 是在程序从上到下被执行的过程中依次加载进内存的
# 放置了我们设置的所有变量名和函数名
#局部命名空间 —— 函数
# 就是函数内部定义的名字
# 当调用函数的时候 才会产生这个名称空间 随着函数执行的结束 这个命名空间就又消失了
#在局部:可以使用全局、内置命名空间中的名字
#在全局:可以使用内置命名空间中的名字，但是不能用局部中使用
#在内置:不能使用局部和全局的名字的
作用域
作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。
全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效
局部作用域：局部名称空间，只能在局部范围内生效
# def sum(a,b): # print(a if a>b else b) # sum(1,2) # def input(): # print(1) # def func(): # input = 1 # print(input) # func() # globals和locals方法 # c = 10 # d = 13 # def func(): # a=12 # g = 23 # f = 88 # b = 13 # print(locals()) # # print(globals()) # func() #print(locals())#globals 永远打印全局的名字 #print(globals())#locals 输出什么 根据locals所在的位置 #global关键字 # a = 10 # def func(): # global a # a = 12 # # print(a) # func() # print(a) # global a # a = 10 # def func(): # # a = 12 # print(a) # # # print(a) # func() # print(a)
7.不通过global 在局部作用域修改全局变量
a = 10 def func(): a = 20 return a a = func() print(a)
8.函数的嵌套和作用域链
#函数的嵌套调用 # def max2(x,y): # m = x if x>y else y # return m # def max4(x,y,z,w): # c = max2(x,y) # d = max2(z,w) # return max(c,d) # print(max4(1,5,3,4)) #函数的嵌套定义 # def f1(): # print(1) # def f2(): # print(2) # f2() # f1() #函数的作用域链 # def f1(): # a = 1 # def f2(): # global a#只修改了全局变量，上面的局部变量没有修改 # a = 2 # print(a) # f2() # print(a) # f1() # print(a) #nonlocal关键字和global的区别 #nonlocal 只能用于局部变量 找上层中离当前函数最近一层的局部变量 #声明了nonlocal的内部函数的变量修改会影响到 离当前函数最近一层的局部变量 # 对全局无效 # 对局部 也只是对 最近的 一层 有影响 # a=1 # def f1(): # a = 1 # def f2(): # nonlocal a#只修改了全局变量，上面的局部变量没有修改 # a = 2 # print(a) # f2() # print(a) # f1() # print(a)
9.函数名的本质
#函数名的本质 #函数名本质上就是函数的内存地址 #1.可以被引用 # def func(): # print(1) # f = func # print(f) #2.可以被当作容器类型的元素 # def f1(): # print('f1') # def f2(): # print(f2) # def f3(): # print(f3) # l = [f1,f2,f3] # l[0]() #3.可以当作函数的参数和返回值 #就当普通变量用 def func(): print(123) def wahaha(f): f() return f #函数名可以作为函数的返回值 qqxing = wahaha(func) # 函数名可以作为函数的参数 qqxing()
10.闭包
闭包函数：
内部函数包含对外部作用域而非全剧作用域名字的引用，该内部函数称为闭包函数
#函数内部定义的函数称为内部函数
由于有了作用域的关系，我们就不能拿到函数内部的变量和函数了。如果我们就是想拿怎么办呢？返回呀！
我们都知道函数内的变量我们要想在函数外部用，可以直接返回这个变量，那么如果我们想在函数外部调用函数内部的函数呢？
是不是直接就把这个函数的名字返回就好了？
# name = 'chun' # def func(): # name = 'shang' # def inner(): # print(name) # # inner() # func() # def func(): # name = 'shang' # def inner(): # print(name) # return inner # f = func() # f() #判断闭包函数的方法__closure__ #输出的__closure__有cell元素 ：是闭包函数 # def func(): # name = 'shang' # def inner(): # print(name) # print(inner.__closure__) # return inner # f = func() # f() #输出的__closure__为None ：不是闭包函数 # name = 'shang' # def func(): # # def inner(): # print(name) # print(inner.__closure__) # return inner # f = func() # f() #闭包嵌套 # def wrapper(): # money = 1000 # def func(): # name = 'eva' # def inner(): # print(name,money) # return inner # return func # # f = wrapper() # i = f() # i() #闭包函数获取网络应用 from urllib.request import urlopen def index(): url = "http://www.xiaohua100.cn/indexhtml" def get(): return urlopen(url).read() return get xiaohua = index() content = xiaohua() print(content)
