内置函数和必须的模块

• 内置函数

  • 输入输出

    • print
    • input

  • 强制转换

    • int
    • bool
    • str
    • list
    • tuple
    • dict
    • set

  • 数学相关

    • max

    • min

    • sum

    • abs

    • divmod 取商 和余数 主要应用在分页中

    • float

    • pow 幂函数

      v = pow(2,3)   # 2**3
      print(v)
      

    • round 保留小数

      v = round(1.127,2)  # 保留小数点后两位
      print(v)
      

  • 进制

    • bin
    • oct
    • int
    • hex

  • 其他

    • len
    • range
    • id
    • type
    • open

1. 数据类型中的方法到底有没有返回值？

   • 无返回值

     v = [11,22,33]
     v.append(99) # 无返回值
     

   • 仅有返回值：

     v = "alex"
     result = v.split('l')
     
     v = {'k1':'v2'}
     result1 = v.get('k1')
     result2 = v.keys()
     

   • 有返回+修改数据

     v = [11,22,33]
     result = v.pop()
     

   • 常用需要记住

     • str

       • strip，返回字符串
       • split，返回列表
       • replace，返回字符串
       • join，返回字符串。

     • list

       • append，无
       • insert，无
       • pop，返回要删除的数据
       • remove，无
       • find/index，返回索引的位置。

     • dict

       • get

       • keys

       • values

       • items

面试题

info = []

def func():
    print(item)
    
for item in range(10):
    info.append(func)

info[0]()

info = []

def func(i):
    def inner():
        print(i)
	return inner

for item in range(10):
    info.append(func(item))

info[0]()
info[1]()
info[4]()

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

2. 内置函数

• 编码相关

  • chr，将十进制数字转换成 unicode 编码中的对应字符串。

    # 主要和random结合用来做验证码的随机产生
    v = chr(99)   
    print(v)
    

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

    num = ord('中')
    

  • 应用：

    import random
    
    def get_random_code(length=6):
        data = []
        for i in range(length):
            v = random.randint(65,90)
            data.append(chr(v))
        return  ''.join(data)
    code = get_random_code()
    print(code)
    

    import random # 导入一个模块 
    v = random.randint(起始,终止) # 得到一个随机数
    

• 高级一点的内置函数

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

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

  • filter

    

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

  • reduce

    

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

• 面试题：

  • 常用的内置函数有哪些？

  • filter/map/reduce是什么意思？

  • 什么是匿名函数？

3. 模块

一般在加载以后不会再第二次加载，可通过以下操作让其再次加载

import importlib
import jd
importlib reload(jd) # 可导入jd模块第二次

定义模块

• 内置：time/json/datetime/os/sys ... 【re模块】
• 第三方：
  • 安装：
    • pip包管理工具： pip install xlrd
    • 源码安装：
      • 下载源码包：压缩文件。
      • 解压文件
      • 打开cmd窗口，并进入此目录：cd C:Python36Libsite-packages
      • 执行：python36 setup.py build
      • 执行：python36 setup.py install
  • 安装路径：C:Python36Libsite-packages
  • 你了解的第三方模块：
    • xlrd
    • requests
• 自定义
  • py文件
  • 文件夹 __init__.py

hashlib

 # 加密  校验下载文件时一般通过选取某些点来校验，而不是取全部
import hashlib

def get_md5(data):
    obj = hashlib.md5()
    obj.update(data.encode('utf-8'))
    result = obj.hexdigest()
    return result

val = get_md5('123')
print(val)

加盐

import hashlib

def get_md5(data):
    obj = hashlib.md5("sidrsicxwersdfsaersdfsdfresdy54436jgfdsjdxff123ad".encode('utf-8'))
    obj.update(data.encode('utf-8'))
    result = obj.hexdigest()
    return result

val = get_md5('123')
print(val)

应用：

import hashlib
USER_LIST = []
def get_md5(data):
    obj = hashlib.md5("12:;idrsicxwersdfsaersdfsdfresdy54436jgfdsjdxff123ad".encode('utf-8'))
    obj.update(data.encode('utf-8'))
    result = obj.hexdigest()
    return result


def register():
    print('**************用户注册**************')
    while True:
        user = input('请输入用户名:')
        if user == 'N':
            return
        pwd = input('请输入密码:')
        temp = {'username':user,'password':get_md5(pwd)}
        USER_LIST.append(temp)

def login():
    print('**************用户登陆**************')
    user = input('请输入用户名:')
    pwd = input('请输入密码:')

    for item in USER_LIST:
        if item['username'] == user and item['password'] == get_md5(pwd):
            return True


register()
result = login()
if result:
    print('登陆成功')
else:
    print('登陆失败')

getpass

# 密码不显示（只能在终端运行）
import getpass
pwd = getpass.getpass('请输入密码：')
if pwd == '123':
    print('输入正确')

冒泡算法
需求：请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序
思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！

shutil

import shutil
# 删除目录
# shutil.rmtree('test')

# 重命名
# shutil.move('test','ttt')

# 压缩文件
# shutil.make_archive('zzh','zip','D:codes21day16lizhong')

