码迷，mamicode.com
首页 > 编程语言 > 详细

python13_day4

时间：2016-11-17 10:18:01      阅读：267      评论：0      收藏：0      [点我收藏+]

标签：用户名   block   eval   十进制   use   images   软件开发   class   最大值   

上周复习

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()




 











python13_day4

标签：用户名   block   eval   十进制   use   images   软件开发   class   最大值   

原文地址：http://www.cnblogs.com/kakarott/p/6072471.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！