## 深浅拷贝

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 赋值运算
  5. # 可变的数据类型:由于数据类型可变，修改数据会在原来的数据的基础上进行修改，
  6. # 可变的数据类型有：列表，字典
  7. l1 = [1, 2, 3]
  8. l2 = l1
  9. l3 = l2
  10. # l1 = [1, 2, 3, 4]  # 注意这不是修改数据，而是在内存中重新创建了一份数据，然后L1 指向了这份新数据
  11. l1.append(666)  # 在原来的数据上修改
  12. print(l1, l2, l3)  # [1, 2, 3, 666] [1, 2, 3, 666] [1, 2, 3, 666]
  13. print(id(l1), id(l2), id(l3))  # 140349669255176 140349669255176 140349669255176
  14. print("--" * 30)
  16. # 不可变的数据类型:由于数据类型是不可变的，不可修改，会在内存中在重新创建一份新的数据
  17. # 不可变的数据类型有：字符串，数字，bool值，元组等
  18. l4 = 'abcd'
  19. l5 = l4
  20. l4 = [1, 2, 3]
  21. print(l4, l5)  # [1, 2, 3] abcd
  22. print(id(l4), id(l5))  # 140230928510856 140230926894952
  23. print("--" * 30)
  25. # 浅copy
  26. # copy一个新列表(dict)，列表在内存中是新的，但是列表里面的元素，完全沿用之前的元素。
  27. l5 = [1, 2, 3, [22, 33]]
  28. l6 = l5.copy()
  29. print(id(l5), id(l6))  # 140589566668360 140589566718024
  30. l5.append(666)
  31. l5.remove(1)
  32. print(l5, l6)  # [2, 3, [22, 33], 666] [1, 2, 3, [22, 33]]
  33. print("--" * 30)
  35. # 列表在内存中是新的，但是列表里面的元素，完全沿用之前的元素
  36. l5 = [1, 2, 3, [22, 33]]
  37. l6 = l5.copy()
  38. print(id(l5[0]))  # 4459755568
  39. print(id(l6[0]))  # 4459755568
  40. l5[-1].append(666)
  41. print(l5, l6)  # [2, 3, [22, 33, 666], 666] [1, 2, 3, [22, 33, 666]]
  42. print("--" * 30)
  44. # 深copy
  45. # 总结 深copy则会在内存中开辟新空间，将原列表以及列表里面的可变的数据类型重新创建一份，
  46. # 不可变的数据类型则沿用之前的，指向之前的数据
  47. import copy
  48. l7 = [1, 2, 3, [22, 33]]
  49. l8 = copy.deepcopy(l7)
  50. print(id(l7), id(l8))  # 140686186753032 140686186752968
  51. l7[-1].append(666)
  52. l7.remove(1)  # 只是删除了l1列表中和内存中的数据1的指向关系，并不是在内存中删除了数据1
  53. print(l7, l8)  # [2, 3, [22, 33, 666]] [1, 2, 3, [22, 33]]
  54. print("--" * 30)
  56. # id 对象的内存地址
  57. # == 比较两边的数值是否相等
  58. # is 判断的两边对象的内存地址是否是同一个
  59. print(2 == 2)
  60. print("--" * 30)
  62. # 切片是浅copy ******
  63. l1 = [1, 2, 3, [22, 33]]
  64. l2 = l1[:]  # 切片是浅copy
  65. l1[-1].append(666)
  66. print(id(l1), id(l2)) # 40282048785864 140282048785608
  67. print(l1, l2)  # [1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33, 666]]

文件操作

文件操作介绍

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. """
  5. 文件三参数
  6.     path：文件的路径
  7.     encoding:文件以什么编码方式存储，就以什么编码方式读取
  8.     mode:读，写，读写，写读，追加，改等等
  10.     三个大方向：
  11.         带b的模式操作对象都是非文字类的文件：视频，音频，图片。
  13.         读（r rb r+ rb+）
  14.             r   读模式
  15.             rb
  16.             r+  读写模式
  17.             rb+
  19.         写 w wb w+ w+b ：如果原文件存在，则清空原文件，在写入。这个慎用
  20.             w   写模式
  21.             wb
  22.             w+  写读模式
  23.             wb+
  25.         追加(a ab a+ a+b)
  26.             a   追加
  27.             ab
  28.             a+
  29.             ab+
  31.     文件操作的其他方法：
  32.         f.read()
  33.         f.write()
  34.         f.readline()
  35.         f.readlines()
  36.         f.close()
  37.         f.seek()
  38.         f.tell()
  39. """
  41. f1 = open("test.txt",encoding='utf-8',mode='r')
  42. content = f1.read()
  43. print(content)
  44. f1.close()
  45. """
  46. f1变量,文件句柄。
  47. open 内置函数,底层调用的操作系统的操作文件功能的接口。
  48. windows: gbk，linux：utf-8  ios: utf-8
  49. 操作文件总共3步；
  50.     1，打开文件，产生文件句柄。
  51.     2，对文件句柄进行操作。
  52.     3，关闭文件句柄。
  53. """
  55. """
  56. # 错误示范：
  57. # 1，UnicodeDecodeError: 'gbk' codec can't decode...   编解码错误。
  58. # 2,路径错误。路径分隔符 与后面的字符产生特殊的意义。 解决方式 r 或者 \
  59.     #f1 = open(r"d:\test\r文件读写test.txt",encoding='utf-8',mode='r')
  60. """

文件操作-读模式

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 读模式（r rb r+ rb+）
  6. # r模式
  7. # 默认就是r模式
  8. # 1.1 read()    # 全部读取文件内容，如果文件过大，可能会导致内存不足
  9. f1 = open('test.txt', encoding='utf-8', mode='r')
  10. content = f1.read()
  11. print(content, type(content))  # <class 'str'> 对文件进行读取出来的都是字符串类型
  12. print("=" * 30)
  14. # 1.2 read(n)
  15. # r模式下,  n代表字符。
  16. f1 = open('test.txt', encoding='utf-8', mode='r')
  17. content = f1.read(3)
  18. print(content)
  19. print("=" * 30)
  21. # 1.3 readline() 按行读取
  22. f1 = open('test.txt', encoding='utf-8', mode='r')
  23. print(f1.readline().strip())
  24. print(f1.readline().strip())
  25. print(f1.readline().strip())
  26. f1.close()
  27. print("=" * 30)
  29. # 1.4 readlines()  返回一个列表,列表里面的元素是原文件每一行
  30. f1 = open('test.txt', encoding='utf-8', mode='r')
  31. content = f1.readlines()
  32. print(content)
  33. f1.close()
  34. print("=" * 30)
  36. # 1.5 for循环  *****注意平常读取大文件就需要用这种方法
  37. f1 = open('test.txt', encoding='utf-8', mode='r')
  38. for line in f1:
  39.     print(line.strip())
  40. f1.close()
  41. print("=" * 30)
  43. # rb模式 读取一些非文字类的文件，如图片，视频等
  44. # 5种读的模式， read()  read(n)  readline()  readlines()  for循环读取
  45. # 如果是 rb 模式，就不需要规定编码了 encoding不是编码或解码，它是规定你这个文件到底采用哪种编码模式而已
  46. f1 = open('test.txt', mode='rb')
  47. content = f1.read()
  48. print(content)
  49. print(content.decode('utf-8'))  # 解码 utf-8 ---> unicode
  50. f1.close()
  51. print("---rb---")
  52. print("=" * 30)
  54. # rb 模式读取图片
  55. f1 = open('time1.jpg', mode='rb')
  56. content = f1.read()
  57. print(content)
  58. f1.close()
  59. print("=" * 30)
  61. # r+ 读写模式
  62. f = open('log1', encoding='utf-8', mode='r+')
  63. print(f.read())
  64. f.write('666\n')
  65. f.close()
  66. print("=" * 30)
  68. # 先写后读会出问题 会覆盖
  69. f = open('log1', encoding='utf-8', mode='r+')
  70. f.write('松岛岛')
  71. print(f.read())
  72. f.close()
  73. print("=" * 30)
  75. # rb+ 模式

