分类： Python技术

Sen+MK长时间序列趋势性分析—-基于python的代码实现

sen+mk python实现代码免费共享—–赶紧收藏吧
python开源社区公布了进行sen+mk趋势性检验的官方包，有关该官方包的主要内容详见：https://github.com/Coder2cdb/pyMannKendall，开源不易，有些人还收费查看，我觉得没必要，本次代码免费分享给大家，有需要的收藏点赞！

本次sen+mk python代码输入参数：多年影像的存储路径
path1=r”E:\2021-03-03—生态修复\吴起本地\NDVI_wuqi”
本次sen+mk python代码输出参数：结果影像存储路径
result_path=r”E:\小师妹\1990-2000_NDVI\result”
调用方法：
sen_mk_test(path1, result_path)
MannKendall输出参数说明

”
trend: tells the trend (increasing, decreasing or no trend)
h: True (if trend is present) or False (if trend is absence)
p: p-value of the significance test
z: normalized test statistics
Tau: Kendall Tau
s: Mann-Kendal’s score
var_s: Variance S
slope: Theil-Sen estimator/slope
intercept: intercept of Kendall-Theil Robust Line
”’

1.导入python包
#coding:utf-8
import numpy as np
import pymannkendall as mk
import os
import rasterio as ras

2.获取所有的影像路径，按照从小到大年份排序
path1=r”E:\2021-03-03—生态修复\吴起本地\NDVI_wuqi”
filepaths=[]
for file in os.listdir(path1):
filepath1=os.path.join(path1,file)
filepaths.append(filepath1)

3.读取所有的影像数据并拼接为一个numpy矩阵
#获取影像数量
num_images=len(filepaths)
#读取影像数据
img1=ras.open(filepaths[0])
#获取影像的投影，高度和宽度
transform1=img1.transform
height1=img1.height
width1=img1.width
array1=img1.read()
img1.close()

#读取所有影像
for path1 in filepaths[1:]:
if path1[-3:]==’tif’:
print(path1)
img2=ras.open(path1)
array2=img2.read()
array1=np.vstack((array1,array2))
img2.close()

nums,width,height=array1.shape

4.定义输出矩阵
#输出矩阵，无值区用-9999填充
slope_array=np.full([width,height],-9999.0000)
z_array=np.full([width,height],-9999.0000)
Trend_array=np.full([width,height],-9999.0000)
Tau_array=np.full([width,height],-9999.0000)
s_array=np.full([width,height],-9999.0000)
p_array=np.full([width,height],-9999.0000)
#只有有值的区域才进行mk检验，如果所有影像同一像元都为空，则不进行mk检验
c1=np.isnan(array1)
sum_array1=np.sum(c1,axis=0)
nan_positions=np.where(sum_array1==num_images)
positions=np.where(sum_array1!=num_images)
#输出总像元数量
print(“all the pixel counts are {0}”.format(len(positions[0])))

5.sen+mk检验
for i in range(len(positions[0])):
print(i)
x=positions[0][i]
y=positions[1][i]
mk_list1=array1[:,x,y]
trend, h, p, z, Tau, s, var_s, slope, intercept = mk.original_test(mk_list1)
if trend==”decreasing”:
trend_value=-1
elif trend==”increasing”:
trend_value=1
else:
trend_value=0
slope_array[x,y]=slope#senslope
s_array[x,y]=s
z_array[x,y]=z
Trend_array[x,y]=trend_value
p_array[x,y]=p
Tau_array[x,y]=Tau

6.定义写影像的函数
#写影像，包括宽度，高度，投影，波段名，矩阵
def writeImage(image_save_path,height1,width1,para_array,bandDes,transform1):
with ras.open(
image_save_path,
‘w’,
driver=’GTiff’,
height=height1,
width=width1,
count=1,
dtype=para_array.dtype,
crs=’+proj=latlong’,
transform=transform1,
) as dst:
dst.write_band(1,para_array)
dst.set_band_description(1,bandDes)
del dst

7.输出结果
#输出矩阵
all_array=[slope_array,Trend_array,p_array,s_array,Tau_array,z_array]
#输出路径
result_path=r”E:\2021-03-03—生态修复\吴起本地\result”
slope_save_path=os.path.join(result_path,”slope.tif”)
Trend_save_path=os.path.join(result_path,”Trend.tif”)
p_save_path=os.path.join(result_path,”p.tif”)
s_save_path=os.path.join(result_path,”s.tif”)
tau_save_path=os.path.join(result_path,”tau.tif”)
z_save_path=os.path.join(result_path,”z.tif”)
image_save_paths=[slope_save_path,Trend_save_path,p_save_path,s_save_path,tau_save_path,z_save_path]
band_Des=[‘slope’,’trend’,’p_value’,’score’,’tau’,’z_value’]
#逐个存储
for i in range(len(all_array)):
writeImage(image_save_paths[i], height1, width1, all_array[i], band_Des[i],transform1)

sen+mk代码汇总
”’
Created on 2021年4月11日

@author: SunStrong
”’
#coding:utf-8
import numpy as np
import pymannkendall as mk
import os
import rasterio as ras

def sen_mk_test(image_path,outputPath):

#image_path:影像的存储路径
#outputPath:结果输出路径

filepaths=[]
for file in os.listdir(path1):
filepath1=os.path.join(path1,file)
filepaths.append(filepath1)

#获取影像数量
num_images=len(filepaths)
#读取影像数据
img1=ras.open(filepaths[0])
#获取影像的投影，高度和宽度
transform1=img1.transform
height1=img1.height
width1=img1.width
array1=img1.read()
img1.close()

#读取所有影像
for path1 in filepaths[1:]:
if path1[-3:]==’tif’:
print(path1)
img2=ras.open(path1)
array2=img2.read()
array1=np.vstack((array1,array2))
img2.close()

nums,width,height=array1.shape
#写影像
def writeImage(image_save_path,height1,width1,para_array,bandDes,transform1):
with ras.open(
image_save_path,
‘w’,
driver=’GTiff’,
height=height1,
width=width1,
count=1,
dtype=para_array.dtype,
crs=’+proj=latlong’,
transform=transform1,
) as dst:
dst.write_band(1,para_array)
dst.set_band_description(1,bandDes)
del dst

#输出矩阵，无值区用-9999填充
slope_array=np.full([width,height],-9999.0000)
z_array=np.full([width,height],-9999.0000)
Trend_array=np.full([width,height],-9999.0000)
Tau_array=np.full([width,height],-9999.0000)
s_array=np.full([width,height],-9999.0000)
p_array=np.full([width,height],-9999.0000)
#只有有值的区域才进行mk检验
c1=np.isnan(array1)
sum_array1=np.sum(c1,axis=0)
nan_positions=np.where(sum_array1==num_images)

positions=np.where(sum_array1!=num_images)

#输出总像元数量
print(“all the pixel counts are {0}”.format(len(positions[0])))
#mk test
for i in range(len(positions[0])):
print(i)
x=positions[0][i]
y=positions[1][i]
mk_list1=array1[:,x,y]
trend, h, p, z, Tau, s, var_s, slope, intercept = mk.original_test(mk_list1)
”’
trend: tells the trend (increasing, decreasing or no trend)
h: True (if trend is present) or False (if trend is absence)
p: p-value of the significance test
z: normalized test statistics
Tau: Kendall Tau
s: Mann-Kendal’s score
var_s: Variance S
slope: Theil-Sen estimator/slope
intercept: intercept of Kendall-Theil Robust Line
”’

if trend==”decreasing”:
trend_value=-1
elif trend==”increasing”:
trend_value=1
else:
trend_value=0
slope_array[x,y]=slope#senslope
s_array[x,y]=s
z_array[x,y]=z
Trend_array[x,y]=trend_value
p_array[x,y]=p
Tau_array[x,y]=Tau

all_array=[slope_array,Trend_array,p_array,s_array,Tau_array,z_array]

slope_save_path=os.path.join(result_path,”slope.tif”)
Trend_save_path=os.path.join(result_path,”Trend.tif”)
p_save_path=os.path.join(result_path,”p.tif”)
s_save_path=os.path.join(result_path,”s.tif”)
tau_save_path=os.path.join(result_path,”tau.tif”)
z_save_path=os.path.join(result_path,”z.tif”)
image_save_paths=[slope_save_path,Trend_save_path,p_save_path,s_save_path,tau_save_path,z_save_path]
band_Des=[‘slope’,’trend’,’p_value’,’score’,’tau’,’z_value’]
for i in range(len(all_array)):
writeImage(image_save_paths[i], height1, width1, all_array[i], band_Des[i],transform1)

#调用
path1=r”E:\2021-03-03—生态修复\吴起本地\NDVI_wuqi”
result_path=r”E:\2021-03-03—生态修复\吴起本地\result”
sen_mk_test(path1, result_path)

 

控制流作业

# ————————-*题—————————#
number = input(‘请输入一个整数：’)
if (int(number)%7 == 0) | (number.find(‘7’) != -1):
print(‘该数与7相关’)
else:
print(‘该数与7无关’)

# ————————-第二题—————————#
id = input(‘请输入身份证号码：’)
if len(id) == 18:
birthday = id[6:14]
print(‘你的出生日期是：’,birthday)
elif len(id) == 15:
birthday = ’19’ + id[6:12]
print(‘你的出生日期是：’,birthday)
else:
print(‘请重新输入身份证号码！’)

