Python学习笔记第三周

目录

一、基础概念

  1、集合

    集合方法

    a、设置集合

    b、取交集

    c、取并集

    d、取差集

    e、判断子集

    f、判断父集

    g、对称差集

    基本操作:

    a、添加

    b、删除

    c、discard删除

    d、长度

    e、成员判断

    f、拷贝

  2、文件操作

    1、操作类型方法

      1)读模式

      2)写模式

      3)追加模式

    2、读模式相关操作

      1)read操作

      2)readline操作

      3)readlines操作

      4)close操作

      5)文件编码格式

      6)正确的文件读取方式

      7)tell和seek方法介绍

    3、文件其他操作

      1)encoding

      2)fino()

      3)isatty()

      4)name打印文件名称

      5)seeekable()

      6)flush()

        例子:打印进度条

      7)colsed判断文件是否关闭

      8)truncate()

    4、修改文件

      1、文件全部读到内存中修改

      2、将文件按照行模式读,然后每行操作完毕后放入新文件,节约内存

      更常用文件操作:

      1)r+读写模式

      2)w+写读模式

      3)a+追加读模式

    5、二进制文件

    二进制文件两种方式,rb与wb

      1、网络传输

      2、视频文件打开

    6、with语句

3、字符编码与转码

4、函数

  1、编程方式

  2、定义函数

  3、定义过程

  4、调用函数与调用过程,查看返回值

  5、使用函数的好处

  6、函数的返回值

  7、形参与实参

  8、默认参数

  9、参数组

  10、局部变量与全局变量

  11、递归

  12、高阶函数

二、作业

  1、作业一:实现类似sed的替换操作

  2、对一个haproxy文件查找、删除、添加操作

内容

一、基础概念

1、集合:

集合是一个无序的、不重复的数据组,它的作用:

1)、去重复、把一个列表变成集合,就会自动去重

2)、关系测试,测试两组数据之间的交集、差集、并集等关系

  集合的方法:

    a、设置集合

>>> list_1 = [1,3,5,6,77,3,12]   #列表1
>>> list_2 = [1,3,88,4,33,77] #列表2
>>> list_1 = set(list_1) #通过set方法可以将列表变为集合
>>> list_1
{1, 3, 5, 6, 12, 77} #集合list_1现在已经去重
>>> list_2 = set(list_2)
>>> list_2
{1, 33, 3, 4, 77, 88}
>>>print(list_1,type(list_1)) #打印list_1类型,发现为set类型,证明为集合 {1, 3, 5, 6, 12, 77} <class 'set'>

    

    b、取交集 intersection(list_1  list_2共有的元素)

>>> list_1.intersection(list_2)
{1, 3, 77}
>>> print(list_1 & list_2)
{1, 3, 77}
#上述两种方法均可以取出list_1与list_2的交集

    c、取并集union(list_1 与list_2中全部去重元素)

>>> list_1.union(list_2)
{1, 33, 3, 4, 5, 6, 12, 77, 88}
>>> list_1 | list_2
{1, 33, 3, 4, 5, 6, 12, 77, 88}
#上述两种方法取两个集合的全部去重元素

    d、取差集(差集是一个集合有,但是另一个集合没有的元素,所以差集可以得到两种不同的结果)

    

>>> list_1.difference(list_2) #list_1中存在但是list_2中不存在
{12, 5, 6}
>>> list_2.difference(list_1) ##list_2中存在但是list_1中不存在
{88, 33, 4}

>>> list_1 - list_2
{12, 5, 6}
>>> list_2 - list_1
{88, 33, 4}

    e、判断子集(判断一个集合是否在另一个集合中)

>>> list_3 = set([1,3])
>>> list_3.issubset(list_2)
True
>>> list_3.issubset(list_1)
True

    f、判断父集

>>> list_1.issuperset(list_3)
True

    g、对称差集symmetri_difference(去掉list_1与list_2的交集后存入其他剩余元素)

>>> list_1.symmetric_difference(list_2)
{33, 4, 5, 6, 88, 12}
>>> list_1 ^ list_2
{33, 4, 5, 6, 88, 12}

   

  基本操作:

    a、添加(集合操作没有插入动作,只能添加)

>>> list_1
{1, 3, 5, 6, 12, 77}
>>> list_1.add(999) #添加单项
>>> list_1.add('wang')
>>> list_1
{1, 3, 5, 6, 999, 12, 77, 'wang'}
>>> list_1.update(['alex','john','tom']) #添加多项
>>> list_1
{1, 3, 5, 6, 999, 12, 77, 'john', 'tom', 'wang', 'alex'}

    b、删除

