Python 部分知识点总结（三）

一、dict

key-value 键值对的数据的集合

可变的，无序的，key不重复
定义

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}
访问

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 对应的值

就地修改
删除

pop(key[,default])

key 存在，移除它，并返回它的 value

key 不存在，返回给定的 default

default 未设置，key 不存在则抛出 KeyError 异常

popitem()

移除并返回一个任意的键值对

字典为 empty，抛出 KeyError 异常

clear() 清空字典

del 语句

del 看着像删除一个对象，本质上减少了一个对象的引用，del 实际上删除的是名称，而不是对象
遍历

遍历 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 的动态的视图，字典变化，视图将反应出这些变化
一边遍历一边清空
要求删除 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)
key 的要求

set 元素可以就是看作 key，set 可以看作 dict 的简化版

hashable 可哈希才可以作为 key，可以使用 hash() 测试
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)
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)
有序字典可以记录元素插入的顺序，打印的时候也是按照这个顺序输出打印

3.6 版本的Python 的字典就是记录 key 插入的顺序（IPython 不一定有效果）

应用场景：

假如使用字典记录了 N 个产品，这些产品使用 ID 由小到大加入到字典中

除了使用字典检索的遍历，有时候需要取出 ID，但是希望是按照输入的顺序

否则还需要重新把遍历到的值排序

二、datetime

datetime 模块是对日期、时间、时间戳的处理
datetime 类

today() 返回本地时区当前时间的 datetime 对象

now(tz=None) 返回当前时间的 datetime 对象，时间到微秒，如果 tz 为None，返回和 today() 一样

utcnow() 没有时区的当前时间

fromtimestamp(timestamp,tz=None) 从一个时间戳返回一个 datetime 对象
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() 返回一个三元组（年，周数，周的天）
日期格式化

类方法 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
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() 返回时间差的总秒数
time
time.sleep(secs) 将调用线程挂起指定的秒数

三、列表解析式

语法

[返回值 for 元素 in 可迭代对象 if 条件]

使用中括号 []，内部是 for 循环，if 条件语句可选

返回一个新的列表
列表解析式是一种语法糖

编译器会优化，不会因为简写而影响效率，反而因优化提高提高了效率

减少程序员工作量，减少出错

简化了代码，但可读性增强
# 返回 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)}

四、内建函数

标识 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) –> 0
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) 给一个一定范围的整数返回对应的字符，如 chr(97)、chr(20013)
ord(c) 返回字符对应的整数，如 ord(‘a’)、ord(‘中’)
str()、rep()、ascii()
sorted(iterable[,key][,reverse]) 排序：返回一个新的列表，默认升序
翻转 reversed(seq)：返回一个翻转元素的迭代器
枚举 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)]
迭代器和取元素 iter(iterable)、next(iterator[,default])

iter 将一个可迭代对象封装成一个迭代器

next 对一个迭代器取下一个元素，如果全部元素都取过了，再次 next 会抛 StopIteration 异常

it = iter(range(5))

next(it)

it =reversed([1,3,5])

next(it)
可迭代对象

能够通过迭代一次次返回不同的元素的对象

所谓相同，不是指值是否相同，而是元素在容器中是否是同一个，例如列表中值可以重复的，[‘a’,’a’]，虽然这个列表有 2 个元素，值一样，但是两个 ‘a’ 是不同的元素

可以迭代，但是未必有序，未必可索引
可迭代对象有：list、tuple、string、bytes、bytearray、range、set、dict、生成器

可以使用成员操作符 in、not in，in 本质上就是在遍历对象
拉链函数 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

Python 部分知识点总结（三）

一、dict

二、datetime

三、列表解析式

四、内建函数

相关推荐

Python内置数据结构（字典）

树

第一周作业

Python数据结构

元组与字符串

Python内置数据结构——列表