python基础 | 条件循环，函数（附生成随机整数），条件循环和函数的使用，函数式编程：面向映射，打印输出、输入

1、条件循环

流程控制，条件语句 和 循环语句

x = int(input('请输入一个整数:'))

1.1 条件语句

if x == 0:
    print('%d ==0' % x)
elif x < 0:
    print('%d <0' % x)
else:
    print('%d >0' % x)

输出结果：
请输入一个整数:12
12 >0

1.2 for循环

1、列表，元组，集合: word遍历list里的所有元素，word一旦为空就输出0

print('for 测试.....')
words = ['good', '', 'study']
for word in words:
    print(word, len(word))

输出结果：

2、字典：跟list一样，会输出所有的 键

print('for 测试.....')
words = {'name':'ashergu','age':23,'work':'student'}
for e in words:
    print(e)

输出结果：

字典的使用：
除女同学外 都要报年龄
obj表示一个字典，listPerson是一个字典组成的列表

listPerson = [{'name':'lili','sex':'male','age':35},
              {'name':'wg','sex':'male','age':28},
              {'name':'xm','sex':'male','age':26},
              {'name':'linda','sex':'female','age':32},
              {'name':'ww','sex':'male','age':37}]

for obj in listPerson:
  if(obj['sex']=='female'):
    print('female no report age')
    continue
  print(obj)   	

3、range: 左闭右开，（左，右，间隔）

print('range.....')
a = range(5)
b = range(2, 5)
c = range(2, 5, 2)

print("a: ", a)
print("b: ", b)
for i in c:
    print("value is", i)

输出结果：
range…
a: range(0, 5) 不包括5
b: range(2, 5)
value is 2
value is 4

b = range(2, 5)
for i in b:
    print("value is", i)

输出结果：
value is 2
value is 3
value is 4

1.3 while循环

# while
print('while.....')
count = 0
while (count < 9):
    print('the index is:', count)
    count += 1  

输出结果：
while…
the index is: 0
the index is: 1
the index is: 2
the index is: 3
the index is: 4
the index is: 5
the index is: 6
the index is: 7
the index is: 8

1.4 break

print('break.....')
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, 'equals', x, '*', n//x)
            break
        else:
            print(n, 'is a prime number')

//：取整除 - 返回商的整数部分（向下取整）
输出结果：
break…
3 is a prime number
4 equals 2 * 2
5 is a prime number
5 is a prime number
5 is a prime number
6 equals 2 * 3
7 is a prime number
7 is a prime number
7 is a prime number
7 is a prime number
7 is a prime number
8 equals 2 * 4
9 is a prime number
9 equals 3 * 3

1.5 continue

# continue
print('continue.....')
for num in range(2, 10):
    if (num % 2 == 0):
        continue
    print("num: ", num)

输出结果：
continue…
num: 3
num: 5
num: 7
num: 9

1.6 pass语句（空函数，空类）

函数后必须有语句，不然出错

def funcname(parameter_list):
    pass

class classname(object):
    pass

pass语句，不执行任何内容

2、函数

描述如何做事的逻辑代码块 -> 封装(隐藏 复用)

定义声明（规划做什么事，不调用不执行）
调用（开始做事）
传参（做事需要什么东西）
函数作用域（外面不能访问函数里面的）

2.1 无参函数

具名函数，即给函数取名（sayHello），但是名字不能随便起，名字前不能有数字

def sayHello():
    print('Hello life!')

sayHello()  # 函数调用

输出结果：
Hello life!

2.2 带参函数

def printMax(a, b):
    if a > b:
        print(a, 'is maximum')
    else:
        print(b, 'is maximum')

printMax(3, 4)

x = 5
y = 7
print('参数传递')
printMax(x, y)

输出结果：
4 is maximum
参数传递
7 is maximum

2.3 局部变量

def func(x):
    print('x is', x)
    x = 2  # 此处x是局部变量
    print('Changed local x to', x)