文件操作-写模式

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # w 写模式
  5. # 没有文件，创建文件写入内容
  6. # 有文件，先清空内容后写入
  7. f = open('log1', encoding='utf-8', mode='w')
  8. f.write('123456')
  9. f.write('深圳 ~~~')
  10. f.write('深圳 ~~~')
  11. f.write('深圳 ~~~')
  12. f.write('深圳 ~~~')
  13. f.write('深圳 ~~~')
  14. f.close()
  16. # wb 写模式(以bytes类型写入到文件)
  17. # 把bytes类型写入到文件 --图片
  18. f1 = open('time1.jpg', mode='rb')
  19. content = f1.read()
  20. f1.close()
  21. f2 = open('time2.jpg', mode='wb')
  22. f2.write(content)
  23. f2.close()
  25. # w+ 写读模式
  26. f = open('log1', encoding='utf-8', mode='w+')
  27. f.write('老男孩教育...')
  28. f.seek(0)   # 调整光标（指针）到最开始
  29. print(f.read())
  30. f.close()
  32. # wb+ 写读模式(bytes)

文件操作-追加模式

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # a 追加
  5. # 没有文件创建文件追加内容，有文件，在文件最后追加内容。
  6. f = open('log3', encoding='utf-8', mode='a')
  7. f.write('老男孩')
  8. f.close()
  10. # 有文件，在文件最后追加内容。
  11. f = open('log1', encoding='utf-8', mode='a')
  12. f.write('666')
  13. f.close()

文件操作-修改

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 文件的修改：所有的文件编辑器都要经过下面这5步才能对文件进行修改
  5. #     1，以读的模式打开原文件
  6. #     2，以写的模式打开新文件
  7. #     3，读取原文件对源文件内容进行修改形成新内容写入新文件
  8. #     4，将原文件删除
  9. #     5，将新文件重命名成原文件
  11. # # 方法一 小文件可以
  12. # # 1，以读的模式打开原文件
  13. # # 2，以写的模式打开新文件
  14. # import os
  15. # with open('tom个人简历', encoding='utf-8') as f1, open('tom个人简历.bak', encoding='utf-8', mode='w') as f2:
  16. #     # 3，读取原文件对源文件内容进行修改形成新内容写入新文件
  17. #     old_content = f1.read()
  18. #     new_content = old_content.replace('tom', 'SB')
  19. #     f2.write(new_content)
  20. # # 4，将原文件删除。
  21. # os.remove('tom个人简历')
  22. # # 5，将新文件重命名成原文件。
  23. # os.rename('tom个人简历.bak', 'tom个人简历')
  25. # 方法二： 推荐使用这种方法
  26. # 1,以读的模式打开原文件。
  27. # 2，以写的模式打开新文件。
  28. import os
  29. with open('tom个人简历', encoding='utf-8') as f1, open('tom个人简历.bak', encoding='utf-8', mode='w') as f2:
  30.     # 3，读取原文件对源文件内容进行修改形成新内容写入新文件。
  31.     for old_line in f1:
  32.         new_line = old_line.replace('SB', 'tom')
  33.         f2.write(new_line)
  35. # 4，将原文件删除。
  36. os.remove('tom个人简历')
  37. # 5，将新文件重命名成原文件。
  38. os.rename('tom个人简历.bak', 'tom个人简历')

文件操作-其他常用方法

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 其他操作方法：
  5. # readable() writable()  ***      文件句柄是否可读，可写
  6. # seek 调整光标位置 按照字节   ***
  7. # seek(0)  将光标移动到开始
  8. # seek(0，2)  将光标移动到最后。
  9. # tell 获取光标位置 按照字节。  ***
  10. # flush 刷新 保存  ***
  11. # truncate 截取原文件，从头开始截，
  12. f = open('log3', encoding='utf-8')
  13. f.seek(1)
  14. print(f.read())
  15. print(f.tell())
  16. f.seek(0)  # 将光标移动到开始
  17. print(f.read())
  18. f.seek(0, 2)  # 将光标移动到最后
  19. print(f.read())
  20. f.close()
  21. print("---" * 30)
  23. # writable() 是否可写
  24. f = open('log3', encoding='utf-8')
  25. print(f.read())
  26. print(f.writable())  # False 是否可写
  27. if f.writable():
  28.     f.write('111')
  29. f.close()
  30. print("---" * 30)
  32. # flush()
  33. f = open('log3', encoding='utf-8', mode='w')
  34. f.write('fjdsklafjdfjksaadfadf')
  35. f.flush()
  36. f.close()
  38. # 截取原文件，从头开始截，需要在可写的模式下，并且不清空原文件
  39. f = open('log3', encoding='utf-8', mode='r+')
  40. f.truncate(3)
  41. f.close()

函数

