欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Python笔记-备忘

程序员文章站 2022-05-15 13:37:26
一、向列表添加元素 x.append(y) #末尾添加一个元素 x.extend([y,z]) #末尾添加多个元素 x.insert(index,y) 二、向列表获取元素 x[index] 三、从列表删除元素 x.remove("y") del x(index) # 删除整个列表 del x x.p ......

一、向列表添加元素

  x.append(y) #末尾添加一个元素
  x.extend([y,z]) #末尾添加多个元素
  x.insert(index,y)

二、向列表获取元素  
  x[index]

三、从列表删除元素
  x.remove("y")
  del x(index) # 删除整个列表 del x
  x.pop() # 弹出列表最后一个元素 x.pop(index) 弹出index对应元素

四、列表分片 (创建副本)
  x[x:y] #x为开始位置 ,y为结束位置 结束位置不包含
  x[x:y:z] #z为步长 默认为1 z为-1,反转数列

五、列表
  x.count(y) #计算x中出现多少次y
  x.index(y) #返回y在x中的位置
  x.reverse() #列表反转
  x.sort()#从小到大排序 sort(fun,key=none,reverse=false)

六、元组(1,)
  x = (a,b,c,d,e,f,g,...)  
  访问元组: x[index]  
  分片复制元组 x2=x1[:]
  间接删除第3个元素 x=x[:2]+x[3:]
  删除元组 del x

七、fotmat格式化(012format参数为位置参数,abc为标签,format中将等值的参数替换进去,即为关键字参数,位置参数必须在关键字参数前)
  "{0} love {1}.{2}".format("i","baidu","com")#即' i love baidu.com'
  "{a} love {b}.{c}".format(a="i",b="baidu",c="com")#即 'i love baidu.com'
  "{0}:{1:.2f}".format("圆周率",3.14159) #即为'圆周率:3.14' 位置参数1后加了:替换域中,冒号表示格式化的开始,.2表示四舍五入保留2位小数

八、导入计时
  import datetime
  start = datetime.datetime.now()
  ...
  ...
  delta = (datetime.datetime.now - start).total_seconds( )
  print(delta)

九、数字处理
  import math   
  math.floor() #地板 向下取整 int   
  math.ceil() #天花板 向上取整 4.5 =5
  math.trunc()# 向0的方向取
  round()#元整 四舍六入 5 取最近的偶数  

  math.sqrt()#开方
  pow(x,y) == x**y
  bin()#二进制
  oct()#八进制
  hex()#十六进制
  math.pi#  π
  math.e

十、类型判断
  type() #返回type型
  isinstance(int,str)# is int 是 str的实例??

十一、列表 [list]
  可以是任意对象(数字,字符串。对象,列表)
  若干个元素 有序排列、可变
  【】
  查询、a[index]
    时间复杂度 o(x) 遍历 x个元素
  赋值:list[x] = value
  删除:a.clear() #清除,剩下空列表
    a.remove(value)# 移除一个值
    a.pop([index]) #默认弹出最后一个值
  其他操作:
    a.reverse()->none# 就地更改 反转序列
    a.sort(key=none,reverse=false)->none#   就地排序 默认升序 key 一个函数 指定key如何排序
  列表复制:
    == 比较值 (内容) ; is 比较内存地址
    lst1 = lst0 没有赋值过程

    a = [1,2,3]
    b = a[:]

    copy->list (shadow copy) x.copy() 依次重新创建
    影子拷贝 及 浅拷贝 只是复制一个引用
    深拷贝 deepcopy -> import copy


  enumerate(iteralbe) #生成由二元组(元素数量为二的元组)构成的迭代对象
            每个二元组由可迭代对象的索引及对应元素组成
    普通的 for 循环
      >>>i = 0
      >>> seq = ['one', 'two', 'three']
      >>> for element in seq:
      ... print i, seq[i]
      ... i +=1
      ...
      0 one
      1 two
      2 three

      for 循环使用 enumerate
      >>>seq = ['one', 'two', 'three']
      >>> for i, element in enumerate(seq):
      ... print i, element
      ...
      0 one
      1 two
      2 three

  zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。
    如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。

      >>> a = [1,2,3]
      >>> b = [4,5,6]
      >>> c = [4,5,6,7,8]
      >>> zipped = zip(a,b) # 打包为元组的列表
      [(1, 4), (2, 5), (3, 6)]
      >>> zip(a,c) # 元素个数与最短的列表一致
      [(1, 4), (2, 5), (3, 6)]
      >>> zip(*zipped) # 与 zip 相反,*zipped 可理解为解压,返回二维矩阵式
      [(1, 2, 3), (4, 5, 6)]

