每天坚持 一天一篇 点个订阅吧  灰常感谢    当个死粉也阔以

　　　　　　　　　　　　　　　　　　　　　　Python人工智能从入门到精通

“\n”Linux 换行符
"\r\n" Windows换行符

函数的参数传递：
　　　传参方式：（2种）
　　　　位置传参(包含关系 )
　　　　　　序列传参
　　　　关键字传参（包含关系）
　　　　　　字典关键字传参
位置传参：
　　　　实际参数（实参）的对应关系与形式参数（形参） 的对应关系是安位置来依次对应的
　　　　说明：
　　　　　　实参和形参通过位置进行传递和匹配
　　　　　　实参的个数必须与形参的个数相同
序列传参：
　　　　序列传参是指在函数调用过程中，用 * 将序列拆解 后按照位置进行传递的方式
　　　　说明：
　　　　　　序列传参时，序列拆解的位置与形参一一对应
　　　　　　序列的位置信息对应相应的形参的位置
关键字传参：
　　　　关键字传参是指传参时，按着形参的名称给形参赋值、实参和形参按形参名进行匹配
字典关键字传参:
　　　　是指字典，将字典用“**”拆解后再进行关键字传参的方式
　　　　说明：
　　　　　　字典的键名必须和形参名一致
　　　　　　字典的键名必须是字符串且标识符
　　　　　　字典额键名要在形参中存在
综合传参：
　　　　函数的传参方式在能确定形参能唯一匹配到相应实参的情况下可以任意组合
　　说明：
　　　　位置传参（序列传参）一定要在关键字传参（字典关键字传参）的左侧

　　示例：

def fu(a, b, c):
    print("a=", a)
    print("b=", b)
    print("c=", c)
fu(100, *[200, 300])
fu(*[100, 200], 300)
fu(100, 200, 300)
fu(100, b=200, c=300)
fu(100, **{"c": 200, "b": 300})

--------------------函数的形参定义--------------------
函数的缺省参数：
　　语法：
　　　　def 函数名 （形参名1=默认实参1， 形参2=默认实参2）
　　　　　　语句块
　　说明：
　　　　缺省参数必须从右至左依次存在的，如果一个参数有缺省参数，
　　　　则右侧的所有参数都必须有缺省参数
函数的形参定义：
　　　　1.位置形参
　　　　　　2.星号元组形参
　　　　3.命名关键字形参
　　　　　　4.双星号字典形参
位置形参：
　　语法：
　　　　def 函数名（形参1， 形参2.......）
　　　　　　语句块
元组形参：
　　语法：
　　　　def 函数名（*元组形参名）：
　　　　　　语句块
　　作用：
　　　　收集多余的位置传参
命名关键字形参：
　　语法：
　　　　def 函数名（*， 命名关键字形参）：
　　　　　　语句块
　　　　或
　　　　def 函数名（*args， 命名关键字形参）：
　　　　　　语句块
　　　　（关键字形参 必须用关键字传参）
　　作用：
　　　　强制所有的参数都参数都必须用关键字传参或字典关键字传参
双星号字典传参：
　　语法：
　　　　def 函数名（**字典形参名）：
　　　　　　语句块
　　作用：
　　　　收集多余关键字传参
　　　　字典形参名通常命名为：kwargs
函数的参数说明：
　　位置形参、星号元组形参、命名关键字形参、双星号字典形参可以混合使用
函数自左到右的顺序为：
　　　　1.位置形参
　　　　2.星号元组形参
　　　　3.命名关键字形参
　　　　4.双星号字典形参
　　例如：
　　　　def fx（a, b, *args, c, **kwargs）:
　　　　　　pass
　　　　fx(100, 200, 300, 400, c="c", d="d")
函数的不定长参数：
　　星号元组形参，双星号字典形参
　　说明：
　　　　可以接收任意位置传参和关键字传参
　　例如：
　　　　def fn（*args， **kwargs）
　　　　　　pass

全局变量和局部变量：
　　局部变量：local variable
　　　　1.定义函数内的变量成为局部变量（函数的形参也是局部变量）
　　　　2.局部变量只能在函数内部使用
　　　　3.局部变量在函数调用时才能够被创建，在函数调用之后被销毁
　　全局变量：global variable
　　　　定义在函数外，模块内的变量称为全局变量
　　　　全局变量所有函数都可以直接访问（但函数内不能将其直接赋值）

练习:
1.写一个函数minmax(a, b, c) 有三个参数，这回这三个参数中的最小值和最大值，
要求，形成元组，最小值在前，最大值在后，如:

def minmax(a, b, c):
...

t = minmax(11, 33, 22)
print(t) # (11, 33) # <<< 打印元组
xiao, da = minmax(6, 5, 4)
print('最小值:', xiao, '最大值:', da)

答案：

def minmax(a, b, c):
    x = a
    if x > b:
        x = b
    if x > c:
        x = c
    z = a  
    if z < b:
        z = b
    if z < c:
        z = c
    L = [x, z]
    print(L)
minmax(2, 1, 3)

方法二：

def minmax(a, b, c):
    L = [min(a, b, c), max(a, b, c)]
    print(L)
