Python第三周 学习笔记（1）

字典

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]) 排序

返回一个新的列表，默认升序

reverse反转

翻转 reversed(seq)

返回一个翻转元素的迭代器

枚举 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方法，迭代 迭代器对象

生成器对象，就是迭代器对象