id(s) #读取变量指定的值的内存地址

type(s) #查看变量或者值的类型

l=[‘a’,’b’,x] # l=[‘a’的内存地址,’b’的内存地址,10的内存地址]

age=input(“请输入您的账号：”) #接收用户输入

运算符

  1. # print(10 / 3)  # 结果带小数
  3. # print(10 // 3)  # **只保留整数部分**
  5. # print(10 % 3) # **取模、取余数**
  7. # print(10 ** 3) # 次方
  9. age=input("请输入您的账号：")      #接收用户输入

字符串格式化输出：

%

  1. res="my name is %s,my age is %s" %('egon','18')
  2. res="my name is %s" %"egon"
  3. %s 可以接受任意类型（字典，元组等）
  4. print('my age is %d' %18)       # %d只能接收int
  6. LOG_PATH = r'%s/log/user.log' %BASE_DIR     #r'字符串'使用字符串源意

str.format

#兼容性好

  1. res='我的名字是{} 我的年龄是{}'.format('egon',18)
  2. res='我的名字是 {0}{0}{0} 我的年龄是 {1}{1}'.format('egon',18)
  4. # 打破位置的限制，按照key=value传值
  5. res="我的名字是 {name} 我的年龄是 {age}".format(age=18,name='egon')

填充与格式化

  1. 2.4 填充与格式化
  2. # 先取到值,然后在冒号后设定填充格式：[填充字符][对齐方式][宽度]
  3. # *<10：左对齐，总共10个字符，不够的用*号填充
  4. print('{0:*<10}'.format('开始执行')) # 开始执行******
  6. # *>10：右对齐，总共10个字符，不够的用*号填充
  7. print('{0:*>10}'.format('开始执行')) # ******开始执行
  9. # *^10：居中显示，总共10个字符，不够的用*号填充
  10. print('{0:*^10}'.format('开始执行')) # ***开始执行***

精度与进制

  1. print('{salary:.3f}'.format(salary=1232132.12351))  #精确到小数点后3位，四舍五入，结果为：1232132.124
  2. print('{0:b}'.format(123))  # 转成二进制，结果为：1111011
  3. print('{0:o}'.format(9))  # 转成八进制，结果为：11
  4. print('{0:x}'.format(15))  # 转成十六进制，结果为：f
  5. print('{0:,}'.format(99812939393931))  # 千分位格式化，结果为：99,812,939,393,931

f

#f:python3.5以后才推出

  1. x = input('your name: ')
  2. y = input('your age: ')
  3. res = f'我的名字是{x} 我的年龄是{y}'
  4. print(res)
  6. # 了解f的新用法：{}内的字符串可以被当做表达式运行
  7. # res=f'{10+3}'
  8. # print(res)

字符串转二进制

  1. data = 'hello world'
  3. # 字符串转二进制
  4. data = bytes(data,encoding='utf-8')
  5. print(data)
  7. # 二进制转字符串
  8. data = str(data,encoding='utf-8')
  9. print(data)

解压赋值

  1. # 引入*，可以帮助我们取两头的值，无法取中间的值
  2. # 取前三个值
  3. # x,y,z,*_=salaries=[111,222,333,444,555]     # *会将没有对应关系的值存成列表然后赋值给紧跟其后的那个变量名，此处为_
  4. # print(x,y,z)
  5. # print(_)
  7. # 取后三个值
  8. # *_,x,y,z=salaries=[111,222,333,444,555]
  9. # print(x,y,z)
  11. # x,*_,y,z=salaries=[111,222,333,444,555]
  12. # print(x,y,z)
  14. # salaries=[111,222,333,444,555]
  15. # _,*middle,_=salaries
  16. # print(middle)
  18. # 解压字典默认解压出来的是字典的key
  19. x,y,z=dic={'a':1,'b':2,'c':3}
  20. print(x,y,z)

深浅拷贝

浅拷贝

  1. # 3.1 浅copy:是把原列表第一层的内存地址不加区分完全copy一份给新列表
  2. list1=[
  3.     'egon',
  4.     'lxx',
  5.     [1,2]
  6. ]
  8. list3=list1.copy()

深拷贝

  1. import copy
  2. list1=[
  3.     'egon',
  4.     'lxx',
  5.     [1,2]
  6. ]
  8. list3=copy.deepcopy(list1)
  9. #深拷贝：递归将列表每一层指向的内存都创建新的

while循环

  1. # 纯计算无io的死讯会导致致命的效率问题；无io会让cpu无等待
  2. # while True:
  3. #     1+1
  6. #退出循环的2种方式
  7.     # 方式一：将条件改为False,等到下次循环判断条件时才会生效
  8.     # tag=True
  9.     # while tag:
  10.     #     inp_name=input('请输入您的账号：')
  11.     #     inp_pwd=input('请输入您的密码：')
  12.     #
  13.     #     if inp_name  == username and inp_pwd == password:
  14.     #         print('登录成功')
  15.     #         tag = False # 之后的代码还会运行，下次循环判断条件时才生效
  16.     #     else:
  17.     #         print('账号名或密码错误')
  18.     #
  19.     #     # print('====end====')
  22. # 方式二：break，只要运行到break就会立刻终止本层循环
  23.     # while True:
  24.     #     inp_name=input('请输入您的账号：')
  25.     #     inp_pwd=input('请输入您的密码：')
  26.     #
  27.     #     if inp_name  == username and inp_pwd == password:
  28.     #         print('登录成功')
  29.     #         break # 立刻终止本层循环
  30.     #     else:
  31.     #         print('账号名或密码错误')
  32.     #
  33.     #     # print('====end====')
  35. # 7、while循环嵌套与结束
  36.         '''
  37.         tag=True
  38.         while tag:
  39.             while tag:
  40.                 while tag:
  41.                     tag=False
  44.         # 每一层都必须配一个break
  45.         while True:
  46.             while True:
  47.                 while True:
  48.                     break
  49.                 break
  50.             break
  51.         '''    
  53. # 8、while +continue：结束本次循环，直接进入下一次
  54.     # 强调：在continue之后添加同级代码毫无意义，因为永远无法运行
  55.     # count=0
  56.     # while count < 6:
  57.     #     if count == 4:
  58.     #         count+=1
  59.     #         continue
  60.     #         # count+=1 # 错误
  61.     #     print(count)
  62.     #     count+=1
  65. # 9、while +else：针对break
  66.     # count=0
  67.     # while count < 6:
  68.     #     if count == 4:
  69.     #         count+=1
  70.     #         continue
  71.     #     print(count)
  72.     #     count+=1
  73.     # else:
  74.     #     print('else包含的代码会在while循环结束后，并且while循环是在没有被break打断的情况下正常结束的，才不会运行')
  76.     # count=0
  77.     # while count < 6:
  78.     #     if count == 4:
  79.     #         break
  80.     #     print(count)
  81.     #     count+=1
  82.     # else:
  83.     #     print('======>')

应用案例

  1. # 应用案列：
  2. # 版本1：
  3. # count=0
  4. # tag=True
  5. # while tag:
  6. #     if count == 3:
  7. #         print('输错三次退出')
  8. #         break
  9. #     inp_name=input('请输入您的账号：')
  10. #     inp_pwd=input('请输入您的密码：')
  11. #
  12. #     if inp_name  == username and inp_pwd == password:
  13. #         print('登录成功')
  14. #         while tag:
  15. #             cmd=input("输入命令>: ")
  16. #             if cmd == 'q':
  17. #                 tag=False
  18. #             else:
  19. #                 print('命令{x}正在运行'.format(x=cmd))
  20. #     else:
  21. #         print('账号名或密码错误')
  22. #         count+=1
  25. # 版本2：优化
  26. count=0
  27. while count < 3:
  28.     inp_name=input('请输入您的账号：')
  29.     inp_pwd=input('请输入您的密码：')
  31.     if inp_name  == username and inp_pwd == password:
  32.         print('登录成功')
  33.         while True:
  34.             cmd=input("输入命令>: ")
  35.             if cmd == 'q': # 整个程序结束，退出所有while循环
  36.                 break
  37.             else:
  38.                 print('命令{x}正在运行'.format(x=cmd))
  39.         break
  40.     else:
  41.         print('账号名或密码错误')
  42.         count+=1
  43. else:
  44.     print('输错3次，退出')

for循环

  1. # 简单版
  2. # l = ['alex_dsb', 'lxx_dsb', 'egon_nb']
  3. # for x in l:  # x='lxx_dsb'
  4. #     print(x)
  6. # 复杂版：
  7. # l = ['alex_dsb', 'lxx_dsb', 'egon_nb']
  8. # i=0
  9. # while i < 3:
  10. #     print(l[i])
  11. #     i+=1
  13. # for i in range(30):
  14. #     print('===>')
  16. # 五：for+continue
  17. # for i in range(6):  # 0 1 2 3 4 5
  18. #     if i == 4:
  19. #         continue
  20. #     print(i)
  22. # 六：for循环嵌套:外层循环循环一次，内层循环需要完整的循环完毕
  23. # for i in range(3):
  24. #     print('外层循环-->', i)
  25. #     for j in range(5):
  26. #         print('内层-->', j)
  28. # 补充：终止for循环只有break一种方案

进制转换

  1. bin(11)     #10进制转2进制
  2. oct(11)     #10进制转8进制
  3. hex(11)     #10进制转16进制
  5. # 2.2.2 其他制转成其十进制
  6. # 二进制->10进制
  7. # print(int('0b1011',2)) # 11
  9. # 二进制->8进制
  10. # print(int('0o13',8)) # 11
  12. # 二进制->16进制
  13. # print(int('0xb',16)) # 11

字符串内置方法

  1. # 4.1.2、切片:索引的拓展应用，从一个大字符串中拷贝出一个子字符串
  2. msg='hello world'
  3. # 顾头不顾尾
  4. # res=msg[0:5] #x
  6. # 步长
  7. # res=msg[0:5:2] # 0 2 4
  9. msg='hello world'
  10. # res=msg[:] # res=msg[0:11]
  11. # print(res)
  13. # res=msg[::-1] # 把字符串倒过来
  14. # print(res)
  16. # 4.1.3、长度len
  17. # msg='hello world'
  18. # print(len(msg))
  20. # 4.1.4、成员运算in和not in
  21. # 判断一个子字符串是否存在于一个大字符串中
  22. # print("alex" in "alex is sb")
  23. # print("alex" not in "alex is sb")
  25. # 4.1.5、移除字符串左右两侧的符号strip
  26. # 默认去掉的空格
  27. # msg='      egon      '
  28. # res=msg.strip()
  30. # 默认去掉的空格
  31. # msg='****egon****'
  32. # print(msg.strip('*'))
  34. # msg='**/*=-**egon**-=()**'
  35. # print(msg.strip('*/-=()'))
  38. # 4.1.6、切分split：把一个字符串按照某种分隔符进行切分，得到一个列表
  39. # # 默认分隔符是空格
  40. # info='egon 18 male'
  41. # res=info.split()
  42. # print(res)
  44. # # 指定分隔符
  45. # info='egon:18:male'
  46. # res=info.split(':')
  48. # 指定分隔次数(了解)
  49. # info='egon:18:male'
  50. # res=info.split(':',1)
  53. # 4.1.7、循环
  54. # info='egon:18:male'
  55. # for x in info:
  56. #     print(x)
  59. # 4.2 需要掌握
  60. #4.2.1、strip,lstrip,rstrip
  61. # msg='***egon****'
  62. # print(msg.strip('*'))
  63. # print(msg.lstrip('*'))
  64. # print(msg.rstrip('*'))
  67. #4.2.2、lower,upper
  68. # msg='AbbbCCCC'
  69. # print(msg.lower())
  70. # print(msg.upper())
  73. #4.2.3、startswith,endswith
  74. # print("alex is sb".startswith("alex"))
  75. # print("alex is sb".endswith('sb'))
  78. #4.2.4、format
  80. #4.2.5、split,rsplit:将字符串切成列表
  81. # info="egon:18:male"
  82. # print(info.split(':',1)) # ["egon","18:male"]
  83. # print(info.rsplit(':',1)) # ["egon:18","male"]
  85. #4.2.6、join: 把列表拼接成字符串
  86. # l=['egon', '18', 'male']
  87. # res=l[0]+":"+l[1]+":"+l[2]
  88. # res=":".join(l) # 按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串
  89. # print(res)
  91. # l=[1,"2",'aaa']
  92. # ":".join(l)
  94. #4.2.7、replace
  95. # msg="you can you up no can no bb"
  96. # print(msg.replace("you","YOU",))
  97. # print(msg.replace("you","YOU",1))
  99. #4.2.8、isdigit
  100. # 判断字符串是否由纯数字组成
  101. # print('123'.isdigit())
  102. # print('12.3'.isdigit())
  104. # age=input('请输入你的年龄：').strip()
  105. # if age.isdigit():
  106. #     age=int(age) # int("abbab")
  107. #     if age > 18:
  108. #         print('猜大了')
  109. #     elif age < 18:
  110. #         print('猜小了')
  111. #     else:
  112. #         print('才最了')
  113. # else:
  114. #     print('必须输入数字，傻子')
  117. # 4.3了解
  118. #4.3.1、find,rfind,index,rindex,count
  119. msg='hello egon hahaha'
  120. # 找到返回起始索引
  121. # print(msg.find('e')) # 返回要查找的字符串在大字符串中的起始索引
  122. # print(msg.find('egon'))
  123. # print(msg.index('e'))
  124. # print(msg.index('egon'))
  125. # 找不到
  126. # print(msg.find('xxx')) # 返回-1，代表找不到
  127. # print(msg.index('xxx')) # 抛出异常
  129. # msg='hello egon hahaha egon、 egon'
  130. # print(msg.count('egon'))
  132. #4.3.2、center,ljust,rjust,zfill
  133. # print('egon'.center(50,'*'))
  134. # print('egon'.ljust(50,'*'))
  135. # print('egon'.rjust(50,'*'))
  136. # print('egon'.zfill(10))
  138. #4.3.3、expandtabs
  139. # msg='hello\tworld'
  140. # print(msg.expandtabs(2)) # 设置制表符代表的空格数为2
  142. #4.3.4、captalize,swapcase,title
  143. # print("hello world egon".capitalize())
  144. # print("Hello WorLd EGon".swapcase())
  145. # print("hello world egon".title())
  147. #4.3.5、is数字系列
  148. #4.3.6、is其他
  149. # print('abc'.islower())
  150. # print('ABC'.isupper())
  151. # print('Hello World'.istitle())
  152. # print('123123aadsf'.isalnum()) # 字符串由字母或数字组成结果为True
  153. # print('ad'.isalpha()) # 字符串由由字母组成结果为True
  154. # print('     '.isspace()) # 字符串由空格组成结果为True
  155. # print('print'.isidentifier())
  156. # print('age_of_egon'.isidentifier())
  157. # print('1age_of_egon'.isidentifier())
  160. num1=b'4' #bytes
  161. num2=u'4' #unicode,python3中无需加u就是unicode
  162. num3='四' #中文数字
  163. num4='Ⅳ' #罗马数字
  165. # isdigit只能识别：num1、num2
  166. # print(num1.isdigit()) # True
  167. # print(num2.isdigit()) # True
  168. # print(num3.isdigit()) # False
  169. # print(num4.isdigit()) # False
  173. # isnumberic可以识别：num2、num3、num4
  174. # print(num2.isnumeric()) # True
  175. # print(num3.isnumeric()) # True
  176. # print(num4.isnumeric()) # True
  179. # isdecimal只能识别：num2
  180. print(num2.isdecimal()) # True
  181. print(num3.isdecimal()) # False
  182. print(num4.isdecimal()) # False

