Python 部分知识点总结(三)

此篇博客只是记录第五周未掌握或不熟悉的知识点,用来加深印象。

一、dict

  1. key-value 键值对的数据的集合
    可变的,无序的,key不重复
  2. 定义
    d = dict()  或者 d = {}
    dict(**kwargs) 使用 name=value对 初始化一个字典
    dict(iterable,**kwarg) 使用可迭代对象和 name=value对 构造字典,不过可迭代对象的元素必须是一个二元结构
     d = dict(((1,’a’),(2,’b’))) 或者 d = dict(([1,’a’],[2,’b’]))
    dict(mapping,**kwarg) 使用一个字典构建另一个字典
    d = {‘a’:10,’b’:20,’c’:None,’d’:[1,2,3]}
    类方法 dict.fromkeys(iterable,value)
    d = dict.fromkeys(range(5))     –>    {0: None, 1: None, 2: None, 3: None, 4: None}
    d = dict.fromkeys(range(5),0)   –>   {0: 0, 1: 0, 2: 0, 3: 0, 4: 0}
  3. 访问
     d[key]:返回 key 对应的值 value;key 不存在抛出 KeyError 异常
     get(key[,default]):返回 key 对应的值 value;key 不存在返回缺省值,如果没有设置缺省值,返回 None
    setdefault(key[,default]):返回 key 对应的值 value;key 不存在,添加 kv 对,value 为 default,并返回default,如果 default 没设置,缺省值为 None
  4. 增加和修改
    d[key] = value
    将 key 对应的值修改为 value
    key 不存在添加新的 kv对
    update([other])  –> None
          使用另一个字典的 kv对 更新字典
          key 不存在,就添加
          key 存在,覆盖已经存在的 key 对应的值
          就地修改
  5. 删除
     pop(key[,default])
          key 存在,移除它,并返回它的 value
          key 不存在,返回给定的 default
          default 未设置,key 不存在则抛出 KeyError 异常
     popitem()
            移除并返回一个任意的键值对
            字典为 empty,抛出 KeyError 异常
    clear()   清空字典
       del 语句
            del 看着像删除一个对象,本质上减少了一个对象的引用,del 实际上删除的是名称,而不是对象
  6. 遍历
         遍历 key
         for k in d:
                print(k)
          for k in d.keys():
                print(k)
           遍历 value
               for k in d:
                   print(d[k])
               for k in d.keys():
                    print(d.get(k))
               for v in d.values():
                   print(v)
            遍历 item,即 kv对
                  for item in d.items():
                      print(item)
                  for item in d.items():
                      print(item[0],item[1])
                  for k,v in d.items():
                      print(k,v)
                  for k,_ in d.items():
                      print(k)
                  for _,v in d.items():
                      print(v)
        Python3中,keys、values、items 方法返回一个类似一个生成器的可迭代对象,不会把函数的返回结果复制到内存中
         Dictionary view 对象
         字典的 entry 的动态的视图,字典变化,视图将反应出这些变化
  7. 一边遍历一边清空
    要求删除 value 为字符串的元素
    d = dict(a=1,b=2,c=’abc’)
    keys = []
    for k,v in d.items():
        if isinstance(v,str):
            keys.append(k)
    print(keys)
    for k in keys:
        d.pop(k)
    print(d)
  8. key 的要求
      set 元素可以就是看作 key,set 可以看作 dict 的简化版
      hashable 可哈希才可以作为 key,可以使用 hash() 测试
  9. collections.defaultdict([default_factory[,…]])
     第一个参数是 default_factory,缺省是 None,它提供一个初始化函数,当 key 不存在的时候,会调用这个工工厂函数来生成 key 对应的 value
    import random
    d = {}
    for k in ‘abcdef’:
        for i in range(random.randint(1,5)):
            if k not in d.keys():
                d[k] = []
            d[k].append(i)
    print(d)
    ——————————————————————————
    from collections import defaultdict
    import random
    d = defaultdict(list)    #是为了下面要用
    for k in ‘abcdef’:
        for i in range(random.randint(1,5)):
            d[k].append(i)      #如果 k 不存在,则d[k] = list()
    print(d)
  10. collections.OrderedDict([items])
     key 并不是按照加入的顺序排列,可以使用 OrderedDict 记录顺序
    from collections import OrderedDict
    import random
    d = {‘b’:3,’a’:4,’p’:1,’o’:2}
    print(d)
    keys = list(d.keys())
    random.shuffle(keys)
    print(keys)
    od = OrderedDict()
    for key in keys:
        od[key] = d[key]
    print(od)
    print(od.keys)
  11. 有序字典可以记录元素插入的顺序,打印的时候也是按照这个顺序输出打印
      3.6 版本的Python 的字典就是记录 key 插入的顺序(IPython 不一定有效果)
           应用场景:
               假如使用字典记录了 N 个产品,这些产品使用 ID 由小到大加入到字典中
               除了使用字典检索的遍历,有时候需要取出 ID,但是希望是按照输入的顺序
               否则还需要重新把遍历到的值排序