print('局部变量')
x = 50
func(x)
print('x is still', x)

输出结果：
局部变量
x is 50
Changed local x to 2
x is still 50

有的数据类型传的是引用，有的不是

person = {
 'name':'yzg',
 'age':30
}

def changeName(p):   # 局部变量 p = person  (person里存放的是引用地址 如028）
  p['name'] = 'ivan'
  p['age'] = 20

def swap(a, b): # 这里局部变量不是引用，分类型
    temp = b
    b = a
    a = temp

changeName(person)
print(person)

a, b = 1, 2
print("a = " + str(a), "b = " + str(b)) # 注意需要把int转换为 str
swap(a, b)
print("a = " + str(a), "b = " + str(b))

运行结果

2.3.1 字符串 数字 布尔值 做参数

字符串里面不能改，同时也都不是传的引用

1、字符串不能更改：

x = 'iphone'  
def fn(v):     # 函数参数: ()  --  输入（做事需要什么东西， 如 v） 
  print(v,' type: ',type(v))
  v[0] = 'a' # 字符串不能更改
fn('iphone');  
print(x)

运行结果

2、不是传的引用：

x = 'iphone';  
def fn(v):     # 函数参数: ()  --  输入（做事需要什么东西， 如 v） 
  print(v,' type: ',type(v))
  v = 'android'
fn(x);  # 传字符串(或 数值6000 布尔值） 
print(x);		

运行结果

3、传字符串 或 数值6000 布尔值 都行

def fn(v):     #//函数参数: ()  --  输入（做事需要什么东西， 如 v） 
  print(v,' type: ',type(v))

fn(True);   
fn(12)
fn('ashergu')	

运行结果

2.3.2 列表做参数

传引用：引用的拷贝，都指向同一份实体，所以可以修改，不能越界赋值（addr[3] = 1，3越界了）要通过append追加

a = ['ivan','yzg','lili']
def change(addr):
	addr[1]='wangwei'
change(a)
print(a)

运行结果

2.3.3 字典对象做参数

同样也是 传引用，可以改变 方法 以及 属性

def car(): print(' dirver car')  # 需先定义，后再使用
def bus(): print(' dirver bus')

person ={
  'name':'ivan',
  'driver':car      
}

def change(obj):
  obj['name']='yzg'   # 更改对象的属性
  obj['driver']= bus  # 更改对象的方法

change(person)
print(person['name'])
person['driver']()

运行结果：

2.3.4 函数做参数

callback：可以把函数作为参数 传入函数中，再在函数中 回调
用来处理 处理时机 和 调用时机 由两个不同函数掌管的问题，到合适的时候 可以通过函数参数 回过去调用某个函数

def fn(callback): # 函数参数: ()  --  输入（做事需要什么东西， 如 callback） 
  print(callback,' type:',type(callback))
  callback();    # 通过参数，间接调用函数 (回调函数）       

def start():
  print('start tv')

fn(start);  # 函数做参数传入

运行结果：

2.3.5 类对象做参数

类实例化后 也可以作为参数传入
复杂对象 都是 引用传入

class Animal:  # 定义对象 Animal
  name = "animal"
  def breath(this):
    print("can breath from water")

def air():
  print("breath from air")
def change(o):
  print("after change")
  o.breath = air # 改变实例中的方法

obj =  Animal() # 新建对象实例
print(obj.name)
obj.breath()
change(obj)    # 对象做实参（引用类型传递 是地址传递，指向的是同一实体) 
print(obj.name)
obj.breath()	

运行结果：

2.4 外部变量

def func2():
    global x  # 表示使用外部变量，使用函数外面的x
    print('x is', x)
    x = 2
    print('Changed local x to', x)

print('访问外部变量:')
x = 50
func2()
print('Value of x is', x) # 函数外面x的值改变了

输出结果：
访问外部变量:
x is 50
Changed local x to 2
Value of x is 2

2.5 默认参数

def say(message, times=1):
    print(message * times)

