python 函数动态参数，名称空间，global，nonlocal

##################################总结######################################
动态参数
    *args：位置参数动态传参，接收到的是元祖，传多少都可以，不传也可以
    **kwargs：关键字参数动态传参,接收到的是字典

    顺序：
        位置参数—*args—默认值参数—**kwargs
        以上参数可以随意搭配使用

    def func():
        pass

    形参的位置*，**  ——聚合
    实参的位置*，**  ——打散

def hehe(*args,**kwargs):#聚合
    print(args)
    print(kwargs)
hehe(1,2,3,haha='heheheehe')

def chi(*food):#聚合
    print(food)
lst=['胡萝卜','大白菜','大萝卜','草']
chi(* lst)#*是打散

def chi(**food):#聚合
    return food
print(chi(** {'tuzi': '胡萝卜', 'niu': '草'},**{'age':1000}))#**是打散

 1，形参的接收顺序。位置, *args, 默认值, **kwargs
2，什么是命名空间，什么是全局名称空间，什么是局部名称空间，什么是内置名称空间。
用来存放名字(变量, 函数名, 类名, 引入的模块名)的
我们在py文件中自己写的变量, 函数.....
在我们执行函数的时候.会产生一个局部名称空间. 放的是: 函数内部的内容(变量, 函数,类...)
我们python解释器提供好的一些内置内容(print, input....)
3，什么是全局作用域，什么是局部作用域。
            1. 全局作用域: 内置+全局
            2. 局部作用域: 局部
5，解释一下什么是global，什么是nonlocal。
        global: 在局部引入全局变量
        nonlocal: 在局部...内层函数引入外层离他最近的那个变量.

a = 50
def func1():
    a = 10 # 局部
    def func2():
        nonlocal a # 不找全局, global找全局
        a += 10 # a=10注释 a = a + 10 python不让这么干
        print("func2", a)
    func2()
    print(a)
func1()
print(a)

结果:

func2 20
20
50

a = 10
def func():
    # 慎用.
    global a  # global 表示从全局把一个变量引入到局部, 后面使用的a都是全局变量
    a += 10 # ?? a = a + 10 # 现在的a是全局的, 你现在视图改全局变量
    print("里面的打印",a)
func()
print("外面的打印", a)

结果:

里面的打印 20
外面的打印 20

##################################作业##################################

2，写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。

def qishuo(number):
    lis=[]
    for i in range(len(number)):
        if i %2 ==0:
            pass
        else:
            lis.append(i)
    return lis
print(qishuo([1,2,3,4,5,6,7]))

def func(a):
    l2 = []
    for i in range(len(a)):
        if i % 2 == 1:
            l2.append(a[i])
    return l2
print(func([1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,34,45,6]))

def baba(a):    #传完参数以后，现在的   a = [1,2,3,4,5,6,7,8,4,5,6,78,9,8]
    return a[1::2]   #对原列表进行切片形成一个新列表，将新列表返回给调用者
print(baba([1,2,3,4,5,6,7,8,4,5,6,78,9,8]))    #爸爸接受return返回的值

3，写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。

def func(a):
    return len(a) > 5
print(func('afdffsfsf'))

4. 写函数，检查传入列表的长度，如果大于2，将列表的前两项内容返回给调用者。

def func(a):
    return a[:2]
print(func([1,2,3,4]))

5，写函数，计算传入函数的字符串中, 数字、字母、空格 以及 其他内容的个数，并返回结果。

def func(s=""):
    shuzi = 0
    zimu = 0
    kongge = 0
    qita = 0
    for c in s:
        if c.isdigit():
            shuzi += 1
        elif c.isalpha():
            zimu += 1
        elif c == " ":
            kongge += 1
        else:
            qita += 1

    return shuzi, zimu, kongge, qita

print(func("jin san pang zuo tian lai zhao alex yao 5000 kuai $$$"))

def number(a):
    upper=0
    lower=0
    isdigit=0
    other=0
    for i in a:
        # print(i)
        if  i.isupper():
            upper=upper+1
        elif i.islower():
            lower=lower+1
        elif i.isdigit():
            isdigit=isdigit+1
        else:
            other=other+1
    return ('大写字母%s,小写字母%s,数字%s,其他字符%s' %(upper,lower,isdigit,other))
