1,定义

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

2.传值
传递的是可变类型，值将被改变
传递的是不可变类型，值被复制了一份传入函数，原有值不变

def change(a):
    a += 1
    return a


b = 10
change(b)
print(b)  # 输出10

def change2(list):
    list.append(33)
    list.append(44)


list = [11, 22]
change2(list)
print(list)  # [11, 22, 33, 44]

3.参数

关键字参数 ，允许函数调用使用关键字参数来确定传入的参数值

def printinfo(name, age):
    "打印任何传入的字符串"
    print("名字: ", name)
    print("年龄: ", age)
    return


# 调用printinfo函数
printinfo(age=50, name="runoob")
'''
名字:  runoob
年龄:  50
'''

不定长参数

#加了1个星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
# 可写函数说明
def printinfo(arg1, *vartuple):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1)
    print(vartuple)

# 调用printinfo 函数
printinfo(70, 60, 50)
'''
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
print(f(1,2,c=10))

# global,nonlocal关键字

a, b, c = 0, 0, 0  # 这是一个全局变量


global 和 nonlocal关键字
def sum():
    # 返回2个参数的和."
    global b  # 声明变量
    a = 1
    b = 1
    c = 1

    def kk():
        nonlocal c  # 声明变量 外部变量
        c = 2

    kk()
    print(c)  # 2


sum()
print(a)  # 0
print(b)  # 1

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

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

字符串，列表或元组对象都可用于创建迭代器：

import sys;
list = [2, 3, 4, 'kkk']
it=iter(list);
for item in it:
    print(item)
# 或者

it=iter(list);
while True:
    try:
        print(next(it))
    except StopIteration:  #next完成的时候,会触发StopIteration异常
        sys.exit()

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

class MyNumber:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        if (self.a <=2):
            x = self.a
            self.a += 1
            return x
        else:
            return StopIteration


my = MyNumber()
my_it = iter(my)
print(next(my_it))
print(next(my_it))
print(next(my_it))

'''
结果:
1
2
<class 'StopIteration'>
'''

3.生成器
使用了 yield 的函数被称为生成器（generator）
跟普通函数不同的是，生成器是一个返回迭代器的函数
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。

import sys


def fibonacci(n):  # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        yield a  # 返回了a值，暂停,并保留了 a, b, counter,第二次从这里执行，有点像步进机
        a, b = b, a + b
        counter += 1


f = fibonacci(10)  # f 是一个迭代器，由生成器返回生成
print(f)  # 并不是数组，而是一个 generator [ˈdʒenəreɪtə(r)]对象

while True:
    try:
        print(next(f), end=" ")
    except StopIteration:
        sys.exit()

'''
<generator object fibonacci at 0x00FE4DF0>
0 test 2 
'''

if

# if
# 1 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块
# 2 在Python中没有switch – case语句。
max = int(input('输入一个正数:'))   #input() 等待用户输入
a = 0
while (a < max):
    if a % 3 == 1:
        print(str(a) + '余数1')
    elif (a % 3 == 2):
        print(str(a) + '余数2')
    else:
        print(str(a) + '余数0')
    a = a + 1
else:
    print('结束了')

#for

list = [9, 1, 3, 4]
for item in list:
    print(item)

for i in range(2, 10, 2):  # range(10) range(2,10)  range(2,10,2)   range(start,end,step)
    print(i)

list(range(10))  # 创建一个列表