人生苦短之我用Python篇（深浅拷贝、常用模块、内置函数）

深浅拷贝

有时候，尤其是当你在处理可变对象时，你可能想要复制一个对象，然后对其做出一些改变而不希望影响原来的对象。这就是Python的copy所发挥作用的地方。

• 　　定义了当对你的类的实例调用copy.copy()时所产生的行为。copy.copy()返回了你的对象的一个浅拷贝——这意味着，当实例本身是一个新实例时，它的所有数据都被引用了——例如，当一个对象本身被复制了，它的数据仍然是被引用的（因此，对于浅拷贝中数据的更改仍然可能导致数据在原始对象的中的改变）。

  　　定义了当对你的类的实例调用copy.deepcopy()时所产生的行为。copy.deepcopy()返回了你的对象的一个深拷贝——对象和其数据都被拷贝了。memodict是对之前被拷贝的对象的一个缓存——这优化了拷贝过程并且阻止了对递归数据结构拷贝时的无限递归。当你想要进行对一个单独的属性进行深拷贝时，调用copy.deepcopy()，并以memodict为第一个参数。

 

思路一：利用切片操作和工厂方法list方法拷贝就叫浅拷贝，只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。

思路二：利用copy中的deepcopy方法进行拷贝就叫做深拷贝，外围和内部元素都进行了拷贝对象本身，而不是引用。

但是对于数字，字符串和其他原子类型对象等，没有被拷贝的说法，即便是用深拷贝，查看id的话也是一样的，如果对其重新赋值，也只是新创建一个对象，替换掉旧的而已。

 常用模块

getpass模块

pwd = getpass.getpass("请输入密码：")  #输入密码不可见

yh = getpass.getuser()                #显示当前登录系统用户名;

getpass.getpass([prompt[, stream]])
提示用户输入一段密码，参数 prompt 用于提示用户开始输入，默认为'Password: '。在 Unix 上，该提示符被写入到类文件对象流中。
参数 stream 默认为控制终端 (/dev/tty) 或入过前者不可用时为 sys.stderr (该参数在 Windows 上无效)。
如果无回显输入不可用，getpass() 回退并向流 stream 中输出一个警告消息，
从 sys.stdin 中读取并抛出异常 GetPassWarning。
适用于： Macintosh, Unix, Windows.

*注：如果你在 IDLE 中调用getpass()，输入可能会在你启动 IDLE 的终端中而不是在 IDLE 窗口中完成

1 >>> import getpass
2 >>> p=getpass.getpass('input your password')
3 input your password
4 >>> print(p)
5 aaa

exception getpass.GetPassWarning
　　Python内置异常 UserWarning 的子类，当密码输入可能被回显时抛出。

getpass.getuser()
　　返回用户的登录名，适用于：Unix, Windows

该函数依次检测环境变量 LOGNAME、USER、LNAME 和 USERNAME，返回其中第一个非空的值。
如果这些变量都没有被设置，支持 pwd 模块的系统会返回密码数据库中的登录名，否则抛出异常。

注，此模块在pycharm中无法使用。

 

os模块，

* os，os模块对通用的操作系统服务提供了可移植的（portable）的接口。os可以认为是nt和posix的抽象。nt提供windows的服务接口，posix提供UNIX（Linux，mac）的服务接口。

* os.path，os.path模块以可移植的方式来处理路径相关的操作。

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.environ  获取系统环境变量
os.path.abspath(path)  返回path规范化的绝对路径
os.path.split(path)  将path分割成目录和文件名二元组返回
os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

 

sys 模块，sys模块包含了跟python解析器和环境相关的变量和函数。

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]

 

subprocess 模块：*  执行系统命令，subprocess模块包含了函数和对象来统一创建新进程，控制新进程的输入输出流，处理进程的返回。

import subprocess

