Python的语法笔记（一）

标准数据类型

不可变数据：Number（数字），String（字符串），Tuple（元组）

可变数据：List（列表），Dictionary（字典），Set（集合）

Number(数字)

python支持 int， float， bool， complex

a, b, c, d = 20, 5.6, false, 4+5j
print(tupe(a), tupe(b), tupe(c), tupe(d))

运算结果：<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

数值类型实例

int	float	complex
10	0.0	5+8j
-756	15.20	5j
080	-90.	9.23e-36j
0x52	70.2e-12 (e同E)	653+0j

可以使用del语句删除一些对象引用

var_1 = 1
var_2 = 2
del var_1, var_2 (var_1和var_2两个变量被删除)

数值运算

运算符	含义
+	加法 ，1+1=2
-	减法 ，8-5=3
*	乘法 ，4*5=20
/	除法，得到一个浮点数 2/4=0.5
//	除法，得到一个整数 2//4=0
%	取余数 5%4=4
**	乘方 2**3=8

数字类型的转换：

• int(x) 将x转换为一个整数。
• float(x) 将x转换到一个浮点数。
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

数学函数

(除开max, min和round，其余均要import math)

函数	描述
abs(x)	返回绝对值，如abs（-10）返回10
ceil(x)	返回上入整数，如math.ceil(4.1) 返回 5
floor(x)	返回下入整数，如math.floor（5.9）返回5
fabs(x)	返回浮点绝对值
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
sqrt(x)	返回数字x的平方根。
round(x[,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。

随机数函数

随机数参数的函数库 import random

函数	描述
choice(seq)	在指定序列中抽取，可以是字符串某个字母
random.randrange (start, stop, step)	在指定范围和步长内抽取
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(list)	将序列的所有元素随机排序,无返回值操作，支持可修改的list类型
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

String(字符串)

python中的字符串用单引号或双引号括起来，同时用反斜杠\转义特殊字符。

字符串的转义字符

Python 使用反斜杠\转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串,Python中的字符串不能改变。

print('Ru\noob')
Ru
oob
print(r'Ru\noob')
Ru\noob

字符串运算符

操作符	描述
+	字符串连接
*	重复输出字符串
[ ]	获取字符串中的字符
[ : ]	截取字符串的一部分，左开右闭
in	字符串中包含字符返回True
not in	字符串中不包含字符返回True
r 或者R	原始字符串打印

运算举例

a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
 
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
 
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")
 
print (r'\n')
print (R'\n')

运算结果：
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

Python字符串内建函数

函数	描述
capitalize()	字符串第一个字符转为大写，其余转小写。str2.capitalize()
center(width, fillchar)	返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。str.center(30, '*')
count(sub, start= 0,end=len(string))	搜索sub字符在字符串中出现的次数，cnt = str1.count('n', 0, len(str1))
endswith(suffix, start, end)	判断字符串是否以suffix字符结束，是则返回True，否则返回False。str1.endswith('b', 0, len(str1))
find(str, beg, end)	检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引位置序号，否则返回-1.str1.find('cxl', 0, len(str1))
isdigit	如果字符串所有字符都是数字则返回 True, 否则返回 False
isalpha	如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
isspace	如果字符串中只包含空白，则返回 True，否则返回 False.
len(string)	字符串长度
lower(), upper()	把大写转换为小写, 小写转大写
max(str), min(str)	返回字符串中最大，最小的字母
swapcase()	大写转小写，小写转大写，str.swapcase()

List(列表)

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。列表是写在方括号[ ] 之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。List的元素可以改变,可以运用在函数返回多个值的时候。

访问列表的内容

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
 
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表
print (list[0:4:2])     #第三个参数为设置步长为2
print (list[::-1])      #-1表示逆向读取

输出结果：
['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
['abcd', 2.23]
[70.2, 'runoob', 2.23, 786, 'abcd']

更新列表元素

修改列表元素：

list = ['Google', 'Runoob', 1997, 2000]

print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])

运算结果：
第三个元素为 :  1997
更新后的第三个元素为 :  2001

在列表中添加元素：

list = ['jack', 'lenna', 15, 28]
list.append('lucy')
print(list)

运算结果：
['jack', 'lenna', 15, 28, 'lucy']

删除列表中的元素：

使用del语句来删除
list = ['jack', 'lenna', 15, 28]

print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

运算结果：
原始列表 :  ['jack', 'lenna', 15, 28]
删除第三个元素 :  ['jack', 'lenna', 28]

Python列表操作符

Python表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6, 7]	[1, 2, 3, 4, 5, 6, 7]	组合
[1, 2] * 2	[1, 2, 1, 2]	重复
3 in [1, 2, 3]	True	存在判断
for x in [1, 2, 3]:print(x)	1 2 3	遍历