# ————————-第三题—————————#
id = input(‘请输入身份证号码：’)
if len(id) == 18:
if int(id[-2]) % 2 == 0:
print(‘女’)
else:
print(‘男’)
elif (len(id)) == 15:
if int(id[-1]) % 2 == 0:
print(‘女’)
else:
print(‘男’)
else:
print(‘请重新输入身份证号码！’)

# ————————-第四题—————————#
list6 = [1,5,2,8,10,13,17,4,6]
## 方法一：
result = []
for i in list6:
result.append(i**2+1)
print(result)

## 方法二：
result = [i**2+1 for i in list6]
print(result)

# ————————-第五题—————————#
list7 = [‘one’,’two’,’three’,’four’,’five’,’six’,’seven’,’eight’,’nine’]
## 方法一：
result = []
for i in list7:
if i.find(‘e’) != -1:
new_i = i.replace(i[:],’^-^’)
result.append(new_i)
else:
result.append(i)
print(result)

## 方法二：
result = [i for i in list7 if i.find(‘e’)!=-1]
print(result)

#————————-第六题—————————#
# 同第四题

# ————————-第七题—————————#
list8 = [‘A’,’C’,’A’,’C’,’B’,’C’,’A’,’A’,’B’,’C’]
dict = {}
for i in set(list8):
dict[i] = list8.count(i)
print(dict)

# ————————-第八题—————————–#
n = 1
s = 0
while s<=1000:
s += 3*n+5
n += 1
print(n,’–>’,s)

# ————————–第九题—————————–#
import random
A = int(input(‘范围*小值：’))
B = int(input(‘范围*大值：’))
number = random.randint(A,B)

while True:
guess = int(input(‘请在{}、{}之间猜一个整数:’.format(A,B)))
if guess > number:
B = guess
elif guess < number:
A = guess
else:
print(‘你真棒，猜中了。’)
break

基于python的代码实现

sen+mk python实现代码免费共享—–赶紧收藏吧
python开源社区公布了进行sen+mk趋势性检验的官方包，有关该官方包的主要内容详见：https://github.com/Coder2cdb/pyMannKendall，开源不易，有些人还收费查看，我觉得没必要，本次代码免费分享给大家，有需要的收藏点赞！

本次sen+mk python代码输入参数：多年影像的存储路径
path1=r”E:\2021-03-03—生态修复\吴起本地\NDVI_wuqi”
本次sen+mk python代码输出参数：结果影像存储路径
result_path=r”E:\小师妹\1990-2000_NDVI\result”
调用方法：
sen_mk_test(path1, result_path)
MannKendall输出参数说明

”
trend: tells the trend (increasing, decreasing or no trend)
h: True (if trend is present) or False (if trend is absence)
p: p-value of the significance test
z: normalized test statistics
Tau: Kendall Tau
s: Mann-Kendal’s score
var_s: Variance S
slope: Theil-Sen estimator/slope
intercept: intercept of Kendall-Theil Robust Line
”’

1.导入python包
#coding:utf-8
import numpy as np
import pymannkendall as mk
import os
import rasterio as ras

2.获取所有的影像路径，按照从小到大年份排序
path1=r”E:\2021-03-03—生态修复\吴起本地\NDVI_wuqi”
filepaths=[]
for file in os.listdir(path1):
filepath1=os.path.join(path1,file)
filepaths.append(filepath1)

3.读取所有的影像数据并拼接为一个numpy矩阵
#获取影像数量
num_images=len(filepaths)
#读取影像数据
img1=ras.open(filepaths[0])
#获取影像的投影，高度和宽度
transform1=img1.transform
height1=img1.height
width1=img1.width
array1=img1.read()
img1.close()

#读取所有影像
for path1 in filepaths[1:]:
if path1[-3:]==’tif’:
print(path1)
img2=ras.open(path1)
array2=img2.read()
array1=np.vstack((array1,array2))
img2.close()

nums,width,height=array1.shape

4.定义输出矩阵
#输出矩阵，无值区用-9999填充
slope_array=np.full([width,height],-9999.0000)
z_array=np.full([width,height],-9999.0000)
Trend_array=np.full([width,height],-9999.0000)
Tau_array=np.full([width,height],-9999.0000)
s_array=np.full([width,height],-9999.0000)
p_array=np.full([width,height],-9999.0000)
#只有有值的区域才进行mk检验，如果所有影像同一像元都为空，则不进行mk检验
c1=np.isnan(array1)
sum_array1=np.sum(c1,axis=0)
nan_positions=np.where(sum_array1==num_images)
positions=np.where(sum_array1!=num_images)
#输出总像元数量
print(“all the pixel counts are {0}”.format(len(positions[0])))

5.sen+mk检验
for i in range(len(positions[0])):
print(i)
x=positions[0][i]
y=positions[1][i]
mk_list1=array1[:,x,y]
trend, h, p, z, Tau, s, var_s, slope, intercept = mk.original_test(mk_list1)
if trend==”decreasing”:
trend_value=-1
elif trend==”increasing”:
trend_value=1
else:
trend_value=0
slope_array[x,y]=slope#senslope
s_array[x,y]=s
z_array[x,y]=z
Trend_array[x,y]=trend_value
p_array[x,y]=p
Tau_array[x,y]=Tau

6.定义写影像的函数
#写影像，包括宽度，高度，投影，波段名，矩阵
def writeImage(image_save_path,height1,width1,para_array,bandDes,transform1):
with ras.open(
image_save_path,
‘w’,
driver=’GTiff’,
height=height1,
width=width1,
count=1,
dtype=para_array.dtype,
crs=’+proj=latlong’,
transform=transform1,
) as dst:
dst.write_band(1,para_array)
dst.set_band_description(1,bandDes)
del dst

7.输出结果
#输出矩阵
all_array=[slope_array,Trend_array,p_array,s_array,Tau_array,z_array]
#输出路径
result_path=r”E:\2021-03-03—生态修复\吴起本地\result”
slope_save_path=os.path.join(result_path,”slope.tif”)
Trend_save_path=os.path.join(result_path,”Trend.tif”)
p_save_path=os.path.join(result_path,”p.tif”)
s_save_path=os.path.join(result_path,”s.tif”)
tau_save_path=os.path.join(result_path,”tau.tif”)
z_save_path=os.path.join(result_path,”z.tif”)
image_save_paths=[slope_save_path,Trend_save_path,p_save_path,s_save_path,tau_save_path,z_save_path]
band_Des=[‘slope’,’trend’,’p_value’,’score’,’tau’,’z_value’]
#逐个存储
for i in range(len(all_array)):
writeImage(image_save_paths[i], height1, width1, all_array[i], band_Des[i],transform1)

sen+mk代码汇总
”’
Created on 2021年4月11日

@author: SunStrong
”’
#coding:utf-8
import numpy as np
import pymannkendall as mk
import os
import rasterio as ras

def sen_mk_test(image_path,outputPath):

#image_path:影像的存储路径
#outputPath:结果输出路径

filepaths=[]
for file in os.listdir(path1):
filepath1=os.path.join(path1,file)
filepaths.append(filepath1)

#获取影像数量
num_images=len(filepaths)
#读取影像数据
img1=ras.open(filepaths[0])
#获取影像的投影，高度和宽度
transform1=img1.transform
height1=img1.height
width1=img1.width
array1=img1.read()
img1.close()

#读取所有影像
for path1 in filepaths[1:]:
if path1[-3:]==’tif’:
print(path1)
img2=ras.open(path1)
array2=img2.read()
array1=np.vstack((array1,array2))
img2.close()

nums,width,height=array1.shape
#写影像
def writeImage(image_save_path,height1,width1,para_array,bandDes,transform1):
with ras.open(
image_save_path,
‘w’,
driver=’GTiff’,
height=height1,
width=width1,
count=1,
dtype=para_array.dtype,
crs=’+proj=latlong’,
transform=transform1,
) as dst:
dst.write_band(1,para_array)
dst.set_band_description(1,bandDes)
del dst

#输出矩阵，无值区用-9999填充
slope_array=np.full([width,height],-9999.0000)
z_array=np.full([width,height],-9999.0000)
Trend_array=np.full([width,height],-9999.0000)
Tau_array=np.full([width,height],-9999.0000)
s_array=np.full([width,height],-9999.0000)
p_array=np.full([width,height],-9999.0000)
#只有有值的区域才进行mk检验
c1=np.isnan(array1)
sum_array1=np.sum(c1,axis=0)
nan_positions=np.where(sum_array1==num_images)

positions=np.where(sum_array1!=num_images)

#输出总像元数量
print(“all the pixel counts are {0}”.format(len(positions[0])))
#mk test
for i in range(len(positions[0])):
print(i)
x=positions[0][i]
y=positions[1][i]
mk_list1=array1[:,x,y]
trend, h, p, z, Tau, s, var_s, slope, intercept = mk.original_test(mk_list1)
”’
trend: tells the trend (increasing, decreasing or no trend)
h: True (if trend is present) or False (if trend is absence)
p: p-value of the significance test
z: normalized test statistics
Tau: Kendall Tau
s: Mann-Kendal’s score
var_s: Variance S
slope: Theil-Sen estimator/slope
intercept: intercept of Kendall-Theil Robust Line
”’

if trend==”decreasing”:
trend_value=-1
elif trend==”increasing”:
trend_value=1
else:
trend_value=0
slope_array[x,y]=slope#senslope
s_array[x,y]=s
z_array[x,y]=z
Trend_array[x,y]=trend_value
p_array[x,y]=p
Tau_array[x,y]=Tau