>>> list_1
{1, 3, 5, 6, 999, 12, 77, 'john', 'tom', 'wang', 'alex'}
>>> list_1.remove(999) #通过remove方法删除,删除后不显示删除项,删除需要明确指定删除项的内容,因为集合是无序的,没有索引的概念
>>> list_1
{1, 3, 5, 6, 12, 77, 'john', 'tom', 'wang', 'alex'}
>>> list_1.remove(wang) #针对字符串需要加引号
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'wang' is not defined
>>> list_1.remove('wang')
>>> list_1
{1, 3, 5, 6, 12, 77, 'john', 'tom', 'alex'}
>>> list_1.pop() #pop方法属于随机删除,删除后显示删除的内容
1
>>> list_1.pop()
3
>>> list_1.pop()
5
>>> list_1.pop()
6
>>> list_1.pop()
12
>>> list_1.pop()
77
>>> list_1.pop()
'john'
>>> list_1
{'tom', 'alex'}

    c、discard删除

>>> list_1
{'wang', 1, 3, 5, 6, 999, 12, 77, 'john', 'tom', 'alex'}
>>> list_1.discard(999)
>>> list_1
{'wang', 1, 3, 5, 6, 12, 77, 'john', 'tom', 'alex'}
>>> list_1.discard(888) #discard与remove的不同之处在于,discard如果是删除不存在的内容,不会报错,但是remove会报错
>>> list_1.remove(999)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 999

    d、长度len

>>> len(list_1)
10
>>> list_1
{'wang', 1, 3, 5, 6, 12, 77, 'john', 'tom', 'alex'}

    e、成员判断(in 和not in)

>>> list_1
{'wang', 1, 3, 5, 6, 12, 77, 'john', 'tom', 'alex'}
>>> 'wang' in list_1
True
>>> 11 in list_1
False
>>> 11 not in list_1
True

    f、拷贝(和list一样,都属于浅拷贝)

2、文件操作:

  1、文件操作包括以下几种方式:

    1)读模式

>>> data = open('yesterday.txt', 'r')   #open函数默认是读默认,所以r可以省略,但是为了规范最好写清楚已哪种方式打开
>>> print(data) #当打开这个文件后,print会返回该文件名字,默认与默认编码等文件本身属性
<_io.TextIOWrapper name='yesterday.txt' mode='r' encoding='UTF-8'>

    2)写模式

>>> data = open('yesterday1.txt', 'w')   #文件已写模式打开
>>> data.write('1234\n') #当打开后,可以使用wirite方法进行写入操作,如果需要每行结束后换行,需要手动添加“\n” 这样保证在输入后进行换行操作,当写入后,会自动提示写了多少个字符
5
>>> f = data.read() #由于模式之间不兼容,如果只以写模式打开文件,进行读操作会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
io.UnsupportedOperation: not readable

    3)追加模式

>>> data = open('yesterday1.txt', 'a')  #和写模式不同,已追加模式打开文件,不会覆盖原文件内容,只会在文件后面进行添加,如果以w模式打开,会将文件原有内容全部清空,重新编写
>>>
>>>
>>> data.write('wwwyy\n') #对于写与追加模式,都可以进行write操作
6
>>> f = data.read() #追加模式也同样不能进行读操作
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
io.UnsupportedOperation: not readable

  总结:

文件打开最常用三种模式为读、写、追加。默认为open函数以读模式方式工作,在读模式中可以读取文件内容,写与追加模式均可以对文件进行修改,不同的是,读模式打开文件后,会将原有文件内容清空,添加新内容,而追加模式不会清空原有内容,会在文件最后添加新的需要追加的内容,至于如何在将r、w和a模式进行结合操作,会在修改文件时进行介绍

  2、读模式的相关操作

    1)read操作

>>> data = open('yesterday.txt', 'r')
>>> data.read() #read操作会一次性将文件全部内容读取到内存中
'往日重现\n\n当我年轻的时候\n听着收音机\n等待着我最喜爱的歌\n当它播放时我独自跟唱\n让我心情愉快起来\n\n就像那些快乐时光\n惊讶消失的无影无踪\n但当它们回来时\n就像是久没联络的朋友一样\n这都是我喜欢的歌\n\n每个Sha-la-la-la\n每个Wo-o-wo-o\n记忆依鲜明\n每个shing-a-ling-a-ling\n节奏依然美好\n\n当故事到了那个段落\n他伤了她的心\n让我流下泪来\n就像从前\n往日重现'
>>> data.read() # 由于文件指针的存在,当一次性读取文件到内存后如果不进行指针回退操作前再次读取,会返回空值,表示该内容上一次已经读取完毕,本次读取没有内容显示
''

    2)readline操作