subprocess.call("ping", shell=True) #执行命令，返回状态码
subprocess.check_call("ipconfig", shell=True)#执行命令，如果执行状态码是 0 ，则返回0，否则抛异常
subprocess.check_output("ipconfig", shell=True)#执行命令，如果状态码是 0 ，则返回执行结果，否则抛异常
subprocess.Popen("mkdir t2", shell=True)

 

shutil\shelve\itertools 模块

shutil.make_archive(base_name, format,...)

创建压缩包并返回文件路径，例如：zip、tar

base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，

如：www                        =>保存至当前路径

如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/

format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”

root_dir： 要压缩的文件夹路径（默认当前目录）

owner： 用户，默认当前用户

group： 组，默认当前组

logger： 用于记录日志，通常是logging.Logger对象

 

import logging

from logging import handlers

logger = logging.getLogger(__name__)

log_file = "timelog.log"
#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)

formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')

fh.setFormatter(formatter)

logger.addHandler(fh)

logger.warning("test1")
logger.warning("test12")
logger.warning("test13")
logger.warning("test14")

文件自动截断例子

 

time\datetime\traceback模块

三种表示主式：

1、时间戳 1970年1月1日后的秒

2、元组包含了：年、日、星期等...time.struct_time

3、格式化的字符串 2014-11-11 11:11 print time.time()

 * time，time模块提供了各种时间相关的函数。常用的time.sleep().

import time
# 时间戳形式存在
print (time.time())
print(time.mktime(time.localtime()))  #print (time.localtime())

# 元组形式存在
print (time.gmtime()) #可加时间戳参数
print (time.localtime()) #可加时间戳参数
print (time.strptime('2014-11-11','%Y-%m-%d')) #字符串形式转换成元组形式

# 字符串形式存在
print (time.strftime('%Y-%m-%d'))  #默认当前时间，必须记住，工作中用得最多
print (time.strftime('%Y-%m-%d',time.localtime()))  #默认当前时间
print (time.asctime())
print (time.asctime(time.localtime()))
print (time.ctime(time.time()))

# 时间的三种表示方式演示
import time
print (time.time())  #秒，时间戳的方式,1488459426.7593124
print (time.gmtime())#元组方式，time.struct_time(tm_year=2017, tm_mon=3, tm_mday=2, tm_hour=12, tm_min=57, tm_sec=6, tm_wday=3, tm_yday=61, tm_isdst=0)
print (time.strftime('%Y-%m-%d %H:%M:%S'))#字符串方式，2017-03-02 20:57:06

 

datetime类定义的类属性与方法：

• datetime.min、datetime.max：datetime所能表示的最小值与最大值；
  
• datetime.resolution：datetime最小单位；
  
• datetime.today()：返回一个表示当前本地时间的datetime对象；
  
• datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
  
• datetime.utcnow()：返回一个当前utc时间的datetime对象；
  
• datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息；
  
• datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；
  
• datetime.combine(date, time)：根据date和time，创建一个datetime对象；
  
• datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；

 

from datetime import *
import time

print('datetime.max:', datetime.max)
print('datetime.min:', datetime.min)
print('datetime.resolution:', datetime.resolution)
print('today():', datetime.today())
print('now():', datetime.now())
print('utcnow():', datetime.utcnow())
print('fromtimestamp(tmstmp):', datetime.fromtimestamp(time.time()))
print('utcfromtimestamp(tmstmp):', datetime.utcfromtimestamp(time.time()) )

输出结果：
datetime.max: 9999-12-31 23:59:59.999999
datetime.min: 0001-01-01 00:00:00
datetime.resolution: 0:00:00.000001
today(): 2017-03-02 21:22:09.304740
now(): 2017-03-02 21:22:09.304739
utcnow(): 2017-03-02 13:22:09.304739
fromtimestamp(tmstmp): 2017-03-02 21:22:09.304740
utcfromtimestamp(tmstmp): 2017-03-02 13:22:09.304740

 

 

json\pickle\模块