十二、随机数
  import random
        random.randint(a,b) #返回【ab】间的整数
     random.choice(seq) #从非空列表中随机挑选一个数
     random.randrange([start,] stop) [,step] ) #按指定基数递增的集合中获取一个随机数, 基数缺省值为1
     random.shuffle(list)# 就地打乱列表元素

十三、元组(tuple) 不可变对象
  tuple() -> empty tuple
  t = (1,)
  访问元组 通过index
  查询 index(value,[start,[stop]])
  count(value)计数

  命名元组 namedtuple(typename,field_name,verbose=false,rename=false)
    命名元组,返回一个元组的子类,并定义了字段
    field_name 可以是空格或逗号分割的字段的字符串,可以是字段的列表
  导入 from collections import namedtuple
    例: point = namedtuple('p[名字]','x,y')
    p1 = point(4,5)

  删除:del tuple

十四、字典 {dict}
  创建: {}
      {keys:value}
      dict(key=value)
      dict([(key,value),(key,value),])
  dict1 = dict((('f',70),('a,80'),('s',90))) // dict(f=70,a=90,s=90)
      doct1 => {'f':70,'a':80,'s':90}

  fromkeys()   #创建并返回一个新的字典 : 两个参数 第一个为key [第二个为value]
    dict1 = {}
    keys =['name','age','job']
    employ = dict.fromkeys(keys)
    employ =>{'name0':none,'age':none,'job':none }

    dict1.fromkeys((1,2,3)) => {1:none,2:none,3:none}
    dict2.fromkeys((1,2,3),"number") = > {1:"numbwe",2:"number",3:"number"}

  访问字典:keys()返回键,values()返回字典所有的值,items()返回所有的项
    dict1 = {}
    dict1 = dict1.fromkeys(range(3),'你好')
    dict1.keys() => dict_keys([0,1,2])
    dict1.values() => dict_values(['你好','你好','你好'])
    dict1.items() => dict_items([(0,'你好'),(1,'你好'),(2,'你好')])

    get() #当键不存在 。返回none
    dict1.get(31) =>'你好' dict.get(32) =>
    若找不到,可在第二个参数设置values
    判断是否存在 : index in dict1

    setdefault() #当键不存在,自动添加none

  更新字典:
    data[key] = value
    pets = {'米奇','老鼠','汤姆','波比'}
    pets.update(米奇='酷奇')
    pets => {'酷奇','老鼠','汤姆','波比'}

  清空字典 :
    dict.clear()
  复制:
    dict2 = dict1.copy() id 1 != 2
  合并:
    data1.update(data2)

  pop() popitem()
    dict1.pop(2) #弹出对应的键值
    dict2.popitem() #弹出一个简直想
  删除值:
    del data[key]

  函数赋为值:行为方法
    def say_hello():
      print('welcome')

    person = {'name':'jerry','hello':say_hello}
    person['hello']() -> welcome

