【Python】基础（学习笔记）,w30hd（python教程 w3school）

文件名：【Python】基础（学习笔记）,w30hd 【Python】基础（学习笔记） 一、Python介绍 1、Python优点

学习成本低

开源

适应⼈群⼴泛

应⽤领域⼴泛

2、Python解释器

Python解释器作用：运行Python文件

Python解释器分类

CPython：C语⾔开发的解释器[官⽅]，应⽤⼴泛的解释器。

IPython：基于CPython的⼀种交互式解释器。

PyPy：基于Python语⾔开发的解释器。

Jython：运⾏在Java平台的解释器，直接把Python代码编译成Java字节码执⾏。

IronPython：运⾏在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

3、PyCharm

PyCharm是⼀种Python IDE（集成开发环境）

1）PyCharm新建⽂件

项⽬管理空⽩位置 — 右键 – New – PythonFile

2）运⾏⽂件

代码内部 — 右键 – Run

3）修改代码⽂字格式

[fifile] – [Settings]/[Default Settings] – [Editor] – [Font]

4）Debug⼯具

断点位置：⽬标要调试的代码块的第⼀⾏代码即可，即⼀个断点即可。

打断点的⽅法：单击⽬标代码的⾏号右侧空⽩位置，在⽂件内部任意位置 — 右键 – Debug’⽂件名’ — 即可调出Debug⼯具⾯板 – 单击StepOver/F8，即可按步执⾏代码。

Debug输出⾯板： Debugger显示变量和变量的细节 Console：输出内容

4、查看python版本

cmd --> Python3 -V

二、Python基础语法 1、编码

Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串

2、标识符 第一个字符必须是字母表中字母或下划线 _标识符的其他的部分由字母、数字和下划线组成标识符对大小写敏感可以用中文作为变量名 3、保留字

保留字即关键字，我们不能把它们用作任何标识符名称。

Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字

>>> import keyword>>> keyword.kwlist['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'] 4、注释

Python中单行注释以 # 开头

# 第一个注释print ("Hello, Python!") # 第二个注释

多行注释可以用多个 #号，还有 ''' 和 """

# 第一个注释# 第二个注释'''第三注释第四注释'''"""第五注释第六注释""" 5、行与缩进

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数

6、多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句

total = item_one + \item_two + \item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \

total = ['item_one', 'item_two', 'item_three','item_four', 'item_five'] 7、空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

空行也是程序代码的一部分。

8、同一行显示多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割

name = 'wmh'; print(name) 9、多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)

10、print 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""

x="a"y="b"# 换行输出print( x )print( y )print('---------')# 不换行输出print( x, end=" " )print( y, end=" " )print() 11、import 与 from…import

在 python 用 import 或者 from...import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule从某个模块中导入某个函数,格式为： from somemodule import somefunction从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc将某个模块中的全部函数导入，格式为： from somemodule import * 三、数据类型 1、赋值

Python 中的变量不需要声明。但每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

一个变量可以通过赋值指向不同类型的对象。

等号（=）用来给变量赋值。

a = 'wmh'print(a)

Python允许你同时为多个变量赋值

a = b = c = 1

可以为多个对象指定多个变量

a, b, c = 1, 2, "runoob"

交换两变量的值

a,b = b,a 2、标准数据类型 Number（数字）String（字符串）List（列表）Tuple（元组）Set（集合）Dictionary（字典）

**不可变数据（3 个）：**Number（数字）、String（字符串）、Tuple（元组）

**可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）

3、Number（数字）

Python3 支持 int、float、bool、complex（复数）

整型(int)：不分正负但不带小数点。Python3 整型是没有限制大小的，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。浮点型(float)：浮点型由整数部分与小数部分组成，可以用科学计数法表示（2.5e2 = 2.5 x 102 = 250）复数(complex)：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， a和b都是浮点型。

可以用十六进制和八进制来代表整数

