Python运算符、控制语句和函数

Python 运算符

算术运算符

以下假设变量 a 为 10，变量 b 为 21：

运算符	描述	实例
+	加–两个对象相加	a+b 输出结果 31
-	减–两个对象相减	a-b 输出结果 -11
*	乘–两个对象相乘或者返回一个被重复若干次的字符串	a*b 输出结果 210
/	除–两个对象相除	b/a 输出结果 2.1
%	取余–返回除法的余数	b%a 输出结果 1
**	幂–返回 x 的 y 次幂	a**b 为 10 的 21 次方
//	取整除–向下取接近商的整数	b//a 输出结果为 2 -9//2 输出结果为 -5

Python 赋值运算符

运算符	描述	实例
=	简单的赋值运算符	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
:=	海象运算符，可在表达式内部为变量赋值

Python 比较运算符

假设变量 a 为 10，变量 b 为 20

运算符	描述	实例
==	等于–比较对象是否相等	（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

Python 逻辑运算符

Python 中 0 代表 False，1 代表 True

运算符	描述
and	表示逻辑与，只要有一个为 False，则结果就为 False。
or	表示逻辑或，只要有一个为 True，则结果就为 True。
not	not x 表示逻辑非，如果 x 为 True，返回 False。如果 x 为 False，它返回 True。

随机数函数

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

Python 条件控制

Python 中将 else if 缩减成了 elif，所以 if 语句的关键字为:if-elif-else.

1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。

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

3、在 Python 中没有 switch – case语句。

a = 5
if a>6 :
  print('a 大于 6')
elif a>4 :
  print('a 大于 4')
else :
  print('a 小于等于 4')

Python 循环语句

在 Python 中没有 do…while 循环。

while 语句条件设置为永远为 True，则来实现无限循环。

类似 if 语句的语法，如果你的 while 循环体中只有一条语句，你可以将该语句与 while 写在同一行中

Python for 循环可以遍历任何序列的项目，例如一个列表或者一个字符串。

Break 可以跳出当前的循环体。

range()生成器函数可以生成数列。

sum = 0
for i in range(10):
  sum  += i 

sum,i = 0,0
while i<10:
  sum += i
  i += 1

Python函数

函数是可重复使用的，用来实现相关联功能的代码块

Python提供了很多内建函数，例如print()，用户也可以自己创建函数，叫做自定义函数。

创建函数要符合以下规则：

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

语法格式一般如下：

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

函数的调用

函数名（实数列表）

可更改与不可更改对象

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

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

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

参数

必需参数

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

def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数 会报错
printme()

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

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

def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )

默认参数

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

def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

不定长参数

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

基本语法如下：

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

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

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

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

def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)
#输出: 
#1
#{'a': 2, 'b': 3}

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

>>> 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

例子如下：

sum = lambda arg1, arg2: arg1 + arg2
#调用sum函数
print("相加后的值为："，sum(10,20))

return语句

return [表达式 ] 语句，用于推出函数，选择性地向调用方法返回一个表达式。

不带参数值的return语句会返回None。