二、datetime

  1. datetime 模块是对日期、时间、时间戳的处理
  2. datetime 类
     today() 返回本地时区当前时间的 datetime 对象
     now(tz=None) 返回当前时间的 datetime 对象,时间到微秒,如果 tz 为None,返回 和 today() 一样
     utcnow() 没有时区的当前时间
     fromtimestamp(timestamp,tz=None)  从一个时间戳返回一个 datetime 对象
  3. datetime 对象
     timestamp() 返回一个到微秒的时间戳,时间戳就是格林威治时间1970年1月1日0点到现在的秒数
    构造方法 datetime.datetime(2016,12,6,16,29,43,79043)year、month、day、hour、minute、second、microsecond,取 datetime 对象的年月日时分秒及微秒
              weekday()                返回星期的天,周一0,周日6
              isoweekday()            返回星期的天,周一1,周日7
              date()                       返回日期 date 对象
              time()                       返回时间 time 对象
              replace()                   修改并返回新的时间
              isocalendar()            返回一个三元组(年,周数,周的天)
  4. 日期格式化
     类方法 strptime(date_string,format) ,返回 datetime 对象
     对象方法 strftime(format),返回字符串
     字符串 format 函数格式化
    >>> import datetime
    >>> dt = datetime.datetime.strptime(“21/11/06 16:30″,”%d/%m/%y %H:%M”)
    >>> print(dt)
    2006-11-21 16:30:00
    >>> print(dt.strftime(“%Y-%m-%d %H:%M:%S”))
    2006-11-21 16:30:00
    >>> print(“{0:%Y}/{0:%m}/{0:%d} {0:%H}::{0:%M}::{0:%S}”.format(dt))
    2006/11/21 16::30::00
  5. timedelta 对象
    >>> datetime.timedelta(days=0,seconds=0,microseconds=0,milliseconds=0,minutes=0,hours=1,weeks=0)
     datetime.timedelta(0, 3600)
    >>> year = datetime.timedelta(days=365)
     >>> year
     datetime.timedelta(365)
    total_seconds()  返回时间差的总秒数
  6. time
    time.sleep(secs)  将调用线程挂起指定的秒数

三、列表解析式

  1. 语法
     [返回值 for 元素 in 可迭代对象 if 条件]
     使用中括号 [],内部是 for 循环,if 条件语句可选
     返回一个新的列表
  2. 列表解析式是一种语法糖
     编译器会优化,不会因为简写而影响效率,反而因优化提高提高了效率
     减少程序员工作量,减少出错
     简化了代码,但可读性增强
  3. # 返回 1 – 10 平方的列表
     [i**2 for i in range(1,11)]
    # 有一个列表 lst = [1,4,9,16,2,5,10,15],生成一个新列表,要求新列表元素是 lst 相邻 2 项的和
    [[1,4,9,16,2,5,10,15][i]+[1,4,9,16,2,5,10,15][i+1] for i in range(len([1,4,9,16,2,5,10,15])-1)]
    # 打印九九乘法表
    {print(“{}*{}={:<2}{}”.format(j,i,i*j,’\n’ if i==j else ‘ ‘),end=”) for i in range(1,10) for j in range(1,i+1)}
    # “0001.abadicddws” 是 ID 格式,要求 ID 格式是以点号分割,左边是 4 位从 1 开始的整数,右边是 10 位随机小写英文字母,请依次生成前 100 个 ID 的列表
    import random
    import string
    {print(“{:04}.{}”.format(i,”.join(random.choice(string.ascii_lowercase) for _ in range(10)))) for i in range(1,101)}