>>> data = open('yesterday.txt', 'r')
>>> data.readline() #与read操作一次性读取不同,readline操作每次只会读取一行内容存储到内存中,readline方法可以针对每行内容进行操作
'往日重现\n'
>>> data.readline()
'\n'
>>> data.readline()
'当我年轻的时候\n'
>>> data.readline()
'听着收音机\n'

    3)readlines操作

>>> data = open('yesterday.txt', 'r')
>>> data.readlines()#区别于read于readline操作,readlines操作也是一次性读取,不同的是它会将读取的内容放入到一个列表中,这样后续可以操作列表的方式对该文件内容进行需要的操作
['往日重现\n', '\n', '当我年轻的时候\n', '听着收音机\n', '等待着我最喜爱的歌\n', '当它播放时我独自跟唱\n', '让我心情愉快起来\n', '\n', '就像那些快乐时光\n', '惊讶消失的无影无踪\n', '但当它们回来时\n', '就像是久没联络的朋友一样\n', '这都是我喜欢的歌\n', '\n', '每个Sha-la-la-la\n', '每个Wo-o-wo-o\n', '记忆依鲜明\n', '每个shing-a-ling-a-ling\n', '节奏依然美好\n', '\n', '当故事到了那个段落\n', '他伤了她的心\n', '让我流下泪来\n', '就像从前\n', '往日重现']

    4)close操作

>>> data.close()  #在r、w、a操作的最后需要将文件关闭,采用close方法进行关闭,这样才会将文件修改保存到硬盘中,如果没有关闭操作,默认情况下都是在内存中进行操作的

    5)文件的编码格式

>>> data = open('yesterday.txt', 'r',encoding='utf-8') #在打开文件时需要跟文件的编码格式,python3中默认是采用utf-8格式的编码,所以可以省略
>>> print(data)
<_io.TextIOWrapper name='yesterday.txt' mode='r' encoding='utf-8'>

    6)正确的文件读取方式

data = open('yesterday.txt','r',encoding='utf-8')
for index,line in enumerate(data.readlines()): #方式一、将文件一次性通过readlines方法读到内存中,然后对其进行操作,该方法适合小文件,如果大文件会由于空间过大,导致打开文件速度过慢,不推荐该方式
print(index,line,end='')
输出:
0 往日重现
1
2 当我年轻的时候
3 听着收音机
4 等待着我最喜爱的歌
5 当它播放时我独自跟唱
6 让我心情愉快起来
7
8 就像那些快乐时光
9 惊讶消失的无影无踪
10 但当它们回来时
11 就像是久没联络的朋友一样
12 这都是我喜欢的歌
13
14 每个Sha-la-la-la
15 每个Wo-o-wo-o
16 记忆依鲜明
17 每个shing-a-ling-a-ling
18 节奏依然美好
19
20 当故事到了那个段落
21 他伤了她的心
22 让我流下泪来
23 就像从前
24 往日重现
########################################################################
data = open('yesterday.txt','r',encoding='utf-8')
for line in data: #第二种方法,data已经变味迭代器而不是列表就没有下标操作,此时会对每行读到内存后进行操作,然后再释放内存,再进行下一行操作,节省内存,推荐该方式操作
print(line,end='')
输出:
往日重现 当我年轻的时候
听着收音机
等待着我最喜爱的歌
当它播放时我独自跟唱
让我心情愉快起来 就像那些快乐时光
惊讶消失的无影无踪
但当它们回来时
就像是久没联络的朋友一样
这都是我喜欢的歌 每个Sha-la-la-la
每个Wo-o-wo-o
记忆依鲜明
每个shing-a-ling-a-ling
节奏依然美好 当故事到了那个段落
他伤了她的心
让我流下泪来
就像从前
往日重现
########################################################################
data = open('yesterday.txt','r',encoding='utf-8')
count = 0
for line in data:
if count == 9:
print('------------')
count +=1
continue
print(line,end='')
count +=1
print('\n')
print(type(data))
输出:
往日重现 当我年轻的时候
听着收音机
等待着我最喜爱的歌
当它播放时我独自跟唱
让我心情愉快起来 就像那些快乐时光
------------ #第九行进行替换操作
但当它们回来时
就像是久没联络的朋友一样
这都是我喜欢的歌 每个Sha-la-la-la
每个Wo-o-wo-o
记忆依鲜明
每个shing-a-ling-a-ling
节奏依然美好 当故事到了那个段落
他伤了她的心
让我流下泪来
就像从前
往日重现 <class '_io.TextIOWrapper'> #验证data此时属于何种类型

    7)tell方法与seek方法介绍

