Python功能模块

fansichao 2021-10-23 16:16:35
Categories: > Tags:

Python2 和 Python3 并存

Python3 安装配置

参考链接:
https://www.cnblogs.com/gaoyuechen/p/8006365.html

安装完成后自带 pip 等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 下载包
wget https://www.python.org/ftp/python/3.6.0/Python-3.6.0.tgz
# 解压
tar xf Python-3.6.0.tgz
# 配置安装信息
./configure --prefix=/usr/local/python3/
# 编译
make && make install
# 配置环境变量
新建文件
vim /etc/profile.d/python3.sh
export PATH=$PATH:/usr/local/python3/bin/
执行一下下面命令
export PATH=$PATH:/usr/local/python3/bin/
# 验证
python3
Python 3.6.0 (default, Feb 1 2017, 14:56:52)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-11)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

pip3 安装配置

env3 安装配置

判断数据类型

第一种:types
import types
type(x) is types.IntType # 判断是否 int 类型
type(x) is types.StringType # 判断是否 string 类型

第二种: 超级恶心的模式,不推荐
type(x) == type(1) # 判断是否 int 类型
type(x) == type(“1”) # 判断是否 string 类型

第三种: isinstance
isinstance(对象,类型名或类型列表或元祖) –> True/False
例如:isinstance(“lst”,(int,str,list)) # True
判断类型 “lst” 在 类型列表中

Python 代码建议

1
2
3
4
from .. import
优先使用import a 使用a.B
有节制使用from a import B
避免使用 from a import *

Python -m xxx.py -m 使得一个模块像脚本一样运行
name
package

Python 的* __ xx的区别
①*函数名 意味着,此函数用于类内部,不属于 api ,等同于私有函数
函数名 ,用来避免子类覆盖其内容,意味着此函数不能被重写,继承等。仅仅用于类的内部使用,
xx函数,用于 Python 调用
使用_one_underline 来表示该方法或属性是私有的,不属于 API;
当创建一个用于 python 调用或一些特殊情况时,使用
two_underline
使用
just_to_underlines,来避免子类的重写!

使用 join 连接字符 ,join 连接字符更高高效比+ ,尤其是大规模的字符串连接
join 使用:
‘xx’.join([str1,str2]) = str1xxstr2
‘xx’.join([str1,str2,str3]) = str1xxstr2xxstr3

时间测试,代码的性能分析
import timeit

生成测试所需的字符数组

格式化字符串优先使用.format,而不是%s 等

.format 的使用方法 1.位置符号
“ select _ from {0} where 1=1 {2} “.format(xx,yy) 2.使用名称
“ select _ from {xx} where 1=1 {yy} “.format(xx=1,yy=1) 3.同过属性
xx = 1
yy = 2
“ select * from {xx} where 1=1 {yy} “.format 4.格式化元组的具体项
point = (1,3)
‘x:{0[0]}; y:{0[1]}’.format(point)
.format 的优势
使用灵活,可以作为参数传递,简便直观,%s 处理需要注意被格式化字符的格式而。format 不需要

通过字符串调用对象属性

python 通过字符串调用对象属性或方法的实例讲解
有时候需要将属性或方法作为参数传入,这个时候可以通过以下几种方式用字符串调用对象属性或方法

1
2
3
4
5
6
7
8
9
10
11
12
1.eval
In [634]: def getmethod(x,char='just for test'):
...: return eval('str.%s' % x)(char)
...:
In [635]: getmethod('upper')
Out[635]: 'JUST FOR TEST'
2getattr
In [650]: def getmethod2(x, char='just for test'):
...: return getattr(char, x)()
...:
In [651]: getmethod2('upper')
Out[651]: 'JUST FOR TEST'

uuid [唯一标识符]

UUID: 通用唯一标识符 ( Universally Unique Identifier ),对于所有的 UUID 它可以保证在空间和时间上的唯一性.

它是通过 MAC 地址、 时间戳、 命名空间、 随机数、 伪随机数来保证生成 ID 的唯一性,,有着固定的大小( 128 bit 位 ),通常由 32 字节的字符串(十六进制)表示。

它的唯一性和一致性特点,使得可以无需注册过程就能够产生一个新的 UUID;
UUID 可以被用作多种用途, 既可以用来短时间内标记一个对象,也可以可靠的辨别网络中的持久性对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
import uuid
# uuid.uuid1 基于时间戳
uuid.uuid1([node[, clock_seq]])
node - 默认主机的硬件地址
clock_seq 默认随机14位序列号
# uuid.uuid3 基于名字的MD5散列值
通过计算名字和命名空间的MD5散列值得到,保证了同一命名空间中不同名字的唯一性,
和不同命名空间的唯一性,但同一命名空间的同一名字生成相同的uuid。
uuid.uuid3(namespace, name)
# uuid.uuid4 基于随机数
由伪随机数得到,有一定重复概率,可以计算得到
# uuid.uuid5() 基于名称的SHA-1散列值
使用 Secure Hash Algorithm 1 算法

总结:

文字处理

Levenshtein 文字距离

import Levenshtein
str1 = ‘qwer1235’
str2 = ‘qwe1235r’

计算汉明距离,要求 str1 和 str2 必须长度一致。是描述两个等长字串之间对应位置上不同字符的个数
Levenshtein.hamming(str1, str2) #

Levenshtein.distance(str1,str2)计算编辑距离。是描述一个字符串转化成另一个字串最少的操作次数,在其中的操作包括插入、删除、替换。
Levenshtein.distance(str1, str2)

HTTP url转义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
         空格 用%20代替
" 用%22代替
# 用%23代替
% 用%25代替
&用%26代替
( 用%28代替
) 用%29代替
+ 用%2B代替
, 用%2C代替
/ 用%2F代替
: 用%3A代替
; 用%3B代替
< 用%3C代替
= 用%3D代替
> 用%3E代替
? 用%3F代替
@ 用%40代替
\ 用%5C代替
| 用%7C代替


%E6%B2%B3%E6%BA%90

python中关于url中特殊字符的编码和解码
原创瞌睡的猫猫 最后发布于2018-06-07 18:44:25 阅读数 5627 收藏
展开
编码

from urllib.parse import quote
text = quote(text, 'utf-8')
1
2
解码

from urllib.parse import unquote
text = unquote(text, 'utf-8')
1
2
假如url = “https://www.baidu.com"一个Ajax请求,url的字符”:”,”/”等需要转码才能传递
那么就需要编码,代码如下