print(number('1111,123123,SSS'))

6，写函数，接收两个数字参数，返回比较大的那个数字。

def func(a, b):
    return a if a > b else b

a = int(input('请输入第一个数字:'))
b = int(input('请输入第二个数字'))
def number(a,b):
    if a >b:
        print(a)
    else:
        print(b)
number(a,b)

7，写函数，检查传入字典的每一个value的长度,如果大于2，
那么仅保留前两个长度的内容，并将新内容返回给调用者。
   dic = {"k1": "v1v1", "k2": [11,22,33,44]}
   PS:字典中的value只能是字符串或列表

def func(dic={}):
for k, v in dic.items():
if len(v) > 2:
dic[k] = v[:2]
return dic

print(func({"k1": "v1v1", "k2": [11,22,33,44]}))

8，写函数，此函数只接收一个参数且此参数必须是列表数据类型，
此函数完成的功能是返回给调用者一个字典，
此字典的键值对为此列表的索引及对应的元素。例如传入的列表为：
[11,22,33] 返回的字典为 {0:11,1:22,2:33}。

def number(b):
    dic={}
    for i in range(len(b)):
        dic[i]=b[i]
    return dic
print(number([11,22,33]))

9，写函数，函数接收四个参数分别是：姓名，性别，年龄，学历。
用户通过输入这四个内容，然后将这四个内容传入到函数中，
此函数接收到这四个内容，将内容追加到一个student_msg文件中。

# name = input('请输入姓名:')
# xinbie = input('请输入性别:')
# age = input('请输入年纪:')
# xueli = input('请输入学历:')
#
# def tongji(a,b,c,d):
#     with open('student_msg',mode="a+",encoding='utf-8') as f:
#         f.write("%s+%s+%s+%s+\n" %(a,b,c,d))
# tongji(name,xinbie,age,xueli)

10，对第9题升级：支持用户持续输入，Q或者q退出，性别默认为男，如果遇到女学生，则把性别输入女。

while True:
    name = input('请输入姓名:,可以按Q退出')
    if name.upper() == 'Q':
        exit()
    xinbie = input('请输入性别:')
    age = input('请输入年纪:')
    xueli = input('请输入学历:')

    def tongji(a,b,c,xinbie='男'):
        with open('student_msg',mode="a+",encoding='utf-8') as f:
            f.write("%s+%s+%s+%s\n" %(a,b,c,xinbie))
    tongji(name,age,xueli)#如果输入女就是女,否者就是男

11，写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作（升级题）。

import os
def modify_file(file,old,new):
    with open(file,mode='r',encoding='utf-8') as f1,\
         open(file+'bak',mode='w',encoding='utf-8') as f2:
        for i in f1:
            i=i.replace(old,new)
            f2.write(i)
    os.remove(file)
    os.rename(file+'bak',file)
modify_file("a.txt", "name", "bbb")

12，写一个函数完成三次登陆功能，再写一个函数完成注册功能(升级题)

def zhuche():
    name=input('请输入你要注册用户名:')
    password=input('请输入你要注册的密码:')
    with open('user',mode='a+',encoding='utf-8') as f:
        f.write(name+':'+password +'\n')
    return '注册成功'

def denglu():
    number=1
    while number <=3:
        name = input('请输入用户名:')
        password = input('请输入密码:')
        with open('user',mode='r',encoding='utf-8') as f:
            for i in f:
                i=i.rstrip().split(':')
                a=i
                if name ==a[0] and password ==a[1]:
                    return ('用户名密码正确')
            else:
                print('帐号或密码错误，请重新输入！ 您还有%s次机会。' % (3 - number))
                number=number+1
    return '登陆失败'

def xuanze():
    while True:
        print('请选择登陆还是注册\n 1 注册 \n 2 登陆')
        content=int(input('请选择:'))
        if content == 1:
            print(zhuche())
            # break
        elif content == 2:
            print(denglu())
            break
        else:
            print('输入错误')
xuanze()