1 def func():
2     pass
3     return "something"
4 result = func()

1 def func():
2     return 1, [2, 3], "haha"
3  
4 a, b, c = func()

 1 name = ‘beauty‘
 2 def change_name():
 3     name = ‘这个是里面的美女‘
 4     print(name, id(name))
 5 change_name()
 6 print(name, id(name))
 7  
 8 # 这里第一个name是一个全局变量，而第二个name是一个局部变量，它们作用的范围不一样，局部变量只对函数内部产生了影响，而全局变量对外面这个大的环境产生了影响。
 9  
10 #执行结果
11 这个是里面的美女 2038317628272
12 beauty 2038317363864
13 # 通过输出两个name的id可以看出，他们所指向的地址是不一样的

 1 name = ‘beauty‘
 2 def change_name():
 3     # name = ‘这个是里面的美女‘
 4     print(name, id(name))
 5 change_name()
 6 print(name, id(name))
 7  
 8 # 这里直接执行全局变量定义的一个name，函数里面能调用全局变量，但是函数外面不能调用局部变量
 9  
10 # 执行结果
11 beauty 1868336181912
12 beauty 1868336181912

 1 name = ‘beauty‘
 2 def change_name():
 3     global name  # 引用修改全局变量一定要在局部变量之前
 4     name = ‘美女‘
 5     print(name, ‘这个是里面打印的‘, id(name))
 6 change_name()
 7 print(name, ‘这个是外面打印的‘, id(name))
 8  
 9 # 注意：这里的指定在函数内部的全局变量一定要在局部变量之前，否则会报错
10 # 所以，在函数里面修改全局变量，以后引用global，就把全局放在上面，不能放在下面<br>
11 #执行结果
12 美女 这个是里面打印的 2114053808040
13 美女 这个是外面打印的 2114053808040

 1 nums = [11, 22, 33, 44]
 2 def change_num():
 3     nums = [11, 22, 33]
 4     print(nums)
 5 change_num()
 6 print(nums)
 7  
 8 # 执行结果
 9 [11, 22, 33]
10 [11, 22, 33, 44]
11  
12 #相当于创建了一个局部变量nums

 1 # 对列表内单独数据进行修改
 2 nums = [11, 22, 33, 44]
 3 def change_num():
 4     del nums[3]
 5     nums[2] = 99
 6     print(nums)
 7 change_num()
 8 print(nums)
 9  
10 # 执行结果
11 # [11, 22, 99]
12 # [11, 22, 99]
13  
14 # 对于函数外面的nums，每个列表整体都有一个内存地址，列表里面的每个元素又都有一个
15 # 地址相对应，在函数里面调用整体的nums的内存地址是不能够被修改的，只能引用它，相当于给列表整体赋值是不能够改的，单个元素可以修改
17 # 可以修改的类型：列表，字典，集合，对象，类，里面有一串的是可以修改的
18 # 不可以修改的，数字，字符串
19  
　　#修改整个列表
20 nums = [11, 22, 33, 44]
21 def change_num():
22     global nums
23     nums = [‘我‘, ‘是‘, ‘在‘, ‘里‘, ‘面‘, ‘的‘]
24     print(nums)
25 change_num()
26 print(nums)
27  
28 # 执行结果
29 [‘我‘, ‘是‘, ‘在‘, ‘里‘, ‘面‘, ‘的‘]
30 [‘我‘, ‘是‘, ‘在‘, ‘里‘, ‘面‘, ‘的‘]
31  
32 # 对于修改，通用可以采用global进行修改

 1 def line_conf(a, b):
 2     def line(x):
 3         return a*x + b
 4   
 5     return line
 6   
 7 line1 = line_conf(1, 1)
 8 line2 = line_conf(4, 5)
 9 print line1(5)
10 print line2(5)
11   
12 #######
13 6
14 25<br># 详细见高阶函数装饰器

 1 # 嵌套函数
 2 def func1():
 3     print(‘laoyuan‘)
 4     def func2():
 5         print(‘laoyuan2‘)
 6     func2()
 7 func1()
 8  
 9 # 执行结果
10 # laoyuan
11 #laoyuan2
12  
13 # 因为这里首先func2是在func1里面的，按照print顺序，所以先得laoyuan

 1 def func1():
 2     def func2():
 3         print(‘xiong2‘)
 4     func2()
 5     print(‘xiong‘)
 6 func1()
 7  
 8 # 执行结果
 9 xiong2
10 xiong