列表内置方法

  1. # 1、作用：按位置存放多个值
  2. # 2、定义
  3. # l=[1,1.2,'a'] # l=list([1,1.2,'a'])
  4. # print(type(l))
  6. # 3、类型转换: 但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表
  7. # res=list('hello')
  8. # print(res)
  9. #
  10. # res=list({'k1':111,'k2':222,'k3':3333})
  11. # print(res)
  14. # 4、内置方法
  15. # 优先掌握的操作：
  16. # 1、按索引存取值(正向存取+反向存取)：即可以取也可以改
  17. # l=[111,'egon','hello']
  18. # 正向取
  19. # print(l[0])
  20. # 反向取
  21. # print(l[-1])
  22. # 可以取也可以改：索引存在则修改对应的值
  23. # l[0]=222
  24. # print(l)
  26. # 无论是取值操作还是赋值操作：索引不存在则报错
  27. # l[3]=333
  30. # 2、切片(顾头不顾尾，步长)
  31. l = [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
  32. # print(l[0:3])
  33. # print(l[0:5:2]) # 0 2 4
  35. # print(l[0:len(l)])
  36. # print(l[:])
  37. # new_l=l[:] # 切片等同于拷贝行为，而且相当于浅copy
  38. # print(id(l))
  39. # print(id(new_l))
  41. # l[-1][0]=1111111
  42. # print(l)
  43. # print(new_l)
  45. # print(l[::-1])
  47. # msg1='hello:egon:<>:18[]==123'
  48. # msg2=msg1[:]
  49. # print(msg1,id(msg1))
  50. # print(msg2,id(msg2))
  51. # 3、长度
  52. # print(len([1, 2, 3]))
  53. # 4、成员运算in和not in
  54. # print('aaa' in ['aaa', 1, 2])
  55. # print(1 in ['aaa', 1, 2])
  56. # 5、往列表中添加值
  57. # 5.1 追加
  58. # l=[111,'egon','hello']
  59. # l.append(3333)
  60. # l.append(4444)
  61. # print(l)
  63. # 5.2、插入值
  64. # l=[111,'egon','hello']
  65. # l.insert(0,'alex')
  66. # print(l)
  68. # 5.3、extend添加值
  69. # new_l=[1,2,3]
  70. # l=[111,'egon','hello']
  71. # l.append(new_l)
  72. # print(l)
  74. # 代码实现
  75. # for item in new_l:
  76. #     l.append(item)
  77. # print(l)
  79. # extend实现了上述代码
  80. # l.extend(new_l)
  81. # l.extend('abc')
  82. # print(l)
  85. # 7、删除
  86. # 方式一：通用的删除方法，只是单纯的删除、没有返回值
  87. # l = [111, 'egon', 'hello']
  88. # del l[1]
  89. # x =del l[1] # 抛出异常，不支持赋值语法
  90. # print(l)
  92. # 方式二：l.pop()根据索引删除，会返回删除的值
  93. # l = [111, 'egon', 'hello']
  94. # l.pop() # 不指定索引默认删除最后一个
  95. # l.pop()
  96. # print(l)
  98. # res=l.pop(1)
  99. # print(l)
  101. # print(res)
  103. # 方式三：l.remove()根据元素删除，返回None
  104. # l = [111, 'egon', [1,2,3],'hello']
  105. # l.remove([1,2,3])
  106. # print(l)
  107. # res=l.remove('egon')
  108. # print(res) # None
  111. # 8、循环
  112. # l=[1,'aaa','bbb']
  113. # for x in l:
  114. #     l.pop(1)
  115. #     print(x)
  117. # 需要掌握操作
  118. l = [1, 'aaa', 'bbb','aaa','aaa']
  119. # 1、l.count()
  120. # print(l.count('aaa'))
  122. # 2、l.index()
  123. # print(l.index('aaa'))
  124. # print(l.index('aaaaaaaaa')) # 找不到报错
  126. # 3、l.clear()
  127. # l.clear()
  128. # print(l)
  130. # 4、l.reverse():不是排序，就是将列表倒过来
  131. # l = [1, 'egon','alex','lxx']
  132. # l.reverse()
  133. # print(l)
  135. # 5、l.sort(): 列表内元素必须是同种类型才可以排序
  136. # l=[11,-3,9,2,3.1]
  137. # l.sort() # 默认从小到大排，称之为升序
  138. # l.sort(reverse=True) # 从大到小排，设置为降序
  139. # print(l)
  141. # l=[11,'a',12]
  142. # l.sort()
  144. # l=['c','e','a']
  145. # l.sort()
  146. # print(l)
  148. # 了解：字符串可以比大小，按照对应的位置的字符依次pk
  149. # 字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的
  150. # print('a'>'b')
  151. # print('abz'>'abcdefg')
  153. # 了解：列表也可以比大小,原理同字符串一样,但是对应位置的元素必须是同种类型
  154. # l1=[1,'abc','zaa']
  155. # l2=[1,'abc','zb']
  156. #
  157. # print(l1 < l2)
  160. # 补充
  161. # 1、队列：FIFO,先进先出
  162. # l=[]
  163. # # 入队操作
  164. # l.append('first')
  165. # l.append('second')
  166. # l.append('third')
  167. #
  168. # print(l)
  169. # # 出队操作
  170. # print(l.pop(0))
  171. # print(l.pop(0))
  172. # print(l.pop(0))
  174. # 2、堆栈：LIFO,后进先出
  175. l=[]
  176. # 入栈操作
  177. l.append('first')
  178. l.append('second')
  179. l.append('third')
  181. print(l)
  182. # 出队操作
  183. print(l.pop())
  184. print(l.pop())
  185. print(l.pop())

元组内置方法

  1. # 元组就是"一个不可变的列表"
  2. #1、作用：按照索引/位置存放多个值，只用于读不用于改
  4. #2、定义:（）内用逗号分隔开多个任意类型的元素
  5. # t=(1,1.3,'aa') # t=tuple((1,1.3,'aa'))
  6. # print(t,type(t))
  9. # x=(10) # 单独一个括号代表包含的意思
  10. # print(x,type(x))
  12. # t=(10,) # 如果元组中只有一个元素，必须加逗号
  13. # print(t,type(t))
  15. # t=(1,1.3,'aa') # t=(0->值1的内存地址,1->值1.3的内存地址,2->值'aaa'的内存地址，)
  16. # t[0]=11111
  18. # t=(1,[11,22]) # t=(0->值1的内存地址,1->值[1,2]的内存地址，)
  19. # print(id(t[0]),id(t[1]))
  20. # # t[0]=111111111 # 不能改
  21. # # t[1]=222222222 # 不能改
  22. #
  23. # t[1][0]=11111111111111111
  24. # # print(t)
  25. # print(id(t[0]),id(t[1]))
  28. #3、类型转换
  29. # print(tuple('hello'))
  30. # print(tuple([1,2,3]))
  31. # print(tuple({'a1':111,'a2':333}))
  33. #4、内置方法
  34. #优先掌握的操作：
  35. #1、按索引取值(正向取+反向取)：只能取
  36. # t=('aa','bbb','cc')
  37. # print(t[0])
  38. # print(t[-1])
  40. #2、切片(顾头不顾尾，步长)
  41. # t=('aa','bbb','cc','dd','eee')
  42. # print(t[0:3])
  43. # print(t[::-1])
  45. #3、长度
  46. # t=('aa','bbb','cc','dd','eee')
  47. # print(len(t))
  48. #4、成员运算in和not in
  49. # print('aa' in t)
  51. #5、循环
  52. # for x in t:
  53. #     print(x)
  55. #6、
  56. t=(2,3,111,111,111,111)
  57. # print(t.index(111))
  58. # print(t.index(1111111111))
  60. print(t.count(111))

字典内置方法

  1. #1、作用
  3. #2、定义：{}内用逗号分隔开多个key：value，其中value可以使任意类型，但是
  4. #                                   key必须是不可变类型,且不能重复
  5. # 造字典的方式一：
  6. # d={'k1':111,(1,2,3):222} # d=dict(...)
  7. # print(d['k1'])
  8. # print(d[(1,2,3)])
  9. # print(type(d))
  11. # d={} # 默认定义出来的是空字典
  12. # print(d,type(d))
  14. # 造字典的方式二：
  15. # d=dict(x=1,y=2,z=3)
  16. # print(d,type(d))
  19. #3、数据类型转换
  20. # info=[
  21. #     ['name','egon'],
  22. #     ('age',18),
  23. #     ['gender','male']
  24. # ]
  25. # # d={}
  26. # # for k,v in info: # k,v=['name','egon'],
  27. # #     d[k]=v
  28. # # print(d)
  29. #
  30. # 造字典的方式三：
  31. # res=dict(info) # 一行代码搞定上述for循环的工作
  32. # print(res)
  35. # 造字典的方式四:快速初始化一个字典
  36. # keys=['name','age','gender']
  37. # # d={}
  38. # # for k in keys:
  39. # #     d[k]=None
  40. # # print(d)
  41. # d={}.fromkeys(keys,None) # 一行代码搞定上述for循环的工作
  42. # print(d)
  44. #4、内置方法
  45. #优先掌握的操作：
  46. #1、按key存取值：可存可取
  47. # d={'k1':111}
  48. # 针对赋值操作：key存在，则修改
  49. # d['k1']=222
  50. # 针对赋值操作：key不存在，则创建新值
  51. # d['k2']=3333
  52. # print(d)
  54. #2、长度len
  55. # d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
  56. # print(d)
  57. # print(len(d))
  60. #3、成员运算in和not in:根据key
  61. # d={'k1':111,'k2':2222}
  62. # print('k1' in d)
  63. # print(111 in d)
  65. #4、删除
  66. d={'k1':111,'k2':2222}
  67. # 4.1 通用删除
  68. # del d['k1']
  69. # print(d)
  71. # 4.2 pop删除：根据key删除元素，返回删除key对应的那个value值
  72. # res=d.pop('k2')
  73. # print(d)
  74. # print(res)
  76. # 4.3 popitem删除：随机删除，返回元组(删除的key,删除的value)
  77. # res=d.popitem()
  78. # print(d)
  79. # print(res)
  81. #5、键keys()，值values()，键值对items()  =>在python3中得到的是老母鸡
  82. d={'k1':111,'k2':2222}
  83. '''
  84. 在python2中
  85. >>> d={'k1':111,'k2':2222}
  86. >>> 
  87. >>> d.keys()#6、循环
  88. ['k2', 'k1']
  89. >>> d.values()
  90. [2222, 111]
  91. >>> d.items()
  92. [('k2', 2222), ('k1', 111)]
  93. >>> dict(d.items())
  94. {'k2': 2222, 'k1': 111}
  95. >>>
  96. '''  
  98. #6、for循环
  99. # for k in d.keys():
  100. #     print(k)
  101. #
  102. # for k in d:
  103. #     print(k)
  105. # for v in d.values():
  106. #     print(v)
  108. # for k,v in d.items():
  109. #     print(k,v)
  112. # print(list(d.keys()))
  113. # print(list(d.values()))
  114. # print(list(d.items()))
  117. #需要掌握的内置方法
  118. d={'k1':111}
  119. #1、d.clear()
  121. #2、d.update()
  122. # d.update({'k2':222,'k3':333,'k1':111111111111111})
  123. # print(d)
  125. #3、d.get() ：根据key取值，容错性好
  126. # print(d['k2'])  # key不存在则报错
  128. # print(d.get('k1')) # 111
  129. # print(d.get('k2')) # key不存在不报错，返回None
  131. #4、d.setdefault()
  132. # info={}
  133. # if 'name' in info:
  134. #     ... # 等同于pass
  135. # else:
  136. #     info['name']='egon'
  137. # print(info)
  139. # 4.1 如果key有则不添加,返回字典中key对应的值
  140. info={'name':'egon'}
  141. res=info.setdefault('name','egon')
  142. # print(info)
  144. print(res)
  146. # 4.2 如果key没有则添加，返回字典中key对应的值
  147. info={}
  148. res=info.setdefault('name','egon')
  149. # print(info)
  150. print(res)

集合内置方法

  1. # 1、作用
  2. # 1.1 关系运算
  3. # friends1 = ["zero","kevin","jason","egon"]
  4. # friends2 = ["Jy","ricky","jason","egon"]
  6. # l=[]
  7. # for x in friends1:
  8. #     if x in friends2:
  9. #         l.append(x)
  10. # print(l)
  13. # 1.2、去重
  16. # 2、定义: 在{}内用逗号分隔开多个元素，多个元素满足以下三个条件
  17. #            1. 集合内元素必须为不可变类型
  18. #            2. 集合内元素无序
  19. #            3. 集合内元素没有重复
  21. # s={1,2} # s=set({1,2})
  23. # s={1,[1,2]}                         # 集合内元素必须为不可变类型
  24. # s={1,'a','z','b',4,7}     # 集合内元素无序
  25. # s={1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
  26. # print(s)
  28. # 了解
  29. # s={} # 默认是空字典
  30. # print(type(s))
  31. # 定义空集合
  32. # s=set()
  33. # print(s,type(s))
  35. # 3、类型转换
  36. # set({1,2,3})
  37. # res=set('hellolllll')
  38. # print(res)
  40. # print(set([1,1,1,1,1,1]))
  41. # print(set([1,1,1,1,1,1,[11,222]]) # 报错
  43. # print(set({'k1':1,'k2':2}))
  47. # 4、内置方法
  48. # =========================关系运算符=========================
  49. friends1 = {"zero","kevin","jason","egon"}
  50. friends2 = {"Jy","ricky","jason","egon"}
  52. # 4.1 取交集：两者共同的好友
  53. # res=friends1 & friends2
  54. # print(res)
  55. # print(friends1.intersection(friends2))
  56. # 4.2 取并集/合集：两者所有的好友
  57. # print(friends1 | friends2)
  58. # print(friends1.union(friends2))
  60. # 4.3 取差集：取friends1独有的好友
  61. # print(friends1 - friends2)
  62. # print(friends1.difference(friends2))
  64. # 取friends2独有的好友
  65. # print(friends2 - friends1)
  66. # print(friends2.difference(friends1))
  68. # 4.4 对称差集: 求两个用户独有的好友们（即去掉共有的好友）
  69. # print(friends1 ^ friends2)
  70. # print(friends1.symmetric_difference(friends2))
  72. # 4.5 父子集：包含的关系
  73. # s1={1,2,3}
  74. # s2={1,2,4}
  75. # 不存在包含关系，下面比较均为False
  76. # print(s1 > s2)
  77. # print(s1 < s2)
  79. # s1={1,2,3}
  80. # s2={1,2}
  81. # print(s1 > s2) # 当s1大于或等于s2时，才能说是s1是s2他爹
  82. # print(s1.issuperset(s2))
  83. # print(s2.issubset(s1)) # s2 < s2  =>True
  85. # s1={1,2,3}
  86. # s2={1,2,3}
  87. # print(s1 == s2) # s1与s2互为父子
  88. # print(s1.issuperset(s2))
  89. # print(s2.issuperset(s1))
  92. # =========================去重=========================
  93. # 1、只能针对不可变类型去重
  94. # print(set([1,1,1,1,2]))
  96. # 2、无法保证原来的顺序
  97. # l=[1,'a','b','z',1,1,1,2]
  98. # l=list(set(l))
  99. # print(l)
  102. l=[
  103.     {'name':'lili','age':18,'sex':'male'},
  104.     {'name':'jack','age':73,'sex':'male'},
  105.     {'name':'tom','age':20,'sex':'female'},
  106.     {'name':'lili','age':18,'sex':'male'},
  107.     {'name':'lili','age':18,'sex':'male'},
  108. ]
  109. new_l=[]
  110. for dic in l:
  111.     if dic not in new_l:
  112.         new_l.append(dic)
  114. # print(new_l)
  116. # 其他操作
  117. '''
  118. # 1.长度
  119. >>> s={'a','b','c'}
  120. >>> len(s)
  121. 3
  123. # 2.成员运算
  124. >>> 'c' in s
  125. True
  127. # 3.循环
  128. >>> for item in s:
  129. ...     print(item)
  130. ... 
  131. c
  132. a
  133. b
  134. '''
  136. # 其他内置方法
  137. s={1,2,3}
  138. # 需要掌握的内置方法1：discard
  139. # s.discard(4) # 删除元素不存在do nothing
  140. # print(s)
  141. # s.remove(4) # 删除元素不存在则报错
  144. # 需要掌握的内置方法2：update
  145. # 将s没有的元素
  146. # s.update({1,3,5})
  147. # print(s)
  149. # 需要掌握的内置方法3：pop
  150. # res=s.pop()
  151. # print(res)
  153. # 需要掌握的内置方法4：add
  154. # s.add(4)
  155. # print(s)
  159. # 其余方法全为了解
  160. res=s.isdisjoint({3,4,5,6}) # 两个集合完全独立、没有共同部分，返回True
  161. print(res)
  163. # 了解
  164. # s.difference_update({3,4,5}) # s=s.difference({3,4,5})
  165. # print(s)

编码解码

  1. # coding:utf-8
  4. x='上'
  6. res=x.encode('gbk') # unicode--->gbk
  7. # print(res,type(res))
  9. print(res.decode('gbk'))

FIFO/LIFO

  1. 1、用列表模拟队列的入队与出队操作,FIFO
  2. 2、用列表模拟堆栈的入队与出队操作,LIFO

文件操作

x模式

  1. x模式（控制文件操作的模式）-》了解
  2. x， 只写模式【不可读；不存在则创建，存在则报错】
  4. with open('d.txt', mode='x', encoding='utf-8') as f:
  5.     f.write('哈哈哈\n')

t模式与b模式

  1. 控制文件读写内容的模式
  2. t：
  3.     1、读写都是以字符串（unicode）为单位
  4.     2、只能针对文本文件
  5.     3、必须指定字符编码，即必须指定encoding参数
  6. b：binary模式
  7.     1、读写都是以bytes为单位
  8.     2、可以针对所有文件
  9.     3、一定不能指定字符编码，即一定不能指定encoding参数
  11. 总结：
  12. 1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，b模式则需要手动编码与解码，所以此时t模式更为方便
  13. 2、针对非文本文件（如图片、视频、音频等）只能使用b模式
  15. # 错误演示：t模式只能读文本文件
  16. # with open(r'爱nmlgb的爱情.mp4',mode='rt') as f:
  17. #     f.read() # 硬盘的二进制读入内存-》t模式会将读入内存的内容进行decode解码操作
  20. # with open(r'test.jpg',mode='rb',encoding='utf-8') as f:               #二进制读取，不能写encoding
  21. #     res=f.read() # 硬盘的二进制读入内存—>b模式下，不做任何转换，直接读入内存
  22. #     print(res) # bytes类型—》当成二进制
  23. #     print(type(res))
  25. # with open(r'd.txt',mode='rb') as f:                                                                        #正确
  26. #     res=f.read() # utf-8的二进制
  27. #     print(res,type(res))
  28. # 
  29. #     print(res.decode('utf-8'))
  32. # with open(r'd.txt',mode='rt',encoding='utf-8') as f:       #正确
  33. #     res=f.read() # utf-8的二进制->unicode
  34. #     print(res)
  37. # with open(r'e.txt',mode='wb') as f:            #正确
  38. #     f.write('你好hello'.encode('gbk'))
  40. # with open(r'f.txt',mode='wb') as f:                #正确,这种写入是覆盖写入
  41. #     f.write('你好hello'.encode('utf-8'))
  42. #     f.write('哈哈哈'.encode('gbk'))

a模式追加

  1. with open('access.log', mode='at', encoding='utf-8') as f:    #w是覆盖写，a是追加写入
  2.     f.write('20200311111112 yyy转账200w\n')

文件拷贝工具

  1. # 文件拷贝工具
  2. src_file=input('源文件路径>>: ').strip()
  3. dst_file=input('源文件路径>>: ').strip()
  4. with open(r'{}'.format(src_file),mode='rb') as f1,\
  5.     open(r'{}'.format(dst_file),mode='wb') as f2:
  6.     # res=f1.read() # 内存占用过大
  7.     # f2.write(res)
  9.     for line in f1:
  10.         f2.write(line)
  12. # 循环读取文件
  13. # 方式一：自己控制每次读取的数据的数据量
  14. # with open(r'test.jpg',mode='rb') as f:
  15. #     while True:
  16. #         res=f.read(1024) # 1024
  17. #         if len(res) == 0:
  18. #             break
  19. #         print(len(res))
  22. # 方式二：以行为单位读，当一行内容过长时会导致一次性读入内容的数据量过大
  23. # with open(r'g.txt',mode='rt',encoding='utf-8') as f:
  24. #     for line in f:
  25. #         print(len(line),line)
  27. # with open(r'g.txt',mode='rb') as f:
  28. #     for line in f:
  29. #         print(line)
  31. # with open(r'test.jpg',mode='rb') as f:
  32. #     for line in f:
  33. #         print(line)

文件操作其他方法

  1. # 一：读相关操作
  2. # 1、readline：一次读一行
  3. # 注意readline与readlines区别
  5. # with open(r'g.txt',mode='rt',encoding='utf-8') as f:
  6. #     # res1=f.readline()
  7. #     # res2=f.readline()
  8. #     # print(res2)
  9. #
  10. #     while True:
  11. #         line=f.readline()
  12. #         if len(line) == 0:
  13. #             break
  14. #         print(line)
  16. # 2、readlines：
  17. # with open(r'g.txt',mode='rt',encoding='utf-8') as f:
  18. #     res=f.readlines()
  19. #     print(res)
  21. # 强调：
  22. # f.read()与f.readlines()都是将内容一次性读入内存，如果内容过大会导致内存溢出，若还想将内容全读入内存，
  25. # 二：写相关操作
  26. # f.writelines()：
  27. # with open('h.txt',mode='wt',encoding='utf-8') as f:
  28. #     # f.write('1111\n222\n3333\n')
  29. #
  30. #     # l=['11111\n','2222','3333',4444]
  31. #     l=['11111\n','2222','3333']
  32. #     # for line in l:
  33. #     #     f.write(line)
  34. #     f.writelines(l)          #一次写多行
  37. # with open('h.txt', mode='wb') as f:
  38. #     # l = [
  39. #     #     '1111aaa1\n'.encode('utf-8'),
  40. #     #     '222bb2'.encode('utf-8'),
  41. #     #     '33eee33'.encode('utf-8')
  42. #     # ]
  43. #
  44. #     # 补充1：如果是纯英文字符，可以直接加前缀b得到bytes类型
  45. #     # l = [
  46. #     #     b'1111aaa1\n',
  47. #     #     b'222bb2',
  48. #     #     b'33eee33'
  49. #     # ]
  50. #
  51. #     # 补充2：'上'.encode('utf-8') 等同于bytes('上',encoding='utf-8')
  52. #     l = [
  53. #         bytes('上啊',encoding='utf-8'),
  54. #         bytes('冲呀',encoding='utf-8'),
  55. #         bytes('小垃圾们',encoding='utf-8'),
  56. #     ]
  57. #     f.writelines(l)
  60. # 3、flush：
  61. # with open('h.txt', mode='wt',encoding='utf-8') as f:
  62. #     f.write('哈')
  63. #     # f.flush()
  64.             #flush() 方法是用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件，同时清空缓冲区，不需要是被动的等待输出缓冲区写入。
  67. # 4、了解
  68. with open('h.txt', mode='wt', encoding='utf-8') as f:
  69.     print(f.readable())
  70.     print(f.writable())
  71.     print(f.encoding)
  72.     print(f.name)
  74. print(f.closed)

f.seek，控制文件指针移动

强调：只有0模式可以在t下使用，1、2必须在b模式下用

  1. # 指针移动的单位都是以bytes/字节为单位
  2. # 只有一种情况特殊：
  3. #       t模式下的read(n),n代表的是字符个数
  5. # with open('aaa.txt',mode='rt',encoding='utf-8') as f:
  6. #     res=f.read(4)
  7. #     print(res)
  9. # f.seek(n,模式):n指的是移动的字节个数
  10. # 模式：
  11. # 模式0：参照物是文件开头位置
  12. # f.seek(9,0)
  13. # f.seek(3,0) # 3
  15. # 模式1：参照物是当前指针所在位置
  16. # f.seek(9,1)
  17. # f.seek(3,1) # 12
  19. # 模式2：参照物是文件末尾位置，应该倒着移动
  20. # f.seek(-9,2) # 3
  21. # f.seek(-3,2) # 9
  23. # 强调：只有0模式可以在t下使用，1、2必须在b模式下用
  25. # f.tell() # 获取文件指针当前位置
  27. # 示范
  28. # with open('aaa.txt',mode='rb') as f:
  29. #     f.seek(9,0)
  30. #     f.seek(3,0) # 3
  31. #     # print(f.tell())
  32. #     f.seek(4,0)
  33. #     res=f.read()
  34. #     print(res.decode('utf-8'))
  38. # with open('aaa.txt',mode='rb') as f:
  39. #     f.seek(9,1)
  40. #     f.seek(3,1) # 12
  41. #     print(f.tell())
  44. # with open('aaa.txt',mode='rb') as f:
  45. #     f.seek(-9,2)
  46. #     # print(f.tell())
  47. #     f.seek(-3,2)
  48. #     # print(f.tell())
  49. #     print(f.read().decode('utf-8'))

f.seek的应用

  1. import time
  3. with open('access.log', mode='rb') as f:
  4.     # 1、将指针跳到文件末尾
  5.     # f.read() # 错误
  6.     f.seek(0,2)   #后面会执行失败
  8.     while True:
  9.         line=f.readline()
  10.         if len(line) == 0:
  11.             time.sleep(0.3)
  12.         else:
  13.             print(line.decode('utf-8'),end='')

文件修改的两种方式

  1. # 文件修改的两种方式
  2. # 方式一：文本编辑采用的就是这种方式
  3. # 实现思路：将文件内容发一次性全部读入内存,然后在内存中修改完毕后再覆盖写回原文件
  4. # 优点: 在文件修改过程中同一份数据只有一份
  5. # 缺点: 会过多地占用内存
  6. # with open('c.txt',mode='rt',encoding='utf-8') as f:
  7. #     res=f.read()
  8. #     data=res.replace('alex','dsb')
  9. #     print(data)
  10. #
  11. # with open('c.txt',mode='wt',encoding='utf-8') as f1:
  12. #     f1.write(data)
  15. # 方式二：
  16. import os
  17. # 实现思路：以读的方式打开原文件,以写的方式打开一个临时文件,一行行读取原文件内容,修改完后写入临时文件...,删掉原文件,将临时文件重命名原文件名
  18. # 优点: 不会占用过多的内存
  19. # 缺点: 在文件修改过程中同一份数据存了两份
  20. with open('c.txt', mode='rt', encoding='utf-8') as f, \
  21.         open('.c.txt.swap', mode='wt', encoding='utf-8') as f1:
  22.     for line in f:
  23.         f1.write(line.replace('alex', 'dsb'))
  25. os.remove('c.txt')
  26. os.rename('.c.txt.swap', 'c.txt')
  28. f = open('a.txt')
  29. res = f.read()
  30. print(res)

函数的基本使用

  1. 语法：
  2. def 函数名(参数1,参数2,...):
  3.     """文档描述"""
  4.     函数体
  5.     return 值
  7. # 定义函数发生的事情
  8.   # 1、申请内存空间保存函数体代码
  9.   # 2、将上述内存地址绑定函数名
  10.   # 3、定义函数不会执行函数体代码，但是会检测函数体语法
  12. # 调用函数发生的事情
  13.   # 1、通过函数名找到函数的内存地址
  14.   # 2、然后加口号就是在触发函数体代码的执行
  15.   # print(func)
  16.   # func()

无参函数

  1. # 形式一：无参函数
  2. # def func():
  3. #     # x
  4. # 示范1
  5. # def bar(): # bar=函数的内存地址
  6. #     print('from bar')

有参函数、空函数

  1. # 形式二：有参函数
  2. # def func(x,y): # x=1  y=2
  3. #     print(x,y)
  4. # func(1,2)
  6. # 形式三：空函数,函数体代码为pass
  7. def func(x, y):
  8.     pass

应用场景

  1. # 三种定义方式各用在何处
  2. # 1、无参函数的应用场景
  3. # def interactive():
  4. #     name=input('username>>: ')
  5. #     age=input('age>>: ')
  6. #     gender=input('gender>>: ')
  7. #     msg='名字：{} 年龄：{} 性别'.format(name,age,gender)
  8. #     print(msg)
  9. #
  10. # interactive()
  13. # 2、有参函数的应用场景
  14. # def add(x,y): # 参数-》原材料
  15. #     # x=20
  16. #     # y=30
  17. #     res=x + y
  18. #     # print(res)
  19. #     return res # 返回值-》产品
  20. #
  21. # # add(10,2)
  22. # res=add(20,30)
  23. # print(res)
  25. # 3、空函数的应用场景
  26. # def auth_user():
  27. #     """user authentication function"""
  28. #     pass

调用场景

  1. # 二、调用函数
  2. # 1、语句的形式:只加括号调用函数
  3. # interactive()
  4. # add(1,2)
  6. # 2、表达式形式：
  7.   # def add(x,y): # 参数-》原材料
  8.   #     res=x + y
  9.   #     return res # 返回值-》产品
  11.   # 赋值表达式
  12.   # res=add(1,2)
  13.   # print(res)
  15.   # 数学表达式
  16.   # res=add(1,2)*10
  17.   # print(res)
  19. # 3、函数调用可以当做参数
  20. # res=add(add(1,2),10)
  21. # print(res)

函数返回值

  1. # 三、函数返回值
  2. # return是函数结束的标志，即函数体代码一旦运行到return会立刻
  3. # 终止函数的运行，并且会将return后的值当做本次运行的结果返回：
  4. # 1、返回None：函数体内没有return
  5. #             return
  6. #             return None
  7. #
  8. # 2、返回一个值：return 值
  9. # def func():
  10. #     return 10
  11. #
  12. # res=func()
  13. # print(res)
  15. # 3、返回多个值：用逗号分隔开多个值，会被return返回成元组
  16. def func():
  17.     return 10, 'aa', [1, 2]
  19. res = func()
  20. print(res, type(res))

函数参数

形参与实参

  1. # 一 形参与实参介绍
  2. # 形参：在定义函数阶段定义的参数称之为形式参数，简称形参,相当于变量名
  3. def func(x, y):  # x=1，y=2
  4.     print(x, y)
  7. # 实参：在调用函数阶段传入的值称之为实际参数，简称实参，相当于变量值
  8. # func(1,2)
  10. # 形参与实参的关系：
  11. # 1、在调用阶段，实参（变量值）会绑定给形参（变量名）
  12. # 2、这种绑定关系只能在函数体内使用
  13. # 3、实参与形参的绑定关系在函数调用时生效，函数调用结束后解除绑定关系
  16. # 实参是传入的值，但值可以是以下形式
  17. # 形式一：
  18. # func(1,2)
  20. # 形式二：
  21. # a=1
  22. # b=2
  23. # func(a,b)
  25. # 形式三：
  26. # func(int('1'),2)
  27. # func(func1(1,2,),func2(2,3),333)

位置参数

  1. # 2.1 位置参数：按照从左到右的顺序依次定义的参数称之为位置参数
  2. # 位置形参:在函数定义阶段，按照从左到右的顺序直接定义的"变量名"
  3. #        特点：必须被传值，多一个不行少一个也不行
  4. # def func(x,y):
  5. #     print(x,y)
  6. # func(1,2,3)
  7. # func(1,)
  9. # 位置实参:在函数调用阶段， 按照从左到有的顺序依次传入的值
  10. #        特点：按照顺序与形参一一对应
  12. # func(1,2)
  13. # func(2,1)

关键字参数

  1. # 2.2 关键字参数
  2. # 关键字实参：在函数调用阶段，按照key=value的形式传入的值
  3. #       特点：指名道姓给某个形参传值，可以完全不参照顺序
  4. # def func(x,y):
  5. #     print(x,y)
  7. # func(y=2,x=1)
  8. # func(1,2)
  10. # 混合使用，强调
  11. # 1、位置实参必须放在关键字实参前
  12. # func(1,y=2)
  13. # func(y=2,1)
  15. # 2、不能能为同一个形参重复传值
  16. # func(1,y=2,x=3)
  17. # func(1,2,x=3,y=4)

默认参数

  1. # 2.3 默认参数
  2. # 默认形参：在定义函数阶段，就已经被赋值的形参，称之为默认参数
  3. #       特点：在定义阶段就已经被赋值，意味着在调用阶段可以不用为其赋值
  4. # def func(x,y=3):
  5. #     print(x,y)
  6. #
  7. # # func(x=1)
  8. # func(x=1,y=44444)
  11. # def register(name,age,gender='男'):
  12. #     print(name,age,gender)
  13. #
  14. # register('三炮',18)
  15. # register('没炮',19,'女')
  17. 强调：
  18.     # 位置形参与默认形参混用，强调：
  19.     # 1、位置形参必须在默认形参的左边
  20.     # def func(y=2,x):      #错误
  21.     #     pass
  24. # 2、默认参数的值是在函数定义阶段被赋值的，准确地说被赋予的是值的内存地址
  25. # 示范1：
  26.   # m=2
  27.   # def func(x,y=m): # y=>2的内存地址
  28.   #     print(x,y
  29.   # m=3333333333333333333
  30.   # func(1)
  32. # 示范2：
  33.   # m = [111111, ]
  34.   # def func(x, y=m): # y=>[111111, ]的内存地址
  35.   #     print(x, y)
  36.   # m.append(3333333)
  37.   # func(1)
  40. # 3、虽然默认值可以被指定为任意数据类型，但是不推荐使用可变类型
  41. # 函数最理想的状态：函数的调用只跟函数本身有关系，不外界代码的影响
  42. m = [111111, ]
  43. def func(x, y=m):
  44.    print(x, y)
  46. m.append(3333333)
  47. m.append(444444)
  48. m.append(5555)
  50. func(1)
  51. func(2)
  52. func(3)

可变长度的位置参数*

  1. # 2.4 可变长度的参数（*与**的用法）
  2. # 可变长度指的是在调用函数时，传入的值（实参）的个数不固定
  3. # 而实参是用来为形参赋值的，所以对应着，针对溢出的实参必须有对应的形参来接收
  6. # 2.4.1 可变长度的位置参数
  7. # I：*形参名：用来接收溢出的位置实参，溢出的位置实参会被*保存成元组的格式然后赋值紧跟其后的形参名
  8. #           *后跟的可以是任意名字，但是约定俗成应该是args
  10.       # def func(x,y,*z): # z =（3,4,5,6）
  11.       #     print(x,y,z)
  13.       # func(1,2,3,4,5,6)
  15.       # def my_sum(*args):
  16.       #     res=0
  17.       #     for item in args:
  18.       #         res+=item
  19.       #     return res
  20.       #
  21.       # res=my_sum(1,2,3,4,)
  22.       # print(res)
  25. # II: *可以用在实参中，实参中带*，先*后的值打散成位置实参
  26.       # def func(x,y,z):
  27.       #     print(x,y,z)
  28.       #
  29.       # # func(*[11,22,33]) # func(11，22，33)
  30.       # # func(*[11,22]) # func(11，22)
  31.       #
  32.       # l=[11,22,33]
  33.       # func(*l)
  35. # III: 形参与实参中都带*
  36.       # def func(x,y,*args): # args=(3,4,5,6)
  37.       #     print(x,y,args)
  39.       # func(1,2,[3,4,5,6])
  40.       # func(1,2,*[3,4,5,6]) # func(1,2,3,4,5,6)
  41.       # func(*'hello') # func('h','e','l','l','o')

可变长度的关键字参数**

  1. # 2.4.2 可变长度的关键字参数
  2. # I：**形参名：用来接收溢出的关键字实参，**会将溢出的关键字实参保存成字典格式，然后赋值给紧跟其后的形参名
  3.     #           **后跟的可以是任意名字，但是约定俗成应该是kwargs
  4.     # def func(x,y,**kwargs):
  5.     #     print(x,y,kwargs)
  6.     #
  7.     # func(1,y=2,a=1,b=2,c=3)
  9. # II: **可以用在实参中(**后跟的只能是字典)，实参中带**，先**后的值打散成关键字实参
  10.     # def func(x,y,z):
  11.     #     print(x,y,z)
  13.     # func(*{'x':1,'y':2,'z':3}) # func('x','y','z')
  14.     # func(**{'x':1,'y':2,'z':3}) # func(x=1,y=2,z=3)
  16.     # 错误
  17.     # func(**{'x':1,'y':2,}) # func(x=1,y=2)
  18.     # func(**{'x':1,'a':2,'z':3}) # func(x=1,a=2,z=3)
  21. # III: 形参与实参中都带**
  22.     # def func(x,y,**kwargs):
  23.     #     print(x,y,kwargs)
  25.     # func(y=222,x=111,a=333,b=444)
  26.     # func(**{'y':222,'x':111,'a':333,'b':4444})

混用与*

  1. # 混用*与**：*args必须在**kwargs之前
  2. # def func(x,*args,**kwargs):
  3. #     print(args)
  4. #     print(kwargs)
  5. #
  6. # func(1,2,3,4,5,6,7,8,x=1,y=2,z=3)
  8. 例子：
  9.     def index(x,y,z):
  10.         print('index=>>> ',x,y,z)
  12.     def wrapper(*args,**kwargs): #args=(1,) kwargs={'z':3,'y':2}
  13.         index(*args,**kwargs)
  14.         index(*(1,),**{'z':3,'y':2})
  15.         index(1,z=3,y=2)
  17.     wrapper(1,z=3,y=2) # 为wrapper传递的参数是给index用的
  18.     # 原格式---》汇总-----》打回原形
  20. wrapper(1,z=3,y=2)====>args=(1,) kwargs={'z':3,'y':2}===>index(1,z=3,y=2)
  21.                                              wrapper(*args,**kwargs)           index(*args,**kwargs)

命名关键字参数

  1. # 1. 命名关键字参数（了解）
  2. #  命名关键字参数：在定义函数时，*后定义的参数，如下所示，称之为命名关键字参数
  3. # 特点：
  4. # 1、命名关键字实参必须按照key=value的形式为其传值
  5. # def func(x,y,*,a,b): # 其中，a和b称之为命名关键字参数
  6. #     print(x,y)
  7. #     print(a,b)
  8. #
  9. # # func(1,2,b=222,a=111)
  11. # 示例
  12. # def func(x,y,*,a=11111,b):
  13. #     print(x,y)
  14. #     print(a,b)
  15. #
  16. # func(1,2,b=22222)

组合使用

  1. # 2. 组合使用（了解）
  2. # 形参混用的顺序：位置新参，默认形参,*args,命名关键字形参，**kwargs
  3. # def func(x,y=111,*args,z,**kwargs):
  4. #     print(x)
  5. #     print(y)
  6. #     print(args)
  7. #     print(z)
  8. #     print(kwargs)
  11. # 实参混用的顺序：
  12. def func(x,y,z,a,b,c):
  13.     print(x)
  14.     print(y)
  15.     print(z)
  16.     print(a)
  17.     print(b)
  18.     print(c)
  20. # func(111,y=222,*[333,444],**{'b':555,'c':666})
  21. # func(111,y=222,333,444,b=555,c=666)
  23. # func(111,*[333,444],a=222,**{'b':555,'c':666})
  24. # func(111,333,444,a=222,b=555,c=66)
  26. # func(111,*[333,444],**{'b':555,'c':666},a=222,)
  27. func(111,3333,4444,b=555,c=666,a=222)
  30. # func(1)
  31. # func(x=1)
  32. # func(1,x=1)
  33. # func(*'hello')
  34. # func(**{})
  35. # func(*'hell',**{})

函数名称空间与作用域

  1. # 有了名称空间之后，就可以在栈区中存放相同的名字，详细的，名称空间

三种名称空间

  1. # 1.1 内置名称空间
  2. # 存放的名字：存放的python解释器内置的名字
  3. '''
  4. >>> print
  5. <built-in function print>
  6. >>> input
  7. <built-in function input>
  8. '''
  9. # 存活周期：python解释器启动则产生，python解释器关闭则销毁
  12. # 1.2 全局名称空间
  13. # 存放的名字：只要不是函数内定义、也不是内置的，剩下的都是全局名称空间的名字
  14. # 存活周期：python文件执行则产生，python文件运行完毕后销毁
  16. # import os
  17. #
  18. # x=10
  19. # if 13 > 3:
  20. #     y=20
  21. #     if 3 == 3:
  22. #         z=30
  23. #
  24. # # func=函数的内存地址
  25. # def func():
  26. #     a=111
  27. #     b=222
  29. # class Foo:
  30. #     pass
  33. # 1.3 局部名称空间
  34. # 存放的名字：在调用函数时，运行函数体代码过程中产生的函数内的名字
  35. # 存活周期：在调用函数时存活，函数调用完毕后则销毁
  36. # def func(a,b):
  37. #     pass
  38. #
  39. # func(10,1)
  40. # func(11,12)

名称空间查找顺序

  1. # 1.4 名称空间的加载顺序
  2. # 内置名称空间>全局名称空间>局部名称空间
  4. # 1.5 销毁顺序
  5. # 局部名称空间>全局名空间>内置名称空间
  7. # 1.6 名字的查找优先级：当前所在的位置向上一层一层查找
  8. # 内置名称空间
  9. # 全局名称空间
  10. # 局部名称空间
  12. # 如果当前在局部名称空间：
  13. # 局部名称空间—>全局名称空间->内置名称空间
  14. # # input=333
  15. # def func():
  16. #     # input=444
  17. #     print(input)
  18. #
  19. # func()
  21. # 如果当前在全局名称空间
  22. # 全局名称空间->内置名称空间
  23. # input=333
  24. # def func():
  25. #     input=444
  26. # func()
  27. # print(input)

作用域

  1. # 二：作用域-》作用范围
  2. # 全局作用域：内置名称空间、全局名称空间
  3. # 1、全局存活
  4. # 2、全局有效:被所有函数共享
  6. # 局部作用域: 局部名称空间的名字
  7. # 1、临时存活
  8. # 2、局部有效:函数内有效
  9. # def foo(x):
  10. #     def f1():
  11. #         def f2():
  12. #             print(x)

global与nonlocal

  1. # 示范2：如果再局部想要修改全局的名字对应的值（不可变类型），需要用global
  2. # x=111
  3. #
  4. # def func():
  5. #     global x # 声明x这个名字是全局的名字，不要再造新的名字了
  6. #     x=222
  7. #
  8. # func()
  9. # print(x)   #x=222
  12. # nonlocal(了解): 修改函数外层函数包含的名字对应的值（不可变类型）
  13. # x=0
  14. # def f1():
  15. #     x=11
  16. #     def f2():
  17. #         nonlocal x        #修改了f1下的x
  18. #         x=22
  19. #     f2()
  20. #     print('f1内的x：',x)
  21. #
  22. # f1()

函数对象

  1. # 精髓：可以把函数当成变量去用
  2. # func=内存地址
  3. def func():
  4.     print('from func')
  7. # 1、可以赋值
  8.   # f=func
  9.   # print(f,func)
  10.   # f()
  12. # 2、可以当做函数当做参数传给另外一个函数
  13.   # def foo(x): # x = func的内存地址
  14.   #     # print(x)
  15.   #     x()
  16.   #
  17.   # foo(func) # foo(func的内存地址)
  19. # 3、可以当做函数当做另外一个函数的返回值
  20.   # def foo(x): # x=func的内存地址
  21.   #     return x # return func的内存地址
  22.   #
  23.   # res=foo(func) # foo（func的内存地址）
  24.   # print(res) # res=func的内存地址
  25.   #
  26.   # res()
  28. # 4、可以当做容器类型的一个元素
  29.   # l=[func,]
  30.   # # print(l)
  31.   # l[0]()

函数对象应用

  1. def login():
  2.     print('登录功能')
  5. def transfer():
  6.     print('转账功能')
  9. def check_banlance():
  10.     print('查询余额')
  13. def withdraw():
  14.     print('提现')
  17. def register():
  18.     print('注册')
  21. func_dic = {
  22.     '0': ['退出', None],
  23.     '1': ['登录', login],
  24.     '2': ['转账', transfer],
  25.     '3': ['查询余额', check_banlance],
  26.     '4': ['提现', withdraw],
  27.     '5': ['注册', register]
  28. }
  29. # func_dic['1']()
  32. while True:
  33.     for k in func_dic:
  34.         print(k, func_dic[k][0])
  36.     choice = input('请输入命令编号：').strip()
  37.     if not choice.isdigit():
  38.         print('必须输入编号，傻叉')
  39.         continue
  41.     if choice == '0':
  42.         break
  44.     # choice='1'
  45.     if choice in func_dic:
  46.         func_dic[choice][1]()
  47.     else:
  48.         print('输入的指令不存在')

函数嵌套

  1. # 函数嵌套
  2. # 1、函数的嵌套调用：在调用一个函数的过程中又调用其他函数
  3.     # def max2(x,y):
  4.     #     if x > y:
  5.     #         return x
  6.     #     else:
  7.     #         return y
  8.     #
  9.     #
  10.     # def max4(a,b,c,d):
  11.     #     # 第一步：比较a，b得到res1
  12.     #     res1=max2(a,b)
  13.     #     # 第二步：比较res1，c得到res2
  14.     #     res2=max2(res1,c)
  15.     #     # 第三步：比较res2，d得到res3
  16.     #     res3=max2(res2,d)
  17.     #     return res3
  18.     #
  19.     # res=max4(1,2,3,4)
  20.     # print(res)
  23. # 2、函数的嵌套定义:在函数内定义其他函数
  24. # def f1():
  25. #     def f2():
  26. #         pass
  29. # 圆形
  30. # 求圆形的求周长：2*pi*radius
  31.     def circle(radius,action=0):
  32.         from math import pi
  34.         def perimiter(radius):
  35.             return 2*pi*radius
  37.         # 求圆形的求面积：pi*(radius**2)
  38.         def area(radius):
  39.             return pi*(radius**2)
  41.         if action == 0:
  42.             return 2*pi*radius
  44.         elif action == 1:
  45.             return area(radius)
  47.     circle(33,action=0)

闭包函数

  1. # 一：大前提：
  2. # 闭包函数=名称空间与作用域+函数嵌套+函数对象
  3. #        核心点：名字的查找关系是以函数定义阶段为准
  5. # 二：什么是闭包函数
  6. # "闭"函数指的该函数是内嵌函数
  7. # "包"函数指的该函数包含对外层函数作用域名字的引用（不是对全局作用域）
  9. # 闭包函数：名称空间与作用域的应用+函数嵌套
  10. # def f1():
  11. #     x = 33333333333333333333
  12. #     def f2():
  13. #         print(x)
  14. #     f2()
  16. # 闭包函数：函数对象
  17. # def f1():
  18. #     x = 33333333333333333333
  19. #     def f2():
  20. #         print('函数f2：',x)
  21. #     return f2
  22. # f=f1()
  23. # # print(f)

闭包应用

  1. import requests
  3. # 传参的方案一：
  4. # def get(url):
  5. #     response=requests.get(url)
  6. #     print(len(response.text))
  7. #
  8. # get('https://www.baidu.com')
  9. # get('https://www.cnblogs.com/linhaifeng')
  10. # get('https://zhuanlan.zhihu.com/p/109056932')
  13. # 传参的方案二：
  14. # 一次传参，多次调用不用再次传参
  15. def outter(url):
  16.     # url='https://www.baidu.com'
  17.     def get():
  18.         response=requests.get(url)
  19.         print(len(response.text))
  20.     return get
  22. baidu=outter('https://www.baidu.com')
  23. baidu()
  25. cnblogs=outter('https://www.cnblogs.com/linhaifeng')
  26. cnblogs()
  28. zhihu=outter('https://zhuanlan.zhihu.com/p/109056932')
  29. zhihu()

无参装饰器

装饰器准备知识

  1. # 一：储备知识
  2. #1、 *args， **kwargs
  3. def index(x,y):
  4.     print(x,y)
  7. def wrapper(*args,**kwargs):
  8.     index(*args,**kwargs) #
  9.                           # index(y=222,x=111)
  10. wrapper(y=222,x=111)
  13. # 2、名称空间与作用域：名称空间的的"嵌套"关系是在函数定义阶段，即检测语法的时候确定的
  16. # 3、函数对象：
  17. #    可以把函数当做参数传入
  18. #    可以把函数当做返回值返回
  19.     def index():
  20.         return 123
  22.     def foo(func):
  23.         return func
  25.     foo(index)
  28. #4、函数的嵌套定义:
  29. def outter(func):
  30.     def wrapper():
  31.         pass
  32.     return wrapper
  35. # 闭包函数
  36. def outter():
  37.     x=111
  38.     def wrapper():
  39.         x
  40.     return wrapper
  42. f=outter()
  46. # 传参的方式一：通过参数的形式为函数体传值
  47.     def wrapper(x):
  48.         print(1)
  49.         print(2)
  50.         print(3)
  51.         x
  53.     wrapper(1)
  54.     wrapper(2)
  55.     wrapper(3)
  58. #传参的方式二：通过闭包的方式为函数体传值
  59.     def outter(x):
  60.         # x=1
  61.         def wrapper():
  62.             print(1)
  63.             print(2)
  64.             print(3)
  65.             x
  66.         return wrapper # return outter内的wrapper那个函数的内地址
  68.     # f1=outter(1)
  69.     # f2=outter(2)
  70.     # f3=outter(3)
  72. wrapper=outter(1)

装饰器理论

  1. """
  2. 1、什么是装饰器
  3.     器指的是工具，可以定义成成函数
  4.     装饰指的是为其他事物添加额外的东西点缀
  6.     合到一起的解释：
  7.         装饰器指的定义一个函数，该函数是用来为其他函数添加额外的功能
  10. 2、为何要用装饰器
  11.     开放封闭原则
  12.         开放：指的是对拓展功能是开放的
  13.         封闭：指的是对修改源代码是封闭的
  15. 装饰器就是在不修改被装饰器对象源代码以及调用方式的前提下为被装饰对象添加新功能

装饰器创造过程

  1. 3、如何用
  2. """
  3. # 需求：在不修改index函数的源代码以及调用方式的前提下为其添加统计运行时间的功能
  4.   def index(x,y):
  5.       time.sleep(3)
  6.       print('index %s %s' %(x,y))
  8. index(111,222)
  9. # index(y=111,x=222)
  10. # index(111,y=222)
  13. #解决方案一：失败
  14. #问题：没有修改被装饰对象的调用方式，但是修改了其源代码
  15.     import time
  16.     def index(x,y):
  17.         start=time.time()
  18.         time.sleep(3)
  19.         print('index %s %s' %(x,y))
  20.         stop = time.time()
  21.         print(stop - start)
  23.     index(111,222)
  27. # 解决方案二：失败
  28. # 问题：没有修改被装饰对象的调用方式，也没有修改了其源代码，并且加上了新功能
  29. #      但是代码冗余
  30.     import time
  32.     def index(x,y):
  33.         time.sleep(3)
  34.         print('index %s %s' %(x,y))
  36.     start=time.time()
  37.     index(111,222)
  38.     stop=time.time()
  39.     print(stop - start)
  43. # 解决方案三：失败
  44. # 问题：解决了方案二代码冗余问题，但带来一个新问题即函数的调用方式改变了
  45.     import time
  46.     def index(x,y):
  47.         time.sleep(3)
  48.         print('index %s %s' %(x,y))
  50.     def wrapper():
  51.         start=time.time()
  52.         index(111,222)
  53.         stop=time.time()
  54.         print(stop - start)
  56.     wrapper()
  60. # 方案三的优化一：将index的参数写活了
  61.     import time
  62.     def index(x,y,z):
  63.         time.sleep(3)
  64.         print('index %s %s %s' %(x,y,z))
  66.     def wrapper(*args,**kwargs):
  67.         start=time.time()
  68.         index(*args,**kwargs) # index(3333,z=5555,y=44444)
  69.         stop=time.time()
  70.         print(stop - start)
  72.     # wrapper(3333,4444,5555)
  76. # 方案三的优化二：在优化一的基础上把被装饰对象写活了，原来只能装饰index（增加了装饰任意函数）
  77.     import time
  79.     def index(x,y,z):
  80.         time.sleep(3)
  81.         print('index %s %s %s' %(x,y,z))
  83.     def home(name):
  84.         time.sleep(2)
  85.         print('welcome %s to home page' %name)
  88.     def outter(func):   # func = index的内存地址
  89.         def wrapper(*args,**kwargs):
  90.             start=time.time()
  91.             func(*args,**kwargs) # index的内存地址()
  92.             stop=time.time()
  93.             print(stop - start)
  94.         return wrapper    #增加了这一句，能够根据返回值函数来调用
  96.     index=outter(index) # index=wrapper的内存地址
  97.     home=outter(home) # home=wrapper的内存地址
  100.     home('egon')
  101.     # home(name='egon')
  105. # 方案三的优化三：将wrapper做的跟被装饰对象一模一样，以假乱真
  106.     import time
  107.     def index(x,y,z):
  108.         time.sleep(3)
  109.         print('index %s %s %s' %(x,y,z))
  111.     def home(name):
  112.         time.sleep(2)
  113.         print('welcome %s to home page' %name)
  115.     def outter(func):
  116.         def wrapper(*args,**kwargs):
  117.             start=time.time()
  118.             res=func(*args,**kwargs)      #res=接受了被装饰函数的返回值
  119.             stop=time.time()
  120.             print(stop - start)
  121.             return res                                #return res，将接受的返回值通过wrapper函数返回去
  122.         return wrapper
  124.     # # 偷梁换柱：home这个名字指向的wrapper函数的内存地址
  125.     home=outter(home)
  127.     res=home('egon') # res=wrapper('egon')
  128.     print('返回值--》',res)
  130.     #大方向：如何在方案三的基础上不改变函数的调用方式

装饰器语法糖

  1. # 语法糖：让你开心的语法
  2. import time
  4. # 装饰器先定义好
  5.   def timmer(func):
  6.       def wrapper(*args,**kwargs):
  7.           start=time.time()
  8.           res=func(*args,**kwargs)
  9.           stop=time.time()
  10.           print(stop - start)
  11.           return res
  12.       return wrapper
  15. # 在被装饰对象正上方的单独一行写@装饰器名字
  16.     # @timmer # index=timmer(index)
  17.     def index(x,y,z):
  18.         time.sleep(3)
  19.         print('index %s %s %s' %(x,y,z))
  21.     # @timmer # home=timmer(ome)
  22.     def home(name):
  23.         time.sleep(2)
  24.         print('welcome %s to home page' %name)
  26.     # index(x=1,y=2,z=3)
  27.     # home('egon')
  30. # 思考题（选做），叠加多个装饰器，加载顺序与运行顺序。----》加载顺序是从上到下
  31.   # @deco1 # index=deco1(deco2.wrapper的内存地址)
  32.   # @deco2 # deco2.wrapper的内存地址=deco2(deco3.wrapper的内存地址)
  33.   # @deco3 # deco3.wrapper的内存地址=deco3(index)
  34.   # def index():
  35.   #     pass
  38. # 总结无参装饰器模板
  39. def outter(func):
  40.     def wrapper(*args,**kwargs):
  41.         # 1、调用原函数
  42.         # 2、为其增加新功能
  43.         res=func(*args,**kwargs)
  44.         return res
  45.     return wrapper

装饰器应用

  1. #为其他函数添加输入密码验证功能
  2. def auth(func):
  3.     def wrapper(*args,**kwargs):
  4.         # 1、调用原函数
  5.         # 2、为其增加新功能
  6.         name=input('your name>>: ').strip()
  7.         pwd=input('your password>>: ').strip()
  8.         if name == 'egon' and pwd == '123':
  9.             res=func(*args,**kwargs)
  10.             return res
  11.         else:
  12.             print('账号密码错误')
  13.     return wrapper
  15. @auth
  16. def index():
  17.     print('from index')
  19. index()

装饰器wraps模块

  1. #偷梁换柱，即将原函数名指向的内存地址偷梁换柱成wrapper函数
  2. #        所以应该将wrapper做的跟原函数一样才行
  5. from functools import wraps
  7. def outter(func):
  8.     @wraps(func)     #打印后面index的摘要或者函数名称，将打印的是index的摘要或者函数名称，不是wrapper的摘要、名称
  9.     def wrapper(*args, **kwargs):
  10.         """这个是主页功能"""
  11.         res = func(*args, **kwargs) # res=index(1,2)
  12.         return res
  14.     # 手动将原函数的属性赋值给wrapper函数
  15.     # 1、函数wrapper.__name__ = 原函数.__name__
  16.     # 2、函数wrapper.__doc__ = 原函数.__doc__
  17.     # wrapper.__name__ = func.__name__
  18.     # wrapper.__doc__ = func.__doc__
  20.     return wrapper
  24. @outter # index=outter(index)
  25. def index(x,y):
  26.     """这个是主页功能"""
  27.     print(x,y)
  30. print(index.__name__) 
  31. print(index.__doc__) #help(index)

有参装饰器

知识准备

  1. # 一：知识储备
  2. # 由于语法糖@的限制，outter函数只能有一个参数，并且该才是只用来接收
  3. #                                       被装饰对象的内存地址
  4. def outter(func):
  5.     # func = 函数的内存地址
  6.     def wrapper(*args,**kwargs):
  7.         res=func(*args,**kwargs)
  8.         return res
  9.     return wrapper
  11. # @outter # index=outter(index) # index=>wrapper
  12. @outter # outter(index)
  13. def index(x,y):
  14.     print(x,y)
  16. # 偷梁换柱之后
  17. # index的参数什么样子，wrapper的参数就应该什么样子
  18. # index的返回值什么样子，wrapper的返回值就应该什么样子
  19. # index的属性什么样子，wrapper的属性就应该什么样子==》from functools import wraps

有参装饰器创造过程

  1. # 山炮玩法：
  2. def auth(func,db_type):
  3.     def wrapper(*args, **kwargs):
  4.         name=input('your name>>>: ').strip()
  5.         pwd=input('your password>>>: ').strip()
  7.         if db_type == 'file':
  8.             print('基于文件的验证')
  9.             if name == 'egon' and pwd == '123':
  10.                 res = func(*args, **kwargs)
  11.                 return res
  12.             else:
  13.                 print('user or password error')
  14.         elif db_type == 'mysql':
  15.             print('基于mysql的验证')
  16.         elif db_type == 'ldap':
  17.             print('基于ldap的验证')
  18.         else:
  19.             print('不支持该db_type')
  21.     return wrapper
  22. #
  23. # @auth  # 账号密码的来源是文件
  24. def index(x,y):
  25.     print('index->>%s:%s' %(x,y))
  27. # @auth # 账号密码的来源是数据库
  28. def home(name):
  29.     print('home->>%s' %name)
  31. # @auth # 账号密码的来源是ldap
  32. def transfer():
  33.     print('transfer')
  36. index=auth(index,'file')     #给装饰器函数添加了第二个参数
  37. home=auth(home,'mysql')
  38. transfer=auth(transfer,'ldap')
  40. # index(1,2)
  41. # home('egon')
  42. # transfer()
  45. #======================================================
  47. # 山炮二
  48. def auth(db_type):
  49.     def deco(func):
  50.         def wrapper(*args, **kwargs):
  51.             name=input('your name>>>: ').strip()
  52.             pwd=input('your password>>>: ').strip()
  54.             if db_type == 'file':
  55.                 print('基于文件的验证')
  56.                 if name == 'egon' and pwd == '123':
  57.                     res = func(*args, **kwargs)
  58.                     return res
  59.                 else:
  60.                     print('user or password error')
  61.             elif db_type == 'mysql':
  62.                 print('基于mysql的验证')
  63.             elif db_type == 'ldap':
  64.                 print('基于ldap的验证')
  65.             else:
  66.                 print('不支持该db_type')
  68.         return wrapper
  69.     return deco
  71. deco=auth(db_type='file')
  72. @deco # 账号密码的来源是文件
  73. def index(x,y):
  74.     print('index->>%s:%s' %(x,y))
  76. deco=auth(db_type='mysql')
  77. @deco # 账号密码的来源是数据库
  78. def home(name):
  79.     print('home->>%s' %name)
  81. deco=auth(db_type='ldap')
  82. @deco # 账号密码的来源是ldap
  83. def transfer():
  84.     print('transfer')
  87. index(1,2)
  88. home('egon')
  89. transfer()

有参装饰器语法糖

  1. # 语法糖
  2. def auth(db_type):
  3.     def deco(func):
  4.         def wrapper(*args, **kwargs):
  5.             name = input('your name>>>: ').strip()
  6.             pwd = input('your password>>>: ').strip()
  8.             if db_type == 'file':
  9.                 print('基于文件的验证')
  10.                 if name == 'egon' and pwd == '123':
  11.                     res = func(*args, **kwargs)  # index(1,2)
  12.                     return res
  13.                 else:
  14.                     print('user or password error')
  15.             elif db_type == 'mysql':
  16.                 print('基于mysql的验证')
  17.             elif db_type == 'ldap':
  18.                 print('基于ldap的验证')
  19.             else:
  20.                 print('不支持该db_type')
  21.         return wrapper
  22.     return deco
  25. @auth(db_type='file')  # @deco # index=deco(index) # index=wrapper
  26. def index(x, y):
  27.     print('index->>%s:%s' % (x, y))
  29. @auth(db_type='mysql')  # @deco # home=deco(home) # home=wrapper
  30. def home(name):
  31.     print('home->>%s' % name)
  34. @auth(db_type='ldap')  # 账号密码的来源是ldap
  35. def transfer():
  36.     print('transfer')
  38. # index(1, 2)
  39. # home('egon')
  40. # transfer()

有参装饰器模板

  1. # 有参装饰器模板
  2. def 有参装饰器(x,y,z):
  3.     def outter(func):
  4.         def wrapper(*args, **kwargs):
  5.             res = func(*args, **kwargs)
  6.             return res
  7.         return wrapper
  8.     return outter
  10. @有参装饰器(1,y=2,z=3)
  11. def 被装饰对象():
  12.     pass

叠加多个装饰器分析

  1. # 一、叠加多个装饰器的加载、运行分析（了解***）
  3. def deco1(func1): # func1 = wrapper2的内存地址
  4.     def wrapper1(*args,**kwargs):
  5.         print('正在运行===>deco1.wrapper1')
  6.         res1=func1(*args,**kwargs)
  7.         return res1
  8.     return wrapper1
  10. def deco2(func2): # func2 = wrapper3的内存地址
  11.     def wrapper2(*args,**kwargs):
  12.         print('正在运行===>deco2.wrapper2')
  13.         res2=func2(*args,**kwargs)
  14.         return res2
  15.     return wrapper2
  17. def deco3(x):
  18.     def outter3(func3): # func3=被装饰对象index函数的内存地址
  19.         def wrapper3(*args,**kwargs):
  20.             print('正在运行===>deco3.outter3.wrapper3')
  21.             res3=func3(*args,**kwargs)
  22.             return res3
  23.         return wrapper3
  24.     return outter3
  27. # 加载顺序自下而上(了解)
  28. @deco1      # index=deco1(wrapper2的内存地址)        ===> index=wrapper1的内存地址
  29. @deco2      # index=deco2(wrapper3的内存地址)        ===> index=wrapper2的内存地址
  30. @deco3(111) # ===>@outter3===> index=outter3(index) ===> index=wrapper3的内存地址
  31. def index(x,y):
  32.     print('from index %s:%s' %(x,y))
  34. # 执行顺序自上而下的，即wraper1-》wrapper2-》wrapper3
  35. index(1,2) # wrapper1(1,2)

01-python基础部分 - 图1

迭代器

  1. 1、什么是迭代器
  2.     迭代器指的是迭代取值的工具，迭代是一个重复的过程，每次重复
  3.     都是基于上一次的结果而继续的，单纯的重复并不是迭代
  5. 2、为何要有迭代器
  6.     迭代器是用来迭代取值的工具，而涉及到把多个值循环取出来的类型
  7.     有：列表、字符串、元组、字典、集合、打开文件
  9.     l=['egon','liu','alex']
  10.     i=0
  11.     while i < len(l):
  12.         print(l[i])
  13.         i+=1
  15.     上述迭代取值的方式只适用于有索引的数据类型：列表、字符串、元组
  16.     为了解决基于索引迭代器取值的局限性
  17.     python必须提供一种能够不依赖于索引的取值方式，这就是迭代器

可迭代对象

  1. # 1、可迭代的对象：但凡内置有__iter__方法的都称之为可迭代的对象
  2. # s1=''
  3. # # s1.__iter__()
  5. # l=[]
  6. # # l.__iter__()
  8. # t=(1,)
  9. # # t.__iter__()
  11. # d={'a':1}
  12. # # d.__iter__()
  13. # set1={1,2,3}
  14. # # set1.__iter__()
  16. # with open('a.txt',mode='w') as f:
  17. #     # f.__iter__()
  18. #     pass

迭代器对象

  1. # 2、调用可迭代对象下的__iter__方法会将其转换成迭代器对象,迭代器对象具有__next__方法
  2. d={'a':1,'b':2,'c':3}
  3. d_iterator=d.__iter__()
  4. # print(d_iterator)
  7. # print(d_iterator.__next__())
  8. # print(d_iterator.__next__())
  9. # print(d_iterator.__next__())
  10. # print(d_iterator.__next__()) # 取完之后会抛出异常StopIteration
  12. # l=[1,2,3,4,5]
  13. # l_iterator=l.__iter__()
  14. #
  15. # while True:
  16. #     try:
  17. #         print(l_iterator.__next__())
  18. #     except StopIteration:
  19. #         break
  24. # 3、可迭代对象与迭代器对象详解
  25.     # 3.1 可迭代对象（"可以转换成迭代器的对象"）：内置有__iter__方法对象
  26.     #        可迭代对象.__iter__(): 得到迭代器对象
  28.     # 3.2 迭代器对象：内置有__next__方法并且内置有__iter__方法的对象
  29.     #        迭代器对象.__next__（）：得到迭代器的下一个值
  30.     #        迭代器对象.__iter__（）：得到迭代器的本身，说白了调了跟没调一个样子
  31.     # dic={'a':1,'b':2,'c':3}
  32.     #
  33.     # dic_iterator=dic.__iter__()
  34.     # print(dic_iterator is dic_iterator.__iter__().__iter__().__iter__())
  37. # 4、可迭代对象：字符串、列表、元组、字典、集合、文件对象
  38.     # 迭代器对象：文件对象
  39.     # s1=''
  40.     # s1.__iter__()
  41.     #
  42.     # l=[]
  43.     # l.__iter__()
  44.     #
  45.     # t=(1,)
  46.     # t.__iter__()
  47.     #
  48.     #
  49.     # d={'a':1}
  50.     # d.__iter__()
  51.     #
  52.     # set1={1,2,3}
  53.     # set1.__iter__()
  54.     #
  55.     #
  56.     # with open('a.txt',mode='w') as f:
  57.     #     f.__iter__()
  58.     #     f.__next__()
  61. # 5、for循环的工作原理：for循环可以称之为叫迭代器循环
  62. d={'a':1,'b':2,'c':3}
  63.     # 1、d.__iter__()得到一个迭代器对象
  64.     # 2、迭代器对象.__next__()拿到一个返回值，然后将该返回值赋值给k
  65.     # 3、循环往复步骤2，直到抛出StopIteration异常for循环会捕捉异常然后结束循环
  66.     # for k in d:
  67.     #     print(k)

迭代器优缺点

  1. # 6、迭代器优缺点总结
  2. # 6.1 缺点：
  3. # I、为序列和非序列类型提供了一种统一的迭代取值方式。
  4. # II、惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值，就迭代器本身来说，
  5. 同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，
  6. 如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。
  8. # 6.2 缺点：
  9. # I、除非取尽，否则无法获取迭代器的长度
  10. #
  11. # II、只能取下一个值，不能回到开始，更像是‘一次性的’，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，
  12. 否则就会停留在某个位置，等待下一次调用next；若是要再次迭代同个对象，你只能重新调用iter方法去创建一个新的迭代器对象，
  13. 如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值。

生成器

生成器即自定义的迭代器—->函数+yield

生成器yield

  1. # 如何得到自定义的迭代器：
  2. # 在函数内一旦存在yield关键字，调用函数并不会执行函数体代码
  3. # 会返回一个生成器对象，生成器即自定义的迭代器
  4.     def func():
  5.         print('第一次')
  6.         yield 1
  7.         print('第二次')
  8.         yield 2
  9.         print('第三次')
  10.         yield 3
  11.         print('第四次')
  13.     # g=func()
  14.     # print(g)
  15.     # 生成器就是迭代器
  16.     # g.__iter__()
  17.     # g.__next__()
  18.     # 会触发函数体代码的运行，然后遇到yield停下来，将yield后的值
  19.     # 当做本次调用的结果返回
  21. # res1=g.__next__()  返回1
  22. # print(res1) 
  23. #
  24. #
  25. # res2=g.__next__() 返回2
  26. # print(res2)
  27. #
  28. # res3=g.__next__()
  29. # print(res3)
  30. #
  31. # res4=g.__next__()
  35. # len('aaa') # 'aaa'.__len__()
  37. # next(g)    # g.__next__()
  38. # iter(可迭代对象)     # 可迭代对象.__iter__()

生成器应用案例

  1. # 应用案列
  2. def my_range(start,stop,step=1):
  3.     # print('start...')
  4.     while start < stop:
  5.         yield start
  6.         start+=step
  7.     # print('end....')
  10. # g=my_range(1,5,2) # 1 3
  11. # print(next(g))
  12. # print(next(g))
  13. # print(next(g))
  15. for n in my_range(1,7,2):   #将生成器函数对象用作for循环遍历
  16.     print(n)
  19. # 总结yield：
  20. # 有了yield关键字，我们就有了一种自定义迭代器的实现方式。yield可以用于返回值，
  21. 但不同于return，函数一旦遇到return就结束了，而yield可以保存函数的运行状态挂起函数，用来返回多次值

yield表达式

  1. def func():
  2.     print('start.....')
  3.     x=yield 1111  # x='xxxxx'  #第一次运行到yield右边暂定，并返回1111.第二次从yield左边开始
  4.     print(f'哈哈哈啊哈{x}') #哈哈哈啊哈xxxxx
  5.     print('哈哈哈啊哈')
  6.     print('哈哈哈啊哈')
  7.     print('哈哈哈啊哈')
  8.     yield 22222      #第二次运行完停在yield右边，返回22222
  10. g=func()
  11. res=next(g)   #返回的永远是yield右边的值，左边的值是send传进去的
  12. #print(res)   #1111
  14. res=g.send('xxxxx')   #send会把参数传给yield左边的变量
  15. # print(res)  #22222
  18. #二：
  19. def dog(name):
  20.     food_list=[]
  21.     print('道哥%s准备吃东西啦...' %name)
  22.     while True:
  23.         # x拿到的是yield接收到的值
  24.         x = yield food_list # x = '肉包子'
  25.         print('道哥%s吃了 %s' %(name,x))
  26.         food_list.append(x) # ['一根骨头','肉包子']
  27. #
  28. g=dog('alex')
  29. res=g.send(None)  # next(g)
  30. print(res)
  32. res=g.send('一根骨头')
  33. print(res)
  35. res=g.send('肉包子')
  36. print(res)
  37. # g.send('一同泔水')

三元表达式

  1. # 针对以下需求
  2. # def func(x,y):
  3. #     if x > y:
  4. #         return x
  5. #     else:
  6. #         return y
  7. #
  8. # res=func(1,2)
  9. # print(res)
  12. # 三元表达式
  13. # 语法格式： 条件成立时要返回的值 if 条件 else 条件不成立时要返回的值
  14. x=1
  15. y=2
  17. # res=x if x > y else y
  18. # print(res)
  21. res=111111 if 'egon' == 'egon' else 2222222222
  22. print(res)
  26. # 应用举例
  27. def func():
  28.     # if 1 > 3:
  29.     #     x=1
  30.     # else:
  31.     #     x=3
  33.     x = 1 if 1 > 3 else 3

生成式表达式

生成式表达式一次生成列表出所有值[]

生成器表达式是可迭代对象，使用遍历依次取值()

  1. 4、生成式
  2.     l=[表达式 for x in 可迭代对象 if 条件]
  5.     g=(表达式 for x in 可迭代对象 if 条件)
  6.     next(g)
  7.     sum(表达式 for x in 可迭代对象 if 条件)
  8.     list(表达式 for x in 可迭代对象 if 条件)
  11.     dic={键:值 for k in 可迭代对象 if 条件}
  12.     set1={元素 for k in 可迭代对象 if 条件}
  1. # 1、列表生成式
  2.         # 左边写name元素的处理函数，右边写if判断是否满足条件
  4.     l = ['alex_dsb', 'lxx_dsb', 'wxx_dsb', "xxq_dsb", 'egon']
  5.     # new_l=[]
  6.     # for name in l:
  7.     #     if name.endswith('dsb'):
  8.     #         new_l.append(name)
  10.      new_l=[name for name in l if name.endswith('x')]
  11.      new_l=[name for name in l if name.endswith('dsb')]
  12.      new_l=[name for name in l]
  14.     # print(new_l)
  16.     # 把所有小写字母全变成大写
  17.     # new_l=[name.upper() for name in l]
  18.     # print(new_l)
  20.     # 把所有的名字去掉后缀_dsb
  21.     # new_l=[name.replace('_dsb','') for name in l]
  22.     # print(new_l)
  25. # 2、字典生成式
  26.     # keys=['name','age','gender']
  27.     # dic={key:None for key in keys}
  28.     # print(dic)
  30.     # items=[('name','egon'),('age',18),('gender','male')]
  31.     # res={k:v for k,v in items if k != 'gender'}
  32.     # print(res)
  35. # 3、集合生成式
  36.     # keys=['name','age','gender']
  37.     # set1={key for key in keys}
  38.     # print(set1,type(set1))
  41. # 4、生成器表达式
  42.     # g=(i for i in range(10) if i > 3)
  43.     # ！！！！！！！！！！！强调！！！！！！！！！！！！！！！
  44.     # 此刻g内部一个值也没有
  46.     # print(g,type(g))
  48.     # print(g)
  49.     # print(next(g))
  50.     # print(next(g))
  51.     # print(next(g))
  52.     # print(next(g))
  53.     # print(next(g))
  54.     # print(next(g))
  55.     # print(next(g))
  58.     with open('笔记.txt', mode='rt', encoding='utf-8') as f:
  59.         # 方式一：
  60.         # res=0
  61.         # for line in f:
  62.         #     res+=len(line)
  63.         # print(res)
  65.         # 方式二：
  66.         # res=sum([len(line) for line in f])
  67.         # print(res)
  69.         # 方式三 ：效率最高
  70.         # res = sum((len(line) for line in f))
  71.         # 上述可以简写为如下形式
  72.         res = sum(len(line) for line in f)
  73.         print(res)

函数的递归

  1. # 一段代码的循环运行的方案有两种
  2. # 方式一：while、for循环
  3. # while True:
  4. #     print(1111)
  5. #     print(2222)
  6. #     print(3333)
  8. # 方式二：递归的本质就是循环：
  9. # def f1():
  10. #     print(1111)
  11. #     print(2222)
  12. #     print(3333)
  13. #     f1()
  14. # f1()
  17. # 二：需要强调的的一点是：
  18. # 递归调用不应该无限地调用下去，必须在满足某种条件下结束递归调用
  19.     # n=0
  20.     # while n < 10:
  21.     #     print(n)
  22.     #     n+=1
  25.     # def f1(n):
  26.     #     if n == 10:
  27.     #         return
  28.     #     print(n)
  29.     #     n+=1
  30.     #     f1(n)
  31.     #
  32.     # f1(0)
  35. # 三：递归的两个阶段
  36. # 回溯：一层一层调用下去
  37. # 递推：满足某种结束条件，结束递归调用，然后一层一层返回
  38. # def age(n):
  39. #     if n == 1:
  40. #         return 18
  41. #     return age(n-1) + 10
  42. #
  43. #
  44. # res=age(5)
  45. # print(res)
  47. # age(5) = age(4) + 10
  48. # age(4) = age(3) + 10
  49. # age(3) = age(2) + 10
  50. # age(2) = age(1) + 10
  51. # age(1) = 18
  54. # 四：递归的应用
  55. l=[1,2,[3,[4,[5,[6,[7,[8,[9,10,11,[12,[13,]]]]]]]]]]
  57. def f1(list1):
  58.     for x in list1:
  59.         if type(x) is list:
  60.             # 如果是列表，应该再循环、再判断,即重新运行本身的代码
  61.             f1(x)
  62.         else:
  63.             print(x)
  65. f1(l)

递归二分法

  1. # 算法：是高效解决问题的办法
  2. # 算法之二分法
  4. # 需求：有一个按照从小到大顺序排列的数字列表
  5. #      需要从该数字列表中找到我们想要的那个一个数字
  6. #      如何做更高效？？？
  9. nums=[-3,4,7,10,13,21,43,77,89]
  10. find_num=10
  12. nums=[-3,4,13,10,-2,7,89]
  13. nums.sort()
  14. print(nums)
  16. # 方案一：整体遍历效率太低
  17. # for num in nums:
  18. #     if num == find_num:
  19. #         print('find it')
  20. #         break
  24. # 方案二：二分法
  25. def binary_search(find_num,列表):
  26.     mid_val='找列表中间的值'
  27.     if find_num > mid_val:
  28.         # 接下来的查找应该是在列表的右半部分
  29.         #列表=列表切片右半部分
  30.         binary_search(find_num,列表)
  31.     elif find_num < mid_val:
  32.         # 接下来的查找应该是在列表的左半部分
  33.         #列表=列表切片左半部分
  34.         binary_search(find_num,列表)
  35.     else:
  36.         print('find it')
  39. nums=[-3,4,7,10,13,21,43,77,89]
  40. find_num=8
  42. def binary_search(find_num,l):
  43.     print(l)
  44.     if len(l) == 0:
  45.         print('找的值不存在')
  46.         return
  47.     mid_index=len(l) // 2      #//只保留整数部分
  49.     if find_num > l[mid_index]:
  50.         # 接下来的查找应该是在列表的右半部分
  51.         l=l[mid_index+1:]
  52.         binary_search(find_num,l)
  53.     elif find_num < l[mid_index]:
  54.         # 接下来的查找应该是在列表的左半部分
  55.         l=l[:mid_index]
  56.         binary_search(find_num,l)
  57.     else:
  58.         print('find it')
  60. binary_search(find_num,nums)

面向过程编程

  1. # 面向过程的编程思想：
  2. #      核心是"过程"二字，过程即流程，指的是做事的步骤：先什么、再什么、后干什么
  3. #      基于该思想编写程序就好比在设计一条流水线
  5. # 优点：复杂的问题流程化、进而简单化
  6. # 缺点：扩展性非常差
  8. # 面向过程的编程思想应用场景解析：
  9. # 1、不是所有的软件都需要频繁更迭：比如编写脚本
  10. # 2、即便是一个软件需要频繁更迭，也不并不代表这个软件所有的组成部分都需要一起更迭

匿名函数

匿名函数准备

匿名函数就是没有名字的函数；

lambda 参数：表达式

  1. # 1、def用于定义有名函数
  2. # func=函数的内存地址
  3. # def func(x,y):
  4. #     return x+y
  6. # print(func)
  7. # 2、lamdab用于定义匿名函数
  8. # print(lambda x,y:x+y)
  11. # 3、调用匿名函数
  12. # 方式一：
  13. # res=(lambda x,y:x+y)(1,2)
  14. # print(res)
  16. # 方式二：
  17. # func=lambda x,y:x+y
  18. # res=func(1,2)
  19. # print(res)
  21. #4、匿名用于临时调用一次的场景：更多的是将匿名与其他函数配合使用

匿名函数应用

max、min、map、filter、reduce、sorted

  1. salaries={
  2.     'siry':3000,
  3.     'tom':7000,
  4.     'lili':10000,
  5.     'jack':2000
  6. }
  7. # 需求1：找出薪资最高的那个人=》lili
  8. # res=max([3,200,11,300,399])
  9. # print(res)
  11. # res=max(salaries)
  12. # print(res)
  15. salaries={
  16.     'siry':3000,
  17.     'tom':7000,
  18.     'lili':10000,
  19.     'jack':2000
  20. }
  21. # 迭代出的内容    比较的值
  22. # 'siry'         3000
  23. # 'tom'          7000
  24. # 'lili'         10000
  25. # 'jack'         2000
  27. # def func(k):
  28. #     return salaries[k]
  30. # ========================max的应用
  31.     # res=max(salaries,key=func) # 返回值=func('siry')
  32.     # print(res)
  34.     # res=max(salaries,key=lambda k:salaries[k])  
  35.          ## res=max([3,200,11,300,399]);max比较的是salaries[k],返回的是k名字
  36.     # print(res)
  39. # ========================min的应用
  40.     # res=min(salaries,key=lambda k:salaries[k])
  41.     # print(res)
  44. # ========================sorted排序
  45.     # salaries={
  46.     #     'siry':3000,
  47.     #     'tom':7000,
  48.     #     'lili':10000,
  49.     #     'jack':2000
  50.     # }
  51.     res=sorted(salaries,key=lambda k:salaries[k],reverse=True)
  52.     # print(res)
  55. # ========================map的应用(了解)
  56.     # l=['alex','lxx','wxx','薛贤妻']
  57.     # new_l=(name+'_dsb' for name in l)
  58.     # print(new_l)
  59.      ---2个作用相同
  60.     # res=map(lambda name:name+'_dsb',l)
  61.     # print(res) # 生成器
  64. # ========================filter的应用（了解）
  65.     # l=['alex_sb','lxx_sb','wxx','薛贤妻']
  66.     # res=(name for name in l if name.endswith('sb'))
  67.     # print(res)
  69.     # res=filter(lambda name:name.endswith('sb'),l)
  70.     # print(res)
  73. # ========================reduce的应用(了解)
  74.     from functools import reduce
  75.     res=reduce(lambda x,y:x+y,[1,2,3],10) # 返回16
  76.     print(res)
  78.     res=reduce(lambda x,y:x+y,['a','b','c'])
  79.     print(res)   #返回abc

函数的提示类型

  1. def register(name:"必须传入名字傻叉",age:1111111,hobbbies:"必须传入爱好元组")->"返回的是整型":
  2.  print(name)
  3.  print(age)
  4.  print(hobbbies)
  5.  return 111
  7. # register(1,'aaa',[1,])
  8. res=register('egon',18,('play','music'))
  9. # res=register('egon',19,(1,2,3))
  11. print(register.__annotations__)  #打印函数的传参提示

制作进度条

  1. print('[%-50s]' %'#')
  2. print('[%-50s]' %'##')
  3. print('[%-50s]' %'###')
  6. import time
  8. def progress(percent):
  9.     if percent > 1:
  10.         percent = 1
  11.     res = int(50 * percent) * '#'
  12.     print('\r[%-50s] %d%%' % (res, int(100 * percent)), end='')
  14. recv_size=0
  15. total_size=1025011
  17. while recv_size < total_size:
  18.     time.sleep(0.01) # 下载了1024个字节的数据
  20.     recv_size+=1024 # recv_size=2048
  22.     # 打印进度条
  23.     # print(recv_size)
  24.     percent = recv_size / total_size  # 1024 / 333333
  25.     progress(percent)

模块导入、包的使用

模块导入基础

  1. 一、绝对导入
  2. # 绝对导入，以包的文件夹作为起始来进行导入
  3.     import sys
  4.     print('==========>这是在被导入的__init__.py中查看到的sys.path')
  5.     print(sys.path)  #该路径是一个列表，包含乐init文件所在的path，可以根据该相对path导入包
  7.     # from foo.bbb.m4 import f4 # foo内有了一个f4
  8.     # # import foo.bbb.m4.f4 # 语法错误，点的左侧必须是一个包   #foo，bbb是目录=包；m4是文件，f4是函数
  11. 二、相对导入
  12.     # 相对导入:仅限于包内使用，不能跨出包（包内模块之间的导入，推荐使用相对导入，绝对导入没有限制）
  13.     # .:代表当前文件夹
  14.     # ..:代表上一层文件夹
  15.     from .m1 import f1
  16.     from .m2 import f2
  17.     from .m3 import f3
  18.     from .bbb.m4 import f4
  20. 三、导入所有*
  21.     from 文件 import *
  22.     print('模块foo==>')
  23.     __all__=['x',] # 控制*代表的名字有哪些；当在其他文件导入模块foo文件时，会将foo文件中__all__列表中的所有变量导入过去，
  24.     则可以更改__all__变量来控制其他文件导入
  26. 四、内置变量__name__
  27.     print(__name__) #
  28.     #1、当foo.py被运行时，__name__的值为'__main__'
  29.     #1、当foo.py被当做模块导入时，__name__的值为'foo'
  30.     if __name__ == '__main__':
  31.         print('文件被执行')
  32.         get()
  33.         change()
  34.     else:
  35.         # 被当做模块导入时做的事情
  36.         print('文件被导入')
  37.         pass
  39. 五、模块导入名称冲突
  40.     # impot导入模块在使用时必须加前缀"模块."
  41.     # 优点：肯定不会与当前名称空间中的名字冲突
  42.     # 缺点：加前缀显得麻烦
  44.     # from...impot...导入模块在使用时不用加前缀
  45.     # 优点：代码更精简
  46.     # 缺点：容易与当前名称空间混淆
  48.     # from ... import ...导入也发生了三件事
  49.     # 1、产一个模块的名称空间
  50.     # 2、运行foo.py将运行过程中产生的名字都丢到模块的名称空间去
  51.     # 3、在当前名称空间拿到一个名字，该名字与模块名称空间中的某一个内存地址
  52.     # from foo import x # x=模块foo中值0的内存地址
  53.     # from foo import get
  54.     # from foo import change
  56. 六、起别名
  57.     # 起别名
  58.     from foo import get as g
  59.     print(g)

模块的搜索路径优先级

# 无论是import还是from...import在导入模块时都涉及到查找问题
# 优先级：
# 1、内存（内置模块）
# 2、硬盘：按照sys.path中存放的文件的顺序依次查找要导入的模块


import sys
# 找foo.py就把foo.py的文件夹添加到环境变量中
sys.path.append(r'/Users/linhaifeng/PycharmProjects/s14/day21/aa')
# import foo
# foo.say()

from foo import say


# 了解：sys.modules查看已经加载到内存中的模块,已经加载到内存中的优先使用内存中的
    import sys
    # import foo # foo=模块的内存地址
    # del foo

    # def func():
    #     import foo # foo=模块的内存地址
    #
    # func()
    #
    # # print('foo' in sys.modules)
    # print(sys.modules)

模块导入强调

# 强调：
# 1.关于包相关的导入语句也分为import和from ... import ...
# 两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：
# 凡是在导入时带点的，点的左边都必须是一个包，否则非法。
# 可以带有一连串的点，如import 顶级包.子包.子模块,但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包,
模块，函数，类(它们都可以用点的方式调用自己的属性)。
# 例如：
# from a.b.c.d.e.f import xxx
# import a.b.c.d.e.f
# 其中a、b、c、d、e 都必须是包


# 2、包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间
#
# 3、import导入文件时，产生名称空间中的名字来源于文件，
# import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

两种导入方式画图

01-python基础部分 - 图2

时间模块

# 时间模块优先掌握的操作
#一：time
import time

# 时间分为三种格式：
    # 1、时间戳：从1970年到现在经过的秒数
    #    作用：用于时间间隔的计算
    # print(time.time())          #1606976950.1573133

    # 2、按照某种格式显示的时间：2020-03-30 11:11:11
    #    作用：用于展示时间

    # print(time.strftime('%Y-%m-%d %H:%M:%S %p'))   #2020-12-03 14:29:35 PM
    # print(time.strftime('%Y-%m-%d %X'))            #2020-12-03 14:29:35

    # 3、结构化的时间
    #    作用：用于单独获取时间的某一部分

    # res=time.localtime() 
        # res为格式time.struct_time(tm_year=2020, tm_mon=12, tm_mday=3, tm_hour=14, tm_min=30, tm_sec=59, tm_wday=3, tm_yday=338, tm_isdst=0)
    # print(res)
    # print(res.tm_year)  #2020
    # print(res.tm_mon)   #12月



#二：datetime
import datetime

# print(datetime.datetime.now())   #2020-12-03 14:33:02.103541
# print(datetime.datetime.now() + datetime.timedelta(days=3))   #2020-12-06 14:33:02.103541
# print(datetime.datetime.now() + datetime.timedelta(weeks=1))  #2020-12-10 14:33:02.103541


# 时间模块需要掌握的操作
# 1、时间格式的转换
    # struct_time->时间戳
    import time
    s_time=time.localtime()  
    print(time.mktime(s_time))   #mktime将结构时间转换成时间戳

    #时间戳->struct_time
    tp_time=time.time()    #1606976950.1573133
    print(time.localtime(tp_time))  #转换成结构时间

    #补充：世界标准时间与本地时间
    print(time.localtime())
    print(time.gmtime()) # 世界标准时间，了解
    print(time.localtime(333333333))  #转换成结构时间
    print(time.gmtime(333333333))    #转换成结构时间


    #struct_time->格式化的字符串形式的时间
    s_time=time.localtime()    #结构时间
    print(time.strftime('%Y-%m-%d %H:%M:%S',s_time))           #重点2020-12-03 14:37:57，不传参代表显示now时间

    print(time.strptime('1988-03-03 11:11:11','%Y-%m-%d %H:%M:%S'))  #转换成结构时间


# !!!真正需要掌握的只有一条：format string<------>timestamp    time.strftime('%Y-%m-%d %H:%M:%S',s_time)
# '1988-03-03 11:11:11'+7

# format string--->struct_time--->timestamp
# struct_time=time.strptime('1988-03-03 11:11:11','%Y-%m-%d %H:%M:%S')
# timestamp=time.mktime(struct_time)+7*86400   #mktime结构时间转时间戳
# print(timestamp)

# format string<---struct_time<---timestamp
# res=time.strftime('%Y-%m-%d %X',time.localtime(timestamp))  #timestamp是时间戳，localtime转成结构时间，strftime人类可读
# print(res)

# time.sleep(3)

# 了解知识
# import time
# print(time.asctime())  #Thu Dec  3 14:42:03 2020


import datetime
# print(datetime.datetime.now())     #2020-12-03 14:42:29.035382
# print(datetime.datetime.utcnow())  #2020-12-03 06:42:29.035382

print(datetime.datetime.fromtimestamp(333333))  #1970-01-05 04:35:33

random模块

import random

# print(random.random()) #(0,1)----float    大于0且小于1之间的小数
# print(random.uniform(1, 3))  # 大于1小于3的小数，如1.927109612082716


# print(random.randint(1, 3))  # [1,3]    大于等于1且小于等于3之间的整数
# print(random.randrange(1, 3))  # [1,3)    大于等于1且小于3之间的整数


# print(random.choice([111, 'aaa', [4, 5]]))  # 1或者23或者[4,5]
# print(random.sample([111, 'aaa', 'ccc','ddd'],2))  # 列表元素任意2个组合


# item = [1, 3, 5, 7, 9]
# random.shuffle(item)  # 打乱item的顺序,相当于"洗牌"
# print(item)

应用：随机验证码

# import random
#
# res=''
# for i in range(6):
#     从26大写字母中随机取出一个=chr(random.randint(65,90))   #chr将数字转成字母
#     从10个数字中随机取出一个=str(random.randint(0,9))
#
#     随机字符=random.choice([从26大写字母中随机取出一个,从10个数字中随机取出一个])
#     res+=随机字符

import random

def make_code(size=4):
res=''
for i in range(size):
s1=chr(random.randint(65,90))
s2=str(random.randint(0,9))
res+=random.choice([s1,s2])
return res

print(make_code(6))

os模块

import os

# 获取某一个文件夹下所有的子文件以及子文件夹的名字
res=os.listdir('.')  #获取当前目录下所有子文件及子文件夹名字
print(res)

# 获取当前计算机CPU个数
os.cpu_count()


# 获取文件大小
size=os.path.getsize(r'/Users/linhaifeng/PycharmProjects/s14/day22/01 时间模块.py')
print(size)


# 删除一个文件
# os.remove()  

# 重命名文件/目录
# os.rename("oldname","newname")  



# 在终端执行命令
# os.system("ls /")   


#给系统添加环境变量
os.environ['aaaaaaaaaa']='111'   #给环境变量列表增加值，# 规定：key与value必须都为字符串
print(os.environ)

# 取目录，文件名
print(os.path.dirname(r'/a/b/c/d.txt'))     #取/a/b/c
print(os.path.basename(r'/a/b/c/d.txt'))    #取d.txt


# 判断是文件还是目录
print(os.path.isfile(r'笔记.txt')) 
print(os.path.isfile(r'aaa'))
print(os.path.isdir(r'aaa'))

# 拼接目录
    print(os.path.join('a','/','b','c','d')) 
    # 推荐用这种
    BASE_DIR=os.path.dirname(os.path.dirname(__file__))  #获取当前文件上上级目录名称
    # print(BASE_DIR)
    # __file__  当前文件绝对路径

    # 在python3.5之后，推出了一个新的模块pathlib
    from pathlib import Path
    # res = Path(__file__).parent.parent  #更简单
    # print(res)

    # res=Path('/a/b/c') / 'd/e.txt'   #\a\b\c\d\e.txt
    # print(res)

    # print(res.resolve())   #D:\a\b\c\d\e.txt


# BASE_DIR=os.path.normpath(os.path.join(
#     __file__,
#     '..',
#     '..'
# ))
# print(BASE_DIR)

sys模块

# python3.8 run.py 1 2 3
# sys.argv获取的是解释器后参数值
# print(sys.argv)
# src_file=sys.argv[1]   #获取第一个参数
# dst_file=sys.argv[2]     #获取第二个参数


import sys
sys.exit()   #退出代码，类似shell的exit
sys.exit(0)
sys.exit(1)

json与pickle模块

序列化&反序列化

# 1、什么是序列化&反序列化
#   内存中的数据类型---->序列化---->特定的格式（json格式或者pickle格式）
#   内存中的数据类型<----反序列化<----特定的格式（json格式或者pickle格式）

#   土办法：
#   {'aaa':111}--->序列化str({'aaa':111})----->"{'aaa':111}"
#   {'aaa':111}<---反序列化eval("{'aaa':111}")<-----"{'aaa':111}"

# 2、为何要序列化
#   序列化得到结果=>特定的格式的内容有两种用途
#   1、可用于存储=》用于存档
#   2、传输给其他平台使用=》跨平台数据交互
#        python                 java
#         列表     特定的格式      数组

#   强调：
#       针对用途1的特定一格式：可是一种专用的格式=》pickle只有python可以识别
#       针对用途2的特定一格式：应该是一种通用、能够被所有语言识别的格式=》json


# 3、如何序列化与反序列化
# 示范1
import json
# 序列化
json_res=json.dumps([1,'aaa',True,False])
# print(json_res,type(json_res)) # "[1, "aaa", true, false]"

# 反序列化
l=json.loads(json_res)
print(l,type(l))

序列化应用

json.dumps(列表) #序列化列表为字符串列表，除了列表，字典都可以

json.dump(列表，f) #将列表序列化到f文件

json.loads(文件中字符串列表) #返回值为列表

json.load(包含字符串列表的文件) #返回值为列表

# 示范2：
import json

dumps
# 序列化的结果写入文件的复杂方法
  json_res=json.dumps([1,'aaa',True,False])          #将列表序列化可以写入文件（列表转为字符串，并且‘’变""）
  # print(json_res,type(json_res)) # "[1, "aaa", true, false]"
  with open('test.json',mode='wt',encoding='utf-8') as f:
      f.write(json_res)

dump
# 将序列化的结果写入文件的简单方法
  with open('test.json',mode='wt',encoding='utf-8') as f:
      json.dump([1,'aaa',True,False],f)   #第二个参数写f文件对象


loads
# 从文件读取json格式的字符串进行反序列化操作的复杂方法
    with open('test.json',mode='rt',encoding='utf-8') as f:
    json_res=f.read()
    l=json.loads(json_res)  #将json格式的字符串列表反序列化之后接收到的就是列表了。
    print(l,type(l))

load
# 从文件读取json格式的字符串进行反序列化操作的简单方法
with open('test.json',mode='rt',encoding='utf-8') as f:
    l=json.load(f)
    print(l,type(l))


# json验证: json格式兼容的是所有语言通用的数据类型，不能识别某一语言的所独有的类型
  json.dumps({1,2,3,4,5})


# json强调：一定要搞清楚json格式，不要与python混淆
  l=json.loads('[1, "aaa", true, false]')
  l=json.loads("[1,1.3,true,'aaa', true, false]")
  print(l[0])


# 了解
l = json.loads(b'[1, "aaa", true, false]')
print(l, type(l))

with open('test.json',mode='rb') as f:
    l=json.load(f)

res=json.dumps({'name':'哈哈哈'})
print(res,type(res))

res=json.loads('{"name": "\u54c8\u54c8\u54c8"}')
print(res,type(res))



# 5.pickle模块   #二进制序列化格式，不可读，只适用于python速度快
    import pickle
    # res=pickle.dumps({1,2,3,4,5})
    # print(res,type(res))

    # s=pickle.loads(res)
    # print(s,type(s))

pickle协议和JSON（JavaScript Object Notation）的区别 ：

  1. JSON是一种文本序列化格式（它输出unicode文本，虽然大部分时间它被编码utf-8），而pickle是二进制序列化格式;

  2. JSON是人类可读的，而pickle则不是;

  3. JSON是可互操作的，并且在Python生态系统之外广泛使用，而pickle是特定于Python的;

猴子补丁

# 4、猴子补丁
    # 在入口处打猴子补丁，使用新版ujson代替json
    import json
    import ujson

    def monkey_patch_json():
        json.__name__ = 'ujson'
        json.dumps = ujson.dumps
        json.loads = ujson.loads

    monkey_patch_json() # 在入口文件处运行


    # import ujson as json # 不行

    # 后续代码中的应用
    # json.dumps()

configparser模块

import configparser

config=configparser.ConfigParser()
config.read('test.ini')

# 1、获取sections
print(config.sections())          #获取ini文件中几个[section+数字]

# 2、获取某一section下的所有options
print(config.options('section1'))  #获取sections下对应的参数的key

# 3、获取items
print(config.items('section1'))   #获取对应sections下的key-value

# 4、
res=config.get('section1','user')   #根据key获取value
print(res,type(res))

res=config.getint('section1','age')  #根据key获取value，并将value转成int类型
print(res,type(res))


res=config.getboolean('section1','is_admin')   #根据key获取值，并转成boolean类型
print(res,type(res))


res=config.getfloat('section1','salary')
print(res,type(res))


##测试文件test.ini
# 注释1
; 注释2
[section1]
k1 = v1
k2:v2
user=egon
age=18
is_admin=true
salary=31

[section2]
k1 = v1

hashlib模块

# 1、什么是哈希hash
#    hash一类算法，该算法接受传入的内容，经过运算得到一串hash值
#    hash值的特点：
    #I 只要传入的内容一样，得到的hash值必然一样
    #II 不能由hash值返解成内容
    #III 不管传入的内容有多大，只要使用的hash算法不变，得到的hash值长度是一定

# 2、hash的用途
# 用途1：特点II用于密码密文传输与验证
# 用途2：特点I、III用于文件完整性校验

# 3、如何用
    import hashlib

    m=hashlib.md5()    #创建一个md5对象
    m.update('hello'.encode('utf-8'))   #再往对象添加加密字符串
    m.update('world'.encode('utf-8'))
    res=m.hexdigest() # 'helloworld'    #res是helloworld的has字符串
    print(res)

    m1=hashlib.md5('he'.encode('utf-8'))
    m1.update('llo'.encode('utf-8'))
    m1.update('w'.encode('utf-8'))
    m1.update('orld'.encode('utf-8'))
    res=m1.hexdigest()# 'helloworld'
    print(res)



# 模拟撞库
cryptograph='aee949757a2e698417463d47acac93df'
import hashlib

# 制作密码字段
passwds=[
    'alex3714',
    'alex1313',
    'alex94139413',
    'alex123456',
    '123456alex',
    'a123lex',
]

dic={}
for p in passwds:
    res=hashlib.md5(p.encode('utf-8'))    #简单写法
    dic[p]=res.hexdigest()

# 模拟撞库得到密码
for k,v in dic.items():
    if v == cryptograph:
        print('撞库成功，明文密码是：%s' %k)
        break


# 提升撞库的成本=>密码加盐
    import hashlib
    m=hashlib.md5()

    m.update('天王'.encode('utf-8'))       #md5对象update加盐
    m.update('alex3714'.encode('utf-8'))
    m.update('盖地虎'.encode('utf-8'))
    print(m.hexdigest())

# 先创建对象hashlib.md5(《文件所有内容》)
        m.update(文件所有的内容)
    m.hexdigest()    #返回值是hash字符串

f=open('a.txt',mode='rb')
f.seek()  #移动光标
f.read(2000) # 巨琳
m1.update(文见的一行)
#
m1.hexdigest()

subproccess模块

import subprocess   #k开启一个进程执行命令，使用stdout与stderr接受命令执行返回信息

obj=subprocess.Popen('echo 123 ; ls / ; ls /root',shell=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 )

# print(obj)
# res=obj.stdout.read()
# print(res.decode('utf-8'))

err_res=obj.stderr.read()
print(err_res.decode('utf-8'))

re模块

import re
    print(re.findall('\w','aAbc123_*()-='))
    print(re.findall('\W','aAbc123_*()-= '))
    print(re.findall('\s','aA\rbc\t\n12\f3_*()-= '))
    print(re.findall('\S','aA\rbc\t\n12\f3_*()-= '))
    print(re.findall('\d','aA\rbc\t\n12\f3_*()-= '))
    print(re.findall('\D','aA\rbc\t\n12\f3_*()-= '))
    print(re.findall('\D','aA\rbc\t\n12\f3_*()-= '))
    print(re.findall('\Aalex',' alexis alex sb'))
                           alex
    print(re.findall('sb\Z',' alexis alexsb sb'))
                                          sb\Z
    print(re.findall('sb\Z',"""alex
    alexis
    alex
    sb
    """))

    print(re.findall('^alex','alexis alex sb'))
    print(re.findall('sb$','alexis alex sb'))
    print(re.findall('sb$',"""alex
    alexis
    alex
    sb
    """))

    print(re.findall('^alex$','alexis alex sb'))
    print(re.findall('^alex$','al       ex'))
    print(re.findall('^alex$','alex'))


重复匹配：| . | * | ? | .* | .*? | + | {n,m} |
1、.:匹配除了\n之外任意一个字符，指定re.DOTALL之后才能匹配换行符
    print(re.findall('a.b','a1b a2b a b abbbb a\nb a\tb a*b'))
                                                      a.b
    ['a1b','a2b','a b','abb','a\tb','a*b']
    print(re.findall('a.b','a1b a2b a b abbbb a\nb a\tb a*b',re.DOTALL))

2、*：左侧字符重复0次或无穷次，性格贪婪
    print(re.findall('ab*','a ab abb abbbbbbbb bbbbbbbb'))
                                                   ab*
    ['a','ab','abb','abbbbbbbb']

3、+：左侧字符重复1次或无穷次，性格贪婪
    print(re.findall('ab+','a ab abb abbbbbbbb bbbbbbbb'))
                            ab+

4、？：左侧字符重复0次或1次，性格贪婪
    print(re.findall('ab?','a ab abb abbbbbbbb bbbbbbbb'))
                                                   ab?
    ['a','ab','ab','ab']

5、{n,m}：左侧字符重复n次到m次，性格贪婪
    {0,} => *
    {1,} => +
    {0,1} => ?
    {n}单独一个n代表只出现n次，多一次不行少一次也不行

    print(re.findall('ab{2,5}','a ab abb abbb abbbb abbbbbbbb bbbbbbbb'))
                                                              ab{2,5}
    ['abb','abbb','abbbb','abbbbb]

    print(re.findall('\d+\.?\d*',"asdfasdf123as1111111.123dfa12adsf1asdf3"))
                                                                  \d+\.?\d*                                      \d+\.?\d+


[]匹配指定字符一个
print(re.findall('a\db','a1111111b a3b a4b a9b aXb a b a\nb',re.DOTALL))
print(re.findall('a[501234]b','a1111111b a3b a4b a9b aXb a b a\nb',re.DOTALL))
print(re.findall('a[0-5]b','a1111111b a3b a1b a0b a4b a9b aXb a b a\nb',re.DOTALL))
print(re.findall('a[0-9a-zA-Z]b','a1111111b axb a3b a1b a0b a4b a9b aXb a b a\nb',re.DOTALL))

print(re.findall('a[^0-9a-zA-Z]b','a1111111b axb a3b a1b a0b a4b a9b aXb a b a\nb',re.DOTALL))
print(re.findall('a-b','a-b aXb a b a\nb',re.DOTALL))
print(re.findall('a[-0-9\n]b','a-b a0b a1b a8b aXb a b a\nb',re.DOTALL))

logging模块

直接使用

import logging

logging.basicConfig(
    # 1、日志输出位置：1、终端 2、文件
    filename='access.log', # 不指定，默认打印到终端

    # 2、日志格式
    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',

    # 3、时间格式
    datefmt='%Y-%m-%d %H:%M:%S %p',

    # 4、日志级别
    # critical => 50
    # error => 40
    # warning => 30
    # info => 20
    # debug => 10
    level=10,
)

logging.debug('调试debug') # 10
logging.info('消息info')   # 20
logging.warning('警告warn')# 30
logging.error('egon提现失败') # 40
logging.critical('严重critical') # 50

配置LOGGING_DIC使用

"""
日志配置字典LOGGING_DIC
"""
# 1、定义三种日志输出格式，日志中可能用到的格式化串如下
# %(name)s Logger的名字
# %(levelno)s 数字形式的日志级别
# %(levelname)s 文本形式的日志级别
# %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
# %(filename)s 调用日志输出函数的模块的文件名
# %(module)s 调用日志输出函数的模块名
# %(funcName)s 调用日志输出函数的函数名
# %(lineno)d 调用日志输出函数的语句所在的代码行
# %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
# %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
# %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
# %(thread)d 线程ID。可能没有
# %(threadName)s 线程名。可能没有
# %(process)d 进程ID。可能没有
# %(message)s用户输出的消息

# 2、强调：其中的%(name)s为getlogger时指定的名字
standard_format = '%(asctime)s - %(threadName)s:%(thread)d - 日志名字:%(name)s - %(filename)s:%(lineno)d -' \
                  '%(levelname)s - %(message)s'

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

test_format = '%(asctime)s] %(message)s'

# 3、日志配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
        'test': {
            'format': test_format
        },
    },
    'filters': {},
    # handlers是日志的接收者，不同的handler会将日志输出到不同的位置
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            # 'maxBytes': 1024*1024*5,  # 日志大小 5M
            'maxBytes': 1000,
            'backupCount': 5,
            'filename': 'a1.log',  # os.path.join(os.path.dirname(os.path.dirname(__file__)),'log','a2.log')
            'encoding': 'utf-8',
            'formatter': 'standard',

        },
        #打印到文件的日志,收集info及以上的日志
        'other': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 保存到文件
            'filename': 'a2.log', # os.path.join(os.path.dirname(os.path.dirname(__file__)),'log','a2.log')
            'encoding': 'utf-8',
            'formatter': 'test',

        },
    },
    # loggers是日志的产生者，产生的日志会传递给handler然后控制输出
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        'kkk': {
            'handlers': ['console','other'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG', # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
            'propagate': False,  # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
        },
        '终端提示': {
            'handlers': ['console',],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',  # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
            'propagate': False,  # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
        },
        '': {
            'handlers': ['default', ],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',  # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
            'propagate': False,  # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
        },
    },
}

