Python：流程控制、函数方法

1，流程控制 1.1，顺序结构 1.1.1，if分支结构

if分支使用布尔表达式或布尔值作为分支条件来进行分支控制。

#第一种形式
if expression:
    statement...
#第二种形式
if expression:
    statement...
else:
    statement...
#第三种形式
if expression:
    statement...
elif expression:
    statement...
elif expression:
    statement...

注意：Python是一门很独特的语言，它的代码是通过缩进来标记的，具有相同缩进的多行代码属于同一个代码块。如果代码莫名其妙地乱缩进，Python解释器会报错。

如果忘记缩进，就不是代码块：

age = 22
if age >20:
    print(age)
print("你已经是叔叔了")

如果随意缩进，将会报错：

age = 22
if age >20:
    print(age)
   print("你已经是叔叔了")

1.1.2，if条件的类型

Python执行if语句时，会判断if条件是True还是False。但实际上，if条件可以是任意类型，当下面的值作为bool表达式、空字典等都会被当作False处理。

False、None、0、""、()、[]、{}

除了False本身，各种代表“空”的None、空字符串、空元祖、空列表、空字典都会被当成False处理。

s = ""
if s:
    print("s不为空")
else:
    print("s不能为空")

1.1.3，pass语句

Python的pass语句就是空语句，有时候程序需要占一位、放一条语句，但又不希望这条语句做任何事情，此时就可通过pass语句来实现。通过使用pass语句，可以让程序更完整。

s = "1"
if s:
    pass
else:
    print("s不能为空")

1.2，断言

断言语句和if分治有点类似，它用于对一个bool表达式进行断言，如果该bool表达式为True，该程序可以继续向下执行；否则程序会引发AssertionError错误。

a = input("年龄：")
a = int(a)
assert 20 < a < 80
print("年龄正常")
==================
年龄：1
Traceback (most recent call last):
  File "E:/Pycharm/WorkSpace/Study/main.py", line 3, in 
    assert 20 < a < 80
AssertionError

1.3，循环结构 1.3.1，while循环

while循环的语法格式如下：

[init_statements]
while test_expression:
    body_statements
    [iteration_statements]

如果循环条件为True，会导致这个循环永远无法结束。 

i = 0
while i < 10:
    print(i)
    i += 1
print("结束循环")

1.3.2，使用while循环遍历列表和元组

由于列表和元组都是有索引的，因此程序可通过while循环、列表或元组的索引来比那里列表和元素中的所有元素。

a = ("燕双嘤", "杜马", "陈恭鹏")
i = 0
while i < len(a):
    print(a[i])
    i += 1

1.3.3，循环使用else

Python的循环可以定义else代码块，当循环条件为False时，程序会执行else代码块。

i = 0
while i < 5:
    print(i)
    i += 1
else:
    print("大于或等于5")

1.3.4，for-in循环

for-in循环专门用于遍历范围、列表、元素和字典等可迭代对象包含的元素。for-in循环的语法格式如下：

for 变量 in 字符串|范围|集合等:
    statement

for-in循环中的变量的值受for-in循环控制，该变量将会在每次循环开始时自动被赋值，因此程序不应该在循环中对该变量赋值。

for-in循环可用于遍历任何可迭代的对象。所谓迭代对象，就是指该对象中包含一个_iter_方法，且该方法的返回值对象具有next()方法。

for i in range(1,10,1):
    print(i)

PS：for-in循环的循环计数器赋值在语法上是允许的，但是没有什么意义。 

1.3.5，使用for-in循环遍历列表和元组

在使用for-in循环遍历列表和元组时，列表或元组有几个元素，for-in循环的循环体就执行几次，针对每个元素执行一次，循环计数器会一次被赋值为元素的值。

a = ("燕双嘤","杜马","步鹰")
for i in a:
    print(i)
for i in range(0,len(a)):
    print(a[i])

1.3.6，使用for-in循环遍历字典

使用for-in循环遍历字典其实也是通过遍历普通列表来实现的。通过以下方法：

• items()：返回字典中所有key-value的列表。
• keys()：返回字典中所有key的列表。
• values()：返回字典中所有value的列表。

a = {"name": "燕双嘤", "sex": "男", "age": 22}
for key,value in a.items():
    print(key,value)
    print(key,a[key])

1.4，控制循环结构 1.4.1，使用break结束循环