1 # import time
2 # class Foc:
3 #     pass
4 #
5 # x=1
6 # def funcname():
7 #     pass

 1 age = 18
 2 def func1():
 3     age = 73
 4     def func2():
 5         print(age)
 6     return func2  # 这里将函数名当作了返回值
 7 val = func1()
 8 val()
 9 # 定义完成后，作用域已经生成，作用域链向上查找。
10 # 只要是函数的作用域定义好了，无论这个函数被调用到哪里，还是会回来找这个函数定义的时候的作用域

1 def calc(x, y):
2     if x < y:
3         return x * y
4     else:
5         return x / y
6  
7 func = lambda x, y: x*y if x < y else x/y # 声明一个匿名函数
8 print(func(16, 8))
9 print(calc(16, 8))

1 data = list(range(10))
2 print(data)
3 # for index,i in enumerate(data):
4 #     data[index] = i*i
5 # print(data)
6 print(list(map(lambda x: x*x, data)))
7 # map 里面跟上一个函数加上一个数据集

 1 # 接受一个或多个函数作为输入
 2 def add(x, y, f):
 3     return f(x)+f(y)
 4 val = add(5, 6, abs)  # 参数可以接受函数
 5 print(val)
 6  
 7 # return返回另外一个函数本身
 8 def calc(x, y):
 9     return x+y
10 def add2():
11     return calc  # return可以返回另一个函数
12 val2 = add2()
13 print(val2(3, 6))

1 def recursion(n):
2     print(n)
3     recursion(n+1)
4 recursion(1)　　
5  
6 # 从这个函数在不断的调用自己，每次调用就n+1,相当于循环了。执行结果就是从0一直打印到997然后报错

1 import sys
2 print(sys.getrecursionlimit())
3  
4 # 执行结果为 1000

 1 def calc(n):
 2     print(n)  # 这里打印一次n
 3     if int(n/2) > 0:
 4         calc(int(n/2))
 5     else:
 6         print(‘-----‘)
 7     print(n)  # 这里打印一次n
 8 calc(10)
 9  
10 # 执行结果
11 10
12 5
13 2
14 1
15 -----
16 1
17 2
18 5
19 10

1 def factorial(n):
2   
3     if n == 0: #是0的时候，就运算完了
4         return 1
5     return n * factorial(n-1) # 每次递归相乘，n值都较之前小1
6   
7   
8 d = factorial(4)
9 print(d)

 1 data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
 2  
 3  
 4 def binary_search(dataset,find_num):
 5     print(dataset)
 6  
 7     if len(dataset) >1:
 8         mid = int(len(dataset)/2)
 9         if dataset[mid] == find_num:  #find it
10             print("找到数字",dataset[mid])
11         elif dataset[mid] > find_num :# 找的数在mid左面
12             print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
13             return binary_search(dataset[0:mid], find_num)
14         else:# 找的数在mid右面
15             print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
16             return binary_search(dataset[mid+1:],find_num)
17     else:
18         if dataset[0] == find_num:  #find it
19             print("找到数字啦",dataset[0])
20         else:
21             print("没的分了,要找的数字[%s]不在列表里" % find_num)

 1 menus = [
 2     {
 3         ‘text‘: ‘北京‘,
 4         ‘children‘: [
 5             {‘text‘: ‘朝阳‘, ‘children‘: []},
 6             {‘text‘: ‘昌平‘, ‘children‘: [
 7                 {‘text‘: ‘沙河‘, ‘children‘: []},
 8                 {‘text‘: ‘回龙观‘, ‘children‘: []},
 9             ]},
10  
11         ]
12     },
13     {
14         ‘text‘: ‘上海‘,
15         ‘children‘: [
16             {‘text‘: ‘宝山‘, ‘children‘: []},
17             {‘text‘: ‘金山‘, ‘children‘: [
18                 {‘text‘: ‘wps‘, ‘children‘: []},
19                 {‘text‘: ‘毒霸‘, ‘children‘: []},
20             ]},
21  
22         ]
23     }
24 ]
25  
26 # 深度查询
27 # 1.打印所有的节点
28 # 2.输入一个节点名字
29 #    沙河，你要遍历找，找到了，就打印ta，并返回True

1 def calc(n):
2     print(n - 1)
3     if n > -50:
4         return calc(n-1)

def factorial(n):
  
    if n == 0: #是0的时候，就运算完了
        return 1
    return n * factorial(n-1) # 每次递归相乘，n值都较之前小1
  
  
d = factorial(4)
print(d)