from urllib.parse import quote
url = "https://www.baidu.com/"
url_encode = quote(url, 'utf-8')
print(url_encode)
1
2
3
4
反之,则为解码
我们在解析网页中可能需要把一些特定的url解码出来以便直观显示等
代码如下:

from urllib.parse import unquote
href= "https%3A%2F%2Fwww.baidu.com%2F"
url_encode = unquote(href, 'utf-8')
print(url_encode)
1
2
3
4
输出结果


Python2中,对url解码 可以这样做:
>>> print urllib.unquote("%E6%B5%8B%E8%AF%95abc")



python3取消unquote属性

可以这样做:

import urllib.parse

print(urllib.parse.unquote("%E6%B5%8B%E8%AF%95abc"))



Python功能模块

Python2 和 Python3 并存

Python3 安装配置

参考链接:
https://www.cnblogs.com/gaoyuechen/p/8006365.html

安装完成后自带 pip 等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 下载包
wget https://www.python.org/ftp/python/3.6.0/Python-3.6.0.tgz
# 解压
tar xf Python-3.6.0.tgz
# 配置安装信息
./configure --prefix=/usr/local/python3/
# 编译
make && make install
# 配置环境变量
新建文件
vim /etc/profile.d/python3.sh
export PATH=$PATH:/usr/local/python3/bin/
执行一下下面命令
export PATH=$PATH:/usr/local/python3/bin/
# 验证
python3
Python 3.6.0 (default, Feb 1 2017, 14:56:52)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-11)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

pip3 安装配置

env3 安装配置

判断数据类型

第一种:types
import types
type(x) is types.IntType # 判断是否 int 类型
type(x) is types.StringType # 判断是否 string 类型

第二种: 超级恶心的模式,不推荐
type(x) == type(1) # 判断是否 int 类型
type(x) == type(“1”) # 判断是否 string 类型

第三种: isinstance
isinstance(对象,类型名或类型列表或元祖) –> True/False
例如:isinstance(“lst”,(int,str,list)) # True
判断类型 “lst” 在 类型列表中

Python 代码建议

1
2
3
4
from .. import
优先使用import a 使用a.B
有节制使用from a import B
避免使用 from a import *

Python -m xxx.py -m 使得一个模块像脚本一样运行
name
package

Python 的* __ xx的区别
①*函数名 意味着,此函数用于类内部,不属于 api ,等同于私有函数
函数名 ,用来避免子类覆盖其内容,意味着此函数不能被重写,继承等。仅仅用于类的内部使用,
xx函数,用于 Python 调用
使用_one_underline 来表示该方法或属性是私有的,不属于 API;
当创建一个用于 python 调用或一些特殊情况时,使用
two_underline
使用
just_to_underlines,来避免子类的重写!

使用 join 连接字符 ,join 连接字符更高高效比+ ,尤其是大规模的字符串连接
join 使用:
‘xx’.join([str1,str2]) = str1xxstr2
‘xx’.join([str1,str2,str3]) = str1xxstr2xxstr3

时间测试,代码的性能分析
import timeit

生成测试所需的字符数组

格式化字符串优先使用.format,而不是%s 等

.format 的使用方法 1.位置符号
“ select _ from {0} where 1=1 {2} “.format(xx,yy) 2.使用名称
“ select _ from {xx} where 1=1 {yy} “.format(xx=1,yy=1) 3.同过属性
xx = 1
yy = 2
“ select * from {xx} where 1=1 {yy} “.format 4.格式化元组的具体项
point = (1,3)
‘x:{0[0]}; y:{0[1]}’.format(point)
.format 的优势
使用灵活,可以作为参数传递,简便直观,%s 处理需要注意被格式化字符的格式而。format 不需要

通过字符串调用对象属性

python 通过字符串调用对象属性或方法的实例讲解
有时候需要将属性或方法作为参数传入,这个时候可以通过以下几种方式用字符串调用对象属性或方法

1
2
3
4
5
6
7
8
9
10
11
12
1.eval
In [634]: def getmethod(x,char='just for test'):
...: return eval('str.%s' % x)(char)
...:
In [635]: getmethod('upper')
Out[635]: 'JUST FOR TEST'
2getattr
In [650]: def getmethod2(x, char='just for test'):
...: return getattr(char, x)()
...:
In [651]: getmethod2('upper')
Out[651]: 'JUST FOR TEST'

获取目录下所有文件名称

1
2
3
4
5
6
7
8
file_dir = "sss"
for root, dirs, files in os.walk(file_dir):
print(root) #当前目录路径
print(dirs) #当前路径下所有子目录
print(files) #当前路径下所有非目录子文件
for filename in files:
file_path = os.path.join(file_dir,filename)
print file_path

uuid [唯一标识符]

UUID: 通用唯一标识符 ( Universally Unique Identifier ),对于所有的 UUID 它可以保证在空间和时间上的唯一性.

它是通过 MAC 地址、 时间戳、 命名空间、 随机数、 伪随机数来保证生成 ID 的唯一性,,有着固定的大小( 128 bit 位 ),通常由 32 字节的字符串(十六进制)表示。

它的唯一性和一致性特点,使得可以无需注册过程就能够产生一个新的 UUID;
UUID 可以被用作多种用途, 既可以用来短时间内标记一个对象,也可以可靠的辨别网络中的持久性对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
import uuid
# uuid.uuid1 基于时间戳
uuid.uuid1([node[, clock_seq]])
node - 默认主机的硬件地址
clock_seq 默认随机14位序列号
# uuid.uuid3 基于名字的MD5散列值
通过计算名字和命名空间的MD5散列值得到,保证了同一命名空间中不同名字的唯一性,
和不同命名空间的唯一性,但同一命名空间的同一名字生成相同的uuid。
uuid.uuid3(namespace, name)
# uuid.uuid4 基于随机数
由伪随机数得到,有一定重复概率,可以计算得到
# uuid.uuid5() 基于名称的SHA-1散列值
使用 Secure Hash Algorithm 1 算法

总结:

文字处理

Levenshtein 文字距离

import Levenshtein
str1 = ‘qwer1235’
str2 = ‘qwe1235r’

计算汉明距离,要求 str1 和 str2 必须长度一致。是描述两个等长字串之间对应位置上不同字符的个数
Levenshtein.hamming(str1, str2) #

