• python小tips

    函数：

    格式：

    1. def 函数的名字():
    2.     函数体
    3.  
    4.  
    5. 例如：
    6.  
    7. def playgame():
    8.     print("I am playing!")
    9.  
    10.  
    11. 函数调用：
    12. playgame()
    13.  
    14.

         调用的方法： 函数名()     

    函数的定义只是定义函数，调用了才会有结果     

    函数的参数

    分类：
    1.形参：在函数定义的时候，需要准备一些变量来接收信息
        1.位置参数，按照位置一个一个声明变量
        2.默认值参数，在函数声明的时候给变量一个默认值，如果实参不传递信息，此时默认值生效，否则就不生效

    1. def luru(name, age, gender="男"):
    2.     print(name, age, gender)
    3.  
    4. luru("张三", 18)    # 张三 18 男
    5. luru("李四", 18)
    6. luru("王二麻子", 18)
    7. luru("赵敏", 18, "女")    # 赵敏 18 女
    8. luru("周芷若", 18, "女")
    9. luru("吴老二", 18)
           3.动态传参
            1. * 参数名（args） 表示接收所有的位置参数的动态传参，接收到的值被统一放在元组里
            2. ** 参数名（kwargs） 表示接收所有的关键字的动态传参，接收到的值统一放在字典里

    1. def chi(*food):   # * 表示位置参数的动态传参，*接收到的值会被统一放在一个元组里面
    2.     print(food)
    3.  
    4. chi('大米饭', "烧茄子",  "紫菜蛋花汤")   # ('大米饭', '烧茄子', '紫菜蛋花汤')
    5. chi("大米饭")   # ('大米饭',)
    6.  
    7. # 关键字参数的动态接收
    8. def chi(**food):  # ** 表示接收关键字的动态传参，接收到的所有参数都会被处理成字典
    9.     print(food)
    10.  
    11. chi(zhu="小米饭", tang="胡辣汤", )  # {'zhu': '小米饭', 'tang': '胡辣汤'}
            混合使用的顺序：位置参数  >  *args  > 默认值  > **kwargs

        上述参数可以随意搭配使用；位置参数 在 默认值参数之前

    2.实参：实际调用的时候传递信息
        1.位置参数，按照位置进行参数传递
        2.关键字参数，按照参数的名字进行传递参数

    1. def chi(zhu, fu, tang, tian):
    2.       print(zhu, fu, tang, tian)
    3.  
    4.   chi("大米饭", '西红柿炒鸡蛋', "紫菜蛋花汤", "哈根达斯")          # 位置参数
    5.   chi(zhu="小米饭", tang="胡辣汤", fu="西红柿炒鸡蛋", tian="老冰棍")    # 关键字参数
    6.    chi("小米饭","胡辣汤", tang="西红柿炒鸡蛋", tian="老冰棍")   # 混合参数
            3.混合参数 (位置参数放前面，关键字参数放后面---> 否则报错)
        实参在执行的时候，必须保障形参有数据

    open(xxxx,mode="xx",encoding="xxxx")  # xxxx是文件名，这个就是混合参数
            * 在实参位置，是把列表打散成位置参数进行传递
        ** 在实参位置，可以把字典自动转化成关键字参数进行传递

    1. def func(*args):
    2.     print(args)
    3.  
    4. # list少量元素
    5. func(stu_lst[0], stu_lst[1], stu_lst[2], stu_lst[3],)   # ('流川枫', '樱木', '大老王', '隔壁二老王')
    6.  
    7. # list 大量元素
    8. func(*stu_lst)   # * 在实参位置，是把列表打散成位置参数进行传递
    9.                 # ** 在实参位置，可以把字典自动转化成关键字参数进行传递
    10. # ('流川枫', '樱木', '大老王', '隔壁二老王')

          
    返回值

    返回值：函数执行之后，会给调用方一个结果，这个结果就是返回值

关于return：
函数只要执行到了return，函数就会立即停止并返回内容，函数内的return后续代码不会执行

    1. def func(a, b):
    2.     # print(a + b)
    3.     return a + b
    4.  
    5. ret = func(10, 30)
    6. print( ret * 3)     # 90
    7.  
    8.  
    9. # 不写return
    10. def func():
    11.     pass
    12.  
    13. ret = func()
    14.  
    15. print(ret)   # None
    16.  
    17. # 写了return但没有返回值
    18. def fun():
    19.     print(1223)
    20.     return   # 不管return有没有返回值，只要读到return就会让程序停止，后续代码不会执行，有点像循环里的break
    21.     print(234)
    22.  
    23. ret = fun()
    24. print(ret)     # 1223   None
    25.  
    1.如果函数里没有return，此时函数收到的是什么？   默认收到的时None