>>> data = open('yesterday.txt','r',encoding='utf-8')
>>> print(data.tell()) #tell方法可以只是当前文件指针所在位置,初始为0
0
>>> print(data.read(100)) #通过read方法读取文件
往日重现 当我年轻的时候
听着收音机
等待着我最喜爱的歌
当它播放时我独自跟唱
让我心情愉快起来 就像那些快乐时光
惊讶消失的无影无踪
但当它们回来时
就像是久没联络的朋友一样
这都是我喜欢的歌 >>> print(data.tell()) #当读取完毕后再次查看文件指针位置
274
>>> print(data.read())#读取剩余的全部文件 每个Sha-la-la-la
每个Wo-o-wo-o
记忆依鲜明
每个shing-a-ling-a-ling
节奏依然美好 当故事到了那个段落
他伤了她的心
让我流下泪来
就像从前
往日重现
>>> print(data.tell()) #读取此时文件指针位置
463
>>> print(data.read())#由于文件全部读取完毕,再次读取只能返回空值 >>> data.seek(0) #将文件指针置为初始位置
print(data.tell()) #验证此时文件指针是否处于初始位置
0
>>> print(data.tell())
print(data.read(50))
0
>>> print(data.read(50))
往日重现 当我年轻的时候
听着收音机
等待着我最喜爱的歌
当它播放时我独自跟唱
让我心情愉快起来 >>> print(data.tell()) #当读取文件后再次通过tell方法获取文件指针所在位置
136

  3、文件的其他操作

    1)encoding:打印文件编码

>>> data.encoding
'utf-8'

    2)  fino()返回文件句柄所在操作系统的编码  基本不使用操作

    3)isatty()该文件是否是一个终端设备,linux系统中可以用来判断是否是一个tty文件

    4)name打印文件名称

>>> data.name
'yesterday.txt'

    5)  seekable() 是否可以移动指针

>>> data.seekable()
True

    6)  flush()刷新操作:

如果以写模式打开文件,写完后不一定立即写入磁盘,如果此时突然断电可能没有及时写入进文件,所以可以通过flush方法刷新进磁盘

例子:可以在安装程序时,打印进度条

import time,sys
for i in range(50):
sys.stdout.write('#')
sys.stdout.flush() #将#号实时刷新到屏幕上来
time.sleep(0.1)

    7)closed 判断文件是否关闭

>>> data.closed
False
>>> data.close()
>>> data.closed
True

    8)  truncate()如果不写入任何东西就是清空文件

    data.truncate(10)会只保留10个字节,其余的会删除,同时truncate自带文件指针,无论通过seek移到任何位置,truncate都会按照初始位置来删除与保留

  4、修改文件:

  修改文件分为两种模式:

    1、将文件全部读入内存中,然后修改,该方式典型代表就是vim程序

    2、将文件按照行模式读,然后每行操作完毕后再放入新文件,这种方式节约内存占用,类似与sed与awk操作

  对于文件操作,除了典型r/w/a方式外还有其他操作,下面来简要介绍这几种更常用操作:

    1)r+  读写操作,表示又能读又能写,这个表示以读与追加模式开始,如果写,会将写的内容放入最后

>>> data = open('test1.txt','r+',encoding='utf-8')  #以读写模式打开文件
>>> data.readline() #对文件进行读操作
'往日重现\n'
>>> data.readline()
'当我年轻的时候\n'
>>> data.readline()
'听着收音机\n'
>>> data.readline()
'等待着我最喜爱的歌\n'
>>> data.write('-------aaaaaaaaaa---------') #对该文件进行写操作
26
>>> data.readline()
'当它播放时我独自跟唱\n'
>>> data.readline()
''
>>> data.seek(0)
0
>>> data.read() #在重新载入文件进行读写会发现,追加的内容会放在最后
'往日重现\n当我年轻的时候\n听着收音机\n等待着我最喜爱的歌\n当它播放时我独自跟唱\n-------aaaaaaaaaa---------'

     2)w+写读模式,创建新文件,输入内容,然后读取文件指针所在位置,在回退,再输入,会发现插入的内容,仍然在最后而不是通过seek调转

