Python 编程笔记（小白初学篇）

教程：https://www.runoob.com/python3/python3-tutorial.html

一、准备工作

1. 下载安装

好用博客：https://blog.csdn.net/yugemiren/article/details/104866397
官网：https://www.python.org
正如博客所言，下载一个低版本的就行。很快的。

2. 实现快捷键清屏

当然，这里指的是windows，Python 并没有自带清屏快捷键，网上这招也许是大佬自己搞出来的。有很多文章都讲如何操作的，操作方法大同小异，本质上都是一样的，这里挑了个简洁的，链接如下：

https://www.cnblogs.com/ningmengcaokanyu/p/10297840.html
大致分为这几步：
1.在PythonLibidlelib下，新建一个ClearWindow.py文件（没有时就新建）
2.PythonLibidlelib下修改config-extensions.def ，在末尾添加如下内容

关于第二步，若改不了的话，可以以管理员的身份打开powershell，然后输入 notepad xxPythonLibidlelibconfig-extensions.def 进行修改，之后保存。

---

这块先当草稿存着

import os   #从标准库导入os模块  
os.chdir('F:HeadFirstPythonchapter3')
#切换到包含数据文件的文件夹

C:>python he11o.py  #windows下执行python脚本
$ python he11o.py    #Linux 下执行python脚本
#!/usr/bin/env python 
#Linux 下，上面那行放xx.py首行，即可像.sh脚本执行

## 分解字符串 ##
import re   #正则表达式的包
list=re.split(r'[;,s]s*', line)   #不含分隔符
list=re.split(r'(;|,|s)s*', line) #包含分隔符
import os; os.chdir(r'C:UsersOHanlonDocumentspython')
#设置当前路径
import os; os.getcwd()   #打印当前路径

*["seven", 18, 'alex'] # *作用是将列表解开成独立的参数。
**{'a' : 4, 'b' : 3}   # **作用是将字典解开成独立的元素。

---

二、基础知识

1. 快应用

这部分记录一下常用的符号，命令，函数..反正就是几个汇总的表格，方便以后快速使用。

常用符号及含义

符号	含义	符号	含义
'	字符串	"	字符串
	转义		续行符（在行尾时）
+	加	-	减
*	乘	/	除
**	幂乘	//	整除
%	取模	=	赋值
+=	加法赋值	-=	减法赋值
*=	乘法赋值	/=	除法赋值
%=	取模赋值	//=	整除赋值
**=	幂乘赋值
!=	不等？	==	相等？
<	小于？	>	大于？
<=	小于等于？	>=	大于等于？
&	位与	`	`
^	位异或	~	位取反
<<	左移	>>	右移
and	布尔与	or	布尔或
not	布尔非	in	在里面？
not in	不在里面？	is	引用的同一对象？
is not	引用不同对象？
常用函数及含义

import math

函数	含义	函数	含义
pow(a, n)	a 的 n 次方	abs(a)	a 的绝对值
round(a)	a 四舍五入	int(a)	a 转换为整数
math.ceil(a)	a 上入整数	long(a)	a 转换为长整数
math.floor(a)	a 下舍整数	float(a)	a 转换为浮点数
input()	获取输入	str(a)	a 转换为字符串
raw_input()	获取输入，返回字符串	repr(object)	返回值的字符串表示形式
range(start, stop[, step])	计数从 start 开始。默认是从 0 开始。	计数到 stop 结束，但不包括 stop。	步长，默认为1。
math.sqrt(a)	a 开根号	cmath.sqrt(a)	a 复数开根号
math.exp(a)	e的a次幂	math.fabs(a)	a 的绝对值
math.log10(a)	以10为基数的a的对数	math.log(a)	以e为基数的a的对数
max(a1,a2,a3...)	返回给定参数(可为序列)的最大值	min(a1,a2,a3...)	返回给定参数的最小值
math.modf(a)	返回x的整数部分与小数部分，	两部分的数值符号与x相同，	整数部分以浮点型表示。
acos(x)	反余弦弧度	asin(x)	反正弦弧度
atan(x)	反正切弧度	atan2(y,x)	y/x的反正切
cos(x)	弧度的余弦	sin(x)	弧度的正弦
tan(x)	弧度的正切	hypot(x,y)	欧几里德范数 sqrt(x*x + y*y)
degrees(x)	弧度转角度	radians(x)	角度转弧度
math.pi	圆周率	math.e	数学常量e
随机数函数