all_array=[slope_array,Trend_array,p_array,s_array,Tau_array,z_array]

slope_save_path=os.path.join(result_path,”slope.tif”)
Trend_save_path=os.path.join(result_path,”Trend.tif”)
p_save_path=os.path.join(result_path,”p.tif”)
s_save_path=os.path.join(result_path,”s.tif”)
tau_save_path=os.path.join(result_path,”tau.tif”)
z_save_path=os.path.join(result_path,”z.tif”)
image_save_paths=[slope_save_path,Trend_save_path,p_save_path,s_save_path,tau_save_path,z_save_path]
band_Des=[‘slope’,’trend’,’p_value’,’score’,’tau’,’z_value’]
for i in range(len(all_array)):
writeImage(image_save_paths[i], height1, width1, all_array[i], band_Des[i],transform1)

#调用
path1=r”E:\2021-03-03—生态修复\吴起本地\NDVI_wuqi”
result_path=r”E:\2021-03-03—生态修复\吴起本地\result”
sen_mk_test(path1, result_path)

 

python简单游戏-反弹球
tkinter实现，直接贴上代码

from tkinter import*
import time
import random

class Ball:
def __init__(self,canvas,paddle,color):
self.canvas = canvas
self.paddle = paddle
self.id = canvas.create_oval(10,10,25,25,fill=color)
self.canvas.move(self.id,245,100)
starts = [-3,-2,-1,1,2,3]
random.shuffle(starts)
self.x = starts[0]
self.y = -3
self.canvas_height = self.canvas.winfo_height()
self.canvas_width = self.canvas.winfo_width()
self.hit_bottom = False

def hit_paddle(self,pos):
paddle_pos=self.canvas.coords(self.paddle.id)
if pos[2]>=paddle_pos[0] and pos[0]<=paddle_pos[2]:
if pos[3]>=paddle_pos[1] and pos[3]<=paddle_pos[3]:
return True
return False

def draw(self):
self.canvas.move(self.id,self.x,self.y)
pos = self.canvas.coords(self.id)
if pos[1] <= 0:
self.y = 4
if pos[3] >= self.canvas_height:
self.hit_bottom=True
if self.hit_paddle(pos)==True:
self.y=-4
if pos[0] <= 0:
self.x = 4
if pos[2] >= self.canvas_width:
self.x = -4

class Paddle:
def __init__(self,canvas,color):
self.canvas = canvas
self.id = canvas.create_rectangle(0,0,100,10,fill=color)
self.canvas.move(self.id,200,400)
self.x=0
self.canvas_width = self.canvas.winfo_width()
canvas.bind_all(‘<KeyPress-Left>’,self.turn_left)
canvas.bind_all(‘<KeyPress-Right>’,self.turn_right)
self.hit_bottom = False

def draw(self):
self.canvas.move(self.id,self.x,0)
pos = self.canvas.coords(self.id)
if pos[0] <= 0:
self.x = 0
elif pos[2] >= self.canvas_width:
self.x = 0

def turn_left(self,evt):
self.x=-7

def turn_right(self,evt):
self.x=7

tk = Tk()
tk.title(“反弹吧！球球”)
#tk.resizable(0,0)
tk.wm_attributes(“-topmost”,1)
canvas = Canvas(tk,width=650,height=600,bd=0,highlightthickness=0)
canvas.pack()
tk.update()

paddle=Paddle(canvas,’blue’)
ball = Ball(canvas,paddle,’red’)

while 1:
if ball.hit_bottom==False:
ball.draw()
paddle.draw()
tk.update_idletasks()
tk.update()
time.sleep(0.01)

Python基础（粗略整理，笔者会持续更新）

Python基础（粗略整理，笔者会持续更新）
输出函数print
print(520) # 可以输出数字
print(98.5)

print(“String”)
str4_ = “We all know that ‘A’ and ‘B’ are two capital letters.” # 输出字符串，没毛病，单双都可
print(3+1) # 输出带运算符表达式

#可以输入到指定的文件
fp = open(‘S:/test.txt’,’a+’) # 注意不是反斜杠。这个文件操作真的简单 a+ 以为不存在则创建，存在则追加
print(“hello world”,file=fp)# 注意要加file = *
fp.close

#不进行换行输出，写在一行？？？

转义字符
\t 制表符以四个字符为单位，可以理解为补齐空格，所以才能制表嘛。会出现1、2、3、4=个空格，即是否重开制表位问题。
原字符 在字符串前加个r或R
r”Hello\nworld” #字符串*后一个字符不能是反斜线
1
标识符和保留字
保留字查看的方法：

import keyword
print（keyword.kwlist）

标识符规则基本一致

变量的定义和使用
变量的定义：

变量名 = *

name = “miao”
1
变量的组成：
标识，类型和值分别可以通过内置函数id(),type(),以及其本身获得
所以都是引用变量呢

多次复制之后，变量名会指向新的空间。 没有被指向的会成为垃圾

数据类型
不带小数的都叫int

带小数的都叫float

浮点数的计算输出因为存储方式问题会存在结果容易出问题的问题。

用decimal（）解决。

True和Fale分别是0 1

字符串，不解释

称为不可变的字符序列

‘单引号’ “双引号” “””“三引号””” 其中单双必须在一行，三可以随意

print(str,type(str)) # 直接逗号分隔。。。

类型转换
str( )函数

懂得都懂，可以讲括号里面的转成字符串

int( )

float( )

不多BB

input( )函数
enter = input(‘输入提示’)

类型转换
int(enter)

本运算
算术运算符
除法运算 /

1/2 = 0.5

整除运算

11//2 = 5

幂运算 **

2**2 = 4

一正一负的整除和取余

一正一负的整除向下取整

9//-4 = -3

余数 = 被除数-出书*商

9%-4 = -3 -9%4 = 3

赋值运算符
运算顺序从右到左
支持链式赋值
a=b=c=20 # 内存地址相同，懂得都懂

参数赋值
a+=30 #等一系列操作

系列解包赋值
a,b,c = 10,20,30
比较运算符
比较运算的结果时Bool类型
== 比较的是对象的值
is运算符比较的是对象的标识（地址，id）is not 不解释
Bool运算符
and -> &&
or ||
not !
in 在不在,可以~ 同样的还有 not in
s = “hello world”
“w” in s

程序的bool值
内置函数bool()

布尔值位False：False、数值（）、None、空字符串、空列表、空元组、空字典、空集合
程序的组织结构
顺序、循环、选择

顺序结构
从上到下，依次执行

选择结构
根据bool值判断语句是否执行

单分支结构：

if num>=n : # (num>=n) 这么些也是可以的
print(“我说可以~”)

双分支结构：

if(num>=n)

多分支结构：
if num>n:
print(“ky”)
elif num==n:
print(“ky”)
else:
printf(“gun”)

分支结构之间允许出现嵌套

if else 简写，类似于三目运算符

x if condition else y

pass语句
语句什么都不做，只是一个占位符，用在语法上需要语句的地方
if(a>b):
pass # 用于构建语句

循环结构
range()函数
用于生成一个整数序列
创建方式：
# 一参,范围，但是不包括右区间点
r = rang(10) # 返回结果是一个迭代器对象，默认从0开始，默认相差1
list(r) # list 生成一个列表，用于存储迭代器对象序列

# 二参，指定了起始值
range(1,10)

# 三参，起始值，结束值，步长
range(1,10,2)

可以使用in和not in来进行bool运算
对象只储存三个值，占内存空间较小，很灵活，再用到range时才会产生相关的序列
while
while condition:

​ sentence

初始化变量
条件判断
执行语句
改变变量
for-in
for var in iterableOBJ:

​ sentence

通常用序列和字符串去作为可迭代对象

用不到变量的话可以用 _ 替代

for _ in range(5):
print(“wo tu le “)

break 和 continue
直接写就完了
break
continue

else 在循环中
else写在循环之后，如果循环执行过程中没有遇到break那么之心完毕之后会执行else
for item in range(5):
print(“Hello!”)
if(item==5):
break
else:
print(“word”)

列表—数组
id,type,value
列表的创建
方括号

list = [“hello”,”world”]

使用内置函数list

list = list([“hello”,”world”,321]) # 混合类型。。。

列表的特点
列表元素有序排列
索引银蛇*个数据
列表可以存放重复数据
任意数据类型混合存储
根据需要动态的分配和回收内存
list的元素获取
获取单个元素
通过index( )函数

list.index(“str”) # 返回*个匹配的索引，不存在则抛出异常
list(“str”,star,end) # 返回区间内的索引

通过索引去获得元素

list[2] # 正向获取 0~n-1 ,n为元素个数
list[-3] # 逆向获取 -n~-1

获取多个元素
切片操作，同样不包括stop

list_name[star:stop:step]

step默认为1，可简写为[star:stop]

step为正数，从star开始往后计算切片；为负数则从star往前挤蒜切片

step，步长，1无间隔，2间隔1……

遍历
for-in,天生的迭代器

列表元素的添加
append( )，追加

extend( ),在列表的末尾至少添加一个元素，对于列表的操作

instet( )，任意位置插入

切片，任意位置至少添加一个元素

list[1:] = list3 # 从*个元素开始切掉后面的，把list3接到后面

列表元素的删除
remove( )

一次删除一个元素
重复元素只删除*个
不存在元素抛出异常
pop( )

删除一个指定索引的元素
不存在抛出异常
没有指定索引删除*后一个，有出栈那味儿了
切片