2.如果写了return
    1.只写了return 后面不跟数据             （充当的break情况）
    2.return 值，此时表示函数有一个返回值，外界能收到一个数据  （用的最多）
    3.return 值1，值2，值3....  此时函数有多个返回值，外界收到的是什么呢     外界收到的是元组，且该元组内存放所有返回值

    内置函数（上）

    内置函数： 直接拿来用的函数 例：print, input
    和数学运算相关
        数据类型： bool、 int、 float、 complex（复数）
        进制转换：bin（二进制）、oct（八进制）, int（十进制），hex（十六进制）
        数学运算：sum, min, max, pow(次方)

    1. # 进制
    2. a = 18
    3. print(bin(a))   # 0b10010   二进制
    4. print(oct(a))   # 0o22    八进制
    5. print(hex(a))    # 0x12    十六进制
    6.  
    7. b = 0b10011
    8. print(int(b))   # 19  二进制转十进制
    9.  
    10. # 数学运算
    11. #  pow
    12. c = 10
    13. d = 3
    14. print(pow(c, d))   # 1000
    15. print(c ** d)    # 1000  表示的也是次方
    16.  
    17. # max , min , sum
    18. lst = [12, 32, 57, 789, 1000]
    19. print(max(lst))   # 1000
    20. print(min(lst))   # 12
    21. print(sum(lst))   # 1890
        和数据结构相关
        列表和元组： list, tuple
        相关内置函数：slice(切片)
        字符串：str,format,bytes,ord(把文字转化成unicode编码中的码位), chr（把unicode编码的码位转化为文字）, repr
        相关内置函数：len, enumerate（能够直接拿到索引和元素）, all（当作and看）, any（当作or看）,     zip, filter, map, sorted,

    1. # 列表
    2. s = {1, 3, 4}
    3. lst = list("呵呵哒")   # list 内部有个for循环
    4. print(lst)    # [1, 3, 4]   ['呵', '呵', '哒']
    5. # list的原理
    6. for item in s:
    7.     lst.append(item)
    8. lst = list("呵呵哒")
    9. print(lst)  # ['呵', '呵', '哒']
    10.  
    11. s = slice(1, 4, 3)  # [1: 4:3]  从1切到4，每3个出来一个
    12. print("呵呵呵呵呵呵"[s])  # 呵
    13.  
    14.  
    15. # format, ord, chr
    16. # format  格式化
    17. a = 18
    18. print(format(a, "b"))   # 二进制 10010
    19.  
    20. print(format(a, "08b"))   # 需要一个由0补充的8位的二进制   00010010    只能补齐，不能切割
    21. c = 12000
    22. print(format(c, "08b"))   # 10111011100000
    23.  
    24. print(format(a, "o"))   # 八进制 22
    25. print(format(a, "x"))    # 十六进制 12
    26.  
    27.  
    28. # ord, chr
    29. a = '中'   # python的内存是unicode
    30. print(ord(a))  # 20013   “中”在unicode中码位是20013
    31. print(chr(20013))   # 中   给出编码位置，展示出文字
    32.  
    33. # enumerate, all, any,
    34. # all, any
    35. print(all([12, "呵呵", "豆沙包"]))    # 把all当作and来看   True
    36. print(all([0, "呵呵", "豆沙包"]))    # False，有一个空就是false
    37. print(any([0, "呵呵", "豆沙包"]))    # True  把any当作or来看
    38. print(any([0, "", ""]))     # False，全是空就是false
    39.  
    40. lst = ["张无忌", "张翠山", "张三丰","张大大"]
    41.  
    42. for item in enumerate(lst):
    43.     print(item)
    44. '''
    45. (0, '张无忌')
    46. (1, '张翠山')
    47. (2, '张三丰')
    48. (3, '张大大')
    49. '''
    50. for index,item in enumerate(lst):
    51.     print(index,item)
    52. #   #  等价于下面
    53. for i in range(len(lst)):
    54.     print(i, lst[i])
    55. '''
    56. 0 张无忌
    57. 1 张翠山
    58. 2 张三丰
    59. 3 张大大
    60. '''
        其他
        id (字符串的内存地址)
        help（）   dir（） （告诉当前数据能执行的操作）print(dir(s))

    python进阶

    作用域

    作用域：变量的访问权限
    全局变量：顶格写，全局作用域
    局部变量：内侧 ，局部作用域