print('默认参数:')
say('Hello')
say('World', 5)

输出结果：
默认参数:
Hello
WorldWorldWorldWorldWorld

def fn(name,money=500):
  print(name,'捐款',money)

fn('lili',1000)
fn('wangwei')

运行结果：

2.6 关键字传参

def func3(a, b=5, c=10):
    print('a is', a, 'and b is', b, 'and c is', c)

print('关键字传参:')
func3(3, 7)
func3(25, c=24)
func3(c=50, a=100)

输出结果：
关键字传参:
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50

2.7 return：返回值

def maximum(x, y):
    if x > y:
        return x
    else:
        return y

print('return:')
print(maximum(2, 3))

输出结果：
return:
3

1、返回函数

def fn(a):
  print('fn run');
  def fnn(b):
    print('fnn run ..');
    return a+b;
  return fnn;
print(fn(10)(20));

解析：替换分析法

def fn(a):
#  a =10;
    print('fn run');
    def  fnn(b): #局部函数 （函数内的函数）
#  b = 20;
        print(' run ..');
        return a+b;
    return fnn;   # 函数名只有加（），才表示调用函数执行。否则只是引用地址的传递
#//fnn();  报错， 原因：局部函数外部不能访问

解析：替换分析法
#//print(fn(10)(20));
x = fn(10);  #//x = func2     x里存放的是函数执行的结果，即 return 后面的东西
y= x(20);    #//y = func2(20);  局部函数可以通过return暴露给外面访问。
             #//  y = a+b;   y里面存放函数执行的结果（即return 后面的东西）
print(y);    #//30；	

2、返回对象

def fun():
  return {
    'name': 'ivan',
    'driver':lambda str:'can dirver '+str,
  }
print('Person '+ fun()['name'])
print(fun()['driver']('car'))

替换法：把fun() 改成 字典名
运行结果：

2.8 函数名间接调用

函数的名字 实际上是代码块的地址（跟变量一样的），所以 可以进行地址的传递

ef start(): #//函数声明定义（规划做什么事）  
  print('starting... machine ');
  print('start success');

start();     #//函数调用（开始做事）
start();     #//可调用多次 （封装隐藏 --> 复用） 
      
fn = start;  fn();  #//函数名赋值给变量，可间接调用 

运行结果：

def fnn():
  count =0;
  print(count);
  count+=1;
  if(count >2):
    return;
  fnn();   #//递归	
fnn();

会一直打印，return 一直得不到执行

2.9 做对象中的方法

1、做类里的行为(方法)

class Person:
  name = 'ivan' # 属性
  def speak(this): # this一定要加，this指向那个实例的地址（指针） 方法
    print(this.name,'can speak'); # 可以通过this访问实例的属性

ivan = Person(); # 构造函数，实例化一个类，创建一个对象，ivan指向类的一个实例
ivan.speak(); 

2、做字典里的一个值（间接调用）动态语言的特点

def fn():
  print('driver bus')  
person ={
  'name':'ivan',
  'driver':fn
}

print(person['driver']) # 函数的地址
person['driver']()
fun = person['driver']
fun()

运行结果

2.10 不定参：实参形参个数不同

不需要名字一定 args，只是习惯，只要前面加*号就是

*args 传入的参数是 元组类型（不能修改）

def test(*args):    
    print(args)  
    print(args[0]) 
    for i in args:
        print(i)

test(1,2,3)

运行结果：

**kwargs 传入的参数是 dict 类型：等号左边是key（不用加单引号，自己会加），等号右边是value

def test(**kwargs):
    print(kwargs)
    keys = kwargs.keys() 
    value = kwargs.values()
    print(keys)
    print(value)

test(a=1,b=2,c=3,d=4)

运行结果：

2.11 作用域

能读写变量函数的范围 --> 权限

country = 'china'; #// 全局变量(任意地方用）