>>> number = 0xA0F# 十六进制>>> number2575>>> number=0o37 # 八进制>>> number31

内置的 type() 函数可以用来查询变量所指的对象类型

>>> a, b, c, d = 20, 5.5, True, 4+3j>>> print(type(a), type(b), type(c), type(d))<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

可以用 isinstance 来判断

>>> a = 111>>> isinstance(a, int)True

sinstance 和 type 的区别在于：

type()不会认为子类是一种父类类型isinstance()会认为子类是一种父类类型

Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加，True==1、False==0会返回 True，但可以通过 is 来判断类型。

issubclass(bool, int) # TrueTrue==1# TrueFalse==0# TrueTrue+1# 2False+1# 11 is True# False0 is False# False

del语句删除单个或多个对象

del vardel var_a, var_b

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

在交互模式中，最后被输出的表达式结果被赋值给变量 _

类似于jQuery中的$

>>> 1 + 23>>> _3 4、String（字符串）

字符串：单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

变量[头下标:尾下标:步长]# 字符串分片(左闭右开)

索引值：从左往右以0开始，从右往左以-1开始

用+运算符连接在一起，用*运算符重复

print (str * 2) # 输出字符串两次，也可以写成 print (2 * str)print (str + "TEST") # 连接字符串

使用反斜杠 \ 转义特殊字符

\r：回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成

>>> print('google runoob taobao\r123456')123456 runoob taobao

在字符串前面添加一个 r，表示原始字符串

>>> print('Ru\noob')Ruoob>>> print(r'Ru\noob')Ru\noob

反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

字符串格式化输出

print ("我叫 %s 今年 %d 岁!" % ('小明', 10)) 符号描述%c格式化字符及其ASCII码%s格式化字符串%d格式化整数%f格式化浮点数字，可指定小数点后的精度

f-string输出

>>> name = 'Runoob'>>> f'Hello {name}' # 替换变量'Hello Runoob'>>> x = 1>>> print(f'{x+1=}') # Python 3.8x+1=2

Python 没有单独的字符类型，一个字符就是长度为1的字符串。

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，word[0] = 'm'会导致错误。

5、List（列表）

列表中元素的类型可以不相同，它支持数字，字符串与列表嵌套

列表写在方括号 [] 之间、用逗号分隔开的元素列表

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

变量[头下标:尾下标:步长]# 列表分片

索引值：从左往右以0开始，从右往左以-1开始

用+运算符连接在一起，用*运算符重复

列表中的元素是可以改变的

删除列表元素：del list[2]

列表比较

import operatora = [1, 2]b = [2, 3]c = [2, 3]print("operator.eq(a,b): ", operator.eq(a,b))# Falseprint("operator.eq(c,b): ", operator.eq(c,b))# True 6、Tuple（元组）

与列表类似，不同之处在于元组的元素不能修改。

所谓元组的不可变指的是元组所指向的内存中的内容不可变

重新赋值的元组变量，绑定到了新的对象，不是修改了原来的对象了

元组写在小括号 () 里，元素之间用逗号隔开

元组也可以被索引和切片，也可以使用+操作符进行拼接

可以把字符串看作一种特殊的元组

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则

tup1 = () # 空元组tup2 = (20,) # 一个元素，需要在元素后添加逗号

string、list 和 tuple 都属于 sequence（序列）

7、Set（集合）

集合（set）：由一个或数个形态各异的大小整体组成的

构成集合的事物或对象称作元素或是成员

基本功能：进行成员关系测试和删除重复元素

可以使用大括号 { } 或者 set() 函数创建集合

创建一个空集合必须用 set() ，因为 { } 是用来创建一个空字典