总结： 里面访问外面没问题，外面访问里面不能直接访问
    1. def func():
    2.     c = 199
    3.     return c   # 想要在函数外面访问到函数里面的东西，必须要return,必须！
    4.  
    5. c1 = func()   # 此时调用的func是c的值
    6. print(c1)   # 199

    函数的嵌套

    结论（*）：
    1.函数可以作为返回值进行返回
    2.函数可以作为参数进行相互传递
    函数实际上就是一个变量名，都表示一个内存地址
    1. def fun1():
    2.     pass
    3.  
    4. def fun2():
    5.     fun1()    # 这个叫函数的调用，不叫嵌套
    6.  
    7. fun2()
    8.  
    9. def func1():
    10.     b = 20
    11.     def func2():  # 函数的嵌套
    12.         print(b)
    13.     func2()  # 20 局部的东西，一般都是在局部自己访问使用的
    14.     # func1内部的func2函数访问了局部变量b，并且在调用func1()时输出了20。
    15.     # 外部无法直接访问b和func2，因为它们是在func1内部定义的局部变量和函数。
    16. func1() # 20 这算直接调用func1()
    17. print(func1())  # None
    18. # 输出 None 是因为函数 func1 没有明确地返回任何值。在 Python 中，如果函数没有显式使用 return 语句返回一个值，它将默认返回 None。
    19. print(b)      # 访问不了，外面没办法访问里面
    20. print(func2)  # 访问不了，外面没办法访问里面
    21.  
    22. # 函数嵌套执行过程
    23. def func1():
    24.     print(123)
    25.     def func2():
    26.         print(234)
    27.         def func3():
    28.             print(345)
    29.         print(1)
    30.         func3()
    31.         print(2)
    32.     print(3)
    33.     func2()
    34.     print(4)
    35.  
    36. func1()
    37. """
    38. 只有调用了才会执行
    39. 123
    40. 3
    41. 234
    42. 1
    43. 345
    44. 2
    45. 4
    47. """
    48.  
    49. def func():
    50.     def inner():
    51.         print(123)
    52.     print(inner)  # .inner at 0x000001C7CD54B520> 打印出来的是函数func的局部变量inner的地址
    53.     return inner    # 返回的是函数，如果返回inner()，返回的是None,把函数当成一个变量进行返回
    54.  
    55. b1 = func()   # b1是func的返回值，此时是b1内部的inner
    56. print(b1)   # .inner at 0x000001A8F892B520>  和inner一样
    57. b1()           # 123
    58.  
    59. # 在外部调用局部变量
    60. def an():
    61.     print(123)
    62.  
    63. an()   # 123
    64.  
    65. bn = an  # 把an赋值给了bn
    66. bn()   # 123 此时的bn()就是an()
    67.  
    68. # 函数就是一个变量！
    69.  
    70. # 代理模式
    71. def func(an):
    72.     # print(an)    # 传入func的变量，打印该变量本身
    73.     an()   # 传入func的函数，执行该函数
    74. # 实参可以是函数
    75. def target():
    76.     print("我是target")
    77.  
    78. c = 123
    79. func(c)   # 123   给func传变量c，调用func，输出123
    80. func(target)   #   给func（）传函数，调用func，返回的是传入函数的地址
    81.                 # 用的是  print(an)
    82. func(target)    # 我是target     说明实参可以是函数
    83.

    两个关键字global，nonlocal

    global:在局部引入全局变量