十五、字符串 不可变对象 有序 可迭代

  '[]'.join(str)
  处理: ~ split 系列(切割) 将字符串o按分割符切成若干字符串 并返回列表
    ~ s.partition(sep) -> (head,sep,tail)系列 将字符串按分隔符割成2段,返回2段和分隔符的元组
      从左至右,遇到分隔符就把字符串分割成两部分,返回头、分隔符、尾三部分
      如果没有找到分隔符,就返回头、2个空元素的三元组
      sep分割字符串。必须指定
    s.rpartition(sep) -> (head,sep,tail)
      从右至左,遇到分隔符就把字符串分割成两部分,返回头、分隔符、尾三部分
      如果没有找到分隔符,就返2个空元素和尾的三元组
    split(sep=none,maxsplit=-1) ->list of strings
      从左至右 sep 指定分割字符串。缺省的情况下空白字符串作为分隔符
    masxsplit 指定分割的次数,-1表示遍历整个字符串
      分割* splitliness([keepends]) -> list of strings
       按照行来切字符串 keepends 指是否保留行分隔符(\n \t \r)

  字符串大小写
    s.upper()# 全大写
    s.lower() #全小写
    大小写,做判断的时候用 swapcase() 交互大小写

  字符串排版
    title() -> str 标题的每个单词都大写
    s.capitalize() -> str 首个单词大写
    s.center(width[,fillchar]) -> str width 打印宽度 fillchar 填充的字符
    s.zfill(width) -> str width 打印宽度,居右,左边用 0 补充
    s.ljust(width[,fillchar]) -> str 左对齐
    s.rjust(width[,fillchar]) -> str 右对齐

  字符串修改
    s.replace(old,new[,count]) -> str 字符串找到匹配替换为新字串,返回新字符串 count 表示替代几次,默认全部替换
    s.strip([chars]) ->str 从字符串两端去除指定的字符集chars中的所有字符 默认为去除空白

    s.lstrip([chars]) ->从左开始
    s.rstrip([chars]) ->从右开始

  字符串查找 *
    s.find(sub[,start,end]]) ->int 从左至右 查找sub(子串) 有返回索引 无,返回-1
    s.rfind(sub[,start,end]]) ->int 从右至左 查找sub(子串) 有返回索引 无,返回-1

    s.index(sub[,start[,end]]) -> int 从左至右 查找sub(子串) 有返回索引 无,抛异常
    s.rindex(sub[,start[,end]]) -> int 从右至左 查找sub(子串) 有返回索引 无,抛异常

    时间复杂度 o(n)
    s.count(sub[,start[,end]]) ->int 在指定区间【)从左至右 统计sub出现的次数

  字符串判断 *
    endswith(suffix[,start[,end]]) -> bool 在指定区间,字符串是否suffix结尾
    startwith(prefix[,start[,end]]) -> bool 在指定区间,字符串是否prefix开头

  字符串判断 is 系列
    isalnum() ->bool 是否是字母和数字组合
    isalpha() ->bool 是否是字母
    isdecimal() 是否只包含十进制数字
    isdigit() 是否全部数字(0~9)
    isidentifier() 是不是字母和下划线开头,其他都是字母、数字、下划线
    islower() 是否都是小写
    isupper() 是否全部大写
    isspace() 是否只包含空白字符

  字符串格式化 ***
    + 拼接字符串 非字符串先进行转化
    join 拼接 只能使用分隔符 且被拼接的为可迭代对象
    格式要求: 占位符 format % (values)(只能是一个对象,或数目相等的元组)

  *** format
    "{} {xxx}".format(*args,**kwargs) ->str args 位置参数,一个元组 kwargs 关键字参数,一个字典
    花括号即占位符 {} 按位置匹配 {n} 表示位置参数索引为n的值
    {{}} 打印{}

    访问元素
      "{0[0]}.{0[1]}".format(('magedu','com')) magedu','com==0 'magedu'=0[0]
    对象属性访问
      from collections import namedtuple
      point = namedtuple('point','x,y')
      p = point(4,5)
      "{{{0.x}.{0.y}}}".format(p)

    对齐
      '{:^30}'.format('centered') 居中
      '{:*^30}'.format('centered') 居中 并用*填充

    进制
      "int:{0:d}; hex:{0:x}; oct:{0:o}; bin:{0:b}".format(42)
      输出为: 'int:42; hex:2a; oct:52;bin:101010'
      "int:{0:d}; hex:{0:#x}; oct:{0:#o}; bin:{0:#b}".format(42)
      输出为: 'int:42; hex:ox2a; oct:oo52;bin:ob101010'


十六、集合{set} 无序 {}内无映射关系
      num = {1,2,3,4,5,5,6,5,4,3,1,1}
      num = {1,2,3,4,5,6}
  创建集合 :
    set1 = {xxxxxxxx}
    set2.set([xxxxxxxxxx])


  访问集合:
    for each in set1:
    print(each,end='')
  操作:
    set1.add(num) 增加num
    set1.remove(num) 删除num

  不可变集合:
    set1.frozenset({1,2,3,4})
    删除 del set1