minmax(2, 3, 1)

其实方法二 这样也是可以的不过就是有点不厚道了  这不属于二道贩子嘛

2.写一个函数 myadd, 此函数可以计算两个数的和,也可以计算三个数的和

def myadd(......):
....
print(myadd(10, 20)) # 30
print(myadd(100, 200, 300)) # 600

答案：

def myadd(a, b, c=0):
    return a + b + c
print(myadd(100, 200, 300))
print(myadd(100, 200))

def mysum(*args):
    return sum(args)

3 . 写一个函数，print_odd, 此函数可以传递一个实参，也可以传递两个实参，当传递一个实参时代表结束值
当传递两个实参时，第一个实参代表起始值，第二个实参代表结束值
打印出以此区间内的全部奇数，不包含结束数:

print_odd(10) # 1 3 5 7 9
print_odd(11, 20) # 11 13 15 17 19

答案：

def print_odd(a, b=None):
    if b == None:
        b = a
        a = 0
    for x in range(a, b):
        if x % 2 != 0:
            print(x, end=" ")
print_odd(10)# 1 3 5 7 9
print_odd(11, 20)# 11 13 15 17 19

4. 写一个函数, mysum可以传入任意个实参的数字,返回所有实参的和

def mysum(*args):
...
print(mysum(1, 2, 3, 4)) # 10
print(mysum(10, 20, 30)) # 60

 答案：

def mysum(*args):
    i = 0
    for x in args:
        i += x
    return i
print(mysum(1, 2, 3, 4)) # 10
print(mysum(10, 20, 30)) # 60

6. 创建一个全局变量 L = []
写一个函数:
def input_number():
....
此函数每次调用将从键盘读入一些数字追加到列表L中

如:
L = []
def input_number():
....
input_number()
print(L) # [ .... 这些是您从键盘输入的数..]

L = []
def input_number():
    while True:
        a = int(input("please input (-1 over):"))
        if a < 0:
            break
        L.append(a)
    return L
L = input_number()
print(L) # [ .... 这些是您从键盘输入的数..]

7. 写一个函数isprime(x) 判断x是否为素数。如果是素数，返回True,否则返回False

答案：

def isprime(x):
    if x > 2:
        for i in range(2, x):
            if x % i == 0:
                s = False
                break
        else:
            s = True
    else:
        if 1 < x < 3:
            s = True
        else:
            s = False
    return s
x = isprime(4)
print(x)

8. 写一个函数prime_m2n(m, n) 返回从m开始，到n结束(不包含n)范围内的素数，返回这些素数的列表并打印
如:
L = prime_m2n(5, 10)
print(L) [5, 7]

答案：

def prime_m2n(m, n):
    L = []
    for x in range(m, n):
        if isprime(x) == True:
            L.append(x)
    return L
L = prime_m2n(5, 10)
print(L)

9. 写一个函数pimes(n) 返回小于n的全部素数的列表,并打印这些素数
如:
L = primes(10)
print(L) # [2, 3, 5, 7]
1) 打印100 以内的全部素数
2) 打印200 以内的全部素数的和

答案：

def pinmes(n):
    return prime_m2n(1, n)
L = pinmes(10)
print(L) # [2, 3, 5, 7]
print(pinmes(100))
print(sum(pinmes(200)))

10. 编写函数 fn(n) 此函数返回下列级数的和:
fn(n) = 1/(1*2) + 1/(2*3) + ....
+ 1/(n*(n-1)) 的和

print(fn(100))

 答案：

def fn(n):
    s = 0
    for i in range(1, n):
        s += 1 / (i * (i + 1))
    return s
print(fn(100))

一波经验加成buff: （咳咳 C波牛B）
　　开局 一人 一电脑 ，一键盘999999999999999级
你肯会迷茫 晕眩 摸不着头尾 没关系 给你加个经验值BUFF
　　因为很多专业术语比较抽象 再加上翻译差别 所以说很多人都是知道专业术语该怎么说
叫什么 一般容易记住和记忆最久的应该就是用自己的方式去跟现实或者一些列子对比
越白话文越好记 什么花里胡哨的术语 知道是什么就行了 （能记还是要记得 说也尽量说
只是在你脑子里是一个对应的实例关系 就好比 变量 在内存中.......跑题了 溜了 溜了）

实参、传参、形参是什么 ？
　　　　实参就是调用函数时的参数
　　　　传参就是把形参传给实参的过程
　　　　形参就是定义（封装）函数时的参数
字典关键字传参就是把字典先用（**）拆开分成形参和实参
　　　　　　　　键代表关键字（形参、不可变）
　　　　　　　　值代表参数（实参、可变）
　　　　一个键对应一个值 一个关键字对应一个参数
列表、元组 都是属于顺序传参 先用（*）拆分后传参
　　　　关键字传参必须有关键字（形参）和参数（实参）
传参的排序规则：
　　从左到右 1.位置形参 2.星号元组形参 3.命名关键字形参 4.双星号字典形参
　　　　变量没什么可说的 就相当于一个公共电话（全局）和私人手机（局部）
所有人都可以用公共电话 你的私人手机你会让所有人用吗？我想不会吧