src调用上面的settings.py配置

# 课后了解性质——》闲着没事自己研究下
# import logging.config
#
# logging.config.dictConfig(settings.LOGGING_DIC)    #将配置settings传入
# print(logging.getLogger)   #打印的是函数对象内存地址

# 接下来要做的是：拿到日志的产生者即loggers来产生日志
# 第一个日志的产生者：kkk
# 第二个日志的产生者：bbb

# 但是需要先导入日志配置字典LOGGING_DIC
import settings
from logging import config,getLogger

config.dictConfig(settings.LOGGING_DIC)


# logger1=getLogger('kkk')
# logger1.info('这是一条info日志')

# logger2=getLogger('终端提示')
# logger2.info('logger2产生的info日志')

# logger3=getLogger('用户交易')
# logger3.info('logger3产生的info日志')   #info方法代表日志级别

logger4=getLogger('用户常规')
logger4.info('logger4产生的info日志')

# 补充两个重要额知识
# 1、日志名的命名
#    日志名是区别日志业务归属的一种非常重要的标识

# 2、日志轮转
#    日志记录着程序员运行过程中的关键信息

ATM项目

项目架构图

01-python基础部分 - 图3

01-python基础部分 - 图4

01-python基础部分 - 图5

项目搭建流程

一 一个项目是如何从到有的
    - 1、需求分析（提取功能）
    - 2、程序的架构设计（核心）
    - 3、分任务开发
    - 4、项目测试
    - 5、项目上线

