Python 部分语法

一、使用一个input( )同时获取多个输入

1. map（）
   函数语法： $map(function,iterable,...)$

• function – 函数
• iterable – 一个或多个序列
• map()函数接收两个参数，一个是函数，一个是序列
• map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

2. str.split( )

• 通过指定分隔符对字符串进行切片，将一个字符串分裂成多个字符串列表，缺省时根据空格切分，可指定逗号或制表符等。

3. map(function,input(“以空格分开”).split())

• input( )输出的是用空格分开的字符串，
• split( )会分割开各个值并放到列表中
• 此时在列表中的值是字符串，如果要用于运算必须在map( )中利用int( )或者float( )等处理，再赋值
• 如果需要赋值的值都是字符串的话则无需map函数了

a,b =input('输入a,b空格隔开:').split()
#此时a,b均为str型
a,b =map(int,input('输入a,b空格隔开:').split())
#此时a,b为int型

二、数字处理精度和精确运算

1. 内置函数round()
   $round(value,ndigits)$，对浮点数进行四舍五入

• ndigits>0，四舍五入到指定的小数位

• ndigits=0, 四舍五入到最接近的整数

• ndigits<0 ，在小数点左侧进行四舍五入

• 如果round()函数只有number这个参数，等同于ndigits=0

  $四舍五入规则：$

• 要求保留位数的后一位<=4，则舍去，如5.214保留小数点后两位，结果是5.21

• 要求保留位数的后一位“=5”，且该位数后面没有数字，则不进位，如5.215，结果为5.21

• 要求保留位数的最后一位“=5”，且该位数后面有数字，则进位，如5.2151，结果为5.22

• 要求保留位数的最后一位“>=6”，则进位。如5.216，结果为5.22

round(2.2456,1)
2.2
round(2.2456,2)
2.25
round(2.2456)
2
round(2.2456,-1)
0.0

$Comment$
不要将$舍入round$和$格式化format$输出搞混淆了。 如果我们目的只是简单的输出一定宽度的数，不需要使用 round() 函数。 而仅仅只需要在格式化的时候指定精度即可。

2. 执行一定精度的浮点数运算
   当使用浮点数进行精度运算，由于浮点数并不能精确的表示十进制数。所以即使是最简单的数学运算也会产生小的误差。但我们仍可以在一定精度内求解

有函数
$f(x)=x^5-15x^4+85x^3-225x^2+274x-121$
已知f(1.5)>0,f(2.4)<0，且在[1.5,2.4]区间只且只有一个根，求该根。要求四舍五入到小数点后6位
输出格式:该方程在[1.5,2.4]区间的根,精确到小数点后6位

def f(x):   # 封装 高次方程带入求值 的函数
    result = pow(x, 5) - 15 * pow(x, 4) + 85 * pow(x, 3) - 225 * pow(x, 2) + 274 * x - 121
    return result

a = 1.5
b = 2.4
c = (a + b) / 2          # 浮点型不可能完全等于零
while abs(f(c)) > 1e-6:  # 所以为了判断需要，根据题目一个范围1e-6，即10的-6次方
    if f(a) * f(c) < 0:  # 若abs(f(c))精度超过6时的值，都当作等于0；
        b = c            # 通过二分法计算、缩减范围
    else:
        a = c
    c = (a + b) / 2
print("{:.6f}".format(c))

此处，因为二分法的得到的一个值恰巧为根的可能性极小，但我们可以限定解的精度。
此处while abs(f(c)) > 1e-6的含义为：

• 当 abs(f(c)) <= $10^{-6}$时while循环停止，即将此后abs(f(c))的值都看作0
• 当abs(f(c))的小数点精度<6，始终大于 $10^{-6}$，所以此判定方法即限定abs(f(c))值的精度
• 高于此精度的值都看作0

三、无穷大与NaN

Python并没有特殊的语法来表示这些特殊的浮点值，但是可以使用 float() 来创建它们。

import math
print( float('inf') )  # inf
print( float('-inf') ) # -inf
print( float('nan') )  # nan
 
a = float('inf')
print( math.isinf(a) ) # true
 
# 无穷大数在执行数学计算的时候会传播
print( a+45 ) # inf

四、函数的参数传递

1. def 保留字 定义一个函数

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

• 定义函数时，有些参数存在默认值，即部分参数不一定需要调用程序输入，可以在定义函数时直接为这些参数指定默认值。，若函数调用时，没有传入对应的参数值，即使用函数定义时的默认值替代。

>>>def dup(str,times = 2):
	print(str * times)
>>>dup('knock~')
knock~knock~
>>>dup('knock~', 4)
knock~knock~knock~knock~

• 由于函数调用时需要按顺序输入参数，可选参数必须定义在非可选参数的后面。在参数前增加一个*号可以设计其为可变参数

# 在参数名前面的*表示b是一个可变参数
>>>def vfunc(a, *b):
	print(type(b))
	for n in b:
	a += n
	return a
>>>vfunc(1,2,3,4,5)
<class 'tuple'>
15

2. lambda函数——匿名函数
   用于定义简单的，能在够在一行内表示的函数

<函数名> = lambda <参数列表> : <表达式>

五、改变Python递归深度

import sys
sys.setrecursionlimit(2000)  # 2000是新的递归层数

六、序列封包 / 解包

1. 序列封包
   把多个值赋给一个变量时，Python会自动的把多个值封装成元组，称为序列封包。

>>>a = 1,2,3
>>>print(a)
(1,2,3)
>>>type(a)
<class 'tuple'>

2. 序列解包

• 把一个序列（列表、元组、字符串等）直接赋给多个变量，此时会把序列中的各个元素依次赋值给每个变量，但是元素的个数需要和变量个数相同，这称为序列解包。

>>>b = 'qwer'         # 创建一个元组
>>>c = tuple(b)
>>>print (c,type(c))    # 打印 ('q', 'w', 'e', 'r') <class 'tuple'> 
k1,k2,k3 = c
# 元素个数与变量个数不相等时，解包会报错：ValueError: too many values to unpack (expected 3) 

>>>k1,k2,k3,k4 = c    # 序列解包
>>>print (k1,k2,k3,k4)
q w e r

# 实现变量的值交换
>>>k1,k2,k3,k4 = k4,k3,k2,k1
>>>print (k1,k2,k3,k4)   
r e w q

 # 不解包进行变量的值交换将会报错
tyui = 1,2,3,4
t,y,u,i = i,u,y,t
NameError: name 'y' is not defined

• 在序列解包时，只想解出部分元素时，可以在变量的左边加*，该变量就会变成列表，保存多个元素

a = tuple(range(10))
print(a)    # 打印 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
 
# 只解出0到2，3到9保存为一个列表
b0,b1,b2,*b3 = a
print (b3)    # 打印 [3, 4, 5, 6, 7, 8, 9]
 
# 只解出8到9，0到7保存为一个列表
*c1,c2,c3 = a
print (c1)    # 打印 [0, 1, 2, 3, 4, 5, 6, 7]
 
# 只解出0和9，1到7保存为一个列表
c1,*c2,c3 = a
print(c2)    # 打印 [1, 2, 3, 4, 5, 6, 7, 8]

七、代码多行书写（语句分割符）

• 如果使用语法括号对，语句可以横跨数行
  如果在封闭的(),{},[]这类配对括号中编写代码，那么Python允许直接在下一行继续输入语句，直到Python解释器到达你输入闭合括号所在的行，语句才会结束。
• 如果语句以反斜杠\结尾，就可以横跨数行。
• 字符串字面量有特殊规则
  三重引号字符串块可以横跨数行。
• 其他规则