四、内建函数

  1. 标识 id :返回对象的唯一标识,CPython 返回内存地址
  2. 哈希 hash():返回一个对象的类型
  3. 类型 type() :返回对象的类型
  4. 类型转换:float(),int(),bin(),hex(),oct(),bool(),list(),tuple(),dict(),set(),complex(),bytes(),bytearray()
  5. 输入 input([prompt]):接收用户输入,返回一个字符串
  6. 打印 print(*objects,sep=’ ‘,end=’\n’,file=sys.stdout,flush=False):打印输出,默认使用空格分割,换行结尾,输出到控制台或者输出至一个文件
  7. 对象长度 len(s):返回一个集合类型的元素合数
  8. isinstance(obj,class_or_tuple):判断对象 obj 是否属于某种类型或者元祖中列出的某个类型,如 isinstance(True,int)
  9. issubclass(cls,class_or_tuple):判断类型 cls 是否是某种类型的子类或元祖中列出的某个类型的子类,如 issubclass(bool,int)
  10. 绝对值 abs(x),x 为数值
  11. 最大值 max(),最小值 min():返回可迭代对象中最大或最小值;返回多个参数中最大或最小值
  12. round(x) 四舍六入五取偶,round(-0.5)   –> 0
  13. pow(x,y) 等价于 x**y
  14. range(stop)  从 0 开始到 stop-1 的可迭代对象;range(start,stop[,step]) 从start 开始到 stop-1 结束步长为 step 的可迭代对象
  15. divmod(x,y) 等价于 tuple(x//y,x%y)
  16. sum(iterable[,start]) 对可迭代对象的所有数值元素求和,如 sum(range(1,100,2))
  17. chr(i) 给一个一定范围的整数返回对应的字符,如 chr(97)、chr(20013)
  18. ord(c) 返回字符对应的整数,如 ord(‘a’)、ord(‘中’)
  19. str()、rep()、ascii()
  20. sorted(iterable[,key][,reverse]) 排序:返回一个新的列表,默认升序
  21. 翻转 reversed(seq):返回一个翻转元素的迭代器
  22. 枚举 enumerate(seq,start=0):迭代一个序列,返回索引数字和元素构成的二元组;start 表示索引开始的数字,默认是 0
    >>> list(enumerate(range(5)))
    [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
    >>> list(enumerate(range(5),100))
    [(100, 0), (101, 1), (102, 2), (103, 3), (104, 4)]
  23. 迭代器和取元素 iter(iterable)、next(iterator[,default])
            iter 将一个可迭代对象封装成一个迭代器
            next 对一个迭代器取下一个元素,如果全部元素都取过了,再次 next 会抛 StopIteration 异常
                     it = iter(range(5))
                     next(it)
                     it =reversed([1,3,5])
                     next(it)
  24. 可迭代对象
     能够通过迭代一次次返回不同的元素的对象
    所谓相同,不是指值是否相同,而是元素在容器中是否是同一个,例如 列表中值可以重复的,[‘a’,’a’],虽然这个列表有 2 个元素,值一样,但是两个 ‘a’ 是不同的元素
    可以迭代,但是未必有序,未必可索引
    可迭代对象有:list、tuple、string、bytes、bytearray、range、set、dict、生成器
    可以使用成员操作符 in、not in,in 本质上就是在遍历对象
  25. 拉链函数 zip(*iterable)
    像拉链一样,把多个可迭代对象合并在一起,返回一个迭代器
    将每次从不同对象中取到的元素合并成一个元祖
    >>> list(zip(range(3),range(3)))
    [(0, 0), (1, 1), (2, 2)]
    >>> list(zip(range(3),range(5)))
    [(0, 0), (1, 1), (2, 2)]
    木桶原理

本文来自投稿,不代表Linux运维部落立场,如若转载,请注明出处:http://www.178linux.com/95551

发表评论

登录后才能评论

This site uses Akismet to reduce spam. Learn how your comment data is processed.

联系我们

400-080-6560

在线咨询:点击这里给我发消息

邮件:1823388528@qq.com

工作时间:周一至周五,9:30-18:30,节假日同时也值班