二 程序的架构设计
    - 三层架构
        - 用户视图层
            - 用于与用户进行交互
                - 接收用户输入的内容
                - 打印输出内容给用户

        - 逻辑接口层
            - 核心业务逻辑，相当于用户视图与数据处理层的桥梁
                - 接收视图层传递过来的参数进行逻辑处理
                - 返回结果给视图层

        - 数据处理层
            - 做数据的 
                - 增
                - 删
                - 查
                - 改

    - 分层设计的好处
        - 思路清晰
        - 不会推翻重写
        - 扩展性强
        - 便于维护

三 搭建项目的目录规范
    - ATM 项目根目录
        - readme.md  项目的说明书

        - start.py  项目启动文件

        - conf  配置文件
            - settings.py

        - lib   公共方法文件
            - common.py  
                            # 密码md5加密,
                            # 登录认证装饰器,
                            # 添加日志功能: (日志功能在接口层 使用)

        - core（用户视图层）  存放用户视图层代码文件
            - src.py

        - interface（逻辑接口层）   存放核心业务逻辑代码
            - admin_interface.py   管理员相关的接口   
                                # 修改额度接口,# 冻结账户接口

                        - bank_interface.py   银行相关的接口
                                # 根据不同的接口类型传入不同的日志对象log_type=
                                    bank_logger = common.get_logger(log_type='bank')
                                # 提现接口(手续费5%),# 还款接口,# 转账接口,# 查看流水接口,# 支付接口

                        - shop_interface.py   购物相关的接口   
                                # 根据不同的接口类型传入不同的日志对象log_type=
                  shop_logger = common.get_logger(log_type='shop')
                  msg = f'用户:[{login_user}]支付 [{cost}$] 成功, 准备发货!'
                  shop_logger.info(msg)
                # 商品准备结算接口
                # 购物车添加接口
                # 查看购物车接口
                        - user_interface.py    用户登录接口
                                # 注册接口
                                # 登录接口
                                # 查看余额接口

        - db（数据处理层）  存放数据与数据处理层代码
            - db_handler.py  数据处理层代码，保存查看数据
            - user_data  用户数据表

        - log  存放日志文件