• json，用于字符串 和 python数据类型间进行转换
• pickle，用于python特有的类型 和 python的数据类型间进行转换

json:
dumps:　　将对象序列化
dump:　　将对象序列化并保存到文件
loads:　　将序列化字符串反序列化
load:　　将序列化字符串从文件读取并反序列化

pickle:基本上和json一样，pickle： pickle模块被用来序列化python的对象到bytes流，从而适合存储到文件，网络传输，或数据库存储。
（pickle的过程也被称serializing,marshalling或者flattening，pickle同时可以用来将bytes流反序列化为python的对象）。

那pickle和json有什么区别呢？
在上面两段代码中，pickle写入和读取文件时，用的是 ‘b’模式，而json没有。
json是可以在不同语言之间交换数据的，而pickle只在python之间使用。
json只能序列化最基本的数据类型，而pickle可以序列化所有的数据类型，包括类，函数都可以序列化。

import json
data = {'k1':123, 'k2':123}
j_dumps = json.dumps(data)
print(j_dumps,type(j_dumps))
j_loads = json.loads(j_dumps)
print(j_loads,type(j_loads))

#打开文件，然后将data写入
with open('data.txt', 'w') as f:
json.dump(data, f)
#同样读取的时候也需要打开文件
with open('data.txt', 'r') as f:
data_1 = json.load(f)
print(type(data_1) )

#######################################

import pickle
data = {'k1':123, 'k2':123}
p_dumps = pickle.dumps(data)
print(p_dumps,type(p_dumps))
p_loads = pickle.loads(p_dumps)
print(p_loads,type(p_loads))

#打开文件，然后将data写入
with open('data.txt', 'wb') as f:
pickle.dump(data, f)
#同样读取的时候也需要打开文件
with open('data.txt', 'rb') as f:
data_1 = pickle.load(f)
print(type(data_1) )

 

re 正则模块

'.'     默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*'     匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a']
'+'     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?'     匹配前一个字符1次或0次
'{m}'   匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c

'\A'    只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z'    匹配字符结尾，同$
'\d'    匹配数字0-9
'\D'    匹配非数字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
's'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'

'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

 最常用的匹配语法

 反斜杠的困扰
与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

仅需轻轻知道的几个匹配模式
re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
S(DOTALL): 点任意匹配模式，改变'.'的行为

 

 

 

 

内置函数

 

 

enumerate：遍历，返回序号和值

seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i,seq[i])
print(i,element)

filter和map函数：

def f1(a):
if a>22:
return True

def f2(a):
if a>22:
return a+100

li = [11,22,33,44,55,66,77]
ret = filter(f1,li) #fliter(函数，可迭代的对象)
print(list(ret))
print(ret)

result = map(f2,li) #fliter(函数，可迭代的对象)
print(list(result))
print(result)

输出结果：
[33, 44, 55, 66, 77]
<filter object at 0x000001BE9C03B198>
[None, None, 133, 144, 155, 166, 177]
<map object at 0x000001BE9C03B278>

#fliter() 将li中的每个值执行函数，将函数返回值为TRUE的添加到列表中
#map() 将li中的每个值执行函数，将函数返回值为TRUE的添加到列表中,返回值为FLASE的用NONE代替

关于计算的:

# abs()　　#求绝对值
abs(11)
# pow()　　#求X方，即幂的次数
pow(3,6)
# round()　　#返回浮点数x的四舍五入值,可以指定返回的小数点位数
round(1.5)
# divmod()　　#求商和余数(地板除)
divmod(5,3)

类型转换：

# int()
print(int(123.1))
# complex()
print(complex(12))
# float()
print(float(55.22))
# bool()
print(bool(0))

输出结果：
123
(12+0j)
55.22
False

进制转换:

bin()#将十进制的数转换成二进制的数

oct()#将十进制的数转换成八进制的数

hex()#将十进制的数转换成十六进制的数