def fn():       #// 函数作用域分函数内外
    country = 'yindu';
    age = 35;    #// 局部变量
    print('fn: ', country);
    print('fn: ', age);
    def fn1():  #//局部函数
        print('fn1 go ');

print(country);
fn();
print(age); #// 不能访问函数内部资源， 故报错NameError::age is not defined
fn1(); #// 局部函数不能访问

局部变量 可以 和全局变量同名
函数嵌套 --> 形成链条 --> 变量回溯（当前没有，沿着链条追查上家） 比如：name

name = "first"
def fn1():
    name = "second"
    def fn2():
        print(name) # 变量回溯（当前没有，追查上家）
    fn2()
    print(name)

fn1()
print(name)
# fn2(); # fn2是局部函数，不能访问

运行结果：

例子1：
print('2 level age is ',age) 注意，输出是 30 不是8

country='china'  # 全局变量(任意地方用）
age =80
def fn():
  country = 'yindu'
  print('2 level country is ',country)
  name1 = 'ivan'  # 局部变量(只能在函数内部用）
  age =30      # 同名时，在局部作用域内（函数内），局部变量有效。

  def fn():      #//嵌套子函数
    print('3 level name is ',name1)  # 子函数可用父函数作用域内的变量 
    age = 8
  fn()
  print('2 level age is ',age) # 注意，输出是 30 不是8
fn()
print('1 level age is ',age)    # 80 不是 8 或 30 同名时：函数外，全局变量的有效 
print('1 level name is ',name1) # 不能访问局部变量 NameError: name 'name1' is not defined

运行结果：

例子2：

i=0
def fn1(i):
  print( 'i = ',i)

a = [1,2,3]
def fn(callback):
  for i in range(3):
    a[i] = callback # a[0] = a[1] = a[2] = fn1
  callback(i) # i = 2
fn(fn1)
a[0](i) # i = 0
a[1](i)

运行结果：

3、条件循环和函数的使用

3.1 分支判断

1、和电脑猜拳，剪刀(0) 石头(1) 布(2) 电脑生成随机数，与你输入比， 判断输赢

import random

def guess():
    ran = random.randint(0, 2)
    inp = int(input("请输入数字： 剪刀：0；石头：1；布：2 ")) # 输入
    print("computer is", ran)
    if ran == inp:
        print("continue")
    elif (ran == 0 and inp == 1) or (ran == 1 and inp == 2) or (ran == 2 and inp == 0): # 条件
        print("you win")
    else:
        print("you lose")

guess()
guess()
guess()

运行结果：

2、什么是真 什么是假

a = 1
#a = 0

a ='lili'
#a =''

a ={'name':'lili'}
#a ={}

非注释为真，注释为假

附：生成随机整数

以下实例返回一个 1 到 9 之间的数字（大于等于 1，小于等于 9）：

# 导入 random 包
import random

# 返回一个 1 到 9 之间([1, 9])的数字
print(random.randint(1, 9))

3.2 冒泡排序（同时赋值 直接交换顺序）

def bubbleSort(arr):
    n = len(arr)
    #遍历所有数组元素
    for i in range(n):
        #最后的倒数i个已经 排好了
        for j in range(n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j] # 同时赋值 直接交换顺序

buf = [64, 25, 55, 12, 20, 11, 90]
bubbleSort(buf)
print("排序后的数组:\n", buf)

同时赋值 直接交换顺序：

arr = [1,2,3]
arr[0], arr[1] = arr[1], arr[0]
print(arr)

运行结果：

3.3 实现累加：不定参 以及 lambda函数使用（函数作为参数）

写一个按照下面方式调用都能正常工作的 累加函数

print(sum(2)(3))

def sum(*args):
  print(args)
  fir = args[0]
  if(len(args) == 2):
    return args[0] + args[1]
  else:
    return lambda sec:fir + sec

函数 检查 args 的长度是否等于2。如果是，则返回前两个参数的和
如果 args 的长度不为2，则返回一个 lambda 函数，该函数接受一个参数 sec，并返回 fir（第一个参数，自带）和 sec 的和

