【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="123"):
    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)
时间: 2024-10-11 04:45:09

【python之路16】作业的相关文章

Python之路—Day2作业

作业需求:1. 优化购物程序,购买时允许用户选择购买多少件:2. 允许多用户登录,下一次登录后,继续按上次的余额继续购买(可以充值):3. 允许用户查看之前的购买记录(纪录要显示商品购买时间):4. 商品列表分级展示:5. 显示已购买商品时, 如果有重复的商品, 不打印多行,而是在一行展示. 本程序包含文件:1.shopping.py 主程序2.shopping.jpg 流程图3.account.txt 用户信息列表4.login.py 用户登录模块5.userlog.txt 用户的购买记录及余

python之路---16 初识面向对象

三十五.初识面向对象 一 .面向对象和面向过程比较 ①面向过程:一切以事物的发展流程为核心    优点:负责的问题流程化,编写相对简单 缺点:可扩展性差 ②面向对象:一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象 优点:可扩展性强 缺点:编程的复杂度高于面向过程 二.类和对象 ①类:就是图纸,创建对象的第一步     对象:通过类造出来的具体事物, ②基本格式 class  类名:            #创建类    类名用驼峰格式 def __init__(self,参数): 

数学之路-python计算实战(16)-机器视觉-滤波去噪(邻域平均法滤波)

# -*- coding: utf-8 -*- #code:[email protected] #邻域平均法滤波,半径为2 import cv2 import numpy as np fn="test3.jpg" myimg=cv2.imread(fn) img=cv2.cvtColor(myimg,cv2.COLOR_BGR2GRAY) #加上椒盐噪声 param=20 #灰阶范围 w=img.shape[1] h=img.shape[0] newimg=np.array(img)

Python之路【第二篇】:Python基础(一)

Python之路[第二篇]:Python基础(一) 入门知识拾遗 一.作用域 对于变量的作用域,执行声明并在内存中存在,该变量就可以在下面的代码中使用. 1 2 3 if 1==1:     name = 'wupeiqi' print  name 下面的结论对吗? 外层变量,可以被内层变量使用 内层变量,无法被外层变量使用 二.三元运算 1 result = 值1 if 条件 else 值2 如果条件为真:result = 值1如果条件为假:result = 值2 三.进制 二进制,01 八进

Python之路_Day5

Python之路_Day5_课堂笔记 ---------------------------------------------------------------------------------------------------- 前期回顾: 一.python基础 二.基本数据类型 int str list tuple dict set 三.函数式编程 四.装饰器 1.将func当作参数传递给装饰器,并执行 2.将装饰器函数的返回值重新赋值给func ------------------

python之路--模块--景丽洋

python之路--常用模块 阅读目录 认识模块 什么是模块 模块的导入和使用 常用模块一 collections模块 时间模块 random模块 os模块 sys模块 序列化模块 re模块 常用模块二 hashlib模块 configparse模块 logging模块 认识模块 返回顶部 什么是模块 什么是模块? 常见的场景:一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀. 但其实import加载的模块分为四个通用类别: 1 使用python编写的代码(

Python之路【第十七篇】:Django【进阶篇 】

Python之路[第十七篇]:Django[进阶篇 ] Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行数据库操作 import MySQLdb def GetList(sql): db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')

Python之路【第九篇】:Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

Python之路[第九篇]:Python操作 RabbitMQ.Redis.Memcache.SQLAlchemy Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度.Memcached基于一个存储键/值对的hashmap.其守护进程(daemon )是用C写的,但是客户端可以用任何语言来编写,并通过memcached协议与守护进程通信. Memc

Python之路【第三篇】:Python基础(二)

Python之路[第三篇]:Python基础(二) 内置函数 一 详细见python文档,猛击这里 文件操作 操作文件时,一般需要经历如下步骤: 打开文件 操作文件 一.打开文件 1 文件句柄 = file('文件路径', '模式') 注:python中打开文件有两种方式,即:open(...) 和  file(...) ,本质上前者在内部会调用后者来进行文件操作,推荐使用 open. 打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作.