函数的初识

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. """
  5. # 面向过程编程
  6. s1 = 'hello jerry'
  7. count = 0
  8. for i in s1:
  9.     count += 1
  10. print(count)
  12. l1 = [1, 2, 3, 4, 5]
  13. count = 0
  14. for i in l1:
  15.     count += 1
  16. print(count)
  18. # 缺点：
  19. # 1，代码重复太多。
  20. # 2，代码的可读性差。
  21. """
  23. # 函数的初识
  24. def my_lf_len(s):
  25.     sun = 0
  26.     for _ in s:
  27.         sun += 1
  28.     print(sun)
  30. s1 = 'hello word'
  31. my_lf_len(s1)
  32. l1 = [1, 2, 3, 3, 5, 56, 6, 6]
  33. my_lf_len(l1)
  35. # 1，函数是什么？
  36. # 功能体，一个函数封装的一个功能
  37. # 结构：
  38. '''
  39. def 函数名():
  40.     函数体
  41. '''
  43. # 2，函数什么时候执行
  44. # 被调用的时候执行 函数名+（）
  45. def my_lf_len(s):
  46.     sum = 0
  47.     for _ in s:
  48.         sum += 1
  49.     print(sum)
  51. my_lf_len('how are you?')
  53. # 3，函数的返回值 return
  54. def tantan():
  55.     print('搜索')
  56.     print('左滑动一下')
  57.     print('右滑动一下')
  58.     # return
  59.     print('发现美女，打招呼')
  60.     # return '美女一枚'
  61.     # return ['恐龙一堆']
  62.     # return '小萝莉', '肯德基', '御姐'
  63.     return {'name': 'alnk', 'age': 18}, [1, 2, 3, 4, 5]    # 这算多个值
  65. ret = tantan()
  66. print(ret, type(ret))
  67. # 调用一次执行一次
  68. tantan()
  69. tantan()
  70. tantan()
  72. # 返回值
  73. '''
  74. return:
  75.     1，终止函数
  76.     2，给函数的调用者（执行者）返回值
  77.         return             --->  None
  78.         return   单个值    --->  单个值   --被返回的数据是什么数据类型就是什么类型
  79.         return   多个值    ---> (多个值,) --元组
  80. '''

函数的参数

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 实参和形参
  5. def Tantan(sex):  # 函数的定义:sex形式参数，形参
  6.     print('搜索')
  7.     print('左滑动一下')
  8.     print('右滑动一下')
  9.     print('发现美女，打招呼')
  10.     return '小萝莉', '肯德基', '御姐'
  12. # 函数的参数
  13. Tantan('女')  # 函数的执行：'女' 实际的数据， 实参
  15. # 从两方面讲函数的参数：实参 和 形参
  16. # 一 实参角度
  17. # 1.位置参数 从左至右，一一对应
  18. def Tantan(sex, age):
  19.     print('筛选性别%s,年龄%s左右' % (sex, age))
  20.     print('搜索')
  21.     print('左滑动一下')
  22.     print('右滑动一下')
  23.     print('发现美女，打招呼')
  25. Tantan('女', 28)
  26. print("----" * 30)
  28. # 练习：比大小，返回大的数字
  29. def max_(a, b):
  30.     # if a > b:
  31.     #     return a
  32.     # else:
  33.     #     return b
  34.     # return a if a > b else b
  35.     return a if a > b else b
  37. print(max_(100, 200))
  38. print("----" * 30)
  40. # 扩展：三元运算符
  41. a = '饼'
  42. b = '西瓜'
  43. ret = a if 3 > 2 else b
  44. print(ret)
  45. print("----" * 30)
  47. # 2.关键字参数 一一对应。
  48. # 函数参数较多 记形参顺序较麻烦时，需要关键字参数
  49. def Tantan(sex,age,area):
  50.     print('筛选性别%s, %s附近，年龄%s左右的美女' %(sex,area,age))
  51.     print('搜索')
  52.     print('左滑动一下')
  53.     print('右滑动一下')
  54.     print('发现美女，打招呼')
  56. Tantan(sex='女',area='南山区',age='28')
  57. print("----" * 30)
  59. # 3.混合参数  一一对应,关键字参数必须要在位置参数后面。
  60. def Tantan(sex,age,area):
  61.     print('筛选性别%s,%s 附近，年龄%s左右的美女' %(sex,area,age))
  62.     print('搜索')
  63.     print('左滑动一下')
  64.     print('右滑动一下')
  65.     print('发现美女，打招呼')
  67. Tantan('女',28,area='南山区')
  68. print("----" * 30)
  70. # 二 形参角度
  71. # 1.位置参数 从左至右，一一对应。
  72. def Tantan(sex,age):
  73.     print('筛选性别%s,年龄%s左右' %(sex,age))
  74.     print('搜索')
  75.     print('左滑动一下')
  76.     print('右滑动一下')
  77.     print('发现美女，打招呼')
  79. Tantan('女', 28)
  80. print("----" * 30)
  82. # 2.默认参数  : 使用最多的一般不更改的参数，默认参数一定放在位置参数后面
  83. def Tantan(area,age,sex='girl'):
  84.     print('筛选性别%s, %s 附近，年龄%s左右的美女' %(sex,area,age))
  85.     print('搜索')
  86.     print('左滑动一下')
  87.     print('右滑动一下')
  88.     print('发现美女，打招呼')
  90. Tantan('南山区',28,'laddboy')
  91. print("----" * 30)
  93. # 3.万能参数（动态参数） *args, **kwargs
  94. def Tantan(*args, **kwargs):
  95.     # 函数的定义： * 代表聚合。
  96.     # * 将实参角度所有的位置参数放到一个元祖中，并将元组给了args
  97.     # ** 将实参角度所有的关键字参数放到一个字典中，并将字典给了kwargs
  98.     print(args)
  99.     print(kwargs)
  100.     # print('筛选地域：%s,年龄%s' % args)
  101.     # print('搜索')
  102.     # print('左滑动一下')
  103.     # print('右滑动一下')
  104.     # print('发现美女，打招呼')
  105.     # print(kwargs)
  107. # Tantan('南山区','28', '性格好','身材好', '家境好')
  108. Tantan('南山区', '28', body='身材好', voice='萝莉音', money='白富美')
  109. print("----" * 30)
  111. def Tantan(*args,**kwargs):
  112.     # 函数的定义： * 代表聚合。
  113.     # *  将实参角度所有的位置参数放到一个元祖中，并将元组给了args
  114.     # ** 将实参角度所有的关键字参数放到一个字典中，并将字典给了kwargs
  115.     print(args)
  116.     print(kwargs)
  118. Tantan('南山区','28',body='身材好',voice='萝莉音',money='白富美')
  119. print("---- 1 -----------------------------------------")
  121. l1 = [1, 2, 3]
  122. l2 = (4, 5, 6)
  123. Tantan(*l1, *l2)  # 函数的执行：*iterable 将l1打散，添加到args
  124. print("---- 2 -----------------------------------------")
  126. Tantan(1, 2, 3, 4, 5, 6)
  127. print("---- 3 -----------------------------------------")
  129. dic1 = {'name': "tom"}
  130. dic2 = {'age': 46}
  131. Tantan(**dic1, **dic2)  # **dic1 将dic1打散，将所有的键值对添加到kwargs
  132. print("---- 4 -----------------------------------------")
  134. # 函数参数
  135.     # 实参
  136.         # 位置参数
  137.         # 关键字参数
  138.         # 混合参数
  140.     # 形参
  141.         # 位置参数
  142.         # 默认参数
  143.         # 万能参数
  145. # 形参的最终顺序
  146. # 位置参数  *args  默认参数  **kwargs
  147. def func(a, b, *args, sex='女', **kwargs):
  148.     print(a, b, sex, args, kwargs)
  150. func(1, 2, 4, 5, 6, name='tom', age=73)