一次至少删除一个呗
clear( )

清空表
del

删除表

del list # 删除对象

列表元素的修改
为指定的元素赋予一个新值
为指定切片赋予一个新值，切下来一块，补充上去，不在乎长度，自动扩充的
列表的排序操作
sort( )方法

默认进行升序排序，内部有参数reserve=True可以进行降序
内置函数sorted

会产生一个新的列表，需要一个变量去接一下
列表生成式
list = [i for i range (star,stop)]

i 的位置是表示列表元素的表达式
字典
Python内置的数据结构之一，与列表一样是一个可变序列
以键值对的方式存储数据，字典是一个无需的序列。 类似于Map
地点的实现原理类似于hashMap，由key到value的处理。经过hash函数，所以在内存上存储时无序的。
字典的创建
使用花括号

score = {“zhangsan”: 100 , “lisi”: 98, “wangwu”: 45}

使用内置函数dict( )

dict(name = “jack” , age = 20) # 注意，这里的键没有加引号

字典元素的获取
用[ ]来获取

score[“zhangsan”] # 如果字典中不存在对应的值则抛出keyError异常

用get( )

score.get(“zhangsan”) # 如果字典中不存在key，返回None
score.get(“zhaoliu”,bucunzaide) # 可以通过参数设置默认的value，以便指定key不存在时的返回值

字典元素的删除
del score[“zhangsan”]
score.clear() # 清空整个字典

字典元素的新增
score[“jack”] = 90 # 类似的还可以用来修改

获取字典视图的三个方法
keys( )获取字典中所有的key
values( )获取字典中所有的valus
items( ) 获取字典中所有的K V对
字典元素的遍历
for item in score:
print(score[item]) # item是Key

字典的特点
字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
字典中的元素是无序的
字典中的key’必须是不可变对象
字典可以根据需求自动的伸缩
字典会浪费较大的内存，是一种空间换时间的数据结构
字典生成式
内置函数 zip()

list = zip(item,price) # 可迭代对象作为参数
print(list)

元组和集合
元组
Python的内置数据结构之以，是一个不可变序列
不可变序列与可变序列
不可变序列：包括字符串和元组，没有 增 删 改 的操作
可变序列：列表、字典和集合，可以对序列执行 增 删 改 操作，对象的地址不发生改变
元组的创建
小括号

t = (“PYTHON”,”hello”,90) t = (“PYTHON”,)

内置函数tuple( )

t = tuple((“PYTHON”,”hello”,90))
1
为什么设计这个东西？
在多任务环境下，同时操作对象时不需要加锁（根本改不了），使用在程序中尽量使用不可变序列
可以动对象的值但是不能动地址
集合
与列表和字典一样属于可变类型的序列
集合时没有value的字典，数据结构同样是hash表
集合的创建
大括号

s = {“Python”,”hello”,90}
1
使用内置函数set( )

s = set(range(5))
s = set({“Python”,”hello”,90})# 括号里面放可迭代的对象
1
2
集合元素的相关操作
新增
add( )一次点击加一个元素
update( ) 一次添加至少一个 括号里面放可迭代的对象
删除
remove( )一次删除一个指定元素，如果指定元素不存在就抛出KeyError
discard( )不抛出
pop( )删除任意元素，栈顶的？
clear( )懂得都懂
集合间的关系
是否相等用 == 和 != 判断
是否是自己 issubset( )
是否是超集 issuperset( )
是否有交集 isdisjoint( )
集合的数学操作
交集 intersection( ) 或者使用运算符 &
并集 union( ) 或者使用运算符 |
经过集合操作，地址不发生变化
差集 difference( )，或者是运算符 –
对称差集 symmetric_difference( )
集合生成式
{i*i for i range(1,10) }
1
字符串
字符串在python中时基本数据类型，是一个不可变的字符序列

字符串的驻留机制。。。

字符型的列表，后面的不做赘述，有需要直接查API

查询，大小写转换，内容对其劈分，各种判断（是否合法），替换与合并，比较，切片，格式化，编码与解码（用于网络传输）

函数
函数的创建和调用
def 函数名（[输入参数]）:

​ 函数体

​ return xxx

def calc(a,b):
c = a+b
return c
result = calc(10,20)

函数调用的参数传递
位置实参，根据形参对应的值进行参数传递

关键字实参，根据形参的名称景行参数传递

calc(b=10,a=10) # 怎么说呢，感觉很诡异
1
参数传值传的是地址，可以间接改变value

函数定义时，给形参设定默认值，只有与默认值不符的时候才需要传递实参

个数可变的我位置参数

定义函数时，无法确定传递的位置参数的个数时，使用可变的位置参数
使用*定义个数可变的位置参数
参数值会是一个元组
个数可变的关键字形参

结果为一个字典（），传的是键值对，关键字形参本身就是键值对er
函数的返回值
函数返回多个值时，结果为元组
变量的作用域
程序代码能访问该变量的区域
局部变量
在函数内定义并使用的变量，只在函数内部有效，局部变量使用global生命，这个变量就会成为全局变量
全局变量
函数体外定义的变量
BUG
面向对象
类
不同的数据类型属于不同的类
可以使用内置函数查看数据类型
对象
类的实例
类的创建
class student:
native_place = “taiyuan” # 直接卸载类里面的变量成为类属性
def __init__(self,name age): # 初始化方法
# 在类之外定义的称为函数，在类内部定义的成为方法
self.name = name
self.age = age
@staticmethod
def method():
print(“Static method”)
@classmethod
def cm(cls):
print(“Class method”)

对象的创建
stu1 = Student(“zhangsan”,18)
# 实例对象有类指针指向类对象
stu.eat()

类属性
在方法外定义的属性——在类体内直接定义
被所有的该类对象共享，当然，允许修改
类方法
使用@classmethod修饰的方法，使用类名可以直接访问

Student.cm( )

静态方法同上，修饰有所不同

动态的绑定属性和方法
stu2.gender = “girl” # 直接绑定到实例化的对象上
def show():
print(“show “)

stu2.show = show # 完成方法绑定

封装
在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象的外部被访问，前面使用两个“ – “
但是仍然可以通过 Objname._ClassName__variable_name 访问
继承
如果一个类没有继承任何类，那么它默认继承object

定义子类是，必须在其构造函数中调用父类的构造函数

class Student(People):
def __init__(self,name,age,score):
super().__init__(name,age)
self,score = score

方法重写
在子类里面把父类的方法重新写一遍就完了呗，或i用super( ).
object
object类是所有类的父类，一次所有类都具有object类的属性和方法
内置函数dir( )可以查看指定对象的所有属性
_str() 同toString( )
多态
你不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行中根据变量所引用对象的类型，动态地决定调用哪个对象中的方法

静态语言实现多态的三个条件

继承
方法重写
弗雷引用指向子类对象
动态语言崇尚”鸭子类型“，当看到一只鸟走起来像鸭子、游泳起来像鸭子，那么这只鸟就可以被称为鸭子。不关心对象是什么类型，到底是不是鸭子，只关心对象的行为。

只要有相关的方法就行，不在乎有没有继承关系。0

特殊方法和属性
obj.__ dict__ #获得类对象或者实例对象所有的属性，返回值是一个字典
obj.__class__# 获得对象所属的类
obj__base__ # 获得对象弗雷的一个元组
obj.__mro__ # 查看类的继承结构
obj.__subclasses__() # 返回子类的列表

def __init__(self,vars):
obj.var = var # 用于定义类成员变量及其初始化
__add__() # 运算符重载
__len__() # 定义如何计算长度

模块化编程
模块
Moudles

一个模块可以有很多个函数，类，语句什么的，一个py文件就是一个模块

方便其他程序和脚本的导入并使用

重用性，方便管理

导入
import math # 导入数学计算模块
from math import pi # 导入math中的pi

 

控制流作业

# ————————-*题—————————#
number = input(‘请输入一个整数：’)
if (int(number)%7 == 0) | (number.find(‘7’) != -1):
print(‘该数与7相关’)
else:
print(‘该数与7无关’)

# ————————-第二题—————————#
id = input(‘请输入身份证号码：’)
if len(id) == 18:
birthday = id[6:14]
print(‘你的出生日期是：’,birthday)
elif len(id) == 15:
birthday = ’19’ + id[6:12]
print(‘你的出生日期是：’,birthday)
else:
print(‘请重新输入身份证号码！’)

# ————————-第三题—————————#
id = input(‘请输入身份证号码：’)
if len(id) == 18:
if int(id[-2]) % 2 == 0:
print(‘女’)
else:
print(‘男’)
elif (len(id)) == 15:
if int(id[-1]) % 2 == 0:
print(‘女’)
else:
print(‘男’)
else:
print(‘请重新输入身份证号码！’)

# ————————-第四题—————————#
list6 = [1,5,2,8,10,13,17,4,6]
## 方法一：
result = []
for i in list6:
result.append(i**2+1)
print(result)

## 方法二：
result = [i**2+1 for i in list6]
print(result)

# ————————-第五题—————————#
list7 = [‘one’,’two’,’three’,’four’,’five’,’six’,’seven’,’eight’,’nine’]
## 方法一：
result = []
for i in list7:
if i.find(‘e’) != -1:
new_i = i.replace(i[:],’^-^’)
result.append(new_i)
else:
result.append(i)
print(result)

## 方法二：
result = [i for i in list7 if i.find(‘e’)!=-1]
print(result)