parame = {value01,value02,...}set(value)sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}print(sites) # 输出集合，重复的元素被自动去掉# 成员测试if 'Runoob' in sites :print('Runoob 在集合中')else :print('Runoob 不在集合中')# set可以进行集合运算a = set('abracadabra')b = set('alacazam')print(a - b) # a 和 b 的差集{'r', 'b', 'd'}print(a | b) # a 和 b 的并集{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}print(a & b) # a 和 b 的交集{'c', 'a'}print(a ^ b) # a 和 b 中不同时存在的元素{'z', 'b', 'm', 'r', 'l', 'd'} 1）添加元素

添加元素：s.add( x )

添加元素、列表、元组、字典：s.update( x )

x 可以有多个，用逗号分开

2）移除元素

不存在报错：s.remove( x )

不存在不报错：s.discard( x )

随机删一个：s.pop()

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除

3）其他操作

计算集合元素个数：len(s)

清空集合：s.clear()

判断元素是否在集合中存在：x in s

8、Dictionary（字典）

列表是有序的对象集合，字典是无序的对象集合 两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

在同一个字典中，键(key)必须是唯一的。

创建时如果同一个键被赋值两次，后一个值为准

注：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict

dict = {}dict['one'] = "123"dict[2] = "456"print (dict['one'])# 输出键为 'one' 的值print (dict[2])# 输出键为 2 的值print (dict) # 输出完整的字典print (dict.keys()) # 输出所有键print (dict.values()) # 输出所有值

创建空字典使用 {}

修改字典

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}tinydict['Age'] = 8# 更新 Agetinydict['School'] = "No.1"# 添加信息 9、隐式类型转换

较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失

10、显式类型转换

int() 强制转换为整型

x = int(1) # x 输出结果为 1y = int(2.8) # y 输出结果为 2z = int("3") # z 输出结果为 3

float() 强制转换为浮点型

x = float(1) # x 输出结果为 1.0y = float(2.8) # y 输出结果为 2.8z = float("3") # z 输出结果为 3.0w = float("4.2") # w 输出结果为 4.2

str() 强制转换为字符串类型

x = str("s1") # x 输出结果为 's1'y = str(2) # y 输出结果为 '2'z = str(3.0) # z 输出结果为 '3.0' 函数描述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)将一个整数转换为一个八进制字符串 四、推导式 1、什么是推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体

列表(list)推导式字典(dict)推导式集合(set)推导式元组(tuple)推导式 2、列表推导式 [表达式 for 变量 in 列表] [out_exp_res for out_exp in input_list][表达式 for 变量 in 列表 if 条件][out_exp_res for out_exp in input_list if condition] out_exp_res：列表生成元素表达式，可以是有返回值的函数。for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。if condition：条件语句，可以过滤列表中不符合条件的值。

过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母

>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']>>> new_names = [name.upper() for name in names if len(name)>3]>>> print(new_names)['ALICE', 'JERRY', 'WENDY', 'SMITH']

计算 30 以内可以被 3 整除的整数

>>> multiples = [i for i in range(30) if i % 3 == 0]>>> print(multiples)[0, 3, 6, 9, 12, 15, 18, 21, 24, 27] 3、字典推导式 { key_expr: value_expr for value in collection }{ key_expr: value_expr for value in collection if condition }

提供三个数字，以三个数字为键，三个数字的平方为值来创建字典

>>> dic = {x: x**2 for x in (2, 4, 6)}>>> dic{2: 4, 4: 16, 6: 36} 4、集合推导式 { expression for item in Sequence }{ expression for item in Sequence if conditional }

判断不是 abc 的字母并输出