列表嵌套

可以理解为多维矩阵。

a = [1, 2, 3]
b = [4, 5, 6]
**理解为a和b加了转置，x是2*3的矩阵**
x = [a, b]
print(x)
print(x[0][1])

运算结果：
[[1, 2, 3], [4, 5, 6]]
2

Python列表的函数和方法

函数 or 方法	描述
len(list)	列表长度
max(list), min(list)	列表中的最大，最小元素
list(seq)
list.append(obj) , list.extend	前者是添加一个目标。后者是添加一个序列可以是列表，元组，集合，字典（键），
list,count(obj)	元组转化为列表
list.index(obj)	从列表中找出第一个匹配obj的索引位置
list.insert(index, obj)	插入对象obj到index位置前
list.pop(index)	移除index位置的元素，其中index默认为-1
list.remove(obj)	移除列表中第一个匹配obj的元素
list.reverse()	列表的所以元素倒置
list.sort(key=None, reverse=False)	对列表的元素排序，reverse=True为降序，reverse=False为降序。要求为同类型
list.clear(), list.copy()	清空，复制列表地址不同

Tuple(元组)

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开，元组中的元素类型也可以不相同，元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。

元组的定义及访问

特殊的包含0个或者1个元素的元组定义方法
tup1 = （）  #空元组
tup2 = （5，）  #一个元素后面需加逗号
tuple = ('abcd', 786, 2.23, 'runoob', 70.2)
tinytuple = (123, 'runoob')

print(tuple)  # 输出完整元组
print(tuple[0])  # 输出元组的第一个元素
print(tuple[1:3])  # 输出从第二个元素开始到第三个元素
print(tuple[2:])  # 输出从第三个元素开始的所有元素
print(tinytuple * 2)  # 输出两次元组
print(tuple + tinytuple)  # 连接元组
print(tuple[0:4:2])
print(tuple[::-1])

