Python第三周 学习笔记

Posted 2020-10-30

字典

---

• key-value键值对的数据的集合
• 可变的、无序的、key不重复

初始化：

d = dict()
d = {}
d = dict(**kwargs)  如：d = dict(a=1,b=2)
dict(iterable, **kwarg)

使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个二元结构

dict(mapping, **kwarg)
dict.fromkeys(iterable, value)

字典元素的访问

• 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

字典增加和修改

• d[key] = value
  • 将key对应的值修改为value
  • key不存在添加新的kv对
• update([other]) -> None
  • 使用另一个字典的kv对更新本字典
  • key不存在，就添加
  • key存在，覆盖已经存在的key对应的值
  • 就地修改

d.update(red=1)
d.update(((‘red‘,2),))
d.update({‘red‘:3})

字典删除

• pop(key[, default])
  • key存在，移除它，并返回它的value
  • key不存在，返回给定的default
  • default未设置，key不存在则抛出KeyError异常

• popitem()

  • 移除并返回一个任意的键值对
  • 字典为empty，抛出KeyError异常
  • clear()
  • 清空字典
• del语句
  • 本质上减少了一个对象的引用，del 实际上删除的是名称，而不是对象

字典遍历：

• 遍历key:

for k in d:
print(k)

for k in d.keys():
print(k)

• 遍历values:

for k in d:
print(d[k])

for k in d:
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的动态的视图，字典变化，视图将反映出这些变化

字典遍历和移除

• 遍历字典时，不允许增删元素
• 可先记录key值再遍历删除

d = dict(a=1, b=2, c=‘abc‘)
keys = []
for k,v in d.items():
if isinstance(v, str):
keys.append(k)
for k in keys:
d.pop(k)
print(d)

defaultdict

• collections.defaultdict([default_factory[, ...]])
• 第一个参数是default_factory，缺省是None，它提供一个初始化函数。当key不存在的时候，会调用这个工厂函数来生成key对应的value

ordereddict

• collections.OrderedDict([items])
• key并不是按照加入的顺序排列，可以使用OrderedDict记录顺序

标准库datetime

---

datetime模块

• datetime类
• today()
  • 返回本地时区当前时间的datetime对象
• now(tz=None)
  • 返回当前时间的datetime对象，时间到微秒，如果tz为None，返回和today()一样
  • fromtimestamp(timestamp, tz=None) 从一个时间戳返回一个datetime对象
• 日期格式化
  • 类方法 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.strftime("%Y-%m-%d %H:%M:%S"))
print("{0:%Y}/{0:%m}/{0:%d} {0:%H}::{0:%M}::{0:%S}".format(dt))

• timedelta对象

  • 与datetime对象做加减运算
  • datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0,minutes=0, hours=0, weeks=0)
  • total_seconds() 返回时间差的总秒数
• 标准库time
  • time.sleep(secs) 将调用线程挂起指定的秒数

列表解析式

---

• 语法

  • [返回值 for 元素 in 可迭代对象 if 条件]
  • 使用中括号[]，内部是for循环，if条件语句可选
  • 返回一个新的列表
• 列表解析式是一种语法糖
  • 编译器会优化，不会因为简写而影响效率，反而因优化提高了效率
  • 减少程序员工作量，减少出错
  • 简化了代码，但可读性增强

列表解析进阶

• [expr for item in iterable if cond1 if cond2]

• 等价于

  ret = []
  for item in iterable:
  if cond1:
  if cond2:
  ret.append(expr)

• [expr for i in iterable1 for j in iterable2 ]
  等价于

  ret = []
  for i in iterable1:
  for j in iterable2:
  ret.append(expr)

生成器表达式

• (返回值 for 元素 in 可迭代对象 if 条件)

  • 生成器表达式是按需计算（或称惰性求值、延迟计算），需要的时候才计算值
  • 列表解析式是立即返回值

• 生成器是可迭代对象、迭代器

• 使用next(itetator)迭代

生成器迭代与列表迭代对比

• 生成器

  • 延迟计算
  • 返回迭代器，可以迭代
  • 从前到后走完一遍后，不能回头

• 列表

  • 立即计算
  • 返回的不是迭代器，返回可迭代对象列表
  • 从前到后走完一遍后，可以重新回头迭代
