【python之路16】作业

#!usr/bin/env python
# -*- coding:utf-8 -*-

# 数据库中原有
old_dict = {
    "#1": {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80},
    "#2": {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80},
    "#3": {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80}
}

# cmdb 新汇报的数据
new_dict = {
    "#1": {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 800},
    "#3": {'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80},
    "#4": {'hostname': 'c2', 'cpu_count': 2, 'mem_capicity': 80}
}

# 需要删除：？
# 需要新建：？
# 需要更新：？
# 注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新
oldkeys = set(old_dict)
newkeys = set(new_dict)
diferent_key_old = oldkeys.difference(newkeys)  #老的里面有，新的里面没有，则删除老的里面
for i in diferent_key_old:
    old_dict.pop(i)
print(old_dict) #删除后的字典
diferent_key_new = newkeys.difference(oldkeys) #新的里面有，老的里面没有，则添加到老的里面
for i in diferent_key_new:
    old_dict[i] = new_dict[i]
print(old_dict) #添加后的字典
intersection_key = newkeys.intersection(oldkeys) #新的和老的交集
for i in intersection_key:
    old_dict[i].update(new_dict[i])
print(old_dict) #同key修改后的字典

#!usr/bin/env python
# -*- coding:utf-8 -*-
#1、简述函数普通参数、指定参数、默认参数、动态参数的区别
#1)普通参数
#定义函数：
def Function_Name(parameter1,parameter2):  #形参
    pass
#调用函数：
#不指定形参调用时，提供的参数必须与形参数量和顺序一致，否则会报错
Function_Name("parameter1","parameter2") #实参

#2）指定参数
#指定参数调用，提供的参数用形参=实参的方式，可以改变参数的顺序调用
Function_Name(parameter2="parameter2",parameter1="parameter1")

#3）默认参数
#定义函数：
#默认参数定义时，必须将默认的参数放置在最后
def Function_Name(parameter1,parameter2="parameter2"):  #形参
    pass
#默认参数调用可以省略，定义函数时默认了的参数，函数自动会默认定义的默认值
Function_Name("parameter1") #传parameter1,parameter2
#默认参数如果不省略，则传参时会用指定的参数覆盖默认参数
Function_Name("parameter1","parameter3") #传parameter1,parameter3

#4)动态参数
#######定义函数
#1）在形参数前面加*，普通调用实际传值时会将逗号分隔的参数以元组的形式传到函数内部，例如：参数为:11,22,33,[1,2,3]
#传到函数内部为元组：(11,22,33,[1,2,3])
#命名潜规则用 args
def Function_Name(*args):
#2）在形参数前面加**，普通调用实际传值时会将键值对以字典的形式传到函数内部，例如：参数为:key1=123,key2=456
#传到函数内部为字典：{"key1":123,"key2":456}
#命名潜规则用kwargs
def Function_Name(**kwargs):
#######调用函数（特殊调用）
#1）在实参前面加*，表示会将会将元组，列表，字典中的可迭代的对象，循环加入元组，例如：
def Function_Name(*args):
    print(kwargs)
Function_Name(*[11,22,33],44) #传至函数内部变为(11,22,33,44,55)
#2)在实参前面加**，表示会将会将字典直接传到函数内部以字典的形式存在，例如：
def Function_Name(**kwargs):
    print(kwargs)
Function_Name(**{"key1":123,"key2":456},key3=789) #传至函数内部变为{'key1': 123, 'key2': 456, 'key3': 789}

#!usr/bin/env python
# -*- coding:utf-8 -*-

#2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
def char_count(st=""):
    dic = {}
    number = 0 #表示数字
    alphabetic = 0 #表示字母
    space = 0 #表示空格
    other = 0 #表示其他
    for i in st:
        if i.isdigit():  #记录数字
            number += 1
        elif i.isalpha(): #记录字母
            alphabetic += 1
        elif i.isspace(): #记录空格
            space += 1
        else:
            other += 1
    dic['number'] = number
    dic['alphabetic'] = alphabetic
    dic['space'] = space
    dic['other'] = other
    return dic

print(char_count('123aad   !!!!'))

#!usr/bin/env python
# -*- coding:utf-8 -*-
#3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
def islength5(argument):
    if isinstance(argument,(str,list,dict)):  #判断传入的类型是否是字符串，列表，字典
        bol = len(argument) > 5
        return bol
    else:
        return None

OB = 'afaafafaf'
print(islength5(OB))

#!usr/bin/env python
# -*- coding:utf-8 -*-
#4、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
def is_containspace(args):
    import types
    if isinstance(args,str): #判断是否为str类型
        for i in args:
            if i.isspace():
                return True
    else:
        for i in args:
            if is_containspace(i):
                return True
    return False

li = ['aa','bb',('aa','c c')]
print(is_containspace(li))

#!usr/bin/env python
# -*- coding:utf-8 -*-
#5、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
def left_list2(lis):
    if len(lis) > 2:
        return lis[0:2]
    else:
        return lis

li = [11,22,33,44]
print(left_list2(li))

#!usr/bin/env python
# -*- coding:utf-8 -*-
#6、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
def odd_element(iteration):
    li = []
    for i in range(0,len(iteration),2):
        li.append(iteration[i])
    return(li)

li = [11,22,33,44,55]
print(odd_element(li))

下面两段代码的区别，第一种方法是建立一个新的字典，将处理后的字典赋值给新的字典，如果原字典和新字典都需要的情况下用这种方法，通常都是用这种做法的；

第二种方法是，在原来的字典的基础上进行修改。

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

def left_dict2(dic={}):
    new_dic = {}
    for key,value in dic.items():
        if len(value) > 2:
            new_dic[key] = value[0:2]
        else:
            new_dic[key] = value
    return new_dic

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

#!usr/bin/env python
# -*- coding:utf-8 -*-
# 7、写函数，检查传入字典的每一个value的长度, 如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
# dic = {"k1": "v1v1", "k2": [11, 22, 33, 44]}
# PS: 字典中的value只能是字符串或列表
def left_dic2(args):
    for key,value in args.items():
        if len(value) > 2:
            args[key] = value[0:2]

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