Levenshtein.distance(str1,str2)计算编辑距离。是描述一个字符串转化成另一个字串最少的操作次数,在其中的操作包括插入、删除、替换。
Levenshtein.distance(str1, str2)

HTTP url转义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
         空格 用%20代替
" 用%22代替
# 用%23代替
% 用%25代替
&用%26代替
( 用%28代替
) 用%29代替
+ 用%2B代替
, 用%2C代替
/ 用%2F代替
: 用%3A代替
; 用%3B代替
< 用%3C代替
= 用%3D代替
> 用%3E代替
? 用%3F代替
@ 用%40代替
\ 用%5C代替
| 用%7C代替


%E6%B2%B3%E6%BA%90

python中关于url中特殊字符的编码和解码
原创瞌睡的猫猫 最后发布于2018-06-07 18:44:25 阅读数 5627 收藏
展开
编码

from urllib.parse import quote
text = quote(text, 'utf-8')
1
2
解码

from urllib.parse import unquote
text = unquote(text, 'utf-8')
1
2
假如url = “https://www.baidu.com"一个Ajax请求,url的字符”:”,”/”等需要转码才能传递
那么就需要编码,代码如下

from urllib.parse import quote
url = "https://www.baidu.com/"
url_encode = quote(url, 'utf-8')
print(url_encode)
1
2
3
4
反之,则为解码
我们在解析网页中可能需要把一些特定的url解码出来以便直观显示等
代码如下:

from urllib.parse import unquote
href= "https%3A%2F%2Fwww.baidu.com%2F"
url_encode = unquote(href, 'utf-8')
print(url_encode)
1
2
3
4
输出结果

https://www.baidu.com/
————————————————
版权声明:本文为CSDN博主「瞌睡的猫猫」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/sinat_35886587/article/details/80613618




Python2中,对url解码 可以这样做:
>>> print urllib.unquote("%E6%B5%8B%E8%AF%95abc")





python3取消unquote属性

可以这样做:

import urllib.parse

print(urllib.parse.unquote("%E6%B5%8B%E8%AF%95abc"))




title: Python-进阶知识点tips
url_path: python/advance/tips
tags:


