目录：
一.三元运算
a = 1
b = 2
if a < b :
c = b
else:
c = a
这样写代码非常繁琐，所以在遇到if else非常简单的时候，可以用到三元运算
a = 1
b = 2
c = b if a < b else a
①—⑥表示写三元运算时候的流程
二.函数：
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。
但你也可以自己创建函数，这被叫做用户自定义函数。
定义函数规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None
函数定义示例：
def 函数名(参数1,参数2):
'''
这是一个解决什么问题的函数
:param 参数1: 参数1代表输入什么
:param 参数2: 参数2代表输入什么
:return: 返回什么东西
'''
函数体
返回值
return 返回值
例如定义计算字符串长度的函数：
def my_len(my_str): #定义函数
'''
用于计算可变类型长度的函数
:param my_str: 用户输入的参数内容
:return:返回参数的长度
'''
count = 0
for val in my_str:
count += 1
return count
a = my_len("hightgood")
print(a) #输出值9
定义一个函数后，尽量不要用print,尽量return结果
自己是可以知道函数代码内部打印的是啥，自己可以随时修改，但是别人不知道
函数中的return：
1.返回None
有三种情况：
（1）无return的情况
（2）本来就return None
（3）return #return空白
#无return
def my_print(parameter):
print("Welcome",parameter)
#return None
def my_print(parameter):
return None
#return
def my_print(parameter):
return #一般用于结束函数体
2.返回一个值
1 def my_len(my_str): #定义函数
2 #计算可变类型值的长度
3 my_str = "goodnight"
4 count = 0
5 for val in my_str:
6 count += 1
7 return count #count就是那个返回值
3.返回多个值
def my_print():
return 11,22,33,[1,2,3]
a = my_print()
print(a)
#打印结果：(11, 22, 33, [1, 2, 3])
return后面的值用逗号隔开，然后以元组的形式返回
4.结束函数代码
def my_print():
print('one')
return #遇到return不继续函数下面的代码
print('two')
my_print() #结果：one
5.补充：接收多个值
def my_print():
return 1,2,3
a,b,c=my_print()
print(a,b,c) #相当于用a接收1，b接收2，c接收3
def my_print():
return [4,5,6]
a,b,c=my_print()
print(a,b,c) #一个列表里有三个值，分别用abc去接收，相当于解包
函数的参数：
def my_len(my_str): #这里的my_str就是形参，形式参数，输入对象不确定，形参可以有多个，用逗号隔开
my_str = "goodnight"
count = 0
for val in my_str:
count += 1
return count
a = my_len("hightgood") #这里的hightgood就是实参，实际参数，输入对象确定
print(a)
函数参数详解：
1.位置参数：
def demo_1(a,b): #位置参数 用户必须传入的参数，不传会报错
print(a,b)
demo_1(1,2) #输出结果：1 2 按照位置传参
demo_1(b=1,a=2) #输出结果：2 1 按照关键字传参
demo_1(1,b=2) #输出结果：1 2 混用，但必须注意先按照位置传参，再按照关键字传参，不然会报错
2.默认参数：
def welcome(name,sex='man'): #sex为默认参数
print('welcome %s,sex %s'%(name,sex))
welcome('zrh') #输出结果：welcome zrh,sex man
welcome('lml','women') #输出结果：welcome lml,sex women
#默认参数如果不传参数，就用默认值，如果默认参数传入参数，就用传入值
默认参数的陷阱：
（1）
a = 18
def age(a1,a2=a):
print(a1,a2)
a = 20
age(10) #输出结果：10 18
内部原理：
（2）
专门针对可变数据类型
def demo(a = []):
a.append(1)
print(a)
demo() #输出结果：[1]
demo() #输出结果：[1] [1]
demo() #输出结果：[1] [1] [1]
def demo_1(a = []):
a.append(1)
print(a)
demo_1([]) #输出结果：[1]
demo_1([]) #输出结果：[1]
demo_1([]) #输出结果：[1]
因为可变类型改变不是在内存中开辟一个新空间，而是在原来的基础上做修改，而10–12行是开辟了三块新内存
3.动态参数：
定义动态参数
def demo(*agrs): #按位置输入的动态参数，组成一个元组
pass
def demo_1(**kwargs): #按关键字传入的参数，组成一个字典
pass
站在函数定义的角度：*做聚合作用，将一个一个的参数组合成一个元组（**则是字典）
站在函数调用的角度：*做打散用，将一个列表或元组打散成多个参数（**则是关键字形式）
#函数定义角度：
def demo(*agrs): #按位置输入的动态参数
print(agrs)
demo(1,2,3,4,5) #输出结果(1, 2, 3, 4, 5)
def demo_1(**kwargs): #按关键字传入的参数，组成一个字典
print(kwargs)
demo_1(a=1,b=2,c=3) #输出结果{'a': 1, 'b': 2, 'c': 3}
#函数调用角度：
val = [1,2,3,4]
val2 = {'a':1,'b':2}
demo(*val) #将val打散成 1 2 3 4，然后传入函数
demo_1(**val2) #将val2打散成 a=1 b=2，然后传入函数
解释一下为什么在混用的传参中有必须先按位置传参，再按关键数传参：
def demo(*agrs,**kwargs): #*agrs和**kwargs的位置是python固定死的
#所以必须先是按照位置传参的*agrs，再是按照关键字传参的**keagrs
print(agrs)
print(kwargs)
demo(1,2,3,4,a = 1,b = 2)
# 输出结果：
# (1, 2, 3, 4)
# {'a': 1, 'b': 2}
第3行对应第7行的输出结果
第4行对应第8行的输出结果
定义多个不同类型参数时的顺序：
def demo(位置参数1,位置参数2,*args,默认参数=x,**kwargs):
pass
#以后职业生涯用到多种参数时必须这么写
格式及原理：
情况总结：
def demo(*args,**kwargs): #接收参数个数不确定的时候用动态传参，用到的时候再用
pass
def demo_1(a,b,c): #位置参数，几个参数必须都要传入几个值，最常用
pass
def demo_2(a,b=10): #默认参数，当参数信息大量形同时用到
pass
函数案例：
需求：写函数，用户输入操作文件名字，将要修改的内容，修改后的内容，然后进行批量操作
def dict_change(filename,old_content,new_content):
'''
函数用于文件内容批量修改操作
:param filename: 操作对象的名字
:param old_content: 将要修改的值
:param new_content: 修改后的值
:return:无返回值
'''
import os
with open(filename,encoding='utf-8') as file_old,open('new_file','w',encoding='utf-8') as file_new :
for val_old in file_old:
val_new = val_old.replace(old_content,new_content)
file_new.write(val_new)
os.remove(filename)
os.rename('new_file',filename)
dict_change('file','.','=')
修改后的文件：
函数的嵌套：
#函数的嵌套调用
def demo_1():
print(123)
def demo_2():
demo_1()
print(456)
demo_2()
# 输出结果：
#
# #函数嵌套定义
def demo_1():
print(123)
def demo_2():
print(456)
demo_2()
demo_1()
# 输出结果：
#
#
注意：内存读函数的时候先读定义函数名（不读里面的函数体），后面遇到调用此函数的时候，再返回读函数的函数体。
在函数外调整内部嵌套函数内容的方法：
def case(x,y,z):
def new_case(a,b,c):
print('content',a,b,c)
new_case(x,y,z)
case(1,2,3)
#输出结果 content 1 2 3
进阶：
①到⑦表示代码运行顺序
*args 和 **kwargs 只是函数定义参数的方式，和混合传参不是一回事哦
函数的命名空间：
在函数外部定义的变量为全局变量，函数内部定义的变量为局部变量
在函数内定义的局部变量只在该函数内可见，当函数运行结束后，在其内部定义的所有局部变量将自动删除而不访问
1.
a = 1
b = 2
def num_max(a,b):
c = b if a<b else a
print(c)
def num_min(a,b):
c = a if a<b else b
print(c)
num_max(10,8)
num_min(5,6)
局部命名空间之间信息不互通，不共享
2.
1 a = 1
2 b = 2
3 def num_max():
4 c = b if a<b else a
5 print(c)
6 num_max() #输出结果：2
函数局部命名空间（儿子）可以用全局命名空间（爸爸）的内容，但是全局命名空间（爸爸）不可以使用函数局部命名空间（儿子）的内容
就是 儿子可以用爸爸的，爸爸不能用儿子的
3.
a = 1
b = 2
def num_max():
def num():
a = 3
print(a)
num()
num_max() #输出结果：3
对于局部命名空间来说，自己有的话就用自己的，自己没有再用全局命名空间的
4.
a = 1
b = 2
def num_max():
c = 3
def num():
d = 4
print(a)
num()
num_max() #输出结果：1
儿子没有的先用爸爸的，爸爸也没有的话，再用爷爷的
爷爷不能用爸爸，更不能用儿子
爸爸也不能用儿子的
命名空间的加载顺序：
1.启动python
2.内置的命名空间（在哪里都可以用，比如print()等）
3.加载全局命名空间中的名字 —— 从上到下顺序加载
4.加载局部命名空间中的名字 —— 调用该函数的时候，在函数里从上到下去加载
函数的作用域：
内置的命名空间，在任意地方都可以用
全局的命名空间，在我们写的代码里任意地方（相当于爷爷，爸爸儿子都可以用爷爷的）
局部的命名空间，只能在自己的函数内使用
global：在函数内部修改全局变量的值
a = 1
def demo_1():
a =2
print(a)
def demo_2():
a = 3
print(a)
demo_2()
demo_1()
print(a)
打印结果：
需求，在函数里修改全局变量a = 10，这个时候就用的global：
a = 1
def demo_1():
global a
a =10
print(a)
def demo_2():
a = 3
print(a)
demo_2()
demo_1()
print(a)
打印结果：
nonlocal：在函数内部修改函数上一级的变量值，儿子修改爸爸的值，但不影响爷爷的值，只改一层
nonlocal 只修改局部命名空间里的 从内部往外部找到第一个对应的变量名
a = 1
def demo_1():
a =2
print(a)
def demo_2():
a = 3
print(a)
demo_2()
demo_1()
print(a)
打印结果：
需求：修改demo_1()里a的值为10
a = 1
def demo_1():
a = 2
print(a)
def demo_2():
nonlocal a
a = 10
print(a)
demo_2()
demo_1()
print(a)
输出结果：
函数名的灵活应用：
def func(): pass
func就是函数名，加个括号func()才是调用函数
函数的名字首先是一个函数的内存地址，可以当作变量使用 ，函数名是第一类对象的概念
函数的名字可以赋值，可以作为其他列表等容器类型的元素
函数的名字可以作为函数的参数,返回值
def func():
print(123)
print(func)
#输出结果：<function func at 0x0000023DB22EF1F8>
# 是个函数 名为func 内存地址
就表示func是一个存着一个函数地址的变量而已
所以下面这些都可以使用：
def func():
print(123)
a = func
print(func)
print(a)
#输出结果：一模一样
# <function func at 0x000002435074F1F8>
# <function func at 0x000002435074F1F8>
def func():
print(123)
a = func
a() #输出结果：123
def func():
print(123)
list_1 = [func]
print(list_1) #输出结果 [<function func at 0x000001BC83DCF1F8>]
#这个时候 list_1[0] == func
list_1[0]() #输出结果：123 list_1[0]()也可以调用函数func()
def func():
print(123)
def exal(q):
q() #相当于func()，用到了前面说的嵌套函数的调用
print(q,type(q))
exal(func)
print(type(func))
#输出结果：
#
# <function func at 0x0000027B24E5F288> <class 'function'>
#<class 'function'>
高阶函数：
高阶函数定义:
1.函数接收的参数是一个函数名
2.函数的返回值是一个函数名
满足上述条件任意一个,都可称之为高阶函数
def foo():
print('from foo')
def test(func_name):
return func_name
print(test(foo)) #<function foo at 0x0000018F2211F288> 拿到的是foo函数名的内存地址
此时test()就是一个高阶函数
闭包：
内部函数(下面的demo_2)引用了外部函数(dem_1)的 变量，内部的函数就叫做闭包
def demo_1():
name = 'zrh'
age = ''
def demo_2():
print(name,age)
print(demo_2.__closure__)
#(<cell at 0x0000018B6DE9A108: str object at 0x0000018B6DE6DDF0>,
<cell at 0x0000018B6DE9A1F8: str object at 0x0000018B6DE6DDB0>)
#打印出来有东西说明用到了外部函数的变量，就形成了闭包
demo_1()
闭包的作用：
在变量不容易被别人改变的情况下，还不会随着你多次去调用而反复取创建
def demo_1():
name = 'zrh'
print(name)
demo_1()
demo_1()
demo_1()
demo_1()
demo_1()
demo_1()
#......
如果我执行demo_1函数一万次。那么内存就会开辟一万次空间储存 name = ‘zrh’，然后再耗费时间关闭那一万次的空间
def demo_1():
name = 'zrh'
def demo_2():
print(name)
return demo_2
i = demo_1()
i()
i()
i()
i()
如果用闭包的方式，即使调用函数一万次，内存也会在第6行代码执行时创建一次空间来储存name = ‘zrh’，大大节省空间利用效率
闭包的应用：
from urllib.request import urlopen #模块
def get_url():
url = 'http://www.cnblogs.com/'
def inner():
ret = urlopen(url).read()
return ret
return inner
get_web = get_url()
res = get_web()
print(res)
同样url = ‘http://www.cnblogs.com/’只创建了一次，后面调用千百万次，内存空间只有一次