某些时候，需要在某种添加出现时强制中止循环，而不是等到循环条件为False时才退出循环。此时可以使用break来完成这个功能。break用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到break，系统就将完全结束该循环，开始执行循环之后的代码。双层循环之跳出内层循环体。

for i in range(0,100):
    print(i)
    if i == 10:
        break

1.4.2，使用continue忽略本次循环的剩下语句

continue的功能和break有点类似，区别是continue知识忽略当次循环的剩下语句，接着下一次循环，并不会中止循环；而break则是完全中止循环本身。

for i in range(0,100):
    print(i)
    if i == 10:
        continue
        print(123)

1.4.3，使用return结束方法

return用于从包围它的最直接方法、函数或匿名函数返回。当函数或方法执行到一条return语句时，这个函数或方法将被结束。Python程序中大部分循环都被放在函数或方法中执行，一旦在循环体内执行到一条return语句时，retrun语句就会结束该函数或方法，循环自然也随之结束。

def test():
    for i in range(0, 100):
        print(i)
        if i == 10:
            return
            print(123)
if __name__ == '__main__':
    test()

2，函数 2.1，函数的定义和调用 2.1.1，定义函数

定义函数的语法格式如下：

def 函数名(形参列表):
    //由零条到多条可执行语句组成的函数
    [return [返回值]]

Python声明函数必须使用def关键字，对函数语法格式的详细说明：

• 函数名：从语法角度来看，函数名只要是一个合法的标识即可；从程序的可读性角度来看，函数名应该由一个或多个有意义的单词组成，每个单词的字母全部小写，单词与单词之间使用下划线分隔。
• 形参列表：用于定义该函数可以接收的参数。形参列表由多个形参名组成，多个形参名之间以英文逗号（,）隔开。

def demo(x):
    print("燕双嘤"+str(x))
    return "哈哈哈"
print(demo("NB"))

2.1.2，多个返回值

如果程序需要有多个返回值，则既可将多个值包装成列表之后返回，也可直接返回多个值。如果Python函数值直接返回了多个值，Python会自动将多个返回值封装成元组。

def demo():
    print("燕双嘤")
    return "哈哈哈","嘤嘤嘤"
print(demo())
==========================
燕双嘤
('哈哈哈', '嘤嘤嘤')

2.2，函数的参数 2.2.1，关键字参数

按照形参位置传入参数被称为位置参数。如果使用位置参数的方式传入参数值，则必须严格按照定义函数时指定的顺序来传入参数值；如果根据参数名来传入参数值，则无须遵守定义形参的顺序，这种方式被称为关键字参数。

def demo(str1, str2):
    print(str1, str2)
    return "哈哈哈"


print(demo("燕双嘤", "NB"))
print(demo(str2="燕双嘤", str1="NB"))
==========================
燕双嘤 NB
哈哈哈
NB 燕双嘤
哈哈哈

2.2.2，参数默认值

在某些情况下，程序需要在定义函数时为一个或多个形参指定默认值——这样在调用函数式就可以省略为该形参传入参数值，而是直接使用该形参的默认值。

def demo(str,sex="男"):
    return "姓名："+str+",性别："+sex


print(demo("燕双嘤"))

PS：多个参数时，有默认值的参数必须放在无默认值参数的后面。上面的str和sex就无法互换。

2.2.3，可变参数

Python允许在形参前面添加一个星号（*），这样就意味着该参数可接收多个参数值，多个参数值被当成元组传入。

def demo(a,*b):
    print(a)
    for i in b:
        print(i)
demo("燕双嘤",1,2,3,4,5)
=======================
燕双嘤
1
2
3
4
5

PS：Python允许可变参数出现在列表的任何位置，但Python要求函数最多只能带一个支持“普通”参数收集的形参。

def demo(*b,a):
    print(a)
    for i in b:
        print(i)
demo("燕双嘤",1,2,3,4,a=5)

demo()函数的第一个参数就是个数可变的形参，由于该参数可接收个数不等的参数值，因此如果需要给后面的参数传入参数值，则必须使用关键字参数；否则，程序会把所传入的多个值都当成是传给b参数的。

Python还可以收集关键字参数，此时Python会将这种关键字参数收集字典。为了让Python能收集关键字参数，需要在参数前面添加两个星号。在这种情况下，一个函数可同时包含一个支持“普通”参数收集的参数和一个支持关键字参数收集的参数。

