首页 > 代码库 > python13_day4

python13_day4

上周复习

1,python基础

2,基本数据类型

3,函数式编程

  函数式编程、三元运行、内置函数、文件处理

  • 容易出问题的点

     函数默认返回值为none,对于列表字典,传入引用。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #函数没有返回值的时候返回none
    li = [11,22,33,44]
    def f2(arg):
        arg.append(li)
    ret = f2(li)
    print(ret)
    -----
    none
     
    #字典,列表等传值传引用
    li = [11,22,33,44]
    def f2(arg):
        arg.append(55)
    f2(li)
    print(li)
    -----
    [11, 22, 33, 44, 55]

  • 所有为False值

    所有空的  s=[],dict{},0,none,""

内置函数下

技术分享

1,chr和ord:完成ASCI码和字符间的转换

1
2
3
4
5
6
7
8
9
r = chr(65)
print(r)
 
n = ord("a")
print(n)
 
-------
A
97

随机数小程序

1
2
3
4
5
6
7
8
9
10
11
12
#注意这里取得是A-Z(65-90)实际这里的应该用65-91,取头舍尾
import random
i = random.randrange(65, 91)
c = chr(i)
print(c)
------
L
 
#ord的使用
print(ord(‘a‘))
---
97


六随机验证码程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import random
li = []
 
for i in range(6):
    r = random.randrange(0, 5)
    if r == 1 or r == 4:
        num = random.randrange(0,10)
        li.append(str(num))
    else:
        temp =random.randrange(65,91)
        c = chr(temp)
        li.append(c)
result = "".join(li)
print(result)
------
FSVAW8

2,compile(),eval(),exec()

compile:将字符串编译成python代码。

eval:只能执行表达式,且有返回值。

exec:执行python代码,但是无返回值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
s = "print(123)"
 
# 将字符串编译成python代码
r = compile(s, "<string>", "exec")
print(r)
exec(s)
 
s = "8*8"
ret = eval(s)
print(ret)
# exec无返回值
print(exec("7+9+8"))
# 执行表达式,并且获取结果
ret = eval("7+9+8")
print(ret)
-----
<code object <module> at 0x0000000000CF36F0, file "<string>", line 1>
123
64
None
24

3,dir:列出一个类给出了哪些功能(help)

1
2
3
4
print(dir(dict))
 
------
[‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘clear‘, ‘copy‘, ‘fromkeys‘, ‘get‘, ‘items‘, ‘keys‘, ‘pop‘, ‘popitem‘, ‘setdefault‘, ‘update‘, ‘values‘]

4,divmod:对一个数取余,且将结果的商和余数存入元组

eg:某网站有156条记录,要求每页显示10行,工多少页。

1
2
3
4
5
6
7
8
9
10
r = divmod(156, 10)
print(r)
print(r[0])
print(r[1])
# 下面简写
n1, n2 = divmod(156, 10)
------
(15, 6)
15
6

5,enumerat:列举,枚举

  • enumerate()是python的内置函数

  • enumerate在字典上是枚举、列举的意思

  • 对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串),enumerate将其组成一个索引序列,利用它可以同时获得索引和值

  • enumerate多用于在for循环中得到计数

  • 例如对于一个seq,得到:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 上述方法有些累赘,利用enumerate()会更加直接和优美
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1):
    print (index, item)
----------
0
1
2 一个
3 测试
 
#同样可以指定起始位置(注意起始位置)
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1, 1):
    print(index, item)
----------
1
2
3 一个
4 测试
 
#统计文件行数的两种方式
count1 = len(open(‘db‘, ‘r‘).readlines())
print(count1)
count = 0
for index, line in enumerate(open(‘db‘,‘r‘)):
    count += 1
print(count)
----------
5
5

6,isinstance:判断对象是某个类的实例(bool值)

 对象和类的关系:对象是类的实例

eg:s="alex"对象,他的类是字符串str。对象和类内部关联,在使用这个对象的时候就会调用换个对象类的方法。

1
2
3
4
5
6
7
8
9
s = "alex" # 对象,"alex" => str
 
s = [11,11,11]
# 用于判断,对象是否是某个类的实例
r = isinstance(s, list)
print(r)
 
-------
TRUE