• 计算方式
  • 生成器表达式延迟计算，列表解析式立即计算
• 内存占用
  • 单从返回值本身来说，生成器表达式省内存，列表解析式返回新的列表
  • 生成器没有数据，内存占用极少，但是使用的时候，虽然一个个返回数据，但是合起来占用的内存也差不多
  • 列表解析式构造新的列表需要占用内存
• 计算速度
  • 单看计算时间看，生成器表达式耗时非常短，列表解析式耗时长
  • 但是生成器本身并没有返回任何值，只返回了一个生成器对象
  • 列表解析式构造并返回了一个新的列表

集合解析式

• {返回值 for 元素 in 可迭代对象 if 条件}
  • 立即返回一个集合

字典解析式

• {返回值 for 元素 in 可迭代对象 if 条件}
  • 使用key:value形式
  • 立即返回一个字典

内建函数

---

• 标识 id
  • 返回对象的唯一标识，CPython返回内存地址
• 哈希 hash()
  • 返回一个对象的哈希值
• 类型 type()
  • 返回对象的类型
• 类型转换
  float() int() bin() hex() oct() bool() list() tuple() dict() set() complex() bytes() bytearray()

• 输入 input([prompt])

  • 接收用户输入，返回一个字符串
  • 打印 print(*objects, sep=‘ ‘, end=‘\n‘, file=sys.stdout, flush=False)
  • 打印输出，默认使用空格分割、换行结尾，输出到控制台
• 对象长度 len(s)
  • 返回一个集合类型的元素个数

• isinstance(obj, class_or_tuple)

  • 判断对象obj是否属于某种类型或者元组中列出的某个类型
  • isinstance(True, int)

• issubclass(cls, class_or_tuple)

  • 判断类型cls是否是某种类型的子类或元组中列出的某个类型的子类
  • issubclass(bool, int)
• 绝对值abs(x)
  • x为数值
• 最大值max() 最小值min()
  • 返回可迭代对象中最大或最小值
  • 返回多个参数中最大或最小值
• round(x)
  • 四舍六入五取偶，round(-0.5)
• pow(x , y)
  • 等价于 x**y
• range(stop)
  • 从0开始到stop-1的可迭代对象；range(start, stop[, step])从start开始到stop-1结束步长为step的可迭代对象
• divmod(x, y)
  • 等价于 tuple (x//y, x%y)

• sum(iterable[, start])

  • 对可迭代对象的所有数值元素求和
  • sum(range(1,100,2))
• chr(i)
  • 给一个一定范围的整数返回对应的字符

• ord(c)

  • 返回字符对应的整数
• sorted(iterable[, key][, reverse]) 排序
  • 返回一个新的列表，默认升序

• reversed()

  • 反转

• 枚举 enumerate(seq, start=0)

  • 迭代一个序列，返回索引数字和元素构成的二元组
    *start表示索引开始的数字，默认是0

• 迭代器和取元素 iter(iterable)、next(iterator[, default])

  • iter将一个可迭代对象封装成一个迭代器
  • next对一个迭代器取下一个元素。如果全部元素都取过了，再次next会抛StopIteration异常
• 拉链函数zip(*iterables)
  • 像拉链一样，把多个可迭代对象合并在一起，返回一个迭代器
  • 将每次从不同对象中取到的元素合并成一个元组
  • 木桶原理，取最小迭代次数迭代

可迭代对象

• 能够通过迭代一次次返回不同的元素的对象。
• 所谓相同，不是指值是否相同，而是元素在容器中是否是同一个，例如列表中值可以重复的，[‘a‘,‘a‘]，虽然这个列表有2个元素，值一样，但是两个‘a‘是不同的元素
• 可以迭代，但是未必有序，未必可索引
• 可迭代对象有：list、tuple、string、bytes、bytearray、range、set、dict、生成器等
• 可以使用成员操作符in、not in，in本质上就是在遍历对象

迭代器

• 特殊的对象，一定是可迭代对象，具备可迭代对象的特征
• 通过iter方法把一个可迭代对象封装成迭代器
• 通过next方法，迭代 迭代器对象
• 生成器对象，就是迭代器对象