autoauto - [Python2 和 Python3 并存](#python2-和-python3-并存)auto - [Python3 安装配置](#python3-安装配置)auto - [pip3 安装配置](#pip3-安装配置)auto - [env3 安装配置](#env3-安装配置)auto - [判断数据类型](#判断数据类型)auto - [Python 代码建议](#python-代码建议)auto - [生成测试所需的字符数组](#生成测试所需的字符数组)auto - [通过字符串调用对象属性](#通过字符串调用对象属性)auto - [uuid [唯一标识符]](#uuid-唯一标识符)auto - [文字处理](#文字处理)auto - [Levenshtein 文字距离](#levenshtein-文字距离)auto - [HTTP `url转义`](#http-url转义)auto- [Python功能模块](#python功能模块)auto - [Python2 和 Python3 并存](#python2-和-python3-并存-1)auto - [Python3 安装配置](#python3-安装配置-1)auto - [pip3 安装配置](#pip3-安装配置-1)auto - [env3 安装配置](#env3-安装配置-1)auto - [判断数据类型](#判断数据类型-1)auto - [Python 代码建议](#python-代码建议-1)auto - [生成测试所需的字符数组](#生成测试所需的字符数组-1)auto - [通过字符串调用对象属性](#通过字符串调用对象属性-1)auto - [获取目录下所有文件名称](#获取目录下所有文件名称)auto - [uuid [唯一标识符]](#uuid-唯一标识符-1)auto - [文字处理](#文字处理-1)auto - [Levenshtein 文字距离](#levenshtein-文字距离-1)auto - [HTTP `url转义`](#http-url转义-1)auto - [魔法函数](#魔法函数)auto - [高级特性/语法糖](#高级特性语法糖)auto - [进阶知识点](#进阶知识点)auto - [函数式编程](#函数式编程)auto - [高阶函数](#高阶函数)auto - [匿名函数](#匿名函数)auto - [闭包](#闭包)auto - [python 循环中不包含域的概念](#python-循环中不包含域的概念)auto - [装饰器](#装饰器)auto - [偏函数](#偏函数)auto - [模块和包的概念](#模块和包的概念)auto - [Python 面向对象编程](#python-面向对象编程)auto - [类属性](#类属性)auto - [实例方法](#实例方法)auto - [类方法](#类方法)auto - [类的继承](#类的继承)auto - [判断类型](#判断类型)auto - [多态](#多态)auto - [多重继承](#多重继承)auto - [获取对象信息](#获取对象信息)auto - [特殊方法](#特殊方法)auto - [动态获取函数变量等](#动态获取函数变量等)auto - [小知识点 Tips](#小知识点-tips)auto - [打包与解包](#打包与解包)auto - [json 序列化](#json-序列化)auto - [`_xxx`,`__xxx`和`__xxx__`的区别](#_xxx__xxx和__xxx__的区别)auto - [其他知识](#其他知识)auto - [参考资源](#参考资源)autoauto

魔法函数

高级特性/语法糖

Python 高级特性,对于 Python 知识上限和优雅高效代码所必需的,是 Python 程序员从初级到高级不可缺少的知识历程。

进阶知识点

函数式编程

Python 支持的函数式编程

支持函数式编程,函数式编程的特点
@偏向于计算,而非指令,把计算视为函数而非指令
@不需要变量,无副作用,测试简单
@支持高阶函数,代码简洁

python 函数式编程的特点:
@不是纯函数式编程,可以有变量
@支持高阶函数,允许函数作为变量传入
@允许闭包,有了闭包就有返回函数
@有限度的支持匿名函数

高阶函数

@变量可以指向函数
@函数的参数可以接收变量
@一个函数可以接收另一个函数作为参数
@能接收函数作参数就是高阶参数

能接收函数作参数的函数就是高阶函数

常见的高阶函数

TODO 所有高阶函数清单,部分用法等

1
2
3
4
5
6
7
8
9
10
11
12
#map函数,对单个参数进行处理
L = list(range(10))
print(list(map(lambda x : x*x, L)))

#在Python 3里,reduce()函数已经被从全局名字空间里移除了,它现在被放置在fucntools模块里用的话要 先引入:对两个参数进行处理
from functools import reduce
print (reduce(lambda x,y: x-y, [1,2,3,4,5]))

#filter()函数:过滤函数,返回符合条件的新的列表
def is_odd(x):
return x % 2 == 1
filter(is_odd, [1, 4, 6, 7, 9, 12, 17])

匿名函数

@高阶函数可以接收函数做参数,有些时候,我们不需要显式地定义函数,直接传入匿名函数更方便

1
lambda x: x * 2

闭包

Python 的函数不但可以返回 int,str,list,dict 等数据类型,还可以返回函数

Python 中闭包,在函数内部定义的函数和外部定义的函数式一样的,只是无法被外部访问,如果有被定义在外函数内部的情况,并且内层函数引用了外层函数的参数,然后返回内层函数的情况,我们称为闭包.

闭包的特点是返回的函数还引用了外层函数的局部变量,所以要正确地使用闭包,就要确保引用的局部变量在函数返回后不能变.

闭包概念:在一个内部函数中,对外部作用域的变量进行引用,(并且一般外部函数的返回值为内部函数),那么内部函数就被认为是闭包

Python 闭包,类似于 子函数

python 循环中不包含域的概念

1
2
3
4
5
6
7
8
9
10
11
12
13
# python循环中不包含域的概念
func_lis = []
for i in range(4):
def func(x):
return x*i
func_lis.append(func)
for f in func_lis:
print(f(2))
# 6
# 6
# 6
# 6
loop在python中是没有域的概念的,flist在像列表中添加func的时候,并没有保存i的值,而是当执行f(2)的时候才去取,这时候循环已经结束,i的值是3,所以结果都是6

装饰器

Python 内置的@语法就是为了简化装饰器调用

偏函数

函数在执行时,要带上所有必要的参数进行调用。但是,有时参数可以在函数被调用之前提前获知。这种情况下,一个函数有一个或多个参数预先就能用上,以便函数能用更少的参数进行调用。

偏函数是将所要承载的函数作为 partial()函数的第一个参数,原函数的各个参数依次作为 partial()函数后续的参数,除非使用关键字参数。

1
2
3
4
5
6
7
8
9
from functools import partial

def mod( n, m ):
return n % m

mod_by_100 = partial( mod, 100 )

print mod( 100, 7 ) # 2
print mod_by_100( 7 ) # 2

模块和包的概念

包就是文件夹,模块名就是.py

包下面有个init.py 这样 python 才会当做包来处理

Python 面向对象编程

TODO

面向对象编程是一种程序设计范式

把程序看做不同对象的相互调用

对现实世界建立对象模型

基本思想

类用于定义抽象类型

实例根据类的定义被创建出来

最重要的思想:数据封装

由于 Python 是动态语言,对每一个实例,都可以直接给他们的属性赋值

可以给一个实例绑定很多属性,如果不希望被外部访问到,可以用双下划线开头,该属性就无法被外部访问.但是如果一个属性以 xxx的形式定义,则又可以被外部访问了,以xxx定义的属性在 python 的类中被称为特殊属性,有很多预定义的特殊属性可以使用,通常不把普通属性用xxx__定义

类属性

类里面属性分为 类属性(独有一份)和实例属性(每个实例都会有一份)。

当实例属性和类属性重名时,实例属性优先级高,它将屏蔽掉对类属性的访问。不要在实例上修改类属性,它实际上并没有修改类属性,而是给实例绑定了一个实例属性

实例方法

实例的方法就是在类中定义的函数,它的第一个参数永远是 self,指向调用该方法的实例本身,其他参数和一个普通函数是完全一样的:在实例方法内部,可以访问所有实例属性,这样,如果外部需要访问私有属性,可以通过方法调用获得,这种数据封装的形式除了能保护内部数据一致性外,还可以简化外部调用的难度。

在 class 中定义的实例方法其实也是属性,实际上是一个函数对象,因为方法也是一个属性,所以它也可以动态地添加到实例上,只是需要用 type.MethodType()把一个函数变为一个方法

类方法

和属性类似,方法也分实例方法和类方法.在 class 中定义的全部是实例方法,实例方法第一个参数 self 是实例本身.通过标记@classmethod 该方法将绑定到类上,而非类的实例上,该方法的第一个参数将传入类本身,通常将参数名命名为 cls,因为是在类上调用,而非实例上调用,因此类方法无法获取任何实例变量,只能获得类的引用

1
2
3
4
5
6
# @classmethod 指定类方法
class Person(object):
count = 0
@classmethod
def how_many(cls):
return cls.count

类的继承

子类和父类是 is 关系,总是从某各类继承 如果没有合适的就从 object 继承,不能忘记调用 super().init

如果已经定义了 Person 类,需要定义新的 Student 和 Teacher 类时,可以直接从 Person 类继承:

1
2
3
4
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender

定义 Student 类时,只需要把额外的属性加上,例如 score:

1
2
3
4
class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score

一定要用 super(Student, self).__init__(name, gender) 去初始化父类,否则,继承自 Person 的 Student 将没有 name 和 gender。

函数super(Student, self)将返回当前类继承的父类,即 Person ,然后调用__init__()方法,注意 self 参数已在 super()中传入,在__init__()中将隐式传递,不需要写出(也不能写)。

判断类型

判断数据类型

1
isinstance("ss", (str,list) )

TODO 判断实例类似等等

继承链上,一个父类的实例不能是子类类型,因为子类比父类多了一些属性和方法,一个实例可以看成它本身的类型,也可以看成它父类的类型。

多态

TODO

多重继承

获取对象信息

isinstance()判断是否是某种类型的实例外

type()函数获取变量的类型,返回一个 Type 对象

dir()函数获取变量的所有属性

getattr()获取属性值

setattr()设置属性值

特殊方法

又名魔法方法、魔法函数等等

详见 博客内文章 Python 魔法函数

动态获取函数变量等

动态获取当前运行的函数名

1
2
3
4
5
6
7
8
9
# 在函数外部时,获取函数名称
func.__name__

# 在函数内部时,获取函数名称
sys._getframe().f_code.co_name

# 在类内部时,获取类名称
self.__class__.name

inspect模块 动态获取当前运行的函数名称

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# coding:utf-8
import inspect

def get__function_name():
    '''获取正在运行函数(或方法)名称'''
    return inspect.stack()[1][3]

def yoyo():
    print("函数名称:%s"%get__function_name())

class Yoyo():
    def yoyoketang(self):
        '''# 上海-悠悠 QQ群:588402570'''
        print("获取当前类名称.方法名:%s.%s" % (self.__class__.__name__, get__function_name()))

if __name__ == "__main__":
    yoyo()
    Yoyo().yoyoketang()

# 运行结果:
函数名称:yoyo
获取当前类名称.方法名:Yoyo.yoyoketang

动态创建函数

小知识点 Tips

打包与解包

1
2
3
x, y ,*z = list(range(0,10))

zip([[1,2],[2,3]])

json 序列化

1
2
3
4

json.loads()
json.dumps()

_xxx,__xxx__xxx__的区别

(1)单下划线 _xxx

“单下划线”开始的成员函数和成员变量都是公开的(public)(但是约定俗成以此开头来设计私有函数/变量,尽管其是 public,理解,即只是标明,标记)。即类实例和子类实例都可以访问此中变量,但是需通过类提供的接口进行访问,不能用from xxx import *导入

(2)双下划线 __xxx

从表象上看可以当做类中的私有变量/方法名,表示私有成员,即只有类对象自己才能访问,其自身的类实例或是其子类也不能访问。

Python 设计此的真正目的仅仅是为了避免子类覆盖父类的方法。

(3)__xxx__

系统定义名字,前后均有一个”双下划线”是代表 python 里特殊方法专用的表示,如init()代表类的构造函数

类的下划线命令区别

其他知识

map

filter

reduce

__solts__ 来给定固定集合的属性分配空间,适合固定少属性的类,可以大量减少内存消耗

1
2
3
4
5
6
7
8
9
10
11
# Python默认采用字典来保存类的实例属性,但对于小类来说,会浪费内存空间
# 可以使用 __solts__ 来给定固定集合的属性分配空间,不采用字典,可以减少约50%的内存消耗

class MyClass(object):
__solts__ = ['name', 'cert']
def __init__(self, name=None, cert=None):
self.name = name
self.crt = cert

# 监测内存使用
https://github.com/ianozsvald/ipython_memory_usage

collections 容器模块

1
2
3
4
5
6
defaultdict
counter
deque
namedtuple
enum.Enum

inspect 获取活跃对象的信息

1
2
3
4
5
6
7
8
9
10
11
12
13
# for .. else 语句 用于捕获for循环是正常结束还是break跳出
# else 在循环正常结束时调用,break跳出循环时不会调用。

test_num = 5
for n in range(0,10):
if n == test_num:
print('>>> 11')
break
else:
print('>>> 22')

# test_num = 5 时,break跳出循环 打印 11
# test_num = 20 时,循环解除,打印 22

协程 - yield

1
2
3
4
5
6
7
8
9
10
11
12
13
14

函数缓存,将一个函数的返回值快速的缓存或取消缓存。
适用于 IO密集型的函数 频繁使用相同参数调用时,可以节省大量时间。

from functools import lru_cache

# maxsize 最多缓存最近多少个返回值
@lru_cache(maxsize=22)
def fib(n):
if n < 2:
return n
return fib(n-1) + fib(n-2)
print([fib(n) for n in range(100)])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# 上下文管理器

# 方式1 with语句 例如 with open
# 方式2 使用类来做上下文管理器
# 方式3 基于生成器来实现

# with open 方式
with open('aa.csv', 'wb') as file_obj:
file_obj.write(b'demo')


# Python 3.7.4
# 类方式
class File(object):

def __init__(self, file_name, method):
self.file_obj = open(file_name, method)

def __enter__(self):
return self.file_obj

def __exit__(self, type, value, traceback):
if value is not None:
print(type)
print(value)
self.file_obj.close()
return True

with File('a.csv', 'wb') as file_obj:
file_obj.write(b'demo')

# 生成器方式
from contextlib import contextmanager
@contextmanager
def open_file(name, method):
f = open(name, method)
yield f
f.close

参考资源


title: Python常用基础命令
url_path: python/base/常用命令
tags:


获取 os.system(cmd)的执行结果

1
2
3
4
5
6
7
8
9
由于os.system是没有返回值的,获取返回值有以下三种方式:
1.使用commands内置模块
import commands
resp = commands.getoutput("hostname")
2.使用os.popen获取返回值
resp = os.popen('ps -ef | grep sssss').readlines()
3.使用subprocess内置模块
from subprocess import Popen,PIPE
resp = Popen("ps -ef | grep sssss",shell=True,stdout=PIPE,stderr=PIPE).stdout.readlines()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# python3
>>> import time
>>> for x in range(10):
... time.sleep(1)
... print("Progress {:2.1%}".format(x / 10), end="\r")
# 下列三行信息输出在同一行
Progress 30.0%
Progress 50.0%
>>> ress 90.0%
# python2
import time
import sys
for x in range(5):
time.sleep(1)
msg = ">>>> %s\r"%str(x)
sys.stdout.write(msg)
sys.stdout.flush()

python 文件传入 参数

1
2
3
4
#! /bin/python
import sys
for arg in sys.argv:
print arg

Python 生成 md5

1
2
3
4
5
6
7
import md5
src = 'this is a md5 test.'
m1 = md5.new()
m1.update(src)
print m1.hexdigest()


Excel 处理

在用 xlrd.open_workbook 时,添加对应的参数 formatting_info=True,就可以保留原有格式了

python 通过字符串调用对象属性或方法的实例讲解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# eval
def getmethod(x,char='just for test'):
return eval('str.%s' % x)(char)
In [635]: getmethod('upper')
Out[635]: 'JUST FOR TEST'
# getattr
In [650]: def getmethod2(x, char='just for test'):...:
return getattr(char, x)()...:
In [651]: getmethod2('upper')
Out[651]: 'JUST FOR TEST'
# 利用内置库operator
In [648]: def getmethod3(x, char='just for test'):...:
return operator.methodcaller(x, char)(str)...:
In [649]: getmethod3('upper')
Out[649]: 'JUST FOR TEST'

使用 traceback 获取栈信息

traceback.print_exc()
获取详细的程序异常信息。
程序运行异常时会输出完整的栈信息,包括调用顺序、异常发生的语句、错误类型等。
import tarceback

try:
f()
except IndexError as ex:
print “程序异常”
print ex
print traceback.print_exc()#1.错误类型(IndexError)、错误对应的值(list index out of range)、具体的 trace 信息(文件名 行号 函数名 对应的代码)

sys.exc_info()

使用 dir 获取模块的方法 dir()

dir(traceback)

美化打印

1
2
3
# Python的美化打印 特别是打印 嵌套字典时非常好用
from prettyprinter import cpprint
cpprint(stats_info_data)

Python-tips 小知识点

tags: 202101


title: Python-进阶知识点 tips
url_path: python/advance/tips
tags:


魔法函数

高级特性/语法糖

Python 高级特性,对于 Python 知识上限和优雅高效代码所必需的,是 Python 程序员从初级到高级不可缺少的知识历程。

进阶知识点

函数式编程

Python 支持的函数式编程

支持函数式编程,函数式编程的特点
@偏向于计算,而非指令,把计算视为函数而非指令
@不需要变量,无副作用,测试简单
@支持高阶函数,代码简洁

python 函数式编程的特点:
@不是纯函数式编程,可以有变量
@支持高阶函数,允许函数作为变量传入
@允许闭包,有了闭包就有返回函数
@有限度的支持匿名函数

高阶函数

@变量可以指向函数
@函数的参数可以接收变量
@一个函数可以接收另一个函数作为参数
@能接收函数作参数就是高阶参数

能接收函数作参数的函数就是高阶函数

常见的高阶函数

TODO 所有高阶函数清单,部分用法等

1
2
3
4
5
6
7
8
9
10
11
12
#map函数,对单个参数进行处理
L = list(range(10))
print(list(map(lambda x : x*x, L)))

#在Python 3里,reduce()函数已经被从全局名字空间里移除了,它现在被放置在fucntools模块里用的话要 先引入:对两个参数进行处理
from functools import reduce
print (reduce(lambda x,y: x-y, [1,2,3,4,5]))

#filter()函数:过滤函数,返回符合条件的新的列表
def is_odd(x):
return x % 2 == 1
filter(is_odd, [1, 4, 6, 7, 9, 12, 17])

匿名函数

@高阶函数可以接收函数做参数,有些时候,我们不需要显式地定义函数,直接传入匿名函数更方便

1
lambda x: x * 2

闭包

Python 的函数不但可以返回 int,str,list,dict 等数据类型,还可以返回函数

Python 中闭包,在函数内部定义的函数和外部定义的函数式一样的,只是无法被外部访问,如果有被定义在外函数内部的情况,并且内层函数引用了外层函数的参数,然后返回内层函数的情况,我们称为闭包.

闭包的特点是返回的函数还引用了外层函数的局部变量,所以要正确地使用闭包,就要确保引用的局部变量在函数返回后不能变.

闭包概念:在一个内部函数中,对外部作用域的变量进行引用,(并且一般外部函数的返回值为内部函数),那么内部函数就被认为是闭包

Python 闭包,类似于 子函数

python 循环中不包含域的概念

1
2
3
4
5
6
7
8
9
10
11
12
13
# python循环中不包含域的概念
func_lis = []
for i in range(4):
def func(x):
return x*i
func_lis.append(func)
for f in func_lis:
print(f(2))
# 6
# 6
# 6
# 6
loop在python中是没有域的概念的,flist在像列表中添加func的时候,并没有保存i的值,而是当执行f(2)的时候才去取,这时候循环已经结束,i的值是3,所以结果都是6

装饰器

Python 内置的@语法就是为了简化装饰器调用

偏函数

函数在执行时,要带上所有必要的参数进行调用。但是,有时参数可以在函数被调用之前提前获知。这种情况下,一个函数有一个或多个参数预先就能用上,以便函数能用更少的参数进行调用。

偏函数是将所要承载的函数作为 partial()函数的第一个参数,原函数的各个参数依次作为 partial()函数后续的参数,除非使用关键字参数。

1
2
3
4
5
6
7
8
9
from functools import partial

def mod( n, m ):
return n % m

mod_by_100 = partial( mod, 100 )

print mod( 100, 7 ) # 2
print mod_by_100( 7 ) # 2

模块和包的概念

包就是文件夹,模块名就是.py

包下面有个init.py 这样 python 才会当做包来处理

Python 面向对象编程

TODO

面向对象编程是一种程序设计范式

把程序看做不同对象的相互调用

对现实世界建立对象模型

基本思想

类用于定义抽象类型

实例根据类的定义被创建出来

最重要的思想:数据封装

由于 Python 是动态语言,对每一个实例,都可以直接给他们的属性赋值

可以给一个实例绑定很多属性,如果不希望被外部访问到,可以用双下划线开头,该属性就无法被外部访问.但是如果一个属性以 xxx的形式定义,则又可以被外部访问了,以xxx定义的属性在 python 的类中被称为特殊属性,有很多预定义的特殊属性可以使用,通常不把普通属性用xxx__定义

类属性

类里面属性分为 类属性(独有一份)和实例属性(每个实例都会有一份)。

当实例属性和类属性重名时,实例属性优先级高,它将屏蔽掉对类属性的访问。不要在实例上修改类属性,它实际上并没有修改类属性,而是给实例绑定了一个实例属性

实例方法

实例的方法就是在类中定义的函数,它的第一个参数永远是 self,指向调用该方法的实例本身,其他参数和一个普通函数是完全一样的:在实例方法内部,可以访问所有实例属性,这样,如果外部需要访问私有属性,可以通过方法调用获得,这种数据封装的形式除了能保护内部数据一致性外,还可以简化外部调用的难度。

在 class 中定义的实例方法其实也是属性,实际上是一个函数对象,因为方法也是一个属性,所以它也可以动态地添加到实例上,只是需要用 type.MethodType()把一个函数变为一个方法

类方法

和属性类似,方法也分实例方法和类方法.在 class 中定义的全部是实例方法,实例方法第一个参数 self 是实例本身.通过标记@classmethod 该方法将绑定到类上,而非类的实例上,该方法的第一个参数将传入类本身,通常将参数名命名为 cls,因为是在类上调用,而非实例上调用,因此类方法无法获取任何实例变量,只能获得类的引用

1
2
3
4
5
6
# @classmethod 指定类方法
class Person(object):
count = 0
@classmethod
def how_many(cls):
return cls.count

类的继承

子类和父类是 is 关系,总是从某各类继承 如果没有合适的就从 object 继承,不能忘记调用 super().init

如果已经定义了 Person 类,需要定义新的 Student 和 Teacher 类时,可以直接从 Person 类继承:

1
2
3
4
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender

定义 Student 类时,只需要把额外的属性加上,例如 score:

1
2
3
4
class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score

一定要用 super(Student, self).__init__(name, gender) 去初始化父类,否则,继承自 Person 的 Student 将没有 name 和 gender。

函数super(Student, self)将返回当前类继承的父类,即 Person ,然后调用__init__()方法,注意 self 参数已在 super()中传入,在__init__()中将隐式传递,不需要写出(也不能写)。

判断类型

判断数据类型

1
isinstance("ss", (str,list) )

TODO 判断实例类似等等

继承链上,一个父类的实例不能是子类类型,因为子类比父类多了一些属性和方法,一个实例可以看成它本身的类型,也可以看成它父类的类型。

多态

TODO

多重继承

获取对象信息

isinstance()判断是否是某种类型的实例外

type()函数获取变量的类型,返回一个 Type 对象

dir()函数获取变量的所有属性

getattr()获取属性值

setattr()设置属性值

特殊方法

又名魔法方法、魔法函数等等

详见 博客内文章 Python 魔法函数

动态获取函数变量等

动态获取当前运行的函数名

1
2
3
4
5
6
7
8
9
# 在函数外部时,获取函数名称
func.__name__

# 在函数内部时,获取函数名称
sys._getframe().f_code.co_name

# 在类内部时,获取类名称
self.__class__.name

inspect模块 动态获取当前运行的函数名称

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# coding:utf-8
import inspect

def get__function_name():
    '''获取正在运行函数(或方法)名称'''
    return inspect.stack()[1][3]

def yoyo():
    print("函数名称:%s"%get__function_name())

class Yoyo():
    def yoyoketang(self):
        '''# 上海-悠悠 QQ群:588402570'''
        print("获取当前类名称.方法名:%s.%s" % (self.__class__.__name__, get__function_name()))

if __name__ == "__main__":
    yoyo()
    Yoyo().yoyoketang()

# 运行结果:
函数名称:yoyo
获取当前类名称.方法名:Yoyo.yoyoketang

动态创建函数

小知识点 Tips

打包与解包

1
2
3
x, y ,*z = list(range(0,10))

zip([[1,2],[2,3]])

json 序列化

1
2
3
4

json.loads()
json.dumps()

_xxx,__xxx__xxx__的区别

(1)单下划线 _xxx

“单下划线”开始的成员函数和成员变量都是公开的(public)(但是约定俗成以此开头来设计私有函数/变量,尽管其是 public,理解,即只是标明,标记)。即类实例和子类实例都可以访问此中变量,但是需通过类提供的接口进行访问,不能用from xxx import *导入

(2)双下划线 __xxx

从表象上看可以当做类中的私有变量/方法名,表示私有成员,即只有类对象自己才能访问,其自身的类实例或是其子类也不能访问。

Python 设计此的真正目的仅仅是为了避免子类覆盖父类的方法。

(3)__xxx__

系统定义名字,前后均有一个”双下划线”是代表 python 里特殊方法专用的表示,如init()代表类的构造函数

类的下划线命令区别

其他知识

map

filter

reduce

__solts__ 来给定固定集合的属性分配空间,适合固定少属性的类,可以大量减少内存消耗

1
2
3
4
5
6
7
8
9
10
11
# Python默认采用字典来保存类的实例属性,但对于小类来说,会浪费内存空间
# 可以使用 __solts__ 来给定固定集合的属性分配空间,不采用字典,可以减少约50%的内存消耗

class MyClass(object):
__solts__ = ['name', 'cert']
def __init__(self, name=None, cert=None):
self.name = name
self.crt = cert

# 监测内存使用
https://github.com/ianozsvald/ipython_memory_usage

collections 容器模块

1
2
3
4
5
6
defaultdict
counter
deque
namedtuple
enum.Enum

inspect 获取活跃对象的信息

1
2
3
4
5
6
7
8
9
10
11
12
13
# for .. else 语句 用于捕获for循环是正常结束还是break跳出
# else 在循环正常结束时调用,break跳出循环时不会调用。

test_num = 5
for n in range(0,10):
if n == test_num:
print('>>> 11')
break
else:
print('>>> 22')

# test_num = 5 时,break跳出循环 打印 11
# test_num = 20 时,循环解除,打印 22

协程 - yield

1
2
3
4
5
6
7
8
9
10
11
12
13
14

函数缓存,将一个函数的返回值快速的缓存或取消缓存。
适用于 IO密集型的函数 频繁使用相同参数调用时,可以节省大量时间。

from functools import lru_cache

# maxsize 最多缓存最近多少个返回值
@lru_cache(maxsize=22)
def fib(n):
if n < 2:
return n
return fib(n-1) + fib(n-2)
print([fib(n) for n in range(100)])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# 上下文管理器

# 方式1 with语句 例如 with open
# 方式2 使用类来做上下文管理器
# 方式3 基于生成器来实现

# with open 方式
with open('aa.csv', 'wb') as file_obj:
file_obj.write(b'demo')


# Python 3.7.4
# 类方式
class File(object):

def __init__(self, file_name, method):
self.file_obj = open(file_name, method)

def __enter__(self):
return self.file_obj

def __exit__(self, type, value, traceback):
if value is not None:
print(type)
print(value)
self.file_obj.close()
return True

with File('a.csv', 'wb') as file_obj:
file_obj.write(b'demo')

# 生成器方式
from contextlib import contextmanager
@contextmanager
def open_file(name, method):
f = open(name, method)
yield f
f.close

参考资源

Python 之大坑

环境说明:

Python 之大坑清单:

说明:很多原有Python2.7的 bug 在Python3.8中已经修复了

Python 之坑

不要使用可变对象作为函数默认值

1
2
3
4
5
6
7
8
9
10
11
12
def append(value, arr=[]):
arr.append(value)
return arr

print append(1)
print append(1)
print append(1)

# 返回结果
[1]
[1, 1]
[1, 1, 1]

原因是模块在加载的时候,arr 定义指向了一个空的列表的地址,以后再次调用时,不是我们理解的再给 arr 分配
一个新的空的列表,而是一直指向的同一个地址的列表,如果列表内容变了其引用也跟着变了。定义默认参数要

默认参数必须指向不可变对象!!!

生成器不保留迭代过后的结果

1
2
3
4
5
6
7
gen = (i for i in range(5))
print (1 in gen)
print (1 in gen)

# 运行结果:
True
False

原因是生成器中的值一旦使用过后,就不再保留了。这个是生成器的原理导致的,生成器不像列表,一开始就把值都初始化好了,而是每次用到的时候生成一个。

解决方法:

1
2
3
4
5
6
7
8
gen = (i for i in range(5))
arr = list(gen) # 转成 list 或 tuple
print (1 in arr)
print (1 in arr)

# 运行结果:
True
True

可变对象之坑

原代码样例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import copy
def generate_info(mark, num=3, data=[]):
# data2 = copy.deepcopy(data)
data2 = data
print(f'>> 标记信息 Mark: {mark} num:{num}')
query_data = [{
'mark': mark,
'num': num,
}]
data2.extend(query_data)
if num >= 1:
num = num - 1
data2 = generate_info(mark, num, copy.deepcopy(data2))
return data2

for i in range(0, 2):
tmp_data = generate_info(i, i)
for tmp in tmp_data:
print(tmp)
# 运行结果
>> 标记信息 Mark: 0 num:0
{'mark': 0, 'num': 0}
>> 标记信息 Mark: 1 num:1
>> 标记信息 Mark: 1 num:0
{'mark': 0, 'num': 0}
{'mark': 1, 'num': 1}
{'mark': 1, 'num': 0}

# !!! 异常点
i == 2时,返回值包含了 i==1 的值

修改方案:不要使用可变对象作为函数默认值!!!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import copy
# def generate_info(mark, num=3, data=[]):
def generate_info(mark, num=3, data=None):
data2 = data if data is not None else []
# data2 = copy.deepcopy(data)
# data2 = data
print(f'>> 标记信息 Mark: {mark} num:{num}')
query_data = [{
'mark': mark,
'num': num,
}]
data2.extend(query_data)
if num >= 1:
num = num - 1
data2 = generate_info(mark, num, copy.deepcopy(data2))
return data2

for i in range(0, 2):
tmp_data = generate_info(i, i)
for tmp in tmp_data:
print(tmp)

# 返回结果正常
>> 标记信息 Mark: 0 num:0
{'mark': 0, 'num': 0}
>> 标记信息 Mark: 1 num:1
>> 标记信息 Mark: 1 num:0
{'mark': 1, 'num': 1}
{'mark': 1, 'num': 0}

修改方案:迭代函数中,可变对象需要使用深拷贝赋值!!!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import copy
def generate_info(mark, num=3, data=[]):
data2 = copy.deepcopy(data)
# data2 = data
print(f'>> 标记信息 Mark: {mark} num:{num}')
query_data = [{
'mark': mark,
'num': num,
}]
data2.extend(query_data)
if num >= 1:
num = num - 1
data2 = generate_info(mark, num, copy.deepcopy(data2))
return data2

for i in range(0, 2):
tmp_data = generate_info(i, i)
for tmp in tmp_data:
print(tmp)
# 返回结果正常
>> 标记信息 Mark: 0 num:0
{'mark': 0, 'num': 0}
>> 标记信息 Mark: 1 num:1
>> 标记信息 Mark: 1 num:0
{'mark': 1, 'num': 1}
{'mark': 1, 'num': 0}

is 和 == 的差异

已修复的坑

1
2
3
4
5
6
7
8
9
10
11
# 1. 列表推导式中的对象泄露问题
[i for i in range(0, 10)]
i 对象会存在

# 2. 嵌套列表创建
li = [[]]*3
li[0].append(1)
# [[1], [1], [1]]
# 由于创建了三个指向同一个list的对象,而非三个对象



title: Python常用基础命令
url_path: python/base/常用命令
tags:


获取 os.system(cmd)的执行结果

1
2
3
4
5
6
7
8
9
由于os.system是没有返回值的,获取返回值有以下三种方式:
1.使用commands内置模块
import commands
resp = commands.getoutput("hostname")
2.使用os.popen获取返回值
resp = os.popen('ps -ef | grep sssss').readlines()
3.使用subprocess内置模块
from subprocess import Popen,PIPE
resp = Popen("ps -ef | grep sssss",shell=True,stdout=PIPE,stderr=PIPE).stdout.readlines()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# python3
>>> import time
>>> for x in range(10):
... time.sleep(1)
... print("Progress {:2.1%}".format(x / 10), end="\r")
# 下列三行信息输出在同一行
Progress 30.0%
Progress 50.0%
>>> ress 90.0%
# python2
import time
import sys
for x in range(5):
time.sleep(1)
msg = ">>>> %s\r"%str(x)
sys.stdout.write(msg)
sys.stdout.flush()

python 文件传入 参数

1
2
3
4
#! /bin/python
import sys
for arg in sys.argv:
print arg

Python 生成 md5

1
2
3
4
5
6
7
import md5
src = 'this is a md5 test.'
m1 = md5.new()
m1.update(src)
print m1.hexdigest()


Excel 处理

在用 xlrd.open_workbook 时,添加对应的参数 formatting_info=True,就可以保留原有格式了

python 通过字符串调用对象属性或方法的实例讲解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# eval
def getmethod(x,char='just for test'):
return eval('str.%s' % x)(char)
In [635]: getmethod('upper')
Out[635]: 'JUST FOR TEST'
# getattr
In [650]: def getmethod2(x, char='just for test'):...:
return getattr(char, x)()...:
In [651]: getmethod2('upper')
Out[651]: 'JUST FOR TEST'
# 利用内置库operator
In [648]: def getmethod3(x, char='just for test'):...:
return operator.methodcaller(x, char)(str)...:
In [649]: getmethod3('upper')
Out[649]: 'JUST FOR TEST'

使用 traceback 获取栈信息

traceback.print_exc()
获取详细的程序异常信息。
程序运行异常时会输出完整的栈信息,包括调用顺序、异常发生的语句、错误类型等。
import tarceback

try:
f()
except IndexError as ex:
print “程序异常”
print ex
print traceback.print_exc()#1.错误类型(IndexError)、错误对应的值(list index out of range)、具体的 trace 信息(文件名 行号 函数名 对应的代码)

sys.exc_info()

使用 dir 获取模块的方法 dir()

dir(traceback)

美化打印

1
2
3
# Python的美化打印 特别是打印 嵌套字典时非常好用
from prettyprinter import cpprint
cpprint(stats_info_data)