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