作为一个Python初学者，我想通过写博客的方式来记录下来自己成长的过程，同时也分享一下自己学习到的知识。以下都是一个Python初学者对Python语言的一些浅见和个人理解。
‘’’
Python中，定义函数的语法如下：
def 函数名([参数列表]):
‘‘文档字符串’’ (函数的注释，三个单引号)
函数体/若干语句
要点：
1.我们使用def来定义函数，然后就是一个空格和函数名称；
（1）Python执行def时，会创建一个函数对象，并绑定到函数名变量上
2.参数列表
（1）圆括号内是形式参数列表，有多个参数列表则使用逗号隔开
（2）形式参数不需要声明类型，也不需要指定函数返回值类型
（3）无参数，也必须保留空的圆括号
（4）实参列表必须与形参列表一一对应
3.return返回值
（1）如果函数体中包含return语句，则结束函数执行并返回值
（2）如果函数体中不包含return语句，则返回None值
(3)要返回多个返回值，使用列表、元组、字典、集合将多个值存起来即可
4.调用函数之前，必须要先定义函数，即先调用def创建函数对象
（1）内置函数对象会自动创建
（2）标准库和第三方库函数，通过import导入模块时，会执行模块中的def语句
‘’’
#函数的定义和调用
def test01():
print("*"*10)
print("0"*10)
print(id(test01))
print(type(test01))
print(test01)
test01()
#形参和实参
def printMax(a,b):
if a>b:
print(a,"较大值")
else:
print(b,"较小值")
printMax(10,20)
printMax(200,100)
#返回值
def add(a,b):
print("计算两个数的和：{0},{1},{2}".format(a,b,(a+b)))
return a+b
def test02():
print("ayg")
print("haha")
return
print("xixi")
def test03(x,y,z):
return [x*10,y*10,z*10]
c = add(30,40)
test02()
print(test03(1,2,3))
‘’’
全局变量：
1.在函数和类定义之外声明的变量。作用域为定义的模块，从定义位置开始直到模块结束
2.全局变量降低了函数的通用性和可读性。应该尽量避免全局变量的使用
3.全局变量一般做常量使用
4.函数内要改变全局变量的值，使用global声明一下
局部变量：
1.在函数体中（包括形式参数）声明的变量
2.局部变量的引用比全局变量快，优先考虑使用
3.如果局部变量和全局变量同名，则在函数内隐藏全局变量，只是用同名的局部变量
‘’’
a = 3 #全局变量
def test01():
b = 4 #局部变量
print(b*10)
global a #如果要在函数内改变全局变量的值，增加global关键字声明
a = 300
print(locals()) #打印输出的局部变量
print(globals()) #打印输出的全局变量
test01()
print(a)
#参数的传递
‘’’
函数的参数传递本质上就是：从实参到形参的赋值操作。Python中参数的传递都是“引用传递”，不是“值传递”。
1.对“可变对象”进行“写操作”，直接作用于原对象本身
2.对“不可变对象”进行“写操作”，会产生一个新的“对象空间”，并用新的值填充这块空间
可变对象有：字典、列表、集合、自定义的对象等
不可变对象有：数字、字符串、元组、函数等
‘’’
#传递可变对象的引用：在函数体中不创建新的对象拷贝，而是可以直接修改所传递的对象
b = [10,20]
def f2(m):
print("m:",id(m))
m.append(30)
f2(b)
print("b:",id(b))
print(b)
#传递不可变对象的引用：在赋值操作时，由于不可变对象无法修改，系统会创建一个新的对象
a = 100
def f1(n):
print("n:",id(n))
n = n+200
print("n:",id(n))
print(n)
f1(a)
print("a",id(a))
#浅拷贝和深拷贝
‘’’
浅拷贝(copy())：不拷贝子对象的内容，只是拷贝子对象的引用
深拷贝(deepcopy())：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象
‘’’
#浅拷贝
import copy
def testCopy():
a = [10,20,[5,6]]
b = copy.copy(a)
print("a:",a)
print("b:",b)
b.append(30)
b[2].append(7)
print("浅拷贝.......")
print("a:",a)
print("b:",b)
def testDeepCopy():
a = [10,20,[5,6]]
b = copy.deepcopy(a)
print("a:",a)
print("b:",b)
b.append(30)
b[2].append(7)
print("深拷贝.......")
print("a:",a)
print("b:",b)
testCopy()
print("****************************************")
testDeepCopy()
#传递不可变对象时，如果发生拷贝，是浅拷贝
a = (10,20,[5,6])
print("a:",id(a))
def test01(m):
print("m:",id(m))
m[2][0] = 999
print(m)
print("m:",id(m))
test01(a)
print(a)
#参数的几种类型
#1.位置参数：函数调用时，实参默认按位置顺序传递，需要个数和形参匹配。按位置传递的参数，称为：“位置参数”
def f1(a,b,c):
print(a,b,c)
f1(2,3,4)
#f1(2,3) 报错，位置参数不匹配
#2.默认值参数：我们可以为某些参数设置默认值，这样这些参数在传递时就是可选的。称为“默认值参数”。默认值参数放到位置参数后面
def f2(a,b,c=10,d=20):
print(a,b,c,d)
f2(8,9)
f2(8,9,19)
#3.我们也可以按照形参的名称传递参数，称为“命名参数”，也称“关键字参数”
def f3(a,b,c):
print(a,b,c)
f3(8,9,19)
f3(c=10,a=20,b=30)
#4.可变参数：①*param(一个星号)，将多个参数收集到一个元组对象中 ②**param(两个星号)，将多个参数收集到一个字典对象中
def f4(a,b,*c):
print(a,b,c)
f4(8,9,10,19,20)
def f5(a,b,**c):
print(a,b,c)
f5(8,9,name="haha",age=18)
def f6(a,b,*c,**d):
print(a,b,c,d)
f6(8,9,20,30,name="haha",age=18)
#5.强制命名参数：在带星号的可变参数后面增加新的参数，必须是强制命名参数
def f7(*a,b,c):
print(a,b,c)
#f7(2,3,4) 会报错。由于a是可变参数，将2,3,4全部收集，造成b和c没有赋值
f7(2,b=3,c=4)
#lambda表达式和匿名函数
‘’’
lambda表达式可以用来声明匿名函数。lambda函数是一种简单的、在同一行中定义函数的方法。lambda函数实际生成了一个函数对象
lambda表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值
lambda表达式的基本语法如下：
lambda arg1,arg2,arg3… : <表达式>
arg1/arg2/arg3为函数的参数。<表达式>相当于函数体。运算结果是：表达式的运算结果
‘’’
f = lambda a,b,c:a+b+c
print(f)
print(f(2,3,4))
g = [lambda a:a*2,lambda b:b*3,lambda c:c*4]
print(g[0](6),g[1](7),g[2](8))
#eval()函数
‘’’
功能：将字符串str当成有效的表达式来求值并返回计算结果
语法：eval(source[,globals[,locals]])->value
参数：
source：一个Python表达式或函数compile()返回的代码对象
globals:可选。必须是dictionary
locals：可选。任意映射对象
‘’’
s = "print('abcde')"
eval(s)
a = 10
b = 20
c = eval("a+b")
print(c)
dict1 = dict(a=100,b=200)
d = eval("a+b",dict1)
print(d)
#递归函数
‘’’
递归函数指的是：自己调用自己的函数，在函数体内部直接或间接的自己调用自己。每个递归函数必须包含两个部分：
1.终止条件
表示递归什么时候结束。一般用于返回值，不再调用自己
2.递归步骤
把第n步的值和第n-1步相关联
递归函数由于会创建大量的函数对象、过量的消耗内存和运算能力。在处理大量数据时，谨慎使用
‘’’
def test01(n):
print("test01:",n)
if n==0:
print("over")
else:
test01(n-1)
print("test01***",n)
test01(4)
#使用递归函数，计算阶乘
def factorial(n):
if n==1:
return 1
else:
return n*factorial(n-1)
result = factorial(5)
print(result)
#嵌套函数：在函数内部定义的函数：用于封装（数据隐藏）
def outer():
print("outer running")
def inner01():
print("inner01 running")
inner01()
outer()
#封装
#封装前
def printChineseName(name,familyName):
print("{0} {1}".format(familyName,name))
def printEnglishName(name,familyName):
print("{0} {1}".format(name,familyName))
printChineseName("哈哈","李")
printEnglishName("伊万卡","特朗普")
#封装后
def printName(isChinese,name,familyName):
def inner_print(a,b):
print("{0} {1}".format(a,b))
if isChinese:
inner_print(familyName,name)
else:
inner_print(name,familyName)
printName(True,"哈哈","李")
printName(False,"伊万卡","特朗普")
#nonlocal关键字
‘’’
nonlocal 用来声明外层的局部变量
global 用来声明全局变量
'''
a = 100
def outer():
b = 10
def inner():
nonlocal b #声明外部函数的局部变量
print("inner b:",b)
b = 20
global a #声明全局变量
a = 1000
inner()
print("outer b",b)
outer()
print("a",a)
