语句

if

if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。
非零数值、非空字符串、非空 list 等，判断为 True，否则为 False

1
2
3
4
5
6
7
8
9
10
11
if x > 0:
  print('正数')
else:
  print('零或负数')

if s :
  print('有值')

>>> s = 0  无输出
>>> s = 1  有值

if 语句多个判断条件的形式

1
2
3
4
5
6
7
8
if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

if 语句多个条件同时判断

结合 or 和 and 来使用

1
2
3
4
5
if age > 0 and age < 18
  print('未成年')

if age < 18 or age < 10
  print('儿童或少年')

注意：if 有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于 >（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。

循环语句

在 Python 提供了 for 循环和 while 循环。

循环控制语句 描述
break 在语句块执行过程中终止循环，并且跳出整个循环
continue 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环
pass pass 是空语句，是为了保持程序结构的完整性

for

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for s in 'abcd':
  print(s)
# 输出
a
b
c
d
for entity in {'a':1,'b':2,100:'一百'}:
  print(entity)
# 输出
a
b
100

while

1
2
3
4
5
6
7
8
9
num = 1
while num < 5:
  print(num)
  num = num + 1
# 输出
1
2
3
4

函数

函数就是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

创建方法

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

语法示例：

1
2
3
4
def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

实例：

  1. def 定义一个函数，给定一个函数名 sum
  2. 声明两个参数 num1 和 num2
  3. 函数的第一行语句进行函数说明：两数之和
  4. 最终 return 语句结束函数，并返回两数之和
1
2
3
4
5
6
7
8
9
def sum(num1,num2):
	"两数之和"
	return num1+num2

# 调用函数
print(sum(5,6))

# 输出结果
11

函数的返回值

函数可以有多个返回值，一次接受多个返回值的数据类型就是元组

函数的参数

参数类型：默认参数、关键字参数(位置参数)、不定长参数

默认参数

在构造函数方法时，给参数赋值即可，在使用的时候，不传该参数，就会使用默认参数

1
2
3
4
5
6
7
8
9
def fun1(name, age=18):
  pass

# 注意：只有在形参表末尾的那些参数可以有默认参数
# 例如：fun1(name, age=18)是有效的，fun2(age=18, name)是无效的

# 传的是list 或者 dict 的情况下， 默认参数的赋值 需要为 None， 因为 默认参数是不可变的值

def fun3(name, age=18, hobby=None)

关键字参数

通过参数名来直接赋值，不用考虑参数列表定义的顺序

1
2
3
4
def fun1(name, age=18, hobby=None):
  pass

fun1(name='tom', hobby=['唱跳','Rap'])

不定长参数

设计函数的时候，我们有时候无法确定传入的参数个数。可以在参数前边加星号 *
如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

1
2
3
4
5
6
def fun3(name, age=18, hobby=None, *game):
  pass

fun3('tom', 99, None, 'lol', 'cf')

>>> tom 99 None ('lol', 'cf')

可变长参数也支持关键字参数（位置参数），没有被定义的关键参数会被放到一个字典里。这种方式即是在参数前边加 **

1
2
3
4
5
6
def fun3(name, age=18, hobby=None, **game):
  print('%s %s %s %s' % (name, age, hobby, game))

fun3('kunkun', 1, ['Rap'], pc='lol', mobile='王者') 

>>> kunkun 1 ['Rap'] {'pc': 'lol', 'mobile': '王者'}

只接受关键字参数

将强制关键字参数放到某个*参数或者单个*后面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 加单个'*'
def fun3(name, *, age):
  pass

fun3('tom') 报错 TypeError: fun3() missing 1 required keyword-only argument: 'age'
fun3('tom', 18) 报错 TypeError: fun3() takes 1 positional argument but 2 were given
fun3('tom', age=18) 正确

# 放在可变参数后面'*hobby'
def fun3(name, age=18, *hobby, sex):
  print('%s %s %s %s' % (name, age, hobby, sex))

fun3('tom', 18, '唱','跳', '男') 报错 TypeError: fun3() missing 1 required keyword-only argument: 'sex'
fun3('tom', 18, '唱','跳', sex='男') 正确

函数的值传递问题

不可更改的类型：变量赋值 a = 1，其实就是生成一个整形对象 1 ，然后变量 a 指向 1，当 a = 1000 其实就是再生成一个整形对象 1000，然后改变 a 的指向，不再指向整形对象 1 ，而是指向 1000，最后 1 会被丢弃

可更改的类型：变量赋值 a = [1,2,3,4,5,6] ，就是生成一个对象 list ，list 里面有 6 个元素，而变量 a 指向 list ，a[2] = 5则是将 list a 的第三个元素值更改,这里跟上面是不同的，并不是将 a 重新指向，而是直接修改 list 中的元素值。

1
2
3
4
5
6
7
8
9
10
11
12
13
def unchangeable(num):
  num = 100

num = 1
unchangeable(num)
print(num) 输出1 而非100，因为参数是不可更改类型

def changeable(numlist):
  numlist.append(100)

numlist = [1,2]
changeable(numlist)
print(numlist) 输出[1,2,100]

匿名函数

python 使用 lambda 来创建匿名函数
匿名函数主要有以下特点：

  • lambda 只是一个表达式，函数体比 def 简单很多。
  • lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

基本语法

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

range()

使用 range(x) 函数，就可以生成一个从 0 到 x-1 的整数序列。

range(0,3) ， 从 0 数到 3 每次间隔默认值为1 也可以写成range(3) 结果：0,1,2

range(0,10,2) ,从 0 数到 10（不取 10 ），每次间隔为 2 结果：0,2,4,6,8