python中_python中的特殊用法

一、python中的Ellipsis对象

提起Ellipsis对象，很多刚入门或者入门不久的同学肯定会两眼发蒙，还有这个东西？平时心细的同学或许在源码中看到过，但不一定知道他的python学名。

Ellipsis对象： 在python代码中通常写作 … ，没错，就是三个点，他的中文解释为：省略，该对象的bool值为 True。

很多人肯定特别关心的一个问题，那它有什么用途呢

用途一：省略代码，作用类似于pass的一种替代方案,这是python的’TBD’(未确定内容)。

deffun():

…

用途二：循环数据结构， 一个复合对象包含指向自身的引用。

示例：

L = [1,2,3]

L.append(L)print(L) #输出为[1,2,3,[…]]

是不是瞬间感觉高大上。

用途三：用来模拟一些情况，使结果看起来更友好，如等差数列，numpy。

高端大气上档次的等差数列生成器，演示结果如下：

简单粗暴地实现：

classProgressionMaker(object):def __getitem__(self, key):if isinstance(key, tuple) and len(key) == 4 and key[2] isEllipsis:return list(range(key[0], key[-1] + 1, key[1] -key[0]))

maker=ProgressionMaker()

pagm= maker[1, 2, ..., 9]print(pagm) #[1, 2, 3, 4, 5, 6, 7, 8, 9]

pagm2= maker[6, 13, ..., 34]print(pagm2) #[6, 13, 20, 27, 34]

至于错误处理、支持更多参数（例如 maker[3, 7, 11, ..., 31, ..., 55, 59] 之类的），或是同时支持等比数列之类的我就不管了，有兴趣的可以自己实现。

虽然看上去很厉害的样子，但其实没什么技术含量……

先来介绍一下如何处理这种语法，其实只用到 object.__getitem__ 方法而已：

classTest(object):def __getitem__(self, key):print(key)

test=Test()

test[1] #1

test[:] #slice(None, None, None)

test[1:9] #slice(1, 9, None)

test[1:3:5] #slice(1, 3, 5)

test[1, 5] #(1, 5)

test[1, 2:3, :4:, ::] #(1, slice(2, 3, None), slice(None, 4, None), slice(None, None, None))

test[1, 2, ..., 9, 10] #(1, 2, Ellipsis, 9, 10)

至于 python库numpy， 其中提供了函数linspace和logspace函数用于生产等差数列和等比数列。

补充说明：...在python中居然是个常量

print(...) #Ellipsis

二、位运算符

>> 和 <<都是位运算，对二进制数进行移位操作。

<< 是左移，末位补0，类比十进制数在末尾添0相当于原数乘以10，x<<1是将x的二进制表示左移一位，相当于原数x乘2。比如整数4在二进制下是100，4<<1左移1位变成1000(二进制)，结果是8。

>>是右移，右移1位相当于除以2。

而>>=和<<=，就是对变量进行位运算移位之后的结果再赋值给原来的变量，可以类比赋值运算符+=和-=可以理解。

比如x>>=2， 就是把变量x右移2位，再保留x操作后的值。

print(2>>1) #1

print(2<<1) #4

print(2>>2) #0

print(100>>2) #25

print(100<<2) #400

print(1>>1) #0

补充说明：

2进制是以0b开头的: 例如: 0b11 则表示十进制的3

8进制是以0o开头的: 例如: 0o11则表示十进制的9

16进制是以0x开头的: 例如: 0x11则表示十进制的17

print(0b11) #3

print(0o12) #10

print(0x23) #35

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13，二进制格式如下：

a = 0011 1100b= 0000 1101a&b = 0000 1100a|b = 0011 1101a^b = 0011 0001

~a = 1100 0011

运算符描述实例

&

按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

(a & b) 输出结果 12 ，二进制解释： 0000 1100

|

按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。

(a | b) 输出结果 61 ，二进制解释： 0011 1101

^

按位异或运算符：当两对应的二进位相异时，结果为1

(a ^ b) 输出结果 49 ，二进制解释： 0011 0001

~

按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1

