Python 部分知识点总结（三）

庞豪 • • 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

赞 (0)
庞豪庞豪
0
上一篇 2018-04-08
下一篇 2018-04-08

相关推荐

电话咨询
在线咨询