Python进阶—高级语法

目录

1、在==和is之间选择

==运算符比较的是两个对象的值(对象中保存的数据)，而is比较的是对象的标识。

通常，我们关注的是值，而不是标识，因此 Python 代码中 == 出现的频率比 is 高。
然而，在变量和单例值之间比较时，应该使用 is。目前，最常使用 is 检查变量绑定的值是不是 None。

下面是推荐的写法：

x is None

否定的正确写法是：

x is not None

is 运算符比 == 速度快，因为它不能重载，所以 Python 不用寻找并调用特殊方法，而是直接比较两个整数 ID。而 a == b 是语法糖，等同于 a.__eq__(b)。继承自 object 的__eq__ 方法比较两个对象的 ID，结果与 is 一样。但是多数内置类型使用更有意义的方式覆盖了 __eq__ 方法，会考虑对象属性的值。相等性测试可能涉及大量处理工作，例如，比较大型集合或嵌套层级深的结构时。

2、元组的相对不可变性

元组与多数 Python 集（列表、字典、集合，等等）一样，保存的是对象的引用。

如果引用的元素是可变的，即便元组本身不可变，元素依然可变。也就是说，元组的不可变性其实是指 tuple 数据结构的物理内容（即保存的引用）不可变，与引用的对象无关。

示例 8-5 表明，元组的值会随着引用的可变对象的变化而变。元组中不可变的是元素的标识。
示例 8-5　一开始，t1 和 t2 相等，但是修改 t1 中的一个可变元素后，二者不相等了

t1 = (1, 2, [30, 40]) ➊
t2 = (1, 2, [30, 40]) ➋
t1 == t2 ➌
>>True

id(t1[-1]) ➍
>>4302515784
t1[-1].append(99) ➎
t1
>>(1, 2, [30, 40, 99])

id(t1[-1]) ➏
>>4302515784

t1 == t2 ➐
>>False

❶ t1 不可变，但是 t1[-1] 可变。
❷ 构建元组 t2，它的元素与 t1 一样。
❸ 虽然 t1 和 t2 是不同的对象，但是二者相等——与预期相符。
❹ 查看 t1[-1] 列表的标识。
❺ 就地修改 t1[-1] 列表。
❻ t1[-1] 的标识没变，只是值变了。
❼ 现在，t1 和 t2 不相等。

3、字典中的键映射多个值

问题
怎样实现一个键对应多个值的字典（也叫multidict）？
解决方案
一个字典就是一个键对应一个单值的映射。如果你想要一个键映射多个值，那么你
就需要将这多个值放到另外的容器中，比如列表或者集合里面。比如，你可以像下面这
样构造这样的字典：

d = {
   
'a' : [1, 2, 3],
'b' : [4, 5]
}

e= {
   
'a' : {
   1, 2, 3},
'b' : {
   4, 5}
}

选择使用列表还是集合取决于你的实际需求。如果你想保持元素的插入顺序就应
该使用列表，如果想去掉重复元素就使用集合（并且不关心元素的顺序问题）。
你可以很方便的使用collections 模块中的defaultdict 来构造这样的字典。
defaultdict 的一个特征是它会自动初始化每个key 刚开始对应的值，所以你只需要
关注添加元素操作了。比如：

from collections import defaultdict
d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)
d = defaultdict(set)
d['a'].add(1)
d['a'].add(2)
d['b'].add(4)

需要注意的是，defaultdict 会自动为将要访问的键（就算目前字典中并不存在这样的键）创建映射实体。如果你并不需要这样的特性，你可以在一个普通的字典上使用setdefault() 方法来代替。比如：

d = {
   } # A regular dictionary
d.setdefault('a', []).append(1)
d.setdefault('a', []).append(2)
d.setdefault('b', []).append(4)

但是很多程序员觉得setdefault() 用起来有点别扭。因为每次调用都得创建一个
新的初始值的实例（例子程序中的空列表[] ）。
讨论
一般来讲，创建一个多值映射字典是很简单的。但是，如果你选择自己实现的话，
那么对于值的初始化可能会有点麻烦，你可能会像下面这样来实现：

d = {
   }
for key, value in pairs:
if key not in d:
   d[key] = []
d[key].append(value)

如果使用defaultdict 的话代码就更加简洁了：

d = defaultdict(list)
for key, value in pairs:
    d[key].append(value)

4、Linux

创建文件夹：mkdir zxc123

进入文件夹：cd zxc123

创建文件：touch zjf.txt

返回根目录：cd …

删除不为空的文件夹：rm -r zxc123(如果想不提示删除信息rm -rf zxc123)

5、python中字典的key要求

❶python中什么对象不能作为字典的key：有__hash__方法可以做字典的key，没有则不能作为字典的key;

❷除了list、dict、set和内部至少带有上述三种类型之一的tuple之外，其余对象均可作为字典的key；

**原因：**源码object对象定义了__hash__方法，list、set、dict把__hash__赋值为None；

6、编码

将生活中常用的数据与计算机数据关联

关联的介质是十进制数据

生活中的数据<------>十进制<------>二进制

❶获取生活中某个字符对应的十进制数据：ord(单个符号)

ord(“a”) ===> 97

​ “A” ===> 65

​ “0” ===> 48

​ “你” ===> 20320

❷根据十进制数据获取其对应生活中的字符：chr(十进制数据)

chr(20320) ===> “你”

7、进制之间的转换

❶ 将数据转化为16进制：hex(数据)

❷ 转化为二进制：bin(数据)

❸ 转化为八进制：oct(数据)

8、关系运算符(时间处理)

经过关系运算符运算之后，最终结果是bool类型的

> 大于
< 小于
>= 大于等于
<= 小于等于
== 是否相等
!= 是否不相等

在数值中比较数值的大小 或者是否相等

在字符串中： 从第一个字符开始，两者一 一对应去比较。

举例

import time
from datetime import datetime

str1 = '2018-01-01T00:00:00.000+08:00'
str2 = '2018-02-01 00:00:00'
str3 = str2[:4]
print(str3)
if str2>str1:
    print('11111111')
----------------------------------------------------------------------- 
>>2018
>>11111111  

9、时间处理模块

❶常用时间处理方法

最常用的time.time()返回的是一个浮点数，单位为秒。但strftime处理的类型是time.struct_time，实际上是一个tuple。strptime和localtime都会返回这个类型。

import time

>>>t = time.time()

>>>t
>>>1202872416.4920001

>>>type(t)
>>><type 'float'>

>>>t = time.localtime()
>>>t
>>>(2008, 2, 13, 10, 56, 44, 2, 44, 0)

>>>type(t)
>>><type 'time.struct_time'>

Python strftime() 函数接收以时间元组，并返回以可读字符串表示的当地时间，格式由参数format决定。
>>>time.strftime('%Y-%m-%d', t)
>>>'2008-02-13'

Python strptime() 函数根据指定的格式把一个时间字符串解析为时间元组。
>>>time.strptime('2008-02-14', '%Y-%m-%d')
>>>(2008, 2, 14, 0, 0, 0, 3, 45, -1)

❷转化为13位时间戳

str2 = '2018-02-01 00:00:00.000+08:00'

def format_time_to_unix_time(time_str):
    time_format = '%Y-%m-%d %H:%M:%S'
    result = datetime.strptime(time_str, time_format)
    un_time = time.mktime(result.timetuple())
    un_time = int(round(un_time) * 1000)
    return un_time


res = format_time_to