>>> data = open('test1.txt','w+',encoding='utf-8')#以w+模式打开
>>> data.write('a-------1\n')
10
>>> data.write('a-------2\n')
10
>>> data.write('a-------3\n')
10
>>> data.write('a-------4\n') #输入内容
10
>>> data.seek(10) #跳转到第一行
10
>>> data.readline() #读取第二行
'a-------2\n'
>>> data.tell()
20
>>> data.write('a-------5\n') #插入新语句,理论上应该插入到第三行
10
>>> data.seek(0)
0
>>> data.read()
'a-------1\na-------2\na-------3\na-------4\na-------5\n' #通过读取发现仍然是插入到最后一行,证明通过seek移动文件指针也没法改变w+的文件输入顺序

    3)a+追加读模式,在追加的过程中可以进行读

>>> data = open('test1.txt','a+',encoding='utf-8')
>>> data.read()
''
>>> data.tell()
50
>>> data.seek(0)
0
>>>
>>>
>>> data.write('a----------6\n')#将指针挪到开头后进行追加写操作
13
>>> data.seek(0)
0
>>> data.read() #重新读取文件发现,追加写仍然按照原有顺序进行添加
'a-------1\na-------2\na-------3\na-------4\na-------5\na----------6\n'

  5、二进制文件

针对二进制文件有两种方式,rb与wb,其中两种情况下使用rb:

1、网络传输,socket传输时只能使用二进制格式编码

2、视频文件打开,也必须使用二进制格式打开

  6、with语句

为了避免打开文件后忘记关闭,可以通过with来管理上下文,即:

>>> with open('tes2.txt','w') as f:f.write('nnnnn\n')
...
6

如此方式,当with代码执行完毕后,内部会自动关闭并释放文件所在内存,同时也可以同时打开多个文件

with open('tes2.txt','w') as f, open('test3.txt','w') as f2:#两个文件之间用‘,’来分割
f.write('nnn\n')
f2.write('mmmm\n')

  

3、字符编码与转码

知识点:

1.在python2默认编码是ASCII, python3里默认是unicode

2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节),utf-8(占1-4个字节), so utf-16就是现在最常用的unicode版本, 不过在文件里存的还是utf-8,因为utf8省空间

3.在py3中encode,在转码的同时还会把string 变成bytes类型,decode在解码的同时还会把bytes变回string

在介绍编码之前先介绍下计算机语言与人类可识别语言转换:

计算机只能识别二进制编码,即0和1,在二进制编码中采用bit(位)来表示,但是这种方式对人类来讲是不可读的,所以初始阶段,发明了ASII码,即采用一个byte(8个bits)方式来表示人类可识别字母,2的8次方-1也就是使用255个ASII码来表示A-Za-z0-9这些数字与字母,但是对于非英语国家来说,255个字符表示没法完全表示自己本国语言,对于中国来说,本身采用了gbk  gbk2308 gbk2312等编码方式来进行特定的编码,但是这种方式到了其他国家由于编码格式未统一,所以导致本国的程序到其他国家未必会被采用,基于这种情况,标注化组织开发了unicode即万国码的方式来代替了原有的各自为政的局面,unicode要求:最少已2个资金来表示,这样又引入了新的问题,就是比较浪费资源,所以最后统一使用utf-8编码方式:英语国家采用ASII编码,一个字节,欧洲等国家采用两个字节,而中国这种亚洲国家采用3个字节来表示自己的编码,至此解决了编码方式的问题

在说的编码与解码,由于类似bgk与utf-8之间没法直接转换,都需要经过unicode作为中转编码,所以需要编码与解码过程

import sys
print(sys.getdefaultencoding()) #打印得出默认编码为utf-8
utf-8
s = '你好' #在python3中默认编码为unicode
s_gbk = s.encode('gbk') #由于默认编码为unicode,所以这里从unicode到gbk编码采用的是encode模式,因为unicode没有decode过程了,可以直接encode
print(s_gbk) #这里输出为gbk编码格式
b'\xc4\xe3\xba\xc3'
s_to_utf8 = s.encode('gbk').decode('gbk').encode('utf-8') '''从bgk变为utf-8:需要先把编码encode为bgk,然后在解码decode,解码是告诉自己为bgk,这时已经转换为unicode了,再从unicode状态encode成utf-8'''
print(s_to_utf8)
b'\xe4\xbd\xa0\xe5\xa5\xbd'
s_to_unicode = s.encode('gbk').decode('gbk').encode('utf-8').decode('utf-8') #在上面的基础上再使用decode模式解码到unicode
print(s_to_unicode)
你好