sum(2)(3) 等价于 func = sum(2) func(3)
在这个例子中，func是一个 lambda 函数，当你调用它并传递值 3 给它时，这个值将作为 sec 参数传递给 lambda 函数，并与 fir（在这里是 2）相加，得到结果 5

附：lambda匿名函数的使用

当需要一个简单的函数 来执行某个特定任务，但又不希望 为其定义一个完整的函数时，可以使用lambda函数lambda函数是一种 匿名函数，它可以在需要时 被快速定义和使用。以下是 lambda函数的基本使用方法：

1、基本语法：lambda函数的基本语法为lambda arguments: expression，其中 arguments 是函数的参数列表，而 expression 是函数执行的代码
即 冒号前面是 输入参数，冒号后面是 返回值

例如：

add = lambda x, y: x + y
print(add(2, 3))  # 输出：5

就相当于 定义了一个 参数为x和y的 add函数（等号左边的值）

2、使用lambda函数作为参数：lambda函数经常被用作其他函数的参数，例如在map()、filter()、sorted()等函数中。
例如：
1）使用 sorted函数

# 使用lambda函数对列表进行排序
points = [(1, 2), (3, 1), (5, 3), (0, 2)]
sorted_points = sorted(points, key=lambda x: x[1])
print(sorted_points)  # 输出：[(3, 1), (1, 2), (0, 2), (5, 3)]

2）使用 map()函数：map()函数 接受一个函数 和 一个序列 作为参数，将函数 应用于序列中的每个元素，并返回一个结果列表。例如，可以使用lambda函数 将一个列表中的每个元素都平方：

numbers = [1, 2, 3, 4, 5]
squared_numbers = map(lambda x: x**2, numbers)
print(list(squared_numbers))  # 输出：[1, 4, 9, 16, 25]

在这个例子中，lambda函数 lambda x: x**2 作为map()函数的 第一个参数，它将对列表中的每个元素 进行平方运算

3）使用 filter()函数：filter()函数接受 一个函数和一个序列作为参数，将函数应用于序列中的每个元素，并返回 满足条件的元素组成的新列表。例如，我们可以使用lambda函数 从一个列表中过滤出所有的偶数：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # 输出：[2, 4, 6, 8, 10]

在这个例子中，lambda函数 lambda x: x % 2 == 0 作为filter()函数的第一个参数，它将对列表中的每个元素进行判断，只保留满足条件的偶数

3、lambda函数作为返回值：lambda函数 也可以作为 另一个函数的返回值，这在某些情况下非常有用。例如：
就是 3.3 中说的

def make_incrementor(n):
    return lambda x: x + n

add_five = make_incrementor(5)
print(add_five(2))  # 输出：7

这里的 lambda 相当于 make_incrementor(n)，lambda x 相当于 make_incrementor(n)(x) : x + n

3.4 引用传递 但是赋值没影响

下面程序输出为多少

def func(o):
    o['siteUrl'] = "http://www.csser.com/";
    o={};    
    o['siteUrl'] = "http://www.popcg.com/";  # 改变的是另一个新创建的对象内容
CSSer={};
func(CSSer);  #//o= CSSer;
print(CSSer['siteUrl']); 	

在函数结束后，CSSer 字典 并没有受到影响，因为在函数内部 对 o 的任何修改 都不会影响到传递给 函数的参数（字典 CSSer）
这是因为在Python中，函数参数是通过 引用传递的，但对参数的重新赋值 不会影响函数外部的变量。所以，虽然在函数内部 对 o 进行了修改，但对 CSSer 没有任何影响

4、函数式编程：面向映射

4.1 不同编程思想

1、命令式编程(面向过程 如C语言): 关心执行步骤，有变量，表达式，控制语句等 -> 解决步骤(告诉机器 怎么做，直接面向计算机)

2、元编程(面向对象 C++/Java): 以对象(独立个体)为核心，组织数据和关系 -> 找对象(告诉机器 是谁做的)