函数的名称空间和顺序

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. """
  5. 函数里面的变量，在函数外面能直接引用么？
  6. def func1():
  7.     m = 1
  8.     print(m)
  9. print(m)  #这行报的错
  11. 报错了：
  12. NameError: name 'm' is not defined
  14. 我们首先回忆一下Python代码运行的时候遇到函数是怎么做的，从Python解释器开始执行之后，就在内存中开辟里一个空间
  15. 每当遇到一个变量的时候，就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读入内存，
  16. 表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。等执行到函数调用的时候，
  17. Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，
  18. 而函数中的变量会储存在新开辟出来的内存中，函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
  20. 我们给这个‘存放名字与值的关系’的空间起了一个名字 --- 命名空间。
  21. 代码在运行伊始，创建存储“变量名与值的关系”的空间叫做全局命名空间；
  22. 在函数的运行中开辟的临时的空间叫做局部命名空间。
  23. """
  24. # python的空间分三种：
  25. # 全局名称空间
  26. # 局部名称空间
  27. # 内置名称空间  print() len() 内置函数
  28. #
  29. # 举例
  30. # def func():
  31. #     name = 'tom'
  32. # func()
  33. # print(name)  # 报错
  34. # func()
  35. # python中的作用域分两种：
  36. # 全局作用域：内置名称空间 全局名称空间
  37. # 局部作用域：局部名称空间
  39. # 取值顺序: 就近原则
  40. # 局部变量先到局部寻找，局部没找到才去全局找，全局没找到，去内置找，都没找到，就报错
  41. # 全局变量直接在全局查找，全局没有就去内置空间查找，如果没有，就报错
  42. # 局部名称空间 ———> 全局名称空间 ———> 内置名称空间    （这个顺序不可逆）
  43. input = 'tom'
  44. def func():
  45.     input = 'jerry'
  46.     print(input)
  47. func()
  48. print(input)
  50. # 加载顺序
  51. # 所有的东西要加载到内存才运行
  52. # 内置名称空间  --->  全局名称空间 --->  局部名称空间

函数的嵌套

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 函数的嵌套
  5. # 举例1
  6. def func():
  7.     print(111)
  9. def func1():
  10.     print(222)
  11.     func()
  13. def func3():
  14.     print(333)
  15.     func1()
  17. print(444)
  18. func()
  19. print(555)
  20. ## 444 111 555
  21. print("---------------- 1 -------------------------")
  23. #举例2
  24. def func():
  25.     print(111)
  27. def func1():
  28.     print(222)
  29.     func()
  31. def func3():
  32.     print(333)
  33.     func1()
  35. print(444)
  36. func3()
  37. print(555)
  38. # 444 333 222 111 555
  39. print("---------------- 2 -------------------------")
  41. def wrapper():
  42.     print(222)
  43.     def inner():
  44.         print(111)
  45.     print(444)
  46.     inner()
  47.     print(333)
  49. wrapper()
  50. # 222 444 111 333

内置函数globals、locals

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 内置函数globals() locals()
  6. name = 'tom'
  7. age = 46
  9. def func():
  10.     sex = '男'
  11.     hobby = '女'
  12.     print(globals())  # 返回一个字典：全局作用域的所有内容
  13.     # {..., 'name': 'tom', 'age': 46, ...} 两边还有其他的内容
  15.     print(locals())   # 返回一个字典：当前位置的内容
  16.     # {'hobby': '女', 'sex': '男'}
  18. func()
  20. print(globals())  # 返回一个字典：全局作用域的所有内容
  21. # {..., 'name': 'tom', 'age': 46, ...} 两边还有其他的内容
  23. print(locals())   # 返回一个字典：当前位置的内容
  24. # {..., 'name': 'tom', 'age': 46, ...} 两边还有其他的内容

函数名的应用

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # 函数名的应用
  5. # 1,函数名是一个特殊的变量 函数名() 执行此函数
  6. def func():
  7.     print(666)
  8. func()
  9. print("--------------- 1 ------------------")
  11. # 2,函数名可以当做变量进行赋值运算。
  12. def func():
  13.     print(666)
  14. f = func
  15. f()
  16. print("--------------- 2 ------------------")
  18. # 3，函数名可以作为容器型数据的元素 ***
  19. def func():
  20.     print(666)
  22. def func1():
  23.     print(777)
  25. def func2():
  26.     print(888)
  28. def func3():
  29.     print(999)
  31. l1 = [func, func1, func2, func3]
  32. for i in l1:
  33.     i()
  35. dic = {
  36.     1: func,
  37.     2: func1,
  38.     3: func2,
  39.     4: func3,
  40. }
  42. # while 1:
  43. #     num = input('请输入序号：').strip()
  44. #     num = int(num)
  45. #     dic[num]()
  46. print("--------------- 3 ------------------")
  48. # 4，函数名可以作为函数的参数。
  49. def func1():
  50.     print(111)
  52. def func2(x):
  53.     x()
  54.     print(222)
  56. func2(func1)
  57. print("--------------- 4 ------------------")
  59. # 5，函数名可以作为函数的返回值。
  60. def func1():
  61.     print(111)
  63. def func2(x):
  64.     print(222)
  65.     return x
  67. ret = func2(func1)
  68. ret()

关键字global、nonlocal

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. # global nonlocal
  6. # global
  7. # 1，声明一个全局变量。
  8. def func():
  9.     global name
  10.     name = 'tom'
  11. func()
  12. print(name)
  13. print("--------------- 1 ------------------")
  15. # 2，修改一个全局变量。
  16. # 原因：局部作用域只能引用全局变量而不能改变全局变量。如果改变则报错
  17. # global 可以实现通过局部作用域而去改变全局变量
  18. count = 1
  19. def func1():
  20.     global count
  21.     count += 1
  22. print(count)
  23. func1()
  24. print(count)
  25. print("--------------- 2 ------------------")
  27. # nonlocal： 子级函数可以通过nonlocal修改父级（更高级非全局变量）函数的变量。
  28. # 现象：子级函数可以引用父级函数的变量但是不能修改。
  29. def func():
  30.     count = 1
  31.     def func1():
  32.         def inner():
  33.             nonlocal count
  34.             count += 1
  35.             print(count)  # 第二个打印 2
  36.         print(count)      # 第一个打印 1
  37.         inner()
  38.         print(count)      # 第三个打印 2
  39.     func1()
  41. func()  # 1 2 2
  42. print("--------------- 3 ------------------")
  44. # 这个不行，会报错
  45. # count = 1
  46. # def func1():
  47. #     def inner():
  48. #         nonlocal count  # 这里会报错，因为count是全局变量了，不能使用nonlocal
  49. #         count += 1
  50. #         print(count)
  51. #     inner()
  52. #
  53. # func1()

