自动化运维Python系列(二)之基础数据类型

一、列表和元组

列表是我们最常用到的数据类型之一,在一个变量中定义多个变量,可以理解为数组

定义列表

>>> name = ["liunx01","linux02","Unix",22]
>>> print(name)
[‘liunx01‘, ‘linux02‘, ‘Unix‘, 22]
>>> name[0]
‘liunx01‘
>>> name[-1]

步长

>>> name
[‘liunx01‘, ‘linux02‘, ‘Unix‘, 29, 22]
>>> name[0::2]
[‘liunx01‘, ‘Unix‘, 22]

切片,取多个元素

>>> name[0:1]
[‘liunx01‘]
>>> name[0:2]
[‘liunx01‘, ‘linux02‘]
>>> name[-3:-1]
[‘linux02‘, ‘Unix‘]
>>> name[-3:]
[‘linux02‘, ‘Unix‘, 22]
>>> name[:3]
[‘liunx01‘, ‘linux02‘, ‘Unix‘]
>>> name[:3][:2]
[‘liunx01‘, ‘linux02‘]

追加

>>> name.append("CentOS")
>>> name
[‘liunx01‘, ‘Unix‘, 22,‘CentOS‘]

插入

>>> name.insert(2,‘RetHat‘)
>>> name
[‘liunx01‘, ‘Unix‘,‘RetHat‘,22,‘CentOS‘]

修改

>>> name[1] = "CentOS"
>>> name
[‘liunx01‘, ‘CentOS‘, ‘RetHat‘, 22,‘CentOS‘]

删除

>>> name
[‘liunx01‘, ‘CentOS‘, ‘RetHat‘, ‘Unix‘, 22]
>>> name.remove("RetHat") #指定元素删除
>>> del name[0:2] #切片删除
>>> name.pop() #删除最后一个value
>>> name
[‘Unix‘]

扩展

>>> name
[‘liunx01‘, ‘CentOS‘, ‘RetHat‘, ‘Unix‘, 22]
>>> b = [1,2,3]
>>> name.extend(b)
>>> name
[‘liunx01‘, ‘CentOS‘, ‘RetHat‘, ‘Unix‘, 22, 1, 2, 3]

统计

>>> num = name.count(22)
>>> print(num)
1

倒序、排序

>>> name = [22,"linux01","linux02","Unix",22]
>>> name.reverse()
>>> print(name)
[22, ‘Unix‘, ‘linux02‘, ‘linux01‘, 22]
>>> name = [22,"linux01","linux02","Unix",22]
>>> name.sort()  #注意3.0里面字符串和数字不能直接排序,用2.0
>>> print(name)
[22, 22, ‘Unix‘, ‘linux01‘, ‘linux02‘]

找索引位置

name = [22,"linux01","linux02","Unix",22]
 for i in range(name.count(22)):
     ele_index = name.index(22)
     name[ele_index] = 999
 print(name)

判断列表中是否存在一个元素

>>> name
[‘liunx01‘, ‘linux02‘, ‘Unix‘, 29, 22]
>>> print(2 in name)
False
>>> print(22 in name)
True

拷贝

>>> name
[‘liunx01‘, ‘CentOS‘, ‘RetHat‘, ‘Unix‘, 22]
>>> name_copy = name.copy()
>>> name_copy
[‘liunx01‘, ‘CentOS‘, ‘RetHat‘, ‘Unix‘, 22]

列表的拷贝可不止上面那么简单:

共享列表第二层内存地址

import copy name = [22,"linux01","linux02",[88,87,86],"Unix",22] name3 = name.copy() #拷贝列表 name4 = copy.copy(name) #浅copy(软链接) name5 = copy.deepcopy(name) #深copy(完全拷贝)  name[0] = 100 name[3][2] = 100  print(name) print(name3) print(name4) print(name5)
 
#输出
[100, ‘linux01‘, ‘linux02‘, [88, 87, 100], ‘Unix‘, 22]
[22, ‘linux01‘, ‘linux02‘, [88, 87, 100], ‘Unix‘, 22]
[22, ‘linux01‘, ‘linux02‘, [88, 87, 100], ‘Unix‘, 22]
[22, ‘linux01‘, ‘linux02‘, [88, 87, 86], ‘Unix‘, 22]

元组

元组其实跟列表差不多,也是存一组数,只不是它一旦创建,便不能再修改,所以又叫只读列表

names = ("alex","jack","eric")

它只有2个方法,一个是count,一个是index

字符串操作

n_arg = {‘name‘:‘lichengbing‘,‘age‘:25}n = ‘My name is {name} and age is {age}‘
print(n.format_map(n_arg))
My name is lichengbing and age is 25
  
n1 = ‘Hello World‘
print(n1.ljust(40,"-"))
Hello World-----------------------------
  
n1 = ‘Hello World‘
print(n1.rjust(40,"-"))
-----------------------------Hello World
  
s = "Hello World!"p = str.maketrans("abcdefg","[email protected]#$%^")
print(s.translate(p))
H$llo Worl#!
  