#————————-第六题—————————#
# 同第四题

# ————————-第七题—————————#
list8 = [‘A’,’C’,’A’,’C’,’B’,’C’,’A’,’A’,’B’,’C’]
dict = {}
for i in set(list8):
dict[i] = list8.count(i)
print(dict)

# ————————-第八题—————————–#
n = 1
s = 0
while s<=1000:
s += 3*n+5
n += 1
print(n,’–>’,s)

# ————————–第九题—————————–#
import random
A = int(input(‘范围*小值：’))
B = int(input(‘范围*大值：’))
number = random.randint(A,B)

while True:
guess = int(input(‘请在{}、{}之间猜一个整数:’.format(A,B)))
if guess > number:
B = guess
elif guess < number:
A = guess
else:
print(‘你真棒，猜中了。’)
break

Dijkstra算法流程及基于Python仿真

Dijkstra流程：

基于Python的程序仿真
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import matplotlib.pyplot as plt
import math

show_animation = True

class Dijkstra:

def __init__(self, ox, oy, resolution, robot_radius):
“””
Initialize map for planning

ox: x position list of Obstacles [m]
oy: y position list of Obstacles [m]
resolution: grid resolution [m]
rr: robot radius[m]
“””

self.min_x = None
self.min_y = None
self.max_x = None
self.max_y = None
self.x_width = None
self.y_width = None
self.obstacle_map = None

self.resolution = resolution
self.robot_radius = robot_radius
#构建栅格地图
self.calc_obstacle_map(ox, oy)
self.motion = self.get_motion_model()

class Node:
def __init__(self, x, y, cost, parent_index):
self.x = x # index of grid
self.y = y # index of grid
self.cost = cost # g(n)
self.parent_index = parent_index
# index of previous Node

def __str__(self):
return str(self.x) + “,” + str(self.y) + “,” + str(
self.cost) + “,” + str(self.parent_index)

def planning(self, sx, sy, gx, gy):
“””
dijkstra path search

input:
s_x: start x position [m]
s_y: start y position [m]
gx: goal x position [m]
gx: goal x position [m]

output:
rx: x position list of the final path
ry: y position list of the final path
“””
#将起点和终点转换为节点形式，即包含下标，代价值和父节点信息
start_node = self.Node(self.calc_xy_index(sx, self.min_x),
self.calc_xy_index(sy, self.min_y), 0.0, -1)
# round((position – minp) / self.resolution)
goal_node = self.Node(self.calc_xy_index(gx, self.min_x),
self.calc_xy_index(gy, self.min_y), 0.0, -1)

open_set, closed_set = dict(), dict() # key – value: hash表
#key是表示索引，value 是节点信息
open_set[self.calc_index(start_node)] = start_node

while 1:
c_id = min(open_set, key=lambda o: open_set[o].cost)
# 取cost*小的节点
current = open_set[c_id]

# show graph 动画仿真
if show_animation: # pragma: no cover
plt.plot(self.calc_position(current.x, self.min_x),
self.calc_position(current.y, self.min_y), “xc”)
# for stopping simulation with the esc key.
plt.gcf().canvas.mpl_connect(
‘key_release_event’,
lambda event: [exit(0) if event.key == ‘escape’ else None])
if len(closed_set.keys()) % 10 == 0:
plt.pause(0.001)

# 判断是否是终点
if current.x == goal_node.x and current.y == goal_node.y:
print(“Find goal”)
goal_node.parent_index = current.parent_index
goal_node.cost = current.cost
break

# Remove the item from the open set
del open_set[c_id]

# Add it to the closed set
closed_set[c_id] = current

# expand search grid based on motion model
for move_x, move_y, move_cost in self.motion:
node = self.Node(current.x + move_x,
current.y + move_y,
current.cost + move_cost, c_id)
n_id = self.calc_index(node)

if n_id in closed_set:
continue

if not self.verify_node(node):
continue

if n_id not in open_set:
open_set[n_id] = node # Discover a new node
else:
if open_set[n_id].cost >= node.cost:
# This path is the best until now. record it!
open_set[n_id] = node

rx, ry = self.calc_final_path(goal_node, closed_set)

return rx, ry
#通过父节点追溯从起点到终点的*佳路径
def calc_final_path(self, goal_node, closed_set):
# generate final course
rx, ry = [self.calc_position(goal_node.x, self.min_x)], [
self.calc_position(goal_node.y, self.min_y)]
parent_index = goal_node.parent_index
while parent_index != -1:
n = closed_set[parent_index]
rx.append(self.calc_position(n.x, self.min_x))
ry.append(self.calc_position(n.y, self.min_y))
parent_index = n.parent_index

return rx, ry

def calc_position(self, index, minp):
pos = index * self.resolution + minp
return pos

def calc_xy_index(self, position, minp):
return round((position – minp) / self.resolution)

def calc_index(self, node):
return node.y * self.x_width + node.x
#检查是否超出地图范围或有障碍物
def verify_node(self, node):
px = self.calc_position(node.x, self.min_x)
py = self.calc_position(node.y, self.min_y)

if px < self.min_x:
return False
if py < self.min_y:
return False
if px >= self.max_x:
return False
if py >= self.max_y:
return False

if self.obstacle_map[int(node.x)][int(node.y)]:
return False

return True

def calc_obstacle_map(self, ox, oy):
”’ 第1步：构建栅格地图 ”’
self.min_x = round(min(ox))
self.min_y = round(min(oy))
self.max_x = round(max(ox))
self.max_y = round(max(oy))
print(“min_x:”, self.min_x)
print(“min_y:”, self.min_y)
print(“max_x:”, self.max_x)
print(“max_y:”, self.max_y)

#计算X和Y方向 栅格的个数
self.x_width = round((self.max_x – self.min_x) / self.resolution)
self.y_width = round((self.max_y – self.min_y) / self.resolution)
print(“x_width:”, self.x_width)
print(“y_width:”, self.y_width)

# obstacle map generation
# 初始化地图，地图是要用二维向量表示的，在这里采用两层列表来表示
#初始化为false，内层为Y方向栅格的个数，外层为X方向栅格个数
self.obstacle_map = [[False for _ in range(int(self.y_width))]
for _ in range(int(self.x_width))]
# 设置障碍物
for ix in range(int(self.x_width)):
x = self.calc_position(ix, self.min_x)
for iy in range(int(self.y_width)):
y = self.calc_position(iy, self.min_y)
for iox, ioy in zip(ox, oy):
#障碍物到栅格的距离，如果小于车体半径，就标记为true,障碍物膨胀
d = math.hypot(iox – x, ioy – y)
if d <= self.robot_radius:
self.obstacle_map[ix][iy] = True
break

@staticmethod
def get_motion_model():
# dx, dy, cost
#定义机器人行走的代价，以当前点为中心周围八个栅格的代价
motion = [[1, 0, 1],
[0, 1, 1],
[-1, 0, 1],
[0, -1, 1],
[-1, -1, math.sqrt(2)],
[-1, 1, math.sqrt(2)],
[1, -1, math.sqrt(2)],
[1, 1, math.sqrt(2)]]

return motion

def main():
# start and goal position
sx = -5.0 # [m]
sy = -5.0 # [m]
gx = 50.0 # [m]
gy = 50.0 # [m]
grid_size = 2.0 # [m]
robot_radius = 1.0 # [m]

# set obstacle positions
ox, oy = [], []
for i in range(-10, 60):
ox.append(i)
oy.append(-10.0)
for i in range(-10, 60):
ox.append(60.0)
oy.append(i)
for i in range(-10, 61):
ox.append(i)
oy.append(60.0)
for i in range(-10, 61):
ox.append(-10.0)
oy.append(i)
for i in range(-10, 40):
ox.append(20.0)
oy.append(i)
for i in range(0, 40):
ox.append(40.0)
oy.append(60.0 – i)

if show_animation: # pragma: no cover
plt.plot(ox, oy, “.k”)
plt.plot(sx, sy, “og”)
plt.plot(gx, gy, “xb”)
plt.grid(True)
plt.axis(“equal”)

dijkstra = Dijkstra(ox, oy, grid_size, robot_radius)
rx, ry = dijkstra.planning(sx, sy, gx, gy)

if show_animation: # pragma: no cover
plt.plot(rx, ry, “-r”)
plt.pause(0.01)
plt.show()

if __name__ == ‘__main__’:
main()

仿真结果：

Reference:
1.Dijkstra
2.PythonRobotics

稍息！立正！——print格式化输出

痴月熊学Python
文章目录
痴月熊学Python
往期文章
前言
一、f-String格式化
二、占位符
三、format格式化
总结
往期文章
*章：Python-新人报道
第二章：小学生都会的数学计算，痴月熊学Python
第三章：变量-从此你就叫张三了！，痴月熊学python
第四章：神奇的变身器-转义字符（改），痴月熊学python

前言
福宝们，下午好啊。改版后的第4.5章阅读量有点少呀，不知道是不是拖更了一天的缘故。呜呜呜，以后一定要做个不拖更的好熊，所以今天继续爆肝第五章：print格式化输出。在写第三章的时候用到过其中一种： ” f … {} ” 的组合。之前的评论下面有小伙伴疑惑，那今天就来详细讲解一下这个东西，另外还有其他格式化的方式。那我们开始今天的学习吧。

提示：以下是本篇文章正文内容，下面案例可供参考