练习题1

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  4. """
  5. # 1、 文件a1.txt内容
  6. # 序号 部门 人数 平均年龄 备注
  7. # 1 python 30 26 单身狗
  8. # 2 Linux 26 30 没对象
  9. # 3 运营部 20 24 女生多
  10. # 通过代码，将其构建成这种数据类型：
  11. # [{'序号':'1','部门':Python,'人数':30,'平均年龄':26,'备注':'单身狗'},......]
  12. """
  13. # 方法1
  14. l1 = []
  15. with open('a1.txt', encoding='utf-8', mode='r') as f:
  16.     k1, k2, k3, k4, k5 = f.readline().strip('').split()
  17.     for line in f:
  18.         dic = {}
  19.         v1, v2, v3, v4, v5 = line.strip('').split()
  20.         dic[k1] = v1
  21.         dic[k2] = v2
  22.         dic[k3] = v3
  23.         dic[k4] = v4
  24.         dic[k5] = v5
  25.         l1.append(dic)
  26. print(l1)
  27. print("----------------------- 1 --------------------------------")
  29. # 方法2
  30. l1 = []
  31. with open('a1.txt', encoding='utf-8', mode='r') as f:
  32.     # 读取第一行作为键
  33.     head_list = f.readline().strip('').split()
  34.     # print(head_list)
  35.     for line in f:
  36.         # 获取每一行为一个列表
  37.         line_list = line.strip().split()
  38.         # print(line_list)
  39.         dic = {}
  40.         # 循环上面的列表 enumerate函数的用法 会返回索引k和值v
  41.         for k, v in enumerate(line_list):
  42.             # print(k, v)
  43.             dic[head_list[k]] = v
  44.         l1.append(dic)
  45. print(l1)
  46. print("----------------------- 2 --------------------------------")
  48. # 2、 传入函数的字符串中,统计[数字]、[字母]、[空格] 以及 [其他]的个数，并返回结果。
  49. def my_count(str1):
  50.     """
  51.     统计数字，字母，空格，其他的字符个数
  52.     :param str1: 字符串
  53.     :return: 数字，字母，空格，其他
  54.     """
  55.     count_num = 0
  56.     count_letter = 0
  57.     count_space = 0
  58.     count_other = 0
  59.     for i in str1:
  60.         if i.isdigit():
  61.             count_num += 1
  62.         elif i.isalpha():
  63.             count_letter += 1
  64.         elif i == ' ':
  65.             count_space += 1
  66.         else:
  67.             count_other += 1
  68.     return '数字[%s] 字母[%s] 空格[%s] 其他[%s]' % (count_num, count_letter, count_space, count_other)
  70. print(my_count('1 b # 3s'))
  71. print("----------------------- 3 --------------------------------")
  73. # 3、 写函数，接收两个数字参数，返回比较大的那个数字
  74. def my_compare(*args):
  75.     """
  76.     比较两个数大小
  77.     :param args:传入2个数字
  78.     :return: 大的数字
  79.     """
  80.     return args[0] if args[0] > args [1] else args[1]
  82. print(my_compare(3,62))
  83. print("----------------------- 4 --------------------------------")
  85. # 4、 写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者
  86. # dic = {"k1": "v1v1", "k2": [11,22,33,44]}   PS:字典中的value只能是字符串或列表
  87. def func(**kwargs):
  88.     """
  89.     检查字典值的长度，大于2，保留前两个长度的内容
  90.     :param kwargs: 字典
  91.     :return: 新列表
  92.     """
  93.     for k,v in kwargs.items():
  94.         kwargs[k] = v[:2] if len(v) > 2 else v
  95.     return kwargs
  96. dic = {"k1": "v1v1", "k2": [11,22,33,44]}
  97. ret = func(**dic)
  98. print(ret)
  99. print("----------------------- 5 --------------------------------")
  101. # 5、写函数，此函数只接收一个参数且此参数必须是列表数据类型，
  102. # 此函数完成的功能是返回给调用者一个字典，此字典的键值对为此列表的索引及对应的元素。例如传入的列表为：[11,22,33]
  103. # 返回的字典为{0:11,1:22,2:33}
  104. def fun(lis):
  105.     """
  106.     接受列表数据类型，返回字典
  107.     :param args: 列表
  108.     :return: 字典
  109.     """
  110.     if type(lis) is list:
  111.         dic = {}
  112.         for k in range(len(lis)):
  113.             dic[k] = lis[k]
  114.         return dic
  115.     else:
  116.         return '参数必须为列表'
  118. l1 = [11,22,33,]
  119. print(fun(l1))
  120. print("----------------------- 6 --------------------------------")
  122. # 6、写函数，函数接收四个参数分别是：姓名，性别，年龄，学历。用户通过输入这四个内容，然后将这
  123. # 四个内容传入到函数中，此函数接收到这四个内容，将内容追加到一个student_msg文件中
  124. def func(name,sex,age,edu):
  125.     """
  126.     接收四个参数，将接收的内容追加到student_msg文件中
  127.     :param name: 姓名
  128.     :param sex: 性别
  129.     :param age: 年龄
  130.     :param edu: 学历
  131.     :return:
  132.     """
  133.     with open('student_msg', encoding='utf-8', mode='a+') as f:
  134.         f.write('%s %s %s %s \n' % (name, sex, age, edu) )
  135.         f.flush()
  136. # name = input('name>>>:')
  137. # sex = input('sex>>>:')
  138. # age = input('age>>>:')
  139. # edu = input('edu>>>:')
  140. # func(name,sex,age,edu)
  141. print("----------------------- 7 --------------------------------")
  143. # 7、 对第6题升级：支持用户持续输入，Q或者q退出，性别默认为男，如果遇到女学生，则把性别输入女
  144. def func(name,age,edu,sex='男'):
  145.     """
  146.     接收四个参数，将接收的内容追加到student_msg文件中
  147.     :param name: 姓名
  148.     :param sex: 性别
  149.     :param age: 年龄
  150.     :param edu: 学历
  151.     :return:
  152.     """
  153.     with open('student_msg', encoding='utf-8', mode='a+') as f:
  154.         f.write('%s %s %s %s \n' % (name, sex, age, edu) )
  155.         f.flush()
  157. # while 1:
  158. #     name = input('name(Q/q exit)>>>:')
  159. #     if name.strip().lower() == 'q':
  160. #         break
  161. #     sex = input('sex>>>:')
  162. #     age = input('age>>>:')
  163. #     edu = input('edu>>>:')
  164. #
  165. #     if sex.strip() == '男':
  166. #         func(name,age,edu)
  167. #     else:
  168. #         func(name,age,edu,sex)
  169. print("----------------------- 8 --------------------------------")
  171. # 8、写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作
  172. import os
  173. def modify_file(file_name,old_modify,new_modify):
  174.     """
  175.     文本修改
  176.     :param file_name: 文件
  177.     :param old_modify: 被修改的内容
  178.     :param new_modify: 修改的内容
  179.     :return: True
  180.     """
  181.     if os.path.exists(file_name):
  182.         with open(file_name, encoding='utf-8', mode='r') as f1, open(file_name+'.bak', encoding='utf-8',mode='w') as f2:
  183.             for old_line in f1:
  184.                 new_line = old_line.replace(old_modify,new_modify)
  185.                 f2.write(new_line)
  186.                 f2.flush()
  187.         os.remove(file_name)
  188.         os.rename(file_name+'.bak',file_name)
  189.         return  True
  190.     else:
  191.         return '文件不存在'
  193. # file_name = input("请输入文件名称:")
  194. # old_modify = input("请输入需要修改的内容：")
  195. # new_modify = input("请输入修改后的内容：")
  196. # ret = modify_file(file_name,old_modify,new_modify)
  197. # print(ret)
  198. print("----------------------- 9 --------------------------------")
  200. # 9、读代码，回答：代码中,打印出来的值a,b,c分别是什么？为什么？
  201. a = 10
  202. b = 20
  203. def test5(a, b):  # a=20 b=10
  204.     a=3
  205.     b=5
  206.     print(a, b)      #a=3 b=5
  208. c = test5(b, a)  # a=3 b=5 因为在函数内部打印的，先从局部变量开始找
  209. print(c)  #none 函数没有return，所以没有返回值C=None。
  210. print("----------------------- 10 --------------------------------")
  212. # 10、写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),将每个实参的每个元素依次
  213. # 添加到函数的动态参数args里面
  214. # 例如 传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)
  215. def func(*args):
  216.     """
  217.     :param args:
  218.     :return:
  219.     """
  220.     print(args)
  222. l1 = [1, 2, 3]
  223. t1 = (22, 33)
  224. func(*l1, *t1)
  225. print("----------------------- 11 --------------------------------")
  227. # 11、写函数,传入函数中多个实参(实参均为字典),将每个实参的键值对依次添加到函数的动态参数kwargs里面
  228. # 例如 传入函数两个参数{‘name’:’alex’} {‘age’:1000}最终kwargs为{‘name’:’alex’ ,‘age’:1000}
  229. def fun(**kwargs):
  230.     """
  231.     :param kwargs:
  232.     :return:
  233.     """
  234.     print(kwargs)
  235. dic1 = {'name': 'alex'}
  236. dic2 = {'age': 1000}
  237. fun(**dic1, **dic2)
  238. print("----------------------- 12 --------------------------------")
  240. # 12、下面代码成立么?如果不成立为什么报错?怎么解决?
  241. # 题目一：
  242. a = 2
  243. def wrapper():
  244.     print(a)
  245. wrapper()  # 2
  247. # 题目二：
  248. # a = 2
  249. # def wrapper():
  250. #     a += 1  # 报错
  251. #     print(a)
  252. # wrapper()
  254. # 题目三：
  255. def wrapper():
  256.     a = 1
  257.     def inner():
  258.         print(a)
  259.     inner()
  260. wrapper()  # 1
  262. # 题目四：
  263. # def wrapper():
  264. #     a = 1
  265. #     def inner():
  266. #         a += 1  # 报错
  267. #         print(a)
  268. #     inner()
  269. # wrapper()
  271. # 题目二修改为如下
  272. a = 2
  273. def wrapper():
  274.     global a
  275.     a += 1
  276.     print(a)
  277. wrapper()
  279. # 题目四修改为如下
  280. def wrapper():
  281.     a = 1
  282.     def inner():
  283.         nonlocal a
  284.         a += 1
  285.         print(a)
  286.     inner()
  287. wrapper()
  288. print("----------------------- 13 --------------------------------")
  290. # 13、写函数,接收两个数字参数,将较小的数字返回
  291. def min_(a,b):
  292.     return a if a < b else b
  293. print(min_(13,2))
  294. print("----------------------- 14 --------------------------------")
  296. # 14、写函数,接收一个参数(此参数类型必须是可迭代对象),将可迭代对象的每个元素以’_’相连接,形成新的字符串,并返回
  297. # 例如 传入的可迭代对象为[1,'老男孩','武sir']返回的结果为’1_老男孩_武sir’
  298. def fun(item):
  299.     """
  300.     :param item:
  301.     :return:
  302.     """
  303.     s = ''
  304.     for i in item:
  305.         s = s + '%s_' % (i)
  306.     s = s.rstrip('_')
  307.     return s
  308. l1 = [1, '深圳', '南山']
  309. ret = fun(l1)
  310. print(ret)
  311. print("----------------------- 15 --------------------------------")
  313. # 15、写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}
  314. # 例如：如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数)
  316. def min_max(*args):
  317.     dic = {'max':max(args),'min':min(args)}
  318.     return dic
  320. ret = min_max(2,5,7,8,4)
  321. print(ret)
  322. print("----------------------- 16 --------------------------------")
  324. # 16、写函数，传入一个参数n，返回n的阶乘
  325. # 例如:cal(7) 计算7*6*5*4*3*2*1
  326. def fun(n):
  327.     s = 1
  328.     for i in range(1, n+1):
  329.         s = s * i
  330.     print(s)
  331. fun(7)
  332. print(7 * 6 * 5 * 4 * 3 * 2 * 1)
  333. print("----------------------- 17 --------------------------------")
  335. # 17、写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
  336. # 例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]
  338. def poker():
  339.     poker_list = []
  340.     l1 = ['红心','草花','黑桃','方片']
  341.     l2 = ['A',2,3,4,5,6,7,8,9,10,'J','Q','K']
  342.     for i in l1:
  343.         for k in l2:
  344.             poker_list.append((i,k))
  345.     return poker_list
  346. print(poker())
  347. print("----------------------- 18 --------------------------------")
  349. # 18、 有如下函数:
  350. # def wrapper():
  351. #     def inner():
  352. #         print(666)
  353. # wrapper()
  354. # 你可以任意添加代码,用两种或以上的方法,执行inner函数
  356. #方法1
  357. def wrapper():
  358.     def inner():
  359.         print(666)
  360.     inner()
  362. wrapper()
  364. #方法2
  365. def wrapper():
  366.     def inner():
  367.         print(666)
  368.     return inner
  370. ret = wrapper()
  371. ret()