(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。

<<

左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。

a << 2 输出结果 240 ，二进制解释： 1111 0000

>>

右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数

a >> 2 输出结果 15 ，二进制解释： 0000 1111

以下实例演示了Python所有位运算符的操作：

#!/usr/bin/python#-*- coding: UTF-8 -*-

a= 60 #60 = 0011 1100

b = 13 #13 = 0000 1101

c =0

c= a & b; #12 = 0000 1100

print "1 - c 的值为：", c

c= a | b; #61 = 0011 1101

print "2 - c 的值为：", c

c= a ^ b; #49 = 0011 0001

print "3 - c 的值为：", c

c= ~a; #-61 = 1100 0011

print "4 - c 的值为：", c

c= a << 2; #240 = 1111 0000

print "5 - c 的值为：", c

c= a >> 2; #15 = 0000 1111

print "6 - c 的值为：", c

以上实例输出结果：

1 - c 的值为： 12

2 - c 的值为： 61

3 - c 的值为： 49

4 - c 的值为： -61

5 - c 的值为： 240

6 - c 的值为： 15

View Code

三、python中包的导入

python中的关于包的导入，好多人会存在一些误区，希望优秀的你可以看完下面的内容：(__file__ 表示当前文件)

四、 整数与IP的互换（这个可以直接跳过）

我们有时会将一个整数与IP地址进行互换,用python代码实现很简单

将一个整数如2000000,变为一个IP地址的方式

importsocketimportstruct

int_ip= 123456789ip= socket.inet_ntoa(struct.pack('I',socket.htonl(int_ip))) #int to ip address

'7.91.205.21'socket.ntohl(struct.unpack("I",socket.inet_aton(str(ip)))[0]) #ip address to int

123456789L

其实这是进制数的转换，我们可以自己写代码

#整数to IP地址格式

defch1(num):

s=[]for i in range(4):

s.append(str(num%256))

num//= 256

return '.'.join(s[::-1])

ch1(123456789) #'7.91.205.21'

用lambda的方式，整数toIP 地址 一行代码搞定

ch2 = lambda x: '.'.join([str(x//(256**i)%256) for i in range(3,-1,-1)])

ch2(123456789) #'7.91.205.21'

用lambda的方式，IP地址转换到整数

ch3 = lambda x:sum([256**j*int(i) for j,i in enumerate(x.split('.')[::-1])])

ch3('7.91.205.21') #123456789

五、编程中的一些概念，KISS、DRY、MVC、OOP、REST

（1）KISS是指Keep It Simple,Stupid（摘自wikipedia），指设计时要坚持简约原则，避免不必要的复杂化。

（2）DRY是指Don't Repeat Yourself（摘自wikipedia），特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾。

（3）OOP 即Object-Oriented Programming，是指面向对象的程序设计。我一直觉得经典的比喻是汽车是一个类（Class），而这个类的属性有轮子、车身、马达等，方法有加速、减速等；而劳斯莱斯就是一个对象（Object）了，这个对象继承了汽车这个类的属性和方法；而如何实现加速、减速？这样的信息被隐藏了——即信息封装（封装），只留下用户接口给我们了，比如踩刹车、踩油门；至于多态嘛，我粗糙比喻下就是一台自动贩卖机（我们假设它每种价格只有一款饮料），同样是投币这种方法，但是你投进去2元跟5元得到的结果是不一样的——当然，除非这贩卖机有问题。

（4）REST（Representational State Transfer）是一种针对网络应用的设计和开发方式，可以降低开发的复杂性，提高系统的可伸缩性。REST提出了一些设计概念和准则： (restful协议)

a. 网络上的所有事物都被抽象为资源（resource）；

b. 每个资源对应一个唯一的资源标识（resource identifier）；

c. 通过通用的连接器接口（generic connector interface）对资源进行操作；

d. 对资源的各种操作不会改变资源标识；

e. 所有的操作都是无状态（stateless）。（忘了转哪里的了）

六、小知识点

1. python中的new-style class要求继承Python中的一个内建类型，一般继承object，也可以继承list或者dict等其他的内建类型。

2. 在Python3X的版本，使用__str__的方法来表示字符串格式化，而在Python2X的版本中采用__unicode__的方法来实现字符串的格式化。

3. python中也有类似于数据库中的四舍五入（round()）和四舍五不入（trancate()）用法，对一个小数只取整数部分，而不做四舍五入的用法是直接对这个小数使用int方法，对一个小数四舍五入则使用内置方法round()方法，用法跟数据库中的一样

###

num = 12.8825

print(int(num)) #12

print(round(num)) #13 默认四舍五入的取整

print(round(num,2)) #12.88

print(round(num,3)) #12.883

print(round(num,5)) #12.8825 超出小数中位数则不做任何处理

print(round(num,-1)) #10.0

print(round(num,-3)) #0.0

4. 元组的使用，可以省去括号 比如：tup = "django",22,[1,2,3] 取索引 tup[1] # 22 一般不这样写，不太友好

5. 字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。

6. 关于python中~取反操作符的使用

首先我们知道3的二进制用8bit表示为 0000 0011 那么对这个数进行二进制取反得到 1111 1100 这点来说应该不会有什么理解上的问题。但是到这里，如果已经忘记或者不知道负数在计算机中是以补码形式表示的盆友(比如我这个菜🐔)就会疑惑了 1111 1100 并不是-4啊？？？怎么回事。

现在计算机普遍使用补码表示负数，所以现在问题变成了 一个数x的补码等于1111 1100 我们要求这个x。

知道一个数的补码 要求其值的方法是 首先看符号位也就是最左的一位，如果是1代表是负数(-)如果是0代码是正数(+)，然后对该值取反+1得到其源码

1111 1100 取反 0000 0011 ＋ 1 ＝ 0000 0100 加上符号- 0000 0100 = -4

总结：取反操作的结果： -（原数据+1） 原数据加一取符号 不论正负数

7. 流的概念：

计算机中的流：通常来说计算机所说的流是指stream,往往是对一种有序连续具有方向性的数据（其单位可以是bit,byte,packet）的抽象描述

8. CRUD与ACID

crud是指在做计算处理时的增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词的首字母简写。crud主要被用在描述软件系统中数据库或者持久层的基本操作功能。

ACID，指数据库事务正确执行的四个基本要素的缩写。包含：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）