nonlocal: 在局部，引入外层的局部变量
    1. a = 10
    2. def func():
    3.  
    4.     # 此时就想要在函数内部修改全局变量a，怎么办？
    5.     global a   # 把外面的全局变量引入到局部
    6.     a = 20  # 创建一个局部变量，并没有改变全局变量中的a
    7.  
    8. func()
    9. print(a)   # 10 为什么还是10（按理说应该是20）？  只写了a = 20不行
    10.             # 有了global a ，a的结果变成20   20
    11.  
    12.  
    13.  
    14.  
    15. def func():
    16.     a = 10
    17.     def func2():
    18.         nonlocal a  # 向外找一层，看有没有该变量，如果有就引入，如果没有，继续向外扩一层，直到全局（不包括）
    19.         a = 20
    20.     func2()
    21.     print(a)
    22.  
    23. func()   # 10
    24.         # 20   （nonlocal a）

    闭包

    闭包：本质：内层函数对外层函数的局部变量的使用，此时内层函数被称为闭包函数
    1. 可以让一个变量常驻于内存
    2. 避免全局变量被修改

    1. def func():
    2.     a = 10   # 把成员变量变成局部变量，将其保护起来
    3.     def inner():
    4.         nonlocal a
    5.         a += 1
    6.         return a
    7.     return inner     # 此时inner构成闭包函数
    8.  
    9. ret = func()   # inner  ==> ret ==> 什么时候执行
    10.  
    11. r1 = ret()
    12. print(r1)   # 11
    13.  
    14. r2 = ret()
    15. print(r2)   # 12

    装饰器

    函数回顾：

    1. 函数可以作为参数进行传递
2.  函数可以作为返回值进行返回
3. 函数名称可以当成变量一样进行赋值
    1. # 1.函数可以作为参数传递
    2. def func():
    3.     print("我是函数")
    4.  
    5. def gggg(fn):
    6.     fn()
    7.  
    8. gggg(func)   # 我是函数
    9.  
    10. # 2.函数可以作为返回值进行返回
    11. def func():
    12.     def inner():
    13.         print("123")
    14.     return inner
    15.  
    16. ret = func()
    17. ret()   # 123
    18.  
    19. # 3.函数名称可以当成变量一样进行赋值
    20. def func1():
    21.     print("我是函数1")
    22.  
    23. def func2():
    24.     print("我是函数2")
    25. func1 = func2
    26. func1()   # 我是函数2
    装饰器：  --> 要求记住最后的结论
    装饰器本质上是一个闭包
    作用：
        在不改变原有函数调用的情况下，给函数增加新功能
        直白：可以在函数前后添加新功能，但不改原代码

    应用： 在用户登录的地方，日志，

    通用装饰器写法：
    def wrapper(fn):     wrapper: 装饰器，fn：目标函数
        def inner(* args, **kwargs):
            # 在目标函数执行之前
            ret = fn(* args, **kwargs)            # 执行目标函数
            # 在目标函数执行之后
            return ret
        return inner     # 千万不能加小括号

    @wrapper
    def target():
        pass

    target()   # ==> inner()

    一个函数可以被多个装饰器装饰

    @wrapper1
    @wrapper2
    def target():
        print('我是目标')

target()

    作用顺序： wrapper1 wrapper2  target  wrapper2  wrapper1y

    一个函数被两个装饰器装饰

    1. def wrapper1(fn):  # fn: wrapper2.inner
    2.     def inner(*args, **kwargs):
    3.         print("这里是wrapper1,进")   # 1
    4.         ret = fn(*args,**kwargs)   #  调用 fn : wrapper2.inner
    5.         print("这里是wrapper1,出")   # 4
    6.         return ret
    7.     return inner
    8.  
    9. def wrapper2(fn):   # fn ： target
    10.     def inner(*args, **kwargs):
    11.         print("这里是wrapper2,进")   # 2
    12.         ret = fn(*args,**kwargs)    # target
    13.         print("这里是wrapper2,出")    # 4
    14.         return ret
    15.     return inner
    16.  
    17. @wrapper1  # target = wrapper1(wrapper2.inner) ==> target:wrapper1.inner
    18. @wrapper2  # target = wrapper2(target)  此时的target是wrapper2的inner
    19. def target():
    20.     print('我是目标')
    21.  
    22. target()
    23.  
    24. wrapper1 wrapper2  target  wrapper2  wrapper1
    25. """
    26. 这里是wrapper1,进
    27. 这里是wrapper2,进
    28. 我是目标
    29. 这里是wrapper2,出
    30. 这里是wrapper1,出
    31. """

    装饰器实战

    1. login_flag = False
    2. def login_verify(fn):
    3.     def inner(*args, **kwargs):
    4.         global login_flag
    5.         if login_flag == False:
    6.             # 这里完成登录校验
    7.             print("还未完成用户登录操作")
    8.             while 1:
    9.                 username = input("用户名：")
    10.                 password = input("密码：")
    11.                 if username == "admin" and password == "1234":
    12.                     print("登陆成功！")
    13.                     login_flag = True
    14.                     break
    15.                 else:
    16.                     print("登陆失败，用户名或密码错误")
    17.  
    18.         # print(1223)
    19.         ret = fn(*args, **kwargs)  # 后续的程序
    20.         return ret
    21.     return inner
    22.  
    23. @login_verify
    24. def add():
    25.     print("添加员工信息")
    26.  
    27. @login_verify
    28. def delete():
    29.     print("删除员工信息")
    30.  
    31. @login_verify
    32. def upd():
    33.     print("修改员工信息")
    34.  
    35. @login_verify
    36. def search():
    37.     print("查询员工信息")
    38.  
    39. add()
    40. delete()
    41. upd()
    42. search()

    迭代器

    for 变量 in 可迭代：
    pass