练习题2

  1. #!/usr/bin/env python3
  2. # author:Alnk(李成果)
  3. import os
  5. """
  6. 题目：用函数完成登录注册以及购物车的功能
  7. 需求:
  8.     1，启动程序，用户可选择四个选项：登录，注册，购物，退出。
  9.     2，用户注册，用户名不能重复，注册成功之后，用户名密码记录到文件中。
  10.     3，用户登录，用户名密码从文件中读取，进行三次验证，验证不成功则退出整个程序。
  11.     4，用户登录成功之后才能选择购物功能进行购物，购物功能（就是将购物车封装到购物的函数中）。
  12.     5，退出则是退出整个程序。
  13. """
  15. # 设定登录标志位
  16. login_flag = False
  18. def register():
  19.     """
  20.     注册
  21.     :return:None
  22.     """
  23.     while 1:
  24.         username = input('\n请输入你想注册的账户名称>>>:').strip()
  25.         userpwd = input('请输入你想设置的登录密码>>>:').strip()
  26.         # 存储用户信息目录
  27.         if not os.path.exists("user_info"):
  28.             os.mkdir("./user_info")
  30.         if os.path.exists("user_info/%s" % (username)):
  31.             print("该用户名已经被注册,请重新输入\n")
  32.             continue
  34.         with open("user_info/%s" % (username), encoding='utf-8', mode='w') as f:
  35.             f.write("%s|%s|0" % (username,userpwd) )
  36.             f.flush()
  37.             print('账号注册成功！\n')
  38.             return
  40. def login():
  41.     """
  42.     登录
  43.     :return:None
  44.     """
  45.     # 密码可输错次数
  46.     count = 3
  47.     while 1:
  48.         username = input("\n请输入登录账号(返回B/b)>>>:").strip()
  49.         if username.strip().lower() == 'b':
  50.             print('\n')
  51.             break
  52.         userpwd = input("请输入登录密码>>>:").strip()
  53.         # 用户是否存在
  54.         if os.path.exists('user_info/%s' % (username) ):
  55.             # 获取用户登录密码和密码输错次数
  56.             with open('user_info/%s' % (username), encoding='utf-8', mode='r') as f1:
  57.                 user_l1 = f1.readline().strip().split('|')
  58.                 pwd = str(user_l1[1])
  59.                 count_pwd = int(user_l1[2])
  60.                 # 账号是否冻结
  61.                 if count_pwd == count:
  62.                     print("账号 [%s] 已经被冻结,请联系管理员解除冻结或使用其他账号登陆\n" % (username))
  63.                     continue
  64.                 # 密码是否正确
  65.                 if userpwd == pwd:
  66.                     print('登录成功！\n')
  67.                     # 重置密码输错次数
  68.                     count_pwd = 0
  69.                     user_l1[2] = count_pwd
  70.                     with open('user_info/%s' % (username), encoding='utf-8', mode='w') as f2:
  71.                         f2.write("%s|%s|%s" % (user_l1[0], user_l1[1], user_l1[2]))
  72.                         f2.flush()
  73.                     # 登录成功，修改默认的标志位
  74.                     global login_flag
  75.                     login_flag = True
  76.                     return
  77.                 else:
  78.                     # 登录失败，密码输错次数 +1
  79.                     count_pwd += 1
  80.                     user_l1[2] = count_pwd
  81.                     with open('user_info/%s' % (username), encoding='utf-8', mode='w') as f3:
  82.                         f3.write("%s|%s|%s" % (user_l1[0] ,user_l1[1], user_l1[2]) )
  83.                         f3.flush
  84.                     # 密码连续输错3次，直接退出程序
  85.                     if count_pwd == count:
  86.                         exit('[%s] 账号密码连续输错3次，程序退出！' % (username))
  87.                     print('密码错误。\n')
  88.                     continue
  89.         else:
  90.             print('用户不存在！')
  92. def recharge():
  93.     """
  94.     充值
  95.     :return:True，用户余额
  96.     """
  97.     while 1:
  98.         user_balance = input("请先给账号充值(返回B/b):")
  99.         if user_balance.lower() == "b":
  100.             print('')
  101.             return False
  102.         elif user_balance.isdigit():
  103.             user_balance = int(user_balance)
  104.             print("账号充值成功！余额为[%s]元\n" % (user_balance))
  105.             return True,user_balance
  106.         else:
  107.             print("输入有误，请重新输入。")
  109. def jiesuan(user_shopping_cart,user_balance):
  110.     """
  111.     结算功能
  112.     :param user_shopping_cart: 用户选购商品的临时字典
  113.     :param user_balance: 用户充值的余额
  114.     :return:None
  115.     """
  116.     while 1:
  117.         # 显示购物车里的商品
  118.         print("\n您的购车里商品如下:")
  119.         for k in user_shopping_cart:
  120.             print("\t商品[%s] 数量[%s] 价格[%s]" % (k, user_shopping_cart[k]['number'], user_shopping_cart[k]['price']))
  121.         # 购物车所有商品总价
  122.         shopp_cart_total = 0
  123.         print("\n\n正在结算，请稍候...")
  124.         # 计算商品总价格
  125.         for k in user_shopping_cart:
  126.             shopp_cart_total = shopp_cart_total + user_shopping_cart[k]['number'] * user_shopping_cart[k]['price']
  127.         # 余额是否能够支付
  128.         if user_balance >= shopp_cart_total:
  129.             print("您本次总共需要支付[%s]元，余额为[%s]元" % (shopp_cart_total, user_balance))
  130.             print("\n您本次购买的商品详单如下：")
  131.             for k in user_shopping_cart:
  132.                 print('\t商品[%s] 数量[%s] 价格[%s]'%(k,user_shopping_cart[k]['number'],user_shopping_cart[k]['price']))
  133.             print("\n本次总共消费[%s]元，账户余额为[%s]元" % (shopp_cart_total, user_balance - shopp_cart_total))
  134.             print("\n购买成功!\n")
  135.             return
  136.         else:
  137.             print("本次总共需要支付[%s]元 你的余额为[%s]元" % (shopp_cart_total, user_balance))
  138.             print("余额不足，请先删除购物车里的一些商品再去结算哟\n")
  139.             while 1:
  140.                 print("\n购物车的商品列表如下:")
  141.                 for k in user_shopping_cart:
  142.                     print('\t商品[%s] 数量[%s] 价格[%s]' % (k, user_shopping_cart[k]['number'], user_shopping_cart[k]['price']))
  143.                 user_choice2 = input("请输入你想删除的商品名称:")
  144.                 # 从购物车删除商品
  145.                 if user_shopping_cart.get(user_choice2):
  146.                     # 商品数量为1，直接删除。否则减少商品的数量1
  147.                     if user_shopping_cart[user_choice2]['number'] == 1:
  148.                         del user_shopping_cart[user_choice2]
  149.                         print('商品[%s]已从购物车删除' % (user_choice2))
  150.                     elif user_shopping_cart[user_choice2]['number'] > 1:
  151.                         user_shopping_cart[user_choice2]['number'] -= 1
  152.                         print("商品[%s]数量减少1件" % (user_choice2))
  153.                     break
  154.                 else:
  155.                     print("\n输入的商品名称有误，请重新输入")
  157. def buy():
  158.     """
  159.     购物
  160.     :return:None
  161.     """
  162.     # 默认标志为是否被修改，即是否已经登录
  163.     if login_flag:
  164.         print('\n')
  165.         # 获取充值函数返回值，为一个元组(True,user_balance)
  166.         ret = recharge()
  167.         if ret[0]:
  168.             # 用户余额
  169.             user_balance = ret[1]
  170.             # 用户选购商品临时购物车
  171.             user_shopping_cart = {}
  172.             # 商品列表
  173.             goods_dic = {
  174.                 "1": {"name": "电脑", "price": 1999, },
  175.                 "2": {"name": "鼠标", "price": 10, },
  176.                 "3": {"name": "键盘", "price": 60, },
  177.                 "4": {"name": "手机", "price": 4000, },
  178.                 "5": {"name": "ipad", "price": 2999, },
  179.                 "n": {"name": "购物车结算", "price": '', },
  180.             }
  181.             while 1:
  182.                 print("下列是您可以选购的商品(退出Q/q):")
  183.                 for key in goods_dic:
  184.                     print('\t', key, goods_dic[key]['name'], goods_dic[key]['price'])
  185.                 user_choice = input("请输入你想购买的商品序号:")
  186.                 if user_choice.lower() == "q":
  187.                     print("退出购物商城")
  188.                     break
  189.                 # 结算
  190.                 elif user_choice == "n":
  191.                     jiesuan(user_shopping_cart,user_balance)
  192.                     break
  193.                 # 添加商品到用户购物车
  194.                 elif goods_dic.get(user_choice):
  195.                     # 判断购物车是否已经有该商品，如果有直接数量加1，没有则创建一个新的键值对
  196.                     if user_shopping_cart.get(goods_dic[user_choice]['name']):
  197.                         user_shopping_cart[goods_dic[user_choice]['name']]['number'] += 1
  198.                     else:
  199.                         user_shopping_cart[goods_dic[user_choice]['name']] = {"number": 1,"price": goods_dic[user_choice]['price']}
  200.                     print("\n商品[%s] 价格[%s] " % (goods_dic[user_choice]['name'], goods_dic[user_choice]['price']))
  201.                     print('添加到购物车成功！\n')
  202.                 else:
  203.                     print("输入有误，请重新输入哦\n")
  204.     else:
  205.         print('请先登录哦\n')
  207. def sign_out():
  208.     """
  209.     退出程序
  210.     :return:None
  211.     """
  212.     exit('退出程序！')
  214. def display():
  215.     """
  216.     程序入口，显示
  217.     :return:None
  218.     """
  219.     msg = """---- 欢迎来到老男孩购物商城 ----
  220.         1 注册
  221.         2 登录
  222.         3 购物
  223.         4 退出
  224.     """
  225.     dic = {
  226.         '1': register,
  227.         '2': login,
  228.         '3': buy,
  229.         '4': sign_out,
  230.     }
  231.     while 1:
  232.         print(msg)
  233.         keys = input('请输入你要选择的操作序号>>>:')
  234.         if keys in dic:
  235.             dic[keys]()
  236.         else:
  237.             print('输入有误，请输入序号哟')
  238.             continue
  240. if __name__ == '__main__':
  241.     display()