# 解压文件  默认解压到当前所在的目录 可通过设置extract_dir
# shutil.unpack_archive('zzh.zip',extract_dir=r'D:codexxxxxxxxxx',format='zip')
import os
import shutil
from datetime import datetime
ctime = datetime.now().strftime('%Y-%m-%d-%H-%M-%S')

# 1.压缩lizhongwei文件夹 zip
# 2.放到到 code 目录（默认不存在）
# 3.将文件解压到D:x1目录中。
if not os.path.exists('code'):
    os.makedirs('code')
shutil.make_archive(os.path.join('code',ctime),'zip','D:codes21day16lizhongwei')
file_path = os.path.join('code',ctime) + '.zip'
shutil.unpack_archive(file_path,r'D:x1','zip')

sys

python解释器相关的数据。

• sys.getrefcount , 获取一个值的应用计数

  a = [11,22,33]
  b = a
  print(sys.getrefcount(a))
  

• sys.getrecursionlimit , python默认支持的递归数量

• sys.stdout.write --> print (进度 ) 主要是用在进度条的显示

  import time
  for i in range(1,101):
      msg = "%s%%
  " %i
      print(msg,end='')
      time.sleep(0.05)
  

  import os
  # 1. 读取文件大小（字节）
  file_size = os.stat('20190409_192149.mp4').st_size
  
  # 2.一点一点的读取文件
  read_size = 0
  with open('20190409_192149.mp4',mode='rb') as f1,open('a.mp4',mode='wb') as f2:
      while read_size < file_size:
          chunk = f1.read(1024) # 每次最多去读取1024字节
          f2.write(chunk)
          read_size += len(chunk)
          val = int(read_size / file_size * 100)
          print('%s%%
  ' %val ,end='')
  

• sys.argv 获取用户执行脚本时，传入的参数

  让用户执行脚本传入要删除的文件路径，在内部帮助用将目录删除。
  C:Python36python36.exe D:/code/s21day14/7.模块传参.py D:/test
  C:Python36python36.exe D:/code/s21day14/7.模块传参.py
  import sys
  
  # 获取用户执行脚本时，传入的参数。
  # C:Python36python36.exe D:/code/s21day14/7.模块传参.py D:/test
  # sys.argv = [D:/code/s21day14/7.模块传参.py, D:/test]
  path = sys.argv[1]
  
  # 删除目录
  import shutil
  shutil.rmtree(path)
  

• sys.path --- 添加解释器里面的环境变量

  - sys.path ，默认Python去导入模块时，会按照sys.path中的路径挨个查找。 
    # import sys
    # sys.path.append('D:\')
    # import oldboy
  

os

os 和操作系统相关的数据。

• os.path.exists(path) ， 如果path存在，返回True；如果path不存在，返回False

• os.stat('20190409_192149.mp4').st_size ， 获取文件大小

• os.path.abspath() ， 获取一个文件的绝对路径

  path = '20190409_192149.mp4' # D:codes21day1420190409_192149.mp4
  import os
  v1 = os.path.abspath(path)
  print(v1)
  

• os.path.dirname ，获取路径的上级目录

  import os
  v = r"D:codes21day1420190409_192149.mp4"
  
  print(os.path.dirname(v))
  

• os.path.join ，路径的拼接

  import os
  path = "D:codes21day14" # user/index/inx/fasd/
  v = 'n.txt'
  
  result = os.path.join(path,v)
  print(result)
  result = os.path.join(path,'n1','n2','n3')
  print(result)
  

• os.listdir ， 查看一个目录下所有的文件【第一层】

  import os
  result = os.listdir(r'D:codes21day14')
  for path in result:
      print(path)
  

• os.walk ， 查看一个目录下所有的文件【所有层】

  import os
  result = os.walk(r'D:codes21day14')
  for a,b,c in result:
      # a,正在查看的目录 b,此目录下的文件夹  c,此目录下的文件
      for item in c:
          path = os.path.join(a,item)
          print(path)
  

• os.makedirs，创建目录和子目录

  import os
  file_path = r'dbxxxoxxxxx.txt'
  
  file_folder = os.path.dirname(file_path)
  if not os.path.exists(file_folder):
      os.makedirs(file_folder)
  
  with open(file_path,mode='w',encoding='utf-8') as f:
      f.write('asdf')
  

• os.rename，重命名

  import os
  os.rename('db','sb')
  

json

json是一个特殊的字符串。 【长的像列表/字典/字符串/数字/真假】集合不能使用

# dump(对象，文件句柄)      load(文件句柄)
import json   
# 序列化，将python的值转换为json格式的字符串。 
# v = [12,3,4,{'k1':'v1'},True,'asdf']
# v1 = json.dumps(v)
# print(v1)

# 反序列化，将json格式的字符串转换成python的数据类型
# v2 = '["alex",123]'
# print(type(v2))
# v3 = json.loads(v2)
# print(v3,type(v3))

- - - 字典或列表中如有中文，序列化时想要保留中文显示:
v = {'k1':'alex','k2':'李杰'}
val = json.dumps(v,ensure_ascii=False)
print(val)
   
v = {'k1':'alex','k2':'李杰'}      
f = open('x.txt',mode='w',encoding='utf-8')
val = json.dump(v,f)
print(val)
f.close
    
v = {'k1':'alex','k2':'李杰'}
f = open('x.txt',mode='r',encoding='utf-8')
data = json.load(f)
f.close()
print(data,type(data))

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

pickle

• json，优点：所有语言通用；缺点：只能序列化基本的数据类型 list/dict/int... 一般在不同系统或者不同语言之间进行数据交互时用

• pickle，优点：python中所有的东西都能被他序列化（除socket对象）；缺点：序列化的内容只有python认识。一般用在函数，集合等 比较少，一般用 json

  import pickle 
  # #################### dumps/loads ######################
  """  产生的字节类型  b
  v = {1,2,3,4}
  val = pickle.dumps(v)
  print(val)
  data = pickle.loads(val)
  print(data,type(data))
  """
  """
  def f1():
      print('f1')
  v1 = pickle.dumps(f1)
  print(v1)
  v2 = pickle.loads(v1)
  v2()
  """
  # #################### dump/load ######################
  在pick里面的dump和load只能用b模式
  # v = {1,2,3,4}
  # f = open('x.txt',mode='wb')
  # val = pickle.dump(v,f)
  # f.close()
  
  # f = open('x.txt',mode='rb')
  # data = pickle.load(f)
  # f.close()
  # print(data)
  

time / datetime

####  time模块
- time.time()  ，获取当前时间戳：以1970-1-1 00:00 开始计算到现在
- time.sleep(10)，等待秒数。
- time.timezone  和电脑设置的时间有关，表示当前时间和世界时间相差的秒数
#### 4.3.2 datetime模块
import time
from datetime import datetime,timezone,timedelta

# ######################## 获取datetime格式时间 ##############################
"""
v1 = datetime.now() # 当前本地时间
print(v1)
tz = timezone(timedelta(hours=7)) # 当前东7区时间
v2 = datetime.now(tz)
print(v2)
v3 = datetime.utcnow() # 当前UTC时间
print(v3)
"""
# ######################## 把datetime格式转换成字符串 ##############################
# v1 = datetime.now()
# print(v1,type(v1))
# val = v1.strftime("%Y-%m-%d %H:%M:%S")
# print(val)

# ######################## 字符串转成datetime ##############################
# v1 = datetime.strptime('2011-11-11','%Y-%m-%d')
# print(v1,type(v1))

# ######################## datetime时间的加减 ##############################
# v1 = datetime.strptime('2011-11-11','%Y-%m-%d')
# v2 = v1 - timedelta(days=140)
# date = v2.strftime('%Y-%m-%d')
# print(date)

# ######################## 时间戳和datetime关系 ##############################
# ctime = time.time()
# print(ctime)
# v1 = datetime.fromtimestamp(ctime)
# print(v1)

# v1 = datetime.now()
# val = v1.timestamp()
# print(val)

subprocess

import subprocess # 用来生成子进程，并可以通过管道连接他们的输入/输出/错误，以及获得他们的返回值。
obj = subprocess.Popen("diasfdafr", shell=True,
                       stdout=subprocess.PIPE,
                       stderr=subprocess.PIPE
                       )
res1=obj.stdout.read()
res2=obj.stderr.read()
# print(res1.decode('gbk'))
print(res2.decode('gbk'))

logging

- 基本应用
- 日志处理本质：Logger/FileHandler/Formatter
- 推荐处理日志方式
  import logging
  
  file_handler = logging.FileHandler(filename='x1.log', mode='a', encoding='utf-8',)
  logging.basicConfig(
      format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
      datefmt='%Y-%m-%d %H:%M:%S %p',
      handlers=[file_handler,],
      level=logging.ERROR
  )
  
  logging.error('你好')
 
- 推荐处理日志方式 + 日志分割
  import time
  import logging
  from logging import handlers
  # file_handler = logging.FileHandler(filename='x1.log', mode='a', encoding='utf-8',)
  file_handler = handlers.TimedRotatingFileHandler(filename='x3.log', when='s', interval=5, encoding='utf-8')
  logging.basicConfig(
      format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
      datefmt='%Y-%m-%d %H:%M:%S %p',
      handlers=[file_handler,],
      level=logging.ERROR
  )
  
  for i in range(1,100000):
      time.sleep(1)
      logging.error(str(i))
    
    
    
 # 在应用日志时，如果想要保留异常的堆栈信息。   
import logging
import requests
  logging.basicConfig(
      filename='wf.log',
      format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
      datefmt='%Y-%m-%d %H:%M:%S %p',
      level=logging.ERROR
  )
  try:
      requests.get('http://www.xxx.com')
  except Exception as e:
      msg = str(e) # 调用e.__str__方法
      logging.error(msg,exc_info=True)

编码的相关知识

v = '你好'
在用unicode编码即内存中时所对应成的二进制编码叫字符串编码
在转换成gbk或者utf-8即写入硬盘或者网络传输等其他编码时所产生的二进制编码类型叫字节编码  显示出来的一般带b标志

异常处理

try:
    val = input('请输入数字:')
    num = int(val)
except Exception as e:
    print('操作异常')