import random

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

---

python 的格式化输出
这块之所以放在这里而不放在下面，是因为这个比较常用，而且都是表格。

---

这块参考：https://www.cnblogs.com/panwenbin-logs/p/10813950.html

Python的字符串格式化有两种方式: %方式、format方式。百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存。
1 %方式

%[(name)][flags][width].[precision]typecode

• (name) 【可选】用于选择指定的key
• flags【可选】可供选择的值有:

flags	含义

• | 右对齐；正数前加正好，负数前加负号；

• | 左对齐；正数前无符号，负数前加负号；
  空格 | 右对齐；正数前加空格，负数前加负号；
  0 | 右对齐；正数前无符号，负数前加负号；用0填充空白处

• width 【可选】占有宽度，默认有多长占多长

• .precision 【可选】小数点后保留的位数

• typecode 【必选】

typecode	含义
s	获取传入对象的__str__方法的返回值，并将其格式化到指定位置
r	获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
c	整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
o	将整数转换成 八 进制表示，并将其格式化到指定位置
x	将整数转换成十六进制表示，并将其格式化到指定位置
d	将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
e	将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
E	将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
f	将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
F	同上
g	自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
G	自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
%	当字符串中存在格式化标志时，需要用 %%表示一个百分号
下面整几个例子：

>>> print("I am %s" % "Alex")
I am Alex
>>> print("I am %s age %d" % ("Alex", 18))
I am Alex age 18
>>> print("I am %(name)s age %(age)d" % {"name": "Alex", "age": 18})
I am Alex age 18
>>> print("percent %.2f" % 99.97623)
percent 99.98
>>> print("I am %(pp).2f %%" % {"pp": 123.425556, })
I am 123.43 %

2 format 方式