b="ddefdsdff_哈哈"
print(b.isidentifier()) #检测一段字符串可否被当作标志符,即是否符合变量命名规则
True

字典

由于列表中嵌套列表的做法不便于我们取值,所以就有了字典

字典的特性:key-value、dict是无序的、key值必须唯一

字典的定义

id_db = {
   100: {
       ‘name‘:"linux",
       ‘age‘:24,
       ‘addr‘:"shanghai"
   },
   101: {
       ‘name‘:"nuix",
       ‘age‘:23,
       ‘addr‘:"anhui",
   },
}
输出
{100: {‘age‘: 24, ‘name‘: ‘linux‘, ‘addr‘: ‘shanghai‘}, 
101: {‘age‘: 23, ‘name‘: ‘nuix‘, ‘addr‘: ‘anhui‘}}

增加(或者覆盖)

dict2 = {
   ‘name‘: "Redhat",
    103: {
    ‘name‘:"Ubuntu",
   },
}
id_db.update(dict2)
print(id_db)
{‘name‘: ‘Redhat‘, 100: {‘age‘: 24, ‘name‘: ‘linux‘, ‘addr‘: ‘shanghai‘}, 
101: {‘age‘: 23, ‘name‘: ‘nuix‘, ‘addr‘: ‘anhui‘}, 103: {‘name‘: ‘Ubuntu‘}}

删除

del id_db[101] #删除整个value里面的数据
id_db[101].pop("addr") #删除单个数据

获取get

v = id_db.get(102)
 print(v)

获取值或者key

print(id_db.values()) print(id_db.keys())
dict_values([{‘name‘: ‘linux‘, ‘addr‘: ‘shanghai‘, ‘age‘: 24}, 
{‘name‘: ‘nuix‘, ‘addr‘: ‘anhui‘, ‘age‘: 23}])
dict_keys([100, 101])

字典转列表

print(id_db.items())
dict_items([(100, {‘name‘: ‘linux‘, ‘addr‘: ‘shanghai‘, ‘age‘: 24}),
(101, {‘name‘: ‘nuix‘, ‘addr‘: ‘anhui‘, ‘age‘: 23})])

判断包含

id_db.has_key(185185) #only in 2.x
 if 185185 in id_db:
     print("yes")
 else:
     print("no")

setdefault

print(id_db.setdefault(185,"9999")) #取一个值,如果值不存在则新添加一个默认值
print(id_db)
9999
{185: ‘9999‘, 100: {‘addr‘: ‘shanghai‘, ‘age‘: 24, ‘name‘: ‘linux‘}, 
101: {‘addr‘: ‘anhui‘, ‘age‘: 23, ‘name‘: ‘nuix‘}}

fromkeys

print(id_db.fromkeys([1,2,3,56],‘dddd‘)) #设置一个新字典,前面是key后面填充value
print(id_db)
{56: ‘dddd‘, 1: ‘dddd‘, 2: ‘dddd‘, 3: ‘dddd‘}
{100: {‘name‘: ‘linux‘, ‘addr‘: ‘shanghai‘, ‘age‘: 24}, 
101: {‘name‘: ‘nuix‘, ‘addr‘: ‘anhui‘, ‘age‘: 23}}

popitem

print(id_db.popitem()) #随机删除一个key,不要用这个随机删除
(100, {‘name‘: ‘linux‘, ‘age‘: 24, ‘addr‘: ‘shanghai‘})

循环

‘‘‘
 for k,v in id_db.items():   #循环效率低,因为有一个dict转list的过程
     print(k,v)
 ‘‘‘
 
 for key in id_db:         #效率高
     print(key,id_db[key])

set集合

set集合是一个无序且不重复的元素集合

1)创建集合

se1 = {11,22}
print(type(se1))
se2 = set([22,33])
print(se2)
输出
<class ‘set‘>
{33, 22}

2)操作集合

集合操作方法和前面的字符串、字典等类似

增加

#se1.add(44)

A存在B不存在

#se3 = se1.difference(se2)

A有B无 B有A无

#se4 = se1.symmetric_difference(se2)

更新se1

# se1.difference_update(se2)

移除(不存在不报错)

#se1.discard(11)

remove(不存在报错)

#se1.remove(11)

随机移除(返回移除的元素,这里pop里面不能加参数,而list里面pop可以有参数)

#ret = se1.pop()

交集

#se5 = se1.intersection(se2)

合并并集

#se6 = se1.union(se2)

update(接受一个可以被迭代的对象)

# lii = [11,2,3]
# se8 = se1.update(lii) 不能以这种形式来更新
se1.update(lii)
se7 = se1
print(se7)

小程序练习

题目:资产盘点结果中,找出CMDB项目中哪些要增加、哪些要被删除、哪些要更新。

这里以两个字典示范

old_dict = {
    "#1": 8,
    "#2": 4,
    "#4": 2,
}
new_dict = {
    "#1": 4,
    "#2": 4,
    "#3": 2,
}
set_old = set(old_dict)
set_new = set(new_dict)
set_del = set_old.difference(set_new)
set_add = set_new.difference(set_old)
set_update = set_old.intersection(set_new)
时间: 2024-10-14 05:28:41

