python运维开发之第三天

一、第二天课程的复习总结

1、列表可以增删改查，元组是不可修改的列表，字符串是不可以修改的。

2、列表，元组是有序的，字典是无序的，字典的key唯一

3、列表字典可以嵌套列表，可以嵌套字典，可以嵌套多层

4、字典不需要保存下标，是通过key来找值（value）

 

二、集合

1、集合特点：无序，不可重复，关系测试

2、关系测试

　　a、交集：取出两个集合间的重复部分A.intersection.B

　　b、并集:两个集合元素总和，（包括重复部分，重复是唯一）A.union.B

　　c、差集：A-B A中有B中没有，B-A，B中有A中没有 A.difference.B B.difference.A

　　d、子集，父集：A包含B，B是A的子集，A是B的父集 子集B.issubset.A 父集A.issuperset.B

　　f、对称差集：取两个集合总和，去掉重复部分。A.symmetric_difference.B

　　g、isdisjoint　没有交集时返回True 

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author  : Willpower-chen
# @blog: http://www.cnblogs.com/willpower-chen/
list_1 = set([1,3,5,7,9,0,10])
list_2 = set([2,4,6,8,0,10])
list_3 = set([1,3,5])
list_4 = set([2,4,6])

print('交集'.center(50,'-'))
print('list_1.intersection(list_2)')
print(list_1.intersection(list_2))
print('另一种写法')
print('list_1 & list_2')
print(list_1 & list_2)

print('并集'.center(50,'-'))
print('list_1.union(list_2)')
print(list_1.union(list_2))
print('另一种写法')
print('list_1 | list_2')
print(list_1 | list_2)

print('差集'.center(50,'-'))
print('list_1.difference(list_2)')
print(list_1.difference(list_2))
print('list_2.difference(list_1)')
print(list_2.difference(list_1))
print('另一种写法')
print('list_1 - list_2')
print(list_1 - list_2)
print('list_2 - list_1')
print(list_2 - list_1)

print('判断子集，父集关系'.center(50,'-'))
print('list_3.issubset(list_1)')
print(list_3.issubset(list_1))
print('list_1.issuperset(list_3)')
print(list_1.issuperset(list_3))



print('对称差集'.center(50,'-'))
print('list_1.symmetric_difference(list_2)')
print(list_1.symmetric_difference(list_2))
print('另一种写法')
print('list_1 ^ list_2')
print(list_1 ^ list_2)

print('判断有无交集'.center(50,'-'))
print('有交集返回False')
print('list_1.isdisjoint(list_2)')
print(list_1.isdisjoint(list_2))
print('没有交集返回True')
print('list_3.isdisjoint(list_4)')
print(list_3.isdisjoint(list_4))

list_1 {0, 1, 3, 5, 7, 9, 10}
list_2 {0, 2, 4, 6, 8, 10}
list_3 {1, 3, 5}
list_4 {2, 4, 6}
------------------------交集------------------------
list_1.intersection(list_2)
{0, 10}
另一种写法
list_1 & list_2
{0, 10}
------------------------并集------------------------
list_1.union(list_2)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
另一种写法
list_1 | list_2
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
------------------------差集------------------------
list_1.difference(list_2)
{1, 3, 5, 9, 7}
list_2.difference(list_1)
{8, 2, 4, 6}
另一种写法
list_1 - list_2
{1, 3, 5, 9, 7}
list_2 - list_1
{8, 2, 4, 6}
--------------------判断子集，父集关系---------------------
list_3.issubset(list_1)
True
list_1.issuperset(list_3)
True
-----------------------对称差集-----------------------
list_1.symmetric_difference(list_2)
{1, 2, 3, 4, 5, 6, 7, 8, 9}
另一种写法
list_1 ^ list_2
{1, 2, 3, 4, 5, 6, 7, 8, 9}
----------------------判断有无交集----------------------
有交集返回False
list_1.isdisjoint(list_2)
False
没有交集返回True
list_3.isdisjoint(list_4)
True

3、集合其他操作

　　a、增：add，update ；add只能增加单个元素，update添加一个或多个集合

　　b、删：remove指定元素删除（只能删一个）并且删除集合中不存在的会报错，

　　　　　　discard删除集合中不存在的不报错，

　　　　　　pop随机删除一个，并返回被删元素

　　c、in 或者 not in ：判断是否在集合中，其实字典，列表都可以这样判断

set_1 {1, 3, 5, 7, 9, 10}
set_2 {8, 2, 10, 4, 6}
set_3 {'a', 1, 3, 5}
set_4 {2, 4, 'b', 6}
------------------------增-------------------------
set_1.add(88)
set_1 {1, 3, 5, 7, 9, 10, 88}
set_1.update(set_2,set_3)
set_1 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 88}
------------------------删除------------------------
set_1.pop()
set_1 {2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 88}
pop_value的值 1
set_1.remove(10)
set_1 {2, 3, 4, 5, 6, 7, 8, 9, 'a', 88}
set_1.discard(7)
set_1 {2, 3, 4, 5, 6, 8, 9, 'a', 88}