7,filter:ret=filter(f2,li)(返回li中满足筛选条件f2的值,这里f2返回True元素才合法

  li:必须为可迭代的对象。f2:为执行条件。

  •  filter(函数,可迭代对象)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# 传统方式实现
def f1(args):
    result = []
    for item in args:
        if item > 22:
            result.append(item)
    return result
   
li = [11, 22, 33, 44, 55]
ret = f1(li)
print(ret)
-------
[33, 44, 55]
  
#使用filter实现一
# print(filter(f2,li))
# filter内部,循环第二个参数
# result = []
# for item in 第二个参数:
#     r = 第一个参数(item)
#     if r :
#         result(item)
# return result
# filter ,循环循环第二个参数,让每个循环元素执行 函数,如果函数返回值True,表示元素合法
def f2(a):
    if a>22:
        return True
li = [11, 22, 33, 44, 55]
ret = filter(f2, li)
print(list(ret))
-----
[33, 44, 55]
 
#lambda表达式实现
f1 = lambda a: a > 30 #表达式返回bool值,通过bool值的结果来判断元素是否合法
 
ret = f1(10)
print(ret)
 
li = [11, 22, 33, 44, 55]
result = filter(lambda a: a > 33, li)
print(list(result))
------
False
[44, 55]
  • map:批量执行某一操作,返回值 

    map(函数,可迭代的对象(可以for循环的东西))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#方式一,批量执行
li = [11, 22, 33, 44, 55]
def f2(a):
    return a + 100
  
result = map(f2, li)
print(list(result))
#方式二:lambda表达式
result = map(lambda a: a + 200, li)
print(list(result))
------
[111, 122, 133, 144, 155]
[211, 222, 233, 244, 255]
 
# filter  # 函数返回True,将元素添加到结果中
# map     # 将函数返回值添加到结果中

8,globals():所有的全局变量

 locals():所有的局部变量

 hash():生成哈希表,更虎字典key的保存

 hex():将十进制转换16进制

9,len() 查看字符串有多少个字节或者字符

  python2:只能按照字节看

  python3:按照字节和字符都能看

10,callable:判断函数值能不能被执行,返回bool值

1
2
3
4
5
6
7
8
9
10
11
12
def f1():
    pass
# f1()
 
f2 = 123
# f2()
 
print(callable(f1))
print(callable(f2))
-----
True
False

11.max,min,sum 求最大值、最小值和求和

1
2
3
4
5
6
7
8
li = [11,22,33,44,55]
print(max(li))
print(min(li))
print(sum(li))
------
55
11
165

12.bin,oct,int,min 分别可以做二进制、八进制、十进制、十六进制的转换。  

1
2
3
4
5
6
7
8
9
10
a = 100
print(bin(a))
print(oct(a))
print(int(a))
print(hex(a))
-----
0b1100100
0o144
100
0x64

13. pow(2,10)表示的十次方

1
2
3
print(pow(2,10))
---
1024

14,reverse:反转

   round:四舍五入

   sorted:排序

    zip:把两个序列合起来变成一个元组

1
2
3
4
5
6
7
8
li = [11,2,44,223]
print(list(reversed(li)))
 
li.reverse()
print(li)
-----
[223, 44, 2, 11]
[223, 44, 2, 11]
1
2
3
print(round(1.8))
-----
2
1
2
3
4
5
l = [11,2,44,223]
lo = sorted(l)
print(lo)
------
[2, 11, 44, 223]
1
2
3
4
5
6
l1 = [11,2,44,223]
l2 = [22,2,44,223]
r = zip(l1,l2)
print(list(r))
------
[(11, 22), (2, 2), (44, 44), (223, 223)]


第三周作业 解析

raw_input 获取的用户输入是字符串

1
2
3
4
5
6
input_str = raw_input("请输入内容:")
 
#如:
#用户输入:123   则 input_str = "123"
#用户输入:hello 则 input_str = "hello"
#用户输入:{"k1":123, "k2": "wupeiqi"}   则 input_str = ‘ {"k1":123, "k2": "wupeiqi"} ‘

################# raw_input 获取到的输入都是字符串、字符串、字符串 !!!!!!! #################

因为raw_input 获取的是字符串,所以用户输入的 ‘ {"k1":123, "k2": "wupeiqi"} ‘ 不具有字典的特性,也就不能使用 dic[‘key‘] 来获取值

如果想要将用户输入的内容转换下格式,

1
2
‘{"k1":123, "k2": "wupeiqi"}‘       字符串转换成字典类型
"[11,22,33,44]"                     字符串转换成列表类型

################# 当当当当,python的json模块可以搞搞搞 !!!!!!! #################

json模块

json模块的作用之一:根据字符串书写格式,将字符串自动转换成相应格式

1
2
3
4
5
6
7
8
import json
inp_str = "[11,22,33,44]"
inp_list = json.loads(inp_str) # 根据字符串书写格式,将字符串自动转换成 列表类型
  
  
inp_str = ‘ {"k1":123, "k2": "wupeiqi"} ‘  # 正确的输入      切记,内部必须是 双引号 !!!
#inp_str = " {‘k1‘:123, ‘k2‘: ‘wupeiqi‘}"   # 错误的输入
inp_dict = json.loads(inp_str) # 根据字符串书写格式,将字符串自动转换成 字典类型

学习json有什么用呢?本次作业可以用上哦!!!!!!!

作业实例:(谁要是再不清楚作业,看我下周带皮鞭去抽他...)

需求:

老板现在给你任务,公司有haproxy配置文件,希望通过python程序可以对ha配置文件进行增删改,不再是以往的打开文件进行直接操作了。

现有ha配置文件如下:

技术分享 现有ha配置文件

PS:以下只是实例,有好的想法也是可以的!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
输出:
    1、获取ha记录
    2、增加ha记录
    3、删除ha记录
 
num = raw_input(‘请输入操作序号:‘)
 
如果用户输入的 1
    read = raw_input(‘请输入backend:‘)     如输入:www.oldboy.org
    讲配置文件 backend www.oldboy.org 节点下的所有记录获取到,并输入到终端
 
如果用户输入的 2
    read = raw_input(‘请输入要新加的记录:‘) 如: {"backend""test.oldboy.org","record":{"server""100.1.7.9","weight"20,"maxconn"30}}
    # 讲read字符串转换成 字典类型
    read_dict = json.loads(read)
 
    backend_title = read_dict[‘backend‘]
    # 去配置文件中找到指定的节点:
    # backend test.oldboy.org
    # 如果已经存在,
        # 则在此节点下添加根据用输入构造出的记录,例如:
            server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000
    # 如果不存在,
        # 则添加backend节点和记录,例如:
    backend test.oldboy.org
        server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000
 
    # (可选)可以再对节点下记录进行判断是否已经存在
 
如果用户输入的 3
    read = raw_input(‘请输入要删除的记录:‘) 如: {"backend""test.oldboy.org","record":{"server""100.1.7.9","weight"20,"maxconn"30}}
    # 讲read字符串转换成 字典类型
    read_dict = json.loads(read)
    backend_title = read_dict[‘backend‘]
    #去配置文件中找到指定的节点,并在删除指定记录,如:
    backend test.oldboy.org
         server 100.1.7.10 100.1.7.10 weight 20 maxconn 3000
         server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000   # 删除掉
 
    # (可选)如果backend下所有的记录都已经被删除,那么将当前 backend test.oldboy.org 也删除掉。


装饰器

 软件开发的开放封闭原则:如果用户新增需求,对于原有的类和函数内部不要改,外部来修改功能。

装饰器

       装饰器是函数,只不过该函数可以具有特殊的含义,装饰器用来装饰函数或类,使用装饰器可以在函数执行前和执行后添加相应操作。

格式:@+函数名,放在要装饰的函数前面:自动执行wrapper函数,将foo函数作为参数传给wrapper

1
2
3
4
5
6
7
8
9
10
11
def wrapper(func):
    def result():
        print(‘before‘)
        func()
        print(‘after‘)
 
    return result
 
@wrapper
def foo():
    print(‘foo‘)

执行步骤:

  • 用户调用foo函数的时候,先执行wrapper函数。

  • 然后将foo函数整体作为一个参数传入给func这个形式参数。

  • 执行result函数。(1,打印before;2,执行func(),就是调用foo函数;3,打印after。)

  • 给出result函数的返回值。

  技术分享

1,准备知识

  •  如果一个函数返回值,则返回none

  • 把一个函数作为参数传入另外一个函数,则调用形式参数就是执行原函数

  • 如果一个函数那个过程中遇到return语句结束。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    def f1():
        print(123)
     
    def f1():
        print(456)
    f1()
     
    def f1():
        print(‘123‘)
     
    def f2(xxx):
        xxx()
     
    f2(f1)
    -----
    456
    123

2,装饰器参数(万能参数)

  •  使用这个样的装饰器可以接受万能参数,在函数调用的时候,只要传入了对应的参数均可行

  •  ?注意装饰器中内部函数inner要接受原函数的返回值,保证原函数不受不受影响。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def outer(func):
    def inner(*args, **kwargs):
        print(‘before‘)
        r = func(*args, **kwargs)
        print(‘after‘)
        return r
    return inner
 
# @ + 函数名
# 功能:
#     1. 自动执行outer函数并且将其下面的函数名f1当作参数传递
#     2. 将outer函数的返回值,重复赋值给 f1
@outer
def f1(arg):
    print(arg)
    return "砍你"
 
@outer
def f2(a1, a2):
    print("F2")
#
@outer
def f3():
    print("F3")

3,装饰器的主要应用(权限控制)

  这段代码很好地控制了登陆权限,在每个需要登录的功能外部,通过装饰器,控制登陆状态。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
LOGIN_USER = {"is_login": False }
  
def outer(func):
    def inner(*args, **kwargs):
        if LOGIN_USER[‘is_login‘]:
            r = func()
            return r
        else:
            print("请登录")
    return inner
  
def outer1(func):
    def inner(*args, **kwargs):
        if LOGIN_USER[‘is_login‘] and LOGIN_USER[‘user_type‘] == 2:
            r = func()
            return r
        else:
            print("请登录,或者权限不够")
    return inner
  
@outer1
def order():
    print("欢迎%s登录" % LOGIN_USER[‘current_user‘])
 
@outer
def changepwd():
    print("欢迎%s登录" % LOGIN_USER[‘current_user‘])
 
@outer
def manager():
    print("欢迎%s登录" % LOGIN_USER[‘current_user‘])
 
def login(user, pwd):
    if user == "alex" and pwd == "123":
        LOGIN_USER[‘is_login‘] = True
        LOGIN_USER[‘current_user‘] = user
        manager()
 
def main():
    while True:
        inp = input("1,后台管理;2,登录")
        if inp == ‘1‘:
            manager()
        elif inp == ‘2‘:
            username = input("请输入用户名")
            pwd = input("请输入密码")
            login(username, pwd)
 
main()




 









来自为知笔记(Wiz)


python13_day4