4、函数

  1、编程方式

    1)面向对象:类  定义用class

    2)面向过程:过程,定义用def

    3)函数式编程:函数,定义用def

      其中函数式编程,其中没有任何变量,对于某一输入一定存在确定的输出,这种编程语言包括Lisp、relang,这里对函数式编码不做过多讨论

  2、定义函数

  

def func1():   #通过def方式定义函数
'''testing'''
print('func1')
return 0 #函数可以有返回值 a = func1() #调用该函数

  3、定义过程

def func2():  #定义过程与定义函数的区别在于定义过程是没有返回值的
'''testing'''
print('in the func2')

  4、调用函数与调用过程,查看返回值

def func1():
'''testing'''
print('func1')
return 0 def func2():
'''testing'''
print('in the func2') a = func1() #调用函数1
b = func2() #调用过程2 print(a)
#打印返回值为0
print(b)
#打印没有返回值,按照默认来定义:None

  5、使用函数的好处

    1)代码的重复利用

    2)程序容易扩展

    3)保持代码的一致性

  6、函数的返回值

def func1():
'''testing1''' def func2():
'''testing2'''
return 1 def func3():
'''testing3'''
return 1,[1,2,3,4,5,6,7],(1,2,4,3,3,'wang'),{'name':'gavin','age':99} a = func1()
b = func2()
c = func3() print(a)
None
print(b)
1
print(c)
(1, [1, 2, 3, 4, 5, 6, 7], (1, 2, 4, 3, 3, 'wang'), {'age': 99, 'name': 'gavin'})

    返回值个数=0,返回None,系统默认返回空

    返回值个数=1,反正object,定义哪个返回值,就返回哪个

    反正值个数>1,返回tuple,当返回值个数大于1时,返回一个元组包含哪些需要返回的数值

  7、形参与实参

def func1(x,y):   #x与y时函数的形参,在没有调用该函数时,x与y不代表任何变量,不占用内存
'''testing1'''
x = x + y
return x a = func1(10,20) #10与20是在调用该函数式传递给该函数的实参,目的是代替形参传入函数得到预期的结果
print(a) #在没有默认参数的情况下,形参与实参是需要一一对应的,如果调用时不一一对应会导致报错
30

  8、默认参数

def func1(x,y=20):#y有默认参数,但是实际调用时没有实参对y赋值,y将采用默认参数,需要注意的是,默认参数要放在最后
'''testing1'''
x = x + y
return x
a = func1(10)
print(a)
30
b = func1(11,21)
print(b)
32

  默认参数特点:

调用函数时,默认参数可有可无,默认参数的用途是1在默认安装软件时使用,2在连接数据库端口号时使用

  9、参数组

def func1(fmt,*args):
'''testing1''' return fmt%args a = func1('%d is larger than %d',2,1)
print(a)
2 is larger than 1 #函数中*args必须是最后一个参数,*表示任意多个参数,*args会把除了前面以外所有参数放入一个tuple里面传递给函数,可以在函数中通过args来访问
#args是一个tuple,可以通过访问tuple方法来在函数中访问args
def func2(format,**keyword):
for k in keyword.keys():
print('keyword[%s] %s %s' %(k,format,keyword[k])) func2('is',one=1,two=2,three=3)
keyword[one] is 1
keyword[three] is 3
keyword[two] is 2
#通过dictionary方式传递参数,同样也可以接受多个参数,但是每个参数必须明确指明名称对应关系,比如a=1,b=2,c=3,这些方法可以混混在一起使用,但是要注意顺序,函数会先接受固定参数,然后是可选参数,然后是任意参数(tuple),再然后才是字典参数(dictionary)

  10、局部变量与全局变量

  局部变量只在函数中生效,而全部变量是在整个程序中都生效的变量,代码顶层定义的变量,局部变量变成全局变量需要在函数中global这个局部变量,但是千万不要这么使用,但是需要注意的是,列表、字典、集合、类都是可以在函数中修改内容的,字符串与整数在局部变量中不能修改

name = 'gavin'

def my(name,age):
name = 'jack' #局部变量
age = 23
return name,age a = my(name,44) #name的局部变量在函数中生效变为jack,但是函数结束后仍然为gavin这个全局变量
print(a) #传入的44在函数中没有生效
('jack', 23)
print(type(a))  #返回值多于一个,反正的是tuple
<class 'tuple'>
print(a[0]) #可以按照元组方式调用返回值
jack
print(a[1])
23
print(name)
gavin
a = 'gavin'

