• day12

    第五章 函数

    5.1 发送邮件

     
     
     
     
     
     
     
    import smtplib
    from email.mime.text import MIMEText
    from email.utils import formataddr
    ​
    msg = MIMEText('正文内容', 'plain', 'utf-8')
    msg['From'] = formataddr(["发件人", '发件地址'])
    msg['To'] = formataddr(["收件人", '收件地址'])
    msg['Subject'] = "主题"
    ​
    server = smtplib.SMTP("发件方服务器", 25)
    server.login("发件邮箱", "密码")
    server.sendmail('发件邮箱', ['收件邮箱', ], msg.as_string())
    server.quit()
     

    5.2 函数的基本结构

    ··· 本质：将N行代码拿到别处并给他起个名字，以后通过名字就可以找到这段代码并执行。

    ··· 场景：

    • 代码重复执行。

    • 代码量特别多超过一屏，可以选择通过函数进行代码的分割。

       
       
       
       
       
       
       
      # 函数的定义
      def 函数名():
          # 函数内容
          pass
      ​
      # 函数的执行
      函数名()
       

       

     
     
     
     
     
     
     
    def func():
        pass
    ​
    func() # 注意：函数如果不被调用，则内部代码永远不会被执行。
     

    5.3 函数的参数

    ··· 函数的参数 优先位置参数，再关键字参数，实际参数可以是任意类型。

    ··· 任意类型 任意个数

    ··· 函数内部的数据是否会混乱。

    • 函数内部执行相互之间不会混乱

    • 执行完毕 + 内部元素不被其他人使用 => 销毁

     
     
     
     
     
     
     
    # 位置传参
    ​
    def func(a,b): # a为形式参数
        pass
    ​
    func(c,d) # b为实际参数
    ​
    # 关键字传参
    ​
    def func(a1, a2):
        print(a1, a2)
    ​
    func(a2=99,a1=2)
    ​
    # 关键字传参数和位置传参可以混合使用（位置传入的参数 > 关键字参数在后 = 总参数个数）
    def func1(a1, a2, a3):
        print(a1, a2, a3)
    ​
    # func(1, 2, a3=9)
    # func(1, a2=2, a3=9)
    # func(a1=1, a2=2, a3=9)
    # func(a1=1, 2,3) # 错误
    ​
    # 默认参数
    ​
    def func(a1,a2,a3=9,a4=10):
        print(a1,a2,a3,a4)
    ​
    func(11,22)
    func(11,22,10)
    func(11,22,10,100)
    func(11,22,10,a4=100)
    func(11,22,a3=10,a4=100)
    func(11,a2=22,a3=10,a4=100)
    func(a1=11,a2=22,a3=10,a4=100)
     
     
     
     
     
     
     
     
    def send_email(to):
        template = "要给%s发送邮件" % (to,)
        print(template)
    ​
    ​
    user_input = input('请输入角色：')
    ​
    if user_input == '管理员':
        send_email('xxxx@qq.com')
    elif user_input == '业务员':
        send_email('xxxxo@qq.com')
    elif user_input == '老板':
        send_email('xoxox@qq.com')
     
     
     
     
     
     
     
     
    万能参数（打散）
    ​
    *args
    ​
    可以接受任意个数的位置参数，并将参数转换成元组。
    ​
    调用函数无 *
    ​
    def func(*args):
        print(args)
    ​
    func(1,2,3,4)
    调用函数有 *
    ​
    def func(*args):
        print(args)
    ​
    func(*(1,2,3,4))
    func(*[1,2,3,4])
    只能用位置传参
    ​
    def func(*args):
        print(args)
    ​
    # func(1)
    # func(1,2)
    func(1,2) # args=(1, 2)
    func((11,22,33,44,55)) # args=((11,22,33,44,55),)
    func(*(11,22,33,44,55)) # args=(11,22,33,44,55)
    **kwargs
    ​
    可以接受任意个数的关键字参数，并将参数转换成字典。
    ​
    调用函数无 **
    ​
    ​
    def func(**kwargs):
        print(kwargs)
    ​
    ​
    func(k1=1,k2="alex")
    调用函数有**
    ​
    def func(**kwargs):
        print(kwargs)
    func(**{'k1':'v2','k2':'v2'}) # kwargs={'k1':'v2','k2':'v2'}
    只能用关键字传参
    ​
    综合应用：无敌 + 无敌 => 真无敌
    ​
    def func(*args,**kwargs):
        print(args,kwargs)
    ​
    # func(1,2,3,4,5,k1=2,k5=9,k19=999)
    func(*[1,2,3],k1=2,k5=9,k19=999)
    func(*[1,2,3],**{'k1':1,'k2':3})
    func(111,222,*[1,2,3],k11='alex',**{'k1':1,'k2':3})
    ​
    ​
    # def func(a1,*args,a2):   # args 代指所有位置参数  *args 可以代表一个整体的元组作为参数
    #     print(a1,args,a2)
    # func(1,2,3,1,3,a2=5)
    ​
    ​
    # def func(a1,*args,a2=9):
    #     print(a1,args,a2)
    # func(1,2,3,1,3)
    ​
    ​
    ​
    ​
    ​
    # def func(**kwargs):   # kwargs 代表所有的关键字参数  **kwargs 可以代表一个整体的字典作为参数
    #     print(kwargs)
    # func(**{'k1':'v2','k2':'v2'}) # kwargs={'k1':'v2','k2':'v2'}
    #
    # func(k1=1,k2="alex") # kwargs={'k1': 1, 'k2': 'alex'}
    # func(k1={'k1':99,'k2':777},k2="alex") # kwargs={'k1': {'k1': 99, 'k2': 777}, 'k2': 'alex'}
    # func(**{'k1':'v2','k2':'v2'}) # kwargs={'k1':'v2','k2':'v2'}
    ​
     

     

    5.4 函数的返回值

    ··· 函数没有返回值，默认返回：None

    ··· 函数内部执行过程中遇到return，就终止。

     
     
     
     
     
     
     
    def func():
        return xxx
    ​
    v=func()  #  v 即为 返回值 需要变量接收
     
     
     
     
     
     
     
     
    def func1():
        return "完成" # 函数每次执行到此，就返回；所以下面代码永远不执行。
        for i in range(10):
            print(i)
    func1()
    ​
    ​
    def func2():
        for i in range(10):
            print(i)
            return "完成"
        print(666)
    func2()
     
     
     
     
     
     
     
     
    def func():
        return (1,2,3)
    ​
    v = func()
    print(v)
    ​
    # 特殊:返回元组
    def func():
        return 5,8,"alex"
    ​
    v = func()
    print(v)
     

    5.5 函数的作用域

    python中：

    • py文件：全局作用域

    • 函数：局部作用域

       
       
       
       
       
       
       
      a = 1
      def s1():
          x1 = 666
          print(x1)
          print(a)
          print(b)
      ​
      b = 2
      print(a)
      s1()
      a = 88888
      def s2():
          print(a,b)
          s1()
      ​
      s2()
       

    • 总结：

      • 一个函数是一个作用域

         
         
         
         
         
         
         
        def func():
            x = 9
            print(x)
        func()
        print(x)
         

      • 作用域中查找数据规则：优先在自己的作用域找数据，自己没有就去 "父级" -> "父级" -> 直到全局，全部么有就报错。注意：父级作用域中的值到底是什么？

         
         
         
         
         
         
         
        x = 10
        def func():
            x = 9
            print(x)
        ​
        func()
         

        子作用域中只能 找到父级中的值 ，默认无法重新为父级的变量进行赋值。(global/nonlocal可以强制做)

         
         
         
         
         
         
         
        # #####################
        name = 'oldboy'
        def func():
            name = 'alex' # 在自己作用域再创建一个这样的值。
            print(name)
        func()
        print(name)
        ​
        ​
        ​
        # #####################
        name = [1,2,43]
        def func():
            name.append(999)
            print(name)
        func()
        print(name)
        ​
        # ###################### 如果非要对全局的变量进行赋值
        # 示例一
        name = ["老男孩",'alex']
        def func():
            global name
            name = '我'
        func()
        print(name)
        # 示例一
        name = "老男孩"
        def func():
            name = 'alex'
            def inner():
                global name
                name = 999
            inner()
            print(name)
        func()
        print(name)
        ​
        ​
        name = "老男孩"
        def func():
            name = 'alex'
            def inner():
                global name
                name = 999
            inner()
            print(name)
        func()
        print(name)
        ​
        # ############################## nonlocal
        name = "老男孩"
        def func():
            name = 'alex'
            def inner():
                nonlocal name # 找到上一级的name
                name = 999
            inner()
            print(name)
        func()
        print(name)
         

    5.6 函数作为变量

     
     
     
     
     
     
     
    def func():
        print(123)
    ​
    v1=func
    v1() # 123
    ​
    # 易于混淆：
    def func():
        return 123
    ​
    func_list1 = [func,func,func]
    func_list2 = [func(),func(),func()]
    ​
    print(func_list1) # ['内存地址'，'内存地址'，'内存地址'] 未加括号未调用
    print(func_list2) # [123,123,123] 加了括号才调用
    ​
    info = {
        'k1':func,
        'k2':func(),
    }
    ​
    print(info)
     

    5.7 函数作为参数---高阶函数

     
     
     
     
     
     
     
    def func(a):   
        print(a)
        
    func(1) # 1
    func([1,2,3,4]) # [1,2,3,4] # 变量可以是任何类型
    ​
    def show():   
        return 999
    ​
    func(show) # 999    show的返回值是999   把999作为 参数   如果函数没有写出返回值，那么返回值为None
    ​
    ​
     
     
     
     
     
     
     
     
    def func(arg):
        v1 = arg()
        print(v1)
        
    def show():
        print(666)
        
    func(show) # 666 None   show 打印了666，返回值None，传入参数None给func，v1=None
     
     
     
     
     
     
     
     
    def func(arg):
        v1 = arg()
        print(v1)
        
    def show():
        print(666)
        
    result = func(show)
    print(result)   # 666 None None  首先按照顺序 先调用show，打印666，返回None，传入func，V1=None，打印V1，返回None，最终再打印None
     

    5.8 函数作为返回值---高阶函数

     
     
     
     
     
     
     
    def func():
        print(123)
    ​
    def bar():
        return func
    ​
    v = bar()
    ​
    v()
     
     
     
     
     
     
     
     
    name = 'oldboy'
    def func():
        print(name)
        
    def bar():
        return func
    ​
    v = bar()
    ​
    v() # oldboy
    ​
    ​
    def bar():
        def inner():
            print(123)
        return inner
    v = bar()
    v() # 123
    ​
    ​
    name = 'oldboy'
    def bar():
        name = 'alex'
        def inner():
            print(name)
        return inner
    v = bar()
    v() # alex
    ​
    ​
    ​
    name = 'oldboy'
    def bar(name):
        def inner():
            print(name)
        return inner
    v1 = bar('alex') # { name=alex, inner }  # 闭包，为函数创建一块区域（内部变量供自己使用），为他以后执行提供数据。
    v2 = bar('eric') # { name=eric, inner }
    v1() # alex
    v2() # eric
    ​
    info = []
    ​
    def func():
        print(item)
        
    for item in range(10):
        info.append(func)
    ​
    info[0]() # 9
    ​
    info = []
    ​
    def func(i):
        def inner():
            print(i)
        return inner
    ​
    for item in range(10):
        info.append(func(item))
    ​
    info[0]() # 0
    info[1]() # 1
    info[4]() # 4
     

    5.9 闭包

    • 函数执行的流程分析（函数到底是谁创建的？）

    • 闭包概念：为函数创建一块区域并为其维护自己数据，以后执行时方便调用。【应用场景：装饰器 / SQLAlchemy源码】

     
     
     
     
     
     
     
    def func(name):
        def inner():
            print(name)
        return inner 
    ​
    v1 = func('alex')
    v1() # alex
    v2 = func('eric')
    v2() # eric
     

    5.10 lambda 表达式

     
     
     
     
     
     
     
    func = lambda 参数（若有）: 函数体  （默认返回值赋值给函数名func，可以理解为func是一个变量）
     
     
     
     
     
     
     
     
    # lambda表达式用来表示简单的函数，函数体只能有一行。
    ​
    # 三元运算，为了解决简单的if else的情况，如：
    if 1 == 1:
        a = 123
    else:
        a = 456
    ​
    a =  123  if 1 == 1 else 456
    ​
    # lambda表达式，为了解决简单函数的情况，如：
    def func(a1,a2):
        return a1 + 100 
    ​
    func = lambda a1,a2: a1+100
     
     
     
     
     
     
     
     
    # 一些示例
    func1 = lambda : 100 
    ​
    func2 = lambda x1: x1 * 10
    ​
    func3 = lambda *args,**kwargs: len(args) + len(kwargs)
    ​
    DATA = 100
    func4 = lambda a1: a1 + DATA
    v = func4(1)
    print(v)
    ​
    ​
    DATA = 100
    def func():
        DATA = 1000
        func4 = lambda a1: a1 + DATA
        v = func4(1)
        print(v)
    func()
    ​
    ​
    func5 = lambda n1,n2: n1 if n1 > n2 else n2
    v = func5(1111,2)
    print(v)
     

    5.11 内置函数

    5.11.1 其他类

    ··· len() 计算长度

    ··· open() 打开文件

    ··· range() 产生序列

    ··· id() 查看内存地址

    ··· type() 查看类型

    5.11.2 输入输出类

    ··· input() 输入

    ··· print() 输出

    5.11.3 强制转换类

    ··· str()

    ··· int()

    ··· bool()

    ··· list()

    ··· tuple()

    ··· dict()

    ··· set()

    5.11.4 数学相关

    ··· abs() 绝对值

     
     
     
     
     
     
     
    v=abs(1)
    print(v) # 1
    v=abs(-1)
    print(v) # 1
     

    ··· float() 转换为浮点数

     
     
     
     
     
     
     
    v=55
    v1=float(v)
    print(v1) # 55.0
    ​
    v=55.5
    v1=int(v)
    print(v1) # 55
     

    ··· max / min 最大值或最小值

     
     
     
     
     
     
     
    v=[1,2,3,4]
    v1=max(v)
    v2=min(v)
    print(v1) # 4
    print(v2) # 1
     

    ··· sum() 求和

     
     
     
     
     
     
     
    v=[1,2,3,4]
    v1=sum(v)
    print(v1) # 10
     

    ··· divmod() 求商和余数

     
     
     
     
     
     
     
    a,b=divmod(101,5)
    print(a,b) # (20,1)
    ​
    # 练习题  请通过分页对数据进行展示
    """
    要求：
        每页显示10条数据
        让用户输入要查看的页面：页码
    """
    ​
    USER_LIST = []
    for i in range(1,836):
        temp = {'name':'你少妻-%s' %i,'email':'123%s@qq.com' %i }
        USER_LIST.append(temp)
    ​
    # 数据总条数
    total_count = len(USER_LIST)
    ​
    # 每页显示10条
    per_page_count= 10
    ​
    # 总页码数
    max_page_num,a = divmod(total_count,per_page_count)
    if a>0:
        max_page_num += 1
    ​
    while True:
        pager = int(input('要查看第几页：'))
        if pager < 1 or pager > max_page_num:
            print('页码不合法，必须是 1 ~ %s' %max_page_num )
        else:
            """
            # 第1页：USER_LIST[0:10] -> 0123456789
            # 第2页：USER_LIST[10:20]
            # 第3页：USER_LIST[20:30]
            ...
            """
            start = (pager-1) * per_page_count
            end = pager * per_page_count
            data = USER_LIST[start:end]
            for item in data:
                print(item)
     

    5.11.5 进制转换相关

    ··· bin() 将十进制转换为二进制

     
     
     
     
     
     
     
    a=23
    b=bin(a)
    print(b)
     

    ··· oct() 将十进制转换为八进制

     
     
     
     
     
     
     
    a=23
    b=oct(a)
    print(b)
     

    ··· int() 将其他进制转换为十进制

     
     
     
     
     
     
     
    # 二进制转化成十进制
    v1 = '0b1101'
    result = int(v1,base=2)
    print(result)
    ​
    # 八进制转化成十进制
    v1 = '0o1101'
    result = int(v1,base=8)
    print(result)
    ​
    # 十六进制转化成十进制
    v1 = '0x1101'
    result = int(v1,base=16)
    print(result)
     

    ··· hex() 将十进制转换为十六进制

     
     
     
     
     
     
     
    a=23
    b=hex(a)
    print(b)
     
     
     
     
     
     
     
     
    # 1字节等于8位
    # IP: 192.168.12.79  ->  001010010 . 001010010 . 001010010 . 001010010
    ​
    # 1. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制并通过,连接起来生成一个新的字符串。
    ip = "192.168.12.79"
    ip_list = ip.split('.') # ['192','168','12','79']
    result = []
    for item in ip_list:
        result.append(bin(int(item)))
    print(','.join(result))
    ​
    ​
    # 2. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制: 
    #          0010100100001010010001010010001010010 -> 十进制的值。
    ​
    info='192.168.12.79'
    fina='0b'
    # 通过'.'分割
    info_split=info.split('.')
    # 通过遍历列表得到列表中每一个元素
    for i in info_split:
        # 将字符串转为整形再转为二进制，
        bin_num=bin(int(i))
        # 将二进制去除0b
        str_num=bin_num[2:]
        # 凑齐八位
        if len(str_num) < 8:
            str_num=(8-len(str_num))*'0'+str_num
        # 链接所有的字符串
        fina+=str_num
    print(int(fina,base=2))
    ​
    # 3232238671
     

    5.11.6 编码相关

    ··· chr，将十进制数字转换成 unicode 编码中的对应字符串。(unicode编码对照表)

     
     
     
     
     
     
     
    v = chr(99)
    print(v) # c
     

    ··· ord，根据字符在unicode编码中找到其对应的十进制。

     
     
     
     
     
     
     
    num = ord('中')
    print(num) # 20013
     

    ··· 随机验证码

     
     
     
     
     
     
     
    import random
    ​
    def get_random_code(length=6):
        data = []
        for i in range(length):
            v = random.randint(65,90)
            data.append(chr(v))
    ​
        return  ''.join(data)
    ​
    ​
    code = get_random_code()
    print(code)
     
     
     
     
     
     
     
     
    import random # 导入一个模块 
    ​
    v = random.randint(起始,终止) # 得到一个机数 高级一些的内置函数
     

    5.11.7 高级一点的函数

    ··· map，循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新的列表中，并返回。

     
     
     
     
     
     
     
    v1 = [11,22,33,44]
    result = map(lambda x:x+100,v1)
    print(list(result)) # 特殊
     

    ··· filter，循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将函数执行的结果筛选后保存到新的列表中，并返回。

     
     
     
     
     
     
     
    v1 = [11,22,33,'asd',44,'xf']
    ​
    def func(x):
        if type(x) == int:
            return True
        return False
    result = filter(func,v1) # [11,]
    print(list(result))
    ​
    ​
    result = filter(lambda x: True if type(x) == int else False ,v1)
    print(list(result))
    ​
    result = filter(lambda x: type(x) == int ,v1)
    print(list(result))
     

    ··· reduce，循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将函数执行的结果做统计后返回。

     
     
     
     
     
     
     
    import functools
    v1 = ['wo','hao','e']
    ​
    def func(x,y):
        return x+y
    result = functools.reduce(func,v1) 
    print(result)
    ​
    result = functools.reduce(lambda x,y:x+y,v1)
    print(result)
     

    第六章 模块

    6.1 将指定的 “字符串” 进行加密。

     
     
     
     
     
     
     
    import hashlib
    ​
    def get_md5(data):
        obj = hashlib.md5()
        obj.update(data.encode('utf-8'))
        result = obj.hexdigest()
        return result
    ​
    val = get_md5('123')
    print(val)
    ​
    # 加盐
    import hashlib
    ​
    def get_md5(data):
        obj = hashlib.md5("sidrsicxwersdfsaersdfsdfresdy54436jgfdsjdxff123ad".encode('utf-8'))
        obj.update(data.encode('utf-8'))
        result = obj.hexdigest()
        return result
    ​
    val = get_md5('123')
    print(val)
     

    密码加密

     
     
     
     
     
     
     
    import hashlib
    USER_LIST = []
    def get_md5(data):
        obj = hashlib.md5("12:;idrsicxwersdfsaersdfsdfresdy54436jgfdsjdxff123ad".encode('utf-8'))
        obj.update(data.encode('utf-8'))
        result = obj.hexdigest()
        return result
    ​
    ​
    def register():
        print('**************用户注册**************')
        while True:
            user = input('请输入用户名:')
            if user == 'N':
                return
            pwd = input('请输入密码:')
            temp = {'username':user,'password':get_md5(pwd)}
            USER_LIST.append(temp)
    ​
    def login():
        print('**************用户登陆**************')
        user = input('请输入用户名:')
        pwd = input('请输入密码:')
    ​
        for item in USER_LIST:
            if item['username'] == user and item['password'] == get_md5(pwd):
                return True
    ​
    ​
    register()
    result = login()
    if result:
        print('登陆成功')
    else:
        print('登陆失败')
     

    密码不显示 （终端专属）

     
     
     
     
     
     
     
    import getpass
    ​
    pwd = getpass.getpass('请输入密码：')
    if pwd == '123':
        print('输入正确')
     
  • 相关阅读:
    用魔数防范文件上传攻击
    nginx http跳转到https
    tengine安装
    版本标记说明
    nginx基于域名的虚拟主机 反向代理配置实例
    非ROOT用户启动Tomcat
    使用druid连接池的超时回收机制排查连接泄露问题
    Jenkins入门系列之
    centos7 关闭SELINUX 防火墙
    mac安装IE浏览器
  • 原文地址：https://www.cnblogs.com/usherwang/p/12851466.html
Copyright © 2020-2023  润新知