[[fill]align][sign][#][0][width][,][.precision][type]

• fill 【可选】空白处填充的字符
• align 【可选】对齐方式（需配合width使用）

align	含义
<	内容左对齐

|内容右对齐(默认)
＝|内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
^|内容居中

• sign 【可选】有无符号数字

align	含义
+	正号加正，负号加负；
-	正号不变，负号加负；
空格	正号空格，负号加负；

• # 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
• , 【可选】为数字添加分隔符，如：1,000,000
• width 【可选】格式化位所占宽度
• .precision 【可选】小数位保留精度
• type 【可选】格式化类型

传入参数类型	type
传入” 字符串类型 “的参数	s，格式化字符串类型数据 空白，未指定类型，则默认是None，同s
传入“ 整数类型 ”的参数	b，将10进制整数自动转换成2进制表示然后格式化 c，将10进制整数自动转换为其对应的unicode字符 d，十进制整数 o，将10进制整数自动转换成8进制表示然后格式化； x，将10进制整数自动转换成16进制表示然后格式化（小写x） X，将10进制整数自动转换成16进制表示然后格式化（大写X）
传入“ 浮点型或小数类型 ”的参数	e， 转换为科学计数法（小写e）表示，然后格式化； E， 转换为科学计数法（大写E）表示，然后格式化; f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化； F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化； g， 自动在e和f中切换 G， 自动在E和F中切换 %，显示百分比（默认显示小数点后6位）

下面整几个例子：

>>> "I am {}, age {}, {}".format("seven", 18, 'Alex')
'I am seven, age 18, Alex'
>>> "I am {0}, age {1}, really {0}".format(*["seven", 18])
'I am seven, age 18, really seven'
>>> "I am {name}, age {age}, really {name}".format(name="seven", age=18)
'I am seven, age 18, really seven'
>>> "I am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
'I am seven, age 18, really seven'
>>> "I am {0[0]}, age {1[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
'I am 1, age 22, really 3'
>>> "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
'numbers: 1111,17,15,f,F, 1587.623000%'
>>> "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
'numbers: 1111,17,15,f,F, 1500.000000%'
>>> "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)
'numbers: 1111,17,15,f,F, 1500.000000%'

数据类型转换

函数	描述
int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

2. 输入输出

python 简单的输入输出如下：

>>> a=input('please input the value of a: ')
please input the value of a: 12
>>> print(a)
12

当你想知道一个变量的值是多少时，可能会对它是整型还是长整型感兴趣。这可以通过两种机制来实现，实际上是值被转换为字符串的两种机制。可以通过以下两个函数来使用这两种机制:一是通过str函数，它会把值转换为合理形式的字符串，以便用户可以理解，而repr会创建一个字符串，它以合法的Python表达式的形式来表示值。下面是一些例子

>>> 'hello world!'
'hello world!'
>>> print('hello world!')
hello world!
>>> print(repr('hello world!'))
'hello world!'
>>> print(str('hello world!'))
hello world!

关于两个input (input 和 raw_input) ，假设有这样一个脚本：

name = input( "what is your name? ")
print "He11o. " + name + " !"
------------------
What is your name? "Gumby"  
#输入需加引号，用raw_input()则不需
He11o. Gumby!
++++++++++++++++++++++++++++
>>input( "Enter a number: ")Enter a number: 3
3
>>>raw_input( "Enter a number: ")Enter a number: 3
'3'

raw_input 会把所有数据当作原始输入存放在字符串中。也就是说，使用这俩input的时候，可以按照如下规则：input 对值进行操作，raw_input 对字符串进行操作。

'''跨行书写字符串，当然最后也得用'''将其引起来。普通字符串也可以跨行（换行的时候加个）。如果一行之中最后一个字符是反斜线，那么，换行符本身就“转义”了，也就是被忽略了。

>>> print('C:
owhere')
C:
owhere
>>> print(r'C:
owhere')
C:
owhere

原始字符串，其最后一个字符不可以是反斜杠
格式化输出见上面。

3. 数据类型

Python基本数据类型一般分为：数字、字符串、列表、元组、字典、集合这六种基本数据类型。

• [ ] 数字；数字类型是不可更改的对象。对变量改变数字值就是生成/创建新的对象。Python支持多种数字类型：整型(标准整型和长整型(Python2.7及之前的有这种类型))、布尔型、双精度浮点型、十进制浮点型、复数。

• 标准整型：int，在大多数32位机器上标准整型取值范围是 (-2^{31}) 到 (2^{31}-1)，也就是-2147483648~2147483647，如果在64位机器使用64位编译器，那么这个系统的标准整型将是64位。

• 布尔型：bool，从 Python2.3 开始 Python 中添加了布尔类型。布尔类型有两种 True 和 False。对于没有__nozero__方法的对象默认是True。对于值为0的数字、空集（空列表、空元组、空字典等）在Python中的布尔类型中都是False。

• 浮点型：float，每个浮点型占8个字节（64位），完全遵守IEEE754号规范（52M/11E/1S）,其中52个位用于表示底，11个位用于表示指数（可表示的范围大约是 (±10^{308.25})），剩下的一个位表示符号。这看上去相当完美，然而，实际精度依赖于机器架构和创建Python解释器的编译器。浮点型值通常都有一个小数点和一个可选的后缀e（大写或小写，表示科学计数法）。在e和指数之间可以用正（+）或负（-）表示指数的正负（正数的话可以省略符号）。经过Python实测浮点型默认长度是24字节。

• 复数类型：complex 在复数中虚数不能单独存在，它们总是和一个值为0.0的实数部分一起来构成一个复数。复数由实数部分和虚数部分构成。表示虚数的语法：real+imagj。实数部分和虚数部分都是浮点型。虚数部分必须有后缀j或J。

• [ ] 字符串：string 是不可变类型，就是说改变一个字符串的元素需要新建一个新的字符串。字符串是由独立的字符组成的，并且这些字符可以通过切片操作顺序地访问。Python里面通过在引号间包含字符的方式创建字符串，单引号和双引号的作用是相同的。Python用“原始字符串”操作符来创建直接量字符串，所以再做区分就没什么意义了。其他的语言，比如C语言里面用单引号来标示字符，双引号标示字符串，而在Python里面没有字符这个类型。这可能是双引号和单引号在Python里面被视作一样的另一个原因。python 中字符串前缀有三种：有（无前缀，前缀u，前缀b），但是字符串的类型只有两种（str，bytes）无前缀，和前缀u 应该是一样的。

• [ ] 列表：list[] 像字符串类型一样，列表类型也是序列式的数据类型。字符串只能由字符组成，而且是不可变的（不能单独改变它的某个值），而列表则是能保留任意数目的Python对象的灵活的容器。列表不仅可以包含Python的标准类型，而且可以用用户定义的对象作为自己的元素。列表可以包含不同类型的对象，而且要比C或者Python自己的数组类型（包含在array扩展包中）都要灵活，因为数组类型所有的元素只能是一种类型。列表可以执行pop、sort、reverse等操作。列表也可以添加或者减少元素，还可以跟其他的列表结合或者把一个列表分成几个。可以对单独一个元素或者多个元素执行insert、update或remove操作。
  关于列表的正向反向索引和切片请看下图（来源于：https://www.runoob.com/）
  

• [ ] 元组类型：Tuple()在很多操作上都跟列表一样，许多用在列表上的例子在元组上照样能跑。它们的主要不同在于元组是不可变的，或者说是只读的，所以那些用于更新列表的操作，比如用切片操作来更新一部分元素的操作，就不能用于元组类型。

• [ ] 字典：Dictionary 是Python语言中唯一的映射类型。映射类型对象里哈希值（键，key） 和指向的对象（值。value） 是一对多的关系。一个字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也包括其他容器类型。字典类型和序列类型容器类（列表、元组） 的区别是存储和访问数据的方式不同。序列类型只用数字类型的键（从序列的开始起按数值顺序索引） 。映射类型可以用其他对象类型做键，一般最常见的是用字符串做键。和序列类型的键不同，映像类型的键直接或间接地和存储的数据值相关联。但因为在映射类型中，我们不再用“序列化排序”的键，所以映像类型中的数据是无序排列的映射类型不要求用数字值做索引以从一个容器中获取对应的数据项。你可以用键直接“映射”到值，这就是为什么叫映射类型（“mappingtype”） 的原因。映射类型通常被称做哈希表，是因为字典对象就是哈希类型的。字典是Python中最强大的数据类型之一。
  字典常见的操作有：字典创建、字典赋值、字典中值的访问、字典更新、字典元素删除等操作。
  集合最早出现在Python2.3版本中，通过集合模块来创建，并通过ImmutableSet类和Set类进行访问。

• [ ] 集合：set{ }有两种不同的类型，可变集合（set）和不可变集合（frozenset）。可变集合，你可以添加和删除元素，对不可变集合则不允许这样做。请注意，可变集合不是可哈希的，因此既不能用做字典的键也不能做其他集合中的元素。不可变集合则正好相反，即，他们有哈希值，能被用做字典的键或是作为集合中的一个成员。集合对象是一组无序排列的可哈希的值。
  集合支持用in和not in操作符检查成员，由len()内建函数得到集合的基数（大小） ，用for循环迭代集合的成员。但是因为集合本身是无序的，你不可以为集合创建索引或执行切片（slice） 操作，也没有键可用来获取集合中元素的值。

a=10    #数字
str='I am a string'    #字符串
list1 = ['Google', 'Runoob', 1997, 2000]    #列表
tup1 = ('Google', 'Runoob', 1997, 2000)     #元组
dict2 = { 'abc': 123, 98.6: 37 }            #字典
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}    #集合

4. 条件与循环语句

Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。
1、条件判断 - if 语句

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

• Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。
• 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
• 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 在Python中没有switch – case语句。

2、循环语句 - while

while 判断条件(condition)：
    执行语句(statements)……

while … else ：在条件语句为 false 时执行 else 的语句块。

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

3、循环语句 - for

for <variable> in <sequence>:
    <statements>
else:
    <statements>

其他控制语句：

语句	含义
break	break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue	continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
pass	pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。

5. 关于文件

1、open函数用来打开文件，语法如下：open(name[, mode[, buffering]])
其使用文件名(name)作为一个强制参数，模式(mode)和缓冲(buffering)参数都是可选的。
1）open 函数中模式参数常用值

值	描述
'r'	读模式 ，默认参数
'x'	写模式，新建一个文件，如果该文件已存在则会报错。
'w'	写模式
'a'	追加模式
'b'	二进制模式（可添加到其他模式中使用）
'+'	读/写模式（可添加到其他模式中使用）
注：'b'模式改变处理文件的方法。一般来说，Python 假定处理的是文本文件（包含字符）。若要处理二进制文件，那么应该在模式参数中增加'b'，例如'rb'。
2）open函数的第3个参数（可选）控制着文件的缓冲。如果参数是0(或者是False)，IO(输入/输出）就是无缓冲的(所有的读写操作都直接针对硬盘)﹔如果是1(或者是True)，IO就是有缓冲的（意味着Python使用内存来代替硬盘，让程序更快，只有使用flush或者close时才会更新硬盘上的数据。大于1的数字代表缓冲区的大小(单位是字节)，-1(或者是任何负数）代表使用默认的缓冲区大小。

读写简单示例：

# write
f=open('somefile.txt','w')
f.write('Hello, ')
f.write('World!')
f.close();
-----------------------
# read
f=open('somefile.txt','r');
f.read(4)     #读取4个字符
f.read()      #读取剩下的字符
f.close()

2、seek 函数来随机访问，seek函数的一般用法为：seek(offset[, whence]) 这个方法把当前位置（进行读和写的位置）移动到由offset 定义的位置。
offset：从开始位置的偏移量，也就是代表需要移动偏移的字节数。
whence：给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。
tell()返回当前游标在文件中的位置。

3、读写行
file.readline() 读取单独的一行（从当前位置开始直到一个换行符出现，也读取这个换行符。file.readline(5) 读取这一行中前五个字符。file.readlines()读取一个文件中所有行并将其作为列表返回。

writelines方法和readlines相反:传给它一个字符串的列表(实际上任何序列或者可迭代的对象都行)，它会把所有的字符串写人文件（或流)。注意，程序不会增加新行，需要自己添加。没有writeline方法,因为能使用write。

6. 关于函数

定义一个函数的格式：

def 函数名（参数列表）:
    函数体
    return *

以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

关于在一个脚本中调用另一个脚本中的函数：

比如我想在脚本 c.py 中调用脚本 a.py 中的函数 fun_c，那么我需要在脚本c.py中from a import fun_c，前提是当前工作路径必须是a.py所在路径，更改工作路径的方式为：os.chdir(r'C:UsersOHanlonDocumentspython')
值得注意的一点，脚本运行之后，工作路径就变成了其所在路径。

关于参数传递

在 python 中，strings, tuples, 和 numbers 是不可更改(immutable)的对象，而 list,dict 等则是可以修改的(mutable)对象。

python 函数的参数传递：

• 不可变类型：类似 C++ 的值传递，如 整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a)）内部修改 a 的值，则是新生成来一个 a。

• 可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响。

关于函数参数

以下是调用函数时可使用的正式参数类型：必需参数、关键字参数、默认参数、不定长参数。

• 必需参数：必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
• 关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
  使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )

• 默认参数：调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：def printinfo( name, age = 35 ):
• 不定长参数
  你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：
  加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]
-----------------------------
#!/usr/bin/python3
 
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

加了两个星号 ** 的参数会以字典的形式导入。

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

声明函数时，参数中星号 * 可以单独出现，如果单独出现星号 * 后的参数必须用关键字传入。

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6

匿名函数
python 使用 lambda 来创建匿名函数。所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
• 语法，lambda 函数的语法只包含一个语句，如下：lambda [arg1 [,arg2,.....argn]]:expression

#!/usr/bin/python3
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

强制位置参数
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
-----------------------------
f(10, 20, 30, d=40, e=50, f=60)       # 正确
f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

7. 关于调试

1 在所需要调试的地方加入如下代码：

import pdb 
pdb.set_trace()

2 调试代码常用命令：

命令	含义
break / b	设置断点
command / c	继续执行程序
list / l	查看当前行的代码段
step / s	进入函数
return / r	执行代码直到从当前函数返回
exit / q	中止并退出
next / n	执行下一行
pp	打印变量的值
help	帮助