zoukankan      html  css  js  c++  java

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




     
  • 相关阅读:
    mac 配置 iterm2
    python面试题
    待办事项--flask
    八皇后问题c语言版（xcode下通过）
    对分布式一些理解
    观察者模式
    用redis实现悲观锁（后端语言以php为例）
    只用200行Go代码写一个自己的区块链！（转）
    php的生命周期的概述
    linux网络编程1 最简单的socket编程
  • 原文地址：https://www.cnblogs.com/kakarott/p/6072471.html
Copyright © 2011-2022 走看看