iterable: 可迭代的东西
    str, list, tuple, dict, set, open()

可迭代的数据类型都会提供一个叫迭代器的东西，这个迭代器可以帮我们把数据类型中的所有数据逐一拿到

获取迭代器的两种方案：
    1.iter()  内置函数可以直接拿到迭代器
    2.__iter__()

从迭代器中拿到数据：
    1.next() 内置函数
    2.__next__() 特殊方法

for 里面一定是要拿迭代器的，所以所有不可迭代的东西不能用for循环
for 循环里面一定有__next__()或next()  出现

总结：迭代器本身统一了不同数据类型的遍历工作

迭代器本身也是可迭代

迭代器本身的特性：
    1.只能向前，不能反复
    2.特别省内存
    3.惰性机制（只要不访问next就不挪）


    1. # next
    2. it = iter("你叫什么名字啊")
    3. print(it)  # 
    4. print(next(it))   # 你
    5. print(next(it))   # 叫
    6. print(next(it))   # 什
    7. print(next(it))   # 么
    8. print(next(it))   # 名
    9. print(next(it))   # 字
    10. print(next(it))   # 啊
    11.  
    12. print(next(it))     # StopIteration：迭代已经停止了，不能再从迭代器中拿东西了
    13.  
    14. #__iter__()
    15. it = "呵呵哒".__iter__()
    16. # print(it)  # 
    17. print(it.__next__())   # 呵
    18. print(it.__next__())   # 呵
    19. print(next(it))      # 哒
    20.  
    21. # 模拟for循环的工作原理
    22.  
    23. s = "我是数据"
    24. it = s.__iter__()  # 拿到迭代器
    25. while 1:
    26.     try:         # 异常值处理
    27.         data = it.__next__()
    28.         print(data)  # for循环的循环体
    29.     except StopIteration:
    30.         break
    31. print(12345)
    32. """
    33. 我
    34. 是
    35. 数
    36. 据
    37. 12345
    38. """

    迭代器本身就是可迭代的

    1. # 迭代器本身也是可迭代的
    2. s = "你好啊，我叫tom"
    3. it = s.__iter__()
    4.  
    5. for mm in it:
    6.     print(mm)
    7.  
    8.  
    9. """ 
    10. 你
    11. 好
    12. 啊
    13. ，
    14. 我
    15. 叫
    16. t
    17. o
    18. m
    19. """

    生成器

    生成器(generator)：
    生成器的本质就是迭代器

    创建生成器的两种方案：
        1.生成器函数
        2.生成器表达式

    生成器函数：
        关键字：yield
        生成器函数执行的时候，并不会执行函数，得到的是生成器

        yield:只要函数中出现了yield,他就是一个生成器函数
            作用：
                1.可以返回数据
                2.可以分段的执行函数中的内容,通过__next__()可以执行到下一个yield的位置

        优势：
            用好了，特别省内存

    生成器的表达式：------> 一次性的
        语法：(数据表达式 for循环 if判断)
    1. def func():
    2.     print(123456)
    3.     yield 999   # yield也有返回的意思，只有执行到next的时候才会返回数据
    4.  
    5. ret = func()
    6. print(ret)   # 
    7. print(ret.__next__())    # yield只有执行到next才会返回数据
    8. print(ret.__next__())   # StopIteration
    9.  
    10. # yield可以分段的执行函数中的内容
    11. def func():
    12.     print(123)
    13.     yield 555
    14.     print(234)
    15.     yield 212
    16.  
    17. ret = func()
    18. print(ret.__next__())  # 123 555
    19. print(ret.__next__())   # 234 212
    20.  
    21. # 用yeild的好处
    22. # 省内存
    23. def order():
    24.     lst = []
    25.     for i in range(10000):
    26.         lst.append(f"衣服{i}")
    27.         if len(lst) == 50:
    28.             yield lst
    29.             # 下一次拿数据
    30.             lst = []
    31.  
    32. gen = order()
    33. print(gen.__next__())  # ['衣服0',...'衣服49']
    34. print(gen.__next__())  # ['衣服50',...'衣服99']

    推导式

    推导式：
    简化代码。
    语法：
        列表推导式：[数据表达式 for循环 if判断]
        集合推导式：{数据表达式 for循环 if判断}
        字典推导式：{k:v for循环 if判断}

    不要把推导式妖魔化

    元组推导式？？？  元组没有推导式，他不能增加数据
    (数据表达式 for循环 if判断)  ----->  不是元组表达式，根本没有元组表达式，这是生成器表达式

    1. lst = []
    2. for i in range(10):
    3.     lst.append(i)
    4.  
    5. print(lst)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    6.  
    7. # 上下等价
    8.  
    9. lst = [i for i in range(10)]
    10. print(lst)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    11.  
    12. # 1.创建一个列表[1,3,5,7,9]
    13. lst = [i for i in range(1, 10, 2)]   # [1, 3, 5, 7, 9]
    14. lst = [i for i in range(10) if i % 2 == 1]   # [1, 3, 5, 7, 9]
    15. print(lst)
    16.  
    17. # 2.生成50件衣服
    18. lst = [f"衣服{i}" for i in range(50)]
    19. print(lst)
    20.  
    21. # 3.将如下列表中所有英文字母修改为大写
    22. lst1 = ["allen", "tony", "jerry", "tom"]
    23. lst2 = [item.upper() for item in lst1]
    24. print(lst2)   # ['ALLEN', 'TONY', 'JERRY', 'TOM']
    25.  
    26. # 集合推导式
    27. s = {i for i in range(10)}
    28. print(s)  # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    29.  
    30.  
    31.  
    32. # 请将下列的列表修改成字典，要求：索引作为key，数据作为value
    33. lst = ['赵本山', '蜜蜂', '狄仁杰', '奥特曼']
    34. dic = {i:lst[i] for i in range(len(lst))}
    35. print(dic)  # {0: '赵本山', 1: '蜜蜂', 2: '狄仁杰', 3: '奥特曼'}

    生成器表达式

    1. # 生成器的表达式
    2. gen = (i**2 for i in range(10))
    3. print(gen.__next__())  # 0
    4. print(gen.__next__())  # 1
    5. print(gen.__next__())  # 4
    6. print(gen.__next__())  # 9
    7.  
    8.  
    9. # 拿出gen的所有元素
    10. for item in gen:
    11.     print(item)
    12.  
    13. lst = list(gen)
    14. print(lst)   # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    15.             # 再运行一次为[]  生成器表达式是一次性的东西
    16.  
    17. # s = list("周杰伦")  # list() ==> for ==> next()
    18. # print(s)  # ['周', '杰', '伦']

    匿名函数

    匿名函数：
    lambda表达式
    语法：
        变量 = lambda 参数，参数2，参数3...:返回值

    1. # def func(a, b):
    2. #     return a + b
    3. #
    4. # ret = func(23, 45)
    5. # print(ret)   # 68
    6.  
    7. fn = lambda a, b: a + b
    8. print(fn)   #  at 0x0000017324AFB520> 说明他本质是个函数
    9.  
    10. ret = fn(12, 13)
    11. print(ret)   # 25

    内置函数（下）

    zip:可以把多个可迭代内容合并

    1. lst1 = ["赵本山", "范伟", "苏有朋"]
    2. lst2 = [40, 38, 42]
    3. lst3 = ["卖拐", "耳朵大有福", "情深深雨蒙蒙"]
    4.  
    5. result = []
    6. for i in range(len(lst1)):
    7.     first = lst1[i]
    8.     second = lst2[i]
    9.     third = lst3[i]
    10.     # result = result.append((first, second, third))
    11.     # list.append()方法会原地修改列表并返回None，
    12.     # 因此在循环中将其结果分配给result会导致result变成None。应该将元组添加到result列表而不是使用append()方法修改result。
    13.     result.append((first, second, third))
    14. print(result)   # [('赵本山', 40, '卖拐'), ('范伟', 38, '耳朵大有福'), ('苏有朋', 42, '情深深雨蒙蒙')]
    15.  
    16. result = zip(lst1, lst2, lst3)
    17.  
    18. for item in result:
    19.     print(item)
    20. """
    21. ('赵本山', 40, '卖拐')
    22. ('范伟', 38, '耳朵大有福')
    23. ('苏有朋', 42, '情深深雨蒙蒙')
    24. """
    locals：查看当前位置局部变量的内容