输出结果：
('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
('abcd', 2.23)
(70.2, 'runoob', 2.23, 786, 'abcd')

元组的删除

元组中的元素不允许删除，但可以通过del语句删除整个元组。

tup = ('Baidu', 'Google', 5, 8, 7)
print(tup)
del(tup)
print(tup)

运算结果：
NameError: name 'tup' is not defined
('Baidu', 'Google', 5, 8, 7)

#####　元组运算符

表达式	描述
len((58, 69, 77, 92))	4, 计算元素个数
(5, 8, 7, 6)+(7, 2, 3)	(5, 8, 7, 6, 7, 2, 3), 连接
3 in (5, 2, 4, 3)	True, 判断存在
for x in (1, 2, 3)	1 2 3,遍历

Python元组内置函数

函数	描述
len(tuple)	len((3, 2, 1))=3, 计算元组长度
max(tuple),min(tuple)	元组中的最大，最小元素
tuple(item)	转换为元组

Set(集合)

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合的定义方法

parameter = {value1, value2, ...}
或者
set（value）

集合的运算

student1 = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
student2 = {'Mary', 'Tom', 'Rose'}
a = set('abracadabra')
b = set('alacazam')

print(student1)  #输出集合，重复的元素被自动去掉

#成员测试
if 'Rose' in student1:
    print('Rose 在集合中')
else:
    print('Rose 不在集合中')

# set可以进行集合运算
# 这些运算也可以通过Python集合内置方法来实现
print(a - b)  # a 和 b 的差集
print(a | b)  # a 和 b 的并集
print(a & b)  # a 和 b 的交集
print(a ^ b)  # a 和 b 中不同时存在的元素

print(student1 - student2)  # a 和 b 的差集
print(student1 | student2)  # a 和 b 的并集
print(student1 & student2)  # a 和 b 的交集
print(student1 ^ student2)  # a 和 b 中不同时存在的元素

输出结果：
{'Tom', 'Mary', 'Jim', 'Jack', 'Rose'}
Rose 在集合中
{'b', 'd', 'r'}
{'c', 'l', 'a', 'd', 'b', 'z', 'm', 'r'}
{'c', 'a'}
{'d', 'b', 'l', 'z', 'm', 'r'}
{'Jack', 'Jim'}
{'Mary', 'Jim', 'Jack', 'Rose', 'Tom'}
{'Rose', 'Tom', 'Mary'}
{'Jim', 'Jack'}

集合的操作

操作	描述
添加单个元素	set.add(x).添加元素x，按字母顺序添加
添加多个元素	set.update(x). x可以是列表，元组，字典
移除元素	set.remove(x)，从集合里面移除元素x
随机删除	set.pop()
元素个数	len(set)
集合清空	set.clear()
判断元素	x in set.在返回True,不在返回False

Dictionary(字典)

​ 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。

字典的定义及访问

dict = {}                 # 创建空字典
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"
 
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
 
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

输出结果：
1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site']) #可转化为list类型
dict_values(['runoob', 1, 'www.runoob.com'])

字典的修改与删除

# 字典的修改
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
dict['Age'] = 8               # 更新 Age
dict['School'] = "菜鸟教程"  # 添加信息
 
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
运算结果：
dict['Age']:  8
dict['School']:  菜鸟教程
    
# 字典的删除
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典

字典键的特性

• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
• 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。

字典的内置函数

函数	描述
len(dict)	计算字典的键数
dict.clear()	删除所有元素
dict.copy()	复制字典
key in dict	判断键的存在
dict.items()	以列表返回可遍历的(键, 值) 元组数组
dict.keys(), dict.values()	返回键，值的迭代器，可以list为列表
dict.update(dict2)	把字典dict2更新到dict
pop(key)	删除key对应的值并返回
popitem()	随机返回并删除一对键和值

运算符

算术运算符， 比较运算符， 赋值运算符， 逻辑运算符， 位运算符，

成员运算符， 身份运算符， 运算符的优先级

算术运算符

运算符	描述
+	加 - 两个对象相加
-	减 - 得到负数或是一个数减去另一个数
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串
/	除 - x 除以 y
%	取模 - 返回除法的余数
**	幂 - 返回x的y次幂

比较运算符

有a = 10， b = 20

运算符	描述
==	(a == b) 返回 False。
！=	(a != b) 返回 True。
>	(a > b) 返回 False。
<	(a < b) 返回 True。
>=	(a >= b) 返回 False。
<=	(a <= b) 返回 True。

赋值运算符

有a = 10， b = 20逻辑运算符

运算符	示例
=	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
：=	海象运算符py3.8新增

海象运算符
if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

位运算符

按位运算是把数看成二进制来进行计算。

运算符	描述
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
^	按位异或运算符：当两对应的二进位相异时，结果为1
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x类似于 -x-1
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。相当于乘2
>>	右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数

位运算示例

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
 
c = a & b;        # 12 = 0000 1100
print ("1 - c 的值为：", c)
 
c = a | b;        # 61 = 0011 1101 
print ("2 - c 的值为：", c)
 
c = a ^ b;        # 49 = 0011 0001
print ("3 - c 的值为：", c)
 
c = ~a;           # -61 = 1100 0011
print ("4 - c 的值为：", c)
 
c = a << 2;       # 240 = 1111 0000
print ("5 - c 的值为：", c)
 
c = a >> 2;       # 15 = 0000 1111
print ("6 - c 的值为：", c)

运算结果：
1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15

逻辑运算符

有x = 10, y = 20

运算符	表达式	描述
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

运用示例

a = 10
b = 20
 
if ( a and b ):
   print ("1 - 变量 a 和 b 都为 true")
else:
   print ("1 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("2 - 变量 a 和 b 都不为 true")
 
# 修改变量 a 的值
a = 0
if ( a and b ):
   print ("3 - 变量 a 和 b 都为 true")
else:
   print ("3 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("4 - 变量 a 和 b 都不为 true")
 
if not( a and b ):
   print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
   print ("5 - 变量 a 和 b 都为 true")

运算结果：
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

成员运算符

可以运用在字符串里面查找是否有某个字母串，也可以在列表，元组，集合里面查找是否有某个元素。

运算符	描述
in	如果在指定的序列中找到值返回 True，否则返回 False。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。

应用举例

a = 10
b = 20
c = 'Tom'
d = 'bc'
list = [1, 2, 3, 4, 5 ];
set = ('Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose')
str = 'abc'
 
if (c in set):
    print('set里面有Tom')

if (d in str):
    print('str里面有bc')
    
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

运算结果：
set里面有Tom
str里面有bc
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中

身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	示例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

id()函数用于获取对象的内存地址。

应用举例

a = 10
b = 10
c = 11

a += 1
print(id(a))
print(id(b))
print(id(c))

计算结果：
498360800
498360768
498360800

运算符优先级

略

end关键字

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，实例如下：

a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a+b
    
输出结果：
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

语句

if语句的样式

if condition_1:
    statement_block_1
elif condition_2:     # elif即else if
    statement_block_2
else:
    statement_block_3

样式解释：

• 如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
• 如果 “condition_1” 为False，将判断 “condition_2”
• 如果"condition_2" 为 True 将执行 “statement_block_2” 块语句
• 如果 “condition_2” 为False，将执行"statement_block_3"块语句

注意：条件后面需加冒号:。利用缩进来表示包含关系

循环语句

while循环

while循环的样式：

while 判断条件(condition)：
    执行语句(statements)……
举例：
a = 10
while a <= 20:
    print(a, end=' ')
    a += 1
输出结果：10 11 12 13 14 15 16 17 18 19 20 

无限循环的样式：

while True:
    num = input('请输入一个数：')
    print('你输入的是：'，num)
print('good bye')  #ctrl + c退出

while~else样式：

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>
举例：
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

for循环

for语句的样式：

for <variable> in <sequence>:
    <statements>
else:
    <statements>
举例：
languages = ["C", "C++", "Perl", "Python"] 
for x in languages:
	print (x， end=',')
c,c++,perl,python

range()函数

range(start, end, step)

start：范围的起始位置

end：范围的结束位置

step：每一次跨步的距离,默认为1

range(-10, -100, -30) : -10， -40， -70

用range()创建列表list(range(5))=[0, 1, 2, 3, 4]

break和continue语句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

迭代器与生成器

函数

函数的定义

def 函数名(参数列表)：
	函数体
举例：
def wlcome(name):
    print('welcom '+name)

参数

必需参数

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

关键字参数

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

def printme(str1, str2):
    print('第一个是'str1)
    print('第二个是'str2)
    return
printme(str1 = 'zust'， str2 = 'EE')
运算结果：zust EE

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值.

不定长参数

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

样式举例：
def functionname([formal_args,] *var_args_tuple ):
   function_suite
   return [expression]
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]
加了两个星号 ** 的参数会以字典的形式导入。所以调用时除第一个外需要用关键字参数，如printinfo(1, a=2,b=3)。

声明函数时，参数中星号 * 可以单独出现，例如:
def f(a,b,*,c):
    return a+b+c
如果单独出现星号 * 后的参数必须用关键字传入。f(1, 2, c = 3)

匿名函数

python 使用 lambda 来创建匿名函数。

lambda [arg1 [,arg2,.....argn]]:expression

举例：
sum = lambda arg1, arg2: arg1 + arg2
print(sum(10, 20))
输出：30

n
printme(str1 = ‘zust’， str2 = ‘EE’)
运算结果：zust EE

##### 默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值.

##### 不定长参数

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

```python
样式举例：
def functionname([formal_args,] *var_args_tuple ):
   function_suite
   return [expression]
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]
加了两个星号 ** 的参数会以字典的形式导入。所以调用时除第一个外需要用关键字参数，如printinfo(1, a=2,b=3)。

声明函数时，参数中星号 * 可以单独出现，例如:
def f(a,b,*,c):
    return a+b+c
如果单独出现星号 * 后的参数必须用关键字传入。f(1, 2, c = 3)

匿名函数

python 使用 lambda 来创建匿名函数。

lambda [arg1 [,arg2,.....argn]]:expression

举例：
sum = lambda arg1, arg2: arg1 + arg2
print(sum(10, 20))
输出：30