>>> a = {x for x in 'abracadabra' if x not in 'abc'}>>> a{'d', 'r'}>>> type(a)<class 'set'> 5、元组推导式 (expression for item in Sequence )或(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []

元组推导式返回的结果是一个生成器对象

>>> a = (x for x in range(1,10))>>> a<generator object <genexpr> at 0x7faf6ee20a50> # 返回的是生成器对象>>> tuple(a) # 使用 tuple() 函数，可以直接将生成器对象转换成元组(1, 2, 3, 4, 5, 6, 7, 8, 9) 五、运算符 1、算数运算符 运算符说明+加 - 两个对象相加-减 - 得到负数或是一个数减去另一个数*乘 - 两个数相乘或是返回一个被重复若干次的字符串/除 - x 除以 y%取模 - 返回除法的余数**幂 - 返回x的y次幂//取整除 - 向下取接近商的整数 2、比较运算符 运算符描述实例==等于 - 比较对象是否相等(a == b) 返回 False。!=不等于 - 比较两个对象是否不相等(a != b) 返回 True。>大于 - 返回x是否大于y(a > b) 返回 False。<小于 - 返回x是否小于y。(a < b) 返回 True。>=大于等于 - 返回x是否大于等于y。(a >= b) 返回 False。<=小于等于 - 返回x是否小于等于y。(a <= b) 返回 True。

所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。

3、赋值运算符 运算符描述实例=赋值运算符c = a + b 将 a + b 的运算结果赋值为 c+=加法赋值运算符c += a 等效于 c = c + a-=减法赋值运算符c -= a 等效于 c = c - a*=乘法赋值运算符c *= a 等效于 c = c * a/=除法赋值运算符c /= a 等效于 c = c / a%=取模赋值运算符c %= a 等效于 c = c % a**=幂赋值运算符c **= a 等效于 c = c ** a//=取整除赋值运算符c //= a 等效于 c = c // a

:= 海象运算符

可在表达式内部为变量赋值。（Python3.8 版本新增运算符）

List = ['r','e','x','h','a','o']for i in range(Len := len(List)):print(List[i],end="")# rexhao 4、位运算符（摆烂） 运算符描述实例&按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0(a & b) 输出结果 12 ，二进制解释： 0000 1100|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。(a | b) 输出结果 61 ，二进制解释： 0011 1101^按位异或运算符：当两对应的二进位相异时，结果为1(a ^ b) 输出结果 49 ，二进制解释： 0011 0001~按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。<<左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。a << 2 输出结果 240 ，二进制解释： 1111 0000>>右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数a >> 2 输出结果 15 ，二进制解释： 0000 1111 5、逻辑运算符 运算符逻辑表达式描述实例andx and y布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。(a and b) 返回 20。orx or y布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。(a or b) 返回 10。notnot x布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。not(a and b) 返回 False 6、成员运算符 运算符描述实例in如果在指定的序列中找到值返回 True，否则返回 False。x 在 y 序列中 , 如果 x 在 y 序列中返回 True。not in如果在指定的序列中没有找到值返回 True，否则返回 False。x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 7、身份运算符 运算符描述实例isis 是判断两个标识符是不是引用自一个对象x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 Falseis notis not 是判断两个标识符是不是引用自不同对象x is not y ， 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

id()：获取对象内存地址。

is 与 == 区别：is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

8、运算符优先级 运算符描述(expressions...),[expressions...], {key: value...}, {expressions...}圆括号的表达式x[index], x[index:index], x(arguments...), x.attribute读取，切片，调用，属性引用await xawait 表达式**乘方(指数)+x, -x, ~x正，负，按位非 NOT*, @, /, //, %乘，矩阵乘，除，整除，取余+, -加和减<<, >>移位&按位与 AND^按位异或 XOR``in,not in, is,is not, <, <=, >, >=, !=, ==比较运算，包括成员检测和标识号检测not x逻辑非 NOTand逻辑与 ANDor逻辑或 ORif -- else条件表达式lambdalambda 表达式:=赋值表达式

Pyhton3 已不支持 <> 运算符

六、分支 1、if

Python 中用 elif 代替了 else if，所以if语句的关键字为：if - elif - else

使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

在Python中没有switch – case语句。

2、while

在 Python 中没有 do…while 循环

使用 CTRL+C 来退出死循环

支持while - else语句，break跳出不执行else

3、for

for 循环用来遍历任何可迭代对象

break 语句用于跳出当前循环体

range(起始值, 结束值, 步长)：创建数字序列

4、pass

pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句（空着会报错）

5、迭代器 1）迭代器概述

迭代：用来访问集合（字符串，列表或元组对象）元素

迭代器：一个可以记住遍历的位置的对象

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束（只能往前不会后退）

迭代器的两个基本的方法：iter() 和 next()

list=[1,2,3,4]it1 = iter(list) # 创建迭代器对象print (next(it1)) # 输出迭代器的下一个元素# 1it2 = iter(list) # 创建迭代器对象for x in it2:print (x, end="")# 1234 2）迭代器创建

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__()

__iter__() 返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 并通过 StopIteration 异常标识迭代的完成

__next__() 会返回下一个迭代器对象

创建一个返回数字的迭代器，初始值为 1，逐步递增 1

class MyNumbers:def __iter__(self):self.a = 1return selfdef __next__(self):x = self.aself.a += 1return xmyclass = MyNumbers()myiter = iter(myclass)print(next(myiter)) 3）StopIteration

StopIteration 异常用于标识迭代的完成，防止出现死循环

import sys # 引入 sys 模块list=[1,2,3,4]it = iter(list) # 创建迭代器对象while True:try:print (next(it))except StopIteration:sys.exit()

在__next__()方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代

class MyNumbers:def __iter__(self):self.a = 1return selfdef __next__(self):if self.a <= 20:x = self.aself.a += 1return xelse:raise StopIterationmyclass = MyNumbers()myiter = iter(myclass)for x in myiter:print(x) 6、生成器

生成器：使用了 yield 的函数

生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行

# 使用 yield 实现斐波那契数列import sysdef fibonacci(n): # 生成器函数 - 斐波那契a, b, counter = 0, 1, 0while True:if (counter > n): returnyield aa, b = b, a + bcounter += 1f = fibonacci(10) # f 是一个迭代器，由生成器返回生成while True:try:print (next(f), end=" ")except StopIteration:sys.exit() 七、函数 1、定义函数 def 函数名（参数列表）:函数体

return [表达式] ：结束函数，选择性地返回一个值给调用方 不带表达式的 return 相当于返回 None

2、传参 1）值传递和引用传递

类型属于对象，对象有不同类型的区分，变量是没有类型的

**不可变类型：**类似 C++ 的值传递，如整数、字符串、元组。**可变类型：**类似 C++ 的引用传递，如 列表、字典。

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象

2）必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

3）关键字参数

关键字参数允许函数调用时参数的顺序与声明时不一致，解释器能够用参数名匹配参数值

def printinfo( name, age ):print ("名字: ", name)print ("年龄: ", age)returnprintinfo( age=50, name="wmh" ) 4）默认参数

调用函数时，如果没有传递参数，则会使用默认参数

def printinfo( name, age = 35 ):print ("名字: ", name)print ("年龄: ", age)returnprintinfo( name="wmh" ) 5）不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。

def functionname([formal_args,] *var_args_tuple ):function_suitereturn [expression]

星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数

def printinfo( arg1, *vartuple ):print (arg1)print (vartuple)returnprintinfo( 70, 60, 50 )# 70# (60, 50)

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

def printinfo( arg1, **vardict ):print ("输出: ")print (arg1)print (vardict)returnprintinfo(1, a=2,b=3)# 1# {'a': 2, 'b': 3}

参数中星号 * 可以单独出现

def f(a,b,*,c):return a+b+cf(1,2,3) # 报错f(1,2,c=3) # 正常 3、匿名函数

使用 lambda 来创建匿名函数

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数

虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率

lambda [arg1 [,arg2,.....argn]]:expression sum = lambda a,b: a + bsum(1,2)# 3 4、强制位置参数

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

def f(a, b, /, c, d, *, e, f):print(a, b, c, d, e, f)returnf(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 必须使用关键字参数的形式