自动化运维Python系列(二)之基础数据类型的相关文章

自动化运维Python系列(一)之基础篇

Python介绍 Python是由创始人吉多·范罗苏姆(Guido van Rossum)在1989年圣诞节假期期间,为了打发时间,构思出来的一个新的脚本解释器.由于Guido在开发Python语言过程中,借鉴了很多ABC语言特性,所有后来包括Guido自己也那么认为,Python语言的前身就是ABC语言. Python是一门面向对象的.动态解释型强定义语言:Python崇尚简洁.优美.清晰,是一门优秀的被广泛使用的语言. 在2015年以前,最流行的Python版本还是2.4,但是由于Pytho

自动化运维Python系列(五)之常用模块

模块 用一坨代码实现了某个功能的代码集合 模块分为三种 · 自定义模块 · 第三方模块 · 内置模块 1)自定义模块 自己编写并存在在某个路径下的python程序,实现了某个功能,可以被其他程序调用 2)第三方模块 网络上下载并能兼容当前Python版本的第三方程序模块,比如支持HTTP测试的requests库 3)内置模块 C:\Python3.5\Lib目录下的py文件大部分都是Python的内置模块,如sys.os.time等 导入模块 import module from module.

自动化运维Python系列之ForeignKey、relationship联表查询

一对多和多对多 数据库表结构设计是程序项目开发前的重要环节,后期数据库操作都是围绕着这个已经设计好的表结构进行,如果表结构设计有问题,整个程序项目就有存在需要整个推翻重构的风险... 数据库表结构除了简单的单表操作以外,还有一对多.多对多等. 一对多 基于SQLAlchemy我们可以先创建如下结构的2张表,然后来看看具体怎样通过外键ForeignKey或者relationship联表操作 创建表 from sqlalchemy.ext.declarative import declarative

自动化运维Python系列(三)之基础函数和文件操作

函数作用 增强代码的重用性和可读性 在没有使用函数编程之前,我们可能一直遵循的都是面向过程编程,即根据业务逻辑从上到下实现各个功能,这样的做的坏处是代码可读性不强,大量冗余代码,而且执行效率不高:有了函数后,我们就可以将多次使用到的相同代码模块放在单独的函数定义中,在任何想要调用它的地方随时调用,这就叫做函数式编程. 面向对象编程其实就是对函数进行再分类和封装,让开发"更快更好更强..." 函数的定义 def 函数名(参数): ... 函数体 ... 返回值 函数的定义主要有如下要点:

自动化运维Python系列(七)之Socket编程

了解知识点TCP\IP 要想理解socket首先得熟悉一下TCP/IP协议族, TCP/IP(Transmission Control Protocol/Internet Protocol)即传输控制协议/网间协议,定义了主机如何连入因特网及数据如何再它们之间传输的标准, 从字面意思来看TCP/IP是TCP和IP协议的合称,但实际上TCP/IP协议是指因特网整个TCP/IP协议族.不同于ISO模型的七个分层,TCP/IP协议参考模型把所有的TCP/IP系列协议归类到四个抽象层中(数据链路层和物理

自动化运维Python系列(四)之装饰器和生成器

装饰器 在理解什么事装饰器之前,我们需要理解:函数也是一个对象,可以赋值给变量,通过变量来调用 def f1():     print('2016') d = f1 d() 输出: 2016 那么装饰器的作用就是在不改变原函数的前提下,调用这些函数,并且为函数增加我们需要的新功能. 我们平时在编写好很多独立函数模块以后,突然需要在每个模块内添加一个功能,比如: def f1():     print('F1') def f2():     print('F2') def f3():     pr

自动化运维Python系列之Memcache、Redis操作

Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度.Memcached基于一个存储键/值对的hashmap.其守护进程(daemon )是用C写的,但是客户端可以用任何语言来编写,并通过memcached协议与守护进程通信. Memcached安装 wget http://memcached.org/latest tar -zxvf memcach

自动化运维Python系列之进程、线程、协程

进程 线程 协程 1)进程是具有一定独立功能的的程序关于某个数据集合上的一次运行活动,是系统进行资源分配和调度的独立单位 2)线程是进程的一个实体,是CPU调度和分派的基本单位 3)协程是程序自身产生的一种线程复用机制,作用是让一个线程重复利用,减少系统资源开销,提高程序效率 由于进程.线程都是操作系统的基本概念,比较抽象,我们可以将CPU看作是一个时刻在运行中的大型工厂,车间就是工厂里具有独立工作能力的程序进程,每个车间里工作的机器人就是线程: 系统工作模式: 同一时间工厂只能为一个车间供电,

自动化运维Python系列之Django进阶操作

FBV && CBV FBV.CBV是Django视图路由处理模型,当用户请求送达路由系统URL后,由其转发给视图view来分析并处理 // FBV    function base views  // CBV    class base views 区别就是一个直接用函数驱动,一个用类驱动,两者在使用上存在一些区别 1)FBV URL中根据路由匹配直接转发给视图中的某一个处理函数 urlpatterns = [     url(r'^home/', views.home), ] 视图函数