一、f-String格式化
所谓格式化输出，就是创建一个可以嵌入变量内容的字符串。如果不进行格式化，变量名就会被直接打印出来，发挥不了他的作用。所以我们现在开始讲之前用到的：f-String格式化。这个上面也说过，格式： f” … {} … “，其中你要在字符串里调用变量，需要把变量写在 ” { } ” 中，字符串的开头还要写个 ” f ” 。f 就代表着format，也就是格式化的意思。这个组合是固定的，缺一不可，你写出了 ” f “，就相当于告诉了python，这是一个已经格式化的字符串。python就会去看那些变量，当然你要是前面写了f，中间没有写中括号，也是可以正常执行的。只不过没有去调用变量。

name = “痴月熊”
name2 = “憨憨熊”
age = 18
age2 = 19
print(f”{name}:下午好各位，我是{name},{age}的文艺小青年。这是我铁子{name2},他{age2}，请多关照”)
print(f”{name2}：嗷嗷嗷~”)

RUN:

痴月熊:下午好各位，我是痴月熊,18的文艺小青年。这是我铁子憨憨熊,他19，请多关照
憨憨熊：嗷嗷嗷~

二、占位符
首先还是看个表，常见的占位符号

符号 意义
%d 整数
%f 浮点数
%s 字符串
占位符，顾名思义。就是在一段字符串中占一个位置，然后引用变量插进来。具体格式是 print(“…%d…” % (变量))，下面还是直接通过练习来看一下效果。

name = “憨憨熊”
once = 1
num = 4.2
print(“%s *喜欢的事情就是打游戏，他*擅长的还是动作冒险类” % name)
print(“魂斗罗他甚至只需要 %d 条命就可以通关” % once)
print(“即使他两个眼睛都已经%f度了，还是不能放下游戏机” %num)

RUN：

憨憨熊 *喜欢的事情就是打游戏，他*擅长的还是动作冒险类
魂斗罗他甚至只需要 1 条命就可以通关
即使他两个眼睛都已经4.200000度了，还是不能放下游戏机

效果就是这样啦，当然也可以放在一起试一下。

name = “憨憨熊”
once = 1
num = 4.2
print(“””
%s *喜欢的事情就是打游戏，他*擅长的还是动作冒险类.
魂斗罗他甚至只需要 %d 条命就可以通关.
即使他两个眼睛都已经%f度了，还是不能放下游戏机
“”” % (name,once,num))

RUN：

憨憨熊 *喜欢的事情就是打游戏，他*擅长的还是动作冒险类.
魂斗罗他甚至只需要 1 条命就可以通关.
即使他两个眼睛都已经4.200000度了，还是不能放下游戏机

使用占位符的时候，一定要想好变量的数据类型，如果你写了个%d，结果你放了个字符串进去就会报错。当然数字也可以作为字符串，你写成%s也可以执行。不过为了方便浏览，*好根据数据类型填入相应的占位符。另外如果你占位符是%d,你放了个浮点型进去，他就会给你强制转换为整数，反之也是一样的。如下：

num1 = 4.2
num2 = 4
print(“%d” % num1)
print(“%f” % num2)

RUN：

4.000000

三、format格式化
第三种就是利用format函数，在python里也叫方法。基本语法是在字符串中写入 ” {} “，*后再字符串的末尾调用.format方法，将变量插入到{}。看起来是不是像f-string格式化，format格式化是在python2.6更新的，而f-string是在python3.6。当然个人认为这个用起来不太舒服，还是上面两个好用点。有很多时候，想要插入变量，都要在后面写一大堆参数。好麻烦！ 以下就是效果啦。

name1 = “痴月熊”
name2 = “憨憨熊”
time = 12
num = 2
print(“此时半夜{}点：\”呜呜呜, {}.\””.format(time,name1))
print(“{name2},大晚上{time}点的,你在瞎叫啥”.format(time=time, name2=name2))
print(“我居然花了{}条命才过这个关卡”.format(num))
print(f”{name1}心里独白：这玩意能一条命就过去的才不是正常熊吧。”.format(name1=name1))
print(“<玛丽奥制造>….”)

RUN:

此时半夜12点：”呜呜呜, 痴月熊.”
憨憨熊,大晚上12点的,你在瞎叫啥
我居然花了2条命才过这个关卡
痴月熊心里独白：这玩意能一条命就过去的才不是正常熊吧。
<玛丽奥制造>….