def test(x, y, z=3, *names, **party):
    print(x, y, z)
    print(names)
    print(party)


test(1, 2, 3, "燕双嘤", "杜马", 党派1="共产党", 党派2="国民党")
==================================================
1 2 3
('燕双嘤', '杜马')
{'党派1': '共产党', '党派2': '国民党'}

如果想让z参数的默认值发挥作用，则需要只传入两个位置参数。

test(1, 2, 3, 党派1="共产党", 党派2="国民党")
==============================
1 2 3
()
{'党派1': '共产党', '党派2': '国民党'}

2.2.4，逆向参数收集

所谓逆向参数收集，指的是在程序已有列表、元组、字典等对象的前提下，把它们的元素“拆开”后传给函数的参数。

def test(num1,num2, *nums):
    print(num1)
    print(num2)
    print(nums)
list = [1, 2, 3]
test(*list)
======================
1
2
(3,)

2.2.5，函数传参机制（类似Java）

Python中函数的参数传递机制都是“值传递”，就是将实际参数值的副本传入函数，而参数本身不会受到任何影响。

def swap(a, b):
    a, b = b, a
    print("在swap函数里：", a, b)


a = 6
b = 9
swap(a, b)
print("交换结束后：", a, b)
==========================
在swap函数里： 9 6
交换结束后： 6 9

根据Python的参数传递机制，传入函数的只是参数的副本，因此程序在函数中对参数赋值并不会影响参数本身。如果参数本身是一个可变对象（列表、字典），此时虽然Python采用的也是值传递方式，但是会修改可变对象。

def swap(ab):
    ab['a'], ab['b'] = ab['b'], ab['a']
    print(ab["a"], ab["b"])
ab = {"a":6,"b":9}
swap(ab)
print(ab["a"], ab["b"])
==============================
9 6
9 6

2.2.6，变量作用域

在程序定义一个变量时，这个变量是有作用范围的，变量的作用范围被称为它的作用域。根据定义变量的位置，变量分为两种：

• 局部变量：在函数中定义的变量，包括参数，都被称为局部变量。每个函数在执行时，系统都会为该函数分配一块“临时内存空间”，所有的局部变量都被保存在这块临时内存空间内。当函数执行完成后，这块内存空间就被释放了，这些局部变量也就失效了，因此离开函数之后就不能再访问局部变量了。
• 全局变量：在函数外面、全局范围内定义的变量，都被称为全局变量。全局变量意味着它们可以在所有函数内被访问。

此外，Python提供了如下三个工具函数来获取指定范围内的“变量字典”：

• globals()：该函数返回全局范围内所有变量组成的“变量字典”。
• locals()：该函数返回当前局部返回内所有变量组成的“变量字典”。
• vars(object)：获取在指定对象范围内所有变量组成的“变量字典”。如果不传入object参数，vars()和locals()的作用完全相同。

globals()和locals()看似完全不同，但它们实际上也是有联系的，关于这两个函数的区别如下：

• locals()总是获取当前局部范围内所有变量组成的“变量字典”，因此，如果在全局范围内调用locals()函数，同样会获取全局范围内所有变量组成的“变量字典”；而globals()无论在哪里执行，总是获取全局范围内所有变量组成的“变量字典”。
• 一般来说，使用locals()和globals()获取的“变量字典”只应该被访问，不应该被修改。但实际上，不管是使用globals()还是使用locals()获取的全局范围内的“变量字典”，都可以被修改，而这种修改回真正改变全局变量本身；但通过locals()获取的局部范围内的“变量字典”，即使对它修改也不会影响局部变量。

def test():
    age = 20
    print(age)
    print(locals())
    locals()['age'] = 12
    print(age)
    globals()['x'] = 19

test()
x = 5
y = 20
print(globals())
print(locals())
print(x)
print(globals()['x'])
globals()['x'] = 39
print(x)
locals()['x'] = 99
print(x)
======================
20
{'age': 20}
20
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000017A902DC1D0>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/Pycharm/WorkSpace/Study/main.py', '__cached__': None, 'test': , 'x': 5, 'y': 20}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000017A902DC1D0>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/Pycharm/WorkSpace/Study/main.py', '__cached__': None, 'test': , 'x': 5, 'y': 20}
5
5
39
99

在函数中声明全局变量

name = "燕双嘤"

def test():
    global name
    print(name)
    name = "杜马"

test()
print(name)
=================
燕双嘤
杜马