3、函数式编程(面向映射):像数学函数(表达式)一样计算，无需更改状态和数据 -> 映射关系(告诉机器 做什么)
不变性（没有可变的状态，不依赖也不改变外面状态，引用透明，和没有副作用)
适合并发编程（没有状态的上锁）
当把函数也看成数据，输入确定，输出也确定 -> 无状态化(因为一旦独立投入计算，我们没有和其他人同步的要求了)

4.2 匿名函数（lambda）

用于 中间处理 无需命名，简洁，充分体现函数式编程：输入->输出，用函数去替换

fn = lambda x:x+10; # 创建匿名函数lambda，让变量fn 指向它
	             	# lambda: 冒号左侧表示函数接收的参数x ,右侧表示函数的返回值x+10
	             	# 等价于 def fn(x):return x+10
print(fn(1))
print((lambda x:x+10)(1)) # 可定义调用一气完成，与上一条语句等价
print()

# 含默认值的匿名函数
c = lambda x,y=2: x+y   # 输入x, y有默认值2；输出x+y 相当于 def c(x, y=2):return x+y
print(c(10))
print()

# 匿名函数放字典中
L = [(lambda x: x**2),(lambda x: x**4)]  # 放字典中，因为python都是引用地址，所里里面啥都能放
print(L[0](2),L[1](2))
print()

# 匿名函数条件判断
print((lambda x,y: x if x> y else y)(3,5))  # 求最值（类三目运算）
# 相当于 def f(x, y): if x > y: return x	else: return y

运行结果：

4.3 高阶函数

以函数为参数或返回值的函数
例:对列表的元素都求平方

def square(x):  # 普通函数
	return x**2
	
a = map(square, [1,2,3]) # 高阶函数:以函数为参数或返回值的函数，map是python定义好的，把列表中的每一个元素作为参数中函数的输入
	
print(list(a))	  # map返回类型是map，需用list转换为列表	

运行结果：

map() 函数用于 将一个函数应用到一个可迭代对象（如列表、元组等）的每个元素上，并返回一个包含结果的迭代器（map体现了之前 提到的 函数式编程的思想：输入输出的映射，无状态，适合并发编程）
map() 函数的基本语法如下：

map(function, iterable)

其中：
1）function 是要应用的函数。
2）iterable 是一个或多个可迭代对象，如列表、元组等

square 只是中间转换作用，可以用匿名函数-> 省去取名烦恼（因没必要取名）

a = map(lambda x: x**2, [1,2,3])
print(list(a))

4.4 闭包

1、闭包：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包

def outer(x):
    def inner(y):  # inner是闭包，它引用外部的变量x
        return x + y
    return inner # 可以通过外部函数间接访问 内部函数

a = outer(2)
print('result:',a(3)) # 驻留了前面2的信息，内部函数把外部信息拿来之后就进行了保存，持续不变，这里是outer的参数x=2

2、驻留：信息保持（python的资源回收机制：引用在（只要有一个对象引用到 这个对象），资源不回收）
例: 资料上传一半，可接着上传

def register(name): //注册信息
    def upload(age): //提交信息
        print('name:', name, 'age:', age);
    return upload;

step = register('wangwei');  //第一步，填入姓名
step(26); # 第二步，填入年龄 ，驻留(保持)了前面姓名的信息
          # 也突破作用域限制： 能调用内部函数upload（通过引用访问函数内的函数）

函数式编程 希望内部输入信息时 外部不会被打断，一气完成

3、闭包内不能改写，外部函数的同名局部变量

def outer():
    x = 5        # python规则，赋值语句左面的变量都是局部变量
    def inner(): # 上面一行的x相对inner函数来说是函数外的局部变量（非全局变量）    	           
        x *= x   # 不能改写函数外的同名变量
        return x
    return inner
outer()()	

运行结果

解决办法：通过复合数据类型来解决 (因它不是存在栈空间)

1）使用列表