def my(name):
global a #将a变为全局变量
name = 'jack' #局部变量
a = 'john'
print(name,a) my('a')
jack john
print(a)
john
names = ['alex','gavin','tom']

def my():
print(names)
names[1] = 'jack' #将全局变量中的names[1]修改为jack
return names my()
['alex', 'gavin', 'tom']
print(names) #在打印时发现局部变量中的jack替换了全部变量中的gavin
['alex', 'jack', 'tom']

  11、递归

在函数内部,可以调用其他函数,如果一个函数在内部调用函数本身,这个函数就叫做递归函数

  递归的特点:

    1)必须有一个明确的结束条件

    2)每次进入更深的一层递归时,问题规模相比上一次递归应有所减少

    3)递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈这种数据结构实现的,每当进入一个函数调用,栈会增加一层栈帧,每当函数返回会减少一层栈帧,由于栈的大小不是无限的,所以递归次数过多会导致栈的溢出)

def calc(n):
print(n)
if int(n/2) > 0:
return calc(int(n/2))
print('--->', n)
calc(10)
10
5
2
1
---> 1

  12、高阶函数:没找到应用场景

变量可以指向函数,函数的参数能接受变量,那么一个函数就能接收另一个函数作为参数,这种函数叫做高阶函数

def add(a,b,f):
return f(a) + f(b)
res = add(3,-10,abs)
print(res)
13

   

二、作业

1、作业一

实现类似与sed的替换操作

import sys,os
i_flag = sys.argv[1] #传递替换参数=s
source_sed = sys.argv[2] #需要替换的内容
dest_sed = sys.argv[3] #替换的内容
source_file = sys.argv[-1] #需要替换的文件
source_file_bak = sys.argv[-1] + '_bak' + '.txt' #替换后的临时文件
flag = 0
print(i_flag,source_sed,dest_sed,source_file,source_file_bak,flag)
if i_flag != 's':
print('error input ,please input your command like this "sed_python s source_sed dest_sed source_file" ')
else:
pass try:
with open(source_file,'r') as file1, open(source_file_bak, 'w') as file2:
for line in file1:
if line.strip() == source_sed: #当核对到需要替换的内容后,进行替换操作
line = line.replace(source_sed,dest_sed)
flag = 1 #当flag为1时进行回写操作,如果没有发生替换,就不进行回写
file2.write(line) #将替换的内容写入新的文件中 except IOError:
print('the file %s is not exist!' %(source_file)) if flag == 1: #判断是否发生替换操作,如果发生,进行回写操作
with open(source_file,'w') as file1, open(source_file_bak, 'r') as file2:
for line in file2:
file1.write(line) #将替换的文件内容回写到原文件中
os.remove(source_file_bak) #替换完成后删除临时文件

作业二

对一个haproxy文件进行查找、删除、添加操作