例子：
print(hex(10))
print(oct(10))
print(bin(255))
输出结果：
0xa
0o12
0b11111111

ASCII转换:

ord()#将ascii码转成整数

chr()#将整数转成ascii码

print(ord('A'))
print(chr(65))
输出结果：
65
A

数学函数:

import math

math.sin()

math.tan()

math.cos()

随机数函数：

import random
random.uniform(1,10)#返回1-10间的一个浮点数
random.choice([1,2,3,4,5,6,7,8,9])#返回其中一个数
random.randint(50,60)#　#返回一个整数
random.randrange(10,100,2)#从指定范围内，按指定基数递增的集合中 获取一个随机数。

判断函数:

******

格式函数：

#只有字符串才有这个属性，int没有
s_num = 'aba'
a = s_num.center(10,'*')#AttributeError: 'int' object has no attribute 'center'
b = s_num.ljust(10,'*')#AttributeError: 'int' object has no attribute 'ljust'
print(a,b)

format()　　#这个方法会把字符串当作一个模版，通过传入的参数进行格式化。这个用来格式化的模版使用大括号({,})作为特殊字符

搜素函数:

num = '123as113f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a'
# count()
print(num.count('a'))
# find()
print(num.find('3'))
# index()
print(num.index('u'))
# rfind()
print(num.rfind('a'))

输出结果：
8
2
46
54

替换函数:

基本用法：对象.replace(rgExp,replaceText,max)
其中，rgExp和replaceText是必须要有的，max是可选的参数，可以不加。
rgExp是指正则表达式模式或可用标志的正则表达式对象，也可以是 String 对象或文字；replaceText是一个String 对象或字符串文字；max是一个数字。
对于一个对象，在对象的每个rgExp都替换成replaceText，从左到右最多max次。
num = '123as113f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a'
new_num = num.replace('1','*',3)
print(num)
print(new_num)

输出结果：
123as113f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a
*23as**3f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a
======================================================================================
str.expandtabs(tabsize=8)
参数:tabsize — 指定转换字符串中的 tab 符号(‘\t’)转为空格的字符数。
返回值:该方法返回字符串中的 tab 符号(‘\t’)转为空格后生成的新字符串。
实例
以下实例展示了expandtabs()方法的实例：
#!/usr/bin/python3

str = "this is\tstring example....wow!!!"

print ("原始字符串: " + str)
print ("替换 \\t 符号: " +  str.expandtabs())
print ("使用16个空格替换 \\t 符号: " +  str.expandtabs(16))

输出结果：
原始字符串: this is    string example....wow!!!
替换 \t 符号: this is string example....wow!!!
使用16个空格替换 \t 符号: this is         string example....wow!!!

拆分函数:

str = 'abc.' \
'123.def.456.ghi.789.jkl'
# partition('.')
#根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符，
#则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
print(str.partition('.'))#输出结果：('abc', '.', '123.def.456.ghi.789.jkl')
# split('.')#通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串
print(str.split('.'))#输出结果：['abc', '123', 'def', '456', 'ghi', '789', 'jkl']
# splitlines()#照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
print(str.splitlines())#输出结果：['abc.123.def.456.ghi.789.jkl']
#

# 剥离函数
# strip()#用于移除字符串头尾指定的字符（默认为空格）
# lstrip()#用于截掉字符串左边的空格或指定字符
# rstrip()##用于截掉字符串右边的空格或指定字符
#
str = '*      abc.123.456.dff ' \
'safafsfa156165.saa,14           *'
print(str)
print(str.strip('*'))
print(str.lstrip('*'))
print(str.rstrip('*'))

输出结果：
*      abc.123.456.dff safafsfa156165.saa,14           *
abc.123.456.dff safafsfa156165.saa,14
abc.123.456.dff safafsfa156165.saa,14           *
*      abc.123.456.dff safafsfa156165.saa,14

len()  #3.5中按字符计算，2.7中按字节计算
json()　　#变量里面的字符必须使用双引号