我的自学Python之路（第二阶段Day6）
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)
上一篇： 一个java流量控制小程序
下一篇： 提供推荐——协作型过滤