globals: 查看全局


    1. a = 144
    2. print(locals())  # 此时locals被写在全局作用域范围内，此时看到的就是全局作用域中的内容
    3.  
    4. def func():
    5.     a = 334
    6.     print(locals())  # 此时locals放在局部作用域范围，看到的是局部作用域的内容
    7.  
    8. func()  # {'a': 334}
    9.  
    10. c = 12
    11. print(globals())  # globals看到的是全局作用域中的内容
    12.  
    13. def func():
    14.     a = 334
    15.     print(globals())  # 此时看到的仍然是全局作用域的内容
    16.  
    17. func()
    sorted: 排序（默认从小到大）

    1. lst = [13, 45, 65, 77, 787, 21, 38, 60]
    2. s = sorted(lst)
    3. s1 = sorted(lst, reverse=True)
    4. print(s1)  # [787, 77, 65, 60, 45, 38, 21, 13]
    5. print(s)  # [13, 21, 38, 45, 60, 65, 77, 787]  正常排序，由小到大
    6.  
    7. lst = ["湫", "狄仁杰", "李元芳", "超级狠人武则天", "爱因斯坦"]
    8.  
    9. # sorted(lst, key=排序函数)
    10. # sorted工作原理是：先读取lst的东西，根据排序函数返回的值进行排序
    11. # def func(item):   # 此时item对应的是列表中的每一项数据
    12. #   return len(item)
    13. # s = sorted(lst,key=func)
    14. # print(s)
    15.  
    16. s = sorted(lst, key=lambda x: len(x))
    17. print(s)   # ['湫', '狄仁杰', '李元芳', '爱因斯坦', '超级狠人武则天']  一般lambda配合sorted使用
    18.  
    19.  
    20. lst = [
    21.     {"id": 1, "name": "周杰伦", "age": "17", "salary": "56700"},
    22.     {"id": 2, "name": "周润发", "age": "57", "salary": "56720"},
    23.     {"id": 3, "name": "周海媚", "age": "37", "salary": "34560"},
    24.     {"id": 4, "name": "周波通", "age": "23", "salary": "56740"},
    25.     {"id": 5, "name": "周大生", "age": "56", "salary": "24350"},
    26.     {"id": 6, "name": "周生生", "age": "77", "salary": "86540"},
    27.     {"id": 7, "name": "周洲洲", "age": "45", "salary": "45670"},
    28. ]
    29.  
    30. # 1,根据每个人年龄排序
    31. s = sorted(lst, key=lambda d: d['age'])
    32. print(s)
    33.  
    34.  
    35. # 2,根据工工资从大到小排序
    36. s = sorted(lst, key=lambda d: d["salary"], reverse=True)
    37. print(s)
    filter: 筛选filter(筛选的条件，筛选对象)，根据筛选条件来判断该值是否保留

    1. lst = ["张无忌", "张三丰", "张翠山", "马保国", "灭绝大师太", "小狐仙"]
    2.  
    3. f = filter(lambda x:not x.startswith("张"), lst)
    4. print(list(f))   # ['马保国', '灭绝大师太', '小狐仙']
    map: 映射,对数据批量处理map(筛选的条件，筛选对象)，根据筛选条件直接保留
    1. st = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    2.  
    3. result = [item * item for item in lst]
    4. print(result)   # [1, 4, 9, 16, 25, 36, 49, 64, 81]
    5.  
    6. r = map(lambda x: x*x,lst)
    7. print(list(r))   # [1, 4, 9, 16, 25, 36, 49, 64, 81]

  • 相关阅读:
    Linux操作系统的基础IO
    Python之哈希表-封装和解构
    c++builder6.0 数据库查询函数select * into 功能的实现
    java_jsp-ssm留学申请服务系统springmvc
    mov视频损坏怎么修复?修复秘诀
    Android扫码连接WIFI实现
    linux学习：视频输入+V4L2
    Day35PHP数组
    【进阶C语言】字符串与内存库函数认识与模拟实现
    Proxy-Reflect
  • 原文地址：https://blog.csdn.net/m0_68682144/article/details/139558967