三、文件操作

　　1、要想对文件操作，就要对打开的文件的内存赋一个对象

　　　　f = open(file,'r',enconding='utf-8')

　　　　f.close()

　　　　f为文件句柄：内存对象，文件大小等属性

　　2、r只读；w只写创建一个新文件，原有文件会被覆盖；a 即append，追加不可读

　　　　r+ 读写，写是追加方式

　　　　w+写读，创建文件覆盖原文件，写是追加方式

　　　　a+追加读写，

　　　　rb 二进制格式读文件，网络传输中的socket用到

　　3、f.readline()读取一行，f.readlines()一次性把文件内容存到内存，所以只适合小文件

　　4、 for line in f： 这里的f不是列表，是一个迭代器

　　5、f.tell()打印当前位置，计数按字符算；f.seek()指针所在位置；f.enconding打印使用的是什么字符编码

　　6、f.seekable()判断指针是否可以移动，像有些终端是不可移动的

　　7、f.flush()强制把缓存的写入磁盘文件中，当数据必须是时时一致性时使用　

import sys,time
for i in range(50):
    sys.stdout.write("#")
    sys.stdout.flush()
    time.sleep(0.5)

 

　　8、f.truncate()截断从头开始算

　　9、文件修改

　　　　　　a、打开文件，加载到内存，修改内存，再加载到文件（不建议用）

　　　　　　b、同时打开文件，边读边写

with open('file','r',encoding='utf-8') as f , \
     open('file2','w',encoding='utf-8') as f_new:
    for line in f:
        if "我" in line:
            line = line.replace("我","who")
        f_new.write(line)

 　　

import os,sys
find_str = sys.argv[1]    #要替换的内容
replace_str = sys.argv[2]    #替换后的内容

with open('file.txt','r') as read_line,\
      open('newfile.txt','w') as write_line:
    for line in read_line:
        if find_str in line:
            line = line.replace(find_str,replace_str)
        write_line.write(line)
if os.path.exists('file.txt.bak'):#判断.bak文件存在的话，删除
    os.remove('file.txt.bak')
os.rename('file.txt','file.txt.bak')#原文件做备份
os.rename('newfile.txt','file.txt')#新文件替换

　　10、with语句

　　　　　语法：with open(file1,'r',) as f1,pen(file2,'r',) as f2: 

　　　　　with可以同时打开多个文件，并且根据缩进自动关闭文件。

四、字符编码与转换

　　记住字符编码之间的转换，都要通过unicode转化

　　

五、函数

　　1、编程方法

　　（1）面向对象：类--》class

　　（2）面向过程：过程--》def

　　（3）函数式编程：函数--》def

　　函数：有返回值return；过程：没有返回值，逻辑定义到过程中

　　2、为什么使用函数

　　（1）代码的重复利用

　　（2）保持一致性

　　（3）可扩展性

　　3、return返回值

　　return返回值的同时，会终止函数的运行即return后面的代码不会运行

　　return的结果返回多个值时，会组成一个元组即返回一个元组tuple

　　为什么要有返回值：因为返回值可以判定函数是否执行完整。

　　4、位置参数（x，y，z为形参，1，3，5为实参）他们的关系是一一对应

def test(x,y,z):
    print(x)
    print(y)
    print(z)

#位置参数
test(1,3,5)
print(''.center(50,'-'))

　　5、关键参数（调用时，与形参的顺序无关）

#关键字参数(与形参的位置无关)
test(y=5,x=2,z=3)#位置参数与关键字参数的混合（位置参数必须在关键字参数前面，至于后面的关键参数的顺序可以无序）
test(6,z=5,y=3)

　　6、默认参数

　　定义形参时，提前给形参定义一个默认值

　　特点：调用函数时，默认尝试非必须传递；用途（1）默认安装值（2）数据默认端口

　 7、参数组

　　　　*args  接收位置参数，转换成元组

　　　　**kwargs 接收N个关键参数，转换成字典

def test2(name,age=22,*args,**kwargs):
    print('name',name)
    print('age',age)
    print('args',args)
    print('kwargs',kwargs)
test2('xzmly',33,44,55,66,77,sex='m',hobby='BM740')

#结果
name xzmly
age 33
args (44, 55, 66, 77)
kwargs {'sex': 'm', 'hobby': 'BM740'}　

 

　8、局部变量

　　函数是变量的作用域

　　全局变量，在整个程序中的变量，整个程序的顶级（即第一级）

　　函数内要改变全局变量，用global 变量名 （不过不建议用global）

　9、递归：函数调用其本身

　　特点：（1）必须要要一个明确的结束条件（2）每进入一层，问题要比上一层少（3）效率不高