import json,shutil,os
def logging():
print('pls input your option'.center(35,'@'))
print('[1]. print the backend information')
print('[2]. add the backend information')
print('[3]. delete the backend information')
print(' the end '.center(35,'@')) def printer(backend):
backend_list = []
with open('haproxy.txt','r',encoding="utf-8") as f:
change_flag = False
for line in f:
if line.split(' ')[0].strip() == 'backend' and line.split(' ')[1].strip() == backend:#匹配要查找的参数
change_flag = True #方便记录该backend下面的server数据
continue
elif change_flag != True:
continue
elif change_flag == True : #根据前面的if操作的赋值,得到backend下面的server配置,写入列表中
if line.split(' ')[0].strip() != 'backend': #该操作为了避免遇到下一个backend,这当做结束操作
backend_list.append(line.strip())
else:
break
return backend_list def adder(obj):
backend_obj = obj['backend']
finder = printer(backend_obj)
if finder == []: #当没有该backend时的操作
with open('haproxy.txt','a') as f: #执行打开文件执行全新文本操作
f.write("\nbackend " + str(obj['backend'])+'\n')
f.write(" " *4 + 'server {server} {server} weight {weight} maxconn {maxconn}'.format(server=obj['record']['server'],weight=obj['record']['weight'],maxconn=obj['record']['maxconn']) +'\n') elif finder != []:#当backend不为新增时,需要判断server是否为新增
data = 'server {server} {server} weight {weight} maxconn {maxconn}'.format(server=obj['record']['server'],weight=obj['record']['weight'],maxconn=obj['record']['maxconn'])
if data not in finder: #当server为新增时,进行如下操作
with open('haproxy.txt','r') as f, open('new.txt','w') as f2:
flag = False
for line in f:
if line.strip().startswith('backend') and line.split(' ')[1].strip() == obj['backend']:
flag = True #为了避免该backend后面server重复写入而进行置位
f2.write(line)
finder.append(data) #将原有server配置与新增server存入一个list钟
for line in finder: #根据list内容,进行打印操作
f2.write(" " * 4 + line + "\n")
continue
if flag and line.strip().startswith("backend"): # 下一个backend
flag = False
f2.write(line)
continue # 退出此循环,避免server信息二次写入
if line.strip() and not flag: #普通文本操作
f2.write(line)
shutil.copy('new.txt','haproxy.txt')
os.remove('new.txt')
else:
print('\033[32;1myour input is in configre of haproxy \033[0m') def delete(backend_name):
finder = printer(backend_name)
if finder == []: #当查找函数没有返回值,说明没有找到配置中存在该选项
print('\033[31;1mthe proxy.txt not inclould the backend\033[0m')
elif finder != []:
with open('haproxy.txt','r') as f, open('del.txt','w') as f2:
flag = False
for line in f:
if line.strip().startswith('backend') and line.split(' ')[1].strip() == backend_name:
flag = True #flag置为True已保证backend下面的server均没法写入配置文件中
continue #直接跳过本次操作,防止和下面if选项符合而导致没有正确删除操作
if flag and line.strip().startswith("backend"): # 下一个backend
flag = False
f2.write(line)
continue # 退出此循环,避免server信息二次写入
if line.strip() and not flag: #普通文本均通过该选项写入配置文件中
f2.write(line)
shutil.copy('del.txt','haproxy.txt') #将执行拷贝操作
os.remove('del.txt') #删除多余配置文件 def output(result): #当列表不为空,调用该函数打印
for line in result:
print(line) def dicter(): #增加选项时,根据输入的字符串转换为字典以方便取值
backend_record_raw = input("Input backend info:").strip()
backend_record_eval = eval(backend_record_raw)
return backend_record_eval def operating(action):
if action == 'printer': #当action为printer时,进行查找操作
backend = input('pls input your will find backend: ').strip()
acter = printer(backend)
if acter != []: #当执行printer函数,返回列表不为空,进行打印
output(acter)
else:
print('\033[31;1mthe backend is not exist!\033[0m') elif action is None:
print("\033[31;1mNothing to do!\033[0m")
else:
if action == 'adder':
backend_record = dicter() #当action为adder时,进行调用赋值函数,从而进入增加操作
adder(backend_record)
elif action == 'delete':
backend_name = input('input your want to delete backend name: ').strip() #根据输入的数值进行删除操作
delete(backend_name) def judging(): #判断环节
choice = input('action:').strip() #根据logging函数替换输入选项
if choice == '': #当选择为1时,将action赋值为printer操作
action = 'printer'
elif choice == '': #当选择为2时,将action赋值为adder操作
action = 'adder'
elif choice == '': #当选择为3时,将action赋值为delete操作
action = 'delete'
elif choice == "q" or choice == "quit":
exit("Bye,thanks!".center(35, "#"))
else:
print("\033[31;1mInput error!\033[0m")
action = None
return action #函数返回值为action赋值 def main(): #程序主入口
while True:
logging() #调用log打印信息
action = judging() #进入判断环节
operating(action) #通过判断环节得到的数据进行操作环节 if __name__ == '__main__':
main()

配置文件如下:

global
log 127.0.0.1 local2
daemon
maxconn 256
log 127.0.0.1 local2 info
defaults
log global
mode http
timeout connect 5000ms
timeout client 50000ms
timeout server 50000ms
option dontlognull
listen stats :8888
stats enable
stats uri /admin
stats auth admin:1234
frontend oldboy.org
bind 0.0.0.0:80
option httplog
option httpclose
option forwardfor
log global
acl www hdr_reg(host) -i www.oldboy.org
use_backend www.oldboy.org if www
backend www.163.com
server 100.1.7.10 100.1.7.10 weight 20 maxconn 3000
server 10.1.1.11 10.1.1.11 weight 20 maxconn 40

  

上一篇:Openstack Pycharm 的远程调试


下一篇:关于我们ajax异步请求的方法与知识