蓝桥杯Python部分小套路(超详细分析！！）

蓝桥杯Python部分小套路
一、说明
本人是小白，以下小套路是对前段所刷题的小小总结，不全面，仅仅作为小分享，各位大佬多多包涵啦~
欢迎大家进入我的主页浏览其它文章。

二、部分小套路
1.同时输入多个参数
n,m=map(int,input().split())

不要漏掉 map
不要漏掉split()
2.输入列表的3种表达方法
list1=list(input().split())
print(list1)

*简单直接的一种，不要在前面漏掉list
如果加上map和int是错误的
list1=list(map(int,input().split()))
`
n=3
list1=[]
for i in range(3):
list1.append(input().split())
print(list1)

将会得到3行x列的列表（x:具体有多少列看自己一行输入多少个数字）
h,l=map(int,input().split())
list1=[[]for i in range(h)]
for j in range(h):
arr=list(input().split())
for k in range(l):
list1[j].append(arr[k])
print(list1)

*行：h与l分布代表行与列数
第二行：首先先建立一个有h个[ ]的列表list1，之后再把数字加入到[ ]中
第三、四行：然后针对h个[ ]，输入对应的数字进去
第五、六行：*后，把arr放入list1的对应j行
这种表示方法没有前2种简单，但是可以用于题目要求输入h行，l列时

控制结构与函数

3.1 分支结构
3.1.1 单分支结构
Python 的单分支结构使用 if 保留字对条件进行判断，使用方式如下：

if <条件>:
<语句块>

<语句块> 是 if 条件满足后执行的一个或多个语句序列，缩进表达 <语句块> 与 if 的包含关系。<条件> 是一个产生 True 或 False 结果的语句，当结果为 True 时，执行 <语句块>，否则跳过 <语句块>。

3.1.2 二分支结构
Python 的二分支结构使用 if-else 保留字对条件进行判断，语法格式如下：

if <条件>:
<语句块 1>
else:
<语句块 2>

<语句块 1> 在 if 中 <条件> 满足即为 True 时执行，<语句块 2> 在 if 中 <条件> 不满足即为 False 时执行。简单来说，二分支结构根据条件的 True 或 False 结果产生两条路径。

二分支结构还有一种更简洁的表达方式，适合 <语句块 1> 和 <语句块 2> 都只包含简单表达式的情况，语法格式如下：

<变量> = <表达式 1> if <条件> else <表达式 2>
1
如果 <条件> 为 True，则将 <表达式 1> 的结果赋值给 <变量>，否则将 <表达式 2> 的结果赋值给 <变量>。

first_num = eval(input(‘请输入*个数：’))
second_num = eval(input(‘请输入第二个数：’))
bigger_num = first_num if first_num >= second_num else second_num
print(f’较大的数是{bigger_num}。’)
————————————————————————
请输入*个数：50
请输入第二个数：25
较大的数是50。

3.1.3 多分支结构
Python 的 if-elif-else 用于描述多分支结构，语句格式如下：

if <条件 1>:
<语句块 1>
elif <条件 2>:
<语句块 2>
…
else:
<语句块 n>

多分支结构通常用于判断同一个条件或一类条件的多个执行路径。Python 会按照多分支结构的代码顺序依次评估判断条件，寻找并执行*个结果为 True 的条件所对应的语句块。当 if-elif-else 中的某个语句块执行后，Python 就会跳过整个 if-elif-else 结构。即使后续的条件测试为真，其对应的语句块也不会被执行。

此外，Python 并不要求 if-elif 结构后面的代码必须有 else 代码块。else 代码块是一个包罗万象的语句，只要不满足任何 if 或 elif 中的条件测试，else 中的代码就会被执行。这可能会引入无效甚至恶意的数据。如果知道*终要测试的条件，应考虑使用一个 elif 代码块代替 else 代码块。这样就可以肯定，仅当满足相应的条件时，代码才会执行。

3.1.4 条件判断及组合
分支结构中的条件判断可以使用任何能够产生 True 或 False 的语句或函数。形成判断条件*常见的方式是采用关系操作符：<、<=、>、>=、==、!=。

Python 语言中，任何非零的数值、非空的数据类型都等价于 True，0 或空类型等价于 False，它们可以直接用作判断条件。

Python 语言使用保留字 not、and 和 or 对条件进行逻辑运算或组合。保留字 not 表示单个条件的“否”关系，and 表示多个条件之间的“与”关系，保留字 or 表示多个条件之间的“或”关系。

3.1.5 测试多个条件
if-elif-else 结构功能强大，但仅适用于只有一个条件满足的情况：遇到了通过了的测试后，Python 便会跳过余下的测试。这种设定效率很高，但只能测试一个特定的条件。

如果需要检查多个条件，应使用一系列不包含 elif 和 else 代码块的简单 if 语句。在可能有多个条件为 True 且需要在每个条件为 True 时都采取响应措施时，这种方法将非常适合。

3.2 循环结构
3.2.1 遍历循环
遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for 语句的循环执行次数是根据遍历结构中元素个数确定的。其语法结构如下：

for <循环变量> in <遍历结构>:
<语句块>

<遍历结构> 可以是字符串、range() 函数或组合数据类型、文件等。对于字符串，可以逐一遍历字符串的每个字符，基本使用方式如下：

for <循环变量> in <字符串变量>:
<语句块>

使用 range() 函数，可以指定语句块的循环次数，基本使用方式如下：

for <循环变量> in range(<循环次数>):
<语句块>

除了在 range() 函数里直接指定循环次数，也可以使用如下用法：range(start, stop[, step])。表示计数从 start 开始，到 stop 结束，但不包括 stop。step 为步长，缺省时步长为 1。

3.2.2 无限循环
Python 通过保留字 while 实现无限循环：

while <条件>:
<语句块>

当程序执行到 while 语句时，条件测试如果为 True，执行循环体语句，语句结束后返回再次判断 while 语句的条件；当条件测试为 False 时，循环终止，执行与 while 同级别缩进的后续语句。

while 定义的是无限循环，让其在恰当的时候停止运行是很重要的。如果让 while 循环停止的条件不多时，通过简单的条件测试即可结束它的运行。但在更复杂的程序当中，很可能会有众多的事件将导致循环的停止，在这种情况下如果在一条 while 语句中检查所有的这些条件，将既复杂又困难。

一种很好的方法是定义一个变量将其作为标志（flag），用于判断整个程序是否处于活动状态。它相当于程序的交通信号灯，当所有的条件满足时，它的值为 True，循环继续执行；一旦循环条件不满足时就为 False，以此来结束程序的运行。

prompt = “\n我是一个复读机。”
prompt += “\n我会重复你的话，输入 quit 结束程序。”

active = True
while active:
message = input(prompt)

if message == ‘quit’:
active = False
else:
print(message)
————————————————————————
我是一个复读机。
我会重复你的话，输入 quit 结束程序。你好
你好

我是一个复读机。
我会重复你的话，输入 quit 结束程序。你是只鹦鹉
你是只鹦鹉

我是一个复读机。
我会重复你的话，输入 quit 结束程序。quit

上述程序中，变量 active 被设置成了标志位，用于判断输入的内容是不是 quit 以确定程序是否继续执行。

3.2.3 循环控制
循环结构有两个辅助循环控制的保留字：break 和 continue。

break 用来跳出 for 或 while 循环，脱离该循环后程序从循环后的代码继续执行。如果有 2 层或多层循环，break 只能退出*内层循环。

利用 break 可将上述代码改写：

prompt = ‘\n我是一个复读机。’
prompt += ‘\n输入 quit 结束程序。’

while True:
message = input(prompt)

if message == ‘quit’:
break
else:
print(message)
————————————————————————
我是一个复读机。
我会重复你的话，输入 quit 结束程序。你好
你好

我是一个复读机。
我会重复你的话，输入 quit 结束程序。你是只鹦鹉
你是只鹦鹉

我是一个复读机。
我会重复你的话，输入 quit 结束程序。quit

continue 用来结束本次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。

current_number = 0
while current_number < 10:
current_number += 1
if current_number % 2 == 0:
continue

print(current_number)
————————————————————————

continue 语句和 break 语句的区别是：continue 语句只结束本次循环，不终止整个循环的执行，而 break 具备结束循环的能力。

3.2.4 循环中的 else 子句
循环语句支持 else 子句。for 循环中，可迭代对象中的元素全部循环完毕时，或当 while 循环的条件为假时，执行该子句；break 语句终止循环时，不执行该子句。

for i in range(10):
print(i, end=’ ‘)
else:
print(‘循环结束。’)
————————————————————————
0 1 2 3 4 5 6 7 8 9 循环结束。

for i in range(10):
print(i, end=’ ‘)
if i == 5:
break # break终止了循环，不执行else子句
else:
print(‘循环结束。’)
————————————————————————
0 1 2 3 4 5

num = 9
while num >= 0:
print(num, end=’ ‘)
num -= 1
else:
print(‘循环结束。’)
————————————————————————
9 8 7 6 5 4 3 2 1 0 循环结束。

num = 0
while num >= 10:
print(num, end=’ ‘)
num -= 1
else:
print(‘循环结束。’)
————————————————————————
循环结束。

3.3 函数的基本使用
3.3.1 函数的概念
函数是一段具有特定功能的、可重用的代码块，通过函数名来表示和调用。经过定义，一组语句等价于一个函数，在需要使用这组语句的地方，直接调用函数名称即可。

Python 定义一个函数使用 def 保留字，语法形式如下：

def <函数名>(<参数列表>):
<函数体>
return <返回值列表>

函数名可以是任何有效的 Python 标识符。参数列表是调用该函数时传递给它的值，可以有零个、一个或多个。当传递多个参数时各参数由逗号分隔，没有参数时也要保留圆括号。函数体是函数每次被调用时执行的代码，由一行或多行语句组成。

如果需要返回值，使用保留字 return 和返回值列表。函数可以没有 return 语句，表示函数没有返回值。函数体运行结束后会将控制权返回给调用者。

3.3.2 基本用法
定义后的函数不能直接运行，需要经过调用才能运行。调用函数的基本方法如下：

<函数名>(<实际赋值参数列表>)
1
具体来说，函数的使用一共分为四个步骤：函数定义、函数调用、函数执行、函数返回。

函数定义：使用 def 保留字将一段代码定义为函数，需要确定函数的名字、参数的名字、参数的个数，使用参数名称作为形式参数（占位符）编写函数内部的功能代码。

函数调用：通过函数名调用函数功能，对函数的各个参数赋予实际值，实际值可以是实际数据，也可以是在调用函数前已经定义过的变量。

函数执行：函数被调用后，使用实际参数（赋予形式参数的实际值）参与函数内部代码的运行。

函数返回：函数执行结束后，根据 return 保留字的指示决定是否返回结果。如果返回结果，则结果将被放置到函数被调用的位置。函数使用完毕，程序继续运行。

3.3.2 传递实参
向函数传递实参的方式很多。可使用位置实参，这要求实参的顺序与形参的顺序相同；也可用关键字实参，其中每个实参都由变量名和值组成；还可以向函数传递列表和字典。

调用函数时，Python 必须将函数调用中的每个实参都关联到函数定义中的形参。为此，*简单的关联方式是基于实参的顺序。这种关联方式称为位置实参。

def describe_pet(animal_type, pet_name):
“””显示宠物信息。”””
print(f”\nI have a {animal_type}.”)
print(f”My {animal_type}’s name is {pet_name.title()}.”)

describe_pet(‘parrot’, ‘polly’)
————————————————————————
I have a parrot.
My parrot’s name is Polly.

位置实参的顺序很重要，如果实参的顺序不正确，结果可能会出乎意料。

关键字实参则是传递给函数的名称值对。因为直接在实参中将名称和值关联起来，所以向函数传递实参时不会混淆。关键字实参让你无须考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值得用途。

def describe_pet(animal_type, pet_name):
“””显示宠物信息。”””
print(f”\nI have a {animal_type}.”)
print(f”My {animal_type}’s name is {pet_name.title()}.”)

describe_pet(animal_type=’parrot’, pet_name=’polly’)
————————————————————————
I have a parrot.
My parrot’s name is Polly.

3.3.3 返回简单值
return 语句用来结束函数并将程序返回到函数被调用的位置继续执行。return 语句可以出现在函数中的任何部分，当执行 return 语句时，即使函数主体中还有其他语句，函数执行也会停止，同时可以将 0 个、1 个或多个函数运算的结果返回给函数被调用处的变量。

函数可以没有 return，此时函数并不返回值。当函数使用 return 返回多个值，应该使用一个变量或多个变量保存结果。如果使用一个变量接收多个返回值的话，Python 将把多个返回值以元组的形式赋值给该变量。

def caluculate(x, y=10):
“””返回两个参数相乘和相加的结果。”””
return x*y, x+y

s = caluculate(99, 2)
print(s)

a, b = caluculate(99, 2)
print(a)
print(b)
————————————————————————
(198, 101)
198
101

3.3.4 为形参指定默认值
函数的参数在定义时可以指定默认值，当函数被调用时，如果没有传入对应的参数值，则使用函数定义时的默认值替代。函数定义时的语法形式如下：

def <函数名>(<非可选参数列表>, <可选参数>=<默认值>):
<函数体>
return <返回值列表>
1
2
3
使用默认值时，必须先在形参列表中列出没有默认值的形参，再列出有默认值的实参。这样才能让 Python 正确地解读位置实参。

def describe_pet(pet_name, animal_type=’dog’):
“””显示宠物信息。”””
print(f”\nI have a {animal_type}.”)
print(f”My {animal_type}’s name is {pet_name.title()}.”)

describe_pet(pet_name=’willie’)
————————————————————————
I have a dog.
My dog’s name is Willie.

3.3.5 让实参变成可选的
有时候，需要让实参变成可选的，这样使用函数的人就能只在必要的时候提供额外的信息。可使用默认值来让实参变成可选的。

例如要处理一位西方人的姓名，他们的姓名都有 first name 与 last name，但并非每个人的名字都有 middle name。下面的程序便演示了怎样处理这个问题：

def get_formatted_name(first_name, last_name, middle_name=”):
“””返回整洁的姓名。”””
if middle_name:
full_name = f”{first_name} {middle_name} {last_name}”
else:
full_name = f”{first_name} {last_name}”
return full_name.title()

musician = get_formatted_name(‘michael’, ‘jackson’)
print(musician)

musician = get_formatted_name(‘michael’, ‘jackson’, ‘joseph’)
print(musician)
————————————————————————
Michael Jackson
Michael Joseph Jackson

3.4 更多的函数使用细节
3.4.1 等效的函数调用
Python 支持混合使用位置参数、关键字参数和默认值，因此有多种等效的函数调用方式。例如下面对函数 describe_pet() 的定义中，给一个形参提供了默认值：

def describe_pet(pet_name, animal_type=’dog’):
1
基于这种定义，在任何情况下都必须给 pet_name 提供实参，指定该实参时可采用位置方式，也可采用关键字方式。如果要函数描述的动物不是小狗，还必须在函数调用中给 animal_type 提供实参。同样，指定该实参时可以采用位置方式，也可采用关键字方式。

下面对这个函数的调用方式都可行：

# 一条名为 Willie 的小狗
describe_pet(‘willie’)
describe_pet(pet_name=’willie’)

# 一只名为 Polly 的鹦鹉
describe_pet(‘polly’, ‘parrot’)
describe_pet(pet_name=’polly’, animal_type=’parrot’)
describe_pet(animal_type=’parrot’, pet_name=’polly’)

3.4.2 返回字典
函数可返回任何类型的值，包括列表和字典等比较复杂的数据结构。下面的函数接受姓名的组成部分，并返回一个表示个人信息的字典：

def build_person(first_name, last_name, age=None):
“””返回一个字典，其中包含有关一个人的信息。”””
person = {‘first’: first_name, ‘last’: last_name}
if age:
person[‘age’] = age
return person

musician = build_person(‘michael’, ‘jackson’)
print(musician)

musician = build_person(‘michael’, ‘jackson’, age=’50’)
print(musician)
————————————————————————
{‘first’: ‘michael’, ‘last’: ‘jackson’}
{‘first’: ‘michael’, ‘last’: ‘jackson’, ‘age’: ’50’}

在函数定义中，定义了一个可选形参 age，其默认值设置成了 None，表示变量没有值。可以将 None 视为占位符，在条件测试中，None 相当于 False。如果函数调用中包含形参 age 的值，这个值也将被存储到字典中。

3.4.3 结合使用函数和 while 循环
下面的程序使用函数 get_formatted_name() 和 while 循环，以更正式的方式问候用户。同时，该程序提供了退出的方式。

def get_formatted_name(first_name, last_name):
“””返回整洁的姓名。”””
full_name = f”{first_name} {last_name}”
return full_name.title()

while True:
print(“\nPlease tell me your name:”)
print(“(enter’q’at any time to quit)”)

f_name = input(“First name:”)
if f_name == ‘q’:
break

l_name = input(“Last name:”)
if l_name == ‘q’:
break

formatted_name = get_formatted_name(f_name, l_name)
print(f”\nHello, {formatted_name}!”)
————————————————————————
Please tell me your name:
(enter ‘q’ at any time to quit)
First name: john
Last name: lennon

Hello, John Lennon!

Please tell me your name:
(enter ‘q’ at any time to quit)
First name: michael
Last name: jackson

Hello, Michael Jackson!

Please tell me your name:
(enter ‘q’ at any time to quit)
First name: q

3.4.4 列表的传递
将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的。假设有一家为用户提交的设计制作 3D 打印模型的公司，需要将打印的设计存储到一个列表中，打印后将移到另一个列表中。下面的程序展示了这一实现：

def print_models(unprinted_designs, completed_models):
“””
模拟打印每个设计，直到没有未打印的设计为止。
打印每个设计后，都将其移到列表 completed_models 中。
“””
while unprinted_designs:
current_design = unprinted_designs.pop()
print(f”Printing model: {current_design}”)
completed_models.append(current_design)

def show_completed_models(completed_models):
“””显示打印好的模型。”””
print(“\nThe following models have been printed:”)
for completed_model in completed_models:
print(completed_model)

unprinted_designs = [‘phone case’, ‘robot pendant’, ‘dodecahedron’]
completed_models = []

print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)
————————————————————————
Printing model: dodecahedron
Printing model: robot pendant
Printing model: phone case

The following models have been printed:
dodecahedron
robot pendant
phone case

有时候，需要禁止函数修改列表。例如在上面的程序中，如果需要保留原来的未打印的设计列表以供备案，那么就不应该让函数修改列表。为了实现这个目的，可以向函数传递列表的副本而非原件。要将列表的副本传递给函数，可以使用列表的切片表示法：

print_models(unprinted_designs[:], completed_models)
1
不过，给函数传递列表副本将会降低程序运行效率，尤其是在处理大型列表时。因此除非有充足的利用，否则还是应该将原始列表传递给函数。

3.4.5 传递任意数量的实参
有时候，预先不知道函数需要接受多少个实参，不过好在 Python 允许函数从调用语句中收集任意数量的实参。

下面是一个模拟制作比萨的程序，形参名 * toppings 中的星号表示创建一个名为 toppings 的空元组。此外，这个程序结合使用了位置实参和任意数量的实参。为了让函数正确接收参数，应当把接收任意数量实参的形参放到参数列表的*后。

def make_pizza(size, *toppings):
“””概述要制作的比萨。”””
print(f”\nMaking a {size}-inch pizza with the following toppings:”)
for topping in toppings:
print(f”- {topping}”)

make_pizza(16, ‘pepperoni’)
make_pizza(12, ‘mushrooms’, ‘green peppers’, ‘extra cheese’)
————————————————————————
Making a 16-inch pizza with the following toppings:
– pepperoni

Making a 12-inch pizza with the following toppings:
– mushrooms
– green peppers
– extra cheese

在上面的程序中，函数需要接收任意数量的实参，但尚且知道接受的是怎样的信息：比萨的尺寸及配料。有时，函数不仅需要接受任意数量的实参，而且预先也不知道传递给函数的会是怎样的信息。在这种情况下，可将函数编写成能接受任意数量的键值对——调用语句提供了多少就接受多少。下面的程序演示了创建用户的简介：

def build_profile(first, last, **user_info):
“””创建一个字典，其中包含获悉的有关用户的一切。”””
user_info[‘first_name’] = first
user_info[‘last_name’] = last
return user_info

user_profile = build_profile(‘albert’, ‘einstein’,
location=’princeton’,
field=’physics’)
print(user_profile)
————————————————————————
{‘location’: ‘princeton’, ‘field’: ‘physics’, ‘first_name’: ‘albert’, ‘last_name’: ‘einstein’}

上述程序中的函数要求必须提供名和姓，同时允许调用者根据需要提供任意数量的名称值对。形参 **user_info 中的两个星号表示创建一个名为 user_info 的空字典，并将收到的所有名称值对都放到这个字典中。显然，为了创建键值对，在向形参 **user_info 传递实参时应使用关键字实参。

3.5 函数的存储及编写规范
3.5.1 将函数存储在模块中
使用函数可以将代码块与主程序分离，通过给函数指定描述性的名称，可以让主程序更加容易理解。进一步地，可以将函数存储在被称为模块的独立文件中（扩展名为. py），再将模块导入到主程序中。Python 语言使用 import 保留字实现引用功能。

3.5.2 使用 import
如果要导入整个模块可以使用如下语句：

import <模块名称>

引用整个模块之后，采用 <模块名称>.<函数名称>() 的方式调用具体的函数。

如果需要从模块中导入特定的函数，可以使用下面的语句：

from <模块名称> import <函数名> # 从模块中调用指定函数
from <模块名称> import <函数名 1>, …, <函数名 N> # 从模块调用任意数量的函数

使用这种引用方式，不再需要 <模块名称>. 作为前导，而是使用 <函数名>() 的形式直接调用模块中的函数。

如果要导入的函数名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的函数别名：

from <模块名称> import <函数名> as <函数别名>

使用这种方式后，在程序中使用 <函数别名>() 的形式即可调用函数。

as 除了可以给函数指定别名，还可以给模块指定别名：

import <模块名称> as <模块别名>

在调用时采用 <模块别名>.<函数名>() 的形式调用模块中的函数。这种做法比给函数指定别名会更好，因为模块名通常无关紧要，而函数名则指明了函数的功能。对于理解代码而言，函数名比模块名更重要。

如果要导入模块中的所有函数，使用 * 运算符即可完成该功能：

from <模块名称> import *

此，使用 <函数名>() 的形式即可调用模块中的任意函数。不过，使用并非自己编写的大型模块时，*好不要采用这种导入方法。这是因为如果模块中有函数的名称与当前项目中使用的名称相同，将可能导致错误：Python 可能遇到多个名称相同的函数或变量，进而覆盖函数，而不是分别导入所有函数。

*佳的做法是，要么只导入需要使用的函数，要么导入整个模块并使用句点表示法。

3.5.3 函数的编写规范
编写函数时，应当遵循以下的规范：

为函数指定描述性名称，且只在其中使用小写字母及下划线。

每个函数都应包含阐述功能的简要注释。该注释应紧跟在函数定义后，并采用文档字符串格式。

给形参指定默认值时，等号两边不要有空格。对于函数调用中的关键字实参，也应遵循这种约定。

如果程序或模块包含多个函数，使用两个空行将相邻的函数分开。

所有 import 语句都应放在文件开头，除非文件开头使用了注释来描述整个程序。

如果形参很多，导致函数定义长度超过了 PEP 8 建议的代码行长，可在函数定义中输入左括号后按回车键，并在下一行按两次 Tab 键，从而将形参列表和只缩进一层的函数体区分开。

def <函数名>(
<参数 1>, <参数 2>,
<参数 3>, <参数 4>,
…
):