def outer():
    x = [5]   # 变为容器类(复合类型)，因它不是存在栈空间上 (它内部又指向另一空间)，[5]是一个列表
    def inner(): 
        x[0] *= x[0] # x[0]就是5
        return x[0]
    return inner   # 返回函数名（暴露内部信息 ）

print(outer()())  #25	

2）使用字典

def outer():
    x = {'age':5, 'name':'lili'}  # 变为容器类(复合类型)，因它不是存在栈空间上 (它内部又指向另一空间)
    def inner(): 
        x['age'] *= x['age'] # x[0]就是5
        return x['age']
    return inner   # 返回函数名（暴露内部信息 ）

print(outer()())  #25	

例：函数内部自加

count = 0
def f():
    count += 1
    return count
f()
print(count)

报错：

UnboundLocalError: local variable ‘count’ referenced before assignment ：这个错误通常指的是在函数或其他作用域内，你试图在变量被赋值之前使用该变量
在Python中，当你在一个函数内部给一个变量赋值时，Python会将其视为局部变量。如果在引用这个变量之前没有为其赋值，Python会抛出 UnboundLocalError 错误

def outer():
    count = 0
    def f():
        count += 1
        return count
    return f
print(outer()())  

报错：

解决：对于复杂类型来说，引用在，变量就一直记着

def person():
    count = [0]
    def getCount():
        count[0] += 1
        return  count[0]
    return getCount        # 返回函数名（暴露内部信息 ）
p = person() # 要先调用，再用内部函数
print('call count...',p()) # 通过子函数引用，能访问局部变量
print('call count...',p()) # 引用在，其内部的变量将一直保持

运行结果：

体现了函数式编程的好处：直接就可以用，不用考虑外部的变化

练习：
假设棋盘大小为50*50，左上角为坐标系原点(0,0)，
设计一个函数，接收2个参数，分别为方向(direction)，步长(step)，
该函数控制棋子的运动。棋子运动的新的坐标除了依赖于方向和步长以外，
当然还要根据原来所处的坐标点，用闭包就可以保持住这个棋子原来所处的坐标

def move(pos = [0, 0]):
    def go(direction, step): # 记住外层的pos位置
        pos[0] += direction[0]*step
        pos[1] += direction[1]*step
        return pos
    return go
print(move([1,1])([1,0], 2)) # 错误，要先调用外层函数，再调用内层函数
print(move()([0, 1], 3))

错误结果：

修正：

def move(pos = [0, 0]):
    def go(direction, step): # 记住外层的pos位置
        pos[0] += direction[0]*step
        pos[1] += direction[1]*step
        return pos
    return go

go2 = move([1,1]) # 先对pos赋值，后面就可以使用了
print(go2([1, 0], 2))
print(go2([0, 1], 3))

运行结果：

5、打印输出、输入

在Python中，打印输出可以使用多种方式，其中一些常见的包括：
1、print() 函数： 这是最基本的打印方法，可以输出文本和变量的值

2、格式化字符串： 使用格式化字符串可以方便地插入变量的值到文本中

name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")

3、使用字符串的 format() 方法： 在Python中，你可以使用字符串对象的 format() 方法来格式化字符串

name = "Bob"
age = 25
print("My name is {} and I am {} years old.".format(name, age))

4、字符串连接： 通过连接字符串和变量，可以实现打印输出

name = "Charlie"
age = 20
print("My name is " + name + " and I am " + str(age) + " years old.")

5、使用格式化符号：%： 这是一种旧式的方法，不过仍然可以使用

name = "David"
age = 35
print("My name is %s and I am %d years old." % (name, age))

6、日志模块 logging： Python提供了一个日志模块，可以用于打印各种级别的日志信息

import logging

logging.basicConfig(level=logging.INFO)
logging.info("This is an info message.")

输入主要是通过 user_input = input("Please enter something: ")
或者 通过 sys.argv 或 argparse 模块可以获取命令行参数：import sys arguments = sys.argv