十七、函数、参数即参数结构
  分类:内建函数、库函数、
    可变参数: 一个形参可以匹配任意个参数
    可变位置参数:收集形成一个tuple
    def add(*nums): nums这个形参可以接受任意个实参
      sum = 0
      for x in nums:
        sum += x
      return sum
     add(1,3,5) add(2,4,6) 收集多个实参为tuple

    可变关键字参数:形参前用**符号,表示可接受多个关键字参数,收集的实参名和值组成dict
    def showconfig(**kwargs):
      for k,v in kwargs.items():
        print('{} = {}'.format(k,v))

    keywordonly-only 参数
      def fun(*args,x,y,**kwargs);
        print(x)
        print(y)
        print(args)
        print(kwargs)
      定义合法
      fun(7,9,y=5,x=3,a=1,b='python')
      => 3
        5
        (7,9)
        {'b':'python','a':1}

      def fun(*args,x):
        print(x)
        print(args)
      fun(3,5)   =>error
      fun(3,5,7)   =>error
      fun(3,5,x=7)   => x=7, 3,5=args

      def fn(*,x,y):
        print(x,y)
      fn(x=5,y=6) x y 必须keyword-only参数

    可变参数和参数默认值:
      def fn(*args,x=5):
        print(x)
        print(args)
      fn() == fn(x=5) () 5
      fn(5) == (5,) 5
      fn(x=6) == () 6

      def fn(y,*args,x=5):
        print('x={},y={}.format(x,y)')
        print(args)
      n(5)、fn(1,2,3,x=10)、

      def fn(x=5,**kwargs):
        print('x={}'.format(x))
        print(kwargs)
      fn() => x = 5 {}
      fn(6)=> x = 6 {}
      fn(x=7,y=6) => x= 7 {'y':6}

  函数参数:
    参数规则一般顺序:普通参数、缺省参数、可变位置参数、keyword-only参数、可变关键字参数
      def fn(x,y,z=3,*args,m=4,n,**kwargs):
        print(x,y,z,m,n)
        print(args)
        print(kwargs)
      fn(1,2,n=3) => 1,2,3,4,3 () {}
      fn(1,2,10,11,t=7,n=5) =>1 2 10 4 5 (11,) {'t':7}

  参数解构:
     def add(x,y:)
        return x+y
     add(4,5)
     t=(4,5)
       add(t[0],t[1])
       add(*t) 解构: 非字典型 * 字典型 **

     d = {'x':5,'y':6}
       add(**d)

  内嵌函数和闭包:
    函数内部可以访问到全局变量 不要去改变
      count = 5
      def myfun():
      global count
      count = 10
      print(count)
      nufun() => 10
      count => 10

  闭包:
    def funx(x):
      def funy(y):
        return x+y
      return funy
    i = funx(8)
    i(5) => 13 // funx(8)(5)

  nonlocal :在内部函数中可以移动外部函数中局部变量的值
    def funx():
      x = 5
      def funy():
        nonlocal x
        x *= x
        return x
      return funy
    funx()() => 25

  lambda 创建匿名函数 :
    g = lambda x : 2 * x + 1
    g (5) => 11

  filter()、map()
    filter有两个参数,第一个参数可以是函数或者none, 如果是函数,则将第二个可迭代数据里的每一个元素作为函数参数进行计算,将返回为true的值
      如果是none,则直接将第二个参数中为true的值筛选出来
    例:奇数过滤器
    def odd(x):
      return x % 2

    temp = filter(odd,range(10)) // list(filter(lambda x : x % 2 ,range(10)))
    list(temp) => [1,3,5,7,9]

  map() 映射 两个参数,一个函数加一个可迭代序列,将系列里的每一个元素作为函数的参数进行运算加工,知道可迭代序列每个元素都加工完毕,返回新序列

    list(map(lambda x: x * 2,range(10)) => [,2,4,6,8,10,12,14,16,18,20]


十八、高阶函数 (函数作为返回值,一个或多个函数作为参数,往往形成闭包)
  y=f(g(x))
  def counter(base):
    def inc(step=1):
      nonlocal base
      base += step
      return base
    return inc

  柯里化:原来接受两个参数的函数变成接受一个参数的函数的过程,新的函数返回一个以原有第二个参数的函数
    z=f(x,y) => z=f(x)(y)
  例子:    def add(x,y):
          return x + y
       print(add(4,5))

    =>    def new_add(x):
           def inner(y):
            return x + y
         return inner

  装饰器 *:本质是高阶函数,

十九、文件读写
  声明:open('路径','模式',encoding='编码')
    路径: 'c:\\path\\data.txe'
        r'c:\path\data.txt'
    模式:文本:'r'读 'w'写 'rw' 读写 'a' 打开,追加
        二进制:'*b'
    f = open(r'e:\pythonfile\date.txt','r')
    f.read() #读取所有信息 指针移动至末尾
    f.seek(0)# 指针移动开头 ,可重新读取
    f.tell() #告诉指针位置
    f.close() #关闭文件对象
  读写:
    f.read(n) #读取n位字符的信息
    f.readlines() #读取所有行信息
    f.readline() #读取下一行

    for line in f.readlines():// for line in f:
      print(line)

  查询当前操作目录     import os
            os.getcwd()
            os.chdir(r'xxxxxx') 切换目录

  文件写入:
    f = open('路径','模式',encoding='编码')
    f.write('xxxxxxxxx')
    f.close()
    f.writelines()# 一次写入多行
    f.flush() #直接将内存缓存操作显示在文件上

  自动释放资源
    with open('路径','r',encoding='编码') as f:
      for line in f:
        print(line)

  pickle模块:
    import pickle
    my_list = [123,123.4,'你好',[another list]]
    pickle_file = open(r'e:\pythonfile\my_list.pkl','wb') 二进制写入
    pickle.dump(my_list,my_list.file) dump方法保存数据
    pickle_file.close()

  打开:
    import pickle
    pickle_file = open(r'e:\pythonfile\my_list.pkl','rb')二进制读
    my_list = pickle.load(pickle_file) load 加载数据
    print(my_list)