项目结构

# 项目的说明书
## 项目：ATM + 购物车

# 项目需求:
    1.额度15000或自定义     -->  注册功能
    2.实现购物商城，买东西加入购物车，调用信用卡接口结账  --> 购物功能、支付功能
    3.可以提现，手续费5%   --> 提现功能
    4.支持多账户登录  --> 登录功能
    5.支持账户间转账  --> 转账功能
    6.记录日常消费 -->  记录流水功能
    7.提供还款接口 -->  还款功能
    8.ATM记录操作日志 --> 记录日志功能
    9.提供管理接口，包括添加账户、用户额度，冻结账户等。。。 ---> 管理员功能
    10.用户认证用装饰器  --> 登录认证装饰器


## "用户视图层" 展示给用户选择的功能
    1、注册功能
    2、登录功能
    3、查看余额
    4、提现功能
    5、还款功能
    6、转账功能
    7、查看流水
    8、购物功能
    9、查看购物车
    10、管理员功能

# 一个项目是如何从无到有
## 一 需求分析
    1.拿到项目，会先在客户那里一起讨论需求，
    商量项目的功能是否能实现，周期与价格，得到一个需求文档。

    2.最后在公司内部需要开一次会议，最终得到一个开发文档，
    交给不同岗位的程序员进行开发。
        - Python: 后端，爬虫

        - 不同的岗位：
            - UI界面设计:
                - 设计软件的布局，会分局软件的外观切成一张张图片。

            - 前端:
                - 拿到UI交给他的图片，然后去搭建网页面。
                - 设计一些页面中，哪些位置需要接收数据，需要进行数据交互。

            - 后端:
                - 直接核心的业务逻辑，调度数据库进行数据的增删查改。

            - 测试:
                - 会给代码进行全面测试，比如压力测试，界面测试（CF卡箱子）。

            - 运维:
                - 部署项目。




## 二 程序的架构设计
### 1、程序设计的好处
    1）思路清晰
    2）不会出现写一半代码时推翻重写
    3）方便自己或以后的同事更好维护

### 2、三层架构设计的好处
    1）把每个功能都分层三部分，逻辑清晰
    2）如果用户更换不同的用户界面或不同，
    的数据储存机制都不会影响接口层的核心
    逻辑代码，扩展性强。
    3）可以在接口层，准确的记录日志与流水。

### 3、三层架构
#### 一 用户视图层
    用于与用户交互的，可以接受用户的输入，打印接口返回的数据。

#### 二 逻辑接口层
    接受 用户视图层 传递过来的参数，根据逻辑判断调用数据层加以处理，
    并返回一个结果给 用户视图层。

#### 三 数据处理层
    接受接口层传递过来的参数，做数据的 
        - 保存数据  save()
        - 查看数据  select()
        - 更新数据
        - 删除数据

## 三 分任务开发
## 四 测试
## 五 上线



# 统计代码
file ---> settings ---> Plugins --->