Python语言系列-03-文件操作和函数的更多相关文章

  1. Python基础-week03 集合 , 文件操作 和 函数详解

    一.集合及其运算 1.集合的概念 集合是一个无序的,不重复的数据组合,它的主要作用如下 *去重,把一个列表变成集合,就自动去重了 *关系测试,测试两组数据之前的交集.并集.差集.子集.父级.对称差集, ...

  2. Python学习系列之文件操作

    Pyhton文件打开方式 with= open('文件路径','打开模式') as f:#PS:python3提供了with语句来帮我们自动调用close方法,所以说无论打开文件是否出错都能自动正确的 ...

  3. C语言样式的文件操作函数

    使用C语言样式的文件操作函数,需要包含stdio.h头文件. 1.打开文件的函数: //oflag的取值为“w”或“r”,分别表示以写或读的方式打开 FILE* fd = fopen(filename ...

  4. python 文件操作的函数

    1. 文件操作的函数 open(文件名(路径), mode="?", encoding="字符集") 2. 模式: r, w, a, r+, w+, a+, r ...

  5. python 文件操作: 文件操作的函数, 模式及常用操作.

    1.文件操作的函数: open("文件名(路径)", mode = '模式', encoding = "字符集") 2.模式: r , w , a , r+ , ...

  6. Unix/Linux环境C编程入门教程(41) C语言库函数的文件操作详解

     上一篇博客我们讲解了如何使用Linux提供的文件操作函数,本文主要讲解使用C语言提供的文件操作的库函数. 1.函数介绍 fopen(打开文件) 相关函数 open,fclose 表头文件 #in ...

  7. Unix/Linux环境C编程新手教程(41) C语言库函数的文件操作具体解释

     上一篇博客我们解说了怎样使用Linux提供的文件操作函数,本文主要解说使用C语言提供的文件操作的库函数. 1.函数介绍 fopen(打开文件) 相关函数 open,fclose 表头文件 #in ...

  8. php中文件操作常用函数有哪些

    php中文件操作常用函数有哪些 一.总结 一句话总结:读写文件函数 判断文件或者目录是否存在函数 创建目录函数 file_exists() mkdir() file_get_content() fil ...

  9. PHP文件操作功能函数大全

    PHP文件操作功能函数大全 <?php /* 转换字节大小 */ function transByte($size){ $arr=array("B","KB&quo ...

随机推荐

  1. AcWing 106. 动态中位数

    依次读入一个整数序列,每当已经读入的整数个数为奇数时,输出已读入的整数构成的序列的中位数. #include<bits/stdc++.h> using namespace std; pri ...

  2. Linux：Ubuntu配置jdk环境变量

    1.下载jdk 推荐官网:https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html 下载tar.gz包即可. ...

  3. Spring data Jpa 提供的validator验证

  4. 二进制方式搭建Kubernetes集群

    环境准备: 演练暂时用单节点一台master和一台node节点来进行部署搭建(kubernetes 1.19版本) 角色 IP 组件 master 10.129.246.114 kube-apiser ...

  5. ZSH主题

    All the current themes can be found in the themes/ directory in the oh-my-zsh distribution. See list ...

  6. 以太网MAC地址组成与交换机基本知识

    以太网MAC地址 MAC地址由48位二进制组成,通常分为六段,用十六进制表示,工作在数据链路层. 数据链路层功能: 链路的建立,维护与拆除 帧包装,帧传输,帧同步 帧的差错恢复 简单的流量控制 第八位 ...

  7. Java Map 集合类在selenium自动化测试设计中的应用

    我们在设计自动化测试用例的时候,往往很多工作是在处理测试的数据. 测试数据无论用Excel 文件, XML文件或者任何一种形式测存储方式,都会设计到参数化以及我们对数据的操作. 这个时候,我们会用到以 ...

  8. EditPlus运行java时如何从键盘输入数据

    在练习Java的Scanner时,EditPlus如何读取从键盘输入的数呢? 例如如下程序,编译通过,运行时却输入不了数据: 1 package myP101; 2 3 import java.uti ...

  9. Beautifulsoup网页解析——爬取豆瓣排行榜分类接口

    我们在网页爬取的过程中,会通过requests成功的获取到所需要的信息,而且,在返回的网页信息中,也是通过HTML代码的形式进行展示的.HTML代码都是通过固定的标签组合来实现页面信息的展示,所以,最 ...

  10. Optional 的使用会导致性能下降吗？

    几天前,我在论坛上发了一篇关于Optional 的文章.其中一条评论是一个非常好的问题: Optional 的使用会导致性能下降吗? 答案是: 是的,它会的.但是你应该担心吗? 使用Optional的 ...